Initial import from the monolithic Qt.

This is the beginning of revision history for this module. If you
want to look at revision history older than this, please refer to the
Qt Git wiki for how to use Git history grafting. At the time of
writing, this wiki is located here:

http://qt.gitorious.org/qt/pages/GitIntroductionWithQt

If you have already performed the grafting and you don't see any
history beyond this commit, try running "git log" with the "--follow"
argument.

Branched from the monolithic repo, Qt master branch, at commit
896db169ea224deb96c59ce8af800d019de63f12

182 files changed, 117113 insertions, 0 deletions

diff --git a/src/gui/painting/makepsheader.pl b/src/gui/painting/makepsheader.pl
new file mode 100755
index 0000000000..8f952720df
--- /dev/null
+++ b/src/gui/painting/makepsheader.pl
@@ -0,0 +1,195 @@
+#!/usr/bin/perl
+#############################################################################
+##
+## Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+## All rights reserved.
+## Contact: Nokia Corporation (qt-info@nokia.com)
+##
+## This file is part of the QtGui module of the Qt Toolkit.
+##
+## $QT_BEGIN_LICENSE:LGPL$
+## No Commercial Usage
+## This file contains pre-release code and may not be distributed.
+## You may use this file in accordance with the terms and conditions
+## contained in the Technology Preview License Agreement accompanying
+## this package.
+##
+## GNU Lesser General Public License Usage
+## Alternatively, this file may be used under the terms of the GNU Lesser
+## General Public License version 2.1 as published by the Free Software
+## Foundation and appearing in the file LICENSE.LGPL included in the
+## packaging of this file.  Please review the following information to
+## ensure the GNU Lesser General Public License version 2.1 requirements
+## 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+##
+## If you have questions regarding the use of this file, please contact
+## Nokia at qt-info@nokia.com.
+##
+##
+##
+##
+##
+##
+##
+##
+## $QT_END_LICENSE$
+##
+#############################################################################
+
+open(INPUT, 'qpsprinter.ps')
+  or die "Can't open qpsprinter.ps";
+
+$dontcompress = 1;
+while(<INPUT>) {
+  $line = $_;
+  chomp $line;
+  if ( /ENDUNCOMPRESS/ ) {
+    $dontcompress = 0;
+  }
+  $line =~ s/%.*$//;
+  $line = $line;
+  if ( $dontcompress eq 1 ) {
+    push(@uncompressed, $line);
+  } else {
+    push(@lines, $line);
+  }
+#  print "$line\n";
+}
+
+$uc = join(" ", @uncompressed);
+$uc =~ s,\t+, ,g;
+$uc=~ s, +, ,g;
+
+$h = join(" ", @lines);
+$h =~ s,\t+, ,g;
+$h =~ s, +, ,g;
+$h = $h.' ';
+
+# now compress as much as possible
+$h =~ s/ bind def / BD /g;
+$h =~ s/ dup dup / d2 /g;
+$h =~ s/ exch def / ED /g;
+$h =~ s/ setfont / F /g;
+$h =~ s/ rlineto / RL /g;
+$h =~ s/ newpath / n /g;
+$h =~ s/ currentmatrix / CM /g;
+$h =~ s/ setmatrix / SM /g;
+$h =~ s/ translate / TR /g;
+$h =~ s/ setdash / SD /g;
+$h =~ s/ aload pop setrgbcolor / SC /g;
+$h =~ s/ currentfile read pop / CR /g;
+$h =~ s/ index / i /g;
+$h =~ s/ bitshift / bs /g;
+$h =~ s/ setcolorspace / scs /g;
+$h =~ s/ dict dup begin / DB /g;
+$h =~ s/ end def / DE /g;
+$h =~ s/ ifelse / ie /g;
+
+# PDF compatible naming
+$h =~ s/ setlinewidth / w /g;
+$h =~ s/ setdash / d /g;
+
+$h =~ s/ lineto / l /g;
+$h =~ s/ moveto / m /g;
+$h =~ s/ curveto / c /g;
+$h =~ s/ closepath / h /g;
+$h =~ s/ clip / W /g;
+$h =~ s/ eoclip / W* /g;
+
+$h =~ s/ gsave / gs /g;
+$h =~ s/ grestore / gr /g;
+
+# add the uncompressed part of the header before
+$h = $uc.' '.$h;
+
+
+
+#print $h;
+
+# wordwrap at col 76
+@head = split(' ', $h);
+$line = shift @head;
+while( @head ) {
+  $token = shift @head;
+  chomp $token;
+#  print "\nl=$l, len=$len, token=$token.";
+  $newline = $line.' '.$token;
+  $newline =~ s, /,/,g;
+  $newline =~ s, \{,\{,g;
+  $newline =~ s, \},\},g;
+  $newline =~ s, \[,\[,g;
+  $newline =~ s, \],\],g;
+  $newline =~ s,\{ ,\{,g;
+  $newline =~ s,\} ,\},g;
+  $newline =~ s,\[ ,\[,g;
+  $newline =~ s,\] ,\],g;
+  if ( length( $newline ) > 76 ) {
+#    print "\nline=$line\n";
+    $header = $header."\n\"".$line."\\n\"";
+    $newline = $token;
+  }
+  $line = $newline;
+}
+$header = $header."\n\"".$line."\\n\"";
+
+
+print "static const char *const ps_header =";
+print $header.";\n\n";
+
+close(INPUT);
+exit;
+
+open(INPUT, 'qpsprinter.agl')
+  or die "Can't open qpsprinter.ps";
+
+print "static const char * const agl =\n";
+
+$str = "\"";
+$string ="";
+$i = 0;
+while(<INPUT>) {
+  $line = $_;
+  chomp $line;
+  $line =~ s/#.*//;
+  if(length($line) ne 0) {
+    $num = $line;
+    $name = $line;
+    $num =~ s/,.*//;
+    $name =~ s/.*, \"//;
+    $name =~ s/\".*//;
+    push(@qchar, $num);
+    push(@index, $i);
+    if(length($str.$name) > 76) {
+      $str = $str."\"\n";
+      $string = $string.$str;
+      $str = "\"";
+    }
+    $str = $str.$name."\\0";
+    $i += length($name)+1;
+  }
+}
+
+print $string.";\n\n";
+
+print "static const struct { quint16 u; quint16 index; } unicodetoglyph[] = {\n    ";
+
+$loop = 0;
+while( @qchar ) {
+  $loop = $loop + 1;
+  $ch = shift @qchar;
+  $i = shift @index;
+  print "{".$ch.", ".$i."}";
+  if($ch ne "0xFFFF") {
+    print ", ";
+  }
+  if(!($loop % 4)) {
+    print "\n    ";
+  }
+};
+
+print "\n};\n\n";
+
diff --git a/src/gui/painting/painting.pri b/src/gui/painting/painting.pri
new file mode 100644
index 0000000000..65e7af4742
--- /dev/null
+++ b/src/gui/painting/painting.pri
@@ -0,0 +1,269 @@
+# Qt gui library, paint module
+
+HEADERS += \
+        painting/qbezier_p.h \
+        painting/qbrush.h \
+        painting/qcolor.h \
+        painting/qcolor_p.h \
+        painting/qcolormap.h \
+        painting/qdrawutil.h \
+        painting/qemulationpaintengine_p.h \
+        painting/qgraphicssystem_p.h \
+        painting/qmatrix.h \
+        painting/qmemrotate_p.h \
+        painting/qoutlinemapper_p.h \
+        painting/qpaintdevice.h \
+        painting/qpaintengine.h \
+		painting/qpaintengine_p.h \
+        painting/qpaintengine_alpha_p.h \
+        painting/qpaintengine_preview_p.h \
+        painting/qpaintengineex_p.h \
+        painting/qpainter.h \
+        painting/qpainter_p.h \
+        painting/qpainterpath.h \
+        painting/qpainterpath_p.h \
+        painting/qvectorpath_p.h \
+        painting/qpathclipper_p.h \
+        painting/qpdf_p.h \
+        painting/qpen.h \
+        painting/qpolygon.h \
+        painting/qpolygonclipper_p.h \
+        painting/qprintengine.h \
+        painting/qprintengine_pdf_p.h \
+        painting/qprintengine_ps_p.h \
+        painting/qprinter.h \
+        painting/qprinter_p.h \
+        painting/qprinterinfo.h \
+        painting/qprinterinfo_p.h \
+        painting/qrasterizer_p.h \
+        painting/qregion.h \
+        painting/qstroker_p.h \
+        painting/qstylepainter.h \
+        painting/qtessellator_p.h \
+        painting/qtextureglyphcache_p.h \
+        painting/qtransform.h \
+        painting/qwindowsurface_p.h \
+        painting/qwmatrix.h \
+        painting/qpaintbuffer_p.h
+
+
+SOURCES += \
+        painting/qbezier.cpp \
+        painting/qblendfunctions.cpp \
+        painting/qbrush.cpp \
+        painting/qcolor.cpp \
+        painting/qcolor_p.cpp \
+        painting/qcssutil.cpp \
+        painting/qdrawutil.cpp \
+        painting/qemulationpaintengine.cpp \
+        painting/qgraphicssystem.cpp \
+        painting/qmatrix.cpp \
+        painting/qmemrotate.cpp \
+        painting/qoutlinemapper.cpp \
+        painting/qpaintdevice.cpp \
+        painting/qpaintengine.cpp \
+        painting/qpaintengine_alpha.cpp \
+        painting/qpaintengine_preview.cpp \
+        painting/qpaintengineex.cpp \
+        painting/qpainter.cpp \
+        painting/qpainterpath.cpp \
+        painting/qpathclipper.cpp \
+        painting/qpdf.cpp \
+        painting/qpen.cpp \
+        painting/qpolygon.cpp \
+        painting/qprintengine_pdf.cpp \
+        painting/qprintengine_ps.cpp \
+        painting/qprinter.cpp \
+        painting/qprinterinfo.cpp \
+        painting/qrasterizer.cpp \
+        painting/qregion.cpp \
+        painting/qstroker.cpp \
+        painting/qstylepainter.cpp \
+        painting/qtessellator.cpp \
+        painting/qtextureglyphcache.cpp \
+        painting/qtransform.cpp \
+        painting/qwindowsurface.cpp \
+        painting/qpaintbuffer.cpp
+
+        SOURCES +=                                      \
+                painting/qpaintengine_raster.cpp        \
+                painting/qdrawhelper.cpp                \
+                painting/qimagescale.cpp                \
+                painting/qgrayraster.c                  \
+                painting/qpaintengine_blitter.cpp       \
+                painting/qblittable.cpp                 \
+
+        HEADERS +=                                      \
+                painting/qpaintengine_raster_p.h        \
+                painting/qdrawhelper_p.h                \
+                painting/qblendfunctions_p.h            \
+                painting/qrasterdefs_p.h                \
+                painting/qgrayraster_p.h                \
+                painting/qpaintengine_blitter_p.h       \
+                painting/qblittable_p.h                 \
+
+win32 {
+        HEADERS += painting/qprintengine_win_p.h
+
+        SOURCES += \
+                painting/qcolormap_win.cpp \
+                painting/qpaintdevice_win.cpp \
+                painting/qprintengine_win.cpp \
+                painting/qprinterinfo_win.cpp
+
+        !win32-borland:!wince*:LIBS += -lmsimg32
+}
+
+embedded {
+    HEADERS += \
+        painting/qgraphicssystem_qws_p.h \
+
+    SOURCES += \
+        painting/qgraphicssystem_qws.cpp \
+
+} else: if(!qpa) {
+    HEADERS += \
+        painting/qgraphicssystem_raster_p.h \
+        painting/qgraphicssystem_runtime_p.h \
+        painting/qgraphicssystemfactory_p.h \
+        painting/qgraphicssystemplugin_p.h \
+        painting/qwindowsurface_raster_p.h
+
+    SOURCES += \
+        painting/qgraphicssystem_raster.cpp \
+        painting/qgraphicssystem_runtime.cpp \
+        painting/qgraphicssystemfactory.cpp \
+        painting/qgraphicssystemplugin.cpp \
+        painting/qwindowsurface_raster.cpp
+}
+
+unix:x11 {
+        HEADERS += \
+                painting/qpaintengine_x11_p.h
+
+        SOURCES += \
+                painting/qcolormap_x11.cpp \
+                painting/qpaintdevice_x11.cpp \
+                painting/qpaintengine_x11.cpp
+}
+
+!embedded:!qpa:!x11:mac {
+        HEADERS += \
+                painting/qpaintengine_mac_p.h \
+                painting/qgraphicssystem_mac_p.h \
+                painting/qprintengine_mac_p.h
+
+        SOURCES += \
+                painting/qcolormap_mac.cpp \
+                painting/qpaintdevice_mac.cpp \
+                painting/qpaintengine_mac.cpp \
+                painting/qgraphicssystem_mac.cpp \
+                painting/qprinterinfo_mac.cpp
+        OBJECTIVE_SOURCES += \
+                painting/qprintengine_mac.mm \
+}
+
+unix:!mac:!symbian|qpa {
+        HEADERS += \
+                painting/qprinterinfo_unix_p.h
+        SOURCES += \
+                painting/qprinterinfo_unix.cpp
+}
+
+win32|x11|mac|embedded|qpa|symbian {
+        SOURCES += painting/qbackingstore.cpp
+        HEADERS += painting/qbackingstore_p.h
+}
+
+embedded {
+        contains(QT_CONFIG,qtopia) {
+                DEFINES += QTOPIA_PRINTENGINE
+                HEADERS += painting/qprintengine_qws_p.h
+                SOURCES += painting/qprintengine_qws.cpp
+        }
+
+        SOURCES += \
+                painting/qcolormap_qws.cpp \
+                painting/qpaintdevice_qws.cpp
+}
+
+qpa {
+        SOURCES += \
+                painting/qcolormap_qpa.cpp \
+                painting/qpaintdevice_qpa.cpp
+}
+
+symbian {
+        SOURCES += \
+				painting/qpaintengine_s60.cpp \
+                painting/qregion_s60.cpp \
+                painting/qcolormap_s60.cpp
+
+        HEADERS += \
+                painting/qpaintengine_s60_p.h
+}
+
+x11|embedded|qpa {
+        contains(QT_CONFIG,qtopia) {
+            DEFINES += QT_NO_CUPS QT_NO_LPR
+        } else {
+            SOURCES += painting/qcups.cpp
+            HEADERS += painting/qcups_p.h
+        }
+} else {
+        DEFINES += QT_NO_CUPS QT_NO_LPR
+}
+
+if(mmx|3dnow|sse|sse2|iwmmxt) {
+    HEADERS += painting/qdrawhelper_x86_p.h \
+               painting/qdrawhelper_mmx_p.h \
+               painting/qdrawhelper_sse_p.h \
+               painting/qdrawingprimitive_sse2_p.h
+    MMX_SOURCES += painting/qdrawhelper_mmx.cpp
+    MMX3DNOW_SOURCES += painting/qdrawhelper_mmx3dnow.cpp
+    SSE3DNOW_SOURCES += painting/qdrawhelper_sse3dnow.cpp
+    SSE_SOURCES += painting/qdrawhelper_sse.cpp
+    SSE2_SOURCES += painting/qdrawhelper_sse2.cpp
+    SSSE3_SOURCES += painting/qdrawhelper_ssse3.cpp
+    IWMMXT_SOURCES += painting/qdrawhelper_iwmmxt.cpp
+}
+
+x11 {
+        HEADERS += painting/qwindowsurface_x11_p.h
+        SOURCES += painting/qwindowsurface_x11.cpp
+}
+
+!embedded:!qpa:mac {
+        HEADERS += painting/qwindowsurface_mac_p.h \
+                   painting/qunifiedtoolbarsurface_mac_p.h
+        SOURCES += painting/qwindowsurface_mac.cpp \
+                   painting/qunifiedtoolbarsurface_mac.cpp
+}
+
+embedded {
+        HEADERS += painting/qwindowsurface_qws_p.h
+        SOURCES += painting/qwindowsurface_qws.cpp
+}
+
+
+
+symbian {
+        HEADERS += painting/qwindowsurface_s60_p.h \
+                    painting/qdrawhelper_arm_simd_p.h
+        SOURCES += painting/qwindowsurface_s60.cpp
+        armccIfdefBlock = \
+        "$${LITERAL_HASH}if defined(ARMV6)" \
+        "MACRO QT_HAVE_ARM_SIMD" \
+        "SOURCEPATH 	painting" \
+        "SOURCE			qdrawhelper_arm_simd.cpp" \
+        "$${LITERAL_HASH}endif"
+
+        MMP_RULES += armccIfdefBlock
+        QMAKE_CXXFLAGS.ARMCC *= -O3
+}
+
+NEON_SOURCES += painting/qdrawhelper_neon.cpp
+NEON_HEADERS += painting/qdrawhelper_neon_p.h
+NEON_ASM += ../3rdparty/pixman/pixman-arm-neon-asm.S painting/qdrawhelper_neon_asm.S
+
+include($$PWD/../../3rdparty/zlib_dependency.pri)
diff --git a/src/gui/painting/qbackingstore.cpp b/src/gui/painting/qbackingstore.cpp
new file mode 100644
index 0000000000..42c1c354b6
--- /dev/null
+++ b/src/gui/painting/qbackingstore.cpp
@@ -0,0 +1,1668 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include "qplatformdefs.h"
+
+#include "qbackingstore_p.h"
+
+#include <QtCore/qglobal.h>
+#include <QtCore/qdebug.h>
+#include <QtCore/qvarlengtharray.h>
+#include <QtGui/qevent.h>
+#include <QtGui/qapplication.h>
+#include <QtGui/qpaintengine.h>
+#include <QtGui/qgraphicsproxywidget.h>
+
+#include <private/qwidget_p.h>
+#include <private/qwindowsurface_raster_p.h>
+#include <private/qapplication_p.h>
+#include <private/qpaintengine_raster_p.h>
+#include <private/qgraphicseffect_p.h>
+
+#include "qgraphicssystem_p.h"
+
+#ifdef Q_WS_QWS
+#include <QtGui/qwsmanager_qws.h>
+#include <private/qwsmanager_p.h>
+#endif
+
+QT_BEGIN_NAMESPACE
+
+extern QRegion qt_dirtyRegion(QWidget *);
+
+/*
+   A version of QRect::intersects() that does not normalize the rects.
+*/
+static inline bool qRectIntersects(const QRect &r1, const QRect &r2)
+{
+    return (qMax(r1.left(), r2.left()) <= qMin(r1.right(), r2.right())
+            && qMax(r1.top(), r2.top()) <= qMin(r1.bottom(), r2.bottom()));
+}
+
+/**
+ * Flushes the contents of the \a windowSurface into the screen area of \a widget.
+ * \a tlwOffset is the position of the top level widget relative to the window surface.
+ * \a region is the region to be updated in \a widget coordinates.
+ */
+static inline void qt_flush(QWidget *widget, const QRegion &region, QWindowSurface *windowSurface,
+                            QWidget *tlw, const QPoint &tlwOffset)
+{
+    Q_ASSERT(widget);
+    Q_ASSERT(!region.isEmpty());
+    Q_ASSERT(windowSurface);
+    Q_ASSERT(tlw);
+
+#if !defined(QT_NO_PAINT_DEBUG) && !defined(Q_WS_QWS)
+    // QWS does flush update in QWindowSurface::flush (because it needs to lock the surface etc).
+    static int flushUpdate = qgetenv("QT_FLUSH_UPDATE").toInt();
+    if (flushUpdate > 0)
+        QWidgetBackingStore::showYellowThing(widget, region, flushUpdate * 10, false);
+#endif
+
+    //The performance hit by doing this should be negligible. However, be aware that
+    //using this FPS when you have > 1 windowsurface can give you inaccurate FPS
+    static bool fpsDebug = qgetenv("QT_DEBUG_FPS").toInt();
+    if (fpsDebug) {
+        static QTime time = QTime::currentTime();
+        static int frames = 0;
+
+        frames++;
+
+        if(time.elapsed() > 5000) {
+            double fps = double(frames * 1000) /time.restart();
+            fprintf(stderr,"FPS: %.1f\n",fps);
+            frames = 0;
+        }
+    }
+    if (widget != tlw)
+        windowSurface->flush(widget, region, tlwOffset + widget->mapTo(tlw, QPoint()));
+    else
+        windowSurface->flush(widget, region, tlwOffset);
+}
+
+#ifndef QT_NO_PAINT_DEBUG
+#ifdef Q_WS_WIN
+static void showYellowThing_win(QWidget *widget, const QRegion &region, int msec)
+{
+    HBRUSH brush;
+    static int i = 0;
+    switch (i) {
+    case 0:
+        brush = CreateSolidBrush(RGB(255, 255, 0));
+        break;
+    case 1:
+        brush = CreateSolidBrush(RGB(255, 200, 55));
+        break;
+    case 2:
+        brush = CreateSolidBrush(RGB(200, 255, 55));
+        break;
+    case 3:
+        brush = CreateSolidBrush(RGB(200, 200, 0));
+        break;
+    }
+    i = (i + 1) & 3;
+
+    HDC hdc = widget->getDC();
+
+    const QVector<QRect> &rects = region.rects();
+    foreach (QRect rect, rects) {
+        RECT winRect;
+        SetRect(&winRect, rect.left(), rect.top(), rect.right(), rect.bottom());
+        FillRect(hdc, &winRect, brush);
+    }
+
+    widget->releaseDC(hdc);
+    ::Sleep(msec);
+}
+#endif
+
+void QWidgetBackingStore::showYellowThing(QWidget *widget, const QRegion &toBePainted, int msec, bool unclipped)
+{
+#ifdef Q_WS_QWS
+    Q_UNUSED(widget);
+    Q_UNUSED(unclipped);
+    static QWSYellowSurface surface(true);
+    surface.setDelay(msec);
+    surface.flush(widget, toBePainted, QPoint());
+#else
+    QRegion paintRegion = toBePainted;
+    QRect widgetRect = widget->rect();
+
+    if (!widget->internalWinId()) {
+        QWidget *nativeParent = widget->nativeParentWidget();
+        const QPoint offset = widget->mapTo(nativeParent, QPoint(0, 0));
+        paintRegion.translate(offset);
+        widgetRect.translate(offset);
+        widget = nativeParent;
+    }
+
+#ifdef Q_WS_WIN
+    Q_UNUSED(unclipped);
+    showYellowThing_win(widget, paintRegion, msec);
+#else
+    //flags to fool painter
+    bool paintUnclipped = widget->testAttribute(Qt::WA_PaintUnclipped);
+    if (unclipped && !widget->d_func()->paintOnScreen())
+        widget->setAttribute(Qt::WA_PaintUnclipped);
+
+    const bool setFlag = !widget->testAttribute(Qt::WA_WState_InPaintEvent);
+    if (setFlag)
+        widget->setAttribute(Qt::WA_WState_InPaintEvent);
+
+    //setup the engine
+    QPaintEngine *pe = widget->paintEngine();
+    if (pe) {
+        pe->setSystemClip(paintRegion);
+        {
+            QPainter p(widget);
+            p.setClipRegion(paintRegion);
+            static int i = 0;
+            switch (i) {
+            case 0:
+                p.fillRect(widgetRect, QColor(255,255,0));
+                break;
+            case 1:
+                p.fillRect(widgetRect, QColor(255,200,55));
+                break;
+            case 2:
+                p.fillRect(widgetRect, QColor(200,255,55));
+                break;
+            case 3:
+                p.fillRect(widgetRect, QColor(200,200,0));
+                break;
+            }
+            i = (i+1) & 3;
+            p.end();
+        }
+    }
+
+    if (setFlag)
+        widget->setAttribute(Qt::WA_WState_InPaintEvent, false);
+
+    //restore
+    widget->setAttribute(Qt::WA_PaintUnclipped, paintUnclipped);
+
+    if (pe)
+        pe->setSystemClip(QRegion());
+
+    QApplication::syncX();
+
+#if defined(Q_OS_UNIX)
+    ::usleep(1000 * msec);
+#endif
+#endif // Q_WS_WIN
+#endif // Q_WS_QWS
+}
+
+bool QWidgetBackingStore::flushPaint(QWidget *widget, const QRegion &rgn)
+{
+    if (!widget)
+        return false;
+
+    int delay = 0;
+    if (widget->testAttribute(Qt::WA_WState_InPaintEvent)) {
+        static int flushPaintEvent = qgetenv("QT_FLUSH_PAINT_EVENT").toInt();
+        if (!flushPaintEvent)
+            return false;
+        delay = flushPaintEvent;
+    } else {
+        static int flushPaint = qgetenv("QT_FLUSH_PAINT").toInt();
+        if (!flushPaint)
+            return false;
+        delay = flushPaint;
+    }
+
+    QWidgetBackingStore::showYellowThing(widget, rgn, delay * 10, true);
+    return true;
+}
+
+void QWidgetBackingStore::unflushPaint(QWidget *widget, const QRegion &rgn)
+{
+    if (widget->d_func()->paintOnScreen() || rgn.isEmpty())
+        return;
+
+    QWidget *tlw = widget->window();
+    QTLWExtra *tlwExtra = tlw->d_func()->maybeTopData();
+    if (!tlwExtra)
+        return;
+
+    const QPoint offset = widget->mapTo(tlw, QPoint());
+    qt_flush(widget, rgn, tlwExtra->backingStore->windowSurface, tlw, offset);
+}
+#endif // QT_NO_PAINT_DEBUG
+
+/*
+    Moves the whole rect by (dx, dy) in widget's coordinate system.
+    Doesn't generate any updates.
+*/
+bool QWidgetBackingStore::bltRect(const QRect &rect, int dx, int dy, QWidget *widget)
+{
+    const QPoint pos(tlwOffset + widget->mapTo(tlw, rect.topLeft()));
+    const QRect tlwRect(QRect(pos, rect.size()));
+    if (fullUpdatePending || dirty.intersects(tlwRect))
+        return false; // We don't want to scroll junk.
+    return windowSurface->scroll(tlwRect, dx, dy);
+}
+
+void QWidgetBackingStore::releaseBuffer()
+{
+    if (windowSurface)
+#if defined(Q_WS_QPA)
+        windowSurface->resize(QSize());
+#else
+        windowSurface->setGeometry(QRect());
+#endif
+#ifdef Q_BACKINGSTORE_SUBSURFACES
+    for (int i = 0; i < subSurfaces.size(); ++i)
+        subSurfaces.at(i)->setGeometry(QRect());
+#endif
+}
+
+/*!
+    Prepares the window surface to paint a\ toClean region of the \a widget and
+    updates the BeginPaintInfo struct accordingly.
+
+    The \a toClean region might be clipped by the window surface.
+*/
+void QWidgetBackingStore::beginPaint(QRegion &toClean, QWidget *widget, QWindowSurface *windowSurface,
+                                     BeginPaintInfo *returnInfo, bool toCleanIsInTopLevelCoordinates)
+{
+#ifdef Q_WS_QWS
+    QWSWindowSurface *surface = static_cast<QWSWindowSurface *>(windowSurface);
+    QWidget *surfaceWidget = surface->window();
+
+    if (!surface->isValid()) {
+        // this looks strange but it really just releases the surface
+        surface->releaseSurface();
+        // the old window surface is deleted in setWindowSurface, which is
+        // called from QWindowSurface constructor.
+        windowSurface = tlw->d_func()->createDefaultWindowSurface();
+        surface = static_cast<QWSWindowSurface *>(windowSurface);
+        // createDefaultWindowSurface() will set topdata->windowSurface on the
+        // widget to zero. However, if this is a sub-surface, it should point
+        // to the widget's sub windowSurface, so we set that here:
+        if (!surfaceWidget->isWindow())
+            surfaceWidget->d_func()->topData()->windowSurface = windowSurface;
+        surface->setGeometry(topLevelRect());
+        returnInfo->windowSurfaceRecreated = true;
+    }
+
+    const QRegion toCleanUnclipped(toClean);
+
+    if (surfaceWidget->isWindow())
+        tlwOffset = surface->painterOffset();
+#ifdef Q_BACKINGSTORE_SUBSURFACES
+    else if (toCleanIsInTopLevelCoordinates)
+        toClean &= surface->clipRegion().translated(surfaceWidget->mapTo(tlw, QPoint()));
+    if (!toCleanIsInTopLevelCoordinates && windowSurface == this->windowSurface)
+        toClean &= surface->clipRegion().translated(-widget->mapTo(surfaceWidget, QPoint()));
+#else
+    toClean &= surface->clipRegion();
+#endif
+
+    if (toClean.isEmpty()) {
+        if (surfaceWidget->isWindow()) {
+            dirtyFromPreviousSync += toCleanUnclipped;
+            hasDirtyFromPreviousSync = true;
+        }
+
+        returnInfo->nothingToPaint = true;
+        // Nothing to repaint. However, we might have newly exposed areas on the
+        // screen, so we have to make sure those are flushed.
+        flush();
+        return;
+    }
+
+    if (surfaceWidget->isWindow()) {
+        if (toCleanUnclipped != toClean) {
+            dirtyFromPreviousSync += (toCleanUnclipped - surface->clipRegion());
+            hasDirtyFromPreviousSync = true;
+        }
+        if (hasDirtyFromPreviousSync) {
+            dirtyFromPreviousSync -= toClean;
+            hasDirtyFromPreviousSync = !dirtyFromPreviousSync.isEmpty();
+        }
+    }
+
+#endif // Q_WS_QWS
+
+    Q_UNUSED(widget);
+    Q_UNUSED(toCleanIsInTopLevelCoordinates);
+
+    // Always flush repainted areas.
+    dirtyOnScreen += toClean;
+
+#if defined(Q_WS_QWS) && !defined(Q_BACKINGSTORE_SUBSURFACES)
+    toClean.translate(tlwOffset);
+#endif
+
+#ifdef QT_NO_PAINT_DEBUG
+    windowSurface->beginPaint(toClean);
+#else
+    returnInfo->wasFlushed = QWidgetBackingStore::flushPaint(tlw, toClean);
+    // Avoid deadlock with QT_FLUSH_PAINT: the server will wait for
+    // the BackingStore lock, so if we hold that, the server will
+    // never release the Communication lock that we are waiting for in
+    // sendSynchronousCommand
+    if (!returnInfo->wasFlushed)
+        windowSurface->beginPaint(toClean);
+#endif
+
+    Q_UNUSED(returnInfo);
+}
+
+void QWidgetBackingStore::endPaint(const QRegion &cleaned, QWindowSurface *windowSurface,
+        BeginPaintInfo *beginPaintInfo)
+{
+#ifndef QT_NO_PAINT_DEBUG
+    if (!beginPaintInfo->wasFlushed)
+        windowSurface->endPaint(cleaned);
+    else
+        QWidgetBackingStore::unflushPaint(tlw, cleaned);
+#else
+    Q_UNUSED(beginPaintInfo);
+    windowSurface->endPaint(cleaned);
+#endif
+
+#ifdef Q_BACKINGSTORE_SUBSURFACES
+    flush(static_cast<QWSWindowSurface *>(windowSurface)->window(), windowSurface);
+#else
+    flush();
+#endif
+}
+
+/*!
+    Returns the region (in top-level coordinates) that needs repaint and/or flush.
+
+    If the widget is non-zero, only the dirty region for the widget is returned
+    and the region will be in widget coordinates.
+*/
+QRegion QWidgetBackingStore::dirtyRegion(QWidget *widget) const
+{
+    const bool widgetDirty = widget && widget != tlw;
+    const QRect tlwRect(topLevelRect());
+#if defined(Q_WS_QPA)
+    const QRect surfaceGeometry(tlwRect.topLeft(), windowSurface->size());
+#else
+    const QRect surfaceGeometry(windowSurface->geometry());
+#endif
+    if (fullUpdatePending || (surfaceGeometry != tlwRect && surfaceGeometry.size() != tlwRect.size())) {
+        if (widgetDirty) {
+            const QRect dirtyTlwRect = QRect(QPoint(), tlwRect.size());
+            const QPoint offset(widget->mapTo(tlw, QPoint()));
+            const QRect dirtyWidgetRect(dirtyTlwRect & widget->rect().translated(offset));
+            return dirtyWidgetRect.translated(-offset);
+        }
+        return QRect(QPoint(), tlwRect.size());
+    }
+
+    // Calculate the region that needs repaint.
+    QRegion r(dirty);
+    for (int i = 0; i < dirtyWidgets.size(); ++i) {
+        QWidget *w = dirtyWidgets.at(i);
+        if (widgetDirty && w != widget && !widget->isAncestorOf(w))
+            continue;
+        r += w->d_func()->dirty.translated(w->mapTo(tlw, QPoint()));
+    }
+
+    // Append the region that needs flush.
+    r += dirtyOnScreen;
+
+    if (dirtyOnScreenWidgets) { // Only in use with native child widgets.
+        for (int i = 0; i < dirtyOnScreenWidgets->size(); ++i) {
+            QWidget *w = dirtyOnScreenWidgets->at(i);
+            if (widgetDirty && w != widget && !widget->isAncestorOf(w))
+                continue;
+            QWidgetPrivate *wd = w->d_func();
+            Q_ASSERT(wd->needsFlush);
+            r += wd->needsFlush->translated(w->mapTo(tlw, QPoint()));
+        }
+    }
+
+    if (widgetDirty) {
+        // Intersect with the widget geometry and translate to its coordinates.
+        const QPoint offset(widget->mapTo(tlw, QPoint()));
+        r &= widget->rect().translated(offset);
+        r.translate(-offset);
+    }
+    return r;
+}
+
+/*!
+    Returns the static content inside the \a parent if non-zero; otherwise the static content
+    for the entire backing store is returned. The content will be clipped to \a withinClipRect
+    if non-empty.
+*/
+QRegion QWidgetBackingStore::staticContents(QWidget *parent, const QRect &withinClipRect) const
+{
+    if (!parent && tlw->testAttribute(Qt::WA_StaticContents)) {
+#if defined(Q_WS_QPA)
+        const QSize surfaceGeometry(windowSurface->size());
+#else
+        const QRect surfaceGeometry(windowSurface->geometry());
+#endif
+        QRect surfaceRect(0, 0, surfaceGeometry.width(), surfaceGeometry.height());
+        if (!withinClipRect.isEmpty())
+            surfaceRect &= withinClipRect;
+        return QRegion(surfaceRect);
+    }
+
+    QRegion region;
+    if (parent && parent->d_func()->children.isEmpty())
+        return region;
+
+    const bool clipToRect = !withinClipRect.isEmpty();
+    const int count = staticWidgets.count();
+    for (int i = 0; i < count; ++i) {
+        QWidget *w = staticWidgets.at(i);
+        QWidgetPrivate *wd = w->d_func();
+        if (!wd->isOpaque || !wd->extra || wd->extra->staticContentsSize.isEmpty()
+            || !w->isVisible() || (parent && !parent->isAncestorOf(w))) {
+            continue;
+        }
+
+        QRect rect(0, 0, wd->extra->staticContentsSize.width(), wd->extra->staticContentsSize.height());
+        const QPoint offset = w->mapTo(parent ? parent : tlw, QPoint());
+        if (clipToRect)
+            rect &= withinClipRect.translated(-offset);
+        if (rect.isEmpty())
+            continue;
+
+        rect &= wd->clipRect();
+        if (rect.isEmpty())
+            continue;
+
+        QRegion visible(rect);
+        wd->clipToEffectiveMask(visible);
+        if (visible.isEmpty())
+            continue;
+        wd->subtractOpaqueSiblings(visible, 0, /*alsoNonOpaque=*/true);
+
+        visible.translate(offset);
+        region += visible;
+    }
+
+    return region;
+}
+
+static inline void sendUpdateRequest(QWidget *widget, bool updateImmediately)
+{
+    if (!widget)
+        return;
+
+    if (updateImmediately) {
+        QEvent event(QEvent::UpdateRequest);
+        QApplication::sendEvent(widget, &event);
+    } else {
+        QApplication::postEvent(widget, new QEvent(QEvent::UpdateRequest), Qt::LowEventPriority);
+    }
+}
+
+/*!
+    Marks the region of the widget as dirty (if not already marked as dirty) and
+    posts an UpdateRequest event to the top-level widget (if not already posted).
+
+    If updateImmediately is true, the event is sent immediately instead of posted.
+
+    If invalidateBuffer is true, all widgets intersecting with the region will be dirty.
+
+    If the widget paints directly on screen, the event is sent to the widget
+    instead of the top-level widget, and invalidateBuffer is completely ignored.
+
+    ### Qt 4.6: Merge into a template function (after MSVC isn't supported anymore).
+*/
+void QWidgetBackingStore::markDirty(const QRegion &rgn, QWidget *widget, bool updateImmediately,
+                                    bool invalidateBuffer)
+{
+    Q_ASSERT(tlw->d_func()->extra);
+    Q_ASSERT(tlw->d_func()->extra->topextra);
+    Q_ASSERT(!tlw->d_func()->extra->topextra->inTopLevelResize);
+    Q_ASSERT(widget->isVisible() && widget->updatesEnabled());
+    Q_ASSERT(widget->window() == tlw);
+    Q_ASSERT(!rgn.isEmpty());
+
+#ifndef QT_NO_GRAPHICSEFFECT
+    widget->d_func()->invalidateGraphicsEffectsRecursively();
+#endif //QT_NO_GRAPHICSEFFECT
+
+    if (widget->d_func()->paintOnScreen()) {
+        if (widget->d_func()->dirty.isEmpty()) {
+            widget->d_func()->dirty = rgn;
+            sendUpdateRequest(widget, updateImmediately);
+            return;
+        } else if (qt_region_strictContains(widget->d_func()->dirty, widget->rect())) {
+            if (updateImmediately)
+                sendUpdateRequest(widget, updateImmediately);
+            return; // Already dirty.
+        }
+
+        const bool eventAlreadyPosted = !widget->d_func()->dirty.isEmpty();
+        widget->d_func()->dirty += rgn;
+        if (!eventAlreadyPosted || updateImmediately)
+            sendUpdateRequest(widget, updateImmediately);
+        return;
+    }
+
+    if (fullUpdatePending) {
+        if (updateImmediately)
+            sendUpdateRequest(tlw, updateImmediately);
+        return;
+    }
+
+    if (!windowSurface->hasFeature(QWindowSurface::PartialUpdates)) {
+        fullUpdatePending = true;
+        sendUpdateRequest(tlw, updateImmediately);
+        return;
+    }
+
+    const QPoint offset = widget->mapTo(tlw, QPoint());
+    const QRect widgetRect = widget->d_func()->effectiveRectFor(widget->rect());
+    if (qt_region_strictContains(dirty, widgetRect.translated(offset))) {
+        if (updateImmediately)
+            sendUpdateRequest(tlw, updateImmediately);
+        return; // Already dirty.
+    }
+
+    if (invalidateBuffer) {
+        const bool eventAlreadyPosted = !dirty.isEmpty();
+#ifndef QT_NO_GRAPHICSEFFECT
+        if (widget->d_func()->graphicsEffect)
+            dirty += widget->d_func()->effectiveRectFor(rgn.boundingRect()).translated(offset);
+        else
+#endif //QT_NO_GRAPHICSEFFECT
+            dirty += rgn.translated(offset);
+        if (!eventAlreadyPosted || updateImmediately)
+            sendUpdateRequest(tlw, updateImmediately);
+        return;
+    }
+
+    if (dirtyWidgets.isEmpty()) {
+        addDirtyWidget(widget, rgn);
+        sendUpdateRequest(tlw, updateImmediately);
+        return;
+    }
+
+    if (widget->d_func()->inDirtyList) {
+        if (!qt_region_strictContains(widget->d_func()->dirty, widgetRect)) {
+#ifndef QT_NO_GRAPHICSEFFECT
+            if (widget->d_func()->graphicsEffect)
+                widget->d_func()->dirty += widget->d_func()->effectiveRectFor(rgn.boundingRect());
+            else
+#endif //QT_NO_GRAPHICSEFFECT
+                widget->d_func()->dirty += rgn;
+        }
+    } else {
+        addDirtyWidget(widget, rgn);
+    }
+
+    if (updateImmediately)
+        sendUpdateRequest(tlw, updateImmediately);
+}
+
+/*!
+    This function is equivalent to calling markDirty(QRegion(rect), ...), but
+    is more efficient as it eliminates QRegion operations/allocations and can
+    use the rect more precisely for additional cut-offs.
+
+    ### Qt 4.6: Merge into a template function (after MSVC isn't supported anymore).
+*/
+void QWidgetBackingStore::markDirty(const QRect &rect, QWidget *widget, bool updateImmediately,
+                                    bool invalidateBuffer)
+{
+    Q_ASSERT(tlw->d_func()->extra);
+    Q_ASSERT(tlw->d_func()->extra->topextra);
+    Q_ASSERT(!tlw->d_func()->extra->topextra->inTopLevelResize);
+    Q_ASSERT(widget->isVisible() && widget->updatesEnabled());
+    Q_ASSERT(widget->window() == tlw);
+    Q_ASSERT(!rect.isEmpty());
+
+#ifndef QT_NO_GRAPHICSEFFECT
+    widget->d_func()->invalidateGraphicsEffectsRecursively();
+#endif //QT_NO_GRAPHICSEFFECT
+
+    if (widget->d_func()->paintOnScreen()) {
+        if (widget->d_func()->dirty.isEmpty()) {
+            widget->d_func()->dirty = QRegion(rect);
+            sendUpdateRequest(widget, updateImmediately);
+            return;
+        } else if (qt_region_strictContains(widget->d_func()->dirty, rect)) {
+            if (updateImmediately)
+                sendUpdateRequest(widget, updateImmediately);
+            return; // Already dirty.
+        }
+
+        const bool eventAlreadyPosted = !widget->d_func()->dirty.isEmpty();
+        widget->d_func()->dirty += rect;
+        if (!eventAlreadyPosted || updateImmediately)
+            sendUpdateRequest(widget, updateImmediately);
+        return;
+    }
+
+    if (fullUpdatePending) {
+        if (updateImmediately)
+            sendUpdateRequest(tlw, updateImmediately);
+        return;
+    }
+
+    if (!windowSurface->hasFeature(QWindowSurface::PartialUpdates)) {
+        fullUpdatePending = true;
+        sendUpdateRequest(tlw, updateImmediately);
+        return;
+    }
+
+    const QRect widgetRect = widget->d_func()->effectiveRectFor(rect);
+    const QRect translatedRect(widgetRect.translated(widget->mapTo(tlw, QPoint())));
+    if (qt_region_strictContains(dirty, translatedRect)) {
+        if (updateImmediately)
+            sendUpdateRequest(tlw, updateImmediately);
+        return; // Already dirty
+    }
+
+    if (invalidateBuffer) {
+        const bool eventAlreadyPosted = !dirty.isEmpty();
+        dirty += translatedRect;
+        if (!eventAlreadyPosted || updateImmediately)
+            sendUpdateRequest(tlw, updateImmediately);
+        return;
+    }
+
+    if (dirtyWidgets.isEmpty()) {
+        addDirtyWidget(widget, rect);
+        sendUpdateRequest(tlw, updateImmediately);
+        return;
+    }
+
+    if (widget->d_func()->inDirtyList) {
+        if (!qt_region_strictContains(widget->d_func()->dirty, widgetRect))
+            widget->d_func()->dirty += widgetRect;
+    } else {
+        addDirtyWidget(widget, rect);
+    }
+
+    if (updateImmediately)
+        sendUpdateRequest(tlw, updateImmediately);
+}
+
+/*!
+    Marks the \a region of the \a widget as dirty on screen. The \a region will be copied from
+    the backing store to the \a widget's native parent next time flush() is called.
+
+    Paint on screen widgets are ignored.
+*/
+void QWidgetBackingStore::markDirtyOnScreen(const QRegion &region, QWidget *widget, const QPoint &topLevelOffset)
+{
+    if (!widget || widget->d_func()->paintOnScreen() || region.isEmpty())
+        return;
+
+#if defined(Q_WS_QWS) || defined(Q_WS_MAC)
+    if (!widget->testAttribute(Qt::WA_WState_InPaintEvent))
+        dirtyOnScreen += region.translated(topLevelOffset);
+    return;
+#endif
+
+    // Top-level.
+    if (widget == tlw) {
+        if (!widget->testAttribute(Qt::WA_WState_InPaintEvent))
+            dirtyOnScreen += region;
+        return;
+    }
+
+    // Alien widgets.
+    if (!widget->internalWinId() && !widget->isWindow()) {
+        QWidget *nativeParent = widget->nativeParentWidget();        // Alien widgets with the top-level as the native parent (common case).
+        if (nativeParent == tlw) {
+            if (!widget->testAttribute(Qt::WA_WState_InPaintEvent))
+                dirtyOnScreen += region.translated(topLevelOffset);
+            return;
+        }
+
+        // Alien widgets with native parent != tlw.
+        QWidgetPrivate *nativeParentPrivate = nativeParent->d_func();
+        if (!nativeParentPrivate->needsFlush)
+            nativeParentPrivate->needsFlush = new QRegion;
+        const QPoint nativeParentOffset = widget->mapTo(nativeParent, QPoint());
+        *nativeParentPrivate->needsFlush += region.translated(nativeParentOffset);
+        appendDirtyOnScreenWidget(nativeParent);
+        return;
+    }
+
+    // Native child widgets.
+    QWidgetPrivate *widgetPrivate = widget->d_func();
+    if (!widgetPrivate->needsFlush)
+        widgetPrivate->needsFlush = new QRegion;
+    *widgetPrivate->needsFlush += region;
+    appendDirtyOnScreenWidget(widget);
+}
+
+void QWidgetBackingStore::removeDirtyWidget(QWidget *w)
+{
+    if (!w)
+        return;
+
+    dirtyWidgetsRemoveAll(w);
+    dirtyOnScreenWidgetsRemoveAll(w);
+    resetWidget(w);
+
+    QWidgetPrivate *wd = w->d_func();
+    const int n = wd->children.count();
+    for (int i = 0; i < n; ++i) {
+        if (QWidget *child = qobject_cast<QWidget*>(wd->children.at(i)))
+            removeDirtyWidget(child);
+    }
+}
+
+#if defined(Q_WS_QWS) && !defined(QT_NO_QWS_MANAGER)
+bool QWidgetBackingStore::hasDirtyWindowDecoration() const
+{
+    QTLWExtra *tlwExtra = tlw->d_func()->maybeTopData();
+    if (tlwExtra && tlwExtra->qwsManager)
+        return !tlwExtra->qwsManager->d_func()->dirtyRegions.isEmpty();
+    return false;
+}
+
+void QWidgetBackingStore::paintWindowDecoration()
+{
+    if (!hasDirtyWindowDecoration())
+        return;
+
+    QDecoration &decoration = QApplication::qwsDecoration();
+    const QRect decorationRect = tlw->rect();
+    QRegion decorationRegion = decoration.region(tlw, decorationRect);
+
+    QWSManagerPrivate *managerPrivate = tlw->d_func()->topData()->qwsManager->d_func();
+    const bool doClipping = !managerPrivate->entireDecorationNeedsRepaint
+                            && !managerPrivate->dirtyClip.isEmpty();
+
+    if (doClipping) {
+        decorationRegion &= static_cast<QWSWindowSurface *>(windowSurface)->clipRegion();
+        decorationRegion &= managerPrivate->dirtyClip;
+    }
+
+    if (decorationRegion.isEmpty())
+        return;
+
+    //### The QWS decorations do not always paint the pixels they promise to paint.
+    // This causes painting problems with QWSMemorySurface. Since none of the other
+    // window surfaces actually use the region, passing an empty region is a safe
+    // workaround.
+
+    windowSurface->beginPaint(QRegion());
+
+    QPaintEngine *engine = windowSurface->paintDevice()->paintEngine();
+    Q_ASSERT(engine);
+    const QRegion oldSystemClip(engine->systemClip());
+    engine->setSystemClip(decorationRegion.translated(tlwOffset));
+
+    QPainter painter(windowSurface->paintDevice());
+    painter.setFont(QApplication::font());
+    painter.translate(tlwOffset);
+
+    const int numDirty = managerPrivate->dirtyRegions.size();
+    for (int i = 0; i < numDirty; ++i) {
+        const int area = managerPrivate->dirtyRegions.at(i);
+
+        QRegion clipRegion = decoration.region(tlw, decorationRect, area);
+        if (!clipRegion.isEmpty()) {
+            // Decoration styles changes the clip and assumes the old clip is non-empty,
+            // so we have to set it, but in theory it shouldn't be required.
+            painter.setClipRegion(clipRegion);
+            decoration.paint(&painter, tlw, area, managerPrivate->dirtyStates.at(i));
+        }
+    }
+    markDirtyOnScreen(decorationRegion, tlw, QPoint());
+
+    painter.end();
+    windowSurface->endPaint(decorationRegion);
+    managerPrivate->clearDirtyRegions();
+    engine->setSystemClip(oldSystemClip);
+}
+#endif
+
+void QWidgetBackingStore::updateLists(QWidget *cur)
+{
+    if (!cur)
+        return;
+
+    QList<QObject*> children = cur->children();
+    for (int i = 0; i < children.size(); ++i) {
+        QWidget *child = qobject_cast<QWidget*>(children.at(i));
+        if (!child)
+            continue;
+
+        updateLists(child);
+    }
+
+    if (cur->testAttribute(Qt::WA_StaticContents))
+        addStaticWidget(cur);
+
+#ifdef Q_BACKINGSTORE_SUBSURFACES
+    QTLWExtra *extra = cur->d_func()->maybeTopData();
+    if (extra && extra->windowSurface && cur != tlw)
+        subSurfaces.append(extra->windowSurface);
+#endif
+}
+
+QWidgetBackingStore::QWidgetBackingStore(QWidget *topLevel)
+    : tlw(topLevel), dirtyOnScreenWidgets(0), hasDirtyFromPreviousSync(false)
+    , fullUpdatePending(0)
+{
+    windowSurface = tlw->windowSurface();
+    if (!windowSurface)
+        windowSurface = topLevel->d_func()->createDefaultWindowSurface();
+
+    // The QWindowSurface constructor will call QWidget::setWindowSurface(),
+    // but automatically created surfaces should not be added to the topdata.
+#ifdef Q_BACKINGSTORE_SUBSURFACES
+    Q_ASSERT(topLevel->d_func()->topData()->windowSurface == windowSurface);
+#endif
+    topLevel->d_func()->topData()->windowSurface = 0;
+
+    // Ensure all existing subsurfaces and static widgets are added to their respective lists.
+    updateLists(topLevel);
+}
+
+QWidgetBackingStore::~QWidgetBackingStore()
+{
+    for (int c = 0; c < dirtyWidgets.size(); ++c) {
+        resetWidget(dirtyWidgets.at(c));
+    }
+
+    delete windowSurface;
+    windowSurface = 0;
+    delete dirtyOnScreenWidgets;
+    dirtyOnScreenWidgets = 0;
+}
+
+//parent's coordinates; move whole rect; update parent and widget
+//assume the screen blt has already been done, so we don't need to refresh that part
+void QWidgetPrivate::moveRect(const QRect &rect, int dx, int dy)
+{
+    Q_Q(QWidget);
+    if (!q->isVisible() || (dx == 0 && dy == 0))
+        return;
+
+    QWidget *tlw = q->window();
+    QTLWExtra* x = tlw->d_func()->topData();
+    if (x->inTopLevelResize)
+        return;
+
+    static int accelEnv = -1;
+    if (accelEnv == -1) {
+        accelEnv = qgetenv("QT_NO_FAST_MOVE").toInt() == 0;
+    }
+
+    QWidget *pw = q->parentWidget();
+    QPoint toplevelOffset = pw->mapTo(tlw, QPoint());
+    QWidgetPrivate *pd = pw->d_func();
+    QRect clipR(pd->clipRect());
+#ifdef Q_WS_QWS
+    QWidgetBackingStore *wbs = x->backingStore.data();
+    QWSWindowSurface *surface = static_cast<QWSWindowSurface*>(wbs->windowSurface);
+    clipR = clipR.intersected(surface->clipRegion().translated(-toplevelOffset).boundingRect());
+#endif
+    const QRect newRect(rect.translated(dx, dy));
+    QRect destRect = rect.intersected(clipR);
+    if (destRect.isValid())
+        destRect = destRect.translated(dx, dy).intersected(clipR);
+    const QRect sourceRect(destRect.translated(-dx, -dy));
+    const QRect parentRect(rect & clipR);
+
+    bool accelerateMove = accelEnv && isOpaque
+#ifndef QT_NO_GRAPHICSVIEW
+                          // No accelerate move for proxy widgets.
+                          && !tlw->d_func()->extra->proxyWidget
+#endif
+                          && !isOverlapped(sourceRect) && !isOverlapped(destRect);
+
+    if (!accelerateMove) {
+        QRegion parentR(effectiveRectFor(parentRect));
+        if (!extra || !extra->hasMask) {
+            parentR -= newRect;
+        } else {
+            // invalidateBuffer() excludes anything outside the mask
+            parentR += newRect & clipR;
+        }
+        pd->invalidateBuffer(parentR);
+        invalidateBuffer((newRect & clipR).translated(-data.crect.topLeft()));
+    } else {
+
+        QWidgetBackingStore *wbs = x->backingStore.data();
+        QRegion childExpose(newRect & clipR);
+
+        if (sourceRect.isValid() && wbs->bltRect(sourceRect, dx, dy, pw))
+            childExpose -= destRect;
+
+        if (!pw->updatesEnabled())
+            return;
+
+        const bool childUpdatesEnabled = q->updatesEnabled();
+        if (childUpdatesEnabled && !childExpose.isEmpty()) {
+            childExpose.translate(-data.crect.topLeft());
+            wbs->markDirty(childExpose, q);
+            isMoved = true;
+        }
+
+        QRegion parentExpose(parentRect);
+        parentExpose -= newRect;
+        if (extra && extra->hasMask)
+            parentExpose += QRegion(newRect) - extra->mask.translated(data.crect.topLeft());
+
+        if (!parentExpose.isEmpty()) {
+            wbs->markDirty(parentExpose, pw);
+            pd->isMoved = true;
+        }
+
+        if (childUpdatesEnabled) {
+            QRegion needsFlush(sourceRect);
+            needsFlush += destRect;
+            wbs->markDirtyOnScreen(needsFlush, pw, toplevelOffset);
+        }
+    }
+}
+
+//widget's coordinates; scroll within rect;  only update widget
+void QWidgetPrivate::scrollRect(const QRect &rect, int dx, int dy)
+{
+    Q_Q(QWidget);
+    QWidget *tlw = q->window();
+    QTLWExtra* x = tlw->d_func()->topData();
+    if (x->inTopLevelResize)
+        return;
+
+    QWidgetBackingStore *wbs = x->backingStore.data();
+    if (!wbs)
+        return;
+
+    static int accelEnv = -1;
+    if (accelEnv == -1) {
+        accelEnv = qgetenv("QT_NO_FAST_SCROLL").toInt() == 0;
+    }
+
+    QRect scrollRect = rect & clipRect();
+    bool overlapped = false;
+    bool accelerateScroll = accelEnv && isOpaque
+                            && !(overlapped = isOverlapped(scrollRect.translated(data.crect.topLeft())));
+
+#if defined(Q_WS_QWS)
+    QWSWindowSurface *surface;
+    surface = static_cast<QWSWindowSurface*>(wbs->windowSurface);
+
+    if (accelerateScroll && !surface->isBuffered()) {
+        const QRegion surfaceClip = surface->clipRegion();
+        const QRegion outsideClip = QRegion(rect) - surfaceClip;
+        if (!outsideClip.isEmpty()) {
+            const QVector<QRect> clipped = (surfaceClip & rect).rects();
+            if (clipped.size() < 8) {
+                for (int i = 0; i < clipped.size(); ++i)
+                    this->scrollRect(clipped.at(i), dx, dy);
+                return;
+            } else {
+                accelerateScroll = false;
+            }
+        }
+    }
+#endif // Q_WS_QWS
+
+    if (!accelerateScroll) {
+        if (overlapped) {
+            QRegion region(scrollRect);
+            subtractOpaqueSiblings(region);
+            invalidateBuffer(region);
+        }else {
+            invalidateBuffer(scrollRect);
+        }
+    } else {
+        const QPoint toplevelOffset = q->mapTo(tlw, QPoint());
+#ifdef Q_WS_QWS
+        QWSWindowSurface *surface = static_cast<QWSWindowSurface*>(wbs->windowSurface);
+        const QRegion clip = surface->clipRegion().translated(-toplevelOffset) & scrollRect;
+        const QRect clipBoundingRect = clip.boundingRect();
+        scrollRect &= clipBoundingRect;
+#endif
+        const QRect destRect = scrollRect.translated(dx, dy) & scrollRect;
+        const QRect sourceRect = destRect.translated(-dx, -dy);
+
+        QRegion childExpose(scrollRect);
+        if (sourceRect.isValid()) {
+            if (wbs->bltRect(sourceRect, dx, dy, q))
+                childExpose -= destRect;
+        }
+
+        if (inDirtyList) {
+            if (rect == q->rect()) {
+                dirty.translate(dx, dy);
+            } else {
+                QRegion dirtyScrollRegion = dirty.intersected(scrollRect);
+                if (!dirtyScrollRegion.isEmpty()) {
+                    dirty -= dirtyScrollRegion;
+                    dirtyScrollRegion.translate(dx, dy);
+                    dirty += dirtyScrollRegion;
+                }
+            }
+        }
+
+        if (!q->updatesEnabled())
+            return;
+
+        if (!childExpose.isEmpty()) {
+            wbs->markDirty(childExpose, q);
+            isScrolled = true;
+        }
+
+        // Instead of using native scroll-on-screen, we copy from
+        // backingstore, giving only one screen update for each
+        // scroll, and a solid appearance
+        wbs->markDirtyOnScreen(destRect, q, toplevelOffset);
+    }
+}
+
+static inline bool discardSyncRequest(QWidget *tlw, QTLWExtra *tlwExtra)
+{
+    if (!tlw || !tlwExtra)
+        return true;
+
+#ifdef Q_WS_X11
+    // Delay the sync until we get an Expose event from X11 (initial show).
+    // Qt::WA_Mapped is set to true, but the actual mapping has not yet occurred.
+    // However, we must repaint immediately regardless of the state if someone calls repaint().
+    if (tlwExtra->waitingForMapNotify && !tlwExtra->inRepaint)
+        return true;
+#endif
+
+    if (!tlw->testAttribute(Qt::WA_Mapped))
+        return true;
+
+    if (!tlw->isVisible()
+#ifndef Q_WS_X11
+        // If we're minimized on X11, WA_Mapped will be false and we
+        // will return in the case above. Some window managers on X11
+        // sends us the PropertyNotify to change the minimized state
+        // *AFTER* we've received the expose event, which is baaad.
+        || tlw->isMinimized()
+#endif
+        )
+        return true;
+
+    return false;
+}
+
+/*!
+    Synchronizes the \a exposedRegion of the \a exposedWidget with the backing store.
+
+    If there's nothing to repaint, the area is flushed and painting does not occur;
+    otherwise the area is marked as dirty on screen and will be flushed right after
+    we are done with all painting.
+*/
+void QWidgetBackingStore::sync(QWidget *exposedWidget, const QRegion &exposedRegion)
+{
+    QTLWExtra *tlwExtra = tlw->d_func()->maybeTopData();
+    if (discardSyncRequest(tlw, tlwExtra) || tlwExtra->inTopLevelResize)
+        return;
+
+    if (!exposedWidget || !exposedWidget->internalWinId() || !exposedWidget->isVisible()
+        || !exposedWidget->updatesEnabled() || exposedRegion.isEmpty()) {
+        return;
+    }
+
+    // If there's no preserved contents support we always need
+    // to do a full repaint before flushing
+    if (!windowSurface->hasFeature(QWindowSurface::PreservedContents))
+        fullUpdatePending = true;
+
+    // Nothing to repaint.
+    if (!isDirty()) {
+        qt_flush(exposedWidget, exposedRegion, windowSurface, tlw, tlwOffset);
+        return;
+    }
+
+    if (exposedWidget != tlw)
+        markDirtyOnScreen(exposedRegion, exposedWidget, exposedWidget->mapTo(tlw, QPoint()));
+    else
+        markDirtyOnScreen(exposedRegion, exposedWidget, QPoint());
+    sync();
+}
+
+/*!
+    Synchronizes the backing store, i.e. dirty areas are repainted and flushed.
+*/
+void QWidgetBackingStore::sync()
+{
+    QTLWExtra *tlwExtra = tlw->d_func()->maybeTopData();
+    if (discardSyncRequest(tlw, tlwExtra)) {
+        // If the top-level is minimized, it's not visible on the screen so we can delay the
+        // update until it's shown again. In order to do that we must keep the dirty states.
+        // These will be cleared when we receive the first expose after showNormal().
+        // However, if the widget is not visible (isVisible() returns false), everything will
+        // be invalidated once the widget is shown again, so clear all dirty states.
+        if (!tlw->isVisible()) {
+            dirty = QRegion();
+            for (int i = 0; i < dirtyWidgets.size(); ++i)
+                resetWidget(dirtyWidgets.at(i));
+            dirtyWidgets.clear();
+            fullUpdatePending = false;
+        }
+        return;
+    }
+
+    const bool updatesDisabled = !tlw->updatesEnabled();
+    bool repaintAllWidgets = false;
+
+    const bool inTopLevelResize = tlwExtra->inTopLevelResize;
+    const QRect tlwRect(topLevelRect());
+#ifdef  Q_WS_QPA
+    const QRect surfaceGeometry(tlwRect.topLeft(), windowSurface->size());
+#else
+    const QRect surfaceGeometry(windowSurface->geometry());
+#endif
+    if ((fullUpdatePending || inTopLevelResize || surfaceGeometry.size() != tlwRect.size()) && !updatesDisabled) {
+        if (hasStaticContents()) {
+            // Repaint existing dirty area and newly visible area.
+            const QRect clipRect(0, 0, surfaceGeometry.width(), surfaceGeometry.height());
+            const QRegion staticRegion(staticContents(0, clipRect));
+            QRegion newVisible(0, 0, tlwRect.width(), tlwRect.height());
+            newVisible -= staticRegion;
+            dirty += newVisible;
+            windowSurface->setStaticContents(staticRegion);
+        } else {
+            // Repaint everything.
+            dirty = QRegion(0, 0, tlwRect.width(), tlwRect.height());
+            for (int i = 0; i < dirtyWidgets.size(); ++i)
+                resetWidget(dirtyWidgets.at(i));
+            dirtyWidgets.clear();
+            repaintAllWidgets = true;
+        }
+    }
+
+#ifdef Q_WS_QPA
+    if (inTopLevelResize || surfaceGeometry.size() != tlwRect.size())
+        windowSurface->resize(tlwRect.size());
+#else
+    if (inTopLevelResize || surfaceGeometry != tlwRect)
+        windowSurface->setGeometry(tlwRect);
+#endif
+
+    if (updatesDisabled)
+        return;
+
+    if (hasDirtyFromPreviousSync)
+        dirty += dirtyFromPreviousSync;
+
+    // Contains everything that needs repaint.
+    QRegion toClean(dirty);
+
+    // Loop through all update() widgets and remove them from the list before they are
+    // painted (in case someone calls update() in paintEvent). If the widget is opaque
+    // and does not have transparent overlapping siblings, append it to the
+    // opaqueNonOverlappedWidgets list and paint it directly without composition.
+    QVarLengthArray<QWidget *, 32> opaqueNonOverlappedWidgets;
+    for (int i = 0; i < dirtyWidgets.size(); ++i) {
+        QWidget *w = dirtyWidgets.at(i);
+        QWidgetPrivate *wd = w->d_func();
+        if (wd->data.in_destructor)
+            continue;
+
+        // Clip with mask() and clipRect().
+        wd->dirty &= wd->clipRect();
+        wd->clipToEffectiveMask(wd->dirty);
+
+        // Subtract opaque siblings and children.
+        bool hasDirtySiblingsAbove = false;
+        // We know for sure that the widget isn't overlapped if 'isMoved' is true.
+        if (!wd->isMoved)
+            wd->subtractOpaqueSiblings(wd->dirty, &hasDirtySiblingsAbove);
+        // Scrolled and moved widgets must draw all children.
+        if (!wd->isScrolled && !wd->isMoved)
+            wd->subtractOpaqueChildren(wd->dirty, w->rect());
+
+        if (wd->dirty.isEmpty()) {
+            resetWidget(w);
+            continue;
+        }
+
+        const QRegion widgetDirty(w != tlw ? wd->dirty.translated(w->mapTo(tlw, QPoint()))
+                                           : wd->dirty);
+        toClean += widgetDirty;
+
+#ifndef QT_NO_GRAPHICSVIEW
+        if (tlw->d_func()->extra->proxyWidget) {
+            resetWidget(w);
+            continue;
+        }
+#endif
+
+        if (!hasDirtySiblingsAbove && wd->isOpaque && !dirty.intersects(widgetDirty.boundingRect())) {
+            opaqueNonOverlappedWidgets.append(w);
+        } else {
+            resetWidget(w);
+            dirty += widgetDirty;
+        }
+    }
+    dirtyWidgets.clear();
+
+    fullUpdatePending = false;
+
+    if (toClean.isEmpty()) {
+        // Nothing to repaint. However, we might have newly exposed areas on the
+        // screen if this function was called from sync(QWidget *, QRegion)), so
+        // we have to make sure those are flushed.
+        flush();
+        return;
+    }
+
+#ifndef QT_NO_GRAPHICSVIEW
+    if (tlw->d_func()->extra->proxyWidget) {
+        updateStaticContentsSize();
+        dirty = QRegion();
+        const QVector<QRect> rects(toClean.rects());
+        for (int i = 0; i < rects.size(); ++i)
+            tlw->d_func()->extra->proxyWidget->update(rects.at(i));
+        return;
+    }
+#endif
+
+#ifndef Q_BACKINGSTORE_SUBSURFACES
+    BeginPaintInfo beginPaintInfo;
+    beginPaint(toClean, tlw, windowSurface, &beginPaintInfo);
+    if (beginPaintInfo.nothingToPaint) {
+        for (int i = 0; i < opaqueNonOverlappedWidgets.size(); ++i)
+            resetWidget(opaqueNonOverlappedWidgets[i]);
+        dirty = QRegion();
+        return;
+    }
+#endif
+
+    // Must do this before sending any paint events because
+    // the size may change in the paint event.
+    updateStaticContentsSize();
+    const QRegion dirtyCopy(dirty);
+    dirty = QRegion();
+
+    // Paint opaque non overlapped widgets.
+    for (int i = 0; i < opaqueNonOverlappedWidgets.size(); ++i) {
+        QWidget *w = opaqueNonOverlappedWidgets[i];
+        QWidgetPrivate *wd = w->d_func();
+
+        int flags = QWidgetPrivate::DrawRecursive;
+        // Scrolled and moved widgets must draw all children.
+        if (!wd->isScrolled && !wd->isMoved)
+            flags |= QWidgetPrivate::DontDrawOpaqueChildren;
+        if (w == tlw)
+            flags |= QWidgetPrivate::DrawAsRoot;
+
+        QRegion toBePainted(wd->dirty);
+        resetWidget(w);
+
+#ifdef Q_BACKINGSTORE_SUBSURFACES
+        QWindowSurface *subSurface = w->windowSurface();
+        BeginPaintInfo beginPaintInfo;
+
+        QPoint off = w->mapTo(tlw, QPoint());
+        toBePainted.translate(off);
+        beginPaint(toBePainted, w, subSurface, &beginPaintInfo, true);
+        toBePainted.translate(-off);
+
+        if (beginPaintInfo.nothingToPaint)
+            continue;
+
+        if (beginPaintInfo.windowSurfaceRecreated) {
+            // Eep the window surface has changed. The old one may have been
+            // deleted, in which case we will segfault on the call to
+            // painterOffset() below. Use the new window surface instead.
+            subSurface = w->windowSurface();
+        }
+
+        QPoint offset(tlwOffset);
+        if (subSurface == windowSurface)
+            offset += w->mapTo(tlw, QPoint());
+        else
+            offset = static_cast<QWSWindowSurface*>(subSurface)->painterOffset();
+        wd->drawWidget(subSurface->paintDevice(), toBePainted, offset, flags, 0, this);
+
+        endPaint(toBePainted, subSurface, &beginPaintInfo);
+#else
+        QPoint offset(tlwOffset);
+        if (w != tlw)
+            offset += w->mapTo(tlw, QPoint());
+        wd->drawWidget(windowSurface->paintDevice(), toBePainted, offset, flags, 0, this);
+#endif
+    }
+
+    // Paint the rest with composition.
+#ifndef Q_BACKINGSTORE_SUBSURFACES
+    if (repaintAllWidgets || !dirtyCopy.isEmpty()) {
+        const int flags = QWidgetPrivate::DrawAsRoot | QWidgetPrivate::DrawRecursive;
+        tlw->d_func()->drawWidget(windowSurface->paintDevice(), dirtyCopy, tlwOffset, flags, 0, this);
+    }
+
+    endPaint(toClean, windowSurface, &beginPaintInfo);
+#else
+    if (!repaintAllWidgets && dirtyCopy.isEmpty())
+        return; // Nothing more to paint.
+
+    QList<QWindowSurface *> surfaceList(subSurfaces);
+    surfaceList.prepend(windowSurface);
+    const QRect dirtyBoundingRect(dirtyCopy.boundingRect());
+
+    // Loop through all window surfaces (incl. the top-level surface) and
+    // repaint those intersecting with the bounding rect of the dirty region.
+    for (int i = 0; i < surfaceList.size(); ++i) {
+        QWindowSurface *subSurface = surfaceList.at(i);
+        QWidget *w = subSurface->window();
+        QWidgetPrivate *wd = w->d_func();
+
+        const QRect clipRect = wd->clipRect().translated(w->mapTo(tlw, QPoint()));
+        if (!qRectIntersects(dirtyBoundingRect, clipRect))
+            continue;
+
+        toClean = dirtyCopy;
+        BeginPaintInfo beginPaintInfo;
+        beginPaint(toClean, w, subSurface, &beginPaintInfo);
+        if (beginPaintInfo.nothingToPaint)
+            continue;
+
+        if (beginPaintInfo.windowSurfaceRecreated) {
+            // Eep the window surface has changed. The old one may have been
+            // deleted, in which case we will segfault on the call to
+            // painterOffset() below. Use the new window surface instead.
+            subSurface = w->windowSurface();
+        }
+
+        int flags = QWidgetPrivate::DrawRecursive;
+        if (w == tlw)
+            flags |= QWidgetPrivate::DrawAsRoot;
+        const QPoint painterOffset = static_cast<QWSWindowSurface*>(subSurface)->painterOffset();
+        wd->drawWidget(subSurface->paintDevice(), toClean, painterOffset, flags, 0, this);
+
+        endPaint(toClean, subSurface, &beginPaintInfo);
+    }
+#endif
+}
+
+/*!
+    Flushes the contents of the backing store into the top-level widget.
+    If the \a widget is non-zero, the content is flushed to the \a widget.
+    If the \a surface is non-zero, the content of the \a surface is flushed.
+*/
+void QWidgetBackingStore::flush(QWidget *widget, QWindowSurface *surface)
+{
+#if defined(Q_WS_QWS) && !defined(QT_NO_QWS_MANAGER)
+    paintWindowDecoration();
+#endif
+
+    if (!dirtyOnScreen.isEmpty()) {
+        QWidget *target = widget ? widget : tlw;
+        QWindowSurface *source = surface ? surface : windowSurface;
+        qt_flush(target, dirtyOnScreen, source, tlw, tlwOffset);
+        dirtyOnScreen = QRegion();
+    }
+
+    if (!dirtyOnScreenWidgets || dirtyOnScreenWidgets->isEmpty())
+        return;
+
+    for (int i = 0; i < dirtyOnScreenWidgets->size(); ++i) {
+        QWidget *w = dirtyOnScreenWidgets->at(i);
+        QWidgetPrivate *wd = w->d_func();
+        Q_ASSERT(wd->needsFlush);
+        qt_flush(w, *wd->needsFlush, windowSurface, tlw, tlwOffset);
+        *wd->needsFlush = QRegion();
+    }
+    dirtyOnScreenWidgets->clear();
+}
+
+static inline bool discardInvalidateBufferRequest(QWidget *widget, QTLWExtra *tlwExtra)
+{
+    Q_ASSERT(widget);
+    if (QApplication::closingDown())
+        return true;
+
+    if (!tlwExtra || tlwExtra->inTopLevelResize || !tlwExtra->backingStore)
+        return true;
+
+    if (!widget->isVisible() || !widget->updatesEnabled())
+        return true;
+
+    return false;
+}
+
+/*!
+    Invalidates the buffer when the widget is resized.
+    Static areas are never invalidated unless absolutely needed.
+*/
+void QWidgetPrivate::invalidateBuffer_resizeHelper(const QPoint &oldPos, const QSize &oldSize)
+{
+    Q_Q(QWidget);
+    Q_ASSERT(!q->isWindow());
+    Q_ASSERT(q->parentWidget());
+
+    const bool staticContents = q->testAttribute(Qt::WA_StaticContents);
+    const bool sizeDecreased = (data.crect.width() < oldSize.width())
+                               || (data.crect.height() < oldSize.height());
+
+    const QPoint offset(data.crect.x() - oldPos.x(), data.crect.y() - oldPos.y());
+    const bool parentAreaExposed = !offset.isNull() || sizeDecreased;
+    const QRect newWidgetRect(q->rect());
+    const QRect oldWidgetRect(0, 0, oldSize.width(), oldSize.height());
+
+    if (!staticContents || graphicsEffect) {
+        QRegion staticChildren;
+        QWidgetBackingStore *bs = 0;
+        if (offset.isNull() && (bs = maybeBackingStore()))
+            staticChildren = bs->staticContents(q, oldWidgetRect);
+        const bool hasStaticChildren = !staticChildren.isEmpty();
+
+        if (hasStaticChildren) {
+            QRegion dirty(newWidgetRect);
+            dirty -= staticChildren;
+            invalidateBuffer(dirty);
+        } else {
+            // Entire widget needs repaint.
+            invalidateBuffer(newWidgetRect);
+        }
+
+        if (!parentAreaExposed)
+            return;
+
+        // Invalidate newly exposed area of the parent.
+        if (!graphicsEffect && extra && extra->hasMask) {
+            QRegion parentExpose(extra->mask.translated(oldPos));
+            parentExpose &= QRect(oldPos, oldSize);
+            if (hasStaticChildren)
+                parentExpose -= data.crect; // Offset is unchanged, safe to do this.
+            q->parentWidget()->d_func()->invalidateBuffer(parentExpose);
+        } else {
+            if (hasStaticChildren && !graphicsEffect) {
+                QRegion parentExpose(QRect(oldPos, oldSize));
+                parentExpose -= data.crect; // Offset is unchanged, safe to do this.
+                q->parentWidget()->d_func()->invalidateBuffer(parentExpose);
+            } else {
+                q->parentWidget()->d_func()->invalidateBuffer(effectiveRectFor(QRect(oldPos, oldSize)));
+            }
+        }
+        return;
+    }
+
+    // Move static content to its new position.
+    if (!offset.isNull()) {
+        if (sizeDecreased) {
+            const QSize minSize(qMin(oldSize.width(), data.crect.width()),
+                                qMin(oldSize.height(), data.crect.height()));
+            moveRect(QRect(oldPos, minSize), offset.x(), offset.y());
+        } else {
+            moveRect(QRect(oldPos, oldSize), offset.x(), offset.y());
+        }
+    }
+
+    // Invalidate newly visible area of the widget.
+    if (!sizeDecreased || !oldWidgetRect.contains(newWidgetRect)) {
+        QRegion newVisible(newWidgetRect);
+        newVisible -= oldWidgetRect;
+        invalidateBuffer(newVisible);
+    }
+
+    if (!parentAreaExposed)
+        return;
+
+    // Invalidate newly exposed area of the parent.
+    const QRect oldRect(oldPos, oldSize);
+    if (extra && extra->hasMask) {
+        QRegion parentExpose(oldRect);
+        parentExpose &= extra->mask.translated(oldPos);
+        parentExpose -= (extra->mask.translated(data.crect.topLeft()) & data.crect);
+        q->parentWidget()->d_func()->invalidateBuffer(parentExpose);
+    } else {
+        QRegion parentExpose(oldRect);
+        parentExpose -= data.crect;
+        q->parentWidget()->d_func()->invalidateBuffer(parentExpose);
+    }
+}
+
+/*!
+    Invalidates the \a rgn (in widget's coordinates) of the backing store, i.e.
+    all widgets intersecting with the region will be repainted when the backing store
+    is synced.
+
+    ### Qt 4.6: Merge into a template function (after MSVC isn't supported anymore).
+*/
+void QWidgetPrivate::invalidateBuffer(const QRegion &rgn)
+{
+    Q_Q(QWidget);
+
+    QTLWExtra *tlwExtra = q->window()->d_func()->maybeTopData();
+    if (discardInvalidateBufferRequest(q, tlwExtra) || rgn.isEmpty())
+        return;
+
+    QRegion wrgn(rgn);
+    wrgn &= clipRect();
+    if (!graphicsEffect && extra && extra->hasMask)
+        wrgn &= extra->mask;
+    if (wrgn.isEmpty())
+        return;
+
+    tlwExtra->backingStore->markDirty(wrgn, q, false, true);
+}
+
+/*!
+    This function is equivalent to calling invalidateBuffer(QRegion(rect), ...), but
+    is more efficient as it eliminates QRegion operations/allocations and can
+    use the rect more precisely for additional cut-offs.
+
+    ### Qt 4.6: Merge into a template function (after MSVC isn't supported anymore).
+*/
+void QWidgetPrivate::invalidateBuffer(const QRect &rect)
+{
+    Q_Q(QWidget);
+
+    QTLWExtra *tlwExtra = q->window()->d_func()->maybeTopData();
+    if (discardInvalidateBufferRequest(q, tlwExtra) || rect.isEmpty())
+        return;
+
+    QRect wRect(rect);
+    wRect &= clipRect();
+    if (wRect.isEmpty())
+        return;
+
+    if (graphicsEffect || !extra || !extra->hasMask) {
+        tlwExtra->backingStore->markDirty(wRect, q, false, true);
+        return;
+    }
+
+    QRegion wRgn(extra->mask);
+    wRgn &= wRect;
+    if (wRgn.isEmpty())
+        return;
+
+    tlwExtra->backingStore->markDirty(wRgn, q, false, true);
+}
+
+void QWidgetPrivate::repaint_sys(const QRegion &rgn)
+{
+    if (data.in_destructor)
+        return;
+
+    Q_Q(QWidget);
+    if (q->testAttribute(Qt::WA_StaticContents)) {
+        if (!extra)
+            createExtra();
+        extra->staticContentsSize = data.crect.size();
+    }
+
+#ifdef Q_WS_QPA //Dont even call q->p
+    QPaintEngine *engine = 0;
+#else
+    QPaintEngine *engine = q->paintEngine();
+#endif
+    // QGLWidget does not support partial updates if:
+    // 1) The context is double buffered
+    // 2) The context is single buffered and auto-fill background is enabled.
+    const bool noPartialUpdateSupport = (engine && (engine->type() == QPaintEngine::OpenGL
+                                                || engine->type() == QPaintEngine::OpenGL2))
+                                        && (usesDoubleBufferedGLContext || q->autoFillBackground());
+    QRegion toBePainted(noPartialUpdateSupport ? q->rect() : rgn);
+
+#ifdef Q_WS_MAC
+    // No difference between update() and repaint() on the Mac.
+    update_sys(toBePainted);
+    return;
+#endif
+
+    toBePainted &= clipRect();
+    clipToEffectiveMask(toBePainted);
+    if (toBePainted.isEmpty())
+        return; // Nothing to repaint.
+
+#ifndef QT_NO_PAINT_DEBUG
+    bool flushed = QWidgetBackingStore::flushPaint(q, toBePainted);
+#endif
+
+    drawWidget(q, toBePainted, QPoint(), QWidgetPrivate::DrawAsRoot | QWidgetPrivate::DrawPaintOnScreen, 0);
+
+#ifndef QT_NO_PAINT_DEBUG
+    if (flushed)
+        QWidgetBackingStore::unflushPaint(q, toBePainted);
+#endif
+
+    if (!q->testAttribute(Qt::WA_PaintOutsidePaintEvent) && q->paintingActive())
+        qWarning("QWidget::repaint: It is dangerous to leave painters active on a widget outside of the PaintEvent");
+}
+
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qbackingstore_p.h b/src/gui/painting/qbackingstore_p.h
new file mode 100644
index 0000000000..05f4bfcb6c
--- /dev/null
+++ b/src/gui/painting/qbackingstore_p.h
@@ -0,0 +1,278 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QBACKINGSTORE_P_H
+#define QBACKINGSTORE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QDebug>
+#include <QtGui/qwidget.h>
+#include <private/qwidget_p.h>
+#include <private/qwindowsurface_p.h>
+#ifdef Q_WS_QWS
+#include <private/qwindowsurface_qws_p.h>
+#endif
+
+QT_BEGIN_NAMESPACE
+
+class QWindowSurface;
+
+struct BeginPaintInfo {
+    inline BeginPaintInfo() : wasFlushed(0), nothingToPaint(0), windowSurfaceRecreated(0) {}
+    uint wasFlushed : 1;
+    uint nothingToPaint : 1;
+    uint windowSurfaceRecreated : 1;
+};
+
+class Q_AUTOTEST_EXPORT QWidgetBackingStore
+{
+public:
+    QWidgetBackingStore(QWidget *t);
+    ~QWidgetBackingStore();
+
+    static void showYellowThing(QWidget *widget, const QRegion &rgn, int msec, bool);
+
+    void sync(QWidget *exposedWidget, const QRegion &exposedRegion);
+    void sync();
+    void flush(QWidget *widget = 0, QWindowSurface *surface = 0);
+
+    inline QPoint topLevelOffset() const { return tlwOffset; }
+
+    QWindowSurface *surface() const { return windowSurface; }
+
+    inline bool isDirty() const
+    {
+        return !(dirtyWidgets.isEmpty() && dirty.isEmpty() && !hasDirtyFromPreviousSync
+                 && !fullUpdatePending
+#if defined(Q_WS_QWS) && !defined(QT_NO_QWS_MANAGER)
+                 && !hasDirtyWindowDecoration()
+#endif
+                );
+    }
+
+    // ### Qt 4.6: Merge into a template function (after MSVC isn't supported anymore).
+    void markDirty(const QRegion &rgn, QWidget *widget, bool updateImmediately = false,
+                   bool invalidateBuffer = false);
+    void markDirty(const QRect &rect, QWidget *widget, bool updateImmediately = false,
+                   bool invalidateBuffer = false);
+
+private:
+    QWidget *tlw;
+    QRegion dirtyOnScreen; // needsFlush
+    QRegion dirty; // needsRepaint
+    QRegion dirtyFromPreviousSync;
+    QVector<QWidget *> dirtyWidgets;
+    QVector<QWidget *> *dirtyOnScreenWidgets;
+    QList<QWidget *> staticWidgets;
+    QWindowSurface *windowSurface;
+#ifdef Q_BACKINGSTORE_SUBSURFACES
+    QList<QWindowSurface*> subSurfaces;
+#endif
+    uint hasDirtyFromPreviousSync : 1;
+    uint fullUpdatePending : 1;
+
+    QPoint tlwOffset;
+
+    static bool flushPaint(QWidget *widget, const QRegion &rgn);
+    static void unflushPaint(QWidget *widget, const QRegion &rgn);
+
+    bool bltRect(const QRect &rect, int dx, int dy, QWidget *widget);
+    void releaseBuffer();
+
+    void beginPaint(QRegion &toClean, QWidget *widget, QWindowSurface *windowSurface,
+                    BeginPaintInfo *returnInfo, bool toCleanIsInTopLevelCoordinates = true);
+    void endPaint(const QRegion &cleaned, QWindowSurface *windowSurface, BeginPaintInfo *beginPaintInfo);
+
+    QRegion dirtyRegion(QWidget *widget = 0) const;
+    QRegion staticContents(QWidget *widget = 0, const QRect &withinClipRect = QRect()) const;
+
+    void markDirtyOnScreen(const QRegion &dirtyOnScreen, QWidget *widget, const QPoint &topLevelOffset);
+
+    void removeDirtyWidget(QWidget *w);
+
+#if defined(Q_WS_QWS) && !defined(QT_NO_QWS_MANAGER)
+    bool hasDirtyWindowDecoration() const;
+    void paintWindowDecoration();
+#endif
+    void updateLists(QWidget *widget);
+
+    inline void addDirtyWidget(QWidget *widget, const QRegion &rgn)
+    {
+        if (widget && !widget->d_func()->inDirtyList && !widget->data->in_destructor) {
+            QWidgetPrivate *widgetPrivate = widget->d_func();
+#ifndef QT_NO_GRAPHICSEFFECT
+            if (widgetPrivate->graphicsEffect)
+                widgetPrivate->dirty = widgetPrivate->effectiveRectFor(rgn.boundingRect());
+            else
+#endif //QT_NO_GRAPHICSEFFECT
+                widgetPrivate->dirty = rgn;
+            dirtyWidgets.append(widget);
+            widgetPrivate->inDirtyList = true;
+        }
+    }
+
+    inline void dirtyWidgetsRemoveAll(QWidget *widget)
+    {
+        int i = 0;
+        while (i < dirtyWidgets.size()) {
+            if (dirtyWidgets.at(i) == widget)
+                dirtyWidgets.remove(i);
+            else
+                ++i;
+        }
+    }
+
+    inline void addStaticWidget(QWidget *widget)
+    {
+        if (!widget)
+            return;
+
+        Q_ASSERT(widget->testAttribute(Qt::WA_StaticContents));
+        if (!staticWidgets.contains(widget))
+            staticWidgets.append(widget);
+    }
+
+    inline void removeStaticWidget(QWidget *widget)
+    { staticWidgets.removeAll(widget); }
+
+    // Move the reparented widget and all its static children from this backing store
+    // to the new backing store if reparented into another top-level / backing store.
+    inline void moveStaticWidgets(QWidget *reparented)
+    {
+        Q_ASSERT(reparented);
+        QWidgetBackingStore *newBs = reparented->d_func()->maybeBackingStore();
+        if (newBs == this)
+            return;
+
+        int i = 0;
+        while (i < staticWidgets.size()) {
+            QWidget *w = staticWidgets.at(i);
+            if (reparented == w || reparented->isAncestorOf(w)) {
+                staticWidgets.removeAt(i);
+                if (newBs)
+                    newBs->addStaticWidget(w);
+            } else {
+                ++i;
+            }
+        }
+    }
+
+    inline QRect topLevelRect() const
+    {
+#ifdef Q_WS_QWS
+        return tlw->frameGeometry();
+#else
+        return tlw->data->crect;
+#endif
+    }
+
+    inline void appendDirtyOnScreenWidget(QWidget *widget)
+    {
+        if (!widget)
+            return;
+
+        if (!dirtyOnScreenWidgets) {
+            dirtyOnScreenWidgets = new QVector<QWidget *>;
+            dirtyOnScreenWidgets->append(widget);
+        } else if (!dirtyOnScreenWidgets->contains(widget)) {
+            dirtyOnScreenWidgets->append(widget);
+        }
+    }
+
+    inline void dirtyOnScreenWidgetsRemoveAll(QWidget *widget)
+    {
+        if (!widget || !dirtyOnScreenWidgets)
+            return;
+
+        int i = 0;
+        while (i < dirtyOnScreenWidgets->size()) {
+            if (dirtyOnScreenWidgets->at(i) == widget)
+                dirtyOnScreenWidgets->remove(i);
+            else
+                ++i;
+        }
+    }
+
+    inline void resetWidget(QWidget *widget)
+    {
+        if (widget) {
+            widget->d_func()->inDirtyList = false;
+            widget->d_func()->isScrolled = false;
+            widget->d_func()->isMoved = false;
+            widget->d_func()->dirty = QRegion();
+        }
+    }
+
+    inline void updateStaticContentsSize()
+    {
+        for (int i = 0; i < staticWidgets.size(); ++i) {
+            QWidgetPrivate *wd = staticWidgets.at(i)->d_func();
+            if (!wd->extra)
+                wd->createExtra();
+            wd->extra->staticContentsSize = wd->data.crect.size();
+        }
+    }
+
+    inline bool hasStaticContents() const
+    { return !staticWidgets.isEmpty() && windowSurface->hasFeature(QWindowSurface::StaticContents); }
+
+    friend QRegion qt_dirtyRegion(QWidget *);
+    friend class QWidgetPrivate;
+    friend class QWidget;
+    friend class QWSManagerPrivate;
+    friend class QETWidget;
+    friend class QWindowSurface;
+    friend class QWSWindowSurface;
+};
+
+QT_END_NAMESPACE
+
+#endif // QBACKINGSTORE_P_H
diff --git a/src/gui/painting/qbezier.cpp b/src/gui/painting/qbezier.cpp
new file mode 100644
index 0000000000..a2f0edd397
--- /dev/null
+++ b/src/gui/painting/qbezier.cpp
@@ -0,0 +1,702 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qbezier_p.h"
+#include <qdebug.h>
+#include <qline.h>
+#include <qpolygon.h>
+#include <qvector.h>
+#include <qlist.h>
+#include <qmath.h>
+
+#include <private/qnumeric_p.h>
+#include <private/qmath_p.h>
+
+QT_BEGIN_NAMESPACE
+
+//#define QDEBUG_BEZIER
+
+#ifdef FLOAT_ACCURACY
+#define INV_EPS (1L<<23)
+#else
+/* The value of 1.0 / (1L<<14) is enough for most applications */
+#define INV_EPS (1L<<14)
+#endif
+
+#ifndef M_SQRT2
+#define M_SQRT2	1.41421356237309504880
+#endif
+
+/*!
+  \internal
+*/
+QBezier QBezier::fromPoints(const QPointF &p1, const QPointF &p2,
+                            const QPointF &p3, const QPointF &p4)
+{
+    QBezier b;
+    b.x1 = p1.x();
+    b.y1 = p1.y();
+    b.x2 = p2.x();
+    b.y2 = p2.y();
+    b.x3 = p3.x();
+    b.y3 = p3.y();
+    b.x4 = p4.x();
+    b.y4 = p4.y();
+    return b;
+}
+
+/*!
+  \internal
+*/
+QPolygonF QBezier::toPolygon(qreal bezier_flattening_threshold) const
+{
+    // flattening is done by splitting the bezier until we can replace the segment by a straight
+    // line. We split further until the control points are close enough to the line connecting the
+    // boundary points.
+    //
+    // the Distance of a point p from a line given by the points (a,b) is given by:
+    //
+    // d = abs( (bx - ax)(ay - py) - (by - ay)(ax - px) ) / line_length
+    //
+    // We can stop splitting if both control points are close enough to the line.
+    // To make the algorithm faster we use the manhattan length of the line.
+
+    QPolygonF polygon;
+    polygon.append(QPointF(x1, y1));
+    addToPolygon(&polygon, bezier_flattening_threshold);
+    return polygon;
+}
+
+QBezier QBezier::mapBy(const QTransform &transform) const
+{
+    return QBezier::fromPoints(transform.map(pt1()), transform.map(pt2()), transform.map(pt3()), transform.map(pt4()));
+}
+
+QBezier QBezier::getSubRange(qreal t0, qreal t1) const
+{
+    QBezier result;
+    QBezier temp;
+
+    // cut at t1
+    if (qFuzzyIsNull(t1 - qreal(1.))) {
+        result = *this;
+    } else {
+        temp = *this;
+        temp.parameterSplitLeft(t1, &result);
+    }
+
+    // cut at t0
+    if (!qFuzzyIsNull(t0))
+        result.parameterSplitLeft(t0 / t1, &temp);
+
+    return result;
+}
+
+static inline int quadraticRoots(qreal a, qreal b, qreal c,
+                                 qreal *x1, qreal *x2)
+{
+    if (qFuzzyIsNull(a)) {
+        if (qFuzzyIsNull(b))
+            return 0;
+        *x1 = *x2 = (-c / b);
+        return 1;
+    } else {
+        const qreal det = b * b - 4 * a * c;
+        if (qFuzzyIsNull(det)) {
+            *x1 = *x2 = -b / (2 * a);
+            return 1;
+        }
+        if (det > 0) {
+            if (qFuzzyIsNull(b)) {
+                *x2 = qSqrt(-c / a);
+                *x1 = -(*x2);
+                return 2;
+            }
+            const qreal stableA = b / (2 * a);
+            const qreal stableB = c / (a * stableA * stableA);
+            const qreal stableC = -1 - qSqrt(1 - stableB);
+            *x2 = stableA * stableC;
+            *x1 = (stableA * stableB) / stableC;
+            return 2;
+        } else
+            return 0;
+    }
+}
+
+static inline bool findInflections(qreal a, qreal b, qreal c,
+                                   qreal *t1 , qreal *t2, qreal *tCups)
+{
+    qreal r1 = 0, r2 = 0;
+
+    short rootsCount = quadraticRoots(a, b, c, &r1, &r2);
+
+    if (rootsCount >= 1) {
+        if (r1 < r2) {
+            *t1 = r1;
+            *t2 = r2;
+        } else {
+            *t1 = r2;
+            *t2 = r1;
+        }
+        if (!qFuzzyIsNull(a))
+            *tCups = qreal(0.5) * (-b / a);
+        else
+            *tCups = 2;
+
+        return true;
+    }
+
+    return false;
+}
+
+
+void QBezier::addToPolygon(QPolygonF *polygon, qreal bezier_flattening_threshold) const
+{
+    QBezier beziers[32];
+    beziers[0] = *this;
+    QBezier *b = beziers;
+
+    while (b >= beziers) {
+        // check if we can pop the top bezier curve from the stack
+        qreal y4y1 = b->y4 - b->y1;
+        qreal x4x1 = b->x4 - b->x1;
+        qreal l = qAbs(x4x1) + qAbs(y4y1);
+        qreal d;
+        if (l > 1.) {
+            d = qAbs( (x4x1)*(b->y1 - b->y2) - (y4y1)*(b->x1 - b->x2) )
+                + qAbs( (x4x1)*(b->y1 - b->y3) - (y4y1)*(b->x1 - b->x3) );
+        } else {
+            d = qAbs(b->x1 - b->x2) + qAbs(b->y1 - b->y2) +
+                qAbs(b->x1 - b->x3) + qAbs(b->y1 - b->y3);
+            l = 1.;
+        }
+        if (d < bezier_flattening_threshold*l || b == beziers + 31) {
+            // good enough, we pop it off and add the endpoint
+            polygon->append(QPointF(b->x4, b->y4));
+            --b;
+        } else {
+            // split, second half of the polygon goes lower into the stack
+            b->split(b+1, b);
+            ++b;
+        }
+    }
+}
+
+QRectF QBezier::bounds() const
+{
+    qreal xmin = x1;
+    qreal xmax = x1;
+    if (x2 < xmin)
+        xmin = x2;
+    else if (x2 > xmax)
+        xmax = x2;
+    if (x3 < xmin)
+        xmin = x3;
+    else if (x3 > xmax)
+        xmax = x3;
+    if (x4 < xmin)
+        xmin = x4;
+    else if (x4 > xmax)
+        xmax = x4;
+
+    qreal ymin = y1;
+    qreal ymax = y1;
+    if (y2 < ymin)
+        ymin = y2;
+    else if (y2 > ymax)
+        ymax = y2;
+    if (y3 < ymin)
+        ymin = y3;
+    else if (y3 > ymax)
+        ymax = y3;
+    if (y4 < ymin)
+        ymin = y4;
+    else if (y4 > ymax)
+        ymax = y4;
+    return QRectF(xmin, ymin, xmax-xmin, ymax-ymin);
+}
+
+
+enum ShiftResult {
+    Ok,
+    Discard,
+    Split,
+    Circle
+};
+
+static ShiftResult good_offset(const QBezier *b1, const QBezier *b2, qreal offset, qreal threshold)
+{
+    const qreal o2 = offset*offset;
+    const qreal max_dist_line = threshold*offset*offset;
+    const qreal max_dist_normal = threshold*offset;
+    const qreal spacing = qreal(0.25);
+    for (qreal i = spacing; i < qreal(0.99); i += spacing) {
+        QPointF p1 = b1->pointAt(i);
+        QPointF p2 = b2->pointAt(i);
+        qreal d = (p1.x() - p2.x())*(p1.x() - p2.x()) + (p1.y() - p2.y())*(p1.y() - p2.y());
+        if (qAbs(d - o2) > max_dist_line)
+            return Split;
+
+        QPointF normalPoint = b1->normalVector(i);
+        qreal l = qAbs(normalPoint.x()) + qAbs(normalPoint.y());
+        if (l != qreal(0.0)) {
+            d = qAbs( normalPoint.x()*(p1.y() - p2.y()) - normalPoint.y()*(p1.x() - p2.x()) ) / l;
+            if (d > max_dist_normal)
+                return Split;
+        }
+    }
+    return Ok;
+}
+
+static ShiftResult shift(const QBezier *orig, QBezier *shifted, qreal offset, qreal threshold)
+{
+    int map[4];
+    bool p1_p2_equal = (orig->x1 == orig->x2 && orig->y1 == orig->y2);
+    bool p2_p3_equal = (orig->x2 == orig->x3 && orig->y2 == orig->y3);
+    bool p3_p4_equal = (orig->x3 == orig->x4 && orig->y3 == orig->y4);
+
+    QPointF points[4];
+    int np = 0;
+    points[np] = QPointF(orig->x1, orig->y1);
+    map[0] = 0;
+    ++np;
+    if (!p1_p2_equal) {
+        points[np] = QPointF(orig->x2, orig->y2);
+        ++np;
+    }
+    map[1] = np - 1;
+    if (!p2_p3_equal) {
+        points[np] = QPointF(orig->x3, orig->y3);
+        ++np;
+    }
+    map[2] = np - 1;
+    if (!p3_p4_equal) {
+        points[np] = QPointF(orig->x4, orig->y4);
+        ++np;
+    }
+    map[3] = np - 1;
+    if (np == 1)
+        return Discard;
+
+    QRectF b = orig->bounds();
+    if (np == 4 && b.width() < .1*offset && b.height() < .1*offset) {
+        qreal l = (orig->x1 - orig->x2)*(orig->x1 - orig->x2) +
+                  (orig->y1 - orig->y2)*(orig->y1 - orig->y1) *
+                  (orig->x3 - orig->x4)*(orig->x3 - orig->x4) +
+                  (orig->y3 - orig->y4)*(orig->y3 - orig->y4);
+        qreal dot = (orig->x1 - orig->x2)*(orig->x3 - orig->x4) +
+                    (orig->y1 - orig->y2)*(orig->y3 - orig->y4);
+        if (dot < 0 && dot*dot < 0.8*l)
+            // the points are close and reverse dirction. Approximate the whole
+            // thing by a semi circle
+            return Circle;
+    }
+
+    QPointF points_shifted[4];
+
+    QLineF prev = QLineF(QPointF(), points[1] - points[0]);
+    QPointF prev_normal = prev.normalVector().unitVector().p2();
+
+    points_shifted[0] = points[0] + offset * prev_normal;
+
+    for (int i = 1; i < np - 1; ++i) {
+        QLineF next = QLineF(QPointF(), points[i + 1] - points[i]);
+        QPointF next_normal = next.normalVector().unitVector().p2();
+
+        QPointF normal_sum = prev_normal + next_normal;
+
+        qreal r = qreal(1.0) + prev_normal.x() * next_normal.x()
+                  + prev_normal.y() * next_normal.y();
+
+        if (qFuzzyIsNull(r)) {
+            points_shifted[i] = points[i] + offset * prev_normal;
+        } else {
+            qreal k = offset / r;
+            points_shifted[i] = points[i] + k * normal_sum;
+        }
+
+        prev_normal = next_normal;
+    }
+
+    points_shifted[np - 1] = points[np - 1] + offset * prev_normal;
+
+    *shifted = QBezier::fromPoints(points_shifted[map[0]], points_shifted[map[1]],
+                                   points_shifted[map[2]], points_shifted[map[3]]);
+
+    return good_offset(orig, shifted, offset, threshold);
+}
+
+// This value is used to determine the length of control point vectors
+// when approximating arc segments as curves. The factor is multiplied
+// with the radius of the circle.
+#define KAPPA qreal(0.5522847498)
+
+
+static bool addCircle(const QBezier *b, qreal offset, QBezier *o)
+{
+    QPointF normals[3];
+
+    normals[0] = QPointF(b->y2 - b->y1, b->x1 - b->x2);
+    qreal dist = qSqrt(normals[0].x()*normals[0].x() + normals[0].y()*normals[0].y());
+    if (qFuzzyIsNull(dist))
+        return false;
+    normals[0] /= dist;
+    normals[2] = QPointF(b->y4 - b->y3, b->x3 - b->x4);
+    dist = qSqrt(normals[2].x()*normals[2].x() + normals[2].y()*normals[2].y());
+    if (qFuzzyIsNull(dist))
+        return false;
+    normals[2] /= dist;
+
+    normals[1] = QPointF(b->x1 - b->x2 - b->x3 + b->x4, b->y1 - b->y2 - b->y3 + b->y4);
+    normals[1] /= -1*qSqrt(normals[1].x()*normals[1].x() + normals[1].y()*normals[1].y());
+
+    qreal angles[2];
+    qreal sign = 1.;
+    for (int i = 0; i < 2; ++i) {
+        qreal cos_a = normals[i].x()*normals[i+1].x() + normals[i].y()*normals[i+1].y();
+        if (cos_a > 1.)
+            cos_a = 1.;
+        if (cos_a < -1.)
+            cos_a = -1;
+        angles[i] = qAcos(cos_a)/Q_PI;
+    }
+
+    if (angles[0] + angles[1] > 1.) {
+        // more than 180 degrees
+        normals[1] = -normals[1];
+        angles[0] = 1. - angles[0];
+        angles[1] = 1. - angles[1];
+        sign = -1.;
+
+    }
+
+    QPointF circle[3];
+    circle[0] = QPointF(b->x1, b->y1) + normals[0]*offset;
+    circle[1] = QPointF(qreal(0.5)*(b->x1 + b->x4), qreal(0.5)*(b->y1 + b->y4)) + normals[1]*offset;
+    circle[2] = QPointF(b->x4, b->y4) + normals[2]*offset;
+
+    for (int i = 0; i < 2; ++i) {
+        qreal kappa = qreal(2.0) * KAPPA * sign * offset * angles[i];
+
+        o->x1 = circle[i].x();
+        o->y1 = circle[i].y();
+        o->x2 = circle[i].x() - normals[i].y()*kappa;
+        o->y2 = circle[i].y() + normals[i].x()*kappa;
+        o->x3 = circle[i+1].x() + normals[i+1].y()*kappa;
+        o->y3 = circle[i+1].y() - normals[i+1].x()*kappa;
+        o->x4 = circle[i+1].x();
+        o->y4 = circle[i+1].y();
+
+        ++o;
+    }
+    return true;
+}
+
+int QBezier::shifted(QBezier *curveSegments, int maxSegments, qreal offset, float threshold) const
+{
+    Q_ASSERT(curveSegments);
+    Q_ASSERT(maxSegments > 0);
+
+    if (x1 == x2 && x1 == x3 && x1 == x4 &&
+        y1 == y2 && y1 == y3 && y1 == y4)
+        return 0;
+
+    --maxSegments;
+    QBezier beziers[10];
+redo:
+    beziers[0] = *this;
+    QBezier *b = beziers;
+    QBezier *o = curveSegments;
+
+    while (b >= beziers) {
+        int stack_segments = b - beziers + 1;
+        if ((stack_segments == 10) || (o - curveSegments == maxSegments - stack_segments)) {
+            threshold *= qreal(1.5);
+            if (threshold > qreal(2.0))
+                goto give_up;
+            goto redo;
+        }
+        ShiftResult res = shift(b, o, offset, threshold);
+        if (res == Discard) {
+            --b;
+        } else if (res == Ok) {
+            ++o;
+            --b;
+            continue;
+        } else if (res == Circle && maxSegments - (o - curveSegments) >= 2) {
+            // add semi circle
+            if (addCircle(b, offset, o))
+                o += 2;
+            --b;
+        } else {
+            b->split(b+1, b);
+            ++b;
+        }
+    }
+
+give_up:
+    while (b >= beziers) {
+        ShiftResult res = shift(b, o, offset, threshold);
+
+        // if res isn't Ok or Split then *o is undefined
+        if (res == Ok || res == Split)
+            ++o;
+
+        --b;
+    }
+
+    Q_ASSERT(o - curveSegments <= maxSegments);
+    return o - curveSegments;
+}
+
+#ifdef QDEBUG_BEZIER
+static QDebug operator<<(QDebug dbg, const QBezier &bz)
+{
+    dbg << '[' << bz.x1<< ", " << bz.y1 << "], "
+        << '[' << bz.x2 <<", " << bz.y2 << "], "
+        << '[' << bz.x3 <<", " << bz.y3 << "], "
+        << '[' << bz.x4 <<", " << bz.y4 << ']';
+    return dbg;
+}
+#endif
+
+static inline void splitBezierAt(const QBezier &bez, qreal t,
+                                 QBezier *left, QBezier *right)
+{
+    left->x1 = bez.x1;
+    left->y1 = bez.y1;
+
+    left->x2 = bez.x1 + t * ( bez.x2 - bez.x1 );
+    left->y2 = bez.y1 + t * ( bez.y2 - bez.y1 );
+
+    left->x3 = bez.x2 + t * ( bez.x3 - bez.x2 ); // temporary holding spot
+    left->y3 = bez.y2 + t * ( bez.y3 - bez.y2 ); // temporary holding spot
+
+    right->x3 = bez.x3 + t * ( bez.x4 - bez.x3 );
+    right->y3 = bez.y3 + t * ( bez.y4 - bez.y3 );
+
+    right->x2 = left->x3 + t * ( right->x3 - left->x3);
+    right->y2 = left->y3 + t * ( right->y3 - left->y3);
+
+    left->x3 = left->x2 + t * ( left->x3 - left->x2 );
+    left->y3 = left->y2 + t * ( left->y3 - left->y2 );
+
+    left->x4 = right->x1 = left->x3 + t * (right->x2 - left->x3);
+    left->y4 = right->y1 = left->y3 + t * (right->y2 - left->y3);
+
+    right->x4 = bez.x4;
+    right->y4 = bez.y4;
+}
+
+qreal QBezier::length(qreal error) const
+{
+    qreal length = qreal(0.0);
+
+    addIfClose(&length, error);
+
+    return length;
+}
+
+void QBezier::addIfClose(qreal *length, qreal error) const
+{
+    QBezier left, right;     /* bez poly splits */
+
+    qreal len = qreal(0.0);  /* arc length */
+    qreal chord;             /* chord length */
+
+    len = len + QLineF(QPointF(x1, y1),QPointF(x2, y2)).length();
+    len = len + QLineF(QPointF(x2, y2),QPointF(x3, y3)).length();
+    len = len + QLineF(QPointF(x3, y3),QPointF(x4, y4)).length();
+
+    chord = QLineF(QPointF(x1, y1),QPointF(x4, y4)).length();
+
+    if((len-chord) > error) {
+        split(&left, &right);                 /* split in two */
+        left.addIfClose(length, error);       /* try left side */
+        right.addIfClose(length, error);      /* try right side */
+        return;
+    }
+
+    *length = *length + len;
+
+    return;
+}
+
+qreal QBezier::tForY(qreal t0, qreal t1, qreal y) const
+{
+    qreal py0 = pointAt(t0).y();
+    qreal py1 = pointAt(t1).y();
+
+    if (py0 > py1) {
+        qSwap(py0, py1);
+        qSwap(t0, t1);
+    }
+
+    Q_ASSERT(py0 <= py1);
+
+    if (py0 >= y)
+        return t0;
+    else if (py1 <= y)
+        return t1;
+
+    Q_ASSERT(py0 < y && y < py1);
+
+    qreal lt = t0;
+    qreal dt;
+    do {
+        qreal t = qreal(0.5) * (t0 + t1);
+
+        qreal a, b, c, d;
+        QBezier::coefficients(t, a, b, c, d);
+        qreal yt = a * y1 + b * y2 + c * y3 + d * y4;
+
+        if (yt < y) {
+            t0 = t;
+            py0 = yt;
+        } else {
+            t1 = t;
+            py1 = yt;
+        }
+        dt = lt - t;
+        lt = t;
+    } while (qAbs(dt) > qreal(1e-7));
+
+    return t0;
+}
+
+int QBezier::stationaryYPoints(qreal &t0, qreal &t1) const
+{
+    // y(t) = (1 - t)^3 * y1 + 3 * (1 - t)^2 * t * y2 + 3 * (1 - t) * t^2 * y3 + t^3 * y4
+    // y'(t) = 3 * (-(1-2t+t^2) * y1 + (1 - 4 * t + 3 * t^2) * y2 + (2 * t - 3 * t^2) * y3 + t^2 * y4)
+    // y'(t) = 3 * ((-y1 + 3 * y2 - 3 * y3 + y4)t^2 + (2 * y1 - 4 * y2 + 2 * y3)t + (-y1 + y2))
+
+    const qreal a = -y1 + 3 * y2 - 3 * y3 + y4;
+    const qreal b = 2 * y1 - 4 * y2 + 2 * y3;
+    const qreal c = -y1 + y2;
+
+    if (qFuzzyIsNull(a)) {
+        if (qFuzzyIsNull(b))
+            return 0;
+
+        t0 = -c / b;
+        return t0 > 0 && t0 < 1;
+    }
+
+    qreal reciprocal = b * b - 4 * a * c;
+
+    if (qFuzzyIsNull(reciprocal)) {
+        t0 = -b / (2 * a);
+        return t0 > 0 && t0 < 1;
+    } else if (reciprocal > 0) {
+        qreal temp = qSqrt(reciprocal);
+
+        t0 = (-b - temp)/(2*a);
+        t1 = (-b + temp)/(2*a);
+
+        if (t1 < t0)
+            qSwap(t0, t1);
+
+        int count = 0;
+        qreal t[2] = { 0, 1 };
+
+        if (t0 > 0 && t0 < 1)
+            t[count++] = t0;
+        if (t1 > 0 && t1 < 1)
+            t[count++] = t1;
+
+        t0 = t[0];
+        t1 = t[1];
+
+        return count;
+    }
+
+    return 0;
+}
+
+qreal QBezier::tAtLength(qreal l) const
+{
+    qreal len = length();
+    qreal t   = qreal(1.0);
+    const qreal error = qreal(0.01);
+    if (l > len || qFuzzyCompare(l, len))
+        return t;
+
+    t *= qreal(0.5);
+    //int iters = 0;
+    //qDebug()<<"LEN is "<<l<<len;
+    qreal lastBigger = qreal(1.0);
+    while (1) {
+        //qDebug()<<"\tt is "<<t;
+        QBezier right = *this;
+        QBezier left;
+        right.parameterSplitLeft(t, &left);
+        qreal lLen = left.length();
+        if (qAbs(lLen - l) < error)
+            break;
+
+        if (lLen < l) {
+            t += (lastBigger - t) * qreal(0.5);
+        } else {
+            lastBigger = t;
+            t -= t * qreal(0.5);
+        }
+        //++iters;
+    }
+    //qDebug()<<"number of iters is "<<iters;
+    return t;
+}
+
+QBezier QBezier::bezierOnInterval(qreal t0, qreal t1) const
+{
+    if (t0 == 0 && t1 == 1)
+        return *this;
+
+    QBezier bezier = *this;
+
+    QBezier result;
+    bezier.parameterSplitLeft(t0, &result);
+    qreal trueT = (t1-t0)/(1-t0);
+    bezier.parameterSplitLeft(trueT, &result);
+
+    return result;
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qbezier_p.h b/src/gui/painting/qbezier_p.h
new file mode 100644
index 0000000000..8d37e9a653
--- /dev/null
+++ b/src/gui/painting/qbezier_p.h
@@ -0,0 +1,274 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QBEZIER_P_H
+#define QBEZIER_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of other Qt classes.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "QtCore/qpoint.h"
+#include "QtCore/qline.h"
+#include "QtCore/qrect.h"
+#include "QtCore/qvector.h"
+#include "QtCore/qlist.h"
+#include "QtCore/qpair.h"
+#include "QtGui/qtransform.h"
+
+QT_BEGIN_NAMESPACE
+
+class QPolygonF;
+
+class Q_GUI_EXPORT QBezier
+{
+public:
+    static QBezier fromPoints(const QPointF &p1, const QPointF &p2,
+                              const QPointF &p3, const QPointF &p4);
+
+    static void coefficients(qreal t, qreal &a, qreal &b, qreal &c, qreal &d);
+
+    inline QPointF pointAt(qreal t) const;
+    inline QPointF normalVector(qreal t) const;
+
+    inline QPointF derivedAt(qreal t) const;
+    inline QPointF secondDerivedAt(qreal t) const;
+
+    QPolygonF toPolygon(qreal bezier_flattening_threshold = 0.5) const;
+    void addToPolygon(QPolygonF *p, qreal bezier_flattening_threshold = 0.5) const;
+
+    QRectF bounds() const;
+    qreal length(qreal error = 0.01) const;
+    void addIfClose(qreal *length, qreal error) const;
+
+    qreal tAtLength(qreal len) const;
+
+    int stationaryYPoints(qreal &t0, qreal &t1) const;
+    qreal tForY(qreal t0, qreal t1, qreal y) const;
+
+    QPointF pt1() const { return QPointF(x1, y1); }
+    QPointF pt2() const { return QPointF(x2, y2); }
+    QPointF pt3() const { return QPointF(x3, y3); }
+    QPointF pt4() const { return QPointF(x4, y4); }
+
+    QBezier mapBy(const QTransform &transform) const;
+
+    inline QPointF midPoint() const;
+    inline QLineF midTangent() const;
+
+    inline QLineF startTangent() const;
+    inline QLineF endTangent() const;
+
+    inline void parameterSplitLeft(qreal t, QBezier *left);
+    inline void split(QBezier *firstHalf, QBezier *secondHalf) const;
+
+    int shifted(QBezier *curveSegments, int maxSegmets,
+                qreal offset, float threshold) const;
+
+    QBezier bezierOnInterval(qreal t0, qreal t1) const;
+    QBezier getSubRange(qreal t0, qreal t1) const;
+
+    qreal x1, y1, x2, y2, x3, y3, x4, y4;
+};
+
+inline QPointF QBezier::midPoint() const
+{
+    return QPointF((x1 + x4 + 3*(x2 + x3))/8., (y1 + y4 + 3*(y2 + y3))/8.);
+}
+
+inline QLineF QBezier::midTangent() const
+{
+    QPointF mid = midPoint();
+    QLineF dir(QLineF(x1, y1, x2, y2).pointAt(0.5), QLineF(x3, y3, x4, y4).pointAt(0.5));
+    return QLineF(mid.x() - dir.dx(), mid.y() - dir.dy(),
+                  mid.x() + dir.dx(), mid.y() + dir.dy());
+}
+
+inline QLineF QBezier::startTangent() const
+{
+    QLineF tangent(pt1(), pt2());
+    if (tangent.isNull())
+        tangent = QLineF(pt1(), pt3());
+    if (tangent.isNull())
+        tangent = QLineF(pt1(), pt4());
+    return tangent;
+}
+
+inline QLineF QBezier::endTangent() const
+{
+    QLineF tangent(pt4(), pt3());
+    if (tangent.isNull())
+        tangent = QLineF(pt4(), pt2());
+    if (tangent.isNull())
+        tangent = QLineF(pt4(), pt1());
+    return tangent;
+}
+
+inline void QBezier::coefficients(qreal t, qreal &a, qreal &b, qreal &c, qreal &d)
+{
+    qreal m_t = 1. - t;
+    b = m_t * m_t;
+    c = t * t;
+    d = c * t;
+    a = b * m_t;
+    b *= 3. * t;
+    c *= 3. * m_t;
+}
+
+inline QPointF QBezier::pointAt(qreal t) const
+{
+#if 1
+    qreal a, b, c, d;
+    coefficients(t, a, b, c, d);
+    return QPointF(a*x1 + b*x2 + c*x3 + d*x4, a*y1 + b*y2 + c*y3 + d*y4);
+#else
+    // numerically more stable:
+    qreal m_t = 1. - t;
+    qreal a = x1*m_t + x2*t;
+    qreal b = x2*m_t + x3*t;
+    qreal c = x3*m_t + x4*t;
+    a = a*m_t + b*t;
+    b = b*m_t + c*t;
+    qreal x = a*m_t + b*t;
+    qreal a = y1*m_t + y2*t;
+    qreal b = y2*m_t + y3*t;
+    qreal c = y3*m_t + y4*t;
+    a = a*m_t + b*t;
+    b = b*m_t + c*t;
+    qreal y = a*m_t + b*t;
+    return QPointF(x, y);
+#endif
+}
+
+inline QPointF QBezier::normalVector(qreal t) const
+{
+    qreal m_t = 1. - t;
+    qreal a = m_t * m_t;
+    qreal b = t * m_t;
+    qreal c = t * t;
+
+    return QPointF((y2-y1) * a + (y3-y2) * b + (y4-y3) * c,  -(x2-x1) * a - (x3-x2) * b - (x4-x3) * c);
+}
+
+inline QPointF QBezier::derivedAt(qreal t) const
+{
+    // p'(t) = 3 * (-(1-2t+t^2) * p0 + (1 - 4 * t + 3 * t^2) * p1 + (2 * t - 3 * t^2) * p2 + t^2 * p3)
+
+    qreal m_t = 1. - t;
+
+    qreal d = t * t;
+    qreal a = -m_t * m_t;
+    qreal b = 1 - 4 * t + 3 * d;
+    qreal c = 2 * t - 3 * d;
+
+    return 3 * QPointF(a * x1 + b * x2 + c * x3 + d * x4,
+                       a * y1 + b * y2 + c * y3 + d * y4);
+}
+
+inline QPointF QBezier::secondDerivedAt(qreal t) const
+{
+    qreal a = 2. - 2. * t;
+    qreal b = -4 + 6 * t;
+    qreal c = 2 - 6 * t;
+    qreal d = 2 * t;
+
+    return 3 * QPointF(a * x1 + b * x2 + c * x3 + d * x4,
+                       a * y1 + b * y2 + c * y3 + d * y4);
+}
+
+inline void QBezier::split(QBezier *firstHalf, QBezier *secondHalf) const
+{
+    Q_ASSERT(firstHalf);
+    Q_ASSERT(secondHalf);
+
+    qreal c = (x2 + x3)*.5;
+    firstHalf->x2 = (x1 + x2)*.5;
+    secondHalf->x3 = (x3 + x4)*.5;
+    firstHalf->x1 = x1;
+    secondHalf->x4 = x4;
+    firstHalf->x3 = (firstHalf->x2 + c)*.5;
+    secondHalf->x2 = (secondHalf->x3 + c)*.5;
+    firstHalf->x4 = secondHalf->x1 = (firstHalf->x3 + secondHalf->x2)*.5;
+
+    c = (y2 + y3)/2;
+    firstHalf->y2 = (y1 + y2)*.5;
+    secondHalf->y3 = (y3 + y4)*.5;
+    firstHalf->y1 = y1;
+    secondHalf->y4 = y4;
+    firstHalf->y3 = (firstHalf->y2 + c)*.5;
+    secondHalf->y2 = (secondHalf->y3 + c)*.5;
+    firstHalf->y4 = secondHalf->y1 = (firstHalf->y3 + secondHalf->y2)*.5;
+}
+
+inline void QBezier::parameterSplitLeft(qreal t, QBezier *left)
+{
+    left->x1 = x1;
+    left->y1 = y1;
+
+    left->x2 = x1 + t * ( x2 - x1 );
+    left->y2 = y1 + t * ( y2 - y1 );
+
+    left->x3 = x2 + t * ( x3 - x2 ); // temporary holding spot
+    left->y3 = y2 + t * ( y3 - y2 ); // temporary holding spot
+
+    x3 = x3 + t * ( x4 - x3 );
+    y3 = y3 + t * ( y4 - y3 );
+
+    x2 = left->x3 + t * ( x3 - left->x3);
+    y2 = left->y3 + t * ( y3 - left->y3);
+
+    left->x3 = left->x2 + t * ( left->x3 - left->x2 );
+    left->y3 = left->y2 + t * ( left->y3 - left->y2 );
+
+    left->x4 = x1 = left->x3 + t * (x2 - left->x3);
+    left->y4 = y1 = left->y3 + t * (y2 - left->y3);
+}
+
+QT_END_NAMESPACE
+
+#endif // QBEZIER_P_H
diff --git a/src/gui/painting/qblendfunctions.cpp b/src/gui/painting/qblendfunctions.cpp
new file mode 100644
index 0000000000..10674f8ef5
--- /dev/null
+++ b/src/gui/painting/qblendfunctions.cpp
@@ -0,0 +1,1644 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <qmath.h>
+#include "qblendfunctions_p.h"
+
+QT_BEGIN_NAMESPACE
+
+struct SourceOnlyAlpha
+{
+    inline uchar alpha(uchar src) const { return src; }
+    inline quint16 bytemul(quint16 spix) const { return spix; }
+};
+
+
+struct SourceAndConstAlpha
+{
+    SourceAndConstAlpha(int a) : m_alpha256(a) {
+        m_alpha255 = (m_alpha256 * 255) >> 8;
+    };
+    inline uchar alpha(uchar src) const { return (src * m_alpha256) >> 8; }
+    inline quint16 bytemul(quint16 x) const {
+        uint t = (((x & 0x07e0)*m_alpha255) >> 8) & 0x07e0;
+        t |= (((x & 0xf81f)*(m_alpha255>>2)) >> 6) & 0xf81f;
+        return t;
+    }
+    int m_alpha255;
+    int m_alpha256;
+};
+
+
+/************************************************************************
+                       RGB16 (565) format target format
+ ************************************************************************/
+
+static inline quint16 convert_argb32_to_rgb16(quint32 spix)
+{
+    quint32 b = spix;
+    quint32 g = spix;
+    b >>= 8;
+    g >>= 5;
+    b &= 0x0000f800;
+    g &= 0x000007e0;
+    spix >>= 3;
+    b |= g;
+    spix &= 0x0000001f;
+    b |= spix;
+    return b;
+}
+
+struct Blend_RGB16_on_RGB16_NoAlpha {
+    inline void write(quint16 *dst, quint16 src) { *dst = src; }
+
+    inline void flush(void *) {}
+};
+
+struct Blend_RGB16_on_RGB16_ConstAlpha {
+    inline Blend_RGB16_on_RGB16_ConstAlpha(quint32 alpha) {
+        m_alpha = (alpha * 255) >> 8;
+        m_ialpha = 255 - m_alpha;
+    }
+
+    inline void write(quint16 *dst, quint16 src) {
+        *dst = BYTE_MUL_RGB16(src, m_alpha) + BYTE_MUL_RGB16(*dst, m_ialpha);
+    }
+
+    inline void flush(void *) {}
+
+    quint32 m_alpha;
+    quint32 m_ialpha;
+};
+
+struct Blend_ARGB24_on_RGB16_SourceAlpha {
+    inline void write(quint16 *dst, const qargb8565 &src) {
+        const uint alpha = src.alpha();
+        if (alpha) {
+            quint16 s = src.rawValue16();
+            if (alpha < 255)
+                s += BYTE_MUL_RGB16(*dst, 255 - alpha);
+            *dst = s;
+        }
+    }
+
+    inline void flush(void *) {}
+};
+
+struct Blend_ARGB24_on_RGB16_SourceAndConstAlpha {
+    inline Blend_ARGB24_on_RGB16_SourceAndConstAlpha(quint32 alpha) {
+        m_alpha = (alpha * 255) >> 8;
+    }
+
+    inline void write(quint16 *dst, qargb8565 src) {
+        src = src.byte_mul(src.alpha(m_alpha));
+        const uint alpha = src.alpha();
+        if (alpha) {
+            quint16 s = src.rawValue16();
+            if (alpha < 255)
+                s += BYTE_MUL_RGB16(*dst, 255 - alpha);
+            *dst = s;
+        }
+    }
+
+    inline void flush(void *) {}
+
+    quint32 m_alpha;
+};
+
+struct Blend_ARGB32_on_RGB16_SourceAlpha {
+    inline void write(quint16 *dst, quint32 src) {
+        const quint8 alpha = qAlpha(src);
+        if(alpha) {
+            quint16 s = convert_argb32_to_rgb16(src);
+            if(alpha < 255)
+                s += BYTE_MUL_RGB16(*dst, 255 - alpha);
+            *dst = s;
+        }
+    }
+
+    inline void flush(void *) {}
+};
+
+struct Blend_ARGB32_on_RGB16_SourceAndConstAlpha {
+    inline Blend_ARGB32_on_RGB16_SourceAndConstAlpha(quint32 alpha) {
+        m_alpha = (alpha * 255) >> 8;
+    }
+
+    inline void write(quint16 *dst, quint32 src) {
+        src = BYTE_MUL(src, m_alpha);
+        const quint8 alpha = qAlpha(src);
+        if(alpha) {
+            quint16 s = convert_argb32_to_rgb16(src);
+            if(alpha < 255)
+                s += BYTE_MUL_RGB16(*dst, 255 - alpha);
+            *dst = s;
+        }
+    }
+
+    inline void flush(void *) {}
+
+    quint32 m_alpha;
+};
+
+void qt_scale_image_rgb16_on_rgb16(uchar *destPixels, int dbpl,
+                                   const uchar *srcPixels, int sbpl,
+                                   const QRectF &targetRect,
+                                   const QRectF &sourceRect,
+                                   const QRect &clip,
+                                   int const_alpha)
+{
+#ifdef QT_DEBUG_DRAW
+    printf("qt_scale_rgb16_on_rgb16: dst=(%p, %d), src=(%p, %d), target=(%d, %d), [%d x %d], src=(%d, %d) [%d x %d] alpha=%d\n",
+           destPixels, dbpl, srcPixels, sbpl,
+           targetRect.x(), targetRect.y(), targetRect.width(), targetRect.height(),
+           sourceRect.x(), sourceRect.y(), sourceRect.width(), sourceRect.height(),
+           const_alpha);
+#endif
+    if (const_alpha == 256) {
+        Blend_RGB16_on_RGB16_NoAlpha noAlpha;
+        qt_scale_image_16bit<quint16>(destPixels, dbpl, srcPixels, sbpl,
+                                      targetRect, sourceRect, clip, noAlpha);
+    } else {
+        Blend_RGB16_on_RGB16_ConstAlpha constAlpha(const_alpha);
+        qt_scale_image_16bit<quint16>(destPixels, dbpl, srcPixels, sbpl,
+                                     targetRect, sourceRect, clip, constAlpha);
+    }
+}
+
+void qt_scale_image_argb24_on_rgb16(uchar *destPixels, int dbpl,
+                                   const uchar *srcPixels, int sbpl,
+                                   const QRectF &targetRect,
+                                   const QRectF &sourceRect,
+                                   const QRect &clip,
+                                   int const_alpha)
+{
+#ifdef QT_DEBUG_DRAW
+    printf("qt_scale_argb24_on_rgb16: dst=(%p, %d), src=(%p, %d), target=(%d, %d), [%d x %d], src=(%d, %d) [%d x %d] alpha=%d\n",
+           destPixels, dbpl, srcPixels, sbpl,
+           targetRect.x(), targetRect.y(), targetRect.width(), targetRect.height(),
+           sourceRect.x(), sourceRect.y(), sourceRect.width(), sourceRect.height(),
+           const_alpha);
+#endif
+    if (const_alpha == 256) {
+        Blend_ARGB24_on_RGB16_SourceAlpha noAlpha;
+        qt_scale_image_16bit<qargb8565>(destPixels, dbpl, srcPixels, sbpl,
+                                        targetRect, sourceRect, clip, noAlpha);
+    } else {
+        Blend_ARGB24_on_RGB16_SourceAndConstAlpha constAlpha(const_alpha);
+        qt_scale_image_16bit<qargb8565>(destPixels, dbpl, srcPixels, sbpl,
+                                        targetRect, sourceRect, clip, constAlpha);
+    }
+}
+
+
+void qt_scale_image_argb32_on_rgb16(uchar *destPixels, int dbpl,
+                                    const uchar *srcPixels, int sbpl,
+                                    const QRectF &targetRect,
+                                    const QRectF &sourceRect,
+                                    const QRect &clip,
+                                    int const_alpha)
+{
+#ifdef QT_DEBUG_DRAW
+    printf("qt_scale_argb32_on_rgb16: dst=(%p, %d), src=(%p, %d), target=(%d, %d), [%d x %d], src=(%d, %d) [%d x %d] alpha=%d\n",
+           destPixels, dbpl, srcPixels, sbpl,
+           targetRect.x(), targetRect.y(), targetRect.width(), targetRect.height(),
+           sourceRect.x(), sourceRect.y(), sourceRect.width(), sourceRect.height(),
+           const_alpha);
+#endif
+    if (const_alpha == 256) {
+        Blend_ARGB32_on_RGB16_SourceAlpha noAlpha;
+        qt_scale_image_16bit<quint32>(destPixels, dbpl, srcPixels, sbpl,
+                                      targetRect, sourceRect, clip, noAlpha);
+    } else {
+        Blend_ARGB32_on_RGB16_SourceAndConstAlpha constAlpha(const_alpha);
+        qt_scale_image_16bit<quint32>(destPixels, dbpl, srcPixels, sbpl,
+                                     targetRect, sourceRect, clip, constAlpha);
+    }
+}
+
+void qt_blend_rgb16_on_rgb16(uchar *dst, int dbpl,
+                             const uchar *src, int sbpl,
+                             int w, int h,
+                             int const_alpha)
+{
+#ifdef QT_DEBUG_DRAW
+    printf("qt_blend_rgb16_on_rgb16: dst=(%p, %d), src=(%p, %d), dim=(%d, %d) alpha=%d\n",
+           dst, dbpl, src, sbpl, w, h, const_alpha);
+#endif
+
+    if (const_alpha == 256) {
+        if (w <= 64) {
+            while (h--) {
+                QT_MEMCPY_USHORT(dst, src, w);
+                dst += dbpl;
+                src += sbpl;
+            }
+        } else {
+            int length = w << 1;
+            while (h--) {
+                memcpy(dst, src, length);
+                dst += dbpl;
+                src += sbpl;
+            }
+        }
+    } else if (const_alpha != 0) {
+        SourceAndConstAlpha alpha(const_alpha); // expects the 0-256 range
+        quint16 *d = (quint16 *) dst;
+        const quint16 *s = (const quint16 *) src;
+        quint8 a = (255 * const_alpha) >> 8;
+        quint8 ia = 255 - a;
+        while (h--) {
+            for (int x=0; x<w; ++x) {
+                d[x] = BYTE_MUL_RGB16(s[x], a) + BYTE_MUL_RGB16(d[x], ia);
+            }
+            d = (quint16 *)(((uchar *) d) + dbpl);
+            s = (const quint16 *)(((const uchar *) s) + sbpl);
+        }
+    }
+}
+
+
+template <typename T> void qt_blend_argb24_on_rgb16(uchar *destPixels, int dbpl,
+                                                    const uchar *srcPixels, int sbpl,
+                                                    int w, int h, const T &alphaFunc)
+{
+    int srcOffset = w*3;
+    int dstJPL = dbpl / 2;
+    quint16 *dst = (quint16 *) destPixels;
+    int dstExtraStride = dstJPL - w;
+
+    for (int y=0; y<h; ++y) {
+        const uchar *src = srcPixels + y * sbpl;
+        const uchar *srcEnd = src + srcOffset;
+        while (src < srcEnd) {
+#if defined(QT_ARCH_ARMV5) || defined(QT_ARCH_POWERPC) || defined(QT_ARCH_SH) || defined(QT_ARCH_AVR32) || (defined(QT_ARCH_WINDOWSCE) && !defined(_X86_)) || (defined(QT_ARCH_SPARC) && defined(Q_CC_GNU)) || (defined(QT_ARCH_INTEGRITY) && !defined(_X86_))
+            // non-16-bit aligned memory access is not possible on PowerPC,
+            // ARM <v6 (QT_ARCH_ARMV5) & SH & AVR32 & SPARC w/GCC
+            quint16 spix = (quint16(src[2])<<8) + src[1];
+#else
+            quint16 spix = *(quint16 *) (src + 1);
+#endif
+            uchar alpha = alphaFunc.alpha(*src);
+
+            if (alpha == 255) {
+                *dst = spix;
+            } else if (alpha != 0) {
+                quint16 dpix = *dst;
+                quint32 sia = 255 - alpha;
+
+                quint16 dr = (dpix & 0x0000f800);
+                quint16 dg = (dpix & 0x000007e0);
+                quint16 db = (dpix & 0x0000001f);
+
+                quint32 siar = dr * sia;
+                quint32 siag = dg * sia;
+                quint32 siab = db * sia;
+
+                quint32 rr = ((siar + (siar>>8) + (0x80 <<  8)) >> 8) & 0xf800;
+                quint32 rg = ((siag + (siag>>8) + (0x80 <<  3)) >> 8) & 0x07e0;
+                quint32 rb = ((siab + (siab>>8) + (0x80 >>  3)) >> 8) & 0x001f;
+
+                *dst = alphaFunc.bytemul(spix) + rr + rg + rb;
+            }
+
+            ++dst;
+            src += 3;
+        }
+        dst += dstExtraStride;
+    }
+
+}
+
+static void qt_blend_argb24_on_rgb16(uchar *destPixels, int dbpl,
+                                     const uchar *srcPixels, int sbpl,
+                                     int w, int h,
+                                     int const_alpha)
+{
+#ifdef QT_DEBUG_DRAW
+    printf("qt_blend_argb24_on_rgb16: dst=(%p, %d), src=(%p, %d), dim=(%d, %d) alpha=%d\n",
+           destPixels, dbpl, srcPixels, sbpl, w, h, const_alpha);
+#endif
+
+    if (const_alpha != 256) {
+        SourceAndConstAlpha alphaFunc(const_alpha);
+        qt_blend_argb24_on_rgb16(destPixels, dbpl, srcPixels, sbpl, w, h, alphaFunc);
+    } else {
+        SourceOnlyAlpha alphaFunc;
+        qt_blend_argb24_on_rgb16(destPixels, dbpl, srcPixels, sbpl, w, h, alphaFunc);
+    }
+}
+
+
+
+
+void qt_blend_argb32_on_rgb16_const_alpha(uchar *destPixels, int dbpl,
+                                          const uchar *srcPixels, int sbpl,
+                                          int w, int h,
+                                          int const_alpha)
+{
+    quint16 *dst = (quint16 *) destPixels;
+    const quint32 *src = (const quint32 *) srcPixels;
+
+    const_alpha = (const_alpha * 255) >> 8;
+    for (int y=0; y<h; ++y) {
+        for (int i = 0; i < w; ++i) {
+            uint s = src[i];
+            s = BYTE_MUL(s, const_alpha);
+            int alpha = qAlpha(s);
+            s = convert_argb32_to_rgb16(s);
+            s += BYTE_MUL_RGB16(dst[i], 255 - alpha);
+            dst[i] = s;
+        }
+        dst = (quint16 *)(((uchar *) dst) + dbpl);
+        src = (const quint32 *)(((const uchar *) src) + sbpl);
+    }
+}
+
+static void qt_blend_argb32_on_rgb16(uchar *destPixels, int dbpl,
+                                     const uchar *srcPixels, int sbpl,
+                                     int w, int h,
+                                     int const_alpha)
+{
+    if (const_alpha != 256) {
+        qt_blend_argb32_on_rgb16_const_alpha(destPixels, dbpl, srcPixels, sbpl, w, h, const_alpha);
+        return;
+    }
+
+    quint16 *dst = (quint16 *) destPixels;
+    quint32 *src = (quint32 *) srcPixels;
+
+    for (int y=0; y<h; ++y) {
+        for (int x=0; x<w; ++x) {
+
+            quint32 spix = src[x];
+            quint32 alpha = spix >> 24;
+
+            if (alpha == 255) {
+                dst[x] = convert_argb32_to_rgb16(spix);
+            } else if (alpha != 0) {
+                quint32 dpix = dst[x];
+
+                quint32 sia = 255 - alpha;
+
+                quint32 sr = (spix >> 8) & 0xf800;
+                quint32 sg = (spix >> 5) & 0x07e0;
+                quint32 sb = (spix >> 3) & 0x001f;
+
+                quint32 dr = (dpix & 0x0000f800);
+                quint32 dg = (dpix & 0x000007e0);
+                quint32 db = (dpix & 0x0000001f);
+
+                quint32 siar = dr * sia;
+                quint32 siag = dg * sia;
+                quint32 siab = db * sia;
+
+                quint32 rr = sr + ((siar + (siar>>8) + (0x80 << 8)) >> 8);
+                quint32 rg = sg + ((siag + (siag>>8) + (0x80 << 3)) >> 8);
+                quint32 rb = sb + ((siab + (siab>>8) + (0x80 >> 3)) >> 8);
+
+                dst[x] = (rr & 0xf800)
+                         | (rg & 0x07e0)
+                         | (rb);
+            }
+        }
+        dst = (quint16 *) (((uchar *) dst) + dbpl);
+        src = (quint32 *) (((uchar *) src) + sbpl);
+    }
+}
+
+
+static void qt_blend_rgb32_on_rgb16(uchar *destPixels, int dbpl,
+                                    const uchar *srcPixels, int sbpl,
+                                    int w, int h,
+                                    int const_alpha)
+{
+#ifdef QT_DEBUG_DRAW
+    printf("qt_blend_rgb32_on_rgb16: dst=(%p, %d), src=(%p, %d), dim=(%d, %d) alpha=%d\n",
+           destPixels, dbpl, srcPixels, sbpl, w, h, const_alpha);
+#endif
+
+    if (const_alpha != 256) {
+        qt_blend_argb32_on_rgb16(destPixels, dbpl, srcPixels, sbpl, w, h, const_alpha);
+        return;
+    }
+
+    const quint32 *src = (const quint32 *) srcPixels;
+    int srcExtraStride = (sbpl >> 2) - w;
+
+    int dstJPL = dbpl / 2;
+
+    quint16 *dst = (quint16 *) destPixels;
+    quint16 *dstEnd = dst + dstJPL * h;
+
+    int dstExtraStride = dstJPL - w;
+
+    while (dst < dstEnd) {
+        const quint32 *srcEnd = src + w;
+        while (src < srcEnd) {
+            *dst = convert_argb32_to_rgb16(*src);
+            ++dst;
+            ++src;
+        }
+        dst += dstExtraStride;
+        src += srcExtraStride;
+    }
+}
+
+
+
+/************************************************************************
+                       RGB32 (-888) format target format
+ ************************************************************************/
+
+static void qt_blend_argb32_on_argb32(uchar *destPixels, int dbpl,
+                                      const uchar *srcPixels, int sbpl,
+                                      int w, int h,
+                                      int const_alpha)
+{
+#ifdef QT_DEBUG_DRAW
+    fprintf(stdout, "qt_blend_argb32_on_argb32: dst=(%p, %d), src=(%p, %d), dim=(%d, %d) alpha=%d\n",
+            destPixels, dbpl, srcPixels, sbpl, w, h, const_alpha);
+    fflush(stdout);
+#endif
+
+    const uint *src = (const uint *) srcPixels;
+    uint *dst = (uint *) destPixels;
+    if (const_alpha == 256) {
+        for (int y=0; y<h; ++y) {
+            for (int x=0; x<w; ++x) {
+                uint s = src[x];
+                if (s >= 0xff000000)
+                    dst[x] = s;
+                else if (s != 0)
+                    dst[x] = s + BYTE_MUL(dst[x], qAlpha(~s));
+            }
+            dst = (quint32 *)(((uchar *) dst) + dbpl);
+            src = (const quint32 *)(((const uchar *) src) + sbpl);
+        }
+    } else if (const_alpha != 0) {
+        const_alpha = (const_alpha * 255) >> 8;
+        for (int y=0; y<h; ++y) {
+            for (int x=0; x<w; ++x) {
+                uint s = BYTE_MUL(src[x], const_alpha);
+                dst[x] = s + BYTE_MUL(dst[x], qAlpha(~s));
+            }
+            dst = (quint32 *)(((uchar *) dst) + dbpl);
+            src = (const quint32 *)(((const uchar *) src) + sbpl);
+        }
+    }
+}
+
+
+void qt_blend_rgb32_on_rgb32(uchar *destPixels, int dbpl,
+                             const uchar *srcPixels, int sbpl,
+                             int w, int h,
+                             int const_alpha)
+{
+#ifdef QT_DEBUG_DRAW
+    fprintf(stdout, "qt_blend_rgb32_on_rgb32: dst=(%p, %d), src=(%p, %d), dim=(%d, %d) alpha=%d\n",
+            destPixels, dbpl, srcPixels, sbpl, w, h, const_alpha);
+    fflush(stdout);
+#endif
+
+    if (const_alpha != 256) {
+        qt_blend_argb32_on_argb32(destPixels, dbpl, srcPixels, sbpl, w, h, const_alpha);
+        return;
+    }
+
+    const uint *src = (const uint *) srcPixels;
+    uint *dst = (uint *) destPixels;
+    if (w <= 64) {
+        for (int y=0; y<h; ++y) {
+            qt_memconvert(dst, src, w);
+            dst = (quint32 *)(((uchar *) dst) + dbpl);
+            src = (const quint32 *)(((const uchar *) src) + sbpl);
+        }
+    } else {
+        int len = w * 4;
+        for (int y=0; y<h; ++y) {
+            memcpy(dst, src, len);
+            dst = (quint32 *)(((uchar *) dst) + dbpl);
+            src = (const quint32 *)(((const uchar *) src) + sbpl);
+        }
+    }
+}
+
+
+
+struct Blend_RGB32_on_RGB32_NoAlpha {
+    inline void write(quint32 *dst, quint32 src) { *dst = src; }
+
+    inline void flush(void *) {}
+};
+
+struct Blend_RGB32_on_RGB32_ConstAlpha {
+    inline Blend_RGB32_on_RGB32_ConstAlpha(quint32 alpha) {
+        m_alpha = (alpha * 255) >> 8;
+        m_ialpha = 255 - m_alpha;
+    }
+
+    inline void write(quint32 *dst, quint32 src) {
+        *dst = BYTE_MUL(src, m_alpha) + BYTE_MUL(*dst, m_ialpha);
+    }
+
+    inline void flush(void *) {}
+
+    quint32 m_alpha;
+    quint32 m_ialpha;
+};
+
+struct Blend_ARGB32_on_ARGB32_SourceAlpha {
+    inline void write(quint32 *dst, quint32 src) {
+        *dst = src + BYTE_MUL(*dst, qAlpha(~src));
+    }
+
+    inline void flush(void *) {}
+};
+
+struct Blend_ARGB32_on_ARGB32_SourceAndConstAlpha {
+    inline Blend_ARGB32_on_ARGB32_SourceAndConstAlpha(quint32 alpha) {
+        m_alpha = (alpha * 255) >> 8;
+        m_ialpha = 255 - m_alpha;
+    }
+
+    inline void write(quint32 *dst, quint32 src) {
+        src = BYTE_MUL(src, m_alpha);
+        *dst = src + BYTE_MUL(*dst, qAlpha(~src));
+    }
+
+    inline void flush(void *) {}
+
+    quint32 m_alpha;
+    quint32 m_ialpha;
+};
+
+void qt_scale_image_rgb32_on_rgb32(uchar *destPixels, int dbpl,
+                                   const uchar *srcPixels, int sbpl,
+                                   const QRectF &targetRect,
+                                   const QRectF &sourceRect,
+                                   const QRect &clip,
+                                   int const_alpha)
+{
+#ifdef QT_DEBUG_DRAW
+    printf("qt_scale_rgb32_on_rgb32: dst=(%p, %d), src=(%p, %d), target=(%d, %d), [%d x %d], src=(%d, %d) [%d x %d] alpha=%d\n",
+           destPixels, dbpl, srcPixels, sbpl,
+           targetRect.x(), targetRect.y(), targetRect.width(), targetRect.height(),
+           sourceRect.x(), sourceRect.y(), sourceRect.width(), sourceRect.height(),
+           const_alpha);
+#endif
+    if (const_alpha == 256) {
+        Blend_RGB32_on_RGB32_NoAlpha noAlpha;
+        qt_scale_image_32bit(destPixels, dbpl, srcPixels, sbpl,
+                             targetRect, sourceRect, clip, noAlpha);
+    } else {
+        Blend_RGB32_on_RGB32_ConstAlpha constAlpha(const_alpha);
+        qt_scale_image_32bit(destPixels, dbpl, srcPixels, sbpl,
+                             targetRect, sourceRect, clip, constAlpha);
+    }
+}
+
+void qt_scale_image_argb32_on_argb32(uchar *destPixels, int dbpl,
+                                     const uchar *srcPixels, int sbpl,
+                                     const QRectF &targetRect,
+                                     const QRectF &sourceRect,
+                                     const QRect &clip,
+                                     int const_alpha)
+{
+#ifdef QT_DEBUG_DRAW
+    printf("qt_scale_argb32_on_argb32: dst=(%p, %d), src=(%p, %d), target=(%d, %d), [%d x %d], src=(%d, %d) [%d x %d] alpha=%d\n",
+           destPixels, dbpl, srcPixels, sbpl,
+           targetRect.x(), targetRect.y(), targetRect.width(), targetRect.height(),
+           sourceRect.x(), sourceRect.y(), sourceRect.width(), sourceRect.height(),
+           const_alpha);
+#endif
+    if (const_alpha == 256) {
+        Blend_ARGB32_on_ARGB32_SourceAlpha sourceAlpha;
+        qt_scale_image_32bit(destPixels, dbpl, srcPixels, sbpl,
+                             targetRect, sourceRect, clip, sourceAlpha);
+    } else {
+        Blend_ARGB32_on_ARGB32_SourceAndConstAlpha constAlpha(const_alpha);
+        qt_scale_image_32bit(destPixels, dbpl, srcPixels, sbpl,
+                             targetRect, sourceRect, clip, constAlpha);
+    }
+}
+
+void qt_transform_image_rgb16_on_rgb16(uchar *destPixels, int dbpl,
+                                       const uchar *srcPixels, int sbpl,
+                                       const QRectF &targetRect,
+                                       const QRectF &sourceRect,
+                                       const QRect &clip,
+                                       const QTransform &targetRectTransform,
+                                       int const_alpha)
+{
+    if (const_alpha == 256) {
+        Blend_RGB16_on_RGB16_NoAlpha noAlpha;
+        qt_transform_image(reinterpret_cast<quint16 *>(destPixels), dbpl,
+                           reinterpret_cast<const quint16 *>(srcPixels), sbpl,
+                           targetRect, sourceRect, clip, targetRectTransform, noAlpha);
+    } else {
+        Blend_RGB16_on_RGB16_ConstAlpha constAlpha(const_alpha);
+        qt_transform_image(reinterpret_cast<quint16 *>(destPixels), dbpl,
+                           reinterpret_cast<const quint16 *>(srcPixels), sbpl,
+                           targetRect, sourceRect, clip, targetRectTransform, constAlpha);
+    }
+}
+
+void qt_transform_image_argb24_on_rgb16(uchar *destPixels, int dbpl,
+                                        const uchar *srcPixels, int sbpl,
+                                        const QRectF &targetRect,
+                                        const QRectF &sourceRect,
+                                        const QRect &clip,
+                                        const QTransform &targetRectTransform,
+                                        int const_alpha)
+{
+    if (const_alpha == 256) {
+        Blend_ARGB24_on_RGB16_SourceAlpha noAlpha;
+        qt_transform_image(reinterpret_cast<quint16 *>(destPixels), dbpl,
+                           reinterpret_cast<const qargb8565 *>(srcPixels), sbpl,
+                           targetRect, sourceRect, clip, targetRectTransform, noAlpha);
+    } else {
+        Blend_ARGB24_on_RGB16_SourceAndConstAlpha constAlpha(const_alpha);
+        qt_transform_image(reinterpret_cast<quint16 *>(destPixels), dbpl,
+                           reinterpret_cast<const qargb8565 *>(srcPixels), sbpl,
+                           targetRect, sourceRect, clip, targetRectTransform, constAlpha);
+    }
+}
+
+
+void qt_transform_image_argb32_on_rgb16(uchar *destPixels, int dbpl,
+                                        const uchar *srcPixels, int sbpl,
+                                        const QRectF &targetRect,
+                                        const QRectF &sourceRect,
+                                        const QRect &clip,
+                                        const QTransform &targetRectTransform,
+                                        int const_alpha)
+{
+    if (const_alpha == 256) {
+        Blend_ARGB32_on_RGB16_SourceAlpha noAlpha;
+        qt_transform_image(reinterpret_cast<quint16 *>(destPixels), dbpl,
+                           reinterpret_cast<const quint32 *>(srcPixels), sbpl,
+                           targetRect, sourceRect, clip, targetRectTransform, noAlpha);
+    } else {
+        Blend_ARGB32_on_RGB16_SourceAndConstAlpha constAlpha(const_alpha);
+        qt_transform_image(reinterpret_cast<quint16 *>(destPixels), dbpl,
+                           reinterpret_cast<const quint32 *>(srcPixels), sbpl,
+                           targetRect, sourceRect, clip, targetRectTransform, constAlpha);
+    }
+}
+
+
+void qt_transform_image_rgb32_on_rgb32(uchar *destPixels, int dbpl,
+                                       const uchar *srcPixels, int sbpl,
+                                       const QRectF &targetRect,
+                                       const QRectF &sourceRect,
+                                       const QRect &clip,
+                                       const QTransform &targetRectTransform,
+                                       int const_alpha)
+{
+    if (const_alpha == 256) {
+        Blend_RGB32_on_RGB32_NoAlpha noAlpha;
+        qt_transform_image(reinterpret_cast<quint32 *>(destPixels), dbpl,
+                           reinterpret_cast<const quint32 *>(srcPixels), sbpl,
+                           targetRect, sourceRect, clip, targetRectTransform, noAlpha);
+    } else {
+        Blend_RGB32_on_RGB32_ConstAlpha constAlpha(const_alpha);
+        qt_transform_image(reinterpret_cast<quint32 *>(destPixels), dbpl,
+                           reinterpret_cast<const quint32 *>(srcPixels), sbpl,
+                           targetRect, sourceRect, clip, targetRectTransform, constAlpha);
+    }
+}
+
+void qt_transform_image_argb32_on_argb32(uchar *destPixels, int dbpl,
+                                         const uchar *srcPixels, int sbpl,
+                                         const QRectF &targetRect,
+                                         const QRectF &sourceRect,
+                                         const QRect &clip,
+                                         const QTransform &targetRectTransform,
+                                         int const_alpha)
+{
+    if (const_alpha == 256) {
+        Blend_ARGB32_on_ARGB32_SourceAlpha sourceAlpha;
+        qt_transform_image(reinterpret_cast<quint32 *>(destPixels), dbpl,
+                           reinterpret_cast<const quint32 *>(srcPixels), sbpl,
+                           targetRect, sourceRect, clip, targetRectTransform, sourceAlpha);
+    } else {
+        Blend_ARGB32_on_ARGB32_SourceAndConstAlpha constAlpha(const_alpha);
+        qt_transform_image(reinterpret_cast<quint32 *>(destPixels), dbpl,
+                           reinterpret_cast<const quint32 *>(srcPixels), sbpl,
+                           targetRect, sourceRect, clip, targetRectTransform, constAlpha);
+    }
+}
+
+SrcOverScaleFunc qScaleFunctions[QImage::NImageFormats][QImage::NImageFormats] = {
+    {   // Format_Invalid
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        0,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        0,      // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_Mono
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        0,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        0,      // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_MonoLSB
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        0,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        0,      // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_Indexed8
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        0,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        0,      // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_RGB32
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        qt_scale_image_rgb32_on_rgb32,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        qt_scale_image_argb32_on_argb32,    // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_ARGB32
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        0,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        0,      // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_ARGB32_Premultiplied
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        qt_scale_image_rgb32_on_rgb32,          // Format_RGB32,
+        0,      // Format_ARGB32,
+        qt_scale_image_argb32_on_argb32,        // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_RGB16
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        0,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        qt_scale_image_argb32_on_rgb16,       // Format_ARGB32_Premultiplied,
+        qt_scale_image_rgb16_on_rgb16,        // Format_RGB16,
+        qt_scale_image_argb24_on_rgb16,       // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_ARGB8565_Premultiplied
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        0,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        0,      // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_RGB666
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        0,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        0,      // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_ARGB6666_Premultiplied
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        0,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        0,      // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_RGB555
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        0,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        0,      // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_ARGB8555_Premultiplied
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        0,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        0,      // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_RGB888
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        0,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        0,      // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_RGB444
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        0,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        0,      // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_ARGB4444_Premultiplied
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        0,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        0,      // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    }
+};
+
+
+SrcOverBlendFunc qBlendFunctions[QImage::NImageFormats][QImage::NImageFormats] = {
+    {   // Format_Invalid
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        0,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        0,      // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_Mono
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        0,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        0,      // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_MonoLSB
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        0,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        0,      // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_Indexed8
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        0,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        0,      // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_RGB32
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        qt_blend_rgb32_on_rgb32,        // Format_RGB32,
+        0,      // Format_ARGB32,
+        qt_blend_argb32_on_argb32,      // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_ARGB32
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        0,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        0,      // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_ARGB32_Premultiplied
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        qt_blend_rgb32_on_rgb32,        // Format_RGB32,
+        0,      // Format_ARGB32,
+        qt_blend_argb32_on_argb32,      // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_RGB16
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        qt_blend_rgb32_on_rgb16,  // Format_RGB32,
+        0,      // Format_ARGB32,
+        qt_blend_argb32_on_rgb16, // Format_ARGB32_Premultiplied,
+        qt_blend_rgb16_on_rgb16,  // Format_RGB16,
+        qt_blend_argb24_on_rgb16, // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_ARGB8565_Premultiplied
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        0,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        0,      // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_RGB666
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        0,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        0,      // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_ARGB6666_Premultiplied
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        0,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        0,      // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_RGB555
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        0,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        0,      // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_ARGB8555_Premultiplied
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        0,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        0,      // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_RGB888
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        0,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        0,      // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_RGB444
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        0,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        0,      // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_ARGB4444_Premultiplied
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        0,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        0,      // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    }
+};
+
+SrcOverTransformFunc qTransformFunctions[QImage::NImageFormats][QImage::NImageFormats] = {
+    {   // Format_Invalid
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        0,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        0,      // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_Mono
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        0,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        0,      // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_MonoLSB
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        0,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        0,      // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_Indexed8
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        0,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        0,      // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_RGB32
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        qt_transform_image_rgb32_on_rgb32,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        qt_transform_image_argb32_on_argb32,    // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_ARGB32
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        0,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        0,      // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_ARGB32_Premultiplied
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        qt_transform_image_rgb32_on_rgb32,          // Format_RGB32,
+        0,      // Format_ARGB32,
+        qt_transform_image_argb32_on_argb32,        // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_RGB16
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        0,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        qt_transform_image_argb32_on_rgb16,       // Format_ARGB32_Premultiplied,
+        qt_transform_image_rgb16_on_rgb16,        // Format_RGB16,
+        qt_transform_image_argb24_on_rgb16,       // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_ARGB8565_Premultiplied
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        0,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        0,      // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_RGB666
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        0,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        0,      // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_ARGB6666_Premultiplied
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        0,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        0,      // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_RGB555
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        0,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        0,      // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_ARGB8555_Premultiplied
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        0,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        0,      // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_RGB888
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        0,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        0,      // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_RGB444
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        0,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        0,      // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    },
+    {   // Format_ARGB4444_Premultiplied
+        0,      // Format_Invalid,
+        0,      // Format_Mono,
+        0,      // Format_MonoLSB,
+        0,      // Format_Indexed8,
+        0,      // Format_RGB32,
+        0,      // Format_ARGB32,
+        0,      // Format_ARGB32_Premultiplied,
+        0,      // Format_RGB16,
+        0,      // Format_ARGB8565_Premultiplied,
+        0,      // Format_RGB666,
+        0,      // Format_ARGB6666_Premultiplied,
+        0,      // Format_RGB555,
+        0,      // Format_ARGB8555_Premultiplied,
+        0,      // Format_RGB888,
+        0,      // Format_RGB444,
+        0       // Format_ARGB4444_Premultiplied,
+    }
+};
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qblendfunctions_p.h b/src/gui/painting/qblendfunctions_p.h
new file mode 100644
index 0000000000..81f8b70caa
--- /dev/null
+++ b/src/gui/painting/qblendfunctions_p.h
@@ -0,0 +1,497 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QBLENDFUNCTIONS_P_H
+#define QBLENDFUNCTIONS_P_H
+
+#include <qmath.h>
+#include "qdrawhelper_p.h"
+
+QT_BEGIN_NAMESPACE
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+template <typename SRC, typename T>
+void qt_scale_image_16bit(uchar *destPixels, int dbpl,
+                          const uchar *srcPixels, int sbpl,
+                          const QRectF &targetRect,
+                          const QRectF &srcRect,
+                          const QRect &clip,
+                          T blender)
+{
+    qreal sx = targetRect.width() / (qreal) srcRect.width();
+    qreal sy = targetRect.height() / (qreal) srcRect.height();
+
+    int ix = 0x00010000 / sx;
+    int iy = 0x00010000 / sy;
+
+//     qDebug() << "scale:" << endl
+//              << " - target" << targetRect << endl
+//              << " - source" << srcRect << endl
+//              << " - clip" << clip << endl
+//              << " - sx=" << sx << " sy=" << sy << " ix=" << ix << " iy=" << iy;
+
+    int cx1 = clip.x();
+    int cx2 = clip.x() + clip.width();
+    int cy1 = clip.top();
+    int cy2 = clip.y() + clip.height();
+
+    int tx1 = qRound(targetRect.left());
+    int tx2 = qRound(targetRect.right());
+    int ty1 = qRound(targetRect.top());
+    int ty2 = qRound(targetRect.bottom());
+
+    if (tx2 < tx1)
+        qSwap(tx2, tx1);
+
+    if (ty2 < ty1)
+        qSwap(ty2, ty1);
+
+    if (tx1 < cx1)
+        tx1 = cx1;
+
+    if (tx2 >= cx2)
+        tx2 = cx2;
+
+    if (tx1 >= tx2)
+        return;
+
+    if (ty1 < cy1)
+        ty1 = cy1;
+
+    if (ty2 >= cy2)
+       ty2 = cy2;
+
+    if (ty1 >= ty2)
+        return;
+
+    int h = ty2 - ty1;
+    int w = tx2 - tx1;
+
+
+    quint32 basex;
+    quint32 srcy;
+
+    if (sx < 0) {
+        int dstx = qFloor((tx1 + qreal(0.5) - targetRect.right()) * ix) + 1;
+        basex = quint32(srcRect.right() * 65536) + dstx;
+    } else {
+        int dstx = qCeil((tx1 + qreal(0.5) - targetRect.left()) * ix) - 1;
+        basex = quint32(srcRect.left() * 65536) + dstx;
+    }
+    if (sy < 0) {
+        int dsty = qFloor((ty1 + qreal(0.5) - targetRect.bottom()) * iy) + 1;
+        srcy = quint32(srcRect.bottom() * 65536) + dsty;
+    } else {
+        int dsty = qCeil((ty1 + qreal(0.5) - targetRect.top()) * iy) - 1;
+        srcy = quint32(srcRect.top() * 65536) + dsty;
+    }
+
+    quint16 *dst = ((quint16 *) (destPixels + ty1 * dbpl)) + tx1;
+
+    while (h--) {
+        const SRC *src = (const SRC *) (srcPixels + (srcy >> 16) * sbpl);
+        int srcx = basex;
+        int x = 0;
+        for (; x<w-7; x+=8) {
+            blender.write(&dst[x], src[srcx >> 16]); srcx += ix;
+            blender.write(&dst[x+1], src[srcx >> 16]); srcx += ix;
+            blender.write(&dst[x+2], src[srcx >> 16]); srcx += ix;
+            blender.write(&dst[x+3], src[srcx >> 16]); srcx += ix;
+            blender.write(&dst[x+4], src[srcx >> 16]); srcx += ix;
+            blender.write(&dst[x+5], src[srcx >> 16]); srcx += ix;
+            blender.write(&dst[x+6], src[srcx >> 16]); srcx += ix;
+            blender.write(&dst[x+7], src[srcx >> 16]); srcx += ix;
+        }
+        for (; x<w; ++x) {
+            blender.write(&dst[x], src[srcx >> 16]);
+            srcx += ix;
+        }
+        blender.flush(&dst[x]);
+        dst = (quint16 *)(((uchar *) dst) + dbpl);
+        srcy += iy;
+    }
+}
+
+template <typename T> void qt_scale_image_32bit(uchar *destPixels, int dbpl,
+                                                const uchar *srcPixels, int sbpl,
+                                                const QRectF &targetRect,
+                                                const QRectF &srcRect,
+                                                const QRect &clip,
+                                                T blender)
+{
+    qreal sx = targetRect.width() / (qreal) srcRect.width();
+    qreal sy = targetRect.height() / (qreal) srcRect.height();
+
+    int ix = 0x00010000 / sx;
+    int iy = 0x00010000 / sy;
+
+//     qDebug() << "scale:" << endl
+//              << " - target" << targetRect << endl
+//              << " - source" << srcRect << endl
+//              << " - clip" << clip << endl
+//              << " - sx=" << sx << " sy=" << sy << " ix=" << ix << " iy=" << iy;
+
+    int cx1 = clip.x();
+    int cx2 = clip.x() + clip.width();
+    int cy1 = clip.top();
+    int cy2 = clip.y() + clip.height();
+
+    int tx1 = qRound(targetRect.left());
+    int tx2 = qRound(targetRect.right());
+    int ty1 = qRound(targetRect.top());
+    int ty2 = qRound(targetRect.bottom());
+
+    if (tx2 < tx1)
+        qSwap(tx2, tx1);
+
+    if (ty2 < ty1)
+        qSwap(ty2, ty1);
+
+    if (tx1 < cx1)
+        tx1 = cx1;
+
+    if (tx2 >= cx2)
+        tx2 = cx2;
+
+    if (tx1 >= tx2)
+        return;
+
+    if (ty1 < cy1)
+        ty1 = cy1;
+
+    if (ty2 >= cy2)
+       ty2 = cy2;
+
+    if (ty1 >= ty2)
+        return;
+
+    int h = ty2 - ty1;
+    int w = tx2 - tx1;
+
+    quint32 basex;
+    quint32 srcy;
+
+    if (sx < 0) {
+        int dstx = qFloor((tx1 + qreal(0.5) - targetRect.right()) * ix) + 1;
+        basex = quint32(srcRect.right() * 65536) + dstx;
+    } else {
+        int dstx = qCeil((tx1 + qreal(0.5) - targetRect.left()) * ix) - 1;
+        basex = quint32(srcRect.left() * 65536) + dstx;
+    }
+    if (sy < 0) {
+        int dsty = qFloor((ty1 + qreal(0.5) - targetRect.bottom()) * iy) + 1;
+        srcy = quint32(srcRect.bottom() * 65536) + dsty;
+    } else {
+        int dsty = qCeil((ty1 + qreal(0.5) - targetRect.top()) * iy) - 1;
+        srcy = quint32(srcRect.top() * 65536) + dsty;
+    }
+
+    quint32 *dst = ((quint32 *) (destPixels + ty1 * dbpl)) + tx1;
+
+    while (h--) {
+        const uint *src = (const quint32 *) (srcPixels + (srcy >> 16) * sbpl);
+        int srcx = basex;
+        int x = 0;
+        for (; x<w; ++x) {
+            blender.write(&dst[x], src[srcx >> 16]);
+            srcx += ix;
+        }
+        blender.flush(&dst[x]);
+        dst = (quint32 *)(((uchar *) dst) + dbpl);
+        srcy += iy;
+    }
+}
+
+struct QTransformImageVertex
+{
+    qreal x, y, u, v; // destination coordinates (x, y) and source coordinates (u, v)
+};
+
+template <class SrcT, class DestT, class Blender>
+void qt_transform_image_rasterize(DestT *destPixels, int dbpl,
+                                  const SrcT *srcPixels, int sbpl,
+                                  const QTransformImageVertex &topLeft, const QTransformImageVertex &bottomLeft,
+                                  const QTransformImageVertex &topRight, const QTransformImageVertex &bottomRight,
+                                  const QRect &sourceRect,
+                                  const QRect &clip,
+                                  qreal topY, qreal bottomY,
+                                  int dudx, int dvdx, int dudy, int dvdy, int u0, int v0,
+                                  Blender blender)
+{
+    int fromY = qMax(qRound(topY), clip.top());
+    int toY = qMin(qRound(bottomY), clip.top() + clip.height());
+    if (fromY >= toY)
+        return;
+
+    qreal leftSlope = (bottomLeft.x - topLeft.x) / (bottomLeft.y - topLeft.y);
+    qreal rightSlope = (bottomRight.x - topRight.x) / (bottomRight.y - topRight.y);
+    int dx_l = int(leftSlope * 0x10000);
+    int dx_r = int(rightSlope * 0x10000);
+    int x_l = int((topLeft.x + (qreal(0.5) + fromY - topLeft.y) * leftSlope + qreal(0.5)) * 0x10000);
+    int x_r = int((topRight.x + (qreal(0.5) + fromY - topRight.y) * rightSlope + qreal(0.5)) * 0x10000);
+
+    int fromX, toX, x1, x2, u, v, i, ii;
+    DestT *line;
+    for (int y = fromY; y < toY; ++y) {
+        line = reinterpret_cast<DestT *>(reinterpret_cast<uchar *>(destPixels) + y * dbpl);
+
+        fromX = qMax(x_l >> 16, clip.left());
+        toX = qMin(x_r >> 16, clip.left() + clip.width());
+        if (fromX < toX) {
+            // Because of rounding, we can get source coordinates outside the source image.
+            // Clamp these coordinates to the source rect to avoid segmentation fault and
+            // garbage on the screen.
+
+            // Find the first pixel on the current scan line where the source coordinates are within the source rect.
+            x1 = fromX;
+            u = x1 * dudx + y * dudy + u0;
+            v = x1 * dvdx + y * dvdy + v0;
+            for (; x1 < toX; ++x1) {
+                int uu = u >> 16;
+                int vv = v >> 16;
+                if (uu >= sourceRect.left() && uu < sourceRect.left() + sourceRect.width()
+                    && vv >= sourceRect.top() && vv < sourceRect.top() + sourceRect.height()) {
+                    break;
+                }
+                u += dudx;
+                v += dvdx;
+            }
+
+            // Find the last pixel on the current scan line where the source coordinates are within the source rect.
+            x2 = toX;
+            u = (x2 - 1) * dudx + y * dudy + u0;
+            v = (x2 - 1) * dvdx + y * dvdy + v0;
+            for (; x2 > x1; --x2) {
+                int uu = u >> 16;
+                int vv = v >> 16;
+                if (uu >= sourceRect.left() && uu < sourceRect.left() + sourceRect.width()
+                    && vv >= sourceRect.top() && vv < sourceRect.top() + sourceRect.height()) {
+                    break;
+                }
+                u -= dudx;
+                v -= dvdx;
+            }
+
+            // Set up values at the beginning of the scan line.
+            u = fromX * dudx + y * dudy + u0;
+            v = fromX * dvdx + y * dvdy + v0;
+            line += fromX;
+
+            // Beginning of the scan line, with per-pixel checks.
+            i = x1 - fromX;
+            while (i) {
+                int uu = qBound(sourceRect.left(), u >> 16, sourceRect.left() + sourceRect.width() - 1);
+                int vv = qBound(sourceRect.top(), v >> 16, sourceRect.top() + sourceRect.height() - 1);
+                blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + vv * sbpl)[uu]);
+                u += dudx;
+                v += dvdx;
+                ++line;
+                --i;
+            }
+
+            // Middle of the scan line, without checks.
+            // Manual loop unrolling.
+            i = x2 - x1;
+            ii = i >> 3;
+            while (ii) {
+                blender.write(&line[0], reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx;
+                blender.write(&line[1], reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx;
+                blender.write(&line[2], reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx;
+                blender.write(&line[3], reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx;
+                blender.write(&line[4], reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx;
+                blender.write(&line[5], reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx;
+                blender.write(&line[6], reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx;
+                blender.write(&line[7], reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx;
+
+                line += 8;
+
+                --ii;
+            }
+            switch (i & 7) {
+                case 7: blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx; ++line;
+                case 6: blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx; ++line;
+                case 5: blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx; ++line;
+                case 4: blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx; ++line;
+                case 3: blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx; ++line;
+                case 2: blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx; ++line;
+                case 1: blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx; ++line;
+            }
+
+            // End of the scan line, with per-pixel checks.
+            i = toX - x2;
+            while (i) {
+                int uu = qBound(sourceRect.left(), u >> 16, sourceRect.left() + sourceRect.width() - 1);
+                int vv = qBound(sourceRect.top(), v >> 16, sourceRect.top() + sourceRect.height() - 1);
+                blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + vv * sbpl)[uu]);
+                u += dudx;
+                v += dvdx;
+                ++line;
+                --i;
+            }
+
+            blender.flush(line);
+        }
+        x_l += dx_l;
+        x_r += dx_r;
+    }
+}
+
+template <class SrcT, class DestT, class Blender>
+void qt_transform_image(DestT *destPixels, int dbpl,
+                        const SrcT *srcPixels, int sbpl,
+                        const QRectF &targetRect,
+                        const QRectF &sourceRect,
+                        const QRect &clip,
+                        const QTransform &targetRectTransform,
+                        Blender blender)
+{
+    enum Corner
+    {
+        TopLeft,
+        TopRight,
+        BottomRight,
+        BottomLeft
+    };
+
+    // map source rectangle to destination.
+    QTransformImageVertex v[4];
+    v[TopLeft].u = v[BottomLeft].u = sourceRect.left();
+    v[TopLeft].v = v[TopRight].v = sourceRect.top();
+    v[TopRight].u = v[BottomRight].u = sourceRect.right();
+    v[BottomLeft].v = v[BottomRight].v = sourceRect.bottom();
+    targetRectTransform.map(targetRect.left(), targetRect.top(), &v[TopLeft].x, &v[TopLeft].y);
+    targetRectTransform.map(targetRect.right(), targetRect.top(), &v[TopRight].x, &v[TopRight].y);
+    targetRectTransform.map(targetRect.left(), targetRect.bottom(), &v[BottomLeft].x, &v[BottomLeft].y);
+    targetRectTransform.map(targetRect.right(), targetRect.bottom(), &v[BottomRight].x, &v[BottomRight].y);
+
+    // find topmost vertex.
+    int topmost = 0;
+    for (int i = 1; i < 4; ++i) {
+        if (v[i].y < v[topmost].y)
+            topmost = i;
+    }
+    // rearrange array such that topmost vertex is at index 0.
+    switch (topmost) {
+    case 1:
+        {
+            QTransformImageVertex t = v[0];
+            for (int i = 0; i < 3; ++i)
+                v[i] = v[i+1];
+            v[3] = t;
+        }
+        break;
+    case 2:
+        qSwap(v[0], v[2]);
+        qSwap(v[1], v[3]);
+        break;
+    case 3:
+        {
+            QTransformImageVertex t = v[3];
+            for (int i = 3; i > 0; --i)
+                v[i] = v[i-1];
+            v[0] = t;
+        }
+        break;
+    }
+
+    // if necessary, swap vertex 1 and 3 such that 1 is to the left of 3.
+    qreal dx1 = v[1].x - v[0].x;
+    qreal dy1 = v[1].y - v[0].y;
+    qreal dx2 = v[3].x - v[0].x;
+    qreal dy2 = v[3].y - v[0].y;
+    if (dx1 * dy2 - dx2 * dy1 > 0)
+        qSwap(v[1], v[3]);
+
+    QTransformImageVertex u = {v[1].x - v[0].x, v[1].y - v[0].y, v[1].u - v[0].u, v[1].v - v[0].v};
+    QTransformImageVertex w = {v[2].x - v[0].x, v[2].y - v[0].y, v[2].u - v[0].u, v[2].v - v[0].v};
+
+    qreal det = u.x * w.y - u.y * w.x;
+    if (det == 0)
+        return;
+
+    qreal invDet = 1.0 / det;
+    qreal m11, m12, m21, m22, mdx, mdy;
+
+    m11 = (u.u * w.y - u.y * w.u) * invDet;
+    m12 = (u.x * w.u - u.u * w.x) * invDet;
+    m21 = (u.v * w.y - u.y * w.v) * invDet;
+    m22 = (u.x * w.v - u.v * w.x) * invDet;
+    mdx = v[0].u - m11 * v[0].x - m12 * v[0].y;
+    mdy = v[0].v - m21 * v[0].x - m22 * v[0].y;
+
+    int dudx = int(m11 * 0x10000);
+    int dvdx = int(m21 * 0x10000);
+    int dudy = int(m12 * 0x10000);
+    int dvdy = int(m22 * 0x10000);
+    int u0 = qCeil((qreal(0.5) * m11 + qreal(0.5) * m12 + mdx) * 0x10000) - 1;
+    int v0 = qCeil((qreal(0.5) * m21 + qreal(0.5) * m22 + mdy) * 0x10000) - 1;
+
+    int x1 = qFloor(sourceRect.left());
+    int y1 = qFloor(sourceRect.top());
+    int x2 = qCeil(sourceRect.right());
+    int y2 = qCeil(sourceRect.bottom());
+    QRect sourceRectI(x1, y1, x2 - x1, y2 - y1);
+
+    // rasterize trapezoids.
+    if (v[1].y < v[3].y) {
+        qt_transform_image_rasterize(destPixels, dbpl, srcPixels, sbpl, v[0], v[1], v[0], v[3], sourceRectI, clip, v[0].y, v[1].y, dudx, dvdx, dudy, dvdy, u0, v0, blender);
+        qt_transform_image_rasterize(destPixels, dbpl, srcPixels, sbpl, v[1], v[2], v[0], v[3], sourceRectI, clip, v[1].y, v[3].y, dudx, dvdx, dudy, dvdy, u0, v0, blender);
+        qt_transform_image_rasterize(destPixels, dbpl, srcPixels, sbpl, v[1], v[2], v[3], v[2], sourceRectI, clip, v[3].y, v[2].y, dudx, dvdx, dudy, dvdy, u0, v0, blender);
+    } else {
+        qt_transform_image_rasterize(destPixels, dbpl, srcPixels, sbpl, v[0], v[1], v[0], v[3], sourceRectI, clip, v[0].y, v[3].y, dudx, dvdx, dudy, dvdy, u0, v0, blender);
+        qt_transform_image_rasterize(destPixels, dbpl, srcPixels, sbpl, v[0], v[1], v[3], v[2], sourceRectI, clip, v[3].y, v[1].y, dudx, dvdx, dudy, dvdy, u0, v0, blender);
+        qt_transform_image_rasterize(destPixels, dbpl, srcPixels, sbpl, v[1], v[2], v[3], v[2], sourceRectI, clip, v[1].y, v[2].y, dudx, dvdx, dudy, dvdy, u0, v0, blender);
+    }
+}
+
+QT_END_NAMESPACE
+
+#endif // QBLENDFUNCTIONS_P_H
diff --git a/src/gui/painting/qblittable.cpp b/src/gui/painting/qblittable.cpp
new file mode 100644
index 0000000000..58025312c7
--- /dev/null
+++ b/src/gui/painting/qblittable.cpp
@@ -0,0 +1,105 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qblittable_p.h"
+
+#ifndef QT_NO_BLITTABLE
+QT_BEGIN_NAMESPACE
+
+class QBlittablePrivate
+{
+public:
+    QBlittablePrivate(const QSize &size, QBlittable::Capabilities caps)
+        : caps(caps), m_size(size), locked(false), cachedImg(0)
+    {}
+    QBlittable::Capabilities caps;
+    QSize m_size;
+    bool locked;
+    QImage *cachedImg;
+};
+
+
+QBlittable::QBlittable(const QSize &size, Capabilities caps)
+    : d_ptr(new QBlittablePrivate(size,caps))
+{
+}
+
+QBlittable::~QBlittable()
+{
+    delete d_ptr;
+}
+
+
+QBlittable::Capabilities QBlittable::capabilities() const
+{
+    Q_D(const QBlittable);
+    return d->caps;
+}
+
+QSize QBlittable::size() const
+{
+    Q_D(const QBlittable);
+    return d->m_size;
+}
+
+QImage *QBlittable::lock()
+{
+    Q_D(QBlittable);
+    if (!d->locked) {
+        d->cachedImg = doLock();
+        d->locked = true;
+    }
+
+    return d->cachedImg;
+}
+
+void QBlittable::unlock()
+{
+    Q_D(QBlittable);
+    if (d->locked) {
+        doUnlock();
+        d->locked = false;
+    }
+}
+
+QT_END_NAMESPACE
+#endif //QT_NO_BLITTABLE
+
diff --git a/src/gui/painting/qblittable_p.h b/src/gui/painting/qblittable_p.h
new file mode 100644
index 0000000000..9d0e8225b8
--- /dev/null
+++ b/src/gui/painting/qblittable_p.h
@@ -0,0 +1,91 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QBLITTABLE_P_H
+#define QBLITTABLE_P_H
+
+#include <QtCore/qsize.h>
+#include <QtGui/private/qpixmap_blitter_p.h>
+
+
+#ifndef QT_NO_BLITTABLE
+QT_BEGIN_NAMESPACE
+
+class QImage;
+class QBlittablePrivate;
+
+class Q_GUI_EXPORT QBlittable
+{
+    Q_DECLARE_PRIVATE(QBlittable);
+public:
+    enum Capability {
+
+        SolidRectCapability             = 0x0001,
+        SourcePixmapCapability          = 0x0002,
+        SourceOverPixmapCapability      = 0x0004,
+        SourceOverScaledPixmapCapability = 0x0008,
+
+        // Internal ones
+        OutlineCapability               = 0x0001000,
+    };
+    Q_DECLARE_FLAGS (Capabilities, Capability);
+
+    QBlittable(const QSize &size, Capabilities caps);
+    virtual ~QBlittable();
+
+    Capabilities capabilities() const;
+    QSize size() const;
+
+    virtual void fillRect(const QRectF &rect, const QColor &color) = 0;
+    virtual void drawPixmap(const QRectF &rect, const QPixmap &pixmap, const QRectF &subrect) = 0;
+
+    QImage *lock();
+    void unlock();
+
+protected:
+    virtual QImage *doLock() = 0;
+    virtual void doUnlock() = 0;
+    QBlittablePrivate *d_ptr;
+};
+
+QT_END_NAMESPACE
+#endif //QT_NO_BLITTABLE
+#endif //QBLITTABLE_P_H
diff --git a/src/gui/painting/qbrush.cpp b/src/gui/painting/qbrush.cpp
new file mode 100644
index 0000000000..bf5764a609
--- /dev/null
+++ b/src/gui/painting/qbrush.cpp
@@ -0,0 +1,2196 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qbrush.h"
+#include "qpixmap.h"
+#include "qbitmap.h"
+#include "qpixmapcache.h"
+#include "qdatastream.h"
+#include "qvariant.h"
+#include "qline.h"
+#include "qdebug.h"
+#include <QtCore/qcoreapplication.h>
+#include "private/qstylehelper_p.h"
+#include <QtCore/qnumeric.h>
+
+QT_BEGIN_NAMESPACE
+
+const uchar *qt_patternForBrush(int brushStyle, bool invert)
+{
+    Q_ASSERT(brushStyle > Qt::SolidPattern && brushStyle < Qt::LinearGradientPattern);
+    if(invert) {
+        static const uchar dense1_pat[] = { 0xff, 0xbb, 0xff, 0xff, 0xff, 0xbb, 0xff, 0xff };
+        static const uchar dense2_pat[] = { 0x77, 0xff, 0xdd, 0xff, 0x77, 0xff, 0xdd, 0xff };
+        static const uchar dense3_pat[] = { 0x55, 0xbb, 0x55, 0xee, 0x55, 0xbb, 0x55, 0xee };
+        static const uchar dense4_pat[] = { 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55 };
+        static const uchar dense5_pat[] = { 0xaa, 0x44, 0xaa, 0x11, 0xaa, 0x44, 0xaa, 0x11 };
+        static const uchar dense6_pat[] = { 0x88, 0x00, 0x22, 0x00, 0x88, 0x00, 0x22, 0x00 };
+        static const uchar dense7_pat[] = { 0x00, 0x44, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00 };
+        static const uchar hor_pat[]    = { 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00 };
+        static const uchar ver_pat[]    = { 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10 };
+        static const uchar cross_pat[]  = { 0x10, 0x10, 0x10, 0xff, 0x10, 0x10, 0x10, 0x10 };
+        static const uchar bdiag_pat[]  = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 };
+        static const uchar fdiag_pat[]  = { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 };
+        static const uchar dcross_pat[] = { 0x81, 0x42, 0x24, 0x18, 0x18, 0x24, 0x42, 0x81 };
+        static const uchar *const pat_tbl[] = {
+            dense1_pat, dense2_pat, dense3_pat, dense4_pat, dense5_pat,
+            dense6_pat, dense7_pat,
+            hor_pat, ver_pat, cross_pat, bdiag_pat, fdiag_pat, dcross_pat };
+        return pat_tbl[brushStyle - Qt::Dense1Pattern];
+    }
+    static const uchar dense1_pat[] = { 0x00, 0x44, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00 };
+    static const uchar dense2_pat[] = { 0x88, 0x00, 0x22, 0x00, 0x88, 0x00, 0x22, 0x00 };
+    static const uchar dense3_pat[] = { 0xaa, 0x44, 0xaa, 0x11, 0xaa, 0x44, 0xaa, 0x11 };
+    static const uchar dense4_pat[] = { 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa };
+    static const uchar dense5_pat[] = { 0x55, 0xbb, 0x55, 0xee, 0x55, 0xbb, 0x55, 0xee };
+    static const uchar dense6_pat[] = { 0x77, 0xff, 0xdd, 0xff, 0x77, 0xff, 0xdd, 0xff };
+    static const uchar dense7_pat[] = { 0xff, 0xbb, 0xff, 0xff, 0xff, 0xbb, 0xff, 0xff };
+    static const uchar hor_pat[]    = { 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff };
+    static const uchar ver_pat[]    = { 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef };
+    static const uchar cross_pat[]  = { 0xef, 0xef, 0xef, 0x00, 0xef, 0xef, 0xef, 0xef };
+    static const uchar bdiag_pat[]  = { 0x7f, 0xbf, 0xdf, 0xef, 0xf7, 0xfb, 0xfd, 0xfe };
+    static const uchar fdiag_pat[]  = { 0xfe, 0xfd, 0xfb, 0xf7, 0xef, 0xdf, 0xbf, 0x7f };
+    static const uchar dcross_pat[] = { 0x7e, 0xbd, 0xdb, 0xe7, 0xe7, 0xdb, 0xbd, 0x7e };
+    static const uchar *const pat_tbl[] = {
+        dense1_pat, dense2_pat, dense3_pat, dense4_pat, dense5_pat,
+        dense6_pat, dense7_pat,
+        hor_pat, ver_pat, cross_pat, bdiag_pat, fdiag_pat, dcross_pat };
+    return pat_tbl[brushStyle - Qt::Dense1Pattern];
+}
+
+QPixmap qt_pixmapForBrush(int brushStyle, bool invert)
+{
+
+    QPixmap pm;
+    QString key = QLatin1Literal("$qt-brush$")
+                  % HexString<uint>(brushStyle)
+                  % QLatin1Char(invert ? '1' : '0');
+    if (!QPixmapCache::find(key, pm)) {
+        pm = QBitmap::fromData(QSize(8, 8), qt_patternForBrush(brushStyle, invert),
+                               QImage::Format_MonoLSB);
+        QPixmapCache::insert(key, pm);
+    }
+
+    return pm;
+}
+
+class QBrushPatternImageCache
+{
+public:
+    QBrushPatternImageCache()
+        : m_initialized(false)
+    {
+        init();
+    }
+
+    void init()
+    {
+        for (int style = Qt::Dense1Pattern; style <= Qt::DiagCrossPattern; ++style) {
+            int i = style - Qt::Dense1Pattern;
+            m_images[i][0] = QImage(qt_patternForBrush(style, 0), 8, 8, 1, QImage::Format_MonoLSB);
+            m_images[i][1] = QImage(qt_patternForBrush(style, 1), 8, 8, 1, QImage::Format_MonoLSB);
+        }
+        m_initialized = true;
+    }
+
+    QImage getImage(int brushStyle, bool invert) const
+    {
+        Q_ASSERT(brushStyle >= Qt::Dense1Pattern && brushStyle <= Qt::DiagCrossPattern);
+        if (!m_initialized)
+            const_cast<QBrushPatternImageCache*>(this)->init();
+        return m_images[brushStyle - Qt::Dense1Pattern][invert];
+    }
+
+    void cleanup() {
+        for (int style = Qt::Dense1Pattern; style <= Qt::DiagCrossPattern; ++style) {
+            int i = style - Qt::Dense1Pattern;
+            m_images[i][0] = QImage();
+            m_images[i][1] = QImage();
+        }
+        m_initialized = false;
+    }
+
+private:
+    QImage m_images[Qt::DiagCrossPattern - Qt::Dense1Pattern + 1][2];
+    bool m_initialized;
+};
+
+static void qt_cleanup_brush_pattern_image_cache();
+Q_GLOBAL_STATIC_WITH_INITIALIZER(QBrushPatternImageCache, qt_brushPatternImageCache,
+                                 {
+                                     qAddPostRoutine(qt_cleanup_brush_pattern_image_cache);
+                                 })
+
+static void qt_cleanup_brush_pattern_image_cache()
+{
+    qt_brushPatternImageCache()->cleanup();
+}
+
+Q_GUI_EXPORT QImage qt_imageForBrush(int brushStyle, bool invert)
+{
+    return qt_brushPatternImageCache()->getImage(brushStyle, invert);
+}
+
+struct QTexturedBrushData : public QBrushData
+{
+    QTexturedBrushData() {
+        m_has_pixmap_texture = false;
+        m_pixmap = 0;
+    }
+    ~QTexturedBrushData() {
+        delete m_pixmap;
+    }
+
+    void setPixmap(const QPixmap &pm) {
+        delete m_pixmap;
+
+        if (pm.isNull()) {
+            m_pixmap = 0;
+            m_has_pixmap_texture = false;
+        } else {
+            m_pixmap = new QPixmap(pm);
+            m_has_pixmap_texture = true;
+        }
+
+        m_image = QImage();
+    }
+
+    void setImage(const QImage &image) {
+        m_image = image;
+        delete m_pixmap;
+        m_pixmap = 0;
+        m_has_pixmap_texture = false;
+    }
+
+    QPixmap &pixmap() {
+        if (!m_pixmap) {
+            m_pixmap = new QPixmap(QPixmap::fromImage(m_image));
+        }
+        return *m_pixmap;
+    }
+
+    QImage &image() {
+        if (m_image.isNull() && m_pixmap)
+            m_image = m_pixmap->toImage();
+        return m_image;
+    }
+
+    QPixmap *m_pixmap;
+    QImage m_image;
+    bool m_has_pixmap_texture;
+};
+
+// returns true if the brush has a pixmap (or bitmap) set as the
+// brush texture, false otherwise
+bool Q_GUI_EXPORT qHasPixmapTexture(const QBrush& brush)
+{
+    if (brush.style() != Qt::TexturePattern)
+        return false;
+    QTexturedBrushData *tx_data = static_cast<QTexturedBrushData *>(brush.d.data());
+    return tx_data->m_has_pixmap_texture;
+}
+
+struct QGradientBrushData : public QBrushData
+{
+    QGradient gradient;
+};
+
+struct QBrushDataPointerDeleter
+{
+    static inline void deleteData(QBrushData *d)
+    {
+        switch (d->style) {
+        case Qt::TexturePattern:
+            delete static_cast<QTexturedBrushData*>(d);
+            break;
+        case Qt::LinearGradientPattern:
+        case Qt::RadialGradientPattern:
+        case Qt::ConicalGradientPattern:
+            delete static_cast<QGradientBrushData*>(d);
+            break;
+        default:
+            delete d;
+        }
+    }
+
+    static inline void cleanup(QBrushData *d)
+    {
+        if (d && !d->ref.deref()) {
+            deleteData(d);
+        }
+    }
+};
+
+/*!
+    \class QBrush
+    \ingroup painting
+    \ingroup shared
+
+    \brief The QBrush class defines the fill pattern of shapes drawn
+    by QPainter.
+
+    A brush has a style, a color, a gradient and a texture.
+
+    The brush style() defines the fill pattern using the
+    Qt::BrushStyle enum. The default brush style is Qt::NoBrush
+    (depending on how you construct a brush). This style tells the
+    painter to not fill shapes. The standard style for filling is
+    Qt::SolidPattern. The style can be set when the brush is created
+    using the appropriate constructor, and in addition the setStyle()
+    function provides means for altering the style once the brush is
+    constructed.
+
+    \image brush-styles.png Brush Styles
+
+    The brush color() defines the color of the fill pattern. The color
+    can either be one of Qt's predefined colors, Qt::GlobalColor, or
+    any other custom QColor. The currently set color can be retrieved
+    and altered using the color() and setColor() functions,
+    respectively.
+
+    The gradient() defines the gradient fill used when the current
+    style is either Qt::LinearGradientPattern,
+    Qt::RadialGradientPattern or Qt::ConicalGradientPattern. Gradient
+    brushes are created by giving a QGradient as a constructor
+    argument when creating the QBrush. Qt provides three different
+    gradients: QLinearGradient, QConicalGradient, and QRadialGradient
+    - all of which inherit QGradient.
+
+    \snippet doc/src/snippets/brush/gradientcreationsnippet.cpp 0
+
+    The texture() defines the pixmap used when the current style is
+    Qt::TexturePattern.  You can create a brush with a texture by
+    providing the pixmap when the brush is created or by using
+    setTexture().
+
+    Note that applying setTexture() makes style() ==
+    Qt::TexturePattern, regardless of previous style
+    settings. Also, calling setColor() will not make a difference if
+    the style is a gradient. The same is the case if the style is
+    Qt::TexturePattern style unless the current texture is a QBitmap.
+
+    The isOpaque() function returns true if the brush is fully opaque
+    otherwise false. A brush is considered opaque if:
+
+    \list
+    \o The alpha component of the color() is 255.
+    \o Its texture() does not have an alpha channel and is not a QBitmap.
+    \o The colors in the gradient() all have an alpha component that is 255.
+    \endlist
+
+    \table 100%
+    \row
+    \o \inlineimage brush-outline.png Outlines
+    \o
+
+    To specify the style and color of lines and outlines, use the
+    QPainter's \l {QPen}{pen} combined with Qt::PenStyle and
+    Qt::GlobalColor:
+
+    \snippet doc/src/snippets/code/src_gui_painting_qbrush.cpp 0
+
+    Note that, by default, QPainter renders the outline (using the
+    currently set pen) when drawing shapes. Use \l {Qt::NoPen}{\c
+    painter.setPen(Qt::NoPen)} to disable this behavior.
+
+    \endtable
+
+    For more information about painting in general, see the \l{Paint
+    System}.
+
+    \sa Qt::BrushStyle, QPainter, QColor
+*/
+
+#ifndef QT_NO_THREAD
+// Special deleter that only deletes if the ref-count goes to zero
+template <>
+class QGlobalStaticDeleter<QBrushData>
+{
+public:
+    QGlobalStatic<QBrushData> &globalStatic;
+    QGlobalStaticDeleter(QGlobalStatic<QBrushData> &_globalStatic)
+        : globalStatic(_globalStatic)
+    { }
+
+    inline ~QGlobalStaticDeleter()
+    {
+        if (!globalStatic.pointer->ref.deref())
+            delete globalStatic.pointer;
+        globalStatic.pointer = 0;
+        globalStatic.destroyed = true;
+    }
+};
+#endif
+
+Q_GLOBAL_STATIC_WITH_INITIALIZER(QBrushData, nullBrushInstance,
+                                 {
+                                     x->ref = 1;
+                                     x->style = Qt::BrushStyle(0);
+                                     x->color = Qt::black;
+                                 })
+
+static bool qbrush_check_type(Qt::BrushStyle style) {
+    switch (style) {
+    case Qt::TexturePattern:
+         qWarning("QBrush: Incorrect use of TexturePattern");
+         break;
+    case Qt::LinearGradientPattern:
+    case Qt::RadialGradientPattern:
+    case Qt::ConicalGradientPattern:
+        qWarning("QBrush: Wrong use of a gradient pattern");
+        break;
+    default:
+        return true;
+    }
+    return false;
+}
+
+/*!
+  \internal
+  Initializes the brush.
+*/
+
+void QBrush::init(const QColor &color, Qt::BrushStyle style)
+{
+    switch(style) {
+    case Qt::NoBrush:
+        d.reset(nullBrushInstance());
+        d->ref.ref();
+        if (d->color != color) setColor(color);
+        return;
+    case Qt::TexturePattern:
+        d.reset(new QTexturedBrushData);
+        break;
+    case Qt::LinearGradientPattern:
+    case Qt::RadialGradientPattern:
+    case Qt::ConicalGradientPattern:
+        d.reset(new QGradientBrushData);
+        break;
+    default:
+        d.reset(new QBrushData);
+        break;
+    }
+    d->ref = 1;
+    d->style = style;
+    d->color = color;
+}
+
+/*!
+    Constructs a default black brush with the style Qt::NoBrush
+    (i.e. this brush will not fill shapes).
+*/
+
+QBrush::QBrush()
+    : d(nullBrushInstance())
+{
+    Q_ASSERT(d);
+    d->ref.ref();
+}
+
+/*!
+    Constructs a brush with a black color and a texture set to the
+    given \a pixmap. The style is set to Qt::TexturePattern.
+
+    \sa setTexture()
+*/
+
+QBrush::QBrush(const QPixmap &pixmap)
+{
+    init(Qt::black, Qt::TexturePattern);
+    setTexture(pixmap);
+}
+
+
+/*!
+    Constructs a brush with a black color and a texture set to the
+    given \a image. The style is set to Qt::TexturePattern.
+
+    \sa setTextureImage()
+*/
+
+QBrush::QBrush(const QImage &image)
+{
+    init(Qt::black, Qt::TexturePattern);
+    setTextureImage(image);
+}
+
+/*!
+    Constructs a black brush with the given \a style.
+
+    \sa setStyle()
+*/
+
+QBrush::QBrush(Qt::BrushStyle style)
+{
+    if (qbrush_check_type(style))
+        init(Qt::black, style);
+    else {
+        d.reset(nullBrushInstance());
+        d->ref.ref();
+    }
+}
+
+/*!
+    Constructs a brush with the given \a color and \a style.
+
+    \sa setColor(), setStyle()
+*/
+
+QBrush::QBrush(const QColor &color, Qt::BrushStyle style)
+{
+    if (qbrush_check_type(style))
+        init(color, style);
+    else {
+        d.reset(nullBrushInstance());
+        d->ref.ref();
+    }
+}
+
+/*!
+    \fn QBrush::QBrush(Qt::GlobalColor color, Qt::BrushStyle style)
+
+    Constructs a brush with the given \a color and \a style.
+
+    \sa setColor(), setStyle()
+*/
+QBrush::QBrush(Qt::GlobalColor color, Qt::BrushStyle style)
+{
+    if (qbrush_check_type(style))
+        init(color, style);
+    else {
+        d.reset(nullBrushInstance());
+        d->ref.ref();
+    }
+}
+
+/*!
+    Constructs a brush with the given \a color and the custom pattern
+    stored in \a pixmap.
+
+    The style is set to Qt::TexturePattern. The color will only have
+    an effect for QBitmaps.
+
+    \sa setColor(), setPixmap()
+*/
+
+QBrush::QBrush(const QColor &color, const QPixmap &pixmap)
+{
+    init(color, Qt::TexturePattern);
+    setTexture(pixmap);
+}
+
+/*!
+
+    Constructs a brush with the given \a color and the custom pattern
+    stored in \a pixmap.
+
+    The style is set to Qt::TexturePattern. The color will only have
+    an effect for QBitmaps.
+
+    \sa setColor(), setPixmap()
+*/
+QBrush::QBrush(Qt::GlobalColor color, const QPixmap &pixmap)
+{
+    init(color, Qt::TexturePattern);
+    setTexture(pixmap);
+}
+
+/*!
+    Constructs a copy of \a other.
+*/
+
+QBrush::QBrush(const QBrush &other)
+    : d(other.d.data())
+{
+    d->ref.ref();
+}
+
+/*!
+    Constructs a brush based on the given \a gradient.
+
+    The brush style is set to the corresponding gradient style (either
+    Qt::LinearGradientPattern, Qt::RadialGradientPattern or
+    Qt::ConicalGradientPattern).
+*/
+QBrush::QBrush(const QGradient &gradient)
+{
+    Q_ASSERT_X(gradient.type() != QGradient::NoGradient, "QBrush::QBrush",
+               "QGradient should not be used directly, use the linear, radial\n"
+               "or conical gradients instead");
+
+    const Qt::BrushStyle enum_table[] = {
+        Qt::LinearGradientPattern,
+        Qt::RadialGradientPattern,
+        Qt::ConicalGradientPattern
+    };
+
+    init(QColor(), enum_table[gradient.type()]);
+    QGradientBrushData *grad = static_cast<QGradientBrushData *>(d.data());
+    grad->gradient = gradient;
+}
+
+/*!
+    Destroys the brush.
+*/
+
+QBrush::~QBrush()
+{
+}
+
+void QBrush::cleanUp(QBrushData *x)
+{
+    QBrushDataPointerDeleter::deleteData(x);
+}
+
+
+void QBrush::detach(Qt::BrushStyle newStyle)
+{
+    if (newStyle == d->style && d->ref == 1)
+        return;
+
+    QScopedPointer<QBrushData> x;
+    switch(newStyle) {
+    case Qt::TexturePattern: {
+        QTexturedBrushData *tbd = new QTexturedBrushData;
+        if (d->style == Qt::TexturePattern) {
+            QTexturedBrushData *data = static_cast<QTexturedBrushData *>(d.data());
+            if (data->m_has_pixmap_texture)
+                tbd->setPixmap(data->pixmap());
+            else
+                tbd->setImage(data->image());
+        }
+        x.reset(tbd);
+        break;
+        }
+    case Qt::LinearGradientPattern:
+    case Qt::RadialGradientPattern:
+    case Qt::ConicalGradientPattern:
+        x.reset(new QGradientBrushData);
+        static_cast<QGradientBrushData *>(x.data())->gradient =
+            static_cast<QGradientBrushData *>(d.data())->gradient;
+        break;
+    default:
+        x.reset(new QBrushData);
+        break;
+    }
+    x->ref = 1;
+    x->style = newStyle;
+    x->color = d->color;
+    x->transform = d->transform;
+    d.reset(x.take());
+}
+
+
+/*!
+    \fn QBrush &QBrush::operator=(const QBrush &brush)
+
+    Assigns the given \a brush to \e this brush and returns a
+    reference to \e this brush.
+*/
+
+QBrush &QBrush::operator=(const QBrush &b)
+{
+    if (d == b.d)
+        return *this;
+
+    b.d->ref.ref();
+    d.reset(b.d.data());
+    return *this;
+}
+
+
+/*!
+    \fn void QBrush::swap(QBrush &other)
+    \since 4.8
+
+    Swaps brush \a other with this brush. This operation is very
+    fast and never fails.
+*/
+
+/*!
+   Returns the brush as a QVariant
+*/
+QBrush::operator QVariant() const
+{
+    return QVariant(QVariant::Brush, this);
+}
+
+/*!
+    \fn Qt::BrushStyle QBrush::style() const
+
+    Returns the brush style.
+
+    \sa setStyle()
+*/
+
+/*!
+    Sets the brush style to \a style.
+
+    \sa style()
+*/
+
+void QBrush::setStyle(Qt::BrushStyle style)
+{
+    if (d->style == style)
+        return;
+
+    if (qbrush_check_type(style)) {
+        detach(style);
+        d->style = style;
+    }
+}
+
+
+/*!
+    \fn const QColor &QBrush::color() const
+
+    Returns the brush color.
+
+    \sa setColor()
+*/
+
+/*!
+    \fn void QBrush::setColor(const QColor &color)
+
+    Sets the brush color to the given \a color.
+
+    Note that calling setColor() will not make a difference if the
+    style is a gradient. The same is the case if the style is
+    Qt::TexturePattern style unless the current texture is a QBitmap.
+
+    \sa color()
+*/
+
+void QBrush::setColor(const QColor &c)
+{
+    detach(d->style);
+    d->color = c;
+}
+
+/*!
+    \fn void QBrush::setColor(Qt::GlobalColor color)
+    \overload
+
+    Sets the brush color to the given \a color.
+*/
+
+
+#ifdef QT3_SUPPORT
+
+/*!
+    \fn void QBrush::setPixmap(const QPixmap &pixmap)
+
+    \compat
+
+    Sets a custom pattern for this brush.
+
+    Use setTexture() instead.
+*/
+
+/*!
+    \fn QPixmap *QBrush::pixmap() const
+
+    Returns a pointer to the custom brush pattern.
+
+    Use texture() instead.
+*/
+QPixmap *QBrush::pixmap() const
+{
+    if (d->style != Qt::TexturePattern)
+        return 0;
+    QTexturedBrushData *data  = static_cast<QTexturedBrushData*>(d.data());
+    QPixmap &pixmap = data->pixmap();
+    return pixmap.isNull() ? 0 : &pixmap;
+}
+#endif
+
+/*!
+    \fn QPixmap QBrush::texture() const
+
+    Returns the custom brush pattern, or a null pixmap if no custom brush pattern
+    has been set.
+
+    \sa setTexture()
+*/
+QPixmap QBrush::texture() const
+{
+    return d->style == Qt::TexturePattern
+                     ? (static_cast<QTexturedBrushData *>(d.data()))->pixmap()
+                     : QPixmap();
+}
+
+/*!
+    Sets the brush pixmap to \a pixmap. The style is set to
+    Qt::TexturePattern.
+
+    The current brush color will only have an effect for monochrome
+    pixmaps, i.e. for QPixmap::depth() == 1 (\l {QBitmap}{QBitmaps}).
+
+    \sa texture()
+*/
+
+void QBrush::setTexture(const QPixmap &pixmap)
+{
+    if (!pixmap.isNull()) {
+        detach(Qt::TexturePattern);
+        QTexturedBrushData *data = static_cast<QTexturedBrushData *>(d.data());
+        data->setPixmap(pixmap);
+    } else {
+        detach(Qt::NoBrush);
+    }
+}
+
+
+/*!
+    \since 4.2
+
+    Returns the custom brush pattern, or a null image if no custom
+    brush pattern has been set.
+
+    If the texture was set as a QPixmap it will be converted to a
+    QImage.
+
+    \sa setTextureImage()
+*/
+
+QImage QBrush::textureImage() const
+{
+    return d->style == Qt::TexturePattern
+                     ? (static_cast<QTexturedBrushData *>(d.data()))->image()
+                     : QImage();
+}
+
+
+/*!
+    \since 4.2
+
+    Sets the brush image to \a image. The style is set to
+    Qt::TexturePattern.
+
+    Note the current brush color will \e not have any affect on
+    monochrome images, as opposed to calling setTexture() with a
+    QBitmap. If you want to change the color of monochrome image
+    brushes, either convert the image to QBitmap with \c
+    QBitmap::fromImage() and set the resulting QBitmap as a texture,
+    or change the entries in the color table for the image.
+
+    \sa textureImage(), setTexture()
+*/
+
+void QBrush::setTextureImage(const QImage &image)
+{
+    if (!image.isNull()) {
+        detach(Qt::TexturePattern);
+        QTexturedBrushData *data = static_cast<QTexturedBrushData *>(d.data());
+        data->setImage(image);
+    } else {
+        detach(Qt::NoBrush);
+    }
+}
+
+
+/*!
+    Returns the gradient describing this brush.
+*/
+const QGradient *QBrush::gradient() const
+{
+    if (d->style == Qt::LinearGradientPattern
+        || d->style == Qt::RadialGradientPattern
+        || d->style == Qt::ConicalGradientPattern) {
+        return &static_cast<const QGradientBrushData *>(d.data())->gradient;
+    }
+    return 0;
+}
+
+
+/*!
+    Returns true if the brush is fully opaque otherwise false. A brush
+    is considered opaque if:
+
+    \list
+    \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.
+    \endlist
+*/
+
+bool QBrush::isOpaque() const
+{
+    bool opaqueColor = d->color.alpha() == 255;
+
+    // Test awfully simple case first
+    if (d->style == Qt::SolidPattern)
+        return opaqueColor;
+
+    if (d->style == Qt::LinearGradientPattern
+        || d->style == Qt::RadialGradientPattern
+        || d->style == Qt::ConicalGradientPattern) {
+        QGradientStops stops = gradient()->stops();
+        for (int i=0; i<stops.size(); ++i)
+            if (stops.at(i).second.alpha() != 255)
+                return false;
+        return true;
+    } else if (d->style == Qt::TexturePattern) {
+        return qHasPixmapTexture(*this)
+            ? !texture().hasAlphaChannel() && !texture().isQBitmap()
+            : !textureImage().hasAlphaChannel();
+    }
+
+    return false;
+}
+
+
+/*!
+    \since 4.2
+
+    Sets \a matrix as an explicit transformation matrix on the
+    current brush. The brush transformation matrix is merged with
+    QPainter transformation matrix to produce the final result.
+
+    \sa matrix()
+*/
+void QBrush::setMatrix(const QMatrix &matrix)
+{
+    setTransform(QTransform(matrix));
+}
+
+/*!
+    \since 4.3
+
+    Sets \a matrix as an explicit transformation matrix on the
+    current brush. The brush transformation matrix is merged with
+    QPainter transformation matrix to produce the final result.
+
+    \sa transform()
+*/
+void QBrush::setTransform(const QTransform &matrix)
+{
+    detach(d->style);
+    d->transform = matrix;
+}
+
+
+/*!
+    \fn void QBrush::matrix() const
+    \since 4.2
+
+    Returns the current transformation matrix for the brush.
+
+    \sa setMatrix()
+*/
+
+/*!
+    \fn bool QBrush::operator!=(const QBrush &brush) const
+
+    Returns true if the brush is different from the given \a brush;
+    otherwise returns false.
+
+    Two brushes are different if they have different styles, colors or
+    transforms or different pixmaps or gradients depending on the style.
+
+    \sa operator==()
+*/
+
+/*!
+    \fn bool QBrush::operator==(const QBrush &brush) const
+
+    Returns true if the brush is equal to the given \a brush;
+    otherwise returns false.
+
+    Two brushes are equal if they have equal styles, colors and
+    transforms and equal pixmaps or gradients depending on the style.
+
+    \sa operator!=()
+*/
+
+bool QBrush::operator==(const QBrush &b) const
+{
+    if (b.d == d)
+        return true;
+    if (b.d->style != d->style || b.d->color != d->color || b.d->transform != d->transform)
+        return false;
+    switch (d->style) {
+    case Qt::TexturePattern:
+        {
+            const QPixmap &us = (static_cast<QTexturedBrushData *>(d.data()))->pixmap();
+            const QPixmap &them = (static_cast<QTexturedBrushData *>(b.d.data()))->pixmap();
+            return ((us.isNull() && them.isNull()) || us.cacheKey() == them.cacheKey());
+        }
+    case Qt::LinearGradientPattern:
+    case Qt::RadialGradientPattern:
+    case Qt::ConicalGradientPattern:
+        {
+            const QGradientBrushData *d1 = static_cast<QGradientBrushData *>(d.data());
+            const QGradientBrushData *d2 = static_cast<QGradientBrushData *>(b.d.data());
+            return d1->gradient == d2->gradient;
+        }
+    default:
+        return true;
+    }
+}
+
+/*!
+    \fn QBrush::operator const QColor&() const
+
+    Returns the brush's color.
+
+    Use color() instead.
+*/
+
+#ifndef QT_NO_DEBUG_STREAM
+/*!
+  \internal
+*/
+QDebug operator<<(QDebug dbg, const QBrush &b)
+{
+#ifndef Q_BROKEN_DEBUG_STREAM
+    static const char *BRUSH_STYLES[] = {
+     "NoBrush",
+     "SolidPattern",
+     "Dense1Pattern",
+     "Dense2Pattern",
+     "Dense3Pattern",
+     "Dense4Pattern",
+     "Dense5Pattern",
+     "Dense6Pattern",
+     "Dense7Pattern",
+     "HorPattern",
+     "VerPattern",
+     "CrossPattern",
+     "BDiagPattern",
+     "FDiagPattern",
+     "DiagCrossPattern",
+     "LinearGradientPattern",
+     "RadialGradientPattern",
+     "ConicalGradientPattern",
+     0, 0, 0, 0, 0, 0,
+     "TexturePattern" // 24
+    };
+
+    dbg.nospace() << "QBrush(" << b.color() << ',' << BRUSH_STYLES[b.style()] << ')';
+    return dbg.space();
+#else
+    qWarning("This compiler doesn't support streaming QBrush to QDebug");
+    return dbg;
+    Q_UNUSED(b);
+#endif
+}
+#endif
+
+/*****************************************************************************
+  QBrush stream functions
+ *****************************************************************************/
+#ifndef QT_NO_DATASTREAM
+/*!
+    \fn QDataStream &operator<<(QDataStream &stream, const QBrush &brush)
+    \relates QBrush
+
+    Writes the given \a brush to the given \a stream and returns a
+    reference to the \a stream.
+
+    \sa {Serializing Qt Data Types}
+*/
+
+QDataStream &operator<<(QDataStream &s, const QBrush &b)
+{
+    quint8 style = (quint8) b.style();
+    bool gradient_style = false;
+
+    if (style == Qt::LinearGradientPattern || style == Qt::RadialGradientPattern
+        || style == Qt::ConicalGradientPattern)
+        gradient_style = true;
+
+    if (s.version() < QDataStream::Qt_4_0 && gradient_style)
+        style = Qt::NoBrush;
+
+    s << style << b.color();
+    if (b.style() == Qt::TexturePattern) {
+        s << b.texture();
+    } else if (s.version() >= QDataStream::Qt_4_0 && gradient_style) {
+        const QGradient *gradient = b.gradient();
+        int type_as_int = int(gradient->type());
+        s << type_as_int;
+        if (s.version() >= QDataStream::Qt_4_3) {
+            s << int(gradient->spread());
+            s << int(gradient->coordinateMode());
+        }
+
+        if (s.version() >= QDataStream::Qt_4_5)
+            s << int(gradient->interpolationMode());
+
+        if (sizeof(qreal) == sizeof(double)) {
+            s << gradient->stops();
+        } else {
+            // ensure that we write doubles here instead of streaming the stops
+            // directly; otherwise, platforms that redefine qreal might generate
+            // data that cannot be read on other platforms.
+            QVector<QGradientStop> stops = gradient->stops();
+            s << quint32(stops.size());
+            for (int i = 0; i < stops.size(); ++i) {
+                const QGradientStop &stop = stops.at(i);
+                s << QPair<double, QColor>(double(stop.first), stop.second);
+            }
+        }
+
+        if (gradient->type() == QGradient::LinearGradient) {
+            s << static_cast<const QLinearGradient *>(gradient)->start();
+            s << static_cast<const QLinearGradient *>(gradient)->finalStop();
+        } else if (gradient->type() == QGradient::RadialGradient) {
+            s << static_cast<const QRadialGradient *>(gradient)->center();
+            s << static_cast<const QRadialGradient *>(gradient)->focalPoint();
+            s << (double) static_cast<const QRadialGradient *>(gradient)->radius();
+        } else { // type == Conical
+            s << static_cast<const QConicalGradient *>(gradient)->center();
+            s << (double) static_cast<const QConicalGradient *>(gradient)->angle();
+        }
+    }
+    if (s.version() >= QDataStream::Qt_4_3)
+        s << b.transform();
+    return s;
+}
+
+/*!
+    \fn QDataStream &operator>>(QDataStream &stream, QBrush &brush)
+    \relates QBrush
+
+    Reads the given \a brush from the given \a stream and returns a
+    reference to the \a stream.
+
+    \sa {Serializing Qt Data Types}
+*/
+
+QDataStream &operator>>(QDataStream &s, QBrush &b)
+{
+    quint8 style;
+    QColor color;
+    s >> style;
+    s >> color;
+    if (style == Qt::TexturePattern) {
+        QPixmap pm;
+        s >> pm;
+        b = QBrush(color, pm);
+    } else if (style == Qt::LinearGradientPattern
+               || style == Qt::RadialGradientPattern
+               || style == Qt::ConicalGradientPattern) {
+
+        int type_as_int;
+        QGradient::Type type;
+        QGradientStops stops;
+        QGradient::CoordinateMode cmode = QGradient::LogicalMode;
+        QGradient::Spread spread = QGradient::PadSpread;
+        QGradient::InterpolationMode imode = QGradient::ColorInterpolation;
+
+        s >> type_as_int;
+        type = QGradient::Type(type_as_int);
+        if (s.version() >= QDataStream::Qt_4_3) {
+            s >> type_as_int;
+            spread = QGradient::Spread(type_as_int);
+            s >> type_as_int;
+            cmode = QGradient::CoordinateMode(type_as_int);
+        }
+
+        if (s.version() >= QDataStream::Qt_4_5) {
+            s >> type_as_int;
+            imode = QGradient::InterpolationMode(type_as_int);
+        }
+
+        if (sizeof(qreal) == sizeof(double)) {
+            s >> stops;
+        } else {
+            quint32 numStops;
+            double n;
+            QColor c;
+
+            s >> numStops;
+            for (quint32 i = 0; i < numStops; ++i) {
+                s >> n >> c;
+                stops << QPair<qreal, QColor>(n, c);
+            }
+        }
+
+        if (type == QGradient::LinearGradient) {
+            QPointF p1, p2;
+            s >> p1;
+            s >> p2;
+            QLinearGradient lg(p1, p2);
+            lg.setStops(stops);
+            lg.setSpread(spread);
+            lg.setCoordinateMode(cmode);
+            lg.setInterpolationMode(imode);
+            b = QBrush(lg);
+        } else if (type == QGradient::RadialGradient) {
+            QPointF center, focal;
+            double radius;
+            s >> center;
+            s >> focal;
+            s >> radius;
+            QRadialGradient rg(center, radius, focal);
+            rg.setStops(stops);
+            rg.setSpread(spread);
+            rg.setCoordinateMode(cmode);
+            rg.setInterpolationMode(imode);
+            b = QBrush(rg);
+        } else { // type == QGradient::ConicalGradient
+            QPointF center;
+            double angle;
+            s >> center;
+            s >> angle;
+            QConicalGradient cg(center, angle);
+            cg.setStops(stops);
+            cg.setSpread(spread);
+            cg.setCoordinateMode(cmode);
+            cg.setInterpolationMode(imode);
+            b = QBrush(cg);
+        }
+    } else {
+        b = QBrush(color, (Qt::BrushStyle)style);
+    }
+    if (s.version() >= QDataStream::Qt_4_3) {
+        QTransform transform;
+        s >> transform;
+        b.setTransform(transform);
+    }
+    return s;
+}
+#endif // QT_NO_DATASTREAM
+
+/*******************************************************************************
+ * QGradient implementations
+ */
+
+
+/*!
+    \class QGradient
+    \ingroup painting
+    \ingroup shared
+
+    \brief The QGradient class is used in combination with QBrush to
+    specify gradient fills.
+
+    Qt currently supports three types of gradient fills:
+
+    \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 Conical gradients interpolate colors around a center point.
+    \endlist
+
+    A gradient's type can be retrieved using the type() function.
+    Each of the types is represented by a subclass of QGradient:
+
+    \table
+    \header
+    \o QLinearGradient
+    \o QRadialGradient
+    \o QConicalGradient
+    \row
+    \o \inlineimage qgradient-linear.png
+    \o \inlineimage qgradient-radial.png
+    \o \inlineimage qgradient-conical.png
+    \endtable
+
+    The colors in a gradient are defined using stop points of the
+    QGradientStop type; i.e., a position and a color. Use the setColorAt()
+    function to define a single stop point. Alternatively, use the
+    setStops() function to define several stop points in one go. Note that
+    the latter function \e replaces the current set of stop points.
+
+    It is the gradient's complete set of stop points (accessible
+    through the stops() function) that describes how the gradient area
+    should be filled. If no stop points have been specified, a gradient
+    of black at 0 to white at 1 is used.
+
+    A diagonal linear gradient from black at (100, 100) to white at
+    (200, 200) could be specified like this:
+
+    \snippet doc/src/snippets/brush/brush.cpp 0
+
+    A gradient can have an arbitrary number of stop points. The
+    following would create a radial gradient starting with
+    red in the center, blue and then green on the edges:
+
+    \snippet doc/src/snippets/brush/brush.cpp 1
+
+    It is possible to repeat or reflect the gradient outside its area
+    by specifiying the \l {QGradient::Spread}{spread method} using the
+    setSpread() function. The default is to pad the outside area with
+    the color at the closest stop point. The currently set \l
+    {QGradient::Spread}{spread method} can be retrieved using the
+    spread() function. The QGradient::Spread enum defines three
+    different methods:
+
+    \table
+    \row
+    \o \inlineimage qradialgradient-pad.png
+    \o \inlineimage qradialgradient-repeat.png
+    \o \inlineimage qradialgradient-reflect.png
+    \row
+    \o \l {QGradient::PadSpread}{PadSpread}
+    \o \l {QGradient::RepeatSpread}{RepeatSpread}
+    \o \l {QGradient::ReflectSpread}{ReflectSpread}
+    \endtable
+
+    Note that the setSpread() function only has effect for linear and
+    radial gradients. The reason is that the conical gradient is
+    closed by definition, i.e. the \e conical gradient fills the
+    entire circle from 0 - 360 degrees, while the boundary of a radial
+    or a linear gradient can be specified through its radius or final
+    stop points, respectively.
+
+    The gradient coordinates can be specified in logical coordinates,
+    relative to device coordinates, or relative to object bounding box coordinates.
+    The \l {QGradient::CoordinateMode}{coordinate mode} can be set using the
+    setCoordinateMode() function. The default is LogicalMode, where the
+    gradient coordinates are specified in the same way as the object
+    coordinates. To retrieve the currently set \l {QGradient::CoordinateMode}
+    {coordinate mode} use coordinateMode().
+
+
+    \sa {demos/gradients}{The Gradients Demo}, QBrush
+*/
+
+/*!
+    \internal
+*/
+QGradient::QGradient()
+    : m_type(NoGradient), dummy(0)
+{
+}
+
+
+/*!
+    \enum QGradient::Type
+
+    Specifies the type of gradient.
+
+    \value LinearGradient  Interpolates colors between start and end points
+    (QLinearGradient).
+
+    \value RadialGradient Interpolate colors between a focal point and end
+    points on a circle surrounding it (QRadialGradient).
+
+    \value ConicalGradient Interpolate colors around a center point (QConicalGradient).
+    \value NoGradient No gradient is used.
+
+    \sa type()
+*/
+
+/*!
+    \enum QGradient::Spread
+
+    Specifies how the area outside the gradient area should be
+    filled.
+
+    \value PadSpread The area is filled with the closest stop
+    color. This is the default.
+
+    \value RepeatSpread The gradient  is repeated outside the gradient
+    area.
+
+    \value ReflectSpread The gradient is reflected outside the
+    gradient area.
+
+    \sa spread(), setSpread()
+*/
+
+/*!
+    \fn void QGradient::setSpread(Spread method)
+
+    Specifies the spread \a method that should be used for this
+    gradient.
+
+    Note that this function only has effect for linear and radial
+    gradients.
+
+    \sa spread()
+*/
+
+/*!
+    \fn QGradient::Spread QGradient::spread() const
+
+    Returns the spread method use by this gradient. The default is
+    PadSpread.
+
+    \sa setSpread()
+*/
+
+/*!
+    \fn QGradient::Type QGradient::type() const
+
+    Returns the type of gradient.
+*/
+
+/*!
+    \fn void QGradient::setColorAt(qreal position, const QColor &color)
+
+    Creates a stop point at the given \a position with the given \a
+    color. The given \a position must be in the range 0 to 1.
+
+    \sa setStops(), stops()
+*/
+
+void QGradient::setColorAt(qreal pos, const QColor &color)
+{
+    if ((pos > 1 || pos < 0) && !qIsNaN(pos)) {
+        qWarning("QGradient::setColorAt: Color position must be specified in the range 0 to 1");
+        return;
+    }
+
+    int index = 0;
+    if (!qIsNaN(pos))
+        while (index < m_stops.size() && m_stops.at(index).first < pos) ++index;
+
+    if (index < m_stops.size() && m_stops.at(index).first == pos)
+        m_stops[index].second = color;
+    else
+        m_stops.insert(index, QGradientStop(pos, color));
+}
+
+/*!
+    \fn void QGradient::setStops(const QGradientStops &stopPoints)
+
+    Replaces the current set of stop points with the given \a
+    stopPoints. The positions of the points must be in the range 0 to
+    1, and must be sorted with the lowest point first.
+
+    \sa setColorAt(), stops()
+*/
+void QGradient::setStops(const QGradientStops &stops)
+{
+    m_stops.clear();
+    for (int i=0; i<stops.size(); ++i)
+        setColorAt(stops.at(i).first, stops.at(i).second);
+}
+
+
+/*!
+    Returns the stop points for this gradient.
+
+    If no stop points have been specified, a gradient of black at 0 to white
+    at 1 is used.
+
+    \sa setStops(), setColorAt()
+*/
+QGradientStops QGradient::stops() const
+{
+    if (m_stops.isEmpty()) {
+        QGradientStops tmp;
+        tmp << QGradientStop(0, Qt::black) << QGradientStop(1, Qt::white);
+        return tmp;
+    }
+    return m_stops;
+}
+
+#define Q_DUMMY_ACCESSOR union {void *p; uint i;}; p = dummy;
+
+/*!
+    \enum QGradient::CoordinateMode
+    \since 4.4
+
+    This enum specifies how gradient coordinates map to the paint
+    device on which the gradient is used.
+
+    \value LogicalMode This is the default mode. The gradient coordinates
+    are specified logical space just like the object coordinates.
+    \value StretchToDeviceMode In this mode the gradient coordinates
+    are relative to the bounding rectangle of the paint device,
+    with (0,0) in the top left corner, and (1,1) in the bottom right
+    corner of the paint device.
+    \value ObjectBoundingMode In this mode the gradient coordinates are
+    relative to the bounding rectangle of the object being drawn, with
+    (0,0) in the top left corner, and (1,1) in the bottom right corner
+    of the object's bounding rectangle.
+*/
+
+/*!
+    \since 4.4
+
+    Returns the coordinate mode of this gradient. The default mode is
+    LogicalMode.
+*/
+QGradient::CoordinateMode QGradient::coordinateMode() const
+{
+    Q_DUMMY_ACCESSOR
+    return CoordinateMode(i & 0x03);
+}
+
+/*!
+    \since 4.4
+
+    Sets the coordinate mode of this gradient to \a mode. The default
+    mode is LogicalMode.
+*/
+void QGradient::setCoordinateMode(CoordinateMode mode)
+{
+    Q_DUMMY_ACCESSOR
+    i &= ~0x03;
+    i |= uint(mode);
+    dummy = p;
+}
+
+/*!
+    \enum QGradient::InterpolationMode
+    \since 4.5
+    \internal
+
+    \value ComponentInterpolation The color components and the alpha component are
+    independently linearly interpolated.
+    \value ColorInterpolation The colors are linearly interpolated in
+    premultiplied color space.
+*/
+
+/*!
+    \since 4.5
+    \internal
+
+    Returns the interpolation mode of this gradient. The default mode is
+    ColorInterpolation.
+*/
+QGradient::InterpolationMode QGradient::interpolationMode() const
+{
+    Q_DUMMY_ACCESSOR
+    return InterpolationMode((i >> 2) & 0x01);
+}
+
+/*!
+    \since 4.5
+    \internal
+
+    Sets the interpolation mode of this gradient to \a mode. The default
+    mode is ColorInterpolation.
+*/
+void QGradient::setInterpolationMode(InterpolationMode mode)
+{
+    Q_DUMMY_ACCESSOR
+    i &= ~(1 << 2);
+    i |= (uint(mode) << 2);
+    dummy = p;
+}
+
+#undef Q_DUMMY_ACCESSOR
+
+/*!
+    \fn bool QGradient::operator!=(const QGradient &gradient) const
+    \since 4.2
+
+    Returns true if the gradient is the same as the other \a gradient
+    specified; otherwise returns false.
+
+    \sa operator==()
+*/
+
+/*!
+    Returns true if the gradient is the same as the other \a gradient
+    specified; otherwise returns false.
+
+    \sa operator!=()
+*/
+bool QGradient::operator==(const QGradient &gradient) const
+{
+    if (gradient.m_type != m_type
+        || gradient.m_spread != m_spread
+        || gradient.dummy != dummy) return false;
+
+    if (m_type == LinearGradient) {
+        if (m_data.linear.x1 != gradient.m_data.linear.x1
+            || m_data.linear.y1 != gradient.m_data.linear.y1
+            || m_data.linear.x2 != gradient.m_data.linear.x2
+            || m_data.linear.y2 != gradient.m_data.linear.y2)
+            return false;
+    } else if (m_type == RadialGradient) {
+        if (m_data.radial.cx != gradient.m_data.radial.cx
+            || 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)
+            return false;
+    } else { // m_type == ConicalGradient
+        if (m_data.conical.cx != gradient.m_data.conical.cx
+            || m_data.conical.cy != gradient.m_data.conical.cy
+            || m_data.conical.angle != gradient.m_data.conical.angle)
+            return false;
+    }
+
+    return stops() == gradient.stops();
+}
+
+/*!
+    \internal
+*/
+bool QGradient::operator==(const QGradient &gradient)
+{
+    return const_cast<const QGradient *>(this)->operator==(gradient);
+}
+
+/*!
+    \class QLinearGradient
+    \ingroup painting
+
+    \brief The QLinearGradient class is used in combination with QBrush to
+    specify a linear gradient brush.
+
+    Linear gradients interpolate colors between start and end
+    points. Outside these points the gradient is either padded,
+    reflected or repeated depending on the currently set \l
+    {QGradient::Spread}{spread} method:
+
+    \table
+    \row
+    \o \inlineimage qlineargradient-pad.png
+    \o \inlineimage qlineargradient-reflect.png
+    \o \inlineimage qlineargradient-repeat.png
+    \row
+    \o \l {QGradient::PadSpread}{PadSpread} (default)
+    \o \l {QGradient::ReflectSpread}{ReflectSpread}
+    \o \l {QGradient::RepeatSpread}{RepeatSpread}
+    \endtable
+
+    The colors in a gradient is defined using stop points of the
+    QGradientStop type, i.e. a position and a color. Use the
+    QGradient::setColorAt() or the QGradient::setStops() function to
+    define the stop points. It is the gradient's complete set of stop
+    points that describes how the gradient area should be filled. If
+    no stop points have been specified, a gradient of black at 0 to
+    white at 1 is used.
+
+    In addition to the functions inherited from QGradient, the
+    QLinearGradient class provides the finalStop() function which
+    returns the final stop point of the gradient, and the start()
+    function returning the start point of the gradient.
+
+    \sa QRadialGradient, QConicalGradient, {demos/gradients}{The
+    Gradients Demo}
+*/
+
+
+/*!
+    Constructs a default linear gradient with interpolation area
+    between (0, 0) and (1, 1).
+
+    \sa QGradient::setColorAt(), setStart(), setFinalStop()
+*/
+
+QLinearGradient::QLinearGradient()
+{
+    m_type = LinearGradient;
+    m_spread = PadSpread;
+    m_data.linear.x1 = 0;
+    m_data.linear.y1 = 0;
+    m_data.linear.x2 = 1;
+    m_data.linear.y2 = 1;
+}
+
+
+/*!
+    Constructs a linear gradient with interpolation area between the
+    given \a start point and \a finalStop.
+
+    \note The expected parameter values are in pixels.
+
+    \sa QGradient::setColorAt(), QGradient::setStops()
+*/
+QLinearGradient::QLinearGradient(const QPointF &start, const QPointF &finalStop)
+{
+    m_type = LinearGradient;
+    m_spread = PadSpread;
+    m_data.linear.x1 = start.x();
+    m_data.linear.y1 = start.y();
+    m_data.linear.x2 = finalStop.x();
+    m_data.linear.y2 = finalStop.y();
+}
+
+/*!
+    \fn QLinearGradient::QLinearGradient(qreal x1, qreal y1, qreal x2, qreal y2)
+
+    Constructs a linear gradient with interpolation area between (\a
+    x1, \a y1) and (\a x2, \a y2).
+
+    \note The expected parameter values are in pixels.
+
+    \sa QGradient::setColorAt(), QGradient::setStops()
+*/
+QLinearGradient::QLinearGradient(qreal xStart, qreal yStart, qreal xFinalStop, qreal yFinalStop)
+{
+    m_type = LinearGradient;
+    m_spread = PadSpread;
+    m_data.linear.x1 = xStart;
+    m_data.linear.y1 = yStart;
+    m_data.linear.x2 = xFinalStop;
+    m_data.linear.y2 = yFinalStop;
+}
+
+
+/*!
+    Returns the start point of this linear gradient in logical coordinates.
+
+    \sa QGradient::stops()
+*/
+
+QPointF QLinearGradient::start() const
+{
+    Q_ASSERT(m_type == LinearGradient);
+    return QPointF(m_data.linear.x1, m_data.linear.y1);
+}
+
+/*!
+    \fn void QLinearGradient::setStart(qreal x, qreal y)
+    \overload
+    \since 4.2
+
+    Sets the start point of this linear gradient in logical
+    coordinates to \a x, \a y.
+
+    \sa start()
+*/
+
+/*!
+    \since 4.2
+
+    Sets the start point of this linear gradient in logical
+    coordinates to \a start.
+
+    \sa start()
+*/
+
+void QLinearGradient::setStart(const QPointF &start)
+{
+    Q_ASSERT(m_type == LinearGradient);
+    m_data.linear.x1 = start.x();
+    m_data.linear.y1 = start.y();
+}
+
+
+/*!
+    \fn void QLinearGradient::setFinalStop(qreal x, qreal y)
+    \overload
+    \since 4.2
+
+    Sets the final stop point of this linear gradient in logical
+    coordinates to \a x, \a y.
+
+    \sa start()
+*/
+
+/*!
+    Returns the final stop point of this linear gradient in logical coordinates.
+
+    \sa QGradient::stops()
+*/
+
+QPointF QLinearGradient::finalStop() const
+{
+    Q_ASSERT(m_type == LinearGradient);
+    return QPointF(m_data.linear.x2, m_data.linear.y2);
+}
+
+
+/*!
+    \since 4.2
+
+    Sets the final stop point of this linear gradient in logical
+    coordinates to \a stop.
+
+    \sa finalStop()
+*/
+
+void QLinearGradient::setFinalStop(const QPointF &stop)
+{
+    Q_ASSERT(m_type == LinearGradient);
+    m_data.linear.x2 = stop.x();
+    m_data.linear.y2 = stop.y();
+}
+
+
+/*!
+    \class QRadialGradient
+    \ingroup painting
+
+    \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:
+
+    \table
+    \row
+    \o \inlineimage qradialgradient-pad.png
+    \o \inlineimage qradialgradient-reflect.png
+    \o \inlineimage qradialgradient-repeat.png
+    \row
+    \o \l {QGradient::PadSpread}{PadSpread} (default)
+    \o \l {QGradient::ReflectSpread}{ReflectSpread}
+    \o \l {QGradient::RepeatSpread}{RepeatSpread}
+    \endtable
+
+    The colors in a gradient is defined using stop points of the
+    QGradientStop type, i.e. a position and a color. Use the
+    QGradient::setColorAt() or the QGradient::setStops() function to
+    define the stop points. It is the gradient's complete set of stop
+    points that describes how the gradient area should be filled.  If
+    no stop points have been specified, a gradient of black at 0 to
+    white at 1 is used.
+
+    In addition to the functions inherited from QGradient, the
+    QRadialGradient class provides the center(), focalPoint() and
+    radius() functions returning the gradient's center, focal point
+    and radius respectively.
+
+    \sa QLinearGradient, QConicalGradient, {demos/gradients}{The
+    Gradients Demo}
+*/
+
+static QPointF qt_radial_gradient_adapt_focal_point(const QPointF &center,
+                                                    qreal radius,
+                                                    const QPointF &focalPoint)
+{
+    // We have a one pixel buffer zone to avoid numerical instability on the
+    // circle border
+    //### this is hacky because technically we should adjust based on current matrix
+    const qreal compensated_radius = radius - radius * qreal(0.001);
+    QLineF line(center, focalPoint);
+    if (line.length() > (compensated_radius))
+        line.setLength(compensated_radius);
+    return line.p2();
+}
+
+/*!
+    Constructs a radial gradient with the given \a center, \a
+    radius and \a focalPoint.
+
+    \sa QGradient::setColorAt(), QGradient::setStops()
+*/
+
+QRadialGradient::QRadialGradient(const QPointF &center, qreal radius, const QPointF &focalPoint)
+{
+    m_type = RadialGradient;
+    m_spread = PadSpread;
+    m_data.radial.cx = center.x();
+    m_data.radial.cy = center.y();
+    m_data.radial.radius = radius;
+
+    QPointF adapted_focal = qt_radial_gradient_adapt_focal_point(center, radius, focalPoint);
+    m_data.radial.fx = adapted_focal.x();
+    m_data.radial.fy = adapted_focal.y();
+}
+
+/*!
+    Constructs a radial gradient with the given \a center, \a
+    radius and the focal point in the circle center.
+
+    \sa QGradient::setColorAt(), QGradient::setStops()
+*/
+QRadialGradient::QRadialGradient(const QPointF &center, qreal radius)
+{
+    m_type = RadialGradient;
+    m_spread = PadSpread;
+    m_data.radial.cx = center.x();
+    m_data.radial.cy = center.y();
+    m_data.radial.radius = 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),
+    \a radius and focal point (\a fx, \a fy).
+
+    \sa QGradient::setColorAt(), QGradient::setStops()
+*/
+
+QRadialGradient::QRadialGradient(qreal cx, qreal cy, qreal radius, qreal fx, qreal fy)
+{
+    m_type = RadialGradient;
+    m_spread = PadSpread;
+    m_data.radial.cx = cx;
+    m_data.radial.cy = cy;
+    m_data.radial.radius = radius;
+
+    QPointF adapted_focal = qt_radial_gradient_adapt_focal_point(QPointF(cx, cy),
+                                                                 radius,
+                                                                 QPointF(fx, fy));
+
+    m_data.radial.fx = adapted_focal.x();
+    m_data.radial.fy = adapted_focal.y();
+}
+
+/*!
+    Constructs a 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()
+ */
+QRadialGradient::QRadialGradient(qreal cx, qreal cy, qreal radius)
+{
+    m_type = RadialGradient;
+    m_spread = PadSpread;
+    m_data.radial.cx = cx;
+    m_data.radial.cy = cy;
+    m_data.radial.radius = radius;
+    m_data.radial.fx = cx;
+    m_data.radial.fy = cy;
+}
+
+
+/*!
+    Constructs a radial gradient with the center and focal point at
+    (0, 0) with a radius of 1.
+*/
+QRadialGradient::QRadialGradient()
+{
+    m_type = RadialGradient;
+    m_spread = PadSpread;
+    m_data.radial.cx = 0;
+    m_data.radial.cy = 0;
+    m_data.radial.radius = 1;
+    m_data.radial.fx = 0;
+    m_data.radial.fy = 0;
+}
+
+
+/*!
+    Returns the center of this radial gradient in logical coordinates.
+
+    \sa QGradient::stops()
+*/
+
+QPointF QRadialGradient::center() const
+{
+    Q_ASSERT(m_type == RadialGradient);
+    return QPointF(m_data.radial.cx, m_data.radial.cy);
+}
+
+/*!
+    \fn void QRadialGradient::setCenter(qreal x, qreal y)
+    \overload
+    \since 4.2
+
+    Sets the center of this radial gradient in logical coordinates
+    to (\a x, \a y).
+
+    \sa center()
+*/
+
+/*!
+    \since 4.2
+
+    Sets the center of this radial gradient in logical coordinates
+    to \a center.
+
+    \sa center()
+*/
+
+void QRadialGradient::setCenter(const QPointF &center)
+{
+    Q_ASSERT(m_type == RadialGradient);
+    m_data.radial.cx = center.x();
+    m_data.radial.cy = center.y();
+}
+
+
+/*!
+    Returns the radius of this radial gradient in logical coordinates.
+
+    \sa QGradient::stops()
+*/
+
+qreal QRadialGradient::radius() const
+{
+    Q_ASSERT(m_type == RadialGradient);
+    return m_data.radial.radius;
+}
+
+
+/*!
+    \since 4.2
+
+    Sets the radius of this radial gradient in logical coordinates
+    to \a radius
+*/
+void QRadialGradient::setRadius(qreal radius)
+{
+    Q_ASSERT(m_type == RadialGradient);
+    m_data.radial.radius = radius;
+}
+
+
+/*!
+    Returns the focal point of this radial gradient in logical
+    coordinates.
+
+    \sa QGradient::stops()
+*/
+
+QPointF QRadialGradient::focalPoint() const
+{
+    Q_ASSERT(m_type == RadialGradient);
+    return QPointF(m_data.radial.fx, m_data.radial.fy);
+}
+
+/*!
+    \fn void QRadialGradient::setFocalPoint(qreal x, qreal y)
+    \overload
+    \since 4.2
+
+    Sets the focal point of this radial gradient in logical
+    coordinates to (\a x, \a y).
+
+    \sa focalPoint()
+*/
+
+/*!
+    \since 4.2
+
+    Sets the focal point of this radial gradient in logical
+    coordinates to \a focalPoint.
+
+    \sa focalPoint()
+*/
+
+void QRadialGradient::setFocalPoint(const QPointF &focalPoint)
+{
+    Q_ASSERT(m_type == RadialGradient);
+    m_data.radial.fx = focalPoint.x();
+    m_data.radial.fy = focalPoint.y();
+}
+
+
+
+/*!
+    \class QConicalGradient
+    \ingroup painting
+
+    \brief The QConicalGradient class is used in combination with QBrush to
+    specify a conical gradient brush.
+
+    Conical gradients interpolate interpolate colors counter-clockwise
+    around a center point.
+
+    \image qconicalgradient.png
+
+    The colors in a gradient is defined using stop points of the
+    QGradientStop type, i.e. a position and a color. Use the
+    QGradient::setColorAt() or the QGradient::setStops() function to
+    define the stop points. It is the gradient's complete set of stop
+    points that describes how the gradient area should be filled. If
+    no stop points have been specified, a gradient of black at 0 to
+    white at 1 is used.
+
+    In addition to the functions inherited from QGradient, the
+    QConicalGradient class provides the angle() and center() functions
+    returning the start angle and center of the gradient.
+
+    Note that the setSpread() function has no effect for conical
+    gradients. The reason is that the conical gradient is closed by
+    definition, i.e. the conical gradient fills the entire circle from
+    0 - 360 degrees, while the boundary of a radial or a linear
+    gradient can be specified through its radius or final stop points,
+    respectively.
+
+    \sa QLinearGradient, QRadialGradient, {demos/gradients}{The
+    Gradients Demo}
+*/
+
+
+/*!
+    Constructs a conical gradient with the given \a center, starting
+    the interpolation at the given \a angle. The \a angle must be
+    specified in degrees between 0 and 360.
+
+    \sa QGradient::setColorAt(), QGradient::setStops()
+*/
+
+QConicalGradient::QConicalGradient(const QPointF &center, qreal angle)
+{
+    m_type = ConicalGradient;
+    m_spread = PadSpread;
+    m_data.conical.cx = center.x();
+    m_data.conical.cy = center.y();
+    m_data.conical.angle = angle;
+}
+
+
+/*!
+    Constructs a conical gradient with the given center (\a cx, \a
+    cy), starting the interpolation at the given \a angle. The angle
+    must be specified in degrees between 0 and 360.
+
+    \sa QGradient::setColorAt(), QGradient::setStops()
+*/
+
+QConicalGradient::QConicalGradient(qreal cx, qreal cy, qreal angle)
+{
+    m_type = ConicalGradient;
+    m_spread = PadSpread;
+    m_data.conical.cx = cx;
+    m_data.conical.cy = cy;
+    m_data.conical.angle = angle;
+}
+
+
+/*!
+    Constructs a conical with center at (0, 0) starting the
+    interpolation at angle 0.
+
+    \sa QGradient::setColorAt(), setCenter(), setAngle()
+*/
+
+QConicalGradient::QConicalGradient()
+{
+    m_type = ConicalGradient;
+    m_spread = PadSpread;
+    m_data.conical.cx = 0;
+    m_data.conical.cy = 0;
+    m_data.conical.angle = 0;
+}
+
+
+/*!
+    Returns the center of the conical gradient in logical
+    coordinates.
+
+    \sa stops()
+*/
+
+QPointF QConicalGradient::center() const
+{
+    Q_ASSERT(m_type == ConicalGradient);
+    return QPointF(m_data.conical.cx, m_data.conical.cy);
+}
+
+
+/*!
+    \fn void QConicalGradient::setCenter(qreal x, qreal y)
+
+    \overload
+
+    Sets the center of this conical gradient in logical coordinates to
+    (\a x, \a y).
+
+    \sa center()
+*/
+
+/*!
+    Sets the center of this conical gradient in logical coordinates to
+    \a center.
+
+    \sa center()
+*/
+
+void QConicalGradient::setCenter(const QPointF &center)
+{
+    Q_ASSERT(m_type == ConicalGradient);
+    m_data.conical.cx = center.x();
+    m_data.conical.cy = center.y();
+}
+
+/*!
+    Returns the start angle of the conical gradient in logical
+    coordinates.
+
+    \sa stops()
+*/
+
+qreal QConicalGradient::angle() const
+{
+    Q_ASSERT(m_type == ConicalGradient);
+    return m_data.conical.angle;
+}
+
+
+/*!
+    \since 4.2
+
+    Sets \a angle to be the start angle for this conical gradient in
+    logical coordinates.
+
+    \sa angle()
+*/
+
+void QConicalGradient::setAngle(qreal angle)
+{
+    Q_ASSERT(m_type == ConicalGradient);
+    m_data.conical.angle = angle;
+}
+
+/*!
+    \typedef QGradientStop
+    \relates QGradient
+
+    Typedef for QPair<\l qreal, QColor>.
+*/
+
+/*!
+    \typedef QGradientStops
+    \relates QGradient
+
+    Typedef for QVector<QGradientStop>.
+*/
+
+/*!
+    \typedef QBrush::DataPtr
+    \internal
+*/
+
+/*!
+    \fn DataPtr &QBrush::data_ptr()
+    \internal
+*/
+
+
+/*!
+    \fn bool QBrush::isDetached() const
+    \internal
+*/
+
+/*!
+    \fn QTransform QBrush::transform() const
+    \since 4.3
+
+    Returns the current transformation matrix for the brush.
+
+    \sa setTransform()
+*/
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qbrush.h b/src/gui/painting/qbrush.h
new file mode 100644
index 0000000000..8b313196db
--- /dev/null
+++ b/src/gui/painting/qbrush.h
@@ -0,0 +1,338 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QBRUSH_H
+#define QBRUSH_H
+
+#include <QtCore/qpair.h>
+#include <QtCore/qpoint.h>
+#include <QtCore/qvector.h>
+#include <QtCore/qscopedpointer.h>
+#include <QtGui/qcolor.h>
+#include <QtGui/qmatrix.h>
+#include <QtGui/qtransform.h>
+#include <QtGui/qimage.h>
+#include <QtGui/qpixmap.h>
+
+#if defined(Q_OS_VXWORKS)
+#  if defined(m_data)
+#    undef m_data
+#  endif
+#  if defined(m_type)
+#    undef m_type
+#  endif
+#endif
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+struct QBrushData;
+class QPixmap;
+class QGradient;
+class QVariant;
+struct QBrushDataPointerDeleter;
+
+class Q_GUI_EXPORT QBrush
+{
+public:
+    QBrush();
+    QBrush(Qt::BrushStyle bs);
+    QBrush(const QColor &color, Qt::BrushStyle bs=Qt::SolidPattern);
+    QBrush(Qt::GlobalColor color, Qt::BrushStyle bs=Qt::SolidPattern);
+
+    QBrush(const QColor &color, const QPixmap &pixmap);
+    QBrush(Qt::GlobalColor color, const QPixmap &pixmap);
+    QBrush(const QPixmap &pixmap);
+    QBrush(const QImage &image);
+
+    QBrush(const QBrush &brush);
+
+    QBrush(const QGradient &gradient);
+
+    ~QBrush();
+    QBrush &operator=(const QBrush &brush);
+#ifdef Q_COMPILER_RVALUE_REFS
+    inline QBrush &operator=(QBrush &&other)
+    { qSwap(d, other.d); return *this; }
+#endif
+    inline void swap(QBrush &other) { qSwap(d, other.d); }
+
+    operator QVariant() const;
+
+    inline Qt::BrushStyle style() const;
+    void setStyle(Qt::BrushStyle);
+
+    inline const QMatrix &matrix() const;
+    void setMatrix(const QMatrix &mat);
+
+    inline QTransform transform() const;
+    void setTransform(const QTransform &);
+
+    QPixmap texture() const;
+    void setTexture(const QPixmap &pixmap);
+
+    QImage textureImage() const;
+    void setTextureImage(const QImage &image);
+
+    inline const QColor &color() const;
+    void setColor(const QColor &color);
+    inline void setColor(Qt::GlobalColor color);
+
+    const QGradient *gradient() const;
+
+    bool isOpaque() const;
+
+    bool operator==(const QBrush &b) const;
+    inline bool operator!=(const QBrush &b) const { return !(operator==(b)); }
+
+#ifdef QT3_SUPPORT
+    inline QT3_SUPPORT operator const QColor&() const;
+    QT3_SUPPORT QPixmap *pixmap() const;
+    inline QT3_SUPPORT void setPixmap(const QPixmap &pixmap) { setTexture(pixmap); }
+#endif
+
+private:
+#if defined(Q_WS_X11)
+    friend class QX11PaintEngine;
+#endif
+    friend class QRasterPaintEngine;
+    friend class QRasterPaintEnginePrivate;
+    friend struct QSpanData;
+    friend class QPainter;
+    friend bool Q_GUI_EXPORT qHasPixmapTexture(const QBrush& brush);
+    void detach(Qt::BrushStyle newStyle);
+    void init(const QColor &color, Qt::BrushStyle bs);
+    QScopedPointer<QBrushData, QBrushDataPointerDeleter> d;
+    void cleanUp(QBrushData *x);
+
+public:
+    inline bool isDetached() const;
+    typedef QScopedPointer<QBrushData, QBrushDataPointerDeleter> DataPtr;
+    inline DataPtr &data_ptr() { return d; }
+};
+
+inline void QBrush::setColor(Qt::GlobalColor acolor)
+{ setColor(QColor(acolor)); }
+
+Q_DECLARE_TYPEINFO(QBrush, Q_MOVABLE_TYPE);
+Q_DECLARE_SHARED(QBrush)
+
+/*****************************************************************************
+  QBrush stream functions
+ *****************************************************************************/
+
+#ifndef QT_NO_DATASTREAM
+Q_GUI_EXPORT QDataStream &operator<<(QDataStream &, const QBrush &);
+Q_GUI_EXPORT QDataStream &operator>>(QDataStream &, QBrush &);
+#endif
+
+#ifndef QT_NO_DEBUG_STREAM
+Q_GUI_EXPORT QDebug operator<<(QDebug, const QBrush &);
+#endif
+
+struct QBrushData
+{
+    QAtomicInt ref;
+    Qt::BrushStyle style;
+    QColor color;
+    QTransform transform;
+};
+
+inline Qt::BrushStyle QBrush::style() const { return d->style; }
+inline const QColor &QBrush::color() const { return d->color; }
+inline const QMatrix &QBrush::matrix() const { return d->transform.toAffine(); }
+inline QTransform QBrush::transform() const { return d->transform; }
+inline bool QBrush::isDetached() const { return d->ref == 1; }
+
+#ifdef QT3_SUPPORT
+inline QBrush::operator const QColor&() const { return d->color; }
+#endif
+
+
+/*******************************************************************************
+ * QGradients
+ */
+class QGradientPrivate;
+
+typedef QPair<qreal, QColor> QGradientStop;
+typedef QVector<QGradientStop> QGradientStops;
+
+class Q_GUI_EXPORT QGradient
+{
+    Q_GADGET
+    Q_ENUMS(Type Spread CoordinateMode)
+public:
+    enum Type {
+        LinearGradient,
+        RadialGradient,
+        ConicalGradient,
+        NoGradient
+    };
+
+    enum Spread {
+        PadSpread,
+        ReflectSpread,
+        RepeatSpread
+    };
+
+    enum CoordinateMode {
+        LogicalMode,
+        StretchToDeviceMode,
+        ObjectBoundingMode
+    };
+
+    enum InterpolationMode {
+        ColorInterpolation,
+        ComponentInterpolation
+    };
+
+    QGradient();
+
+    Type type() const { return m_type; }
+
+    inline void setSpread(Spread spread);
+    Spread spread() const { return m_spread; }
+
+    void setColorAt(qreal pos, const QColor &color);
+
+    void setStops(const QGradientStops &stops);
+    QGradientStops stops() const;
+
+    CoordinateMode coordinateMode() const;
+    void setCoordinateMode(CoordinateMode mode);
+
+    InterpolationMode interpolationMode() const;
+    void setInterpolationMode(InterpolationMode mode);
+
+    bool operator==(const QGradient &gradient) const;
+    inline bool operator!=(const QGradient &other) const
+    { return !operator==(other); }
+
+    bool operator==(const QGradient &gradient); // ### Qt 5: remove
+
+private:
+    friend class QLinearGradient;
+    friend class QRadialGradient;
+    friend class QConicalGradient;
+
+    Type m_type;
+    Spread m_spread;
+    QGradientStops m_stops;
+    union {
+        struct {
+            qreal x1, y1, x2, y2;
+        } linear;
+        struct {
+            qreal cx, cy, fx, fy, radius;
+        } radial;
+        struct {
+            qreal cx, cy, angle;
+        } conical;
+    } m_data;
+    void *dummy;
+};
+
+inline void QGradient::setSpread(Spread aspread)
+{ m_spread = aspread; }
+
+class Q_GUI_EXPORT QLinearGradient : public QGradient
+{
+public:
+    QLinearGradient();
+    QLinearGradient(const QPointF &start, const QPointF &finalStop);
+    QLinearGradient(qreal xStart, qreal yStart, qreal xFinalStop, qreal yFinalStop);
+
+    QPointF start() const;
+    void setStart(const QPointF &start);
+    inline void setStart(qreal x, qreal y) { setStart(QPointF(x, y)); }
+
+    QPointF finalStop() const;
+    void setFinalStop(const QPointF &stop);
+    inline void setFinalStop(qreal x, qreal y) { setFinalStop(QPointF(x, y)); }
+};
+
+
+class Q_GUI_EXPORT QRadialGradient : public QGradient
+{
+public:
+    QRadialGradient();
+    QRadialGradient(const QPointF &center, qreal radius, const QPointF &focalPoint);
+    QRadialGradient(qreal cx, qreal cy, qreal radius, qreal fx, qreal fy);
+
+    QRadialGradient(const QPointF &center, qreal radius);
+    QRadialGradient(qreal cx, qreal cy, qreal radius);
+
+    QPointF center() const;
+    void setCenter(const QPointF &center);
+    inline void setCenter(qreal x, qreal y) { setCenter(QPointF(x, y)); }
+
+    QPointF focalPoint() const;
+    void setFocalPoint(const QPointF &focalPoint);
+    inline void setFocalPoint(qreal x, qreal y) { setFocalPoint(QPointF(x, y)); }
+
+    qreal radius() const;
+    void setRadius(qreal radius);
+};
+
+
+class Q_GUI_EXPORT QConicalGradient : public QGradient
+{
+public:
+    QConicalGradient();
+    QConicalGradient(const QPointF &center, qreal startAngle);
+    QConicalGradient(qreal cx, qreal cy, qreal startAngle);
+
+    QPointF center() const;
+    void setCenter(const QPointF &center);
+    inline void setCenter(qreal x, qreal y) { setCenter(QPointF(x, y)); }
+
+    qreal angle() const;
+    void setAngle(qreal angle);
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QBRUSH_H
diff --git a/src/gui/painting/qcolor.cpp b/src/gui/painting/qcolor.cpp
new file mode 100644
index 0000000000..ff6c24ee9e
--- /dev/null
+++ b/src/gui/painting/qcolor.cpp
@@ -0,0 +1,2720 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qcolor.h"
+#include "qcolor_p.h"
+#include "qnamespace.h"
+#include "qcolormap.h"
+#include "qdatastream.h"
+#include "qvariant.h"
+#include "qdebug.h"
+
+#ifdef Q_WS_X11
+#  include "qapplication.h"
+#  include "qx11info_x11.h"
+#  include "private/qt_x11_p.h"
+
+static bool allowX11ColorNames = false;
+
+#endif
+
+#include <math.h>
+#include <stdio.h>
+#include <limits.h>
+
+QT_BEGIN_NAMESPACE
+
+/*!
+    \class QColor
+    \brief The QColor class provides colors based on RGB, HSV or CMYK values.
+
+    \ingroup painting
+    \ingroup appearance
+
+
+    A color is normally specified in terms of RGB (red, green, and
+    blue) components, but it is also possible to specify it in terms
+    of HSV (hue, saturation, and value) and CMYK (cyan, magenta,
+    yellow and black) components. In addition a color can be specified
+    using a color name. The color name can be any of the SVG 1.0 color
+    names.
+
+    \table
+    \header
+    \o RGB \o HSV \o CMYK
+    \row
+    \o \inlineimage qcolor-rgb.png
+    \o \inlineimage qcolor-hsv.png
+    \o \inlineimage qcolor-cmyk.png
+    \endtable
+
+    The QColor constructor creates the color based on RGB values.  To
+    create a QColor based on either HSV or CMYK values, use the
+    toHsv() and toCmyk() functions respectively. These functions
+    return a copy of the color using the desired format. In addition
+    the static fromRgb(), fromHsv() and fromCmyk() functions create
+    colors from the specified values. Alternatively, a color can be
+    converted to any of the three formats using the convertTo()
+    function (returning a copy of the color in the desired format), or
+    any of the setRgb(), setHsv() and setCmyk() functions altering \e
+    this color's format. The spec() function tells how the color was
+    specified.
+
+    A color can be set by passing an RGB string (such as "#112233"),
+    or a color name (such as "blue"), to the setNamedColor() function.
+    The color names are taken from the SVG 1.0 color names. The name()
+    function returns the name of the color in the format
+    "#RRGGBB". Colors can also be set using setRgb(), setHsv() and
+    setCmyk(). To get a lighter or darker color use the lighter() and
+    darker() functions respectively.
+
+    The isValid() function indicates whether a QColor is legal at
+    all. For example, a RGB color with RGB values out of range is
+    illegal. For performance reasons, QColor mostly disregards illegal
+    colors, and for that reason, the result of using an invalid color
+    is undefined.
+
+    The color components can be retrieved individually, e.g with
+    red(), hue() and cyan(). The values of the color components can
+    also be retrieved in one go using the getRgb(), getHsv() and
+    getCmyk() functions. Using the RGB color model, the color
+    components can in addition be accessed with rgb().
+
+    There are several related non-members: QRgb is a typdef for an
+    unsigned int representing the RGB value triplet (r, g, b). Note
+    that it also can hold a value for the alpha-channel (for more
+    information, see the \l {QColor#Alpha-Blended
+    Drawing}{Alpha-Blended Drawing} section). The qRed(), qBlue() and
+    qGreen() functions return the respective component of the given
+    QRgb value, while the qRgb() and qRgba() functions create and
+    return the QRgb triplet based on the given component
+    values. Finally, the qAlpha() function returns the alpha component
+    of the provided QRgb, and the qGray() function calculates and
+    return a gray value based on the given value.
+
+    QColor is platform and device independent. The QColormap class
+    maps the color to the hardware.
+
+    For more information about painting in general, see the \l{Paint
+    System} documentation.
+
+    \tableofcontents
+
+    \section1 Integer vs. Floating Point Precision
+
+    QColor supports floating point precision and provides floating
+    point versions of all the color components functions,
+    e.g. getRgbF(), hueF() and fromCmykF(). Note that since the
+    components are stored using 16-bit integers, there might be minor
+    deviations between the values set using, for example, setRgbF()
+    and the values returned by the getRgbF() function due to rounding.
+
+    While the integer based functions take values in the range 0-255
+    (except hue() which must have values within the range 0-359),
+    the floating point functions accept values in the range 0.0 - 1.0.
+
+    \section1 Alpha-Blended Drawing
+
+    QColor also support alpha-blended outlining and filling. The
+    alpha channel of a color specifies the transparency effect, 0
+    represents a fully transparent color, while 255 represents a fully
+    opaque color. For example:
+
+    \snippet doc/src/snippets/code/src_gui_painting_qcolor.cpp 0
+
+    The code above produces the following output:
+
+    \img alphafill.png
+
+    Alpha-blended drawing is supported on Windows, Mac OS X, and on
+    X11 systems that have the X Render extension installed.
+
+    The alpha channel of a color can be retrieved and set using the
+    alpha() and setAlpha() functions if its value is an integer, and
+    alphaF() and setAlphaF() if its value is qreal (double). By
+    default, the alpha-channel is set to 255 (opaque). To retrieve and
+    set \e all the RGB color components (including the alpha-channel)
+    in one go, use the rgba() and setRgba() functions.
+
+    \section1 Predefined Colors
+
+    There are 20 predefined QColors described by the Qt::GlobalColor enum,
+    including black, white, primary and secondary colors, darker versions
+    of these colors and three shades of gray. QColor also recognizes a
+    variety of color names; the static colorNames() function returns a
+    QStringList color names that QColor knows about.
+
+    \img qt-colors.png Qt Colors
+
+    Additionally, the Qt::color0, Qt::color1 and Qt::transparent colors
+    are used for special purposes.
+
+    Qt::color0 (zero pixel value) and Qt::color1 (non-zero pixel value)
+    are special colors for drawing in QBitmaps. Painting with Qt::color0
+    sets the bitmap bits to 0 (transparent; i.e., background), and painting
+    with Qt::color1 sets the bits to 1 (opaque; i.e., foreground).
+
+    Qt::transparent is used to indicate a transparent pixel. When painting
+    with this value, a pixel value will be used that is appropriate for the
+    underlying pixel format in use.
+
+    \section1 The HSV Color Model
+
+    The RGB model is hardware-oriented. Its representation is close to
+    what most monitors show. In contrast, HSV represents color in a way
+    more suited to the human perception of color. For example, the
+    relationships "stronger than", "darker than", and "the opposite of"
+    are easily expressed in HSV but are much harder to express in RGB.
+
+    HSV, like RGB, has three components:
+
+    \list
+    \o H, for hue, is in the range 0 to 359 if the color is chromatic (not
+    gray), or meaningless if it is gray. It represents degrees on the
+    color wheel familiar to most people. Red is 0 (degrees), green is
+    120, and blue is 240.
+
+    \inlineimage qcolor-hue.png
+
+    \o S, for saturation, is in the range 0 to 255, and the bigger it is,
+    the stronger the color is. Grayish colors have saturation near 0; very
+    strong colors have saturation near 255.
+
+    \inlineimage qcolor-saturation.png
+
+    \o V, for value, is in the range 0 to 255 and represents lightness or
+    brightness of the color. 0 is black; 255 is as far from black as
+    possible.
+
+    \inlineimage qcolor-value.png
+    \endlist
+
+    Here are some examples: pure red is H=0, S=255, V=255; a dark red,
+    moving slightly towards the magenta, could be H=350 (equivalent to
+    -10), S=255, V=180; a grayish light red could have H about 0 (say
+    350-359 or 0-10), S about 50-100, and S=255.
+
+    Qt returns a hue value of -1 for achromatic colors. If you pass a
+    hue value that is too large, Qt forces it into range. Hue 360 or 720 is
+    treated as 0; hue 540 is treated as 180.
+
+    In addition to the standard HSV model, Qt provides an
+    alpha-channel to feature \l {QColor#Alpha-Blended
+    Drawing}{alpha-blended drawing}.
+
+    \section1 The HSL Color Model
+
+    HSL is similar to HSV. Instead of value parameter from HSV,
+    HSL has the lightness parameter.
+    The lightness parameter goes from black to color and from color to white.
+    If you go outside at the night its black or dark gray. At day its colorful but
+    if you look in a really strong light a things they are going to white and
+    wash out.
+
+    \section1 The CMYK Color Model
+
+    While the RGB and HSV color models are used for display on
+    computer monitors, the CMYK model is used in the four-color
+    printing process of printing presses and some hard-copy
+    devices.
+
+    CMYK has four components, all in the range 0-255: cyan (C),
+    magenta (M), yellow (Y) and black (K).  Cyan, magenta and yellow
+    are called subtractive colors; the CMYK color model creates color
+    by starting with a white surface and then subtracting color by
+    applying the appropriate components. While combining cyan, magenta
+    and yellow gives the color black, subtracting one or more will
+    yield any other color. When combined in various percentages, these
+    three colors can create the entire spectrum of colors.
+
+    Mixing 100 percent of cyan, magenta and yellow \e does produce
+    black, but the result is unsatisfactory since it wastes ink,
+    increases drying time, and gives a muddy colour when printing. For
+    that reason, black is added in professional printing to provide a
+    solid black tone; hence the term 'four color process'.
+
+    In addition to the standard CMYK model, Qt provides an
+    alpha-channel to feature \l {QColor#Alpha-Blended
+    Drawing}{alpha-blended drawing}.
+
+    \sa QPalette, QBrush, QApplication::setColorSpec()
+*/
+
+#define QCOLOR_INT_RANGE_CHECK(fn, var) \
+    do { \
+        if (var < 0 || var > 255) { \
+            qWarning(#fn": invalid value %d", var); \
+            var = qMax(0, qMin(var, 255)); \
+        } \
+    } while (0)
+
+#define QCOLOR_REAL_RANGE_CHECK(fn, var) \
+    do { \
+        if (var < qreal(0.0) || var > qreal(1.0)) { \
+            qWarning(#fn": invalid value %g", var); \
+            var = qMax(qreal(0.0), qMin(var, qreal(1.0)));      \
+        } \
+    } while (0)
+
+/*****************************************************************************
+  QColor member functions
+ *****************************************************************************/
+
+/*!
+    \enum QColor::Spec
+
+    The type of color specified, either RGB, HSV, CMYK or HSL.
+
+    \value Rgb
+    \value Hsv
+    \value Cmyk
+    \value Hsl
+    \value Invalid
+
+    \sa spec(), convertTo()
+*/
+
+/*!
+    \fn Spec QColor::spec() const
+
+    Returns how the color was specified.
+
+    \sa Spec, convertTo()
+*/
+
+
+/*!
+    \fn QColor::QColor()
+
+    Constructs an invalid color with the RGB value (0, 0, 0). An
+    invalid color is a color that is not properly set up for the
+    underlying window system.
+
+    The alpha value of an invalid color is unspecified.
+
+    \sa isValid()
+*/
+
+/*!
+    \overload
+
+    Constructs a new color with a color value of \a color.
+
+    \sa isValid(), {QColor#Predefined Colors}{Predefined Colors}
+ */
+QColor::QColor(Qt::GlobalColor color)
+{
+#define QRGB(r, g, b) \
+    QRgb(((0xffu << 24) | ((r & 0xff) << 16) | ((g & 0xff) << 8) | (b & 0xff)))
+#define QRGBA(r, g, b, a) \
+    QRgb(((a & 0xff) << 24) | ((r & 0xff) << 16) | ((g & 0xff) << 8) | (b & 0xff))
+
+    static const QRgb global_colors[] = {
+        QRGB(255, 255, 255), // Qt::color0
+        QRGB(  0,   0,   0), // Qt::color1
+        QRGB(  0,   0,   0), // black
+        QRGB(255, 255, 255), // white
+        /*
+         * From the "The Palette Manager: How and Why" by Ron Gery,
+         * March 23, 1992, archived on MSDN:
+         *
+         *     The Windows system palette is broken up into two
+         *     sections, one with fixed colors and one with colors
+         *     that can be changed by applications. The system palette
+         *     predefines 20 entries; these colors are known as the
+         *     static or reserved colors and consist of the 16 colors
+         *     found in the Windows version 3.0 VGA driver and 4
+         *     additional colors chosen for their visual appeal.  The
+         *     DEFAULT_PALETTE stock object is, as the name implies,
+         *     the default palette selected into a device context (DC)
+         *     and consists of these static colors. Applications can
+         *     set the remaining 236 colors using the Palette Manager.
+         *
+         * The 20 reserved entries have indices in [0,9] and
+         * [246,255]. We reuse 17 of them.
+         */
+        QRGB(128, 128, 128), // index 248   medium gray
+        QRGB(160, 160, 164), // index 247   light gray
+        QRGB(192, 192, 192), // index 7     light gray
+        QRGB(255,   0,   0), // index 249   red
+        QRGB(  0, 255,   0), // index 250   green
+        QRGB(  0,   0, 255), // index 252   blue
+        QRGB(  0, 255, 255), // index 254   cyan
+        QRGB(255,   0, 255), // index 253   magenta
+        QRGB(255, 255,   0), // index 251   yellow
+        QRGB(128,   0,   0), // index 1     dark red
+        QRGB(  0, 128,   0), // index 2     dark green
+        QRGB(  0,   0, 128), // index 4     dark blue
+        QRGB(  0, 128, 128), // index 6     dark cyan
+        QRGB(128,   0, 128), // index 5     dark magenta
+        QRGB(128, 128,   0), // index 3     dark yellow
+        QRGBA(0, 0, 0, 0)    //             transparent
+    };
+#undef QRGB
+#undef QRGBA
+
+    setRgb(qRed(global_colors[color]),
+           qGreen(global_colors[color]),
+           qBlue(global_colors[color]),
+           qAlpha(global_colors[color]));
+}
+
+/*!
+    \fn QColor::QColor(int r, int g, int b, int a = 255)
+
+    Constructs a color with the RGB value \a r, \a g, \a b, and the
+    alpha-channel (transparency) value of \a a.
+
+    The color is left invalid if any of the arguments are invalid.
+
+    \sa setRgba(), isValid()
+*/
+
+/*!
+    Constructs a color with the value \a color. The alpha component is
+    ignored and set to solid.
+
+    \sa fromRgb(), isValid()
+*/
+
+QColor::QColor(QRgb color)
+{
+    cspec = Rgb;
+    ct.argb.alpha = 0xffff;
+    ct.argb.red   = qRed(color)   * 0x101;
+    ct.argb.green = qGreen(color) * 0x101;
+    ct.argb.blue  = qBlue(color)  * 0x101;
+    ct.argb.pad   = 0;
+}
+
+
+/*!
+    \internal
+
+    Constructs a color with the given \a spec.
+
+    This function is primarly present to avoid that QColor::Invalid
+    becomes a valid color by accident.
+*/
+
+QColor::QColor(Spec spec)
+{
+    switch (spec) {
+    case Invalid:
+        invalidate();
+        break;
+    case Rgb:
+        setRgb(0, 0, 0);
+        break;
+    case Hsv:
+        setHsv(0, 0, 0);
+        break;
+    case Cmyk:
+        setCmyk(0, 0, 0, 0);
+        break;
+    case Hsl:
+        setHsl(0, 0, 0, 0);
+        break;
+    }
+}
+
+/*!
+    \fn QColor::QColor(const QString &name)
+
+    Constructs a named color in the same way as setNamedColor() using
+    the given \a name.
+
+    The color is left invalid if the \a name cannot be parsed.
+
+    \sa setNamedColor(), name(), isValid()
+*/
+
+/*!
+    \fn QColor::QColor(const char *name)
+
+    Constructs a named color in the same way as setNamedColor() using
+    the given \a name.
+
+    The color is left invalid if the \a name cannot be parsed.
+
+    \sa setNamedColor(), name(), isValid()
+*/
+
+/*!
+    \fn QColor::QColor(const QColor &color)
+
+    Constructs a color that is a copy of \a color.
+
+    \sa isValid()
+*/
+
+/*!
+    \fn bool QColor::isValid() const
+
+    Returns true if the color is valid; otherwise returns false.
+*/
+
+/*!
+    Returns the name of the color in the format "#RRGGBB"; i.e. a "#"
+    character followed by three two-digit hexadecimal numbers.
+
+    \sa setNamedColor()
+*/
+
+QString QColor::name() const
+{
+    QString s;
+    s.sprintf("#%02x%02x%02x", red(), green(), blue());
+    return s;
+}
+
+/*!
+    Sets the RGB value of this QColor to \a name, which may be in one
+    of these formats:
+
+    \list
+    \i #RGB (each of R, G, and B is a single hex digit)
+    \i #RRGGBB
+    \i #RRRGGGBBB
+    \i #RRRRGGGGBBBB
+    \i A name from the list of colors defined in the list of \l{SVG color keyword names}
+       provided by the World Wide Web Consortium; for example, "steelblue" or "gainsboro".
+       These color names work on all platforms. Note that these color names are \e not the
+       same as defined by the Qt::GlobalColor enums, e.g. "green" and Qt::green does not
+       refer to the same color.
+    \i \c transparent - representing the absence of a color.
+    \i \e{X11 only}: If allowX11ColorNames() returns true, any valid X11 color name. See
+       the documentation for \c XParseColor() for information about valid X11 color names.
+    \endlist
+
+    The color is invalid if \a name cannot be parsed.
+
+    \sa QColor(), name(), isValid(), allowX11ColorNames()
+*/
+
+void QColor::setNamedColor(const QString &name)
+{
+    if (!setColorFromString(name))
+        qWarning("QColor::setNamedColor: Unknown color name '%s'", name.toLatin1().constData());
+}
+
+/*!
+   \since 4.7
+
+   Returns true if the \a name is a valid color name and can
+   be used to construct a valid QColor object, otherwise returns
+   false.
+
+   It uses the same algorithm used in setNamedColor().
+
+   \sa setNamedColor()
+*/
+bool QColor::isValidColor(const QString &name)
+{
+    return !name.isEmpty() && QColor().setColorFromString(name);
+}
+
+bool QColor::setColorFromString(const QString &name)
+{
+    if (name.isEmpty()) {
+        invalidate();
+        return true;
+    }
+
+    if (name.startsWith(QLatin1Char('#'))) {
+        QRgb rgb;
+        if (qt_get_hex_rgb(name.constData(), name.length(), &rgb)) {
+            setRgb(rgb);
+            return true;
+        } else {
+            invalidate();
+            return false;
+        }
+    }
+
+#ifndef QT_NO_COLORNAMES
+    QRgb rgb;
+    if (qt_get_named_rgb(name.constData(), name.length(), &rgb)) {
+        setRgba(rgb);
+        return true;
+    } else
+#endif
+    {
+#ifdef Q_WS_X11
+        XColor result;
+        if (allowX11ColorNames()
+            && QApplication::instance()
+            && QX11Info::display()
+            && XParseColor(QX11Info::display(), QX11Info::appColormap(), name.toLatin1().constData(), &result)) {
+            setRgb(result.red >> 8, result.green >> 8, result.blue >> 8);
+            return true;
+        } else
+#endif
+        {
+            invalidate();
+            return false;
+        }
+    }
+}
+
+/*!
+    Returns a QStringList containing the color names Qt knows about.
+
+    \sa {QColor#Predefined Colors}{Predefined Colors}
+*/
+QStringList QColor::colorNames()
+{
+#ifndef QT_NO_COLORNAMES
+    return qt_get_colornames();
+#else
+    return QStringList();
+#endif
+}
+
+/*!
+    Sets the contents pointed to by \a h, \a s, \a v, and \a a, to the hue,
+    saturation, value, and alpha-channel (transparency) components of the
+    color's HSV value.
+
+    These components can be retrieved individually using the hueF(),
+    saturationF(), valueF() and alphaF() functions.
+
+    \sa setHsv() {QColor#The HSV Color Model}{The HSV Color Model}
+*/
+void QColor::getHsvF(qreal *h, qreal *s, qreal *v, qreal *a) const
+{
+        if (!h || !s || !v)
+        return;
+
+    if (cspec != Invalid && cspec != Hsv) {
+        toHsv().getHsvF(h, s, v, a);
+        return;
+    }
+
+    *h = ct.ahsv.hue == USHRT_MAX ? qreal(-1.0) : ct.ahsv.hue / qreal(36000.0);
+    *s = ct.ahsv.saturation / qreal(USHRT_MAX);
+    *v = ct.ahsv.value / qreal(USHRT_MAX);
+
+    if (a)
+        *a = ct.ahsv.alpha / qreal(USHRT_MAX);
+}
+
+/*!
+    Sets the contents pointed to by \a h, \a s, \a v, and \a a, to the hue,
+    saturation, value, and alpha-channel (transparency) components of the
+    color's HSV value.
+
+    These components can be retrieved individually using the hue(),
+    saturation(), value() and alpha() functions.
+
+    \sa setHsv(), {QColor#The HSV Color Model}{The HSV Color Model}
+*/
+void QColor::getHsv(int *h, int *s, int *v, int *a) const
+{
+    if (!h || !s || !v)
+        return;
+
+    if (cspec != Invalid && cspec != Hsv) {
+        toHsv().getHsv(h, s, v, a);
+        return;
+    }
+
+    *h = ct.ahsv.hue == USHRT_MAX ? -1 : ct.ahsv.hue / 100;
+    *s = ct.ahsv.saturation >> 8;
+    *v = ct.ahsv.value      >> 8;
+
+    if (a)
+        *a = ct.ahsv.alpha >> 8;
+}
+
+/*!
+    Sets a HSV color value; \a h is the hue, \a s is the saturation, \a v is
+    the value and \a a is the alpha component of the HSV color.
+
+    All the values must be in the range 0.0-1.0.
+
+    \sa getHsvF(), setHsv(), {QColor#The HSV Color Model}{The HSV
+    Color Model}
+*/
+void QColor::setHsvF(qreal h, qreal s, qreal v, qreal a)
+{
+    if (((h < qreal(0.0) || h > qreal(1.0)) && h != qreal(-1.0))
+        || (s < qreal(0.0) || s > qreal(1.0))
+        || (v < qreal(0.0) || v > qreal(1.0))
+        || (a < qreal(0.0) || a > qreal(1.0))) {
+        qWarning("QColor::setHsvF: HSV parameters out of range");
+        return;
+    }
+
+    cspec = Hsv;
+    ct.ahsv.alpha      = qRound(a * USHRT_MAX);
+    ct.ahsv.hue        = h == qreal(-1.0) ? USHRT_MAX : qRound(h * 36000);
+    ct.ahsv.saturation = qRound(s * USHRT_MAX);
+    ct.ahsv.value      = qRound(v * USHRT_MAX);
+    ct.ahsv.pad        = 0;
+}
+
+/*!
+    Sets a HSV color value; \a h is the hue, \a s is the saturation, \a v is
+    the value and \a a is the alpha component of the HSV color.
+
+    The saturation, value and alpha-channel values must be in the range 0-255,
+    and the hue value must be greater than -1.
+
+    \sa getHsv(), setHsvF(), {QColor#The HSV Color Model}{The HSV
+    Color Model}
+*/
+void QColor::setHsv(int h, int s, int v, int a)
+{
+    if (h < -1 || (uint)s > 255 || (uint)v > 255 || (uint)a > 255) {
+        qWarning("QColor::setHsv: HSV parameters out of range");
+        invalidate();
+        return;
+    }
+
+    cspec = Hsv;
+    ct.ahsv.alpha      = a * 0x101;
+    ct.ahsv.hue        = h == -1 ? USHRT_MAX : (h % 360) * 100;
+    ct.ahsv.saturation = s * 0x101;
+    ct.ahsv.value      = v * 0x101;
+    ct.ahsv.pad        = 0;
+}
+
+/*!
+    \since 4.6
+
+    Sets the contents pointed to by \a h, \a s, \a l, and \a a, to the hue,
+    saturation, lightness, and alpha-channel (transparency) components of the
+    color's HSL value.
+
+    These components can be retrieved individually using the hueHslF(),
+    saturationHslF(), lightnessF() and alphaF() functions.
+
+    \sa setHsl()
+*/
+void QColor::getHslF(qreal *h, qreal *s, qreal *l, qreal *a) const
+{
+        if (!h || !s || !l)
+        return;
+
+    if (cspec != Invalid && cspec != Hsl) {
+        toHsl().getHslF(h, s, l, a);
+        return;
+    }
+
+    *h = ct.ahsl.hue == USHRT_MAX ? qreal(-1.0) : ct.ahsl.hue / qreal(36000.0);
+    *s = ct.ahsl.saturation / qreal(USHRT_MAX);
+    *l = ct.ahsl.lightness / qreal(USHRT_MAX);
+
+    if (a)
+        *a = ct.ahsl.alpha / qreal(USHRT_MAX);
+}
+
+/*!
+    \since 4.6
+
+    Sets the contents pointed to by \a h, \a s, \a l, and \a a, to the hue,
+    saturation, lightness, and alpha-channel (transparency) components of the
+    color's HSL value.
+
+    These components can be retrieved individually using the hueHsl(),
+    saturationHsl(), lightness() and alpha() functions.
+
+    \sa setHsl()
+*/
+void QColor::getHsl(int *h, int *s, int *l, int *a) const
+{
+    if (!h || !s || !l)
+        return;
+
+    if (cspec != Invalid && cspec != Hsl) {
+        toHsl().getHsl(h, s, l, a);
+        return;
+    }
+
+    *h = ct.ahsl.hue == USHRT_MAX ? -1 : ct.ahsl.hue / 100;
+    *s = ct.ahsl.saturation >> 8;
+    *l = ct.ahsl.lightness  >> 8;
+
+    if (a)
+        *a = ct.ahsl.alpha >> 8;
+}
+
+/*!
+    \since 4.6
+
+    Sets a HSL color lightness; \a h is the hue, \a s is the saturation, \a l is
+    the lightness and \a a is the alpha component of the HSL color.
+
+    All the values must be in the range 0.0-1.0.
+
+    \sa getHslF(), setHsl()
+*/
+void QColor::setHslF(qreal h, qreal s, qreal l, qreal a)
+{
+    if (((h < qreal(0.0) || h > qreal(1.0)) && h != qreal(-1.0))
+        || (s < qreal(0.0) || s > qreal(1.0))
+        || (l < qreal(0.0) || l > qreal(1.0))
+        || (a < qreal(0.0) || a > qreal(1.0))) {
+        qWarning("QColor::setHsvF: HSV parameters out of range");
+        return;
+    }
+
+    cspec = Hsl;
+    ct.ahsl.alpha      = qRound(a * USHRT_MAX);
+    ct.ahsl.hue        = h == qreal(-1.0) ? USHRT_MAX : qRound(h * 36000);
+    ct.ahsl.saturation = qRound(s * USHRT_MAX);
+    ct.ahsl.lightness  = qRound(l * USHRT_MAX);
+    ct.ahsl.pad        = 0;
+}
+
+/*!
+    \since 4.6
+
+    Sets a HSL color value; \a h is the hue, \a s is the saturation, \a l is
+    the lightness and \a a is the alpha component of the HSL color.
+
+    The saturation, value and alpha-channel values must be in the range 0-255,
+    and the hue value must be greater than -1.
+
+    \sa getHsl(), setHslF()
+*/
+void QColor::setHsl(int h, int s, int l, int a)
+{
+    if (h < -1 || (uint)s > 255 || (uint)l > 255 || (uint)a > 255) {
+        qWarning("QColor::setHsv: HSV parameters out of range");
+        invalidate();
+        return;
+    }
+
+    cspec = Hsl;
+    ct.ahsl.alpha      = a * 0x101;
+    ct.ahsl.hue        = h == -1 ? USHRT_MAX : (h % 360) * 100;
+    ct.ahsl.saturation = s * 0x101;
+    ct.ahsl.lightness  = l * 0x101;
+    ct.ahsl.pad        = 0;
+}
+
+/*!
+    Sets the contents pointed to by \a r, \a g, \a b, and \a a, to the red,
+    green, blue, and alpha-channel (transparency) components of the color's
+    RGB value.
+
+    These components can be retrieved individually using the redF(), greenF(),
+    blueF() and alphaF() functions.
+
+    \sa rgb(), setRgb()
+*/
+void QColor::getRgbF(qreal *r, qreal *g, qreal *b, qreal *a) const
+{
+    if (!r || !g || !b)
+        return;
+
+    if (cspec != Invalid && cspec != Rgb) {
+        toRgb().getRgbF(r, g, b, a);
+        return;
+    }
+
+    *r = ct.argb.red   / qreal(USHRT_MAX);
+    *g = ct.argb.green / qreal(USHRT_MAX);
+    *b = ct.argb.blue  / qreal(USHRT_MAX);
+
+    if (a)
+        *a = ct.argb.alpha / qreal(USHRT_MAX);
+
+}
+
+/*!
+    Sets the contents pointed to by \a r, \a g, \a b, and \a a, to the red,
+    green, blue, and alpha-channel (transparency) components of the color's
+    RGB value.
+
+    These components can be retrieved individually using the red(), green(),
+    blue() and alpha() functions.
+
+    \sa rgb(), setRgb()
+*/
+void QColor::getRgb(int *r, int *g, int *b, int *a) const
+{
+    if (!r || !g || !b)
+        return;
+
+    if (cspec != Invalid && cspec != Rgb) {
+        toRgb().getRgb(r, g, b, a);
+        return;
+    }
+
+    *r = ct.argb.red   >> 8;
+    *g = ct.argb.green >> 8;
+    *b = ct.argb.blue  >> 8;
+
+    if (a)
+        *a = ct.argb.alpha >> 8;
+}
+
+/*!
+    \obsolete
+    \fn void QColor::getRgba(int *r, int *g, int *b, int *a) const
+
+    Use getRgb() instead.
+*/
+
+/*!
+    \fn void QColor::setRgbF(qreal r, qreal g, qreal b, qreal a)
+
+    Sets the color channels of this color to \a r (red), \a g (green),
+    \a b (blue) and \a a (alpha, transparency).
+
+    All values must be in the range 0.0-1.0.
+
+    \sa rgb(), getRgbF(), setRgb()
+*/
+void QColor::setRgbF(qreal r, qreal g, qreal b, qreal a)
+{
+    if (r < qreal(0.0) || r > qreal(1.0)
+        || g < qreal(0.0) || g > qreal(1.0)
+        || b < qreal(0.0) || b > qreal(1.0)
+        || a < qreal(0.0) || a > qreal(1.0)) {
+        qWarning("QColor::setRgbF: RGB parameters out of range");
+        invalidate();
+        return;
+    }
+
+    cspec = Rgb;
+    ct.argb.alpha = qRound(a * USHRT_MAX);
+    ct.argb.red   = qRound(r * USHRT_MAX);
+    ct.argb.green = qRound(g * USHRT_MAX);
+    ct.argb.blue  = qRound(b * USHRT_MAX);
+    ct.argb.pad   = 0;
+}
+
+/*!
+    Sets the RGB value to \a r, \a g, \a b and the alpha value to \a a.
+
+    All the values must be in the range 0-255.
+
+    \sa rgb(), getRgb(), setRgbF()
+*/
+void QColor::setRgb(int r, int g, int b, int a)
+{
+    if ((uint)r > 255 || (uint)g > 255 || (uint)b > 255 || (uint)a > 255) {
+        qWarning("QColor::setRgb: RGB parameters out of range");
+        invalidate();
+        return;
+    }
+
+    cspec = Rgb;
+    ct.argb.alpha = a * 0x101;
+    ct.argb.red   = r * 0x101;
+    ct.argb.green = g * 0x101;
+    ct.argb.blue  = b * 0x101;
+    ct.argb.pad   = 0;
+}
+
+/*!
+    \obsolete
+    \fn void QColor::setRgba(int r, int g, int b, int a)
+
+    Use setRgb() instead.
+*/
+
+/*!
+    \fn QRgb QColor::rgba() const
+
+    Returns the RGB value of the color, including its alpha.
+
+    For an invalid color, the alpha value of the returned color is unspecified.
+
+    \sa setRgba(), rgb()
+*/
+
+QRgb QColor::rgba() const
+{
+    if (cspec != Invalid && cspec != Rgb)
+        return toRgb().rgba();
+    return qRgba(ct.argb.red >> 8, ct.argb.green >> 8, ct.argb.blue >> 8, ct.argb.alpha >> 8);
+}
+
+/*!
+    Sets the RGB value to \a rgba, including its alpha.
+
+    \sa rgba(), rgb()
+*/
+void QColor::setRgba(QRgb rgba)
+{
+    cspec = Rgb;
+    ct.argb.alpha = qAlpha(rgba) * 0x101;
+    ct.argb.red   = qRed(rgba)   * 0x101;
+    ct.argb.green = qGreen(rgba) * 0x101;
+    ct.argb.blue  = qBlue(rgba)  * 0x101;
+    ct.argb.pad   = 0;
+}
+
+/*!
+    \fn QRgb QColor::rgb() const
+
+    Returns the RGB value of the color. The alpha value is opaque.
+
+    \sa getRgb(), rgba()
+*/
+QRgb QColor::rgb() const
+{
+    if (cspec != Invalid && cspec != Rgb)
+        return toRgb().rgb();
+    return qRgb(ct.argb.red >> 8, ct.argb.green >> 8, ct.argb.blue >> 8);
+}
+
+/*!
+    \overload
+
+    Sets the RGB value to \a rgb. The alpha value is set to opaque.
+*/
+void QColor::setRgb(QRgb rgb)
+{
+    cspec = Rgb;
+    ct.argb.alpha = 0xffff;
+    ct.argb.red   = qRed(rgb)   * 0x101;
+    ct.argb.green = qGreen(rgb) * 0x101;
+    ct.argb.blue  = qBlue(rgb)  * 0x101;
+    ct.argb.pad   = 0;
+}
+
+/*!
+    Returns the alpha color component of this color.
+
+    \sa setAlpha(), alphaF(), {QColor#Alpha-Blended
+    Drawing}{Alpha-Blended Drawing}
+*/
+int QColor::alpha() const
+{ return ct.argb.alpha >> 8; }
+
+
+/*!
+    Sets the alpha of this color to \a alpha. Integer alpha is specified in the
+    range 0-255.
+
+    \sa alpha(), alphaF(), {QColor#Alpha-Blended
+    Drawing}{Alpha-Blended Drawing}
+*/
+
+void QColor::setAlpha(int alpha)
+{
+    QCOLOR_INT_RANGE_CHECK("QColor::setAlpha", alpha);
+    ct.argb.alpha = alpha * 0x101;
+}
+
+/*!
+    Returns the alpha color component of this color.
+
+    \sa setAlphaF(), alpha(),  {QColor#Alpha-Blended
+    Drawing}{Alpha-Blended Drawing}
+*/
+qreal QColor::alphaF() const
+{ return ct.argb.alpha / qreal(USHRT_MAX); }
+
+/*!
+    Sets the alpha of this color to \a alpha. qreal alpha is specified in the
+    range 0.0-1.0.
+
+    \sa alphaF(), alpha(), {QColor#Alpha-Blended
+    Drawing}{Alpha-Blended Drawing}
+
+*/
+void QColor::setAlphaF(qreal alpha)
+{
+    QCOLOR_REAL_RANGE_CHECK("QColor::setAlphaF", alpha);
+    qreal tmp = alpha * USHRT_MAX;
+    ct.argb.alpha = qRound(tmp);
+}
+
+
+/*!
+    Returns the red color component of this color.
+
+    \sa setRed(), redF(), getRgb()
+*/
+int QColor::red() const
+{
+    if (cspec != Invalid && cspec != Rgb)
+        return toRgb().red();
+    return ct.argb.red >> 8;
+}
+
+/*!
+    Sets the red color component of this color to \a red. Integer components
+    are specified in the range 0-255.
+
+    \sa red(), redF(), setRgb()
+*/
+void QColor::setRed(int red)
+{
+    QCOLOR_INT_RANGE_CHECK("QColor::setRed", red);
+    if (cspec != Rgb)
+        setRgb(red, green(), blue(), alpha());
+    else
+        ct.argb.red = red * 0x101;
+}
+
+/*!
+    Returns the green color component of this color.
+
+    \sa setGreen(), greenF(), getRgb()
+*/
+int QColor::green() const
+{
+    if (cspec != Invalid && cspec != Rgb)
+        return toRgb().green();
+    return ct.argb.green >> 8;
+}
+
+/*!
+    Sets the green color component of this color to \a green. Integer
+    components are specified in the range 0-255.
+
+    \sa green(), greenF(),  setRgb()
+*/
+void QColor::setGreen(int green)
+{
+    QCOLOR_INT_RANGE_CHECK("QColor::setGreen", green);
+    if (cspec != Rgb)
+        setRgb(red(), green, blue(), alpha());
+    else
+        ct.argb.green = green * 0x101;
+}
+
+
+/*!
+    Returns the blue color component of this color.
+
+    \sa setBlue(), blueF(), getRgb()
+*/
+int QColor::blue() const
+{
+    if (cspec != Invalid && cspec != Rgb)
+        return toRgb().blue();
+    return ct.argb.blue >> 8;
+}
+
+
+/*!
+    Sets the blue color component of this color to \a blue. Integer components
+    are specified in the range 0-255.
+
+    \sa blue(), blueF(), setRgb()
+*/
+void QColor::setBlue(int blue)
+{
+    QCOLOR_INT_RANGE_CHECK("QColor::setBlue", blue);
+    if (cspec != Rgb)
+        setRgb(red(), green(), blue, alpha());
+    else
+        ct.argb.blue = blue * 0x101;
+}
+
+/*!
+    Returns the red color component of this color.
+
+    \sa setRedF(), red(), getRgbF()
+*/
+qreal QColor::redF() const
+{
+    if (cspec != Invalid && cspec != Rgb)
+        return toRgb().redF();
+    return ct.argb.red / qreal(USHRT_MAX);
+}
+
+
+/*!
+    Sets the red color component of this color to \a red. Float components
+    are specified in the range 0.0-1.0.
+
+    \sa redF(), red(), setRgbF()
+*/
+void QColor::setRedF(qreal red)
+{
+    QCOLOR_REAL_RANGE_CHECK("QColor::setRedF", red);
+    if (cspec != Rgb)
+        setRgbF(red, greenF(), blueF(), alphaF());
+    else
+        ct.argb.red = qRound(red * USHRT_MAX);
+}
+
+/*!
+    Returns the green color component of this color.
+
+    \sa setGreenF(), green(), getRgbF()
+*/
+qreal QColor::greenF() const
+{
+    if (cspec != Invalid && cspec != Rgb)
+        return toRgb().greenF();
+    return ct.argb.green / qreal(USHRT_MAX);
+}
+
+
+/*!
+    Sets the green color component of this color to \a green. Float components
+    are specified in the range 0.0-1.0.
+
+    \sa greenF(), green(), setRgbF()
+*/
+void QColor::setGreenF(qreal green)
+{
+    QCOLOR_REAL_RANGE_CHECK("QColor::setGreenF", green);
+    if (cspec != Rgb)
+        setRgbF(redF(), green, blueF(), alphaF());
+    else
+        ct.argb.green = qRound(green * USHRT_MAX);
+}
+
+/*!
+    Returns the blue color component of this color.
+
+     \sa setBlueF(), blue(), getRgbF()
+*/
+qreal QColor::blueF() const
+{
+    if (cspec != Invalid && cspec != Rgb)
+        return toRgb().blueF();
+    return ct.argb.blue / qreal(USHRT_MAX);
+}
+
+/*!
+    Sets the blue color component of this color to \a blue. Float components
+    are specified in the range 0.0-1.0.
+
+    \sa blueF(), blue(), setRgbF()
+*/
+void QColor::setBlueF(qreal blue)
+{
+    QCOLOR_REAL_RANGE_CHECK("QColor::setBlueF", blue);
+    if (cspec != Rgb)
+        setRgbF(redF(), greenF(), blue, alphaF());
+    else
+        ct.argb.blue = qRound(blue * USHRT_MAX);
+}
+
+/*!
+    Returns the hue color component of this color.
+
+    The color is implicitly converted to HSV.
+
+    \sa hsvHue(), hueF(), getHsv(), {QColor#The HSV Color Model}{The HSV Color
+    Model}
+*/
+
+int QColor::hue() const
+{
+    return hsvHue();
+}
+
+/*!
+    Returns the hue color component of this color.
+
+    \sa hueF(), getHsv(), {QColor#The HSV Color Model}{The HSV Color
+    Model}
+*/
+int QColor::hsvHue() const
+{
+    if (cspec != Invalid && cspec != Hsv)
+        return toHsv().hue();
+    return ct.ahsv.hue == USHRT_MAX ? -1 : ct.ahsv.hue / 100;
+}
+
+/*!
+    Returns the saturation color component of this color.
+
+    The color is implicitly converted to HSV.
+
+    \sa hsvSaturation(), saturationF(), getHsv(), {QColor#The HSV Color Model}{The HSV Color
+    Model}
+*/
+
+int QColor::saturation() const
+{
+    return hsvSaturation();
+}
+
+/*!
+    Returns the saturation color component of this color.
+
+    \sa saturationF(), getHsv(), {QColor#The HSV Color Model}{The HSV Color
+    Model}
+*/
+int QColor::hsvSaturation() const
+{
+    if (cspec != Invalid && cspec != Hsv)
+        return toHsv().saturation();
+    return ct.ahsv.saturation >> 8;
+}
+
+/*!
+    Returns the value color component of this color.
+
+    \sa valueF(), getHsv(), {QColor#The HSV Color Model}{The HSV Color
+    Model}
+*/
+int QColor::value() const
+{
+    if (cspec != Invalid && cspec != Hsv)
+        return toHsv().value();
+    return ct.ahsv.value >> 8;
+}
+
+/*!
+    Returns the hue color component of this color.
+
+    The color is implicitly converted to HSV.
+
+    \sa hsvHueF(), hue(), getHsvF(), {QColor#The HSV Color Model}{The HSV Color
+    Model}
+*/
+qreal QColor::hueF() const
+{
+    return hsvHueF();
+}
+
+/*!
+    Returns the hue color component of this color.
+
+    \sa hue(), getHsvF(), {QColor#The HSV Color Model}{The HSV Color
+    Model}
+*/
+qreal QColor::hsvHueF() const
+{
+    if (cspec != Invalid && cspec != Hsv)
+        return toHsv().hueF();
+    return ct.ahsv.hue == USHRT_MAX ? qreal(-1.0) : ct.ahsv.hue / qreal(36000.0);
+}
+
+/*!
+    Returns the saturation color component of this color.
+
+     The color is implicitly converted to HSV.
+
+    \sa hsvSaturationF(), saturation() getHsvF(), {QColor#The HSV Color Model}{The HSV Color
+    Model}
+*/
+qreal QColor::saturationF() const
+{
+    return hsvSaturationF();
+}
+
+/*!
+    Returns the saturation color component of this color.
+
+    \sa saturation() getHsvF(), {QColor#The HSV Color Model}{The HSV Color
+    Model}
+*/
+qreal QColor::hsvSaturationF() const
+{
+    if (cspec != Invalid && cspec != Hsv)
+        return toHsv().saturationF();
+    return ct.ahsv.saturation / qreal(USHRT_MAX);
+}
+
+/*!
+    Returns the value color component of this color.
+
+    \sa value() getHsvF(), {QColor#The HSV Color Model}{The HSV Color
+    Model}
+*/
+qreal QColor::valueF() const
+{
+    if (cspec != Invalid && cspec != Hsv)
+        return toHsv().valueF();
+    return ct.ahsv.value / qreal(USHRT_MAX);
+}
+
+/*!
+    \since 4.6
+
+    Returns the hue color component of this color.
+
+    \sa getHslF(), getHsl()
+*/
+int QColor::hslHue() const
+{
+    if (cspec != Invalid && cspec != Hsl)
+        return toHsl().hslHue();
+    return ct.ahsl.hue == USHRT_MAX ? -1 : ct.ahsl.hue / 100;
+}
+
+/*!
+    \since 4.6
+
+    Returns the saturation color component of this color.
+
+    \sa saturationF(), getHsv(), {QColor#The HSV Color Model}{The HSV Color
+    Model}
+*/
+int QColor::hslSaturation() const
+{
+    if (cspec != Invalid && cspec != Hsl)
+        return toHsl().hslSaturation();
+    return ct.ahsl.saturation >> 8;
+}
+
+/*!
+    \since 4.6
+
+    Returns the lightness color component of this color.
+
+    \sa lightnessF(), getHsl()
+*/
+int QColor::lightness() const
+{
+    if (cspec != Invalid && cspec != Hsl)
+        return toHsl().lightness();
+    return ct.ahsl.lightness >> 8;
+}
+
+/*!
+    \since 4.6
+
+    Returns the hue color component of this color.
+
+    \sa hue(), getHslF()
+*/
+qreal QColor::hslHueF() const
+{
+    if (cspec != Invalid && cspec != Hsl)
+        return toHsl().hslHueF();
+    return ct.ahsl.hue == USHRT_MAX ? qreal(-1.0) : ct.ahsl.hue / qreal(36000.0);
+}
+
+/*!
+    \since 4.6
+
+    Returns the saturation color component of this color.
+
+    \sa saturationF() getHslF()
+*/
+qreal QColor::hslSaturationF() const
+{
+    if (cspec != Invalid && cspec != Hsl)
+        return toHsl().hslSaturationF();
+    return ct.ahsl.saturation / qreal(USHRT_MAX);
+}
+
+/*!
+    \since 4.6
+
+    Returns the lightness color component of this color.
+
+    \sa value() getHslF()
+*/
+qreal QColor::lightnessF() const
+{
+    if (cspec != Invalid && cspec != Hsl)
+        return toHsl().lightnessF();
+    return ct.ahsl.lightness / qreal(USHRT_MAX);
+}
+
+/*!
+    Returns the cyan color component of this color.
+
+    \sa cyanF(), getCmyk(), {QColor#The CMYK Color Model}{The CMYK
+    Color Model}
+*/
+int QColor::cyan() const
+{
+    if (cspec != Invalid && cspec != Cmyk)
+        return toCmyk().cyan();
+    return ct.acmyk.cyan >> 8;
+}
+
+/*!
+    Returns the magenta color component of this color.
+
+    \sa magentaF(), getCmyk(), {QColor#The CMYK Color Model}{The CMYK
+    Color Model}
+*/
+int QColor::magenta() const
+{
+    if (cspec != Invalid && cspec != Cmyk)
+        return toCmyk().magenta();
+    return ct.acmyk.magenta >> 8;
+}
+
+/*!
+    Returns the yellow color component of this color.
+
+    \sa yellowF(), getCmyk(), {QColor#The CMYK Color Model}{The CMYK
+    Color Model}
+*/
+int QColor::yellow() const
+{
+    if (cspec != Invalid && cspec != Cmyk)
+        return toCmyk().yellow();
+    return ct.acmyk.yellow >> 8;
+}
+
+/*!
+    Returns the black color component of this color.
+
+    \sa blackF(), getCmyk(), {QColor#The CMYK Color Model}{The CMYK
+    Color Model}
+
+*/
+int QColor::black() const
+{
+    if (cspec != Invalid && cspec != Cmyk)
+        return toCmyk().black();
+    return ct.acmyk.black >> 8;
+}
+
+/*!
+    Returns the cyan color component of this color.
+
+    \sa cyan(), getCmykF(), {QColor#The CMYK Color Model}{The CMYK
+    Color Model}
+*/
+qreal QColor::cyanF() const
+{
+    if (cspec != Invalid && cspec != Cmyk)
+        return toCmyk().cyanF();
+    return ct.acmyk.cyan / qreal(USHRT_MAX);
+}
+
+/*!
+    Returns the magenta color component of this color.
+
+    \sa magenta(), getCmykF(), {QColor#The CMYK Color Model}{The CMYK
+    Color Model}
+*/
+qreal QColor::magentaF() const
+{
+    if (cspec != Invalid && cspec != Cmyk)
+        return toCmyk().magentaF();
+    return ct.acmyk.magenta / qreal(USHRT_MAX);
+}
+
+/*!
+    Returns the yellow color component of this color.
+
+     \sa yellow(), getCmykF(), {QColor#The CMYK Color Model}{The CMYK
+    Color Model}
+*/
+qreal QColor::yellowF() const
+{
+    if (cspec != Invalid && cspec != Cmyk)
+        return toCmyk().yellowF();
+    return ct.acmyk.yellow / qreal(USHRT_MAX);
+}
+
+/*!
+    Returns the black color component of this color.
+
+    \sa black(), getCmykF(), {QColor#The CMYK Color Model}{The CMYK
+    Color Model}
+*/
+qreal QColor::blackF() const
+{
+    if (cspec != Invalid && cspec != Cmyk)
+        return toCmyk().blackF();
+    return ct.acmyk.black / qreal(USHRT_MAX);
+}
+
+/*!
+    Create and returns an RGB QColor based on this color.
+
+    \sa fromRgb(), convertTo(), isValid()
+*/
+QColor QColor::toRgb() const
+{
+    if (!isValid() || cspec == Rgb)
+        return *this;
+
+    QColor color;
+    color.cspec = Rgb;
+    color.ct.argb.alpha = ct.argb.alpha;
+    color.ct.argb.pad = 0;
+
+    switch (cspec) {
+    case Hsv:
+        {
+            if (ct.ahsv.saturation == 0 || ct.ahsv.hue == USHRT_MAX) {
+                // achromatic case
+                color.ct.argb.red = color.ct.argb.green = color.ct.argb.blue = ct.ahsv.value;
+                break;
+            }
+
+            // chromatic case
+            const qreal h = ct.ahsv.hue == 36000 ? 0 : ct.ahsv.hue / 6000.;
+            const qreal s = ct.ahsv.saturation / qreal(USHRT_MAX);
+            const qreal v = ct.ahsv.value / qreal(USHRT_MAX);
+            const int i = int(h);
+            const qreal f = h - i;
+            const qreal p = v * (qreal(1.0) - s);
+
+            if (i & 1) {
+                const qreal q = v * (qreal(1.0) - (s * f));
+
+                switch (i) {
+                case 1:
+                    color.ct.argb.red   = qRound(q * USHRT_MAX);
+                    color.ct.argb.green = qRound(v * USHRT_MAX);
+                    color.ct.argb.blue  = qRound(p * USHRT_MAX);
+                    break;
+                case 3:
+                    color.ct.argb.red   = qRound(p * USHRT_MAX);
+                    color.ct.argb.green = qRound(q * USHRT_MAX);
+                    color.ct.argb.blue  = qRound(v * USHRT_MAX);
+                    break;
+                case 5:
+                    color.ct.argb.red   = qRound(v * USHRT_MAX);
+                    color.ct.argb.green = qRound(p * USHRT_MAX);
+                    color.ct.argb.blue  = qRound(q * USHRT_MAX);
+                    break;
+                }
+            } else {
+                const qreal t = v * (qreal(1.0) - (s * (qreal(1.0) - f)));
+
+                switch (i) {
+                case 0:
+                    color.ct.argb.red   = qRound(v * USHRT_MAX);
+                    color.ct.argb.green = qRound(t * USHRT_MAX);
+                    color.ct.argb.blue  = qRound(p * USHRT_MAX);
+                    break;
+                case 2:
+                    color.ct.argb.red   = qRound(p * USHRT_MAX);
+                    color.ct.argb.green = qRound(v * USHRT_MAX);
+                    color.ct.argb.blue  = qRound(t * USHRT_MAX);
+                    break;
+                case 4:
+                    color.ct.argb.red   = qRound(t * USHRT_MAX);
+                    color.ct.argb.green = qRound(p * USHRT_MAX);
+                    color.ct.argb.blue  = qRound(v * USHRT_MAX);
+                    break;
+                }
+            }
+            break;
+        }
+    case Hsl:
+        {
+            if (ct.ahsl.saturation == 0 || ct.ahsl.hue == USHRT_MAX) {
+                // achromatic case
+                color.ct.argb.red = color.ct.argb.green = color.ct.argb.blue = ct.ahsl.lightness;
+            } else if (ct.ahsl.lightness == 0) {
+                // lightness 0 
+                color.ct.argb.red = color.ct.argb.green = color.ct.argb.blue = 0;
+            } else {
+                // chromatic case
+                const qreal h = ct.ahsl.hue == 36000 ? 0 : ct.ahsl.hue / 36000.;
+                const qreal s = ct.ahsl.saturation / qreal(USHRT_MAX);
+                const qreal l = ct.ahsl.lightness / qreal(USHRT_MAX);
+
+                qreal temp2;
+                if (l < qreal(0.5))
+                    temp2 = l * (qreal(1.0) + s);
+                else
+                    temp2 = l + s - (l * s);
+
+                const qreal temp1 = (qreal(2.0) * l) - temp2;
+                qreal temp3[3] = { h + (qreal(1.0) / qreal(3.0)),
+                                   h,
+                                   h - (qreal(1.0) / qreal(3.0)) };
+
+                for (int i = 0; i != 3; ++i) {
+                    if (temp3[i] < qreal(0.0))
+                        temp3[i] += qreal(1.0);
+                    else if (temp3[i] > qreal(1.0))
+                        temp3[i] -= qreal(1.0);
+
+                    const qreal sixtemp3 = temp3[i] * qreal(6.0);
+                    if (sixtemp3 < qreal(1.0))
+                        color.ct.array[i+1] = qRound((temp1 + (temp2 - temp1) * sixtemp3) * USHRT_MAX);
+                    else if ((temp3[i] * qreal(2.0)) < qreal(1.0))
+                        color.ct.array[i+1] = qRound(temp2 * USHRT_MAX);
+                    else if ((temp3[i] * qreal(3.0)) < qreal(2.0))
+                        color.ct.array[i+1] = qRound((temp1 + (temp2 -temp1) * (qreal(2.0) /qreal(3.0) - temp3[i]) * qreal(6.0)) * USHRT_MAX);
+                    else
+                        color.ct.array[i+1] = qRound(temp1 * USHRT_MAX);
+                }
+                color.ct.argb.red = color.ct.argb.red == 1 ? 0 : color.ct.argb.red;
+                color.ct.argb.green = color.ct.argb.green == 1 ? 0 : color.ct.argb.green;
+                color.ct.argb.blue = color.ct.argb.blue == 1 ? 0 : color.ct.argb.blue;
+            }
+            break;
+        }
+    case Cmyk:
+        {
+            const qreal c = ct.acmyk.cyan / qreal(USHRT_MAX);
+            const qreal m = ct.acmyk.magenta / qreal(USHRT_MAX);
+            const qreal y = ct.acmyk.yellow / qreal(USHRT_MAX);
+            const qreal k = ct.acmyk.black / qreal(USHRT_MAX);
+
+            color.ct.argb.red   = qRound((qreal(1.0) - (c * (qreal(1.0) - k) + k)) * USHRT_MAX);
+            color.ct.argb.green = qRound((qreal(1.0) - (m * (qreal(1.0) - k) + k)) * USHRT_MAX);
+            color.ct.argb.blue  = qRound((qreal(1.0) - (y * (qreal(1.0) - k) + k)) * USHRT_MAX);
+            break;
+        }
+    default:
+        break;
+    }
+
+    return color;
+}
+
+
+#define Q_MAX_3(a, b, c) ( ( a > b && a > c) ? a : (b > c ? b : c) )
+#define Q_MIN_3(a, b, c) ( ( a < b && a < c) ? a : (b < c ? b : c) )
+
+
+/*!
+    Creates and returns an HSV QColor based on this color.
+
+    \sa fromHsv(), convertTo(), isValid(), {QColor#The HSV Color
+    Model}{The HSV Color Model}
+*/
+QColor QColor::toHsv() const
+{
+    if (!isValid() || cspec == Hsv)
+        return *this;
+
+    if (cspec != Rgb)
+        return toRgb().toHsv();
+
+    QColor color;
+    color.cspec = Hsv;
+    color.ct.ahsv.alpha = ct.argb.alpha;
+    color.ct.ahsv.pad = 0;
+
+    const qreal r = ct.argb.red   / qreal(USHRT_MAX);
+    const qreal g = ct.argb.green / qreal(USHRT_MAX);
+    const qreal b = ct.argb.blue  / qreal(USHRT_MAX);
+    const qreal max = Q_MAX_3(r, g, b);
+    const qreal min = Q_MIN_3(r, g, b);
+    const qreal delta = max - min;
+    color.ct.ahsv.value = qRound(max * USHRT_MAX);
+    if (qFuzzyIsNull(delta)) {
+        // achromatic case, hue is undefined
+        color.ct.ahsv.hue = USHRT_MAX;
+        color.ct.ahsv.saturation = 0;
+    } else {
+        // chromatic case
+        qreal hue = 0;
+        color.ct.ahsv.saturation = qRound((delta / max) * USHRT_MAX);
+        if (qFuzzyCompare(r, max)) {
+            hue = ((g - b) /delta);
+        } else if (qFuzzyCompare(g, max)) {
+            hue = (qreal(2.0) + (b - r) / delta);
+        } else if (qFuzzyCompare(b, max)) {
+            hue = (qreal(4.0) + (r - g) / delta);
+        } else {
+            Q_ASSERT_X(false, "QColor::toHsv", "internal error");
+        }
+        hue *= qreal(60.0);
+        if (hue < qreal(0.0))
+            hue += qreal(360.0);
+        color.ct.ahsv.hue = qRound(hue * 100);
+    }
+
+    return color;
+}
+
+/*!
+    Creates and returns an HSL QColor based on this color.
+
+    \sa fromHsl(), convertTo(), isValid()
+*/
+QColor QColor::toHsl() const
+{
+    if (!isValid() || cspec == Hsl)
+        return *this;
+
+    if (cspec != Rgb)
+        return toRgb().toHsl();
+
+    QColor color;
+    color.cspec = Hsl;
+    color.ct.ahsl.alpha = ct.argb.alpha;
+    color.ct.ahsl.pad = 0;
+
+    const qreal r = ct.argb.red   / qreal(USHRT_MAX);
+    const qreal g = ct.argb.green / qreal(USHRT_MAX);
+    const qreal b = ct.argb.blue  / qreal(USHRT_MAX);
+    const qreal max = Q_MAX_3(r, g, b);
+    const qreal min = Q_MIN_3(r, g, b);
+    const qreal delta = max - min;
+    const qreal delta2 = max + min;
+    const qreal lightness = qreal(0.5) * delta2;
+    color.ct.ahsl.lightness = qRound(lightness * USHRT_MAX);
+    if (qFuzzyIsNull(delta)) {
+        // achromatic case, hue is undefined
+        color.ct.ahsl.hue = USHRT_MAX;
+        color.ct.ahsl.saturation = 0;
+    } else {
+        // chromatic case
+        qreal hue = 0;
+        if (lightness < qreal(0.5))
+            color.ct.ahsl.saturation = qRound((delta / delta2) * USHRT_MAX);
+        else
+            color.ct.ahsl.saturation = qRound((delta / (qreal(2.0) - delta2)) * USHRT_MAX);
+        if (qFuzzyCompare(r, max)) {
+            hue = ((g - b) /delta);
+        } else if (qFuzzyCompare(g, max)) {
+            hue = (qreal(2.0) + (b - r) / delta);
+        } else if (qFuzzyCompare(b, max)) {
+            hue = (qreal(4.0) + (r - g) / delta);
+        } else {
+            Q_ASSERT_X(false, "QColor::toHsv", "internal error");
+        }
+        hue *= qreal(60.0);
+        if (hue < qreal(0.0))
+            hue += qreal(360.0);
+        color.ct.ahsl.hue = qRound(hue * 100);
+    }
+
+    return color;
+}
+
+/*!
+    Creates and returns a CMYK QColor based on this color.
+
+    \sa fromCmyk(), convertTo(), isValid(), {QColor#The CMYK Color
+    Model}{The CMYK Color Model}
+*/
+QColor QColor::toCmyk() const
+{
+    if (!isValid() || cspec == Cmyk)
+        return *this;
+    if (cspec != Rgb)
+        return toRgb().toCmyk();
+
+    QColor color;
+    color.cspec = Cmyk;
+    color.ct.acmyk.alpha = ct.argb.alpha;
+
+    // rgb -> cmy
+    const qreal r = ct.argb.red   / qreal(USHRT_MAX);
+    const qreal g = ct.argb.green / qreal(USHRT_MAX);
+    const qreal b = ct.argb.blue  / qreal(USHRT_MAX);
+    qreal c = qreal(1.0) - r;
+    qreal m = qreal(1.0) - g;
+    qreal y = qreal(1.0) - b;
+
+    // cmy -> cmyk
+    const qreal k = qMin(c, qMin(m, y));
+
+    if (!qFuzzyIsNull(k - 1)) {
+        c = (c - k) / (qreal(1.0) - k);
+        m = (m - k) / (qreal(1.0) - k);
+        y = (y - k) / (qreal(1.0) - k);
+    }
+
+    color.ct.acmyk.cyan    = qRound(c * USHRT_MAX);
+    color.ct.acmyk.magenta = qRound(m * USHRT_MAX);
+    color.ct.acmyk.yellow  = qRound(y * USHRT_MAX);
+    color.ct.acmyk.black   = qRound(k * USHRT_MAX);
+
+    return color;
+}
+
+QColor QColor::convertTo(QColor::Spec colorSpec) const
+{
+    if (colorSpec == cspec)
+        return *this;
+    switch (colorSpec) {
+    case Rgb:
+        return toRgb();
+    case Hsv:
+        return toHsv();
+    case Cmyk:
+        return toCmyk();
+    case Hsl:
+        return toHsl();
+    case Invalid:
+        break;
+    }
+    return QColor(); // must be invalid
+}
+
+
+/*!
+    Static convenience function that returns a QColor constructed from the
+    given QRgb value \a rgb.
+
+    The alpha component of \a rgb is ignored (i.e. it is automatically set to
+    255), use the fromRgba() function to include the alpha-channel specified by
+    the given QRgb value.
+
+    \sa fromRgba(), fromRgbF(), toRgb(), isValid()
+*/
+
+QColor QColor::fromRgb(QRgb rgb)
+{
+    return fromRgb(qRed(rgb), qGreen(rgb), qBlue(rgb));
+}
+
+
+/*!
+    Static convenience function that returns a QColor constructed from the
+    given QRgb value \a rgba.
+
+    Unlike the fromRgb() function, the alpha-channel specified by the given
+    QRgb value is included.
+
+    \sa fromRgb(), isValid()
+*/
+
+QColor QColor::fromRgba(QRgb rgba)
+{
+    return fromRgb(qRed(rgba), qGreen(rgba), qBlue(rgba), qAlpha(rgba));
+}
+
+/*!
+    Static convenience function that returns a QColor constructed from the RGB
+    color values, \a r (red), \a g (green), \a b (blue), and \a a
+    (alpha-channel, i.e. transparency).
+
+    All the values must be in the range 0-255.
+
+    \sa toRgb(), fromRgbF(), isValid()
+*/
+QColor QColor::fromRgb(int r, int g, int b, int a)
+{
+    if (r < 0 || r > 255
+        || g < 0 || g > 255
+        || b < 0 || b > 255
+        || a < 0 || a > 255) {
+        qWarning("QColor::fromRgb: RGB parameters out of range");
+        return QColor();
+    }
+
+    QColor color;
+    color.cspec = Rgb;
+    color.ct.argb.alpha = a * 0x101;
+    color.ct.argb.red   = r * 0x101;
+    color.ct.argb.green = g * 0x101;
+    color.ct.argb.blue  = b * 0x101;
+    color.ct.argb.pad   = 0;
+    return color;
+}
+
+/*!
+    Static convenience function that returns a QColor constructed from the RGB
+    color values, \a r (red), \a g (green), \a b (blue), and \a a
+    (alpha-channel, i.e. transparency).
+
+    All the values must be in the range 0.0-1.0.
+
+    \sa fromRgb(), toRgb(), isValid()
+*/
+QColor QColor::fromRgbF(qreal r, qreal g, qreal b, qreal a)
+{
+    if (r < qreal(0.0) || r > qreal(1.0)
+        || g < qreal(0.0) || g > qreal(1.0)
+        || b < qreal(0.0) || b > qreal(1.0)
+        || a < qreal(0.0) || a > qreal(1.0)) {
+        qWarning("QColor::fromRgbF: RGB parameters out of range");
+        return QColor();
+    }
+
+    QColor color;
+    color.cspec = Rgb;
+    color.ct.argb.alpha = qRound(a * USHRT_MAX);
+    color.ct.argb.red   = qRound(r * USHRT_MAX);
+    color.ct.argb.green = qRound(g * USHRT_MAX);
+    color.ct.argb.blue  = qRound(b * USHRT_MAX);
+    color.ct.argb.pad   = 0;
+    return color;
+}
+
+/*!
+    Static convenience function that returns a QColor constructed from the HSV
+    color values, \a h (hue), \a s (saturation), \a v (value), and \a a
+    (alpha-channel, i.e. transparency).
+
+    The value of \a s, \a v, and \a a must all be in the range 0-255; the value
+    of \a h must be in the range 0-359.
+
+    \sa toHsv(), fromHsvF(), isValid(), {QColor#The HSV Color
+    Model}{The HSV Color Model}
+*/
+QColor QColor::fromHsv(int h, int s, int v, int a)
+{
+    if (((h < 0 || h >= 360) && h != -1)
+        || s < 0 || s > 255
+        || v < 0 || v > 255
+        || a < 0 || a > 255) {
+        qWarning("QColor::fromHsv: HSV parameters out of range");
+        return QColor();
+    }
+
+    QColor color;
+    color.cspec = Hsv;
+    color.ct.ahsv.alpha      = a * 0x101;
+    color.ct.ahsv.hue        = h == -1 ? USHRT_MAX : (h % 360) * 100;
+    color.ct.ahsv.saturation = s * 0x101;
+    color.ct.ahsv.value      = v * 0x101;
+    color.ct.ahsv.pad        = 0;
+    return color;
+}
+
+/*!
+    \overload
+
+    Static convenience function that returns a QColor constructed from the HSV
+    color values, \a h (hue), \a s (saturation), \a v (value), and \a a
+    (alpha-channel, i.e. transparency).
+
+    All the values must be in the range 0.0-1.0.
+
+    \sa toHsv(), fromHsv(), isValid(), {QColor#The HSV Color
+    Model}{The HSV Color Model}
+*/
+QColor QColor::fromHsvF(qreal h, qreal s, qreal v, qreal a)
+{
+    if (((h < qreal(0.0) || h > qreal(1.0)) && h != qreal(-1.0))
+        || (s < qreal(0.0) || s > qreal(1.0))
+        || (v < qreal(0.0) || v > qreal(1.0))
+        || (a < qreal(0.0) || a > qreal(1.0))) {
+        qWarning("QColor::fromHsvF: HSV parameters out of range");
+        return QColor();
+    }
+
+    QColor color;
+    color.cspec = Hsv;
+    color.ct.ahsv.alpha      = qRound(a * USHRT_MAX);
+    color.ct.ahsv.hue        = h == qreal(-1.0) ? USHRT_MAX : qRound(h * 36000);
+    color.ct.ahsv.saturation = qRound(s * USHRT_MAX);
+    color.ct.ahsv.value      = qRound(v * USHRT_MAX);
+    color.ct.ahsv.pad        = 0;
+    return color;
+}
+
+/*!
+    \since 4.6
+
+    Static convenience function that returns a QColor constructed from the HSV
+    color values, \a h (hue), \a s (saturation), \a l (lightness), and \a a
+    (alpha-channel, i.e. transparency).
+
+    The value of \a s, \a l, and \a a must all be in the range 0-255; the value
+    of \a h must be in the range 0-359.
+
+    \sa toHsl(), fromHslF(), isValid()
+*/
+QColor QColor::fromHsl(int h, int s, int l, int a)
+{
+    if (((h < 0 || h >= 360) && h != -1)
+        || s < 0 || s > 255
+        || l < 0 || l > 255
+        || a < 0 || a > 255) {
+        qWarning("QColor::fromHsv: HSV parameters out of range");
+        return QColor();
+    }
+
+    QColor color;
+    color.cspec = Hsl;
+    color.ct.ahsl.alpha      = a * 0x101;
+    color.ct.ahsl.hue        = h == -1 ? USHRT_MAX : (h % 360) * 100;
+    color.ct.ahsl.saturation = s * 0x101;
+    color.ct.ahsl.lightness  = l * 0x101;
+    color.ct.ahsl.pad        = 0;
+    return color;
+}
+
+/*!
+    \overload
+    \since 4.6
+
+    Static convenience function that returns a QColor constructed from the HSV
+    color values, \a h (hue), \a s (saturation), \a l (lightness), and \a a
+    (alpha-channel, i.e. transparency).
+
+    All the values must be in the range 0.0-1.0.
+
+    \sa toHsl(), fromHsl(), isValid()
+*/
+QColor QColor::fromHslF(qreal h, qreal s, qreal l, qreal a)
+{
+    if (((h < qreal(0.0) || h > qreal(1.0)) && h != qreal(-1.0))
+        || (s < qreal(0.0) || s > qreal(1.0))
+        || (l < qreal(0.0) || l > qreal(1.0))
+        || (a < qreal(0.0) || a > qreal(1.0))) {
+        qWarning("QColor::fromHsvF: HSV parameters out of range");
+        return QColor();
+    }
+
+    QColor color;
+    color.cspec = Hsl;
+    color.ct.ahsl.alpha      = qRound(a * USHRT_MAX);
+    color.ct.ahsl.hue        = (h == qreal(-1.0)) ? USHRT_MAX : qRound(h * 36000);
+    if (color.ct.ahsl.hue == 36000)
+        color.ct.ahsl.hue = 0;
+    color.ct.ahsl.saturation = qRound(s * USHRT_MAX);
+    color.ct.ahsl.lightness  = qRound(l * USHRT_MAX);
+    color.ct.ahsl.pad        = 0;
+    return color;
+}
+
+
+/*!
+    Sets the contents pointed to by \a c, \a m, \a y, \a k, and \a a, to the
+    cyan, magenta, yellow, black, and alpha-channel (transparency) components
+    of the color's CMYK value.
+
+    These components can be retrieved individually using the cyan(), magenta(),
+    yellow(), black() and alpha() functions.
+
+    \sa setCmyk(), {QColor#The CMYK Color Model}{The CMYK Color Model}
+*/
+void QColor::getCmyk(int *c, int *m, int *y, int *k, int *a)
+{
+    if (!c || !m || !y || !k)
+        return;
+
+    if (cspec != Invalid && cspec != Cmyk) {
+        toCmyk().getCmyk(c, m, y, k, a);
+        return;
+    }
+
+    *c = ct.acmyk.cyan >> 8;
+    *m = ct.acmyk.magenta >> 8;
+    *y = ct.acmyk.yellow >> 8;
+    *k = ct.acmyk.black >> 8;
+
+    if (a)
+        *a = ct.acmyk.alpha >> 8;
+}
+
+/*!
+    Sets the contents pointed to by \a c, \a m, \a y, \a k, and \a a, to the
+    cyan, magenta, yellow, black, and alpha-channel (transparency) components
+    of the color's CMYK value.
+
+    These components can be retrieved individually using the cyanF(),
+    magentaF(), yellowF(), blackF() and alphaF() functions.
+
+    \sa setCmykF(), {QColor#The CMYK Color Model}{The CMYK Color Model}
+*/
+void QColor::getCmykF(qreal *c, qreal *m, qreal *y, qreal *k, qreal *a)
+{
+    if (!c || !m || !y || !k)
+        return;
+
+    if (cspec != Invalid && cspec != Cmyk) {
+        toCmyk().getCmykF(c, m, y, k, a);
+        return;
+    }
+
+    *c = ct.acmyk.cyan    / qreal(USHRT_MAX);
+    *m = ct.acmyk.magenta / qreal(USHRT_MAX);
+    *y = ct.acmyk.yellow  / qreal(USHRT_MAX);
+    *k = ct.acmyk.black   / qreal(USHRT_MAX);
+
+    if (a)
+        *a = ct.acmyk.alpha / qreal(USHRT_MAX);
+}
+
+/*!
+    Sets the color to CMYK values, \a c (cyan), \a m (magenta), \a y (yellow),
+    \a k (black), and \a a (alpha-channel, i.e. transparency).
+
+    All the values must be in the range 0-255.
+
+    \sa getCmyk(), setCmykF(), {QColor#The CMYK Color Model}{The
+    CMYK Color Model}
+*/
+void QColor::setCmyk(int c, int m, int y, int k, int a)
+{
+    if (c < 0 || c > 255
+        || m < 0 || m > 255
+        || y < 0 || y > 255
+        || k < 0 || k > 255
+        || a < 0 || a > 255) {
+        qWarning("QColor::setCmyk: CMYK parameters out of range");
+        return;
+    }
+
+    cspec = Cmyk;
+    ct.acmyk.alpha   = a * 0x101;
+    ct.acmyk.cyan    = c * 0x101;
+    ct.acmyk.magenta = m * 0x101;
+    ct.acmyk.yellow  = y * 0x101;
+    ct.acmyk.black   = k * 0x101;
+}
+
+/*!
+    \overload
+
+    Sets the color to CMYK values, \a c (cyan), \a m (magenta), \a y (yellow),
+    \a k (black), and \a a (alpha-channel, i.e. transparency).
+
+    All the values must be in the range 0.0-1.0.
+
+    \sa getCmykF() setCmyk(), {QColor#The CMYK Color Model}{The CMYK
+    Color Model}
+*/
+void QColor::setCmykF(qreal c, qreal m, qreal y, qreal k, qreal a)
+{
+    if (c < qreal(0.0) || c > qreal(1.0)
+        || m < qreal(0.0) || m > qreal(1.0)
+        || y < qreal(0.0) || y > qreal(1.0)
+        || k < qreal(0.0) || k > qreal(1.0)
+        || a < qreal(0.0) || a > qreal(1.0)) {
+        qWarning("QColor::setCmykF: CMYK parameters out of range");
+        return;
+    }
+
+    cspec = Cmyk;
+    ct.acmyk.alpha   = qRound(a * USHRT_MAX);
+    ct.acmyk.cyan    = qRound(c * USHRT_MAX);
+    ct.acmyk.magenta = qRound(m * USHRT_MAX);
+    ct.acmyk.yellow  = qRound(y * USHRT_MAX);
+    ct.acmyk.black   = qRound(k * USHRT_MAX);
+}
+
+/*!
+    Static convenience function that returns a QColor constructed from the
+    given CMYK color values: \a c (cyan), \a m (magenta), \a y (yellow), \a k
+    (black), and \a a (alpha-channel, i.e. transparency).
+
+    All the values must be in the range 0-255.
+
+    \sa toCmyk(), fromCmykF(), isValid(), {QColor#The CMYK Color Model}{The CMYK
+    Color Model}
+*/
+QColor QColor::fromCmyk(int c, int m, int y, int k, int a)
+{
+    if (c < 0 || c > 255
+        || m < 0 || m > 255
+        || y < 0 || y > 255
+        || k < 0 || k > 255
+        || a < 0 || a > 255) {
+        qWarning("QColor::fromCmyk: CMYK parameters out of range");
+        return QColor();
+    }
+
+    QColor color;
+    color.cspec = Cmyk;
+    color.ct.acmyk.alpha   = a * 0x101;
+    color.ct.acmyk.cyan    = c * 0x101;
+    color.ct.acmyk.magenta = m * 0x101;
+    color.ct.acmyk.yellow  = y * 0x101;
+    color.ct.acmyk.black   = k * 0x101;
+    return color;
+}
+
+/*!
+    \overload
+
+    Static convenience function that returns a QColor constructed from the
+    given CMYK color values: \a c (cyan), \a m (magenta), \a y (yellow), \a k
+    (black), and \a a (alpha-channel, i.e. transparency).
+
+    All the values must be in the range 0.0-1.0.
+
+    \sa toCmyk(), fromCmyk(), isValid(), {QColor#The CMYK Color
+    Model}{The CMYK Color Model}
+*/
+QColor QColor::fromCmykF(qreal c, qreal m, qreal y, qreal k, qreal a)
+{
+    if (c < qreal(0.0) || c > qreal(1.0)
+        || m < qreal(0.0) || m > qreal(1.0)
+        || y < qreal(0.0) || y > qreal(1.0)
+        || k < qreal(0.0) || k > qreal(1.0)
+        || a < qreal(0.0) || a > qreal(1.0)) {
+        qWarning("QColor::fromCmykF: CMYK parameters out of range");
+        return QColor();
+    }
+
+    QColor color;
+    color.cspec = Cmyk;
+    color.ct.acmyk.alpha   = qRound(a * USHRT_MAX);
+    color.ct.acmyk.cyan    = qRound(c * USHRT_MAX);
+    color.ct.acmyk.magenta = qRound(m * USHRT_MAX);
+    color.ct.acmyk.yellow  = qRound(y * USHRT_MAX);
+    color.ct.acmyk.black   = qRound(k * USHRT_MAX);
+    return color;
+}
+
+/*!
+    \fn QColor QColor::lighter(int factor) const
+    \since 4.3
+
+    Returns a lighter (or darker) color, but does not change this object.
+
+    If the \a factor is greater than 100, this functions returns a lighter
+    color. Setting \a factor to 150 returns a color that is 50% brighter. If
+    the \a factor is less than 100, the return color is darker, but we
+    recommend using the darker() function for this purpose. If the \a factor
+    is 0 or negative, the return value is unspecified.
+
+    The function converts the current RGB color to HSV, multiplies the value
+    (V) component by \a factor and converts the color back to RGB.
+
+    \sa darker(), isValid()
+*/
+
+/*!
+    \obsolete
+
+    Use lighter(\a factor) instead.
+*/
+QColor QColor::light(int factor) const
+{
+    if (factor <= 0)                                // invalid lightness factor
+        return *this;
+    else if (factor < 100)                        // makes color darker
+        return darker(10000 / factor);
+
+    QColor hsv = toHsv();
+    int s = hsv.ct.ahsv.saturation;
+    int v = hsv.ct.ahsv.value;
+
+    v = (factor*v)/100;
+    if (v > USHRT_MAX) {
+        // overflow... adjust saturation
+        s -= v - USHRT_MAX;
+        if (s < 0)
+            s = 0;
+        v = USHRT_MAX;
+    }
+
+    hsv.ct.ahsv.saturation = s;
+    hsv.ct.ahsv.value = v;
+
+    // convert back to same color spec as original color
+    return hsv.convertTo(cspec);
+}
+
+/*!
+    \fn QColor QColor::darker(int factor) const
+    \since 4.3
+
+    Returns a darker (or lighter) color, but does not change this object.
+
+    If the \a factor is greater than 100, this functions returns a darker
+    color. Setting \a factor to 300 returns a color that has one-third the
+    brightness. If the \a factor is less than 100, the return color is lighter,
+    but we recommend using the lighter() function for this purpose. If the
+    \a factor is 0 or negative, the return value is unspecified.
+
+    The function converts the current RGB color to HSV, divides the value (V)
+    component by \a factor and converts the color back to RGB.
+
+    \sa lighter(), isValid()
+*/
+
+/*!
+    \obsolete
+
+    Use darker(\a factor) instead.
+*/
+QColor QColor::dark(int factor) const
+{
+    if (factor <= 0)                                // invalid darkness factor
+        return *this;
+    else if (factor < 100)                        // makes color lighter
+        return lighter(10000 / factor);
+
+    QColor hsv = toHsv();
+    hsv.ct.ahsv.value = (hsv.ct.ahsv.value * 100) / factor;
+
+    // convert back to same color spec as original color
+    return hsv.convertTo(cspec);
+}
+
+/*!
+    Assigns a copy of \a color to this color, and returns a reference to it.
+*/
+QColor &QColor::operator=(const QColor &color)
+{
+    cspec = color.cspec;
+    ct.argb = color.ct.argb;
+    return *this;
+}
+
+/*! \overload
+    Assigns a copy of \a color and returns a reference to this color.
+ */
+QColor &QColor::operator=(Qt::GlobalColor color)
+{
+    return operator=(QColor(color));
+}
+
+/*!
+    Returns true if this color has the same RGB and alpha values as \a color;
+    otherwise returns false.
+*/
+bool QColor::operator==(const QColor &color) const
+{
+    if (cspec == Hsl && cspec == color.cspec) {
+        return (ct.argb.alpha == color.ct.argb.alpha
+                && ((((ct.ahsl.hue % 36000) == (color.ct.ahsl.hue % 36000)))
+                    || (ct.ahsl.hue == color.ct.ahsl.hue))
+                && (qAbs(ct.ahsl.saturation - color.ct.ahsl.saturation) < 50
+                    || ct.ahsl.lightness == 0
+                    || color.ct.ahsl.lightness == 0
+                    || ct.ahsl.lightness == USHRT_MAX
+                    || color.ct.ahsl.lightness == USHRT_MAX)
+                && (qAbs(ct.ahsl.lightness - color.ct.ahsl.lightness)) < 50);
+    } else {
+        return (cspec == color.cspec
+                && ct.argb.alpha == color.ct.argb.alpha
+                && (((cspec == QColor::Hsv)
+                     && ((ct.ahsv.hue % 36000) == (color.ct.ahsv.hue % 36000)))
+                    || (ct.ahsv.hue == color.ct.ahsv.hue))
+                && ct.argb.green == color.ct.argb.green
+                && ct.argb.blue  == color.ct.argb.blue
+                && ct.argb.pad   == color.ct.argb.pad);
+    }
+}
+
+/*!
+    Returns true if this color has a different RGB and alpha values from
+    \a color; otherwise returns false.
+*/
+bool QColor::operator!=(const QColor &color) const
+{ return !operator==(color); }
+
+
+/*!
+    Returns the color as a QVariant
+*/
+QColor::operator QVariant() const
+{
+    return QVariant(QVariant::Color, this);
+}
+
+#ifdef Q_WS_X11
+/*!
+    Returns true if setNamedColor() is allowed to look up colors in the X11
+    color database. By default, this function returns false.
+
+    \note This function is only available on the X11 platform.
+
+    \sa setAllowX11ColorNames()
+*/
+bool QColor::allowX11ColorNames()
+{
+    return ::allowX11ColorNames;
+}
+
+/*!
+    Allow setNamedColor() to look up colors in the X11 color database if
+    \a enabled. By default, setNamedColor() does \e not look up colors in the
+    X11 color database.
+
+    \note This function is only available on the X11 platform.
+
+    \sa setNamedColor(), allowX11ColorNames()
+*/
+void QColor::setAllowX11ColorNames(bool enabled)
+{
+    ::allowX11ColorNames = enabled;
+}
+#endif
+
+/*! \internal
+
+    Marks the color as invalid and sets all components to zero (alpha is set
+    to fully opaque for compatibility with Qt 3).
+*/
+void QColor::invalidate()
+{
+    cspec = Invalid;
+    ct.argb.alpha = USHRT_MAX;
+    ct.argb.red = 0;
+    ct.argb.green = 0;
+    ct.argb.blue = 0;
+    ct.argb.pad = 0;
+}
+
+#ifdef QT3_SUPPORT
+
+/*!
+    Returns the pixel value used by the underlying window system to refer to a
+    color.
+
+    Use QColormap::pixel() instead.
+
+    \oldcode
+        QColor myColor;
+        uint pixel = myColor.pixel(screen);
+    \newcode
+        QColormap cmap = QColormap::instance(screen);
+        uint pixel  = cmap.pixel(*this);
+    \endcode
+*/
+uint QColor::pixel(int screen) const
+{
+    QColormap cmap = QColormap::instance(screen);
+    return cmap.pixel(*this);
+}
+
+#endif // QT3_SUPPORT
+
+/*****************************************************************************
+  QColor stream functions
+ *****************************************************************************/
+
+#ifndef QT_NO_DEBUG_STREAM
+QDebug operator<<(QDebug dbg, const QColor &c)
+{
+#ifndef Q_BROKEN_DEBUG_STREAM
+    if (!c.isValid())
+        dbg.nospace() << "QColor(Invalid)";
+    else if (c.spec() == QColor::Rgb)
+        dbg.nospace() << "QColor(ARGB " << c.alphaF() << ", " << c.redF() << ", " << c.greenF() << ", " << c.blueF() << ')';
+    else if (c.spec() == QColor::Hsv)
+        dbg.nospace() << "QColor(AHSV " << c.alphaF() << ", " << c.hueF() << ", " << c.saturationF() << ", " << c.valueF() << ')';
+    else if (c.spec() == QColor::Cmyk)
+        dbg.nospace() << "QColor(ACMYK " << c.alphaF() << ", " << c.cyanF() << ", " << c.magentaF() << ", " << c.yellowF() << ", "
+                      << c.blackF()<< ')';
+    else if (c.spec() == QColor::Hsl)
+        dbg.nospace() << "QColor(AHSL " << c.alphaF() << ", " << c.hslHueF() << ", " << c.hslSaturationF() << ", " << c.lightnessF() << ')';
+
+    return dbg.space();
+#else
+    qWarning("This compiler doesn't support streaming QColor to QDebug");
+    return dbg;
+    Q_UNUSED(c);
+#endif
+}
+#endif
+
+#ifndef QT_NO_DATASTREAM
+/*!
+    \fn QDataStream &operator<<(QDataStream &stream, const QColor &color)
+    \relates QColor
+
+    Writes the \a color to the \a stream.
+
+    \sa {Serializing Qt Data Types}
+*/
+QDataStream &operator<<(QDataStream &stream, const QColor &color)
+{
+    if (stream.version() < 7) {
+        if (!color.isValid())
+            return stream << quint32(0x49000000);
+        quint32 p = (quint32)color.rgb();
+        if (stream.version() == 1) // Swap red and blue
+            p = ((p << 16) & 0xff0000) | ((p >> 16) & 0xff) | (p & 0xff00ff00);
+        return stream << p;
+    }
+
+    qint8   s = color.cspec;
+    quint16 a = color.ct.argb.alpha;
+    quint16 r = color.ct.argb.red;
+    quint16 g = color.ct.argb.green;
+    quint16 b = color.ct.argb.blue;
+    quint16 p = color.ct.argb.pad;
+
+    stream << s;
+    stream << a;
+    stream << r;
+    stream << g;
+    stream << b;
+    stream << p;
+
+    return stream;
+}
+
+/*!
+    \fn QDataStream &operator>>(QDataStream &stream, QColor &color)
+    \relates QColor
+
+    Reads the \a color from the \a stream.
+
+    \sa {Serializing Qt Data Types}
+*/
+QDataStream &operator>>(QDataStream &stream, QColor &color)
+{
+    if (stream.version() < 7) {
+        quint32 p;
+        stream >> p;
+        if (p == 0x49000000) {
+            color.invalidate();
+            return stream;
+        }
+        if (stream.version() == 1) // Swap red and blue
+            p = ((p << 16) & 0xff0000) | ((p >> 16) & 0xff) | (p & 0xff00ff00);
+        color.setRgb(p);
+        return stream;
+    }
+
+    qint8 s;
+    quint16 a, r, g, b, p;
+    stream >> s;
+    stream >> a;
+    stream >> r;
+    stream >> g;
+    stream >> b;
+    stream >> p;
+
+    color.cspec = QColor::Spec(s);
+    color.ct.argb.alpha = a;
+    color.ct.argb.red   = r;
+    color.ct.argb.green = g;
+    color.ct.argb.blue  = b;
+    color.ct.argb.pad   = p;
+
+    return stream;
+}
+#endif // QT_NO_DATASTREAM
+
+
+/*****************************************************************************
+  QColor global functions (documentation only)
+ *****************************************************************************/
+
+/*!
+    \fn int qRed(QRgb rgb)
+    \relates QColor
+
+    Returns the red component of the ARGB quadruplet \a rgb.
+
+    \sa qRgb(), QColor::red()
+*/
+
+/*!
+    \fn int qGreen(QRgb rgb)
+    \relates QColor
+
+    Returns the green component of the ARGB quadruplet \a rgb.
+
+    \sa qRgb(), QColor::green()
+*/
+
+/*!
+    \fn int qBlue(QRgb rgb)
+    \relates QColor
+
+    Returns the blue component of the ARGB quadruplet \a rgb.
+
+    \sa qRgb(), QColor::blue()
+*/
+
+/*!
+    \fn int qAlpha(QRgb rgba)
+    \relates QColor
+
+    Returns the alpha component of the ARGB quadruplet \a rgba.
+
+    \sa qRgb(), QColor::alpha()
+*/
+
+/*!
+    \fn QRgb qRgb(int r, int g, int b)
+    \relates QColor
+
+    Returns the ARGB quadruplet (255, \a{r}, \a{g}, \a{b}).
+
+    \sa qRgba(), qRed(), qGreen(), qBlue()
+*/
+
+/*!
+    \fn QRgb qRgba(int r, int g, int b, int a)
+    \relates QColor
+
+    Returns the ARGB quadruplet (\a{a}, \a{r}, \a{g}, \a{b}).
+
+    \sa qRgb(), qRed(), qGreen(), qBlue()
+*/
+
+/*!
+    \fn int qGray(int r, int g, int b)
+    \relates QColor
+
+    Returns a gray value (0 to 255) from the (\a r, \a g, \a b)
+    triplet.
+
+    The gray value is calculated using the formula (\a r * 11 + \a g * 16 +
+    \a b * 5)/32.
+*/
+
+/*!
+    \fn int qGray(QRgb rgb)
+    \overload
+    \relates QColor
+
+    Returns a gray value (0 to 255) from the given ARGB quadruplet \a rgb.
+
+    The gray value is calculated using the formula (R * 11 + G * 16 + B * 5)/32;
+    the alpha-channel is ignored.
+*/
+
+/*!
+    \fn QColor::QColor(int x, int y, int z, Spec colorSpec)
+
+    Use one of the other QColor constructors, or one of the static convenience
+    functions, instead.
+*/
+
+/*!
+    \fn QColor::rgb(int *r, int *g, int *b) const
+
+    Use getRgb() instead.
+*/
+
+/*!
+    \fn QColor::hsv(int *h, int *s, int *v) const
+
+    Use getHsv() instead.
+*/
+
+/*!
+    \fn QColor QColor::convertTo(Spec colorSpec) const
+
+    Creates a copy of \e this color in the format specified by \a colorSpec.
+
+    \sa spec(), toCmyk(), toHsv(), toRgb(), isValid()
+*/
+
+/*!
+    \typedef QRgb
+    \relates QColor
+
+    An ARGB quadruplet on the format #AARRGGBB, equivalent to an unsigned int.
+
+    The type also holds a value for the alpha-channel. The default alpha
+    channel is \c ff, i.e opaque. For more information, see the
+    \l{QColor#Alpha-Blended Drawing}{Alpha-Blended Drawing} section.
+
+    \sa QColor::rgb(), QColor::rgba()
+*/
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qcolor.h b/src/gui/painting/qcolor.h
new file mode 100644
index 0000000000..af7248ce8c
--- /dev/null
+++ b/src/gui/painting/qcolor.h
@@ -0,0 +1,308 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QCOLOR_H
+#define QCOLOR_H
+
+#include <QtGui/qrgb.h>
+#include <QtCore/qnamespace.h>
+#include <QtCore/qstringlist.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+class QColor;
+class QColormap;
+class QVariant;
+
+#ifndef QT_NO_DEBUG_STREAM
+Q_GUI_EXPORT QDebug operator<<(QDebug, const QColor &);
+#endif
+#ifndef QT_NO_DATASTREAM
+Q_GUI_EXPORT QDataStream &operator<<(QDataStream &, const QColor &);
+Q_GUI_EXPORT QDataStream &operator>>(QDataStream &, QColor &);
+#endif
+
+class Q_GUI_EXPORT QColor
+{
+public:
+    enum Spec { Invalid, Rgb, Hsv, Cmyk, Hsl };
+
+    QColor();
+    QColor(Qt::GlobalColor color);
+    QColor(int r, int g, int b, int a = 255);
+    QColor(QRgb rgb);
+    QColor(const QString& name);
+    QColor(const char *name);
+    QColor(const QColor &color);
+    QColor(Spec spec);
+
+    bool isValid() const;
+
+    QString name() const;
+    void setNamedColor(const QString& name);
+
+    static QStringList colorNames();
+
+    inline Spec spec() const
+    { return cspec; }
+
+    int alpha() const;
+    void setAlpha(int alpha);
+
+    qreal alphaF() const;
+    void setAlphaF(qreal alpha);
+
+    int red() const;
+    int green() const;
+    int blue() const;
+    void setRed(int red);
+    void setGreen(int green);
+    void setBlue(int blue);
+
+    qreal redF() const;
+    qreal greenF() const;
+    qreal blueF() const;
+    void setRedF(qreal red);
+    void setGreenF(qreal green);
+    void setBlueF(qreal blue);
+
+    void getRgb(int *r, int *g, int *b, int *a = 0) const;
+    void setRgb(int r, int g, int b, int a = 255);
+
+    void getRgbF(qreal *r, qreal *g, qreal *b, qreal *a = 0) const;
+    void setRgbF(qreal r, qreal g, qreal b, qreal a = 1.0);
+
+    QRgb rgba() const;
+    void setRgba(QRgb rgba);
+
+    QRgb rgb() const;
+    void setRgb(QRgb rgb);
+
+    int hue() const; // 0 <= hue < 360
+    int saturation() const;
+    int hsvHue() const; // 0 <= hue < 360
+    int hsvSaturation() const;
+    int value() const;
+
+    qreal hueF() const; // 0.0 <= hueF < 360.0
+    qreal saturationF() const;
+    qreal hsvHueF() const; // 0.0 <= hueF < 360.0
+    qreal hsvSaturationF() const;
+    qreal valueF() const;
+
+    void getHsv(int *h, int *s, int *v, int *a = 0) const;
+    void setHsv(int h, int s, int v, int a = 255);
+
+    void getHsvF(qreal *h, qreal *s, qreal *v, qreal *a = 0) const;
+    void setHsvF(qreal h, qreal s, qreal v, qreal a = 1.0);
+
+    int cyan() const;
+    int magenta() const;
+    int yellow() const;
+    int black() const;
+
+    qreal cyanF() const;
+    qreal magentaF() const;
+    qreal yellowF() const;
+    qreal blackF() const;
+
+    void getCmyk(int *c, int *m, int *y, int *k, int *a = 0);
+    void setCmyk(int c, int m, int y, int k, int a = 255);
+
+    void getCmykF(qreal *c, qreal *m, qreal *y, qreal *k, qreal *a = 0);
+    void setCmykF(qreal c, qreal m, qreal y, qreal k, qreal a = 1.0);
+
+    int hslHue() const; // 0 <= hue < 360
+    int hslSaturation() const;
+    int lightness() const;
+
+    qreal hslHueF() const; // 0.0 <= hueF < 360.0
+    qreal hslSaturationF() const;
+    qreal lightnessF() const;
+
+    void getHsl(int *h, int *s, int *l, int *a = 0) const;
+    void setHsl(int h, int s, int l, int a = 255);
+
+    void getHslF(qreal *h, qreal *s, qreal *l, qreal *a = 0) const;
+    void setHslF(qreal h, qreal s, qreal l, qreal a = 1.0);
+
+    QColor toRgb() const;
+    QColor toHsv() const;
+    QColor toCmyk() const;
+    QColor toHsl() const;
+
+    QColor convertTo(Spec colorSpec) const;
+
+    static QColor fromRgb(QRgb rgb);
+    static QColor fromRgba(QRgb rgba);
+
+    static QColor fromRgb(int r, int g, int b, int a = 255);
+    static QColor fromRgbF(qreal r, qreal g, qreal b, qreal a = 1.0);
+
+    static QColor fromHsv(int h, int s, int v, int a = 255);
+    static QColor fromHsvF(qreal h, qreal s, qreal v, qreal a = 1.0);
+
+    static QColor fromCmyk(int c, int m, int y, int k, int a = 255);
+    static QColor fromCmykF(qreal c, qreal m, qreal y, qreal k, qreal a = 1.0);
+
+    static QColor fromHsl(int h, int s, int l, int a = 255);
+    static QColor fromHslF(qreal h, qreal s, qreal l, qreal a = 1.0);
+
+    QColor light(int f = 150) const;
+    QColor lighter(int f = 150) const;
+    QColor dark(int f = 200) const;
+    QColor darker(int f = 200) const;
+
+    QColor &operator=(const QColor &);
+    QColor &operator=(Qt::GlobalColor color);
+
+    bool operator==(const QColor &c) const;
+    bool operator!=(const QColor &c) const;
+
+    operator QVariant() const;
+
+#ifdef Q_WS_X11
+    static bool allowX11ColorNames();
+    static void setAllowX11ColorNames(bool enabled);
+#endif
+
+#ifdef QT3_SUPPORT
+    inline QT3_SUPPORT_CONSTRUCTOR QColor(int x, int y, int z, Spec colorSpec)
+    { if (colorSpec == Hsv) setHsv(x, y, z); else setRgb(x, y, z); }
+
+    inline QT3_SUPPORT void rgb(int *r, int *g, int *b) const
+    { getRgb(r, g, b); }
+    inline QT3_SUPPORT void hsv(int *h, int *s, int *v) const
+    { getHsv(h, s, v); }
+
+    inline QT3_SUPPORT void setRgba(int r, int g, int b, int a)
+    { setRgb(r, g, b, a); }
+    inline QT3_SUPPORT void getRgba(int *r, int *g, int *b, int *a) const
+    { getRgb(r, g, b, a); }
+
+    QT3_SUPPORT uint pixel(int screen = -1) const;
+#endif
+
+    static bool isValidColor(const QString &name);
+
+private:
+#ifndef QT3_SUPPORT
+    // do not allow a spec to be used as an alpha value
+    QColor(int, int, int, Spec);
+#endif
+
+    void invalidate();
+    bool setColorFromString(const QString &name);
+
+    Spec cspec;
+    union {
+        struct {
+            ushort alpha;
+            ushort red;
+            ushort green;
+            ushort blue;
+            ushort pad;
+        } argb;
+        struct {
+            ushort alpha;
+            ushort hue;
+            ushort saturation;
+            ushort value;
+            ushort pad;
+        } ahsv;
+        struct {
+            ushort alpha;
+            ushort cyan;
+            ushort magenta;
+            ushort yellow;
+            ushort black;
+        } acmyk;
+        struct {
+            ushort alpha;
+            ushort hue;
+            ushort saturation;
+            ushort lightness;
+            ushort pad;
+        } ahsl;
+        ushort array[5];
+    } ct;
+
+    friend class QColormap;
+#ifndef QT_NO_DATASTREAM
+    friend Q_GUI_EXPORT QDataStream &operator<<(QDataStream &, const QColor &);
+    friend Q_GUI_EXPORT QDataStream &operator>>(QDataStream &, QColor &);
+#endif
+};
+
+inline QColor::QColor()
+{ invalidate(); }
+
+inline QColor::QColor(int r, int g, int b, int a)
+{ setRgb(r, g, b, a); }
+
+inline QColor::QColor(const char *aname)
+{ setNamedColor(QLatin1String(aname)); }
+
+inline QColor::QColor(const QString& aname)
+{ setNamedColor(aname); }
+
+inline QColor::QColor(const QColor &acolor)
+    : cspec(acolor.cspec)
+{ ct.argb = acolor.ct.argb; }
+
+inline bool QColor::isValid() const
+{ return cspec != Invalid; }
+
+inline QColor QColor::lighter(int f) const 
+{ return light(f); }
+
+inline QColor QColor::darker(int f) const 
+{ return dark(f); }
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QCOLOR_H
diff --git a/src/gui/painting/qcolor_p.cpp b/src/gui/painting/qcolor_p.cpp
new file mode 100644
index 0000000000..38fed7146d
--- /dev/null
+++ b/src/gui/painting/qcolor_p.cpp
@@ -0,0 +1,370 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qglobal.h"
+
+#if defined(Q_CC_BOR)
+// needed for qsort() because of a std namespace problem on Borland
+#include "qplatformdefs.h"
+#endif
+
+#include "qrgb.h"
+#include "qstringlist.h"
+
+QT_BEGIN_NAMESPACE
+
+static inline int h2i(char hex)
+{
+    if (hex >= '0' && hex <= '9')
+        return hex - '0';
+    if (hex >= 'a' && hex <= 'f')
+        return hex - 'a' + 10;
+    if (hex >= 'A' && hex <= 'F')
+        return hex - 'A' + 10;
+    return -1;
+}
+
+static inline int hex2int(const char *s)
+{
+    return (h2i(s[0]) << 4) | h2i(s[1]);
+}
+
+static inline int hex2int(char s)
+{
+    int h = h2i(s);
+    return (h << 4) | h;
+}
+
+bool qt_get_hex_rgb(const char *name, QRgb *rgb)
+{
+    if(name[0] != '#')
+        return false;
+    name++;
+    int len = qstrlen(name);
+    int r, g, b;
+    if (len == 12) {
+        r = hex2int(name);
+        g = hex2int(name + 4);
+        b = hex2int(name + 8);
+    } else if (len == 9) {
+        r = hex2int(name);
+        g = hex2int(name + 3);
+        b = hex2int(name + 6);
+    } else if (len == 6) {
+        r = hex2int(name);
+        g = hex2int(name + 2);
+        b = hex2int(name + 4);
+    } else if (len == 3) {
+        r = hex2int(name[0]);
+        g = hex2int(name[1]);
+        b = hex2int(name[2]);
+    } else {
+        r = g = b = -1;
+    }
+    if ((uint)r > 255 || (uint)g > 255 || (uint)b > 255) {
+        *rgb = 0;
+        return false;
+    }
+    *rgb = qRgb(r, g ,b);
+    return true;
+}
+
+bool qt_get_hex_rgb(const QChar *str, int len, QRgb *rgb)
+{
+    if (len > 13)
+        return false;
+    char tmp[16];
+    for(int i = 0; i < len; ++i)
+        tmp[i] = str[i].toLatin1();
+    tmp[len] = 0;
+    return qt_get_hex_rgb(tmp, rgb);
+}
+
+#ifndef QT_NO_COLORNAMES
+
+/*
+  CSS color names = SVG 1.0 color names + transparent (rgba(0,0,0,0))
+*/
+
+#ifdef rgb
+#  undef rgb
+#endif
+#define rgb(r,g,b) (0xff000000 | (r << 16) |  (g << 8) | b)
+
+static const struct RGBData {
+    const char *name;
+    uint  value;
+} rgbTbl[] = {
+    { "aliceblue", rgb(240, 248, 255) },
+    { "antiquewhite", rgb(250, 235, 215) },
+    { "aqua", rgb( 0, 255, 255) },
+    { "aquamarine", rgb(127, 255, 212) },
+    { "azure", rgb(240, 255, 255) },
+    { "beige", rgb(245, 245, 220) },
+    { "bisque", rgb(255, 228, 196) },
+    { "black", rgb( 0, 0, 0) },
+    { "blanchedalmond", rgb(255, 235, 205) },
+    { "blue", rgb( 0, 0, 255) },
+    { "blueviolet", rgb(138, 43, 226) },
+    { "brown", rgb(165, 42, 42) },
+    { "burlywood", rgb(222, 184, 135) },
+    { "cadetblue", rgb( 95, 158, 160) },
+    { "chartreuse", rgb(127, 255, 0) },
+    { "chocolate", rgb(210, 105, 30) },
+    { "coral", rgb(255, 127, 80) },
+    { "cornflowerblue", rgb(100, 149, 237) },
+    { "cornsilk", rgb(255, 248, 220) },
+    { "crimson", rgb(220, 20, 60) },
+    { "cyan", rgb( 0, 255, 255) },
+    { "darkblue", rgb( 0, 0, 139) },
+    { "darkcyan", rgb( 0, 139, 139) },
+    { "darkgoldenrod", rgb(184, 134, 11) },
+    { "darkgray", rgb(169, 169, 169) },
+    { "darkgreen", rgb( 0, 100, 0) },
+    { "darkgrey", rgb(169, 169, 169) },
+    { "darkkhaki", rgb(189, 183, 107) },
+    { "darkmagenta", rgb(139, 0, 139) },
+    { "darkolivegreen", rgb( 85, 107, 47) },
+    { "darkorange", rgb(255, 140, 0) },
+    { "darkorchid", rgb(153, 50, 204) },
+    { "darkred", rgb(139, 0, 0) },
+    { "darksalmon", rgb(233, 150, 122) },
+    { "darkseagreen", rgb(143, 188, 143) },
+    { "darkslateblue", rgb( 72, 61, 139) },
+    { "darkslategray", rgb( 47, 79, 79) },
+    { "darkslategrey", rgb( 47, 79, 79) },
+    { "darkturquoise", rgb( 0, 206, 209) },
+    { "darkviolet", rgb(148, 0, 211) },
+    { "deeppink", rgb(255, 20, 147) },
+    { "deepskyblue", rgb( 0, 191, 255) },
+    { "dimgray", rgb(105, 105, 105) },
+    { "dimgrey", rgb(105, 105, 105) },
+    { "dodgerblue", rgb( 30, 144, 255) },
+    { "firebrick", rgb(178, 34, 34) },
+    { "floralwhite", rgb(255, 250, 240) },
+    { "forestgreen", rgb( 34, 139, 34) },
+    { "fuchsia", rgb(255, 0, 255) },
+    { "gainsboro", rgb(220, 220, 220) },
+    { "ghostwhite", rgb(248, 248, 255) },
+    { "gold", rgb(255, 215, 0) },
+    { "goldenrod", rgb(218, 165, 32) },
+    { "gray", rgb(128, 128, 128) },
+    { "green", rgb( 0, 128, 0) },
+    { "greenyellow", rgb(173, 255, 47) },
+    { "grey", rgb(128, 128, 128) },
+    { "honeydew", rgb(240, 255, 240) },
+    { "hotpink", rgb(255, 105, 180) },
+    { "indianred", rgb(205, 92, 92) },
+    { "indigo", rgb( 75, 0, 130) },
+    { "ivory", rgb(255, 255, 240) },
+    { "khaki", rgb(240, 230, 140) },
+    { "lavender", rgb(230, 230, 250) },
+    { "lavenderblush", rgb(255, 240, 245) },
+    { "lawngreen", rgb(124, 252, 0) },
+    { "lemonchiffon", rgb(255, 250, 205) },
+    { "lightblue", rgb(173, 216, 230) },
+    { "lightcoral", rgb(240, 128, 128) },
+    { "lightcyan", rgb(224, 255, 255) },
+    { "lightgoldenrodyellow", rgb(250, 250, 210) },
+    { "lightgray", rgb(211, 211, 211) },
+    { "lightgreen", rgb(144, 238, 144) },
+    { "lightgrey", rgb(211, 211, 211) },
+    { "lightpink", rgb(255, 182, 193) },
+    { "lightsalmon", rgb(255, 160, 122) },
+    { "lightseagreen", rgb( 32, 178, 170) },
+    { "lightskyblue", rgb(135, 206, 250) },
+    { "lightslategray", rgb(119, 136, 153) },
+    { "lightslategrey", rgb(119, 136, 153) },
+    { "lightsteelblue", rgb(176, 196, 222) },
+    { "lightyellow", rgb(255, 255, 224) },
+    { "lime", rgb( 0, 255, 0) },
+    { "limegreen", rgb( 50, 205, 50) },
+    { "linen", rgb(250, 240, 230) },
+    { "magenta", rgb(255, 0, 255) },
+    { "maroon", rgb(128, 0, 0) },
+    { "mediumaquamarine", rgb(102, 205, 170) },
+    { "mediumblue", rgb( 0, 0, 205) },
+    { "mediumorchid", rgb(186, 85, 211) },
+    { "mediumpurple", rgb(147, 112, 219) },
+    { "mediumseagreen", rgb( 60, 179, 113) },
+    { "mediumslateblue", rgb(123, 104, 238) },
+    { "mediumspringgreen", rgb( 0, 250, 154) },
+    { "mediumturquoise", rgb( 72, 209, 204) },
+    { "mediumvioletred", rgb(199, 21, 133) },
+    { "midnightblue", rgb( 25, 25, 112) },
+    { "mintcream", rgb(245, 255, 250) },
+    { "mistyrose", rgb(255, 228, 225) },
+    { "moccasin", rgb(255, 228, 181) },
+    { "navajowhite", rgb(255, 222, 173) },
+    { "navy", rgb( 0, 0, 128) },
+    { "oldlace", rgb(253, 245, 230) },
+    { "olive", rgb(128, 128, 0) },
+    { "olivedrab", rgb(107, 142, 35) },
+    { "orange", rgb(255, 165, 0) },
+    { "orangered", rgb(255, 69, 0) },
+    { "orchid", rgb(218, 112, 214) },
+    { "palegoldenrod", rgb(238, 232, 170) },
+    { "palegreen", rgb(152, 251, 152) },
+    { "paleturquoise", rgb(175, 238, 238) },
+    { "palevioletred", rgb(219, 112, 147) },
+    { "papayawhip", rgb(255, 239, 213) },
+    { "peachpuff", rgb(255, 218, 185) },
+    { "peru", rgb(205, 133, 63) },
+    { "pink", rgb(255, 192, 203) },
+    { "plum", rgb(221, 160, 221) },
+    { "powderblue", rgb(176, 224, 230) },
+    { "purple", rgb(128, 0, 128) },
+    { "red", rgb(255, 0, 0) },
+    { "rosybrown", rgb(188, 143, 143) },
+    { "royalblue", rgb( 65, 105, 225) },
+    { "saddlebrown", rgb(139, 69, 19) },
+    { "salmon", rgb(250, 128, 114) },
+    { "sandybrown", rgb(244, 164, 96) },
+    { "seagreen", rgb( 46, 139, 87) },
+    { "seashell", rgb(255, 245, 238) },
+    { "sienna", rgb(160, 82, 45) },
+    { "silver", rgb(192, 192, 192) },
+    { "skyblue", rgb(135, 206, 235) },
+    { "slateblue", rgb(106, 90, 205) },
+    { "slategray", rgb(112, 128, 144) },
+    { "slategrey", rgb(112, 128, 144) },
+    { "snow", rgb(255, 250, 250) },
+    { "springgreen", rgb( 0, 255, 127) },
+    { "steelblue", rgb( 70, 130, 180) },
+    { "tan", rgb(210, 180, 140) },
+    { "teal", rgb( 0, 128, 128) },
+    { "thistle", rgb(216, 191, 216) },
+    { "tomato", rgb(255, 99, 71) },
+    { "transparent", 0 },
+    { "turquoise", rgb( 64, 224, 208) },
+    { "violet", rgb(238, 130, 238) },
+    { "wheat", rgb(245, 222, 179) },
+    { "white", rgb(255, 255, 255) },
+    { "whitesmoke", rgb(245, 245, 245) },
+    { "yellow", rgb(255, 255, 0) },
+    { "yellowgreen", rgb(154, 205, 50) }
+};
+
+static const int rgbTblSize = sizeof(rgbTbl) / sizeof(RGBData);
+
+#undef rgb
+
+inline bool operator<(const char *name, const RGBData &data)
+{ return qstrcmp(name, data.name) < 0; }
+inline bool operator<(const RGBData &data, const char *name)
+{ return qstrcmp(data.name, name) < 0; }
+
+static bool get_named_rgb(const char *name_no_space, QRgb *rgb)
+{
+    QByteArray name = QByteArray(name_no_space).toLower();
+    const RGBData *r = qBinaryFind(rgbTbl, rgbTbl + rgbTblSize, name.constData());
+    if (r != rgbTbl + rgbTblSize) {
+        *rgb = r->value;
+        return true;
+    }
+    return false;
+}
+
+bool qt_get_named_rgb(const char *name, QRgb* rgb)
+{
+    int len = int(strlen(name));
+    if(len > 255)
+        return false;
+    char name_no_space[256];
+    int pos = 0;
+    for(int i = 0; i < len; i++) {
+        if(name[i] != '\t' && name[i] != ' ')
+            name_no_space[pos++] = name[i];
+    }
+    name_no_space[pos] = 0;
+
+    return get_named_rgb(name_no_space, rgb);
+}
+
+bool qt_get_named_rgb(const QChar *name, int len, QRgb *rgb)
+{
+    if(len > 255)
+        return false;
+    char name_no_space[256];
+    int pos = 0;
+    for(int i = 0; i < len; i++) {
+        if(name[i] != QLatin1Char('\t') && name[i] != QLatin1Char(' '))
+            name_no_space[pos++] = name[i].toLatin1();
+    }
+    name_no_space[pos] = 0;
+    return get_named_rgb(name_no_space, rgb);
+}
+
+
+uint qt_get_rgb_val(const char *name)
+{
+    QRgb r = 0;
+    qt_get_named_rgb(name,&r);
+    return r;
+}
+
+QStringList qt_get_colornames()
+{
+    int i = 0;
+    QStringList lst;
+    for (i = 0; i < rgbTblSize; i++)
+        lst << QLatin1String(rgbTbl[i].name);
+    return lst;
+}
+
+#else
+
+bool qt_get_named_rgb(const char *, QRgb*)
+{
+    return false;
+}
+
+uint qt_get_rgb_val(const char *)
+{
+    return 0;
+}
+QStringList qt_get_colornames()
+{
+    return QStringList();
+}
+#endif // QT_NO_COLORNAMES
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qcolor_p.h b/src/gui/painting/qcolor_p.h
new file mode 100644
index 0000000000..0698a7643c
--- /dev/null
+++ b/src/gui/painting/qcolor_p.h
@@ -0,0 +1,71 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QCOLOR_P_H
+#define QCOLOR_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "QtCore/qglobal.h"
+#include "QtGui/qrgb.h"
+#include "QtCore/qstringlist.h"
+
+QT_BEGIN_NAMESPACE
+
+uint qt_get_rgb_val(const char *name);
+bool qt_get_named_rgb(const char *, QRgb*);
+bool qt_get_named_rgb(const QChar *, int len, QRgb*);
+bool qt_get_hex_rgb(const char *, QRgb *);
+bool qt_get_hex_rgb(const QChar *, int len, QRgb *);
+QStringList qt_get_colornames();
+
+QT_END_NAMESPACE
+
+#endif // QCOLOR_P_H
diff --git a/src/gui/painting/qcolormap.h b/src/gui/painting/qcolormap.h
new file mode 100644
index 0000000000..4d0521d622
--- /dev/null
+++ b/src/gui/painting/qcolormap.h
@@ -0,0 +1,97 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QCOLORMAP_H
+#define QCOLORMAP_H
+
+#include <QtCore/qatomic.h>
+#include <QtGui/qrgb.h>
+#include <QtCore/qvector.h>
+#include <QtGui/qwindowdefs.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+class QColor;
+class QColormapPrivate;
+
+class Q_GUI_EXPORT QColormap
+{
+public:
+    enum Mode { Direct, Indexed, Gray };
+
+    static void initialize();
+    static void cleanup();
+
+    static QColormap instance(int screen = -1);
+
+    QColormap(const QColormap &colormap);
+    ~QColormap();
+
+    QColormap &operator=(const QColormap &colormap);
+
+    Mode mode() const;
+
+    int depth() const;
+    int size() const;
+
+    uint pixel(const QColor &color) const;
+    const QColor colorAt(uint pixel) const;
+
+    const QVector<QColor> colormap() const;
+
+#ifdef Q_WS_WIN
+    static HPALETTE hPal();
+#endif
+
+private:
+    QColormap();
+    QColormapPrivate *d;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QCOLORMAP_H
diff --git a/src/gui/painting/qcolormap.qdoc b/src/gui/painting/qcolormap.qdoc
new file mode 100644
index 0000000000..04ed407510
--- /dev/null
+++ b/src/gui/painting/qcolormap.qdoc
@@ -0,0 +1,148 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Free Documentation License
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of this
+** file.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \class QColormap
+    \ingroup painting
+
+    \brief The QColormap class maps device independent QColors to device
+    dependent pixel values.
+*/
+
+/*! \enum QColormap::Mode
+
+    This enum describes how QColormap maps device independent RGB
+    values to device dependent pixel values.
+
+    \value Direct Pixel values are derived directly from the RGB
+    values, also known as "True Color."
+
+    \value Indexed Pixel values represent indexes into a vector of
+    available colors, i.e. QColormap uses the index of the color that
+    most closely matches an RGB value.
+
+    \value Gray Similar to \c Indexed, pixel values represent a vector
+    of available gray tones.  QColormap uses the index of the gray
+    tone that most closely matches the computed gray tone of an RGB
+    value.
+*/
+
+/*!
+    \fn QColormap QColormap::instance(int screen)
+
+    Returns the colormap for the specified \a screen.  If \a screen is
+    -1, this function returns the colormap for the default screen.
+*/
+
+/*!
+    \fn QColormap::QColormap(const QColormap &colormap)
+
+    Constructs a copy of another \a colormap.
+*/
+
+/*!
+    \fn QColormap::~QColormap()
+    
+    Destroys the colormap.
+*/
+
+/*!
+    \fn int QColormap::size() const
+
+    Returns the size of the colormap for \c Indexed and \c Gray modes;
+    Returns -1 for \c Direct mode.
+
+    \sa colormap()
+*/
+
+/*!
+    \fn uint QColormap::pixel(const QColor &color) const
+
+    Returns a device dependent pixel value for the \a color.
+
+    \sa colorAt()
+*/
+
+/*!
+    \fn int QColormap::depth() const
+
+    Returns the depth of the device.
+
+    \sa size()
+*/
+
+/*!
+    \fn QColormap::Mode QColormap::mode() const
+
+    Returns the mode of this colormap.
+
+    \sa QColormap::Mode
+*/
+
+/*!
+    \fn const QColor QColormap::colorAt(uint pixel) const
+
+    Returns a QColor for the \a pixel.
+
+    \sa pixel()
+*/
+
+/*!
+    \fn const QVector<QColor> QColormap::colormap() const
+
+    Returns a vector of colors which represents the devices colormap
+    for \c Indexed and \c Gray modes.  This function returns an empty
+    vector for \c Direct mode.
+
+    \sa size()
+*/
+
+/*! \fn HPALETTE QColormap::hPal()
+
+    This function is only available on Windows.
+
+    Returns an handle to the HPALETTE used by this colormap.  If no
+    HPALETTE is being used, this function returns zero.
+*/
+
+/*! \since 4.2
+
+    \fn QColormap &QColormap::operator=(const QColormap &colormap)
+
+    Assigns the given \a colormap to \e this color map and returns
+    a reference to \e this color map.
+*/
+
+/*!
+   \fn void QColormap::initialize()
+   \internal
+*/
+
+/*!
+   \fn void QColormap::cleanup()
+   \internal
+*/
diff --git a/src/gui/painting/qcolormap_mac.cpp b/src/gui/painting/qcolormap_mac.cpp
new file mode 100644
index 0000000000..28589f41b8
--- /dev/null
+++ b/src/gui/painting/qcolormap_mac.cpp
@@ -0,0 +1,111 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qcolormap.h"
+#include "qcolor.h"
+
+QT_BEGIN_NAMESPACE
+
+class QColormapPrivate
+{
+public:
+    inline QColormapPrivate()
+        : ref(1)
+    { }
+
+    QAtomicInt ref;
+};
+static QColormap *qt_mac_global_map = 0;
+
+void QColormap::initialize()
+{
+    qt_mac_global_map = new QColormap;
+}
+
+void QColormap::cleanup()
+{
+    delete qt_mac_global_map;
+    qt_mac_global_map = 0;
+}
+
+QColormap QColormap::instance(int)
+{
+    return *qt_mac_global_map;
+}
+
+QColormap::QColormap() : d(new QColormapPrivate)
+{}
+
+QColormap::QColormap(const QColormap &colormap) :d (colormap.d)
+{ d->ref.ref(); }
+
+QColormap::~QColormap()
+{
+    if (!d->ref.deref())
+        delete d;
+}
+
+QColormap::Mode QColormap::mode() const
+{ return QColormap::Direct; }
+
+int QColormap::depth() const
+{
+    return 32;
+}
+
+int QColormap::size() const
+{
+    return -1;
+}
+
+uint QColormap::pixel(const QColor &color) const
+{ return color.rgba(); }
+
+const QColor QColormap::colorAt(uint pixel) const
+{ return QColor(pixel); }
+
+const QVector<QColor> QColormap::colormap() const
+{ return QVector<QColor>(); }
+
+QColormap &QColormap::operator=(const QColormap &colormap)
+{ qAtomicAssign(d, colormap.d); return *this; }
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qcolormap_qpa.cpp b/src/gui/painting/qcolormap_qpa.cpp
new file mode 100644
index 0000000000..f66607bb05
--- /dev/null
+++ b/src/gui/painting/qcolormap_qpa.cpp
@@ -0,0 +1,231 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qcolormap.h"
+#include "qcolor.h"
+#include "qpaintdevice.h"
+#include "private/qapplication_p.h"
+#include "private/qgraphicssystem_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QColormapPrivate
+{
+public:
+    inline QColormapPrivate()
+        : ref(1), mode(QColormap::Direct), depth(0), numcolors(0)
+    { }
+
+    QAtomicInt ref;
+
+    QColormap::Mode mode;
+    int depth;
+    int numcolors;
+};
+
+static QColormapPrivate *screenMap = 0;
+
+void QColormap::initialize()
+{
+    screenMap = new QColormapPrivate;
+
+    QPlatformIntegration *pi = QApplicationPrivate::platformIntegration();
+    QList<QPlatformScreen*> screens = pi->screens();
+
+    screenMap->depth = screens.at(0)->depth();
+    if (screenMap->depth < 8) {
+        screenMap->mode = QColormap::Indexed;
+        screenMap->numcolors = 256;
+    } else {
+        screenMap->mode = QColormap::Direct;
+        screenMap->numcolors = -1;
+    }
+}
+
+void QColormap::cleanup()
+{
+    delete screenMap;
+    screenMap = 0;
+}
+
+QColormap QColormap::instance(int /*screen*/)
+{
+    return QColormap();
+}
+
+QColormap::QColormap()
+    : d(screenMap)
+{ d->ref.ref(); }
+
+QColormap::QColormap(const QColormap &colormap)
+    :d (colormap.d)
+{ d->ref.ref(); }
+
+QColormap::~QColormap()
+{
+    if (!d->ref.deref())
+        delete d;
+}
+
+QColormap::Mode QColormap::mode() const
+{ return d->mode; }
+
+
+int QColormap::depth() const
+{ return d->depth; }
+
+
+int QColormap::size() const
+{
+    return d->numcolors;
+}
+
+#ifndef QT_QWS_DEPTH16_RGB
+#define QT_QWS_DEPTH16_RGB 565
+#endif
+static const int qt_rbits = (QT_QWS_DEPTH16_RGB/100);
+static const int qt_gbits = (QT_QWS_DEPTH16_RGB/10%10);
+static const int qt_bbits = (QT_QWS_DEPTH16_RGB%10);
+static const int qt_red_shift = qt_bbits+qt_gbits-(8-qt_rbits);
+static const int qt_green_shift = qt_bbits-(8-qt_gbits);
+static const int qt_neg_blue_shift = 8-qt_bbits;
+static const int qt_blue_mask = (1<<qt_bbits)-1;
+static const int qt_green_mask = (1<<(qt_gbits+qt_bbits))-(1<<qt_bbits);
+static const int qt_red_mask = (1<<(qt_rbits+qt_gbits+qt_bbits))-(1<<(qt_gbits+qt_bbits));
+
+static const int qt_red_rounding_shift = qt_red_shift + qt_rbits;
+static const int qt_green_rounding_shift = qt_green_shift + qt_gbits;
+static const int qt_blue_rounding_shift = qt_bbits - qt_neg_blue_shift;
+
+inline ushort qt_convRgbTo16(QRgb c)
+{
+    const int tr = qRed(c) << qt_red_shift;
+    const int tg = qGreen(c) << qt_green_shift;
+    const int tb = qBlue(c) >> qt_neg_blue_shift;
+
+    return (tb & qt_blue_mask) | (tg & qt_green_mask) | (tr & qt_red_mask);
+}
+
+inline QRgb qt_conv16ToRgb(ushort c)
+{
+    const int r=(c & qt_red_mask);
+    const int g=(c & qt_green_mask);
+    const int b=(c & qt_blue_mask);
+    const int tr = r >> qt_red_shift | r >> qt_red_rounding_shift;
+    const int tg = g >> qt_green_shift | g >> qt_green_rounding_shift;
+    const int tb = b << qt_neg_blue_shift | b >> qt_blue_rounding_shift;
+
+    return qRgb(tr,tg,tb);
+}
+
+uint QColormap::pixel(const QColor &color) const
+{
+    QRgb rgb = color.rgba();
+    if (d->mode == QColormap::Direct) {
+        switch(d->depth) {
+        case 16:
+            return qt_convRgbTo16(rgb);
+        case 24:
+        case 32:
+        {
+            const int r = qRed(rgb);
+            const int g = qGreen(rgb);
+            const int b = qBlue(rgb);
+            const int red_shift = 16;
+            const int green_shift = 8;
+            const int red_mask   = 0xff0000;
+            const int green_mask = 0x00ff00;
+            const int blue_mask  = 0x0000ff;
+            const int tg = g << green_shift;
+#ifdef QT_QWS_DEPTH_32_BGR
+            if (qt_screen->pixelType() == QScreen::BGRPixel) {
+                const int tb = b << red_shift;
+                return 0xff000000 | (r & blue_mask) | (tg & green_mask) | (tb & red_mask);
+            }
+#endif
+            const int tr = r << red_shift;
+            return 0xff000000 | (b & blue_mask) | (tg & green_mask) | (tr & red_mask);
+        }
+        }
+    }
+    //XXX
+    //return qt_screen->alloc(qRed(rgb), qGreen(rgb), qBlue(rgb));
+    return 0;
+}
+
+const QColor QColormap::colorAt(uint pixel) const
+{
+    if (d->mode == Direct) {
+        if (d->depth == 16) {
+            pixel = qt_conv16ToRgb(pixel);
+        }
+        const int red_shift = 16;
+        const int green_shift = 8;
+        const int red_mask   = 0xff0000;
+        const int green_mask = 0x00ff00;
+        const int blue_mask  = 0x0000ff;
+#ifdef QT_QWS_DEPTH_32_BGR
+        if (qt_screen->pixelType() == QScreen::BGRPixel) {
+            return QColor((pixel & blue_mask),
+                          (pixel & green_mask) >> green_shift,
+                          (pixel & red_mask) >> red_shift);
+        }
+#endif
+        return QColor((pixel & red_mask) >> red_shift,
+                      (pixel & green_mask) >> green_shift,
+                      (pixel & blue_mask));
+    }
+#if 0 // XXX
+    Q_ASSERT_X(int(pixel) < qt_screen->numCols(), "QColormap::colorAt", "pixel out of bounds of palette");
+    return QColor(qt_screen->clut()[pixel]);
+#endif
+    return QColor();
+}
+
+const QVector<QColor> QColormap::colormap() const
+{
+    return QVector<QColor>();
+}
+
+QColormap &QColormap::operator=(const QColormap &colormap)
+{ qAtomicAssign(d, colormap.d); return *this; }
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qcolormap_qws.cpp b/src/gui/painting/qcolormap_qws.cpp
new file mode 100644
index 0000000000..5c0933d6eb
--- /dev/null
+++ b/src/gui/painting/qcolormap_qws.cpp
@@ -0,0 +1,185 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qcolormap.h"
+#include "qcolor.h"
+#include "qpaintdevice.h"
+#include "qscreen_qws.h"
+#include "qwsdisplay_qws.h"
+
+QT_BEGIN_NAMESPACE
+
+class QColormapPrivate
+{
+public:
+    inline QColormapPrivate()
+        : ref(1), mode(QColormap::Direct), depth(0), numcolors(0)
+    { }
+
+    QAtomicInt ref;
+
+    QColormap::Mode mode;
+    int depth;
+    int numcolors;
+};
+
+static QColormapPrivate *screenMap = 0;
+
+void QColormap::initialize()
+{
+    screenMap = new QColormapPrivate;
+
+    screenMap->depth = QPaintDevice::qwsDisplay()->depth();
+    if (screenMap->depth < 8) {
+        screenMap->mode = QColormap::Indexed;
+        screenMap->numcolors = 256;
+    } else {
+        screenMap->mode = QColormap::Direct;
+        screenMap->numcolors = -1;
+    }
+}
+
+void QColormap::cleanup()
+{
+    delete screenMap;
+    screenMap = 0;
+}
+
+QColormap QColormap::instance(int /*screen*/)
+{
+    return QColormap();
+}
+
+QColormap::QColormap()
+    : d(screenMap)
+{ d->ref.ref(); }
+
+QColormap::QColormap(const QColormap &colormap)
+    :d (colormap.d)
+{ d->ref.ref(); }
+
+QColormap::~QColormap()
+{
+    if (!d->ref.deref())
+        delete d;
+}
+
+QColormap::Mode QColormap::mode() const
+{ return d->mode; }
+
+
+int QColormap::depth() const
+{ return d->depth; }
+
+
+int QColormap::size() const
+{
+    return d->numcolors;
+}
+
+uint QColormap::pixel(const QColor &color) const
+{
+    QRgb rgb = color.rgba();
+    if (d->mode == QColormap::Direct) {
+        switch(d->depth) {
+        case 16:
+            return qt_convRgbTo16(rgb);
+        case 24:
+        case 32:
+        {
+            const int r = qRed(rgb);
+            const int g = qGreen(rgb);
+            const int b = qBlue(rgb);
+            const int red_shift = 16;
+            const int green_shift = 8;
+            const int red_mask   = 0xff0000;
+            const int green_mask = 0x00ff00;
+            const int blue_mask  = 0x0000ff;
+            const int tg = g << green_shift;
+#ifdef QT_QWS_DEPTH_32_BGR
+            if (qt_screen->pixelType() == QScreen::BGRPixel) {
+                const int tb = b << red_shift;
+                return 0xff000000 | (r & blue_mask) | (tg & green_mask) | (tb & red_mask);
+            }
+#endif
+            const int tr = r << red_shift;
+            return 0xff000000 | (b & blue_mask) | (tg & green_mask) | (tr & red_mask);
+        }
+        }
+    }
+    return qt_screen->alloc(qRed(rgb), qGreen(rgb), qBlue(rgb));
+}
+
+const QColor QColormap::colorAt(uint pixel) const
+{
+    if (d->mode == Direct) {
+        if (d->depth == 16) {
+            pixel = qt_conv16ToRgb(pixel);
+        }
+        const int red_shift = 16;
+        const int green_shift = 8;
+        const int red_mask   = 0xff0000;
+        const int green_mask = 0x00ff00;
+        const int blue_mask  = 0x0000ff;
+#ifdef QT_QWS_DEPTH_32_BGR
+        if (qt_screen->pixelType() == QScreen::BGRPixel) {
+            return QColor((pixel & blue_mask),
+                          (pixel & green_mask) >> green_shift,
+                          (pixel & red_mask) >> red_shift);
+        }
+#endif
+        return QColor((pixel & red_mask) >> red_shift,
+                      (pixel & green_mask) >> green_shift,
+                      (pixel & blue_mask));
+    }
+    Q_ASSERT_X(int(pixel) < qt_screen->colorCount(), "QColormap::colorAt", "pixel out of bounds of palette");
+    return QColor(qt_screen->clut()[pixel]);
+}
+
+const QVector<QColor> QColormap::colormap() const
+{
+    return QVector<QColor>();
+}
+
+QColormap &QColormap::operator=(const QColormap &colormap)
+{ qAtomicAssign(d, colormap.d); return *this; }
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qcolormap_s60.cpp b/src/gui/painting/qcolormap_s60.cpp
new file mode 100644
index 0000000000..2c634db8a5
--- /dev/null
+++ b/src/gui/painting/qcolormap_s60.cpp
@@ -0,0 +1,107 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qcolormap.h"
+#include "qcolor.h"
+
+QT_BEGIN_NAMESPACE
+
+class QColormapPrivate
+{
+public:
+    inline QColormapPrivate()
+        : ref(1)
+    { }
+
+    QAtomicInt ref;
+};
+
+void QColormap::initialize()
+{
+}
+
+void QColormap::cleanup()
+{
+}
+
+QColormap QColormap::instance(int)
+{
+    return QColormap();
+}
+
+QColormap::QColormap() : d(new QColormapPrivate)
+{}
+
+QColormap::QColormap(const QColormap &colormap) :d (colormap.d)
+{ d->ref.ref(); }
+
+QColormap::~QColormap()
+{
+    if (!d->ref.deref())
+        delete d;
+}
+
+QColormap::Mode QColormap::mode() const
+{ return QColormap::Direct; }
+
+int QColormap::depth() const
+{
+    return 32;
+}
+
+int QColormap::size() const
+{
+    return -1;
+}
+
+uint QColormap::pixel(const QColor &color) const
+{ return color.rgba(); }
+
+const QColor QColormap::colorAt(uint pixel) const
+{ return QColor(pixel); }
+
+const QVector<QColor> QColormap::colormap() const
+{ return QVector<QColor>(); }
+
+QColormap &QColormap::operator=(const QColormap &colormap)
+{ qAtomicAssign(d, colormap.d); return *this; }
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qcolormap_win.cpp b/src/gui/painting/qcolormap_win.cpp
new file mode 100644
index 0000000000..1773f717c0
--- /dev/null
+++ b/src/gui/painting/qcolormap_win.cpp
@@ -0,0 +1,201 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qcolor.h"
+#include "qcolormap.h"
+#include "qvector.h"
+#include "qt_windows.h"
+
+#if defined(Q_WS_WINCE)
+#include "qguifunctions_wince.h"
+#endif
+
+QT_BEGIN_NAMESPACE
+
+class QColormapPrivate
+{
+public:
+    inline QColormapPrivate()
+        : ref(1), mode(QColormap::Direct), depth(0), hpal(0)
+    { }
+
+    QAtomicInt ref;
+
+    QColormap::Mode mode;
+    int depth;
+    int numcolors;
+
+    HPALETTE hpal;
+    QVector<QColor> palette;
+};
+
+static QColormapPrivate *screenMap = 0;
+
+void QColormap::initialize()
+{
+    HDC dc = qt_win_display_dc();
+
+    screenMap = new QColormapPrivate;
+    screenMap->depth = GetDeviceCaps(dc, BITSPIXEL);
+
+    screenMap->numcolors = -1;
+    if (GetDeviceCaps(dc, RASTERCAPS) & RC_PALETTE)
+        screenMap->numcolors = GetDeviceCaps(dc, SIZEPALETTE);
+
+    if (screenMap->numcolors <= 16 || screenMap->numcolors > 256)        // no need to create palette
+        return;
+
+    LOGPALETTE* pal = 0;
+    int numPalEntries = 6*6*6; // color cube
+
+    pal = (LOGPALETTE*)malloc(sizeof(LOGPALETTE) + numPalEntries * sizeof(PALETTEENTRY));
+    // Make 6x6x6 color cube
+    int idx = 0;
+    for(int ir = 0x0; ir <= 0xff; ir+=0x33) {
+        for(int ig = 0x0; ig <= 0xff; ig+=0x33) {
+            for(int ib = 0x0; ib <= 0xff; ib+=0x33) {
+                pal->palPalEntry[idx].peRed = ir;
+                pal->palPalEntry[idx].peGreen = ig;
+                pal->palPalEntry[idx].peBlue = ib;
+                pal->palPalEntry[idx].peFlags = 0;
+                idx++;
+            }
+        }
+    }
+
+    pal->palVersion = 0x300;
+    pal->palNumEntries = numPalEntries;
+
+    screenMap->hpal = CreatePalette(pal);
+    if (!screenMap->hpal)
+        qErrnoWarning("QColor::initialize: Failed to create logical palette");
+    free (pal);
+
+    SelectPalette(dc, screenMap->hpal, FALSE);
+    RealizePalette(dc);
+
+    PALETTEENTRY paletteEntries[256];
+    screenMap->numcolors = GetPaletteEntries(screenMap->hpal, 0, 255, paletteEntries);
+
+    screenMap->palette.resize(screenMap->numcolors);
+    for (int i = 0; i < screenMap->numcolors; i++) {
+        screenMap->palette[i] = qRgb(paletteEntries[i].peRed,
+                                     paletteEntries[i].peGreen,
+                                     paletteEntries[i].peBlue);
+    }
+}
+
+void QColormap::cleanup()
+{
+    if (!screenMap)
+        return;
+
+    if (screenMap->hpal) {                                // delete application global
+        DeleteObject(screenMap->hpal);                        // palette
+        screenMap->hpal = 0;
+    }
+
+    delete screenMap;
+    screenMap = 0;
+}
+
+QColormap QColormap::instance(int)
+{
+    Q_ASSERT_X(screenMap, "QColormap",
+               "A QApplication object needs to be constructed before QColormap is used.");
+    return QColormap();
+}
+
+QColormap::QColormap()
+    : d(screenMap)
+{ d->ref.ref(); }
+
+QColormap::QColormap(const QColormap &colormap)
+    :d (colormap.d)
+{ d->ref.ref(); }
+
+QColormap::~QColormap()
+{
+    if (!d->ref.deref())
+        delete d;
+}
+
+QColormap::Mode QColormap::mode() const
+{ return d->mode; }
+
+int QColormap::depth() const
+{ return d->depth; }
+
+int QColormap::size() const
+{ return d->numcolors; }
+
+uint QColormap::pixel(const QColor &color) const
+{
+    const QColor c = color.toRgb();
+    COLORREF rgb = RGB(c.red(), c.green(), c.blue());
+    if (d->hpal)
+        return PALETTEINDEX(GetNearestPaletteIndex(d->hpal, rgb));
+    return rgb;
+}
+
+const QColor QColormap::colorAt(uint pixel) const
+{
+    if (d->hpal) {
+        if (pixel < uint(d->numcolors))
+            return d->palette.at(pixel);
+        return QColor();
+    }
+    return QColor(GetRValue(pixel), GetGValue(pixel), GetBValue(pixel));
+}
+
+
+HPALETTE QColormap::hPal()
+{ return screenMap ? screenMap->hpal : 0; }
+
+
+const QVector<QColor> QColormap::colormap() const
+{ return d->palette; }
+
+QColormap &QColormap::operator=(const QColormap &colormap)
+{ qAtomicAssign(d, colormap.d); return *this; }
+
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qcolormap_x11.cpp b/src/gui/painting/qcolormap_x11.cpp
new file mode 100644
index 0000000000..05eefa455b
--- /dev/null
+++ b/src/gui/painting/qcolormap_x11.cpp
@@ -0,0 +1,670 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qcolormap.h"
+
+#include "qapplication.h"
+#include "qdebug.h"
+#include "qdesktopwidget.h"
+#include "qvarlengtharray.h"
+
+#include "qx11info_x11.h"
+#include <private/qt_x11_p.h>
+#include <limits.h>
+
+QT_BEGIN_NAMESPACE
+
+class QColormapPrivate
+{
+public:
+    QColormapPrivate()
+        : ref(1), mode(QColormap::Direct), depth(0),
+          colormap(0), defaultColormap(true),
+          visual(0), defaultVisual(true),
+          r_max(0), g_max(0), b_max(0),
+          r_shift(0), g_shift(0), b_shift(0)
+    {}
+
+    QAtomicInt ref;
+
+    QColormap::Mode mode;
+    int depth;
+
+    Colormap colormap;
+    bool defaultColormap;
+
+    Visual *visual;
+    bool defaultVisual;
+
+    int r_max;
+    int g_max;
+    int b_max;
+
+    uint r_shift;
+    uint g_shift;
+    uint b_shift;
+
+    QVector<QColor> colors;
+    QVector<int> pixels;
+};
+
+
+static uint right_align(uint v)
+{
+    while (!(v & 0x1))
+        v >>= 1;
+    return v;
+}
+
+static int lowest_bit(uint v)
+{
+    int i;
+    uint b = 1u;
+    for (i = 0; ((v & b) == 0u) && i < 32;  ++i)
+        b <<= 1u;
+    return i == 32 ? -1 : i;
+}
+
+static int cube_root(int v)
+{
+    if (v == 1)
+        return 1;
+    // brute force algorithm
+    int i = 1;
+    for (;;) {
+        const int b = i * i * i;
+        if (b <= v) {
+            ++i;
+        } else {
+            --i;
+            break;
+        }
+    }
+    return i;
+}
+
+static Visual *find_visual(Display *display,
+                           int screen,
+                           int visual_class,
+                           int visual_id,
+                           int *depth,
+                           bool *defaultVisual)
+{
+    XVisualInfo *vi, rvi;
+    int count;
+
+    uint mask = VisualScreenMask;
+    rvi.screen = screen;
+
+    if (visual_class != -1) {
+        rvi.c_class = visual_class;
+        mask |= VisualClassMask;
+    }
+    if (visual_id != -1) {
+        rvi.visualid = visual_id;
+        mask |= VisualIDMask;
+    }
+
+    Visual *visual = DefaultVisual(display, screen);
+    *defaultVisual = true;
+    *depth = DefaultDepth(display, screen);
+
+    vi = XGetVisualInfo(display, mask, &rvi, &count);
+    if (vi) {
+        int best = 0;
+        for (int x = 0; x < count; ++x) {
+            if (vi[x].depth > vi[best].depth)
+                best = x;
+        }
+        if (best >= 0 && best <= count && vi[best].visualid != XVisualIDFromVisual(visual)) {
+            visual = vi[best].visual;
+            *defaultVisual = (visual == DefaultVisual(display, screen));
+            *depth = vi[best].depth;
+        }
+    }
+    if (vi)
+        XFree((char *)vi);
+    return visual;
+}
+
+static void query_colormap(QColormapPrivate *d, int screen)
+{
+    Display *display = QX11Info::display();
+
+    // query existing colormap
+    int q_colors = (((1u << d->depth) > 256u) ? 256u : (1u << d->depth));
+    XColor queried[256];
+    memset(queried, 0, sizeof(queried));
+    for (int x = 0; x < q_colors; ++x)
+        queried[x].pixel = x;
+    XQueryColors(display, d->colormap, queried, q_colors);
+
+    d->colors.resize(q_colors);
+    for (int x = 0; x < q_colors; ++x) {
+        if (queried[x].red == 0
+            && queried[x].green == 0
+            && queried[x].blue == 0
+            && queried[x].pixel != BlackPixel(display, screen)) {
+            // unallocated color cell, skip it
+            continue;
+        }
+
+        d->colors[x] = QColor::fromRgbF(queried[x].red / float(USHRT_MAX),
+                                        queried[x].green / float(USHRT_MAX),
+                                        queried[x].blue / float(USHRT_MAX));
+    }
+
+    // for missing colors, find the closest color in the existing colormap
+    Q_ASSERT(d->pixels.size());
+    for (int x = 0; x < d->pixels.size(); ++x) {
+        if (d->pixels.at(x) != -1)
+            continue;
+
+        QRgb rgb;
+        if (d->mode == QColormap::Indexed) {
+            const int r = (x / (d->g_max * d->b_max)) % d->r_max;
+            const int g = (x / d->b_max) % d->g_max;
+            const int b = x % d->b_max;
+            rgb = qRgb((r * 0xff + (d->r_max - 1) / 2) / (d->r_max - 1),
+                       (g * 0xff + (d->g_max - 1) / 2) / (d->g_max - 1),
+                       (b * 0xff + (d->b_max - 1) / 2) / (d->b_max - 1));
+        } else {
+            rgb = qRgb(x, x, x);
+        }
+
+        // find closest color
+        int mindist = INT_MAX, best = -1;
+        for (int y = 0; y < q_colors; ++y) {
+            int r =   qRed(rgb) - (queried[y].red   >> 8);
+            int g = qGreen(rgb) - (queried[y].green >> 8);
+            int b =  qBlue(rgb) - (queried[y].blue  >> 8);
+            int dist = (r * r) + (g * g) + (b * b);
+            if (dist < mindist) {
+                mindist = dist;
+                best = y;
+            }
+        }
+
+        Q_ASSERT(best >= 0 && best < q_colors);
+        if (d->visual->c_class & 1) {
+            XColor xcolor;
+            xcolor.red   = queried[best].red;
+            xcolor.green = queried[best].green;
+            xcolor.blue  = queried[best].blue;
+            xcolor.pixel = queried[best].pixel;
+
+            if (XAllocColor(display, d->colormap, &xcolor)) {
+                d->pixels[x] = xcolor.pixel;
+            } else {
+                // some weird stuff is going on...
+                d->pixels[x] = (qGray(rgb) < 127
+                                ? BlackPixel(display, screen)
+                                : WhitePixel(display, screen));
+            }
+        } else {
+            d->pixels[x] = best;
+        }
+    }
+}
+
+static void init_gray(QColormapPrivate *d, int screen)
+{
+    d->pixels.resize(d->r_max);
+
+    for (int g = 0; g < d->g_max; ++g) {
+        const int gray = (g * 0xff + (d->r_max - 1) / 2) / (d->r_max - 1);
+        const QRgb rgb = qRgb(gray, gray, gray);
+
+        d->pixels[g] = -1;
+
+        if (d->visual->c_class & 1) {
+            XColor xcolor;
+            xcolor.red   =   qRed(rgb) * 0x101;
+            xcolor.green = qGreen(rgb) * 0x101;
+            xcolor.blue  =  qBlue(rgb) * 0x101;
+            xcolor.pixel = 0ul;
+
+            if (XAllocColor(QX11Info::display(), d->colormap, &xcolor))
+                d->pixels[g] = xcolor.pixel;
+        }
+    }
+
+    query_colormap(d, screen);
+}
+
+static void init_indexed(QColormapPrivate *d, int screen)
+{
+    d->pixels.resize(d->r_max * d->g_max * d->b_max);
+
+    // create color cube
+    for (int x = 0, r = 0; r < d->r_max; ++r) {
+        for (int g = 0; g < d->g_max; ++g) {
+            for (int b = 0; b < d->b_max; ++b, ++x) {
+                const QRgb rgb = qRgb((r * 0xff + (d->r_max - 1) / 2) / (d->r_max - 1),
+                                      (g * 0xff + (d->g_max - 1) / 2) / (d->g_max - 1),
+                                      (b * 0xff + (d->b_max - 1) / 2) / (d->b_max - 1));
+
+                d->pixels[x] = -1;
+
+                if (d->visual->c_class & 1) {
+                    XColor xcolor;
+                    xcolor.red   =   qRed(rgb) * 0x101;
+                    xcolor.green = qGreen(rgb) * 0x101;
+                    xcolor.blue  =  qBlue(rgb) * 0x101;
+                    xcolor.pixel = 0ul;
+
+                    if (XAllocColor(QX11Info::display(), d->colormap, &xcolor))
+                        d->pixels[x] = xcolor.pixel;
+                }
+            }
+        }
+    }
+
+    query_colormap(d, screen);
+}
+
+static void init_direct(QColormapPrivate *d, bool ownColormap)
+{
+    if (d->visual->c_class != DirectColor || !ownColormap)
+        return;
+
+    // preallocate 768 on the stack, so that we don't have to malloc
+    // for the common case (<= 24 bpp)
+    QVarLengthArray<XColor, 768> colorTable(d->r_max + d->g_max + d->b_max);
+    int i = 0;
+
+    for (int r = 0; r < d->r_max; ++r) {
+        colorTable[i].red = r << 8 | r;
+        colorTable[i].pixel = r << d->r_shift;
+        colorTable[i].flags = DoRed;
+        ++i;
+    }
+
+    for (int g = 0; g < d->g_max; ++g) {
+        colorTable[i].green = g << 8 | g;
+        colorTable[i].pixel = g << d->g_shift;
+        colorTable[i].flags = DoGreen;
+        ++i;
+    }
+
+    for (int b = 0; b < d->b_max; ++b) {
+        colorTable[i].blue = (b << 8 | b);
+        colorTable[i].pixel = b << d->b_shift;
+        colorTable[i].flags = DoBlue;
+        ++i;
+    }
+
+    XStoreColors(X11->display, d->colormap, colorTable.data(), colorTable.count());
+}
+
+static QColormap **cmaps = 0;
+
+void QColormap::initialize()
+{
+    Display *display = QX11Info::display();
+    const int screens = ScreenCount(display);
+
+    cmaps = new QColormap*[screens];
+
+    for (int i = 0; i < screens; ++i) {
+        cmaps[i] = new QColormap;
+        QColormapPrivate * const d = cmaps[i]->d;
+
+        bool use_stdcmap = false;
+        int color_count = X11->color_count;
+
+        // defaults
+        d->depth = DefaultDepth(display, i);
+        d->colormap = DefaultColormap(display, i);
+        d->defaultColormap = true;
+        d->visual = DefaultVisual(display, i);
+        d->defaultVisual = true;
+
+        Visual *argbVisual = 0;
+
+        if (X11->visual && i == DefaultScreen(display)) {
+            // only use the outside colormap on the default screen
+            d->visual = find_visual(display, i, X11->visual->c_class,
+                                    XVisualIDFromVisual(X11->visual),
+                                    &d->depth, &d->defaultVisual);
+        } else if ((X11->visual_class != -1 && X11->visual_class >= 0 && X11->visual_class < 6)
+                   || (X11->visual_id != -1)) {
+            // look for a specific visual or type of visual
+            d->visual = find_visual(display, i, X11->visual_class, X11->visual_id,
+                                    &d->depth, &d->defaultVisual);
+        } else if (QApplication::colorSpec() == QApplication::ManyColor) {
+            // look for a TrueColor w/ a depth higher than 8bpp
+            d->visual = find_visual(display, i, TrueColor, -1, &d->depth, &d->defaultVisual);
+            if (d->depth <= 8) {
+                d->visual = DefaultVisual(display, i);
+                d->defaultVisual = true;
+                color_count = 216;
+            }
+        } else if (!X11->custom_cmap) {
+            XStandardColormap *stdcmap = 0;
+            int ncmaps = 0;
+
+#ifndef QT_NO_XRENDER
+            if (X11->use_xrender) {
+                int nvi;
+                XVisualInfo templ;
+                templ.screen  = i;
+                templ.depth   = 32;
+                templ.c_class = TrueColor;
+                XVisualInfo *xvi = XGetVisualInfo(X11->display, VisualScreenMask |
+                                                  VisualDepthMask |
+                                                  VisualClassMask, &templ, &nvi);
+                for (int idx = 0; idx < nvi; ++idx) {
+                    XRenderPictFormat *format = XRenderFindVisualFormat(X11->display,
+                                                                        xvi[idx].visual);
+                    if (format->type == PictTypeDirect && format->direct.alphaMask) {
+                        argbVisual = xvi[idx].visual;
+                        break;
+                    }
+                }
+                XFree(xvi);
+            }
+#endif
+            if (XGetRGBColormaps(display, RootWindow(display, i),
+                                 &stdcmap, &ncmaps, XA_RGB_DEFAULT_MAP)) {
+                if (stdcmap) {
+                    for (int c = 0; c < ncmaps; ++c) {
+                        if (!stdcmap[c].red_max ||
+                            !stdcmap[c].green_max ||
+                            !stdcmap[c].blue_max ||
+                            !stdcmap[c].red_mult ||
+                            !stdcmap[c].green_mult ||
+                            !stdcmap[c].blue_mult)
+                            continue; // invalid stdcmap
+
+                        XVisualInfo proto;
+                        proto.visualid = stdcmap[c].visualid;
+                        proto.screen = i;
+
+                        int nvisuals = 0;
+                        XVisualInfo *vi = XGetVisualInfo(display, VisualIDMask | VisualScreenMask,
+                                                         &proto, &nvisuals);
+                        if (vi) {
+                            if (nvisuals > 0) {
+                                use_stdcmap = true;
+
+                                d->mode = ((vi[0].visual->c_class < StaticColor)
+                                           ? Gray
+                                           : ((vi[0].visual->c_class < TrueColor)
+                                              ? Indexed
+                                              : Direct));
+
+                                d->depth = vi[0].depth;
+                                d->colormap = stdcmap[c].colormap;
+                                d->defaultColormap = true;
+                                d->visual = vi[0].visual;
+                                d->defaultVisual = (d->visual == DefaultVisual(display, i));
+
+                                d->r_max = stdcmap[c].red_max   + 1;
+                                d->g_max = stdcmap[c].green_max + 1;
+                                d->b_max = stdcmap[c].blue_max  + 1;
+
+                                if (d->mode == Direct) {
+                                    // calculate offsets
+                                    d->r_shift = lowest_bit(d->visual->red_mask);
+                                    d->g_shift = lowest_bit(d->visual->green_mask);
+                                    d->b_shift = lowest_bit(d->visual->blue_mask);
+                                } else {
+                                    d->r_shift = 0;
+                                    d->g_shift = 0;
+                                    d->b_shift = 0;
+                                }
+                            }
+                            XFree(vi);
+                        }
+                        break;
+                    }
+                    XFree(stdcmap);
+                }
+            }
+        }
+        if (!use_stdcmap) {
+            switch (d->visual->c_class) {
+            case StaticGray:
+                d->mode = Gray;
+
+                d->r_max = d->g_max = d->b_max = d->visual->map_entries;
+                break;
+
+            case XGrayScale:
+                d->mode = Gray;
+
+                // follow precedent set in libXmu...
+                if (color_count != 0)
+                    d->r_max = d->g_max = d->b_max = color_count;
+                else if (d->visual->map_entries > 65000)
+                    d->r_max = d->g_max = d->b_max = 4096;
+                else if (d->visual->map_entries > 4000)
+                    d->r_max = d->g_max = d->b_max = 512;
+                else if (d->visual->map_entries > 250)
+                    d->r_max = d->g_max = d->b_max = 12;
+                else
+                    d->r_max = d->g_max = d->b_max = 4;
+                break;
+
+            case StaticColor:
+                d->mode = Indexed;
+
+                d->r_max = right_align(d->visual->red_mask)   + 1;
+                d->g_max = right_align(d->visual->green_mask) + 1;
+                d->b_max = right_align(d->visual->blue_mask)  + 1;
+                break;
+
+            case PseudoColor:
+                d->mode = Indexed;
+
+                // follow precedent set in libXmu...
+                if (color_count != 0)
+                    d->r_max = d->g_max = d->b_max = cube_root(color_count);
+                else if (d->visual->map_entries > 65000)
+                    d->r_max = d->g_max = d->b_max = 27;
+                else if (d->visual->map_entries > 4000)
+                    d->r_max = d->g_max = d->b_max = 12;
+                else if (d->visual->map_entries > 250)
+                    d->r_max = d->g_max = d->b_max = cube_root(d->visual->map_entries - 125);
+                else
+                    d->r_max = d->g_max = d->b_max = cube_root(d->visual->map_entries);
+                break;
+
+            case TrueColor:
+            case DirectColor:
+                d->mode = Direct;
+
+                d->r_max = right_align(d->visual->red_mask)   + 1;
+                d->g_max = right_align(d->visual->green_mask) + 1;
+                d->b_max = right_align(d->visual->blue_mask)  + 1;
+
+                d->r_shift = lowest_bit(d->visual->red_mask);
+                d->g_shift = lowest_bit(d->visual->green_mask);
+                d->b_shift = lowest_bit(d->visual->blue_mask);
+                break;
+            }
+        }
+
+        bool ownColormap = false;
+        if (X11->colormap && i == DefaultScreen(display)) {
+            // only use the outside colormap on the default screen
+            d->colormap = X11->colormap;
+            d->defaultColormap = (d->colormap == DefaultColormap(display, i));
+        } else if ((!use_stdcmap
+                   && (((d->visual->c_class & 1) && X11->custom_cmap)
+                       || d->visual != DefaultVisual(display, i)))
+                   || d->visual->c_class == DirectColor) {
+            // allocate custom colormap (we always do this when using DirectColor visuals)
+            d->colormap =
+                XCreateColormap(display, RootWindow(display, i), d->visual,
+                                d->visual->c_class == DirectColor ? AllocAll : AllocNone);
+            d->defaultColormap = false;
+            ownColormap = true;
+        }
+
+        switch (d->mode) {
+        case Gray:
+            init_gray(d, i);
+            break;
+        case Indexed:
+            init_indexed(d, i);
+            break;
+        case Direct:
+            init_direct(d, ownColormap);
+            break;
+        }
+
+        QX11InfoData *screen = X11->screens + i;
+        screen->depth = d->depth;
+        screen->visual = d->visual;
+        screen->defaultVisual = d->defaultVisual;
+        screen->colormap = d->colormap;
+        screen->defaultColormap = d->defaultColormap;
+        screen->cells = screen->visual->map_entries;
+
+        if (argbVisual) {
+            X11->argbVisuals[i] = argbVisual;
+            X11->argbColormaps[i] = XCreateColormap(display, RootWindow(display, i), argbVisual, AllocNone);
+        }
+
+        // ###
+        // We assume that 8bpp == pseudocolor, but this is not
+        // always the case (according to the X server), so we need
+        // to make sure that our internal data is setup in a way
+        // that is compatible with our assumptions
+        if (screen->visual->c_class == TrueColor && screen->depth == 8 && screen->cells == 8)
+            screen->cells = 256;
+    }
+}
+
+void QColormap::cleanup()
+{
+    Display *display = QX11Info::display();
+    const int screens = ScreenCount(display);
+
+    for (int i = 0; i < screens; ++i)
+        delete cmaps[i];
+
+    delete [] cmaps;
+    cmaps = 0;
+}
+
+
+QColormap QColormap::instance(int screen)
+{
+    if (screen == -1)
+        screen = QX11Info::appScreen();
+    return *cmaps[screen];
+}
+
+/*! \internal
+    Constructs a new colormap.
+*/
+QColormap::QColormap()
+    : d(new QColormapPrivate)
+{}
+
+QColormap::QColormap(const QColormap &colormap)
+    :d (colormap.d)
+{ d->ref.ref(); }
+
+QColormap::~QColormap()
+{
+    if (!d->ref.deref()) {
+        if (!d->defaultColormap)
+            XFreeColormap(QX11Info::display(), d->colormap);
+        delete d;
+    }
+}
+
+QColormap::Mode QColormap::mode() const
+{ return d->mode; }
+
+int QColormap::depth() const
+{ return d->depth; }
+
+int QColormap::size() const
+{
+    return (d->mode == Gray
+            ? d->r_max
+            : (d->mode == Indexed
+               ? d->r_max * d->g_max * d->b_max
+               : -1));
+}
+
+uint QColormap::pixel(const QColor &color) const
+{
+    const QColor c = color.toRgb();
+    const uint r = (c.ct.argb.red   * d->r_max) >> 16;
+    const uint g = (c.ct.argb.green * d->g_max) >> 16;
+    const uint b = (c.ct.argb.blue  * d->b_max) >> 16;
+    if (d->mode != Direct) {
+        if (d->mode == Gray)
+            return d->pixels.at((r * 30 + g * 59 + b * 11) / 100);
+        return d->pixels.at(r * d->g_max * d->b_max + g * d->b_max + b);
+    }
+    return (r << d->r_shift) + (g << d->g_shift) + (b << d->b_shift);
+}
+
+const QColor QColormap::colorAt(uint pixel) const
+{
+    if (d->mode != Direct) {
+        Q_ASSERT(pixel <= (uint)d->colors.size());
+        return d->colors.at(pixel);
+    }
+
+    const int r = (((pixel & d->visual->red_mask)   >> d->r_shift) << 8) / d->r_max;
+    const int g = (((pixel & d->visual->green_mask) >> d->g_shift) << 8) / d->g_max;
+    const int b = (((pixel & d->visual->blue_mask)  >> d->b_shift) << 8) / d->b_max;
+    return QColor(r, g, b);
+}
+
+const QVector<QColor> QColormap::colormap() const
+{ return d->colors; }
+
+QColormap &QColormap::operator=(const QColormap &colormap)
+{
+    qAtomicAssign(d, colormap.d);
+    return *this;
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qcssutil.cpp b/src/gui/painting/qcssutil.cpp
new file mode 100644
index 0000000000..729cff504e
--- /dev/null
+++ b/src/gui/painting/qcssutil.cpp
@@ -0,0 +1,408 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qcssutil_p.h"
+#include "private/qcssparser_p.h"
+#include "qpainter.h"
+#include <qmath.h>
+
+#ifndef QT_NO_CSSPARSER
+
+QT_BEGIN_NAMESPACE
+
+using namespace QCss;
+
+static QPen qPenFromStyle(const QBrush& b, qreal width, BorderStyle s)
+{
+    Qt::PenStyle ps = Qt::NoPen;
+
+    switch (s) {
+    case BorderStyle_Dotted:
+        ps  = Qt::DotLine;
+        break;
+    case BorderStyle_Dashed:
+        ps = width == 1 ? Qt::DotLine : Qt::DashLine;
+        break;
+    case BorderStyle_DotDash:
+        ps = Qt::DashDotLine;
+        break;
+    case BorderStyle_DotDotDash:
+        ps = Qt::DashDotDotLine;
+        break;
+    case BorderStyle_Inset:
+    case BorderStyle_Outset:
+    case BorderStyle_Solid:
+        ps = Qt::SolidLine;
+        break;
+    default:
+        break;
+    }
+
+    return QPen(b, width, ps, Qt::FlatCap);
+}
+
+void qDrawRoundedCorners(QPainter *p, qreal x1, qreal y1, qreal x2, qreal y2,
+                         const QSizeF& r1, const QSizeF& r2,
+                         Edge edge, BorderStyle s, QBrush c)
+{
+    const qreal pw = (edge == TopEdge || edge == BottomEdge) ? y2-y1 : x2-x1;
+    if (s == BorderStyle_Double) {
+        qreal wby3 = pw/3;
+        switch (edge) {
+        case TopEdge:
+        case BottomEdge:
+            qDrawRoundedCorners(p, x1, y1, x2, y1+wby3, r1, r2, edge, BorderStyle_Solid, c);
+            qDrawRoundedCorners(p, x1, y2-wby3, x2, y2, r1, r2, edge, BorderStyle_Solid, c);
+            break;
+        case LeftEdge:
+            qDrawRoundedCorners(p, x1, y1+1, x1+wby3, y2, r1, r2, LeftEdge, BorderStyle_Solid, c);
+            qDrawRoundedCorners(p, x2-wby3, y1+1, x2, y2, r1, r2, LeftEdge, BorderStyle_Solid, c);
+            break;
+        case RightEdge:
+            qDrawRoundedCorners(p, x1, y1+1, x1+wby3, y2, r1, r2, RightEdge, BorderStyle_Solid, c);
+            qDrawRoundedCorners(p, x2-wby3, y1+1, x2, y2, r1, r2, RightEdge, BorderStyle_Solid, c);
+            break;
+        default:
+            break;
+        }
+        return;
+    } else if (s == BorderStyle_Ridge || s == BorderStyle_Groove) {
+        BorderStyle s1, s2;
+        if (s == BorderStyle_Groove) {
+            s1 = BorderStyle_Inset;
+            s2 = BorderStyle_Outset;
+        } else {
+            s1 = BorderStyle_Outset;
+            s2 = BorderStyle_Inset;
+        }
+        int pwby2 = qRound(pw/2);
+        switch (edge) {
+        case TopEdge:
+            qDrawRoundedCorners(p, x1, y1, x2, y1 + pwby2, r1, r2, TopEdge, s1, c);
+            qDrawRoundedCorners(p, x1, y1 + pwby2, x2, y2, r1, r2, TopEdge, s2, c);
+            break;
+        case BottomEdge:
+            qDrawRoundedCorners(p, x1, y1 + pwby2, x2, y2, r1, r2, BottomEdge, s1, c);
+            qDrawRoundedCorners(p, x1, y1, x2, y2-pwby2, r1, r2, BottomEdge, s2, c);
+            break;
+        case LeftEdge:
+            qDrawRoundedCorners(p, x1, y1, x1 + pwby2, y2, r1, r2, LeftEdge, s1, c);
+            qDrawRoundedCorners(p, x1 + pwby2, y1, x2, y2, r1, r2, LeftEdge, s2, c);
+            break;
+        case RightEdge:
+            qDrawRoundedCorners(p, x1 + pwby2, y1, x2, y2, r1, r2, RightEdge, s1, c);
+            qDrawRoundedCorners(p, x1, y1, x2 - pwby2, y2, r1, r2, RightEdge, s2, c);
+            break;
+        default:
+            break;
+        }
+    } else if ((s == BorderStyle_Outset && (edge == TopEdge || edge == LeftEdge))
+            || (s == BorderStyle_Inset && (edge == BottomEdge || edge == RightEdge)))
+            c = c.color().lighter();
+
+    p->save();
+    qreal pwby2 = pw/2;
+    p->setBrush(Qt::NoBrush);
+    QPen pen = qPenFromStyle(c, pw, s);
+    pen.setCapStyle(Qt::SquareCap); // this eliminates the offby1 errors that we might hit below
+    p->setPen(pen);
+    switch (edge) {
+    case TopEdge:
+        if (!r1.isEmpty())
+            p->drawArc(QRectF(x1 - r1.width() + pwby2, y1 + pwby2,
+                              2*r1.width() - pw, 2*r1.height() - pw), 135*16, -45*16);
+        if (!r2.isEmpty())
+            p->drawArc(QRectF(x2 - r2.width() + pwby2, y1 + pwby2,
+                       2*r2.width() - pw, 2*r2.height() - pw), 45*16, 45*16);
+        break;
+    case BottomEdge:
+        if (!r1.isEmpty())
+            p->drawArc(QRectF(x1 - r1.width() + pwby2, y2 - 2*r1.height() + pwby2,
+                              2*r1.width() - pw, 2*r1.height() - pw), -90 * 16, -45 * 16);
+        if (!r2.isEmpty())
+            p->drawArc(QRectF(x2 - r2.width() + pwby2, y2 - 2*r2.height() + pwby2,
+                       2*r2.width() - pw, 2*r2.height() - pw), -90 * 16, 45 * 16);
+        break;
+    case LeftEdge:
+        if (!r1.isEmpty())
+            p->drawArc(QRectF(x1 + pwby2, y1 - r1.height() + pwby2,
+                       2*r1.width() - pw, 2*r1.height() - pw), 135*16, 45*16);
+        if (!r2.isEmpty())
+            p->drawArc(QRectF(x1 + pwby2, y2 - r2.height() + pwby2,
+                       2*r2.width() - pw, 2*r2.height() - pw), 180*16, 45*16);
+        break;
+    case RightEdge:
+        if (!r1.isEmpty())
+            p->drawArc(QRectF(x2 - 2*r1.width() + pwby2, y1 - r1.height() + pwby2,
+                       2*r1.width() - pw, 2*r1.height() - pw), 45*16, -45*16);
+        if (!r2.isEmpty())
+            p->drawArc(QRectF(x2 - 2*r2.width() + pwby2, y2 - r2.height() + pwby2,
+                       2*r2.width() - pw, 2*r2.height() - pw), 315*16, 45*16);
+        break;
+    default:
+        break;
+    }
+    p->restore();
+}
+
+
+void qDrawEdge(QPainter *p, qreal x1, qreal y1, qreal x2, qreal y2, qreal dw1, qreal dw2,
+               QCss::Edge edge, QCss::BorderStyle style, QBrush c)
+{
+    p->save();
+    const qreal width = (edge == TopEdge || edge == BottomEdge) ? (y2-y1) : (x2-x1);
+
+    if (width <= 2 && style == BorderStyle_Double)
+        style = BorderStyle_Solid;
+
+    switch (style) {
+    case BorderStyle_Inset:
+    case BorderStyle_Outset:
+        if ((style == BorderStyle_Outset && (edge == TopEdge || edge == LeftEdge))
+            || (style == BorderStyle_Inset && (edge == BottomEdge || edge == RightEdge)))
+            c = c.color().lighter();
+        // fall through!
+    case BorderStyle_Solid: {
+        p->setPen(Qt::NoPen);
+        p->setBrush(c);
+        if (width == 1 || (dw1 == 0 && dw2 == 0)) {
+            p->drawRect(QRectF(x1, y1, x2-x1, y2-y1));
+        } else { // draw trapezoid
+            QPolygonF quad;
+            switch (edge) {
+            case TopEdge:
+                quad << QPointF(x1, y1) << QPointF(x1 + dw1, y2)
+                     << QPointF(x2 - dw2, y2) << QPointF(x2, y1);
+                break;
+            case BottomEdge:
+                quad << QPointF(x1 + dw1, y1) << QPointF(x1, y2)
+                     << QPointF(x2, y2) << QPointF(x2 - dw2, y1);
+                break;
+            case LeftEdge:
+                quad << QPointF(x1, y1) << QPointF(x1, y2)
+                     << QPointF(x2, y2 - dw2) << QPointF(x2, y1 + dw1);
+                break;
+            case RightEdge:
+                quad << QPointF(x1, y1 + dw1) << QPointF(x1, y2 - dw2)
+                     << QPointF(x2, y2) << QPointF(x2, y1);
+                break;
+            default:
+                break;
+            }
+            p->drawConvexPolygon(quad);
+        }
+        break;
+    }
+    case BorderStyle_Dotted:
+    case BorderStyle_Dashed:
+    case BorderStyle_DotDash:
+    case BorderStyle_DotDotDash:
+        p->setPen(qPenFromStyle(c, width, style));
+        if (width == 1)
+            p->drawLine(QLineF(x1, y1, x2 - 1, y2 - 1));
+        else if (edge == TopEdge || edge == BottomEdge)
+            p->drawLine(QLineF(x1 + width/2, (y1 + y2)/2, x2 - width/2, (y1 + y2)/2));
+        else
+            p->drawLine(QLineF((x1+x2)/2, y1 + width/2, (x1+x2)/2, y2 - width/2));
+        break;
+
+    case BorderStyle_Double: {
+        int wby3 = qRound(width/3);
+        int dw1by3 = qRound(dw1/3);
+        int dw2by3 = qRound(dw2/3);
+        switch (edge) {
+        case TopEdge:
+            qDrawEdge(p, x1, y1, x2, y1 + wby3, dw1by3, dw2by3, TopEdge, BorderStyle_Solid, c);
+            qDrawEdge(p, x1 + dw1 - dw1by3, y2 - wby3, x2 - dw2 + dw1by3, y2,
+                      dw1by3, dw2by3, TopEdge, BorderStyle_Solid, c);
+            break;
+        case LeftEdge:
+            qDrawEdge(p, x1, y1, x1 + wby3, y2, dw1by3, dw2by3, LeftEdge, BorderStyle_Solid, c);
+            qDrawEdge(p, x2 - wby3, y1 + dw1 - dw1by3, x2, y2 - dw2 + dw2by3, dw1by3, dw2by3,
+                      LeftEdge, BorderStyle_Solid, c);
+            break;
+        case BottomEdge:
+            qDrawEdge(p, x1 + dw1 - dw1by3, y1, x2 - dw2 + dw2by3, y1 + wby3, dw1by3, dw2by3,
+                      BottomEdge, BorderStyle_Solid, c);
+            qDrawEdge(p, x1, y2 - wby3, x2, y2, dw1by3, dw2by3, BottomEdge, BorderStyle_Solid, c);
+            break;
+        case RightEdge:
+            qDrawEdge(p, x2 - wby3, y1, x2, y2, dw1by3, dw2by3, RightEdge, BorderStyle_Solid, c);
+            qDrawEdge(p, x1, y1 + dw1 - dw1by3, x1 + wby3, y2 - dw2 + dw2by3, dw1by3, dw2by3,
+                      RightEdge, BorderStyle_Solid, c);
+            break;
+        default:
+            break;
+        }
+        break;
+    }
+    case BorderStyle_Ridge:
+    case BorderStyle_Groove: {
+        BorderStyle s1, s2;
+        if (style == BorderStyle_Groove) {
+            s1 = BorderStyle_Inset;
+            s2 = BorderStyle_Outset;
+        } else {
+            s1 = BorderStyle_Outset;
+            s2 = BorderStyle_Inset;
+        }
+        int dw1by2 = qFloor(dw1/2), dw2by2 = qFloor(dw2/2);
+        int wby2 = qRound(width/2);
+        switch (edge) {
+        case TopEdge:
+            qDrawEdge(p, x1, y1, x2, y1 + wby2, dw1by2, dw2by2, TopEdge, s1, c);
+            qDrawEdge(p, x1 + dw1by2, y1 + wby2, x2 - dw2by2, y2, dw1by2, dw2by2, TopEdge, s2, c);
+            break;
+        case BottomEdge:
+            qDrawEdge(p, x1, y1 + wby2, x2, y2, dw1by2, dw2by2, BottomEdge, s1, c);
+            qDrawEdge(p, x1 + dw1by2, y1, x2 - dw2by2, y1 + wby2, dw1by2, dw2by2, BottomEdge, s2, c);
+            break;
+        case LeftEdge:
+            qDrawEdge(p, x1, y1, x1 + wby2, y2, dw1by2, dw2by2, LeftEdge, s1, c);
+            qDrawEdge(p, x1 + wby2, y1 + dw1by2, x2, y2 - dw2by2, dw1by2, dw2by2, LeftEdge, s2, c);
+            break;
+        case RightEdge:
+            qDrawEdge(p, x1 + wby2, y1, x2, y2, dw1by2, dw2by2, RightEdge, s1, c);
+            qDrawEdge(p, x1, y1 + dw1by2, x1 + wby2, y2 - dw2by2, dw1by2, dw2by2, RightEdge, s2, c);
+            break;
+        default:
+            break;
+        }
+    }
+    default:
+        break;
+    }
+    p->restore();
+}
+
+void qNormalizeRadii(const QRect &br, const QSize *radii,
+                     QSize *tlr, QSize *trr, QSize *blr, QSize *brr)
+{
+    *tlr = radii[0].expandedTo(QSize(0, 0));
+    *trr = radii[1].expandedTo(QSize(0, 0));
+    *blr = radii[2].expandedTo(QSize(0, 0));
+    *brr = radii[3].expandedTo(QSize(0, 0));
+    if (tlr->width() + trr->width() > br.width())
+        *tlr = *trr = QSize(0, 0);
+    if (blr->width() + brr->width() > br.width())
+        *blr = *brr = QSize(0, 0);
+    if (tlr->height() + blr->height() > br.height())
+        *tlr = *blr = QSize(0, 0);
+    if (trr->height() + brr->height() > br.height())
+        *trr = *brr = QSize(0, 0);
+}
+
+// Determines if Edge e1 draws over Edge e2. Depending on this trapezoids or rectanges are drawn
+static bool paintsOver(const QCss::BorderStyle *styles, const QBrush *colors, QCss::Edge e1, QCss::Edge e2)
+{
+    QCss::BorderStyle s1 = styles[e1];
+    QCss::BorderStyle s2 = styles[e2];
+
+    if (s2 == BorderStyle_None || colors[e2] == Qt::transparent)
+        return true;
+
+    if ((s1 == BorderStyle_Solid && s2 == BorderStyle_Solid) && (colors[e1] == colors[e2]))
+        return true;
+
+    return false;
+}
+
+void qDrawBorder(QPainter *p, const QRect &rect, const QCss::BorderStyle *styles,
+                 const int *borders, const QBrush *colors, const QSize *radii)
+{
+    const QRectF br(rect);
+    QSize tlr, trr, blr, brr;
+    qNormalizeRadii(rect, radii, &tlr, &trr, &blr, &brr);
+
+    // Drawn in increasing order of precendence
+    if (styles[BottomEdge] != BorderStyle_None && borders[BottomEdge] > 0) {
+        qreal dw1 = (blr.width() || paintsOver(styles, colors, BottomEdge, LeftEdge)) ? 0 : borders[LeftEdge];
+        qreal dw2 = (brr.width() || paintsOver(styles, colors, BottomEdge, RightEdge)) ? 0 : borders[RightEdge];
+        qreal x1 = br.x() + blr.width();
+        qreal y1 = br.y() + br.height() - borders[BottomEdge];
+        qreal x2 = br.x() + br.width() - brr.width();
+        qreal y2 = br.y() + br.height() ;
+
+        qDrawEdge(p, x1, y1, x2, y2, dw1, dw2, BottomEdge, styles[BottomEdge], colors[BottomEdge]);
+        if (blr.width() || brr.width())
+            qDrawRoundedCorners(p, x1, y1, x2, y2, blr, brr, BottomEdge, styles[BottomEdge], colors[BottomEdge]);
+    }
+    if (styles[RightEdge] != BorderStyle_None && borders[RightEdge] > 0) {
+        qreal dw1 = (trr.height() || paintsOver(styles, colors, RightEdge, TopEdge)) ? 0 : borders[TopEdge];
+        qreal dw2 = (brr.height() || paintsOver(styles, colors, RightEdge, BottomEdge)) ? 0 : borders[BottomEdge];
+        qreal x1 = br.x() + br.width() - borders[RightEdge];
+        qreal y1 = br.y() + trr.height();
+        qreal x2 = br.x() + br.width();
+        qreal y2 = br.y() + br.height() - brr.height();
+
+        qDrawEdge(p, x1, y1, x2, y2, dw1, dw2, RightEdge, styles[RightEdge], colors[RightEdge]);
+        if (trr.height() || brr.height())
+            qDrawRoundedCorners(p, x1, y1, x2, y2, trr, brr, RightEdge, styles[RightEdge], colors[RightEdge]);
+    }
+    if (styles[LeftEdge] != BorderStyle_None && borders[LeftEdge] > 0) {
+        qreal dw1 = (tlr.height() || paintsOver(styles, colors, LeftEdge, TopEdge)) ? 0 : borders[TopEdge];
+        qreal dw2 = (blr.height() || paintsOver(styles, colors, LeftEdge, BottomEdge)) ? 0 : borders[BottomEdge];
+        qreal x1 = br.x();
+        qreal y1 = br.y() + tlr.height();
+        qreal x2 = br.x() + borders[LeftEdge];
+        qreal y2 = br.y() + br.height() - blr.height();
+
+        qDrawEdge(p, x1, y1, x2, y2, dw1, dw2, LeftEdge, styles[LeftEdge], colors[LeftEdge]);
+        if (tlr.height() || blr.height())
+            qDrawRoundedCorners(p, x1, y1, x2, y2, tlr, blr, LeftEdge, styles[LeftEdge], colors[LeftEdge]);
+    }
+    if (styles[TopEdge] != BorderStyle_None && borders[TopEdge] > 0) {
+        qreal dw1 = (tlr.width() || paintsOver(styles, colors, TopEdge, LeftEdge)) ? 0 : borders[LeftEdge];
+        qreal dw2 = (trr.width() || paintsOver(styles, colors, TopEdge, RightEdge)) ? 0 : borders[RightEdge];
+        qreal x1 = br.x() + tlr.width();
+        qreal y1 = br.y();
+        qreal x2 = br.left() + br.width() - trr.width();
+        qreal y2 = br.y() + borders[TopEdge];
+
+        qDrawEdge(p, x1, y1, x2, y2, dw1, dw2, TopEdge, styles[TopEdge], colors[TopEdge]);
+        if (tlr.width() || trr.width())
+            qDrawRoundedCorners(p, x1, y1, x2, y2, tlr, trr, TopEdge, styles[TopEdge], colors[TopEdge]);
+    }
+}
+
+#endif //QT_NO_CSSPARSER
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qcssutil_p.h b/src/gui/painting/qcssutil_p.h
new file mode 100644
index 0000000000..80606b4cb9
--- /dev/null
+++ b/src/gui/painting/qcssutil_p.h
@@ -0,0 +1,84 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QCSSUTIL_P_H
+#define QCSSUTIL_P_H
+
+#include "QtCore/qglobal.h"
+
+#ifndef QT_NO_CSSPARSER
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "private/qcssparser_p.h"
+#include "QtCore/qsize.h"
+
+QT_BEGIN_NAMESPACE
+
+class QPainter;
+
+extern void qDrawEdge(QPainter *p, qreal x1, qreal y1, qreal x2, qreal y2, qreal dw1, qreal dw2,
+                      QCss::Edge edge, QCss::BorderStyle style, QBrush c);
+
+extern void qDrawRoundedCorners(QPainter *p, qreal x1, qreal y1, qreal x2, qreal y2,
+                                const QSizeF& r1, const QSizeF& r2,
+                                QCss::Edge edge, QCss::BorderStyle s, QBrush c);
+
+extern void qDrawBorder(QPainter *p, const QRect &rect, const QCss::BorderStyle *styles,
+                        const int *borders, const QBrush *colors, const QSize *radii);
+
+extern void qNormalizeRadii(const QRect &br, const QSize *radii,
+                            QSize *tlr, QSize *trr, QSize *blr, QSize *brr);
+
+QT_END_NAMESPACE
+        
+#endif //QT_NO_CSSPARSER
+
+#endif // QCSSUTIL_P_H
diff --git a/src/gui/painting/qcups.cpp b/src/gui/painting/qcups.cpp
new file mode 100644
index 0000000000..24faa2f300
--- /dev/null
+++ b/src/gui/painting/qcups.cpp
@@ -0,0 +1,401 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include <qdebug.h>
+#include "qcups_p.h"
+
+#ifndef QT_NO_CUPS
+
+#ifndef QT_LINUXBASE // LSB merges everything into cups.h
+# include <cups/language.h>
+#endif
+#include <qtextcodec.h>
+
+QT_BEGIN_NAMESPACE
+
+typedef int (*CupsGetDests)(cups_dest_t **dests);
+typedef void (*CupsFreeDests)(int num_dests, cups_dest_t *dests);
+typedef const char* (*CupsGetPPD)(const char *printer);
+typedef int (*CupsMarkOptions)(ppd_file_t *ppd, int num_options, cups_option_t *options);
+typedef ppd_file_t* (*PPDOpenFile)(const char *filename);
+typedef void (*PPDMarkDefaults)(ppd_file_t *ppd);
+typedef int (*PPDMarkOption)(ppd_file_t *ppd, const char *keyword, const char *option);
+typedef void (*PPDClose)(ppd_file_t *ppd);
+typedef int (*PPDMarkOption)(ppd_file_t *ppd, const char *keyword, const char *option);
+typedef void (*CupsFreeOptions)(int num_options, cups_option_t *options);
+typedef void (*CupsSetDests)(int num_dests, cups_dest_t *dests);
+typedef cups_lang_t* (*CupsLangGet)(const char *language);
+typedef const char* (*CupsLangEncoding)(cups_lang_t *language);
+typedef int (*CupsAddOption)(const char *name, const char *value, int num_options, cups_option_t **options);
+typedef int (*CupsTempFd)(char *name, int len);
+typedef int (*CupsPrintFile)(const char * name, const char * filename, const char * title, int num_options, cups_option_t * options);
+
+static bool cupsLoaded = false;
+static int qt_cups_num_printers = 0;
+static CupsGetDests _cupsGetDests = 0;
+static CupsFreeDests _cupsFreeDests = 0;
+static CupsGetPPD _cupsGetPPD = 0;
+static PPDOpenFile _ppdOpenFile = 0;
+static PPDMarkDefaults _ppdMarkDefaults = 0;
+static PPDClose _ppdClose = 0;
+static CupsMarkOptions _cupsMarkOptions = 0;
+static PPDMarkOption _ppdMarkOption = 0;
+static CupsFreeOptions _cupsFreeOptions = 0;
+static CupsSetDests _cupsSetDests = 0;
+static CupsLangGet _cupsLangGet = 0;
+static CupsLangEncoding _cupsLangEncoding = 0;
+static CupsAddOption _cupsAddOption = 0;
+static CupsTempFd _cupsTempFd = 0;
+static CupsPrintFile _cupsPrintFile = 0;
+
+static void resolveCups()
+{
+    QLibrary cupsLib(QLatin1String("cups"), 2);
+    if(cupsLib.load()) {
+        _cupsGetDests = (CupsGetDests) cupsLib.resolve("cupsGetDests");
+        _cupsFreeDests = (CupsFreeDests) cupsLib.resolve("cupsFreeDests");
+        _cupsGetPPD = (CupsGetPPD) cupsLib.resolve("cupsGetPPD");
+        _cupsLangGet = (CupsLangGet) cupsLib.resolve("cupsLangGet");
+        _cupsLangEncoding = (CupsLangEncoding) cupsLib.resolve("cupsLangEncoding");
+        _ppdOpenFile = (PPDOpenFile) cupsLib.resolve("ppdOpenFile");
+        _ppdMarkDefaults = (PPDMarkDefaults) cupsLib.resolve("ppdMarkDefaults");
+        _ppdClose = (PPDClose) cupsLib.resolve("ppdClose");
+        _cupsMarkOptions = (CupsMarkOptions) cupsLib.resolve("cupsMarkOptions");
+        _ppdMarkOption = (PPDMarkOption) cupsLib.resolve("ppdMarkOption");
+        _cupsFreeOptions = (CupsFreeOptions) cupsLib.resolve("cupsFreeOptions");
+        _cupsSetDests = (CupsSetDests) cupsLib.resolve("cupsSetDests");
+        _cupsAddOption = (CupsAddOption) cupsLib.resolve("cupsAddOption");
+        _cupsTempFd = (CupsTempFd) cupsLib.resolve("cupsTempFd");
+        _cupsPrintFile = (CupsPrintFile) cupsLib.resolve("cupsPrintFile");
+
+        if (_cupsGetDests && _cupsFreeDests) {
+            cups_dest_t *printers;
+            int num_printers = _cupsGetDests(&printers);
+            if (num_printers)
+                _cupsFreeDests(num_printers, printers);
+            qt_cups_num_printers = num_printers;
+        }
+    }
+    cupsLoaded = true;
+}
+
+// ================ CUPS Support class ========================
+
+QCUPSSupport::QCUPSSupport()
+    :
+    prnCount(0),
+    printers(0),
+    page_sizes(0),
+    currPrinterIndex(0),
+    currPPD(0)
+{
+    if (!cupsLoaded)
+        resolveCups();
+
+    // getting all available printers
+    if (!isAvailable())
+        return;
+
+    prnCount = _cupsGetDests(&printers);
+
+    for (int i = 0; i <  prnCount; ++i) {
+        if (printers[i].is_default) {
+            currPrinterIndex = i;
+            setCurrentPrinter(i);
+            break;
+        }
+    }
+
+#ifndef QT_NO_TEXTCODEC
+    cups_lang_t *cupsLang = _cupsLangGet(0);
+    codec = QTextCodec::codecForName(_cupsLangEncoding(cupsLang));
+    if (!codec)
+        codec = QTextCodec::codecForLocale();
+#endif
+}
+
+QCUPSSupport::~QCUPSSupport()
+{
+     if (currPPD)
+        _ppdClose(currPPD);
+     if (prnCount)
+         _cupsFreeDests(prnCount, printers);
+}
+
+int QCUPSSupport::availablePrintersCount() const
+{
+    return prnCount;
+}
+
+const cups_dest_t* QCUPSSupport::availablePrinters() const
+{
+    return printers;
+}
+
+const ppd_file_t* QCUPSSupport::currentPPD() const
+{
+    return currPPD;
+}
+
+const ppd_file_t* QCUPSSupport::setCurrentPrinter(int index)
+{
+    Q_ASSERT(index >= 0 && index <= prnCount);
+    if (index == prnCount)
+        return 0;
+
+    currPrinterIndex = index;
+
+    if (currPPD)
+        _ppdClose(currPPD);
+    currPPD = 0;
+    page_sizes = 0;
+
+    const char *ppdFile = _cupsGetPPD(printers[index].name);
+
+    if (!ppdFile)
+      return 0;
+
+    currPPD = _ppdOpenFile(ppdFile);
+    unlink(ppdFile);
+
+    // marking default options
+    _ppdMarkDefaults(currPPD);
+
+    // marking options explicitly set
+    _cupsMarkOptions(currPPD, printers[currPrinterIndex].num_options, printers[currPrinterIndex].options);
+
+    // getting pointer to page sizes
+    page_sizes = ppdOption("PageSize");
+
+    return currPPD;
+}
+
+int QCUPSSupport::currentPrinterIndex() const
+{
+    return currPrinterIndex;
+}
+
+bool QCUPSSupport::isAvailable()
+{
+    if(!cupsLoaded)
+        resolveCups();
+
+    return _cupsGetDests &&
+        _cupsFreeDests &&
+        _cupsGetPPD &&
+        _ppdOpenFile &&
+        _ppdMarkDefaults &&
+        _ppdClose &&
+        _cupsMarkOptions &&
+        _ppdMarkOption &&
+        _cupsFreeOptions &&
+        _cupsSetDests &&
+        _cupsLangGet &&
+        _cupsLangEncoding &&
+        _cupsAddOption &&
+        (qt_cups_num_printers > 0);
+}
+
+const ppd_option_t* QCUPSSupport::ppdOption(const char *key) const
+{
+    if (currPPD) {
+        for (int gr = 0; gr < currPPD->num_groups; ++gr) {
+            for (int opt = 0; opt < currPPD->groups[gr].num_options; ++opt) {
+                if (qstrcmp(currPPD->groups[gr].options[opt].keyword, key) == 0)
+                    return &currPPD->groups[gr].options[opt];
+            }
+        }
+    }
+    return 0;
+}
+
+const cups_option_t* QCUPSSupport::printerOption(const QString &key) const
+{
+    for (int i = 0; i < printers[currPrinterIndex].num_options; ++i) {
+        if (QLatin1String(printers[currPrinterIndex].options[i].name) == key)
+            return &printers[currPrinterIndex].options[i];
+    }
+    return 0;
+}
+
+const ppd_option_t* QCUPSSupport::pageSizes() const
+{
+    return page_sizes;
+}
+
+int QCUPSSupport::markOption(const char* name, const char* value)
+{
+    return _ppdMarkOption(currPPD, name, value);
+}
+
+void QCUPSSupport::saveOptions(QList<const ppd_option_t*> options, QList<const char*> markedOptions)
+{
+    int oldOptionCount = printers[currPrinterIndex].num_options;
+    cups_option_t* oldOptions = printers[currPrinterIndex].options;
+
+    int newOptionCount = 0;
+    cups_option_t* newOptions = 0;
+
+    // copying old options that are not on the new list
+    for (int i = 0; i < oldOptionCount; ++i) {
+        bool contains = false;
+        for (int j = 0; j < options.count(); ++j) {
+            if (qstrcmp(options.at(j)->keyword, oldOptions[i].name) == 0) {
+                contains = true;
+                break;
+            }
+        }
+
+        if (!contains) {
+            newOptionCount = _cupsAddOption(oldOptions[i].name, oldOptions[i].value, newOptionCount, &newOptions);
+        }
+    }
+
+    // we can release old option list
+     _cupsFreeOptions(oldOptionCount, oldOptions);
+
+    // adding marked options
+    for (int i = 0; i < markedOptions.count(); ++i) {
+        const char* name = markedOptions.at(i);
+        ++i;
+        newOptionCount = _cupsAddOption(name, markedOptions.at(i), newOptionCount, &newOptions);
+    }
+
+    // placing the new option list
+    printers[currPrinterIndex].num_options = newOptionCount;
+    printers[currPrinterIndex].options = newOptions;
+
+    // saving new default values
+    _cupsSetDests(prnCount, printers);
+}
+
+QRect QCUPSSupport::paperRect(const char *choice) const
+{
+    if (!currPPD)
+        return QRect();
+    for (int i = 0; i < currPPD->num_sizes; ++i) {
+        if (qstrcmp(currPPD->sizes[i].name, choice) == 0)
+            return QRect(0, 0, qRound(currPPD->sizes[i].width), qRound(currPPD->sizes[i].length));
+    }
+    return QRect();
+}
+
+QRect QCUPSSupport::pageRect(const char *choice) const
+{
+    if (!currPPD)
+        return QRect();
+    for (int i = 0; i < currPPD->num_sizes; ++i) {
+        if (qstrcmp(currPPD->sizes[i].name, choice) == 0)
+            return QRect(qRound(currPPD->sizes[i].left),
+                         qRound(currPPD->sizes[i].length - currPPD->sizes[i].top),
+                         qRound(currPPD->sizes[i].right - currPPD->sizes[i].left),
+                         qRound(currPPD->sizes[i].top - currPPD->sizes[i].bottom));
+    }
+    return QRect();
+}
+
+QStringList QCUPSSupport::options() const
+{
+    QStringList list;
+    collectMarkedOptions(list);
+    return list;
+}
+
+bool QCUPSSupport::printerHasPPD(const char *printerName)
+{
+    if (!isAvailable())
+        return false;
+    const char *ppdFile = _cupsGetPPD(printerName);
+    if (ppdFile)
+        unlink(ppdFile);
+    return (ppdFile != 0);
+}
+
+QString QCUPSSupport::unicodeString(const char *s)
+{
+#ifndef QT_NO_TEXTCODEC
+    return codec->toUnicode(s);
+#else
+    return QLatin1String(s);
+#endif
+}
+
+void QCUPSSupport::collectMarkedOptions(QStringList& list, const ppd_group_t* group) const
+{
+    if (group == 0) {
+        if (!currPPD)
+            return;
+        for (int i = 0; i < currPPD->num_groups; ++i) {
+            collectMarkedOptions(list, &currPPD->groups[i]);
+            collectMarkedOptionsHelper(list, &currPPD->groups[i]);
+        }
+    } else {
+        for (int i = 0; i < group->num_subgroups; ++i)
+            collectMarkedOptionsHelper(list, &group->subgroups[i]);
+    }
+}
+
+void QCUPSSupport::collectMarkedOptionsHelper(QStringList& list, const ppd_group_t* group) const
+{
+    for (int i = 0; i < group->num_options; ++i) {
+        for (int j = 0; j < group->options[i].num_choices; ++j) {
+            if (group->options[i].choices[j].marked == 1 && qstrcmp(group->options[i].choices[j].choice, group->options[i].defchoice) != 0)
+                list << QString::fromLocal8Bit(group->options[i].keyword) << QString::fromLocal8Bit(group->options[i].choices[j].choice);
+        }
+    }
+}
+
+QPair<int, QString> QCUPSSupport::tempFd()
+{
+    char filename[512];
+    int fd = _cupsTempFd(filename, 512);
+    return QPair<int, QString>(fd, QString::fromLocal8Bit(filename));
+}
+
+// Prints the given file and returns a job id.
+int QCUPSSupport::printFile(const char * printerName, const char * filename, const char * title,
+                            int num_options, cups_option_t * options)
+{
+    return _cupsPrintFile(printerName, filename, title, num_options, options);
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_CUPS
diff --git a/src/gui/painting/qcups_p.h b/src/gui/painting/qcups_p.h
new file mode 100644
index 0000000000..bc00c7396e
--- /dev/null
+++ b/src/gui/painting/qcups_p.h
@@ -0,0 +1,121 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QCUPS_P_H
+#define QCUPS_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+#include "QtCore/qstring.h"
+#include "QtCore/qstringlist.h"
+#include "QtGui/qprinter.h"
+
+#ifndef QT_NO_CUPS
+#include <QtCore/qlibrary.h>
+#include <cups/cups.h>
+#include <cups/ppd.h>
+
+QT_BEGIN_NAMESPACE
+
+Q_DECLARE_TYPEINFO(cups_option_t, Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE);
+
+class QCUPSSupport
+{
+public:
+    QCUPSSupport();
+    ~QCUPSSupport();
+
+    static bool isAvailable();
+    static int cupsVersion() { return isAvailable() ? CUPS_VERSION_MAJOR*10000+CUPS_VERSION_MINOR*100+CUPS_VERSION_PATCH : 0; }
+    int availablePrintersCount() const;
+    const cups_dest_t* availablePrinters() const;
+    int currentPrinterIndex() const;
+    const ppd_file_t* setCurrentPrinter(int index);
+
+    const ppd_file_t* currentPPD() const;
+    const ppd_option_t* ppdOption(const char *key) const;
+
+    const cups_option_t* printerOption(const QString &key) const;
+    const ppd_option_t* pageSizes() const;
+
+    int markOption(const char* name, const char* value);
+    void saveOptions(QList<const ppd_option_t*> options, QList<const char*> markedOptions);
+
+    QRect paperRect(const char *choice) const;
+    QRect pageRect(const char *choice) const;
+
+    QStringList options() const;
+
+    static bool printerHasPPD(const char *printerName);
+
+    QString unicodeString(const char *s);
+
+    QPair<int, QString> tempFd();
+    int printFile(const char * printerName, const char * filename, const char * title,
+                  int num_options, cups_option_t * options);
+
+private:
+    void collectMarkedOptions(QStringList& list, const ppd_group_t* group = 0) const;
+    void collectMarkedOptionsHelper(QStringList& list, const ppd_group_t* group) const;
+
+    int prnCount;
+    cups_dest_t *printers;
+    const ppd_option_t* page_sizes;
+    int currPrinterIndex;
+    ppd_file_t *currPPD;
+#ifndef QT_NO_TEXTCODEC
+    QTextCodec *codec;
+#endif
+};
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_CUPS
+
+#endif
diff --git a/src/gui/painting/qdatabuffer_p.h b/src/gui/painting/qdatabuffer_p.h
new file mode 100644
index 0000000000..5e50f6e032
--- /dev/null
+++ b/src/gui/painting/qdatabuffer_p.h
@@ -0,0 +1,145 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QDATABUFFER_P_H
+#define QDATABUFFER_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of other Qt classes.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "QtCore/qbytearray.h"
+
+QT_BEGIN_NAMESPACE
+
+template <typename Type> class QDataBuffer
+{
+public:
+    QDataBuffer(int res)
+    {
+        capacity = res;
+        if (res)
+            buffer = (Type*) qMalloc(capacity * sizeof(Type));
+        else
+            buffer = 0;
+        siz = 0;
+    }
+
+    ~QDataBuffer()
+    {
+        if (buffer)
+            qFree(buffer);
+    }
+
+    inline void reset() { siz = 0; }
+
+    inline bool isEmpty() const { return siz==0; }
+
+    inline int size() const { return siz; }
+    inline Type *data() const { return buffer; }
+
+    inline Type &at(int i) { Q_ASSERT(i >= 0 && i < siz); return buffer[i]; }
+    inline const Type &at(int i) const { Q_ASSERT(i >= 0 && i < siz); return buffer[i]; }
+    inline Type &last() { Q_ASSERT(!isEmpty()); return buffer[siz-1]; }
+    inline const Type &last() const { Q_ASSERT(!isEmpty()); return buffer[siz-1]; }
+    inline Type &first() { Q_ASSERT(!isEmpty()); return buffer[0]; }
+    inline const Type &first() const { Q_ASSERT(!isEmpty()); return buffer[0]; }
+
+    inline void add(const Type &t) {
+        reserve(siz + 1);
+        buffer[siz] = t;
+        ++siz;
+    }
+
+    inline void pop_back() {
+        Q_ASSERT(siz > 0);
+        --siz;
+    }
+
+    inline void resize(int size) {
+        reserve(size);
+        siz = size;
+    }
+
+    inline void reserve(int size) {
+        if (size > capacity) {
+            if (capacity == 0)
+                capacity = 1;
+            while (capacity < size)
+                capacity *= 2;
+            buffer = (Type*) qRealloc(buffer, capacity * sizeof(Type));
+        }
+    }
+
+    inline void shrink(int size) {
+        capacity = size;
+        if (size)
+            buffer = (Type*) qRealloc(buffer, capacity * sizeof(Type));
+        else {
+            qFree(buffer);
+            buffer = 0;
+        }
+    }
+
+    inline void swap(QDataBuffer<Type> &other) {
+        qSwap(capacity, other.capacity);
+        qSwap(siz, other.siz);
+        qSwap(buffer, other.buffer);
+    }
+
+    inline QDataBuffer &operator<<(const Type &t) { add(t); return *this; }
+
+private:
+    int capacity;
+    int siz;
+    Type *buffer;
+};
+
+QT_END_NAMESPACE
+
+#endif // QDATABUFFER_P_H
diff --git a/src/gui/painting/qdrawhelper.cpp b/src/gui/painting/qdrawhelper.cpp
new file mode 100644
index 0000000000..5e75e4a884
--- /dev/null
+++ b/src/gui/painting/qdrawhelper.cpp
@@ -0,0 +1,8078 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <private/qdrawhelper_p.h>
+#include <private/qpaintengine_raster_p.h>
+#include <private/qpainter_p.h>
+#include <private/qdrawhelper_x86_p.h>
+#ifdef QT_HAVE_ARM_SIMD
+#include <private/qdrawhelper_arm_simd_p.h>
+#endif
+#include <private/qdrawhelper_neon_p.h>
+#include <private/qmath_p.h>
+#include <qmath.h>
+
+QT_BEGIN_NAMESPACE
+
+
+#define MASK(src, a) src = BYTE_MUL(src, a)
+
+#if defined(Q_OS_IRIX) && defined(Q_CC_GNU) && __GNUC__ == 3 && __GNUC__ < 4 && QT_POINTER_SIZE == 8
+#define Q_IRIX_GCC3_3_WORKAROUND
+//
+// work around http://gcc.gnu.org/bugzilla/show_bug.cgi?id=14484
+//
+static uint gccBug(uint value) __attribute__((noinline));
+static uint gccBug(uint value)
+{
+    return value;
+}
+#endif
+
+/*
+  constants and structures
+*/
+
+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;
+    };
+};
+
+/*
+  Destination fetch. This is simple as we don't have to do bounds checks or
+  transformations
+*/
+
+static uint * QT_FASTCALL destFetchMono(uint *buffer, QRasterBuffer *rasterBuffer, int x, int y, int length)
+{
+    uchar *data = (uchar *)rasterBuffer->scanLine(y);
+    uint *start = buffer;
+    const uint *end = buffer + length;
+    while (buffer < end) {
+        *buffer = data[x>>3] & (0x80 >> (x & 7)) ? rasterBuffer->destColor1 : rasterBuffer->destColor0;
+        ++buffer;
+        ++x;
+    }
+    return start;
+}
+
+static uint * QT_FASTCALL destFetchMonoLsb(uint *buffer, QRasterBuffer *rasterBuffer, int x, int y, int length)
+{
+    uchar *data = (uchar *)rasterBuffer->scanLine(y);
+    uint *start = buffer;
+    const uint *end = buffer + length;
+    while (buffer < end) {
+        *buffer = data[x>>3] & (0x1 << (x & 7)) ? rasterBuffer->destColor1 : rasterBuffer->destColor0;
+        ++buffer;
+        ++x;
+    }
+    return start;
+}
+
+static uint * QT_FASTCALL destFetchARGB32(uint *buffer, QRasterBuffer *rasterBuffer, int x, int y, int length)
+{
+    const uint *data = (const uint *)rasterBuffer->scanLine(y) + x;
+    for (int i = 0; i < length; ++i)
+        buffer[i] = PREMUL(data[i]);
+    return buffer;
+}
+
+static uint * QT_FASTCALL destFetchARGB32P(uint *, QRasterBuffer *rasterBuffer, int x, int y, int)
+{
+    return (uint *)rasterBuffer->scanLine(y) + x;
+}
+
+static uint * QT_FASTCALL destFetchRGB16(uint *buffer, QRasterBuffer *rasterBuffer, int x, int y, int length)
+{
+    const ushort *data = (const ushort *)rasterBuffer->scanLine(y) + x;
+    for (int i = 0; i < length; ++i)
+        buffer[i] = qConvertRgb16To32(data[i]);
+    return buffer;
+}
+
+template <class DST>
+Q_STATIC_TEMPLATE_FUNCTION uint * QT_FASTCALL destFetch(uint *buffer, QRasterBuffer *rasterBuffer,
+                                    int x, int y, int length)
+{
+    const DST *src = reinterpret_cast<DST*>(rasterBuffer->scanLine(y)) + x;
+    quint32 *dest = reinterpret_cast<quint32*>(buffer);
+    while (length--)
+        *dest++ = *src++;
+    return buffer;
+}
+
+# define SPANFUNC_POINTER_DESTFETCH(Arg) destFetch<Arg>
+
+static DestFetchProc destFetchProc[QImage::NImageFormats] =
+{
+    0, // Format_Invalid
+    destFetchMono, // Format_Mono,
+    destFetchMonoLsb, // Format_MonoLSB
+    0, // Format_Indexed8
+    destFetchARGB32P, // Format_RGB32
+    destFetchARGB32, // Format_ARGB32,
+    destFetchARGB32P, // Format_ARGB32_Premultiplied
+    destFetchRGB16,   // Format_RGB16
+    SPANFUNC_POINTER_DESTFETCH(qargb8565), // Format_ARGB8565_Premultiplied
+    SPANFUNC_POINTER_DESTFETCH(qrgb666),   // Format_RGB666
+    SPANFUNC_POINTER_DESTFETCH(qargb6666), // Format_ARGB6666_Premultiplied
+    SPANFUNC_POINTER_DESTFETCH(qrgb555),   // Format_RGB555
+    SPANFUNC_POINTER_DESTFETCH(qargb8555), // Format_ARGB8555_Premultiplied
+    SPANFUNC_POINTER_DESTFETCH(qrgb888),   // Format_RGB888
+    SPANFUNC_POINTER_DESTFETCH(qrgb444),   // Format_RGB444
+    SPANFUNC_POINTER_DESTFETCH(qargb4444)  // Format_ARGB4444_Premultiplied
+};
+
+/*
+   Returns the color in the mono destination color table
+   that is the "nearest" to /color/.
+*/
+static inline QRgb findNearestColor(QRgb color, QRasterBuffer *rbuf)
+{
+    QRgb color_0 = PREMUL(rbuf->destColor0);
+    QRgb color_1 = PREMUL(rbuf->destColor1);
+    color = PREMUL(color);
+
+    int r = qRed(color);
+    int g = qGreen(color);
+    int b = qBlue(color);
+    int rx, gx, bx;
+    int dist_0, dist_1;
+
+    rx = r - qRed(color_0);
+    gx = g - qGreen(color_0);
+    bx = b - qBlue(color_0);
+    dist_0 = rx*rx + gx*gx + bx*bx;
+
+    rx = r - qRed(color_1);
+    gx = g - qGreen(color_1);
+    bx = b - qBlue(color_1);
+    dist_1 = rx*rx + gx*gx + bx*bx;
+
+    if (dist_0 < dist_1)
+        return color_0;
+    return color_1;
+}
+
+/*
+  Destination store.
+*/
+
+static void QT_FASTCALL destStoreMono(QRasterBuffer *rasterBuffer, int x, int y, const uint *buffer, int length)
+{
+    uchar *data = (uchar *)rasterBuffer->scanLine(y);
+    if (rasterBuffer->monoDestinationWithClut) {
+        for (int i = 0; i < length; ++i) {
+            if (buffer[i] == rasterBuffer->destColor0) {
+                data[x >> 3] &= ~(0x80 >> (x & 7));
+            } else if (buffer[i] == rasterBuffer->destColor1) {
+                data[x >> 3] |= 0x80 >> (x & 7);
+            } else if (findNearestColor(buffer[i], rasterBuffer) == rasterBuffer->destColor0) {
+                data[x >> 3] &= ~(0x80 >> (x & 7));
+            } else {
+                data[x >> 3] |= 0x80 >> (x & 7);
+            }
+            ++x;
+        }
+    } else {
+        for (int i = 0; i < length; ++i) {
+            if (qGray(buffer[i]) < int(qt_bayer_matrix[y & 15][x & 15]))
+                data[x >> 3] |= 0x80 >> (x & 7);
+            else
+                data[x >> 3] &= ~(0x80 >> (x & 7));
+            ++x;
+        }
+    }
+}
+
+static void QT_FASTCALL destStoreMonoLsb(QRasterBuffer *rasterBuffer, int x, int y, const uint *buffer, int length)
+{
+    uchar *data = (uchar *)rasterBuffer->scanLine(y);
+    if (rasterBuffer->monoDestinationWithClut) {
+        for (int i = 0; i < length; ++i) {
+            if (buffer[i] == rasterBuffer->destColor0) {
+                data[x >> 3] &= ~(1 << (x & 7));
+            } else if (buffer[i] == rasterBuffer->destColor1) {
+                data[x >> 3] |= 1 << (x & 7);
+            } else if (findNearestColor(buffer[i], rasterBuffer) == rasterBuffer->destColor0) {
+                data[x >> 3] &= ~(1 << (x & 7));
+            } else {
+                data[x >> 3] |= 1 << (x & 7);
+            }
+            ++x;
+        }
+    } else {
+        for (int i = 0; i < length; ++i) {
+            if (qGray(buffer[i]) < int(qt_bayer_matrix[y & 15][x & 15]))
+                data[x >> 3] |= 1 << (x & 7);
+            else
+                data[x >> 3] &= ~(1 << (x & 7));
+            ++x;
+        }
+    }
+}
+
+static void QT_FASTCALL destStoreARGB32(QRasterBuffer *rasterBuffer, int x, int y, const uint *buffer, int length)
+{
+    uint *data = (uint *)rasterBuffer->scanLine(y) + x;
+    for (int i = 0; i < length; ++i) {
+        int p = buffer[i];
+        int alpha = qAlpha(p);
+        if (alpha == 255)
+            data[i] = p;
+        else if (alpha == 0)
+            data[i] = 0;
+        else {
+            int inv_alpha = 0xff0000/qAlpha(buffer[i]);
+            data[i] = (p & 0xff000000)
+                      | ((qRed(p)*inv_alpha) & 0xff0000)
+                      | (((qGreen(p)*inv_alpha) >> 8) & 0xff00)
+                      | ((qBlue(p)*inv_alpha) >> 16);
+        }
+    }
+}
+
+static void QT_FASTCALL destStoreRGB16(QRasterBuffer *rasterBuffer, int x, int y, const uint *buffer, int length)
+{
+    quint16 *data = (quint16*)rasterBuffer->scanLine(y) + x;
+    qt_memconvert<quint16, quint32>(data, buffer, length);
+}
+
+template <class DST>
+Q_STATIC_TEMPLATE_FUNCTION void QT_FASTCALL destStore(QRasterBuffer *rasterBuffer,
+                                  int x, int y,
+                                  const uint *buffer, int length)
+{
+    DST *dest = reinterpret_cast<DST*>(rasterBuffer->scanLine(y)) + x;
+    const quint32p *src = reinterpret_cast<const quint32p*>(buffer);
+    while (length--)
+        *dest++ = DST(*src++);
+}
+
+# define SPANFUNC_POINTER_DESTSTORE(DEST) destStore<DEST>
+
+static DestStoreProc destStoreProc[QImage::NImageFormats] =
+{
+    0, // Format_Invalid
+    destStoreMono, // Format_Mono,
+    destStoreMonoLsb, // Format_MonoLSB
+    0, // Format_Indexed8
+    0, // Format_RGB32
+    destStoreARGB32, // Format_ARGB32,
+    0, // Format_ARGB32_Premultiplied
+    destStoreRGB16, // Format_RGB16
+    SPANFUNC_POINTER_DESTSTORE(qargb8565), // Format_ARGB8565_Premultiplied
+    SPANFUNC_POINTER_DESTSTORE(qrgb666),   // Format_RGB666
+    SPANFUNC_POINTER_DESTSTORE(qargb6666), // Format_ARGB6666_Premultiplied
+    SPANFUNC_POINTER_DESTSTORE(qrgb555),   // Format_RGB555
+    SPANFUNC_POINTER_DESTSTORE(qargb8555), // Format_ARGB8555_Premultiplied
+    SPANFUNC_POINTER_DESTSTORE(qrgb888),   // Format_RGB888
+    SPANFUNC_POINTER_DESTSTORE(qrgb444),   // Format_RGB444
+    SPANFUNC_POINTER_DESTSTORE(qargb4444)  // Format_ARGB4444_Premultiplied
+};
+
+/*
+  Source fetches
+
+  This is a bit more complicated, as we need several fetch routines for every surface type
+
+  We need 5 fetch methods per surface type:
+  untransformed
+  transformed (tiled and not tiled)
+  transformed bilinear (tiled and not tiled)
+
+  We don't need bounds checks for untransformed, but we need them for the other ones.
+
+  The generic implementation does pixel by pixel fetches
+*/
+
+template <QImage::Format format>
+Q_STATIC_TEMPLATE_FUNCTION uint QT_FASTCALL qt_fetchPixel(const uchar *scanLine, int x, const QVector<QRgb> *rgb);
+
+template<>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+uint QT_FASTCALL qt_fetchPixel<QImage::Format_Mono>(const uchar *scanLine,
+                                                 int x, const QVector<QRgb> *rgb)
+{
+    bool pixel = scanLine[x>>3] & (0x80 >> (x & 7));
+    if (rgb) return PREMUL(rgb->at(pixel ? 1 : 0));
+    return pixel ? 0xff000000 : 0xffffffff;
+}
+
+template<>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+uint QT_FASTCALL qt_fetchPixel<QImage::Format_MonoLSB>(const uchar *scanLine,
+                                                    int x, const QVector<QRgb> *rgb)
+{
+    bool pixel = scanLine[x>>3] & (0x1 << (x & 7));
+    if (rgb) return PREMUL(rgb->at(pixel ? 1 : 0));
+    return pixel ? 0xff000000 : 0xffffffff;
+}
+
+template<>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+uint QT_FASTCALL qt_fetchPixel<QImage::Format_Indexed8>(const uchar *scanLine,
+                                                     int x, const QVector<QRgb> *rgb)
+{
+    return PREMUL(rgb->at(scanLine[x]));
+}
+
+template<>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+uint QT_FASTCALL qt_fetchPixel<QImage::Format_ARGB32>(const uchar *scanLine,
+                                                   int x, const QVector<QRgb> *)
+{
+    return PREMUL(((const uint *)scanLine)[x]);
+}
+
+template<>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+uint QT_FASTCALL qt_fetchPixel<QImage::Format_ARGB32_Premultiplied>(const uchar *scanLine,
+                                                                 int x, const QVector<QRgb> *)
+{
+    return ((const uint *)scanLine)[x];
+}
+
+template<>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+uint QT_FASTCALL qt_fetchPixel<QImage::Format_RGB16>(const uchar *scanLine,
+                                                  int x, const QVector<QRgb> *)
+{
+    return qConvertRgb16To32(((const ushort *)scanLine)[x]);
+}
+
+template<>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+uint QT_FASTCALL qt_fetchPixel<QImage::Format_ARGB8565_Premultiplied>(const uchar *scanLine,
+                                                     int x,
+                                                     const QVector<QRgb> *)
+{
+    const qargb8565 color = reinterpret_cast<const qargb8565*>(scanLine)[x];
+    return qt_colorConvert<quint32, qargb8565>(color, 0);
+}
+
+template<>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+uint QT_FASTCALL qt_fetchPixel<QImage::Format_RGB666>(const uchar *scanLine,
+                                                   int x,
+                                                   const QVector<QRgb> *)
+{
+    const qrgb666 color = reinterpret_cast<const qrgb666*>(scanLine)[x];
+    return qt_colorConvert<quint32, qrgb666>(color, 0);
+}
+
+template<>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+uint QT_FASTCALL qt_fetchPixel<QImage::Format_ARGB6666_Premultiplied>(const uchar *scanLine,
+                                                   int x,
+                                                   const QVector<QRgb> *)
+{
+    const qargb6666 color = reinterpret_cast<const qargb6666*>(scanLine)[x];
+    return qt_colorConvert<quint32, qargb6666>(color, 0);
+}
+
+template<>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+uint QT_FASTCALL qt_fetchPixel<QImage::Format_RGB555>(const uchar *scanLine,
+                                                   int x,
+                                                   const QVector<QRgb> *)
+{
+    const qrgb555 color = reinterpret_cast<const qrgb555*>(scanLine)[x];
+    return qt_colorConvert<quint32, qrgb555>(color, 0);
+}
+
+template<>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+uint QT_FASTCALL qt_fetchPixel<QImage::Format_ARGB8555_Premultiplied>(const uchar *scanLine,
+                                                     int x,
+                                                     const QVector<QRgb> *)
+{
+    const qargb8555 color = reinterpret_cast<const qargb8555*>(scanLine)[x];
+    return qt_colorConvert<quint32, qargb8555>(color, 0);
+}
+
+template<>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+uint QT_FASTCALL qt_fetchPixel<QImage::Format_RGB888>(const uchar *scanLine,
+                                                   int x,
+                                                   const QVector<QRgb> *)
+{
+    const qrgb888 color = reinterpret_cast<const qrgb888*>(scanLine)[x];
+    return qt_colorConvert<quint32, qrgb888>(color, 0);
+}
+
+template<>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+uint QT_FASTCALL qt_fetchPixel<QImage::Format_RGB444>(const uchar *scanLine,
+                                                   int x,
+                                                   const QVector<QRgb> *)
+{
+    const qrgb444 color = reinterpret_cast<const qrgb444*>(scanLine)[x];
+    return qt_colorConvert<quint32, qrgb444>(color, 0);
+}
+
+template<>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+uint QT_FASTCALL qt_fetchPixel<QImage::Format_ARGB4444_Premultiplied>(const uchar *scanLine,
+                                                     int x,
+                                                     const QVector<QRgb> *)
+{
+    const qargb4444 color = reinterpret_cast<const qargb4444*>(scanLine)[x];
+    return qt_colorConvert<quint32, qargb4444>(color, 0);
+}
+
+template<>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+uint QT_FASTCALL qt_fetchPixel<QImage::Format_Invalid>(const uchar *,
+                                                     int ,
+                                                     const QVector<QRgb> *)
+{
+    return 0;
+}
+
+typedef uint (QT_FASTCALL *FetchPixelProc)(const uchar *scanLine, int x, const QVector<QRgb> *);
+
+#define SPANFUNC_POINTER_FETCHPIXEL(Arg) qt_fetchPixel<QImage::Arg>
+
+
+static const FetchPixelProc fetchPixelProc[QImage::NImageFormats] =
+{
+    0,
+    SPANFUNC_POINTER_FETCHPIXEL(Format_Mono),
+    SPANFUNC_POINTER_FETCHPIXEL(Format_MonoLSB),
+    SPANFUNC_POINTER_FETCHPIXEL(Format_Indexed8),
+    SPANFUNC_POINTER_FETCHPIXEL(Format_ARGB32_Premultiplied),
+    SPANFUNC_POINTER_FETCHPIXEL(Format_ARGB32),
+    SPANFUNC_POINTER_FETCHPIXEL(Format_ARGB32_Premultiplied),
+    SPANFUNC_POINTER_FETCHPIXEL(Format_RGB16),
+    SPANFUNC_POINTER_FETCHPIXEL(Format_ARGB8565_Premultiplied),
+    SPANFUNC_POINTER_FETCHPIXEL(Format_RGB666),
+    SPANFUNC_POINTER_FETCHPIXEL(Format_ARGB6666_Premultiplied),
+    SPANFUNC_POINTER_FETCHPIXEL(Format_RGB555),
+    SPANFUNC_POINTER_FETCHPIXEL(Format_ARGB8555_Premultiplied),
+    SPANFUNC_POINTER_FETCHPIXEL(Format_RGB888),
+    SPANFUNC_POINTER_FETCHPIXEL(Format_RGB444),
+    SPANFUNC_POINTER_FETCHPIXEL(Format_ARGB4444_Premultiplied)
+};
+
+enum TextureBlendType {
+    BlendUntransformed,
+    BlendTiled,
+    BlendTransformed,
+    BlendTransformedTiled,
+    BlendTransformedBilinear,
+    BlendTransformedBilinearTiled,
+    NBlendTypes
+};
+
+template <QImage::Format format>
+Q_STATIC_TEMPLATE_FUNCTION const uint * QT_FASTCALL qt_fetchUntransformed(uint *buffer, const Operator *, const QSpanData *data,
+                                             int y, int x, int length)
+{
+    const uchar *scanLine = data->texture.scanLine(y);
+    for (int i = 0; i < length; ++i)
+        buffer[i] = qt_fetchPixel<format>(scanLine, x + i, data->texture.colorTable);
+    return buffer;
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION const uint * QT_FASTCALL
+qt_fetchUntransformed<QImage::Format_ARGB32_Premultiplied>(uint *, const Operator *,
+                                                         const QSpanData *data,
+                                                         int y, int x, int)
+{
+    const uchar *scanLine = data->texture.scanLine(y);
+    return ((const uint *)scanLine) + x;
+}
+
+template<TextureBlendType blendType>  /* either BlendTransformed or BlendTransformedTiled */
+Q_STATIC_TEMPLATE_FUNCTION
+const uint * QT_FASTCALL fetchTransformed(uint *buffer, const Operator *, const QSpanData *data,
+                                                         int y, int x, int length)
+{
+    FetchPixelProc fetch = fetchPixelProc[data->texture.format];
+
+    int image_width = data->texture.width;
+    int image_height = data->texture.height;
+
+    const qreal cx = x + qreal(0.5);
+    const qreal cy = y + qreal(0.5);
+
+    const uint *end = buffer + length;
+    uint *b = buffer;
+    if (data->fast_matrix) {
+        // The increment pr x in the scanline
+        int fdx = (int)(data->m11 * fixed_scale);
+        int fdy = (int)(data->m12 * fixed_scale);
+
+        int fx = int((data->m21 * cy
+                      + data->m11 * cx + data->dx) * fixed_scale);
+        int fy = int((data->m22 * cy
+                      + data->m12 * cx + data->dy) * fixed_scale);
+
+        while (b < end) {
+            int px = fx >> 16;
+            int py = fy >> 16;
+
+            if (blendType == BlendTransformedTiled) {
+                px %= image_width;
+                py %= image_height;
+                if (px < 0) px += image_width;
+                if (py < 0) py += image_height;
+
+                const uchar *scanLine = data->texture.scanLine(py);
+                *b = fetch(scanLine, px, data->texture.colorTable);
+            } else {
+                if ((px < 0) || (px >= image_width)
+                    || (py < 0) || (py >= image_height)) {
+                    *b = uint(0);
+                } else {
+                    const uchar *scanLine = data->texture.scanLine(py);
+                    *b = fetch(scanLine, px, data->texture.colorTable);
+                }
+            }
+            fx += fdx;
+            fy += fdy;
+            ++b;
+        }
+    } else {
+        const qreal fdx = data->m11;
+        const qreal fdy = data->m12;
+        const qreal fdw = data->m13;
+
+        qreal fx = data->m21 * cy + data->m11 * cx + data->dx;
+        qreal fy = data->m22 * cy + data->m12 * cx + data->dy;
+        qreal fw = data->m23 * cy + data->m13 * cx + data->m33;
+
+        while (b < end) {
+            const qreal iw = fw == 0 ? 1 : 1 / fw;
+            const qreal tx = fx * iw;
+            const qreal ty = fy * iw;
+            int px = int(tx) - (tx < 0);
+            int py = int(ty) - (ty < 0);
+
+            if (blendType == BlendTransformedTiled) {
+                px %= image_width;
+                py %= image_height;
+                if (px < 0) px += image_width;
+                if (py < 0) py += image_height;
+
+                const uchar *scanLine = data->texture.scanLine(py);
+                *b = fetch(scanLine, px, data->texture.colorTable);
+            } else {
+                if ((px < 0) || (px >= image_width)
+                    || (py < 0) || (py >= image_height)) {
+                    *b = uint(0);
+                } else {
+                    const uchar *scanLine = data->texture.scanLine(py);
+                    *b = fetch(scanLine, px, data->texture.colorTable);
+                }
+            }
+            fx += fdx;
+            fy += fdy;
+            fw += fdw;
+            //force increment to avoid /0
+            if (!fw) {
+                fw += fdw;
+            }
+            ++b;
+        }
+    }
+
+    return buffer;
+}
+
+/** \internal
+  interpolate 4 argb pixels with the distx and disty factor.
+  distx and disty bust be between 0 and 16
+ */
+static inline uint interpolate_4_pixels_16(uint tl, uint tr, uint bl, uint br, int distx, int disty)
+{
+    uint distxy = distx * disty;
+    //idistx * disty = (16-distx) * disty = 16*disty - distxy
+    //idistx * idisty = (16-distx) * (16-disty) = 16*16 - 16*distx -16*dity + distxy
+    uint tlrb = (tl & 0x00ff00ff)         * (16*16 - 16*distx - 16*disty + distxy);
+    uint tlag = ((tl & 0xff00ff00) >> 8)  * (16*16 - 16*distx - 16*disty + distxy);
+    uint trrb = ((tr & 0x00ff00ff)        * (distx*16 - distxy));
+    uint trag = (((tr & 0xff00ff00) >> 8) * (distx*16 - distxy));
+    uint blrb = ((bl & 0x00ff00ff)        * (disty*16 - distxy));
+    uint blag = (((bl & 0xff00ff00) >> 8) * (disty*16 - distxy));
+    uint brrb = ((br & 0x00ff00ff)        * (distxy));
+    uint brag = (((br & 0xff00ff00) >> 8) * (distxy));
+    return (((tlrb + trrb + blrb + brrb) >> 8) & 0x00ff00ff) | ((tlag + trag + blag + brag) & 0xff00ff00);
+}
+
+#if defined(QT_ALWAYS_HAVE_SSE2)
+#define interpolate_4_pixels_16_sse2(tl, tr, bl, br, distx, disty, colorMask, v_256, b)  \
+{ \
+    const __m128i dxdy = _mm_mullo_epi16 (distx, disty); \
+    const __m128i distx_ = _mm_slli_epi16(distx, 4); \
+    const __m128i disty_ = _mm_slli_epi16(disty, 4); \
+    const __m128i idxidy =  _mm_add_epi16(dxdy, _mm_sub_epi16(v_256, _mm_add_epi16(distx_, disty_))); \
+    const __m128i dxidy =  _mm_sub_epi16(distx_, dxdy); \
+    const __m128i idxdy =  _mm_sub_epi16(disty_, dxdy); \
+ \
+    __m128i tlAG = _mm_srli_epi16(tl, 8); \
+    __m128i tlRB = _mm_and_si128(tl, colorMask); \
+    __m128i trAG = _mm_srli_epi16(tr, 8); \
+    __m128i trRB = _mm_and_si128(tr, colorMask); \
+    __m128i blAG = _mm_srli_epi16(bl, 8); \
+    __m128i blRB = _mm_and_si128(bl, colorMask); \
+    __m128i brAG = _mm_srli_epi16(br, 8); \
+    __m128i brRB = _mm_and_si128(br, colorMask); \
+ \
+    tlAG = _mm_mullo_epi16(tlAG, idxidy); \
+    tlRB = _mm_mullo_epi16(tlRB, idxidy); \
+    trAG = _mm_mullo_epi16(trAG, dxidy); \
+    trRB = _mm_mullo_epi16(trRB, dxidy); \
+    blAG = _mm_mullo_epi16(blAG, idxdy); \
+    blRB = _mm_mullo_epi16(blRB, idxdy); \
+    brAG = _mm_mullo_epi16(brAG, dxdy); \
+    brRB = _mm_mullo_epi16(brRB, dxdy); \
+ \
+    /* Add the values, and shift to only keep 8 significant bits per colors */ \
+    __m128i rAG =_mm_add_epi16(_mm_add_epi16(tlAG, trAG), _mm_add_epi16(blAG, brAG)); \
+    __m128i rRB =_mm_add_epi16(_mm_add_epi16(tlRB, trRB), _mm_add_epi16(blRB, brRB)); \
+    rAG = _mm_andnot_si128(colorMask, rAG); \
+    rRB = _mm_srli_epi16(rRB, 8); \
+    _mm_storeu_si128((__m128i*)(b), _mm_or_si128(rAG, rRB)); \
+}
+#endif
+
+#if defined(QT_ALWAYS_HAVE_NEON)
+#define interpolate_4_pixels_16_neon(tl, tr, bl, br, distx, disty, disty_, colorMask, invColorMask, v_256, b)  \
+{ \
+    const int16x8_t dxdy = vmulq_s16(distx, disty); \
+    const int16x8_t distx_ = vshlq_n_s16(distx, 4); \
+    const int16x8_t idxidy =  vaddq_s16(dxdy, vsubq_s16(v_256, vaddq_s16(distx_, disty_))); \
+    const int16x8_t dxidy =  vsubq_s16(distx_, dxdy); \
+    const int16x8_t idxdy =  vsubq_s16(disty_, dxdy); \
+ \
+    int16x8_t tlAG = vreinterpretq_s16_u16(vshrq_n_u16(vreinterpretq_u16_s16(tl), 8)); \
+    int16x8_t tlRB = vandq_s16(tl, colorMask); \
+    int16x8_t trAG = vreinterpretq_s16_u16(vshrq_n_u16(vreinterpretq_u16_s16(tr), 8)); \
+    int16x8_t trRB = vandq_s16(tr, colorMask); \
+    int16x8_t blAG = vreinterpretq_s16_u16(vshrq_n_u16(vreinterpretq_u16_s16(bl), 8)); \
+    int16x8_t blRB = vandq_s16(bl, colorMask); \
+    int16x8_t brAG = vreinterpretq_s16_u16(vshrq_n_u16(vreinterpretq_u16_s16(br), 8)); \
+    int16x8_t brRB = vandq_s16(br, colorMask); \
+ \
+    int16x8_t rAG = vmulq_s16(tlAG, idxidy); \
+    int16x8_t rRB = vmulq_s16(tlRB, idxidy); \
+    rAG = vmlaq_s16(rAG, trAG, dxidy); \
+    rRB = vmlaq_s16(rRB, trRB, dxidy); \
+    rAG = vmlaq_s16(rAG, blAG, idxdy); \
+    rRB = vmlaq_s16(rRB, blRB, idxdy); \
+    rAG = vmlaq_s16(rAG, brAG, dxdy); \
+    rRB = vmlaq_s16(rRB, brRB, dxdy); \
+ \
+    rAG = vandq_s16(invColorMask, rAG); \
+    rRB = vreinterpretq_s16_u16(vshrq_n_u16(vreinterpretq_u16_s16(rRB), 8)); \
+    vst1q_s16((int16_t*)(b), vorrq_s16(rAG, rRB)); \
+}
+#endif
+
+template<TextureBlendType blendType>
+Q_STATIC_TEMPLATE_FUNCTION inline void fetchTransformedBilinear_pixelBounds(int max, int l1, int l2, int &v1, int &v2)
+{
+    if (blendType == BlendTransformedBilinearTiled) {
+        v1 %= max;
+        if (v1 < 0) v1 += max;
+        v2 = v1 + 1;
+        v2 %= max;
+    } else {
+        if (v1 < l1) {
+            v2 = v1 = l1;
+        } else if (v1 >= l2) {
+            v2 = v1 = l2;
+        } else {
+            v2 = v1 + 1;
+        }
+    }
+
+    Q_ASSERT(v1 >= 0 && v1 < max);
+    Q_ASSERT(v2 >= 0 && v2 < max);
+}
+
+template<TextureBlendType blendType, QImage::Format format> /* blendType = BlendTransformedBilinear or BlendTransformedBilinearTiled */
+Q_STATIC_TEMPLATE_FUNCTION
+const uint * QT_FASTCALL fetchTransformedBilinear(uint *buffer, const Operator *, const QSpanData *data,
+                                                  int y, int x, int length)
+{
+#ifdef Q_CC_RVCT // needed to avoid compiler crash in RVCT 2.2
+    FetchPixelProc fetch;
+    if (format != QImage::Format_Invalid)
+        fetch = qt_fetchPixel<format>;
+    else
+        fetch = fetchPixelProc[data->texture.format];
+#else
+    FetchPixelProc fetch = (format != QImage::Format_Invalid) ? FetchPixelProc(qt_fetchPixel<format>) : fetchPixelProc[data->texture.format];
+#endif
+
+    int image_width = data->texture.width;
+    int image_height = data->texture.height;
+
+    int image_x1 = data->texture.x1;
+    int image_y1 = data->texture.y1;
+    int image_x2 = data->texture.x2 - 1;
+    int image_y2 = data->texture.y2 - 1;
+
+    const qreal cx = x + qreal(0.5);
+    const qreal cy = y + qreal(0.5);
+
+    uint *end = buffer + length;
+    uint *b = buffer;
+    if (data->fast_matrix) {
+        // The increment pr x in the scanline
+        int fdx = (int)(data->m11 * fixed_scale);
+        int fdy = (int)(data->m12 * fixed_scale);
+
+        int fx = int((data->m21 * cy
+                      + data->m11 * cx + data->dx) * fixed_scale);
+        int fy = int((data->m22 * cy
+                      + data->m12 * cx + data->dy) * fixed_scale);
+
+        fx -= half_point;
+        fy -= half_point;
+
+        if (fdy == 0) { //simple scale, no rotation
+            int y1 = (fy >> 16);
+            int y2;
+            fetchTransformedBilinear_pixelBounds<blendType>(image_height, image_y1, image_y2, y1, y2);
+            const uchar *s1 = data->texture.scanLine(y1);
+            const uchar *s2 = data->texture.scanLine(y2);
+
+            if (fdx <= fixed_scale && fdx > 0) { // scale up on X
+                int disty = (fy & 0x0000ffff) >> 8;
+                int idisty = 256 - disty;
+                int x = fx >> 16;
+
+                // The idea is first to do the interpolation between the row s1 and the row s2
+                // into an intermediate buffer, then we interpolate between two pixel of this buffer.
+
+                // intermediate_buffer[0] is a buffer of red-blue component of the pixel, in the form 0x00RR00BB
+                // intermediate_buffer[1] is the alpha-green component of the pixel, in the form 0x00AA00GG
+                quint32 intermediate_buffer[2][buffer_size + 2];
+                // count is the size used in the intermediate_buffer.
+                int count = qCeil(length * data->m11) + 2; //+1 for the last pixel to interpolate with, and +1 for rounding errors.
+                Q_ASSERT(count <= buffer_size + 2); //length is supposed to be <= buffer_size and data->m11 < 1 in this case
+                int f = 0;
+                int lim = count;
+                if (blendType == BlendTransformedBilinearTiled) {
+                    x %= image_width;
+                    if (x < 0) x += image_width;
+                } else {
+                    lim = qMin(count, image_x2-x+1);
+                    if (x < image_x1) {
+                        Q_ASSERT(x <= image_x2);
+                        uint t = fetch(s1, image_x1, data->texture.colorTable);
+                        uint b = fetch(s2, image_x1, data->texture.colorTable);
+                        quint32 rb = (((t & 0xff00ff) * idisty + (b & 0xff00ff) * disty) >> 8) & 0xff00ff;
+                        quint32 ag = ((((t>>8) & 0xff00ff) * idisty + ((b>>8) & 0xff00ff) * disty) >> 8) & 0xff00ff;
+                        do {
+                            intermediate_buffer[0][f] = rb;
+                            intermediate_buffer[1][f] = ag;
+                            f++;
+                            x++;
+                        } while (x < image_x1 && f < lim);
+                    }
+                }
+
+                if (blendType != BlendTransformedBilinearTiled &&
+                        (format == QImage::Format_ARGB32_Premultiplied || format == QImage::Format_RGB32)) {
+#if defined(QT_ALWAYS_HAVE_SSE2)
+                    const __m128i disty_ = _mm_set1_epi16(disty);
+                    const __m128i idisty_ = _mm_set1_epi16(idisty);
+                    const __m128i colorMask = _mm_set1_epi32(0x00ff00ff);
+
+                    lim -= 3;
+                    for (; f < lim; x += 4, f += 4) {
+                        // Load 4 pixels from s1, and split the alpha-green and red-blue component
+                        __m128i top = _mm_loadu_si128((__m128i*)((const uint *)(s1)+x));
+                        __m128i topAG = _mm_srli_epi16(top, 8);
+                        __m128i topRB = _mm_and_si128(top, colorMask);
+                        // Multiplies each colour component by idisty
+                        topAG = _mm_mullo_epi16 (topAG, idisty_);
+                        topRB = _mm_mullo_epi16 (topRB, idisty_);
+
+                        // Same for the s2 vector
+                        __m128i bottom = _mm_loadu_si128((__m128i*)((const uint *)(s2)+x));
+                        __m128i bottomAG = _mm_srli_epi16(bottom, 8);
+                        __m128i bottomRB = _mm_and_si128(bottom, colorMask);
+                        bottomAG = _mm_mullo_epi16 (bottomAG, disty_);
+                        bottomRB = _mm_mullo_epi16 (bottomRB, disty_);
+
+                        // Add the values, and shift to only keep 8 significant bits per colors
+                        __m128i rAG =_mm_add_epi16(topAG, bottomAG);
+                        rAG = _mm_srli_epi16(rAG, 8);
+                        _mm_storeu_si128((__m128i*)(&intermediate_buffer[1][f]), rAG);
+                        __m128i rRB =_mm_add_epi16(topRB, bottomRB);
+                        rRB = _mm_srli_epi16(rRB, 8);
+                        _mm_storeu_si128((__m128i*)(&intermediate_buffer[0][f]), rRB);
+                    }
+#elif defined(QT_ALWAYS_HAVE_NEON)
+                    const int16x8_t disty_ = vdupq_n_s16(disty);
+                    const int16x8_t idisty_ = vdupq_n_s16(idisty);
+                    const int16x8_t colorMask = vdupq_n_s16(0x00ff);
+
+                    lim -= 3;
+                    for (; f < lim; x += 4, f += 4) {
+                        // Load 4 pixels from s1, and split the alpha-green and red-blue component
+                        int16x8_t top = vld1q_s16((int16_t*)((const uint *)(s1)+x));
+                        int16x8_t topAG = vreinterpretq_s16_u16(vshrq_n_u16(vreinterpretq_u16_s16(top), 8));
+                        int16x8_t topRB = vandq_s16(top, colorMask);
+                        // Multiplies each colour component by idisty
+                        topAG = vmulq_s16(topAG, idisty_);
+                        topRB = vmulq_s16(topRB, idisty_);
+
+                        // Same for the s2 vector
+                        int16x8_t bottom = vld1q_s16((int16_t*)((const uint *)(s2)+x));
+                        int16x8_t bottomAG = vreinterpretq_s16_u16(vshrq_n_u16(vreinterpretq_u16_s16(bottom), 8));
+                        int16x8_t bottomRB = vandq_s16(bottom, colorMask);
+                        bottomAG = vmulq_s16(bottomAG, disty_);
+                        bottomRB = vmulq_s16(bottomRB, disty_);
+
+                        // Add the values, and shift to only keep 8 significant bits per colors
+                        int16x8_t rAG = vaddq_s16(topAG, bottomAG);
+                        rAG = vreinterpretq_s16_u16(vshrq_n_u16(vreinterpretq_u16_s16(rAG), 8));
+                        vst1q_s16((int16_t*)(&intermediate_buffer[1][f]), rAG);
+                        int16x8_t rRB = vaddq_s16(topRB, bottomRB);
+                        rRB = vreinterpretq_s16_u16(vshrq_n_u16(vreinterpretq_u16_s16(rRB), 8));
+                        vst1q_s16((int16_t*)(&intermediate_buffer[0][f]), rRB);
+                    }
+#endif
+                }
+                for (; f < count; f++) { // Same as above but without sse2
+                    if (blendType == BlendTransformedBilinearTiled) {
+                        if (x >= image_width) x -= image_width;
+                    } else {
+                        x = qMin(x, image_x2);
+                    }
+
+                    uint t = fetch(s1, x, data->texture.colorTable);
+                    uint b = fetch(s2, x, data->texture.colorTable);
+
+                    intermediate_buffer[0][f] = (((t & 0xff00ff) * idisty + (b & 0xff00ff) * disty) >> 8) & 0xff00ff;
+                    intermediate_buffer[1][f] = ((((t>>8) & 0xff00ff) * idisty + ((b>>8) & 0xff00ff) * disty) >> 8) & 0xff00ff;
+                    x++;
+                }
+                // Now interpolate the values from the intermediate_buffer to get the final result.
+                fx &= fixed_scale - 1;
+                Q_ASSERT((fx >> 16) == 0);
+                while (b < end) {
+                    register int x1 = (fx >> 16);
+                    register int x2 = x1 + 1;
+                    Q_ASSERT(x1 >= 0);
+                    Q_ASSERT(x2 < count);
+
+                    register int distx = (fx & 0x0000ffff) >> 8;
+                    register int idistx = 256 - distx;
+                    int rb = ((intermediate_buffer[0][x1] * idistx + intermediate_buffer[0][x2] * distx) >> 8) & 0xff00ff;
+                    int ag = (intermediate_buffer[1][x1] * idistx + intermediate_buffer[1][x2] * distx) & 0xff00ff00;
+                    *b = rb | ag;
+                    b++;
+                    fx += fdx;
+                }
+            } else if ((fdx < 0 && fdx > -(fixed_scale / 8)) || fabs(data->m22) < (1./8.)) { // scale up more than 8x
+                int y1 = (fy >> 16);
+                int y2;
+                fetchTransformedBilinear_pixelBounds<blendType>(image_height, image_y1, image_y2, y1, y2);
+                const uchar *s1 = data->texture.scanLine(y1);
+                const uchar *s2 = data->texture.scanLine(y2);
+                int disty = (fy & 0x0000ffff) >> 8;
+                int idisty = 256 - disty;
+                while (b < end) {
+                    int x1 = (fx >> 16);
+                    int x2;
+                    fetchTransformedBilinear_pixelBounds<blendType>(image_width, image_x1, image_x2, x1, x2);
+                    uint tl = fetch(s1, x1, data->texture.colorTable);
+                    uint tr = fetch(s1, x2, data->texture.colorTable);
+                    uint bl = fetch(s2, x1, data->texture.colorTable);
+                    uint br = fetch(s2, x2, data->texture.colorTable);
+
+                    int distx = (fx & 0x0000ffff) >> 8;
+                    int idistx = 256 - distx;
+
+                    uint xtop = INTERPOLATE_PIXEL_256(tl, idistx, tr, distx);
+                    uint xbot = INTERPOLATE_PIXEL_256(bl, idistx, br, distx);
+                    *b = INTERPOLATE_PIXEL_256(xtop, idisty, xbot, disty);
+
+                    fx += fdx;
+                    ++b;
+                }
+            } else { //scale down
+                int y1 = (fy >> 16);
+                int y2;
+                fetchTransformedBilinear_pixelBounds<blendType>(image_height, image_y1, image_y2, y1, y2);
+                const uchar *s1 = data->texture.scanLine(y1);
+                const uchar *s2 = data->texture.scanLine(y2);
+                int disty = (fy & 0x0000ffff) >> 12;
+
+                if (blendType != BlendTransformedBilinearTiled &&
+                    (format == QImage::Format_ARGB32_Premultiplied || format == QImage::Format_RGB32)) {
+
+#define BILINEAR_DOWNSCALE_BOUNDS_PROLOG \
+                    while (b < end) { \
+                        int x1 = (fx >> 16); \
+                        int x2; \
+                        fetchTransformedBilinear_pixelBounds<blendType>(image_width, image_x1, image_x2, x1, x2); \
+                        if (x1 != x2) \
+                            break; \
+                        uint tl = fetch(s1, x1, data->texture.colorTable); \
+                        uint tr = fetch(s1, x2, data->texture.colorTable); \
+                        uint bl = fetch(s2, x1, data->texture.colorTable); \
+                        uint br = fetch(s2, x2, data->texture.colorTable); \
+                        int distx = (fx & 0x0000ffff) >> 12; \
+                        *b = interpolate_4_pixels_16(tl, tr, bl, br, distx, disty); \
+                        fx += fdx; \
+                        ++b; \
+                    } \
+                    uint *boundedEnd; \
+                    if (fdx > 0) \
+                        boundedEnd = qMin(end, buffer + uint((image_x2 - (fx >> 16)) / data->m11)); \
+                    else \
+                        boundedEnd = qMin(end, buffer + uint((image_x1 - (fx >> 16)) / data->m11)); \
+                    boundedEnd -= 3;
+
+#if defined(QT_ALWAYS_HAVE_SSE2)
+                    BILINEAR_DOWNSCALE_BOUNDS_PROLOG
+
+                    const __m128i colorMask = _mm_set1_epi32(0x00ff00ff);
+                    const __m128i v_256 = _mm_set1_epi16(256);
+                    const __m128i v_disty = _mm_set1_epi16(disty);
+                    __m128i v_fdx = _mm_set1_epi32(fdx*4);
+
+                    ptrdiff_t secondLine = reinterpret_cast<const uint *>(s2) - reinterpret_cast<const uint *>(s1);
+
+                    union Vect_buffer { __m128i vect; quint32 i[4]; };
+                    Vect_buffer v_fx;
+
+                    for (int i = 0; i < 4; i++) {
+                        v_fx.i[i] = fx;
+                        fx += fdx;
+                    }
+
+                    while (b < boundedEnd) {
+
+                        Vect_buffer tl, tr, bl, br;
+
+                        for (int i = 0; i < 4; i++) {
+                            int x1 = v_fx.i[i] >> 16;
+                            const uint *addr_tl = reinterpret_cast<const uint *>(s1) + x1;
+                            const uint *addr_tr = addr_tl + 1;
+                            tl.i[i] = *addr_tl;
+                            tr.i[i] = *addr_tr;
+                            bl.i[i] = *(addr_tl+secondLine);
+                            br.i[i] = *(addr_tr+secondLine);
+                        }
+                        __m128i v_distx = _mm_srli_epi16(v_fx.vect, 12);
+                        v_distx = _mm_shufflehi_epi16(v_distx, _MM_SHUFFLE(2,2,0,0));
+                        v_distx = _mm_shufflelo_epi16(v_distx, _MM_SHUFFLE(2,2,0,0));
+
+                        interpolate_4_pixels_16_sse2(tl.vect, tr.vect, bl.vect, br.vect, v_distx, v_disty, colorMask, v_256, b);
+                        b+=4;
+                        v_fx.vect = _mm_add_epi32(v_fx.vect, v_fdx);
+                    }
+                    fx = v_fx.i[0];
+#elif defined(QT_ALWAYS_HAVE_NEON)
+                    BILINEAR_DOWNSCALE_BOUNDS_PROLOG
+
+                    const int16x8_t colorMask = vdupq_n_s16(0x00ff);
+                    const int16x8_t invColorMask = vmvnq_s16(colorMask);
+                    const int16x8_t v_256 = vdupq_n_s16(256);
+                    const int16x8_t v_disty = vdupq_n_s16(disty);
+                    const int16x8_t v_disty_ = vshlq_n_s16(v_disty, 4);
+                    int32x4_t v_fdx = vdupq_n_s32(fdx*4);
+
+                    ptrdiff_t secondLine = reinterpret_cast<const uint *>(s2) - reinterpret_cast<const uint *>(s1);
+
+                    union Vect_buffer { int32x4_t vect; quint32 i[4]; };
+                    Vect_buffer v_fx;
+
+                    for (int i = 0; i < 4; i++) {
+                        v_fx.i[i] = fx;
+                        fx += fdx;
+                    }
+
+                    const int32x4_t v_ffff_mask = vdupq_n_s32(0x0000ffff);
+
+                    while (b < boundedEnd) {
+
+                        Vect_buffer tl, tr, bl, br;
+
+                        Vect_buffer v_fx_shifted;
+                        v_fx_shifted.vect = vshrq_n_s32(v_fx.vect, 16);
+
+                        int32x4_t v_distx = vshrq_n_s32(vandq_s32(v_fx.vect, v_ffff_mask), 12);
+
+                        for (int i = 0; i < 4; i++) {
+                            int x1 = v_fx_shifted.i[i];
+                            const uint *addr_tl = reinterpret_cast<const uint *>(s1) + x1;
+                            const uint *addr_tr = addr_tl + 1;
+                            tl.i[i] = *addr_tl;
+                            tr.i[i] = *addr_tr;
+                            bl.i[i] = *(addr_tl+secondLine);
+                            br.i[i] = *(addr_tr+secondLine);
+                        }
+
+                        v_distx = vorrq_s32(v_distx, vshlq_n_s32(v_distx, 16));
+
+                        interpolate_4_pixels_16_neon(vreinterpretq_s16_s32(tl.vect), vreinterpretq_s16_s32(tr.vect), vreinterpretq_s16_s32(bl.vect), vreinterpretq_s16_s32(br.vect), vreinterpretq_s16_s32(v_distx), v_disty, v_disty_, colorMask, invColorMask, v_256, b);
+                        b+=4;
+                        v_fx.vect = vaddq_s32(v_fx.vect, v_fdx);
+                    }
+                    fx = v_fx.i[0];
+#endif
+                }
+
+                while (b < end) {
+                    int x1 = (fx >> 16);
+                    int x2;
+                    fetchTransformedBilinear_pixelBounds<blendType>(image_width, image_x1, image_x2, x1, x2);
+                    uint tl = fetch(s1, x1, data->texture.colorTable);
+                    uint tr = fetch(s1, x2, data->texture.colorTable);
+                    uint bl = fetch(s2, x1, data->texture.colorTable);
+                    uint br = fetch(s2, x2, data->texture.colorTable);
+                    int distx = (fx & 0x0000ffff) >> 12;
+                    *b = interpolate_4_pixels_16(tl, tr, bl, br, distx, disty);
+                    fx += fdx;
+                    ++b;
+                }
+            }
+        } else { //rotation
+            if (fabs(data->m11) > 8 || fabs(data->m22) > 8) {
+                //if we are zooming more than 8 times, we use 8bit precision for the position.
+                while (b < end) {
+                    int x1 = (fx >> 16);
+                    int x2;
+                    int y1 = (fy >> 16);
+                    int y2;
+
+                    fetchTransformedBilinear_pixelBounds<blendType>(image_width, image_x1, image_x2, x1, x2);
+                    fetchTransformedBilinear_pixelBounds<blendType>(image_height, image_y1, image_y2, y1, y2);
+
+                    const uchar *s1 = data->texture.scanLine(y1);
+                    const uchar *s2 = data->texture.scanLine(y2);
+
+                    uint tl = fetch(s1, x1, data->texture.colorTable);
+                    uint tr = fetch(s1, x2, data->texture.colorTable);
+                    uint bl = fetch(s2, x1, data->texture.colorTable);
+                    uint br = fetch(s2, x2, data->texture.colorTable);
+
+                    int distx = (fx & 0x0000ffff) >> 8;
+                    int disty = (fy & 0x0000ffff) >> 8;
+                    int idistx = 256 - distx;
+                    int idisty = 256 - disty;
+
+                    uint xtop = INTERPOLATE_PIXEL_256(tl, idistx, tr, distx);
+                    uint xbot = INTERPOLATE_PIXEL_256(bl, idistx, br, distx);
+                    *b = INTERPOLATE_PIXEL_256(xtop, idisty, xbot, disty);
+
+                    fx += fdx;
+                    fy += fdy;
+                    ++b;
+                }
+            } else {
+                //we are zooming less than 8x, use 4bit precision
+                while (b < end) {
+                    int x1 = (fx >> 16);
+                    int x2;
+                    int y1 = (fy >> 16);
+                    int y2;
+
+                    fetchTransformedBilinear_pixelBounds<blendType>(image_width, image_x1, image_x2, x1, x2);
+                    fetchTransformedBilinear_pixelBounds<blendType>(image_height, image_y1, image_y2, y1, y2);
+
+                    const uchar *s1 = data->texture.scanLine(y1);
+                    const uchar *s2 = data->texture.scanLine(y2);
+
+                    uint tl = fetch(s1, x1, data->texture.colorTable);
+                    uint tr = fetch(s1, x2, data->texture.colorTable);
+                    uint bl = fetch(s2, x1, data->texture.colorTable);
+                    uint br = fetch(s2, x2, data->texture.colorTable);
+
+                    int distx = (fx & 0x0000ffff) >> 12;
+                    int disty = (fy & 0x0000ffff) >> 12;
+
+                    *b = interpolate_4_pixels_16(tl, tr, bl, br, distx, disty);
+
+                    fx += fdx;
+                    fy += fdy;
+                    ++b;
+                }
+            }
+        }
+    } else {
+        const qreal fdx = data->m11;
+        const qreal fdy = data->m12;
+        const qreal fdw = data->m13;
+
+        qreal fx = data->m21 * cy + data->m11 * cx + data->dx;
+        qreal fy = data->m22 * cy + data->m12 * cx + data->dy;
+        qreal fw = data->m23 * cy + data->m13 * cx + data->m33;
+
+        while (b < end) {
+            const qreal iw = fw == 0 ? 1 : 1 / fw;
+            const qreal px = fx * iw - qreal(0.5);
+            const qreal py = fy * iw - qreal(0.5);
+
+            int x1 = int(px) - (px < 0);
+            int x2;
+            int y1 = int(py) - (py < 0);
+            int y2;
+
+            int distx = int((px - x1) * 256);
+            int disty = int((py - y1) * 256);
+            int idistx = 256 - distx;
+            int idisty = 256 - disty;
+
+            fetchTransformedBilinear_pixelBounds<blendType>(image_width, image_x1, image_x2, x1, x2);
+            fetchTransformedBilinear_pixelBounds<blendType>(image_height, image_y1, image_y2, y1, y2);
+
+            const uchar *s1 = data->texture.scanLine(y1);
+            const uchar *s2 = data->texture.scanLine(y2);
+
+            uint tl = fetch(s1, x1, data->texture.colorTable);
+            uint tr = fetch(s1, x2, data->texture.colorTable);
+            uint bl = fetch(s2, x1, data->texture.colorTable);
+            uint br = fetch(s2, x2, data->texture.colorTable);
+
+            uint xtop = INTERPOLATE_PIXEL_256(tl, idistx, tr, distx);
+            uint xbot = INTERPOLATE_PIXEL_256(bl, idistx, br, distx);
+            *b = INTERPOLATE_PIXEL_256(xtop, idisty, xbot, disty);
+
+            fx += fdx;
+            fy += fdy;
+            fw += fdw;
+            //force increment to avoid /0
+            if (!fw) {
+                fw += fdw;
+            }
+            ++b;
+        }
+    }
+
+    return buffer;
+}
+
+#define SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Arg) qt_fetchUntransformed<QImage::Arg>
+
+static const SourceFetchProc sourceFetch[NBlendTypes][QImage::NImageFormats] = {
+    // Untransformed
+    {
+        0, // Invalid
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_Mono),   // Mono
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_MonoLSB),   // MonoLsb
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_Indexed8),   // Indexed8
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_ARGB32_Premultiplied),   // RGB32
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_ARGB32),   // ARGB32
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_ARGB32_Premultiplied),   // ARGB32_Premultiplied
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_RGB16),   // RGB16
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_ARGB8565_Premultiplied),// ARGB8565_Premultiplied
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_RGB666),  // RGB666
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_ARGB6666_Premultiplied),// ARGB6666_Premultiplied
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_RGB555),  // RGB555
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_ARGB8555_Premultiplied),// ARGB8555_Premultiplied
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_RGB888),  // RGB888
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_RGB444),  // RGB444
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_ARGB4444_Premultiplied) // ARGB4444_Premultiplied
+    },
+    // Tiled
+    {
+        0, // Invalid
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_Mono),   // Mono
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_MonoLSB),   // MonoLsb
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_Indexed8),   // Indexed8
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_ARGB32_Premultiplied),   // RGB32
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_ARGB32),   // ARGB32
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_ARGB32_Premultiplied),   // ARGB32_Premultiplied
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_RGB16),   // RGB16
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_ARGB8565_Premultiplied),// ARGB8565_Premultiplied
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_RGB666),  // RGB666
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_ARGB6666_Premultiplied),// ARGB6666_Premultiplied
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_RGB555),  // RGB555
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_ARGB8555_Premultiplied),// ARGB8555_Premultiplied
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_RGB888),  // RGB888
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_RGB444),  // RGB444
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_ARGB4444_Premultiplied) // ARGB4444_Premultiplied
+    },
+    // Transformed
+    {
+        0, // Invalid
+        fetchTransformed<BlendTransformed>,   // Mono
+        fetchTransformed<BlendTransformed>,   // MonoLsb
+        fetchTransformed<BlendTransformed>,   // Indexed8
+        fetchTransformed<BlendTransformed>,   // RGB32
+        fetchTransformed<BlendTransformed>,   // ARGB32
+        fetchTransformed<BlendTransformed>,   // ARGB32_Premultiplied
+        fetchTransformed<BlendTransformed>,   // RGB16
+        fetchTransformed<BlendTransformed>,   // ARGB8565_Premultiplied
+        fetchTransformed<BlendTransformed>,   // RGB666
+        fetchTransformed<BlendTransformed>,   // ARGB6666_Premultiplied
+        fetchTransformed<BlendTransformed>,   // RGB555
+        fetchTransformed<BlendTransformed>,   // ARGB8555_Premultiplied
+        fetchTransformed<BlendTransformed>,   // RGB888
+        fetchTransformed<BlendTransformed>,   // RGB444
+        fetchTransformed<BlendTransformed>,   // ARGB4444_Premultiplied
+    },
+    {
+        0, // TransformedTiled
+        fetchTransformed<BlendTransformedTiled>,   // Mono
+        fetchTransformed<BlendTransformedTiled>,   // MonoLsb
+        fetchTransformed<BlendTransformedTiled>,   // Indexed8
+        fetchTransformed<BlendTransformedTiled>,   // RGB32
+        fetchTransformed<BlendTransformedTiled>,   // ARGB32
+        fetchTransformed<BlendTransformedTiled>,   // ARGB32_Premultiplied
+        fetchTransformed<BlendTransformedTiled>,   // RGB16
+        fetchTransformed<BlendTransformedTiled>,   // ARGB8565_Premultiplied
+        fetchTransformed<BlendTransformedTiled>,   // RGB666
+        fetchTransformed<BlendTransformedTiled>,   // ARGB6666_Premultiplied
+        fetchTransformed<BlendTransformedTiled>,   // RGB555
+        fetchTransformed<BlendTransformedTiled>,   // ARGB8555_Premultiplied
+        fetchTransformed<BlendTransformedTiled>,   // RGB888
+        fetchTransformed<BlendTransformedTiled>,   // RGB444
+        fetchTransformed<BlendTransformedTiled>,   // ARGB4444_Premultiplied
+    },
+    {
+        0, // Bilinear
+        fetchTransformedBilinear<BlendTransformedBilinear, QImage::Format_Invalid>,   // Mono
+        fetchTransformedBilinear<BlendTransformedBilinear, QImage::Format_Invalid>,   // MonoLsb
+        fetchTransformedBilinear<BlendTransformedBilinear, QImage::Format_Invalid>,   // Indexed8
+        fetchTransformedBilinear<BlendTransformedBilinear, QImage::Format_ARGB32_Premultiplied>,   // RGB32
+        fetchTransformedBilinear<BlendTransformedBilinear, QImage::Format_ARGB32>,   // ARGB32
+        fetchTransformedBilinear<BlendTransformedBilinear, QImage::Format_ARGB32_Premultiplied>,   // ARGB32_Premultiplied
+        fetchTransformedBilinear<BlendTransformedBilinear, QImage::Format_Invalid>,   // RGB16
+        fetchTransformedBilinear<BlendTransformedBilinear, QImage::Format_Invalid>,   // ARGB8565_Premultiplied
+        fetchTransformedBilinear<BlendTransformedBilinear, QImage::Format_Invalid>,   // RGB666
+        fetchTransformedBilinear<BlendTransformedBilinear, QImage::Format_Invalid>,   // ARGB6666_Premultiplied
+        fetchTransformedBilinear<BlendTransformedBilinear, QImage::Format_Invalid>,   // RGB555
+        fetchTransformedBilinear<BlendTransformedBilinear, QImage::Format_Invalid>,   // ARGB8555_Premultiplied
+        fetchTransformedBilinear<BlendTransformedBilinear, QImage::Format_Invalid>,   // RGB888
+        fetchTransformedBilinear<BlendTransformedBilinear, QImage::Format_Invalid>,   // RGB444
+        fetchTransformedBilinear<BlendTransformedBilinear, QImage::Format_Invalid>    // ARGB4444_Premultiplied
+    },
+    {
+        0, // BilinearTiled
+        fetchTransformedBilinear<BlendTransformedBilinearTiled, QImage::Format_Invalid>,   // Mono
+        fetchTransformedBilinear<BlendTransformedBilinearTiled, QImage::Format_Invalid>,   // MonoLsb
+        fetchTransformedBilinear<BlendTransformedBilinearTiled, QImage::Format_Invalid>,   // Indexed8
+        fetchTransformedBilinear<BlendTransformedBilinearTiled, QImage::Format_ARGB32_Premultiplied>,   // RGB32
+        fetchTransformedBilinear<BlendTransformedBilinearTiled, QImage::Format_ARGB32>,   // ARGB32
+        fetchTransformedBilinear<BlendTransformedBilinearTiled, QImage::Format_ARGB32_Premultiplied>,   // ARGB32_Premultiplied
+        fetchTransformedBilinear<BlendTransformedBilinearTiled, QImage::Format_Invalid>,   // RGB16
+        fetchTransformedBilinear<BlendTransformedBilinearTiled, QImage::Format_Invalid>,   // ARGB8565_Premultiplied
+        fetchTransformedBilinear<BlendTransformedBilinearTiled, QImage::Format_Invalid>,   // RGB666
+        fetchTransformedBilinear<BlendTransformedBilinearTiled, QImage::Format_Invalid>,   // ARGB6666_Premultiplied
+        fetchTransformedBilinear<BlendTransformedBilinearTiled, QImage::Format_Invalid>,   // RGB555
+        fetchTransformedBilinear<BlendTransformedBilinearTiled, QImage::Format_Invalid>,   // ARGB8555_Premultiplied
+        fetchTransformedBilinear<BlendTransformedBilinearTiled, QImage::Format_Invalid>,   // RGB888
+        fetchTransformedBilinear<BlendTransformedBilinearTiled, QImage::Format_Invalid>,   // RGB444
+        fetchTransformedBilinear<BlendTransformedBilinearTiled, QImage::Format_Invalid>    // ARGB4444_Premultiplied
+    },
+};
+
+
+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];
+}
+
+static void QT_FASTCALL getLinearGradientValues(LinearGradientValues *v, const QSpanData *data)
+{
+    v->dx = data->gradient.linear.end.x - data->gradient.linear.origin.x;
+    v->dy = data->gradient.linear.end.y - data->gradient.linear.origin.y;
+    v->l = v->dx * v->dx + v->dy * v->dy;
+    v->off = 0;
+    if (v->l != 0) {
+        v->dx /= v->l;
+        v->dy /= v->l;
+        v->off = -v->dx * data->gradient.linear.origin.x - v->dy * data->gradient.linear.origin.y;
+    }
+}
+
+static const uint * QT_FASTCALL fetchLinearGradient(uint *buffer, const Operator *op, const QSpanData *data,
+                                                    int y, int x, int length)
+{
+    const uint *b = buffer;
+    qreal t, inc;
+
+    bool affine = true;
+    qreal rx=0, ry=0;
+    if (op->linear.l == 0) {
+        t = inc = 0;
+    } else {
+        rx = data->m21 * (y + qreal(0.5)) + data->m11 * (x + qreal(0.5)) + data->dx;
+        ry = data->m22 * (y + qreal(0.5)) + data->m12 * (x + qreal(0.5)) + data->dy;
+        t = op->linear.dx*rx + op->linear.dy*ry + op->linear.off;
+        inc = op->linear.dx * data->m11 + op->linear.dy * data->m12;
+        affine = !data->m13 && !data->m23;
+
+        if (affine) {
+            t *= (GRADIENT_STOPTABLE_SIZE - 1);
+            inc *= (GRADIENT_STOPTABLE_SIZE - 1);
+        }
+    }
+
+    const uint *end = buffer + length;
+    if (affine) {
+        if (inc > qreal(-1e-5) && inc < qreal(1e-5)) {
+            QT_MEMFILL_UINT(buffer, length, qt_gradient_pixel_fixed(&data->gradient, int(t * FIXPT_SIZE)));
+        } else {
+            if (t+inc*length < qreal(INT_MAX >> (FIXPT_BITS + 1)) &&
+                t+inc*length > qreal(INT_MIN >> (FIXPT_BITS + 1))) {
+                // we can use fixed point math
+                int t_fixed = int(t * FIXPT_SIZE);
+                int inc_fixed = int(inc * FIXPT_SIZE);
+                while (buffer < end) {
+                    *buffer = qt_gradient_pixel_fixed(&data->gradient, t_fixed);
+                    t_fixed += inc_fixed;
+                    ++buffer;
+                }
+            } else {
+                // we have to fall back to float math
+                while (buffer < end) {
+                    *buffer = qt_gradient_pixel(&data->gradient, t/GRADIENT_STOPTABLE_SIZE);
+                    t += inc;
+                    ++buffer;
+                }
+            }
+        }
+    } else { // fall back to float math here as well
+        qreal rw = data->m23 * (y + qreal(0.5)) + data->m13 * (x + qreal(0.5)) + data->m33;
+        while (buffer < end) {
+            qreal x = rx/rw;
+            qreal y = ry/rw;
+            t = (op->linear.dx*x + op->linear.dy *y) + op->linear.off;
+
+            *buffer = qt_gradient_pixel(&data->gradient, t);
+            rx += data->m11;
+            ry += data->m12;
+            rw += data->m13;
+            if (!rw) {
+                rw += data->m13;
+            }
+            ++buffer;
+        }
+    }
+
+    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;
+
+        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 * 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;
+
+        while (buffer < end) {
+            *buffer = qt_gradient_pixel(&data->gradient, qSafeSqrt(det) - 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);
+
+            rx += data->m11;
+            ry += data->m12;
+            rw += data->m13;
+            if (!rw) {
+                rw += data->m13;
+            }
+            ++buffer;
+        }
+    }
+
+    return b;
+}
+
+static const uint * QT_FASTCALL fetchConicalGradient(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))
+               + 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;
+
+    const uint *end = buffer + length;
+    if (affine) {
+        rx -= data->gradient.conical.center.x;
+        ry -= data->gradient.conical.center.y;
+        while (buffer < end) {
+            qreal angle = qAtan2(ry, rx) + data->gradient.conical.angle;
+
+            *buffer = qt_gradient_pixel(&data->gradient, 1 - angle / (2*Q_PI));
+
+            rx += data->m11;
+            ry += data->m12;
+            ++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 angle = qAtan2(ry/rw - data->gradient.conical.center.x,
+                                rx/rw - data->gradient.conical.center.y)
+                          + data->gradient.conical.angle;
+
+            *buffer = qt_gradient_pixel(&data->gradient, 1. - angle / (2*Q_PI));
+
+            rx += data->m11;
+            ry += data->m12;
+            rw += data->m13;
+            if (!rw) {
+                rw += data->m13;
+            }
+            ++buffer;
+        }
+    }
+    return b;
+}
+
+#if defined(Q_CC_RVCT)
+// Force ARM code generation for comp_func_* -methods
+#  pragma push
+#  pragma arm
+#  if defined(QT_HAVE_ARMV6)
+static __forceinline void preload(const uint *start)
+{
+    asm( "pld [start]" );
+}
+static const uint L2CacheLineLength = 32;
+static const uint L2CacheLineLengthInInts = L2CacheLineLength/sizeof(uint);
+#    define PRELOAD_INIT(x) preload(x);
+#    define PRELOAD_INIT2(x,y) PRELOAD_INIT(x) PRELOAD_INIT(y)
+#    define PRELOAD_COND(x) if (((uint)&x[i])%L2CacheLineLength == 0) preload(&x[i] + L2CacheLineLengthInInts);
+// Two consecutive preloads stall, so space them out a bit by using different modulus.
+#    define PRELOAD_COND2(x,y) if (((uint)&x[i])%L2CacheLineLength == 0) preload(&x[i] + L2CacheLineLengthInInts); \
+         if (((uint)&y[i])%L2CacheLineLength == 16) preload(&y[i] + L2CacheLineLengthInInts);
+#  endif // QT_HAVE_ARMV6
+#endif // Q_CC_RVCT
+
+#if !defined(Q_CC_RVCT) || !defined(QT_HAVE_ARMV6)
+#    define PRELOAD_INIT(x)
+#    define PRELOAD_INIT2(x,y)
+#    define PRELOAD_COND(x)
+#    define PRELOAD_COND2(x,y)
+#endif
+
+/* The constant alpha factor describes an alpha factor that gets applied
+   to the result of the composition operation combining it with the destination.
+
+   The intent is that if const_alpha == 0. we get back dest, and if const_alpha == 1.
+   we get the unmodified operation
+
+   result = src op dest
+   dest = result * const_alpha + dest * (1. - const_alpha)
+
+   This means that in the comments below, the first line is the const_alpha==255 case, the
+   second line the general one.
+
+   In the lines below:
+   s == src, sa == alpha(src), sia = 1 - alpha(src)
+   d == dest, da == alpha(dest), dia = 1 - alpha(dest)
+   ca = const_alpha, cia = 1 - const_alpha
+
+   The methods exist in two variants. One where we have a constant source, the other
+   where the source is an array of pixels.
+*/
+
+/*
+  result = 0
+  d = d * cia
+*/
+#define comp_func_Clear_impl(dest, length, const_alpha)\
+{\
+    if (const_alpha == 255) {\
+        QT_MEMFILL_UINT(dest, length, 0);\
+    } else {\
+        int ialpha = 255 - const_alpha;\
+        PRELOAD_INIT(dest)\
+        for (int i = 0; i < length; ++i) {\
+            PRELOAD_COND(dest)\
+            dest[i] = BYTE_MUL(dest[i], ialpha);\
+        }\
+    }\
+}
+
+void QT_FASTCALL comp_func_solid_Clear(uint *dest, int length, uint, uint const_alpha)
+{
+    comp_func_Clear_impl(dest, length, const_alpha);
+}
+
+void QT_FASTCALL comp_func_Clear(uint *dest, const uint *, int length, uint const_alpha)
+{
+    comp_func_Clear_impl(dest, length, const_alpha);
+}
+
+/*
+  result = s
+  dest = s * ca + d * cia
+*/
+void QT_FASTCALL comp_func_solid_Source(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha == 255) {
+        QT_MEMFILL_UINT(dest, length, color);
+    } else {
+        int ialpha = 255 - const_alpha;
+        color = BYTE_MUL(color, const_alpha);
+        PRELOAD_INIT(dest)
+        for (int i = 0; i < length; ++i) {
+            PRELOAD_COND(dest)
+            dest[i] = color + BYTE_MUL(dest[i], ialpha);
+        }
+    }
+}
+
+void QT_FASTCALL comp_func_Source(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    if (const_alpha == 255) {
+        ::memcpy(dest, src, length * sizeof(uint));
+    } else {
+        int ialpha = 255 - const_alpha;
+        PRELOAD_INIT2(dest, src)
+        for (int i = 0; i < length; ++i) {
+            PRELOAD_COND2(dest, src)
+            dest[i] = INTERPOLATE_PIXEL_255(src[i], const_alpha, dest[i], ialpha);
+        }
+    }
+}
+
+void QT_FASTCALL comp_func_solid_Destination(uint *, int, uint, uint)
+{
+}
+
+void QT_FASTCALL comp_func_Destination(uint *, const uint *, int, uint)
+{
+}
+
+/*
+  result = s + d * sia
+  dest = (s + d * sia) * ca + d * cia
+       = s * ca + d * (sia * ca + cia)
+       = s * ca + d * (1 - sa*ca)
+*/
+void QT_FASTCALL comp_func_solid_SourceOver(uint *dest, int length, uint color, uint const_alpha)
+{
+    if ((const_alpha & qAlpha(color)) == 255) {
+        QT_MEMFILL_UINT(dest, length, color);
+    } else {
+        if (const_alpha != 255)
+            color = BYTE_MUL(color, const_alpha);
+        PRELOAD_INIT(dest)
+        for (int i = 0; i < length; ++i) {
+            PRELOAD_COND(dest)
+            dest[i] = color + BYTE_MUL(dest[i], qAlpha(~color));
+        }
+    }
+}
+
+void QT_FASTCALL comp_func_SourceOver(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    PRELOAD_INIT2(dest, src)
+    if (const_alpha == 255) {
+        for (int i = 0; i < length; ++i) {
+            PRELOAD_COND2(dest, src)
+            uint s = src[i];
+            if (s >= 0xff000000)
+                dest[i] = s;
+            else if (s != 0)
+                dest[i] = s + BYTE_MUL(dest[i], qAlpha(~s));
+        }
+    } else {
+        for (int i = 0; i < length; ++i) {
+            PRELOAD_COND2(dest, src)
+            uint s = BYTE_MUL(src[i], const_alpha);
+            dest[i] = s + BYTE_MUL(dest[i], qAlpha(~s));
+        }
+    }
+}
+
+/*
+  result = d + s * dia
+  dest = (d + s * dia) * ca + d * cia
+       = d + s * dia * ca
+*/
+void QT_FASTCALL comp_func_solid_DestinationOver(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha != 255)
+        color = BYTE_MUL(color, const_alpha);
+    PRELOAD_INIT(dest)
+    for (int i = 0; i < length; ++i) {
+        PRELOAD_COND(dest)
+        uint d = dest[i];
+        dest[i] = d + BYTE_MUL(color, qAlpha(~d));
+    }
+}
+
+void QT_FASTCALL comp_func_DestinationOver(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    PRELOAD_INIT2(dest, src)
+    if (const_alpha == 255) {
+        for (int i = 0; i < length; ++i) {
+            PRELOAD_COND2(dest, src)
+            uint d = dest[i];
+            dest[i] = d + BYTE_MUL(src[i], qAlpha(~d));
+        }
+    } else {
+        for (int i = 0; i < length; ++i) {
+            PRELOAD_COND2(dest, src)
+            uint d = dest[i];
+            uint s = BYTE_MUL(src[i], const_alpha);
+            dest[i] = d + BYTE_MUL(s, qAlpha(~d));
+        }
+    }
+}
+
+/*
+  result = s * da
+  dest = s * da * ca + d * cia
+*/
+void QT_FASTCALL comp_func_solid_SourceIn(uint *dest, int length, uint color, uint const_alpha)
+{
+    PRELOAD_INIT(dest)
+    if (const_alpha == 255) {
+        for (int i = 0; i < length; ++i) {
+            PRELOAD_COND(dest)
+            dest[i] = BYTE_MUL(color, qAlpha(dest[i]));
+        }
+    } else {
+        color = BYTE_MUL(color, const_alpha);
+        uint cia = 255 - const_alpha;
+        for (int i = 0; i < length; ++i) {
+            PRELOAD_COND(dest)
+            uint d = dest[i];
+            dest[i] = INTERPOLATE_PIXEL_255(color, qAlpha(d), d, cia);
+        }
+    }
+}
+
+void QT_FASTCALL comp_func_SourceIn(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    PRELOAD_INIT2(dest, src)
+    if (const_alpha == 255) {
+        for (int i = 0; i < length; ++i) {
+            PRELOAD_COND2(dest, src)
+            dest[i] = BYTE_MUL(src[i], qAlpha(dest[i]));
+        }
+    } else {
+        uint cia = 255 - const_alpha;
+        for (int i = 0; i < length; ++i) {
+            PRELOAD_COND2(dest, src)
+            uint d = dest[i];
+            uint s = BYTE_MUL(src[i], const_alpha);
+            dest[i] = INTERPOLATE_PIXEL_255(s, qAlpha(d), d, cia);
+        }
+    }
+}
+
+/*
+  result = d * sa
+  dest = d * sa * ca + d * cia
+       = d * (sa * ca + cia)
+*/
+void QT_FASTCALL comp_func_solid_DestinationIn(uint *dest, int length, uint color, uint const_alpha)
+{
+    uint a = qAlpha(color);
+    if (const_alpha != 255) {
+        a = BYTE_MUL(a, const_alpha) + 255 - const_alpha;
+    }
+    PRELOAD_INIT(dest)
+    for (int i = 0; i < length; ++i) {
+        PRELOAD_COND(dest)
+        dest[i] = BYTE_MUL(dest[i], a);
+    }
+}
+
+void QT_FASTCALL comp_func_DestinationIn(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    PRELOAD_INIT2(dest, src)
+    if (const_alpha == 255) {
+        for (int i = 0; i < length; ++i) {
+            PRELOAD_COND2(dest, src)
+            dest[i] = BYTE_MUL(dest[i], qAlpha(src[i]));
+        }
+    } else {
+        int cia = 255 - const_alpha;
+        for (int i = 0; i < length; ++i) {
+            PRELOAD_COND2(dest, src)
+            uint a = BYTE_MUL(qAlpha(src[i]), const_alpha) + cia;
+            dest[i] = BYTE_MUL(dest[i], a);
+        }
+    }
+}
+
+/*
+  result = s * dia
+  dest = s * dia * ca + d * cia
+*/
+
+void QT_FASTCALL comp_func_solid_SourceOut(uint *dest, int length, uint color, uint const_alpha)
+{
+    PRELOAD_INIT(dest)
+    if (const_alpha == 255) {
+        for (int i = 0; i < length; ++i) {
+            PRELOAD_COND(dest)
+            dest[i] = BYTE_MUL(color, qAlpha(~dest[i]));
+        }
+    } else {
+        color = BYTE_MUL(color, const_alpha);
+        int cia = 255 - const_alpha;
+        for (int i = 0; i < length; ++i) {
+            PRELOAD_COND(dest)
+            uint d = dest[i];
+            dest[i] = INTERPOLATE_PIXEL_255(color, qAlpha(~d), d, cia);
+        }
+    }
+}
+
+void QT_FASTCALL comp_func_SourceOut(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    PRELOAD_INIT2(dest, src)
+    if (const_alpha == 255) {
+        for (int i = 0; i < length; ++i) {
+            PRELOAD_COND2(dest, src)
+            dest[i] = BYTE_MUL(src[i], qAlpha(~dest[i]));
+        }
+    } else {
+        int cia = 255 - const_alpha;
+        for (int i = 0; i < length; ++i) {
+            PRELOAD_COND2(dest, src)
+            uint s = BYTE_MUL(src[i], const_alpha);
+            uint d = dest[i];
+            dest[i] = INTERPOLATE_PIXEL_255(s, qAlpha(~d), d, cia);
+        }
+    }
+}
+
+/*
+  result = d * sia
+  dest = d * sia * ca + d * cia
+       = d * (sia * ca + cia)
+*/
+void QT_FASTCALL comp_func_solid_DestinationOut(uint *dest, int length, uint color, uint const_alpha)
+{
+    uint a = qAlpha(~color);
+    if (const_alpha != 255)
+        a = BYTE_MUL(a, const_alpha) + 255 - const_alpha;
+    PRELOAD_INIT(dest)
+    for (int i = 0; i < length; ++i) {
+        PRELOAD_COND(dest)
+        dest[i] = BYTE_MUL(dest[i], a);
+    }
+}
+
+void QT_FASTCALL comp_func_DestinationOut(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    PRELOAD_INIT2(dest, src)
+    if (const_alpha == 255) {
+        for (int i = 0; i < length; ++i) {
+            PRELOAD_COND2(dest, src)
+            dest[i] = BYTE_MUL(dest[i], qAlpha(~src[i]));
+        }
+    } else {
+        int cia = 255 - const_alpha;
+        for (int i = 0; i < length; ++i) {
+            PRELOAD_COND2(dest, src)
+            uint sia = BYTE_MUL(qAlpha(~src[i]), const_alpha) + cia;
+            dest[i] = BYTE_MUL(dest[i], sia);
+        }
+    }
+}
+
+/*
+  result = s*da + d*sia
+  dest = s*da*ca + d*sia*ca + d *cia
+       = s*ca * da + d * (sia*ca + cia)
+       = s*ca * da + d * (1 - sa*ca)
+*/
+void QT_FASTCALL comp_func_solid_SourceAtop(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha != 255) {
+        color = BYTE_MUL(color, const_alpha);
+    }
+    uint sia = qAlpha(~color);
+    PRELOAD_INIT(dest)
+    for (int i = 0; i < length; ++i) {
+        PRELOAD_COND(dest)
+        dest[i] = INTERPOLATE_PIXEL_255(color, qAlpha(dest[i]), dest[i], sia);
+    }
+}
+
+void QT_FASTCALL comp_func_SourceAtop(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    PRELOAD_INIT2(dest, src)
+    if (const_alpha == 255) {
+        for (int i = 0; i < length; ++i) {
+            PRELOAD_COND2(dest, src)
+            uint s = src[i];
+            uint d = dest[i];
+            dest[i] = INTERPOLATE_PIXEL_255(s, qAlpha(d), d, qAlpha(~s));
+        }
+    } else {
+        for (int i = 0; i < length; ++i) {
+            PRELOAD_COND2(dest, src)
+            uint s = BYTE_MUL(src[i], const_alpha);
+            uint d = dest[i];
+            dest[i] = INTERPOLATE_PIXEL_255(s, qAlpha(d), d, qAlpha(~s));
+        }
+    }
+}
+
+/*
+  result = d*sa + s*dia
+  dest = d*sa*ca + s*dia*ca + d *cia
+       = s*ca * dia + d * (sa*ca + cia)
+*/
+void QT_FASTCALL comp_func_solid_DestinationAtop(uint *dest, int length, uint color, uint const_alpha)
+{
+    uint a = qAlpha(color);
+    if (const_alpha != 255) {
+        color = BYTE_MUL(color, const_alpha);
+        a = qAlpha(color) + 255 - const_alpha;
+    }
+    PRELOAD_INIT(dest)
+    for (int i = 0; i < length; ++i) {
+        PRELOAD_COND(dest)
+        uint d = dest[i];
+        dest[i] = INTERPOLATE_PIXEL_255(d, a, color, qAlpha(~d));
+    }
+}
+
+void QT_FASTCALL comp_func_DestinationAtop(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    PRELOAD_INIT2(dest, src)
+    if (const_alpha == 255) {
+        for (int i = 0; i < length; ++i) {
+            PRELOAD_COND2(dest, src)
+            uint s = src[i];
+            uint d = dest[i];
+            dest[i] = INTERPOLATE_PIXEL_255(d, qAlpha(s), s, qAlpha(~d));
+        }
+    } else {
+        int cia = 255 - const_alpha;
+        for (int i = 0; i < length; ++i) {
+            PRELOAD_COND2(dest, src)
+            uint s = BYTE_MUL(src[i], const_alpha);
+            uint d = dest[i];
+            uint a = qAlpha(s) + cia;
+            dest[i] = INTERPOLATE_PIXEL_255(d, a, s, qAlpha(~d));
+        }
+    }
+}
+
+/*
+  result = d*sia + s*dia
+  dest = d*sia*ca + s*dia*ca + d *cia
+       = s*ca * dia + d * (sia*ca + cia)
+       = s*ca * dia + d * (1 - sa*ca)
+*/
+void QT_FASTCALL comp_func_solid_XOR(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha != 255)
+        color = BYTE_MUL(color, const_alpha);
+    uint sia = qAlpha(~color);
+
+    PRELOAD_INIT(dest)
+    for (int i = 0; i < length; ++i) {
+        PRELOAD_COND(dest)
+        uint d = dest[i];
+        dest[i] = INTERPOLATE_PIXEL_255(color, qAlpha(~d), d, sia);
+    }
+}
+
+void QT_FASTCALL comp_func_XOR(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    PRELOAD_INIT2(dest, src)
+    if (const_alpha == 255) {
+        for (int i = 0; i < length; ++i) {
+            PRELOAD_COND2(dest, src)
+            uint d = dest[i];
+            uint s = src[i];
+            dest[i] = INTERPOLATE_PIXEL_255(s, qAlpha(~d), d, qAlpha(~s));
+        }
+    } else {
+        for (int i = 0; i < length; ++i) {
+            PRELOAD_COND2(dest, src)
+            uint d = dest[i];
+            uint s = BYTE_MUL(src[i], const_alpha);
+            dest[i] = INTERPOLATE_PIXEL_255(s, qAlpha(~d), d, qAlpha(~s));
+        }
+    }
+}
+
+struct QFullCoverage {
+    inline void store(uint *dest, const uint src) const
+    {
+        *dest = src;
+    }
+};
+
+struct QPartialCoverage {
+    inline QPartialCoverage(uint const_alpha)
+        : ca(const_alpha)
+        , ica(255 - const_alpha)
+    {
+    }
+
+    inline void store(uint *dest, const uint src) const
+    {
+        *dest = INTERPOLATE_PIXEL_255(src, ca, *dest, ica);
+    }
+
+private:
+    const uint ca;
+    const uint ica;
+};
+
+static inline int mix_alpha(int da, int sa)
+{
+    return 255 - ((255 - sa) * (255 - da) >> 8);
+}
+
+/*
+    Dca' = Sca.Da + Dca.Sa + Sca.(1 - Da) + Dca.(1 - Sa)
+         = Sca + Dca
+*/
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_Plus_impl(uint *dest, int length, uint color, const T &coverage)
+{
+    uint s = color;
+
+    PRELOAD_INIT(dest)
+    for (int i = 0; i < length; ++i) {
+        PRELOAD_COND(dest)
+        uint d = dest[i];
+        d = comp_func_Plus_one_pixel(d, s);
+        coverage.store(&dest[i], d);
+    }
+}
+
+void QT_FASTCALL comp_func_solid_Plus(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_solid_Plus_impl(dest, length, color, QFullCoverage());
+    else
+        comp_func_solid_Plus_impl(dest, length, color, QPartialCoverage(const_alpha));
+}
+
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_Plus_impl(uint *dest, const uint *src, int length, const T &coverage)
+{
+    PRELOAD_INIT2(dest, src)
+    for (int i = 0; i < length; ++i) {
+        PRELOAD_COND2(dest, src)
+        uint d = dest[i];
+        uint s = src[i];
+
+        d = comp_func_Plus_one_pixel(d, s);
+
+        coverage.store(&dest[i], d);
+    }
+}
+
+void QT_FASTCALL comp_func_Plus(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_Plus_impl(dest, src, length, QFullCoverage());
+    else
+        comp_func_Plus_impl(dest, src, length, QPartialCoverage(const_alpha));
+}
+
+/*
+    Dca' = Sca.Dca + Sca.(1 - Da) + Dca.(1 - Sa)
+*/
+static inline int multiply_op(int dst, int src, int da, int sa)
+{
+    return qt_div_255(src * dst + src * (255 - da) + dst * (255 - sa));
+}
+
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_Multiply_impl(uint *dest, int length, uint color, const T &coverage)
+{
+    int sa = qAlpha(color);
+    int sr = qRed(color);
+    int sg = qGreen(color);
+    int sb = qBlue(color);
+
+    PRELOAD_INIT(dest)
+    for (int i = 0; i < length; ++i) {
+        PRELOAD_COND(dest)
+        uint d = dest[i];
+        int da = qAlpha(d);
+
+#define OP(a, b) multiply_op(a, b, da, sa)
+        int r = OP(  qRed(d), sr);
+        int b = OP( qBlue(d), sb);
+        int g = OP(qGreen(d), sg);
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+void QT_FASTCALL comp_func_solid_Multiply(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_solid_Multiply_impl(dest, length, color, QFullCoverage());
+    else
+        comp_func_solid_Multiply_impl(dest, length, color, QPartialCoverage(const_alpha));
+}
+
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_Multiply_impl(uint *dest, const uint *src, int length, const T &coverage)
+{
+    PRELOAD_INIT2(dest, src)
+    for (int i = 0; i < length; ++i) {
+        PRELOAD_COND2(dest, src)
+        uint d = dest[i];
+        uint s = src[i];
+
+        int da = qAlpha(d);
+        int sa = qAlpha(s);
+
+#define OP(a, b) multiply_op(a, b, da, sa)
+        int r = OP(  qRed(d),   qRed(s));
+        int b = OP( qBlue(d),  qBlue(s));
+        int g = OP(qGreen(d), qGreen(s));
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+void QT_FASTCALL comp_func_Multiply(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_Multiply_impl(dest, src, length, QFullCoverage());
+    else
+        comp_func_Multiply_impl(dest, src, length, QPartialCoverage(const_alpha));
+}
+
+/*
+    Dca' = (Sca.Da + Dca.Sa - Sca.Dca) + Sca.(1 - Da) + Dca.(1 - Sa)
+         = Sca + Dca - Sca.Dca
+*/
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_Screen_impl(uint *dest, int length, uint color, const T &coverage)
+{
+    int sa = qAlpha(color);
+    int sr = qRed(color);
+    int sg = qGreen(color);
+    int sb = qBlue(color);
+
+    PRELOAD_INIT(dest)
+    for (int i = 0; i < length; ++i) {
+        PRELOAD_COND(dest)
+        uint d = dest[i];
+        int da = qAlpha(d);
+
+#define OP(a, b) 255 - qt_div_255((255-a) * (255-b))
+        int r = OP(  qRed(d), sr);
+        int b = OP( qBlue(d), sb);
+        int g = OP(qGreen(d), sg);
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+void QT_FASTCALL comp_func_solid_Screen(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_solid_Screen_impl(dest, length, color, QFullCoverage());
+    else
+        comp_func_solid_Screen_impl(dest, length, color, QPartialCoverage(const_alpha));
+}
+
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_Screen_impl(uint *dest, const uint *src, int length, const T &coverage)
+{
+    PRELOAD_INIT2(dest, src)
+    for (int i = 0; i < length; ++i) {
+        PRELOAD_COND2(dest, src)
+        uint d = dest[i];
+        uint s = src[i];
+
+        int da = qAlpha(d);
+        int sa = qAlpha(s);
+
+#define OP(a, b) 255 - (((255-a) * (255-b)) >> 8)
+        int r = OP(  qRed(d),   qRed(s));
+        int b = OP( qBlue(d),  qBlue(s));
+        int g = OP(qGreen(d), qGreen(s));
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+void QT_FASTCALL comp_func_Screen(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_Screen_impl(dest, src, length, QFullCoverage());
+    else
+        comp_func_Screen_impl(dest, src, length, QPartialCoverage(const_alpha));
+}
+
+/*
+    if 2.Dca < Da
+        Dca' = 2.Sca.Dca + Sca.(1 - Da) + Dca.(1 - Sa)
+    otherwise
+        Dca' = Sa.Da - 2.(Da - Dca).(Sa - Sca) + Sca.(1 - Da) + Dca.(1 - Sa)
+*/
+static inline int overlay_op(int dst, int src, int da, int sa)
+{
+    const int temp = src * (255 - da) + dst * (255 - sa);
+    if (2 * dst < da)
+        return qt_div_255(2 * src * dst + temp);
+    else
+        return qt_div_255(sa * da - 2 * (da - dst) * (sa - src) + temp);
+}
+
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_Overlay_impl(uint *dest, int length, uint color, const T &coverage)
+{
+    int sa = qAlpha(color);
+    int sr = qRed(color);
+    int sg = qGreen(color);
+    int sb = qBlue(color);
+
+    PRELOAD_INIT(dest)
+    for (int i = 0; i < length; ++i) {
+        PRELOAD_COND(dest)
+        uint d = dest[i];
+        int da = qAlpha(d);
+
+#define OP(a, b) overlay_op(a, b, da, sa)
+        int r = OP(  qRed(d), sr);
+        int b = OP( qBlue(d), sb);
+        int g = OP(qGreen(d), sg);
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+void QT_FASTCALL comp_func_solid_Overlay(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_solid_Overlay_impl(dest, length, color, QFullCoverage());
+    else
+        comp_func_solid_Overlay_impl(dest, length, color, QPartialCoverage(const_alpha));
+}
+
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_Overlay_impl(uint *dest, const uint *src, int length, const T &coverage)
+{
+    PRELOAD_INIT2(dest, src)
+    for (int i = 0; i < length; ++i) {
+        PRELOAD_COND2(dest, src)
+        uint d = dest[i];
+        uint s = src[i];
+
+        int da = qAlpha(d);
+        int sa = qAlpha(s);
+
+#define OP(a, b) overlay_op(a, b, da, sa)
+        int r = OP(  qRed(d),   qRed(s));
+        int b = OP( qBlue(d),  qBlue(s));
+        int g = OP(qGreen(d), qGreen(s));
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+void QT_FASTCALL comp_func_Overlay(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_Overlay_impl(dest, src, length, QFullCoverage());
+    else
+        comp_func_Overlay_impl(dest, src, length, QPartialCoverage(const_alpha));
+}
+
+/*
+    Dca' = min(Sca.Da, Dca.Sa) + Sca.(1 - Da) + Dca.(1 - Sa)
+    Da'  = Sa + Da - Sa.Da
+*/
+static inline int darken_op(int dst, int src, int da, int sa)
+{
+    return qt_div_255(qMin(src * da, dst * sa) + src * (255 - da) + dst * (255 - sa));
+}
+
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_Darken_impl(uint *dest, int length, uint color, const T &coverage)
+{
+    int sa = qAlpha(color);
+    int sr = qRed(color);
+    int sg = qGreen(color);
+    int sb = qBlue(color);
+
+    PRELOAD_INIT(dest)
+    for (int i = 0; i < length; ++i) {
+        PRELOAD_COND(dest)
+        uint d = dest[i];
+        int da = qAlpha(d);
+
+#define OP(a, b) darken_op(a, b, da, sa)
+        int r =  OP(  qRed(d), sr);
+        int b =  OP( qBlue(d), sb);
+        int g =  OP(qGreen(d), sg);
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+void QT_FASTCALL comp_func_solid_Darken(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_solid_Darken_impl(dest, length, color, QFullCoverage());
+    else
+        comp_func_solid_Darken_impl(dest, length, color, QPartialCoverage(const_alpha));
+}
+
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_Darken_impl(uint *dest, const uint *src, int length, const T &coverage)
+{
+    PRELOAD_INIT2(dest, src)
+    for (int i = 0; i < length; ++i) {
+        PRELOAD_COND2(dest, src)
+        uint d = dest[i];
+        uint s = src[i];
+
+        int da = qAlpha(d);
+        int sa = qAlpha(s);
+
+#define OP(a, b) darken_op(a, b, da, sa)
+        int r = OP(  qRed(d),   qRed(s));
+        int b = OP( qBlue(d),  qBlue(s));
+        int g = OP(qGreen(d), qGreen(s));
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+void QT_FASTCALL comp_func_Darken(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_Darken_impl(dest, src, length, QFullCoverage());
+    else
+        comp_func_Darken_impl(dest, src, length, QPartialCoverage(const_alpha));
+}
+
+/*
+   Dca' = max(Sca.Da, Dca.Sa) + Sca.(1 - Da) + Dca.(1 - Sa)
+   Da'  = Sa + Da - Sa.Da
+*/
+static inline int lighten_op(int dst, int src, int da, int sa)
+{
+    return qt_div_255(qMax(src * da, dst * sa) + src * (255 - da) + dst * (255 - sa));
+}
+
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_Lighten_impl(uint *dest, int length, uint color, const T &coverage)
+{
+    int sa = qAlpha(color);
+    int sr = qRed(color);
+    int sg = qGreen(color);
+    int sb = qBlue(color);
+
+    PRELOAD_INIT(dest)
+    for (int i = 0; i < length; ++i) {
+        PRELOAD_COND(dest)
+        uint d = dest[i];
+        int da = qAlpha(d);
+
+#define OP(a, b) lighten_op(a, b, da, sa)
+        int r =  OP(  qRed(d), sr);
+        int b =  OP( qBlue(d), sb);
+        int g =  OP(qGreen(d), sg);
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+void QT_FASTCALL comp_func_solid_Lighten(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_solid_Lighten_impl(dest, length, color, QFullCoverage());
+    else
+        comp_func_solid_Lighten_impl(dest, length, color, QPartialCoverage(const_alpha));
+}
+
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_Lighten_impl(uint *dest, const uint *src, int length, const T &coverage)
+{
+    PRELOAD_INIT2(dest, src)
+    for (int i = 0; i < length; ++i) {
+        PRELOAD_COND2(dest, src)
+        uint d = dest[i];
+        uint s = src[i];
+
+        int da = qAlpha(d);
+        int sa = qAlpha(s);
+
+#define OP(a, b) lighten_op(a, b, da, sa)
+        int r = OP(  qRed(d),   qRed(s));
+        int b = OP( qBlue(d),  qBlue(s));
+        int g = OP(qGreen(d), qGreen(s));
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+void QT_FASTCALL comp_func_Lighten(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_Lighten_impl(dest, src, length, QFullCoverage());
+    else
+        comp_func_Lighten_impl(dest, src, length, QPartialCoverage(const_alpha));
+}
+
+/*
+   if Sca.Da + Dca.Sa >= Sa.Da
+       Dca' = Sa.Da + Sca.(1 - Da) + Dca.(1 - Sa)
+   otherwise
+       Dca' = Dca.Sa/(1-Sca/Sa) + Sca.(1 - Da) + Dca.(1 - Sa)
+*/
+static inline int color_dodge_op(int dst, int src, int da, int sa)
+{
+    const int sa_da = sa * da;
+    const int dst_sa = dst * sa;
+    const int src_da = src * da;
+
+    const int temp = src * (255 - da) + dst * (255 - sa);
+    if (src_da + dst_sa >= sa_da)
+        return qt_div_255(sa_da + temp);
+    else
+        return qt_div_255(255 * dst_sa / (255 - 255 * src / sa) + temp);
+}
+
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_ColorDodge_impl(uint *dest, int length, uint color, const T &coverage)
+{
+    int sa = qAlpha(color);
+    int sr = qRed(color);
+    int sg = qGreen(color);
+    int sb = qBlue(color);
+
+    PRELOAD_INIT(dest)
+    for (int i = 0; i < length; ++i) {
+        PRELOAD_COND(dest)
+        uint d = dest[i];
+        int da = qAlpha(d);
+
+#define OP(a,b) color_dodge_op(a, b, da, sa)
+        int r = OP(  qRed(d), sr);
+        int b = OP( qBlue(d), sb);
+        int g = OP(qGreen(d), sg);
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+void QT_FASTCALL comp_func_solid_ColorDodge(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_solid_ColorDodge_impl(dest, length, color, QFullCoverage());
+    else
+        comp_func_solid_ColorDodge_impl(dest, length, color, QPartialCoverage(const_alpha));
+}
+
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_ColorDodge_impl(uint *dest, const uint *src, int length, const T &coverage)
+{
+    PRELOAD_INIT2(dest, src)
+    for (int i = 0; i < length; ++i) {
+        PRELOAD_COND2(dest, src)
+        uint d = dest[i];
+        uint s = src[i];
+
+        int da = qAlpha(d);
+        int sa = qAlpha(s);
+
+#define OP(a, b) color_dodge_op(a, b, da, sa)
+        int r = OP(  qRed(d),   qRed(s));
+        int b = OP( qBlue(d),  qBlue(s));
+        int g = OP(qGreen(d), qGreen(s));
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+void QT_FASTCALL comp_func_ColorDodge(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_ColorDodge_impl(dest, src, length, QFullCoverage());
+    else
+        comp_func_ColorDodge_impl(dest, src, length, QPartialCoverage(const_alpha));
+}
+
+/*
+   if Sca.Da + Dca.Sa <= Sa.Da
+       Dca' = Sca.(1 - Da) + Dca.(1 - Sa)
+   otherwise
+       Dca' = Sa.(Sca.Da + Dca.Sa - Sa.Da)/Sca + Sca.(1 - Da) + Dca.(1 - Sa)
+*/
+static inline int color_burn_op(int dst, int src, int da, int sa)
+{
+    const int src_da = src * da;
+    const int dst_sa = dst * sa;
+    const int sa_da = sa * da;
+
+    const int temp = src * (255 - da) + dst * (255 - sa);
+
+    if (src == 0 || src_da + dst_sa <= sa_da)
+        return qt_div_255(temp);
+    return qt_div_255(sa * (src_da + dst_sa - sa_da) / src + temp);
+}
+
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_ColorBurn_impl(uint *dest, int length, uint color, const T &coverage)
+{
+    int sa = qAlpha(color);
+    int sr = qRed(color);
+    int sg = qGreen(color);
+    int sb = qBlue(color);
+
+    PRELOAD_INIT(dest)
+    for (int i = 0; i < length; ++i) {
+        PRELOAD_COND(dest)
+        uint d = dest[i];
+        int da = qAlpha(d);
+
+#define OP(a, b) color_burn_op(a, b, da, sa)
+        int r =  OP(  qRed(d), sr);
+        int b =  OP( qBlue(d), sb);
+        int g =  OP(qGreen(d), sg);
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+void QT_FASTCALL comp_func_solid_ColorBurn(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_solid_ColorBurn_impl(dest, length, color, QFullCoverage());
+    else
+        comp_func_solid_ColorBurn_impl(dest, length, color, QPartialCoverage(const_alpha));
+}
+
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_ColorBurn_impl(uint *dest, const uint *src, int length, const T &coverage)
+{
+    PRELOAD_INIT2(dest, src)
+    for (int i = 0; i < length; ++i) {
+        PRELOAD_COND2(dest, src)
+        uint d = dest[i];
+        uint s = src[i];
+
+        int da = qAlpha(d);
+        int sa = qAlpha(s);
+
+#define OP(a, b) color_burn_op(a, b, da, sa)
+        int r = OP(  qRed(d),   qRed(s));
+        int b = OP( qBlue(d),  qBlue(s));
+        int g = OP(qGreen(d), qGreen(s));
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+void QT_FASTCALL comp_func_ColorBurn(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_ColorBurn_impl(dest, src, length, QFullCoverage());
+    else
+        comp_func_ColorBurn_impl(dest, src, length, QPartialCoverage(const_alpha));
+}
+
+/*
+    if 2.Sca < Sa
+        Dca' = 2.Sca.Dca + Sca.(1 - Da) + Dca.(1 - Sa)
+    otherwise
+        Dca' = Sa.Da - 2.(Da - Dca).(Sa - Sca) + Sca.(1 - Da) + Dca.(1 - Sa)
+*/
+static inline uint hardlight_op(int dst, int src, int da, int sa)
+{
+    const uint temp = src * (255 - da) + dst * (255 - sa);
+
+    if (2 * src < sa)
+        return qt_div_255(2 * src * dst + temp);
+    else
+        return qt_div_255(sa * da - 2 * (da - dst) * (sa - src) + temp);
+}
+
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_HardLight_impl(uint *dest, int length, uint color, const T &coverage)
+{
+    int sa = qAlpha(color);
+    int sr = qRed(color);
+    int sg = qGreen(color);
+    int sb = qBlue(color);
+
+    PRELOAD_INIT(dest)
+    for (int i = 0; i < length; ++i) {
+        PRELOAD_COND(dest)
+        uint d = dest[i];
+        int da = qAlpha(d);
+
+#define OP(a, b) hardlight_op(a, b, da, sa)
+        int r =  OP(  qRed(d), sr);
+        int b =  OP( qBlue(d), sb);
+        int g =  OP(qGreen(d), sg);
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+void QT_FASTCALL comp_func_solid_HardLight(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_solid_HardLight_impl(dest, length, color, QFullCoverage());
+    else
+        comp_func_solid_HardLight_impl(dest, length, color, QPartialCoverage(const_alpha));
+}
+
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_HardLight_impl(uint *dest, const uint *src, int length, const T &coverage)
+{
+    PRELOAD_INIT2(dest, src)
+    for (int i = 0; i < length; ++i) {
+        PRELOAD_COND2(dest, src)
+        uint d = dest[i];
+        uint s = src[i];
+
+        int da = qAlpha(d);
+        int sa = qAlpha(s);
+
+#define OP(a, b) hardlight_op(a, b, da, sa)
+        int r = OP(  qRed(d),   qRed(s));
+        int b = OP( qBlue(d),  qBlue(s));
+        int g = OP(qGreen(d), qGreen(s));
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+void QT_FASTCALL comp_func_HardLight(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_HardLight_impl(dest, src, length, QFullCoverage());
+    else
+        comp_func_HardLight_impl(dest, src, length, QPartialCoverage(const_alpha));
+}
+
+/*
+    if 2.Sca <= Sa
+        Dca' = Dca.(Sa + (2.Sca - Sa).(1 - Dca/Da)) + Sca.(1 - Da) + Dca.(1 - Sa)
+    otherwise if 2.Sca > Sa and 4.Dca <= Da
+        Dca' = Dca.Sa + Da.(2.Sca - Sa).(4.Dca/Da.(4.Dca/Da + 1).(Dca/Da - 1) + 7.Dca/Da) + Sca.(1 - Da) + Dca.(1 - Sa)
+    otherwise if 2.Sca > Sa and 4.Dca > Da
+        Dca' = Dca.Sa + Da.(2.Sca - Sa).((Dca/Da)^0.5 - Dca/Da) + Sca.(1 - Da) + Dca.(1 - Sa)
+*/
+static inline int soft_light_op(int dst, int src, int da, int sa)
+{
+    const int src2 = src << 1;
+    const int dst_np = da != 0 ? (255 * dst) / da : 0;
+    const int temp = (src * (255 - da) + dst * (255 - sa)) * 255;
+
+    if (src2 < sa)
+        return (dst * (sa * 255 + (src2 - sa) * (255 - dst_np)) + temp) / 65025;
+    else if (4 * dst <= da)
+        return (dst * sa * 255 + da * (src2 - sa) * ((((16 * dst_np - 12 * 255) * dst_np + 3 * 65025) * dst_np) / 65025) + temp) / 65025;
+    else {
+#   ifdef Q_CC_RVCT // needed to avoid compiler crash in RVCT 2.2
+        return (dst * sa * 255 + da * (src2 - sa) * (qIntSqrtInt(dst_np * 255) - dst_np) + temp) / 65025;
+#   else
+        return (dst * sa * 255 + da * (src2 - sa) * (int(qSqrt(qreal(dst_np * 255))) - dst_np) + temp) / 65025;
+#   endif
+    }
+}
+
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_SoftLight_impl(uint *dest, int length, uint color, const T &coverage)
+{
+    int sa = qAlpha(color);
+    int sr = qRed(color);
+    int sg = qGreen(color);
+    int sb = qBlue(color);
+
+    PRELOAD_INIT(dest)
+    for (int i = 0; i < length; ++i) {
+        PRELOAD_COND(dest)
+        uint d = dest[i];
+        int da = qAlpha(d);
+
+#define OP(a, b) soft_light_op(a, b, da, sa)
+        int r =  OP(  qRed(d), sr);
+        int b =  OP( qBlue(d), sb);
+        int g =  OP(qGreen(d), sg);
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+void QT_FASTCALL comp_func_solid_SoftLight(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_solid_SoftLight_impl(dest, length, color, QFullCoverage());
+    else
+        comp_func_solid_SoftLight_impl(dest, length, color, QPartialCoverage(const_alpha));
+}
+
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_SoftLight_impl(uint *dest, const uint *src, int length, const T &coverage)
+{
+    PRELOAD_INIT2(dest, src)
+    for (int i = 0; i < length; ++i) {
+        PRELOAD_COND2(dest, src)
+        uint d = dest[i];
+        uint s = src[i];
+
+        int da = qAlpha(d);
+        int sa = qAlpha(s);
+
+#define OP(a, b) soft_light_op(a, b, da, sa)
+        int r = OP(  qRed(d),   qRed(s));
+        int b = OP( qBlue(d),  qBlue(s));
+        int g = OP(qGreen(d), qGreen(s));
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+void QT_FASTCALL comp_func_SoftLight(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_SoftLight_impl(dest, src, length, QFullCoverage());
+    else
+        comp_func_SoftLight_impl(dest, src, length, QPartialCoverage(const_alpha));
+}
+
+/*
+   Dca' = abs(Dca.Sa - Sca.Da) + Sca.(1 - Da) + Dca.(1 - Sa)
+        = Sca + Dca - 2.min(Sca.Da, Dca.Sa)
+*/
+static inline int difference_op(int dst, int src, int da, int sa)
+{
+    return src + dst - qt_div_255(2 * qMin(src * da, dst * sa));
+}
+
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_Difference_impl(uint *dest, int length, uint color, const T &coverage)
+{
+    int sa = qAlpha(color);
+    int sr = qRed(color);
+    int sg = qGreen(color);
+    int sb = qBlue(color);
+
+    PRELOAD_INIT(dest)
+    for (int i = 0; i < length; ++i) {
+        PRELOAD_COND(dest)
+        uint d = dest[i];
+        int da = qAlpha(d);
+
+#define OP(a, b) difference_op(a, b, da, sa)
+        int r =  OP(  qRed(d), sr);
+        int b =  OP( qBlue(d), sb);
+        int g =  OP(qGreen(d), sg);
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+void QT_FASTCALL comp_func_solid_Difference(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_solid_Difference_impl(dest, length, color, QFullCoverage());
+    else
+        comp_func_solid_Difference_impl(dest, length, color, QPartialCoverage(const_alpha));
+}
+
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_Difference_impl(uint *dest, const uint *src, int length, const T &coverage)
+{
+    PRELOAD_INIT2(dest, src)
+    for (int i = 0; i < length; ++i) {
+        PRELOAD_COND2(dest, src)
+        uint d = dest[i];
+        uint s = src[i];
+
+        int da = qAlpha(d);
+        int sa = qAlpha(s);
+
+#define OP(a, b) difference_op(a, b, da, sa)
+        int r = OP(  qRed(d),   qRed(s));
+        int b = OP( qBlue(d),  qBlue(s));
+        int g = OP(qGreen(d), qGreen(s));
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+void QT_FASTCALL comp_func_Difference(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_Difference_impl(dest, src, length, QFullCoverage());
+    else
+        comp_func_Difference_impl(dest, src, length, QPartialCoverage(const_alpha));
+}
+
+/*
+    Dca' = (Sca.Da + Dca.Sa - 2.Sca.Dca) + Sca.(1 - Da) + Dca.(1 - Sa)
+*/
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void QT_FASTCALL comp_func_solid_Exclusion_impl(uint *dest, int length, uint color, const T &coverage)
+{
+    int sa = qAlpha(color);
+    int sr = qRed(color);
+    int sg = qGreen(color);
+    int sb = qBlue(color);
+
+    PRELOAD_INIT(dest)
+    for (int i = 0; i < length; ++i) {
+        PRELOAD_COND(dest)
+        uint d = dest[i];
+        int da = qAlpha(d);
+
+#define OP(a, b) (a + b - qt_div_255(2*(a*b)))
+        int r =  OP(  qRed(d), sr);
+        int b =  OP( qBlue(d), sb);
+        int g =  OP(qGreen(d), sg);
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+void QT_FASTCALL comp_func_solid_Exclusion(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_solid_Exclusion_impl(dest, length, color, QFullCoverage());
+    else
+        comp_func_solid_Exclusion_impl(dest, length, color, QPartialCoverage(const_alpha));
+}
+
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_Exclusion_impl(uint *dest, const uint *src, int length, const T &coverage)
+{
+    PRELOAD_INIT2(dest, src)
+    for (int i = 0; i < length; ++i) {
+        PRELOAD_COND2(dest, src)
+        uint d = dest[i];
+        uint s = src[i];
+
+        int da = qAlpha(d);
+        int sa = qAlpha(s);
+
+#define OP(a, b) (a + b - ((a*b) >> 7))
+        int r = OP(  qRed(d),   qRed(s));
+        int b = OP( qBlue(d),  qBlue(s));
+        int g = OP(qGreen(d), qGreen(s));
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+void QT_FASTCALL comp_func_Exclusion(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_Exclusion_impl(dest, src, length, QFullCoverage());
+    else
+        comp_func_Exclusion_impl(dest, src, length, QPartialCoverage(const_alpha));
+}
+
+#if defined(Q_CC_RVCT)
+// Restore pragma state from previous #pragma arm
+#  pragma pop
+#endif
+
+void QT_FASTCALL rasterop_solid_SourceOrDestination(uint *dest,
+                                                    int length,
+                                                    uint color,
+                                                    uint const_alpha)
+{
+    Q_UNUSED(const_alpha);
+    while (length--)
+        *dest++ |= color;
+}
+
+void QT_FASTCALL rasterop_SourceOrDestination(uint *dest,
+                                              const uint *src,
+                                              int length,
+                                              uint const_alpha)
+{
+    Q_UNUSED(const_alpha);
+    while (length--)
+        *dest++ |= *src++;
+}
+
+void QT_FASTCALL rasterop_solid_SourceAndDestination(uint *dest,
+                                                     int length,
+                                                     uint color,
+                                                     uint const_alpha)
+{
+    Q_UNUSED(const_alpha);
+    color |= 0xff000000;
+    while (length--)
+        *dest++ &= color;
+}
+
+void QT_FASTCALL rasterop_SourceAndDestination(uint *dest,
+                                               const uint *src,
+                                               int length,
+                                               uint const_alpha)
+{
+    Q_UNUSED(const_alpha);
+    while (length--) {
+        *dest = (*src & *dest) | 0xff000000;
+        ++dest; ++src;
+    }
+}
+
+void QT_FASTCALL rasterop_solid_SourceXorDestination(uint *dest,
+                                                     int length,
+                                                     uint color,
+                                                     uint const_alpha)
+{
+    Q_UNUSED(const_alpha);
+    color &= 0x00ffffff;
+    while (length--)
+        *dest++ ^= color;
+}
+
+void QT_FASTCALL rasterop_SourceXorDestination(uint *dest,
+                                               const uint *src,
+                                               int length,
+                                               uint const_alpha)
+{
+    Q_UNUSED(const_alpha);
+    while (length--) {
+        *dest = (*src ^ *dest) | 0xff000000;
+        ++dest; ++src;
+    }
+}
+
+void QT_FASTCALL rasterop_solid_NotSourceAndNotDestination(uint *dest,
+                                                           int length,
+                                                           uint color,
+                                                           uint const_alpha)
+{
+    Q_UNUSED(const_alpha);
+    color = ~color;
+    while (length--) {
+        *dest = (color & ~(*dest)) | 0xff000000;
+        ++dest;
+    }
+}
+
+void QT_FASTCALL rasterop_NotSourceAndNotDestination(uint *dest,
+                                                     const uint *src,
+                                                     int length,
+                                                     uint const_alpha)
+{
+    Q_UNUSED(const_alpha);
+    while (length--) {
+        *dest = (~(*src) & ~(*dest)) | 0xff000000;
+        ++dest; ++src;
+    }
+}
+
+void QT_FASTCALL rasterop_solid_NotSourceOrNotDestination(uint *dest,
+                                                          int length,
+                                                          uint color,
+                                                          uint const_alpha)
+{
+    Q_UNUSED(const_alpha);
+    color = ~color | 0xff000000;
+    while (length--) {
+        *dest = color | ~(*dest);
+        ++dest;
+    }
+}
+
+void QT_FASTCALL rasterop_NotSourceOrNotDestination(uint *dest,
+                                                    const uint *src,
+                                                    int length,
+                                                    uint const_alpha)
+{
+    Q_UNUSED(const_alpha);
+    while (length--) {
+        *dest = ~(*src) | ~(*dest) | 0xff000000;
+        ++dest; ++src;
+    }
+}
+
+void QT_FASTCALL rasterop_solid_NotSourceXorDestination(uint *dest,
+                                                        int length,
+                                                        uint color,
+                                                        uint const_alpha)
+{
+    Q_UNUSED(const_alpha);
+    color = ~color & 0x00ffffff;
+    while (length--) {
+        *dest = color ^ (*dest);
+        ++dest;
+    }
+}
+
+void QT_FASTCALL rasterop_NotSourceXorDestination(uint *dest,
+                                                  const uint *src,
+                                                  int length,
+                                                  uint const_alpha)
+{
+    Q_UNUSED(const_alpha);
+    while (length--) {
+        *dest = ((~(*src)) ^ (*dest)) | 0xff000000;
+        ++dest; ++src;
+    }
+}
+
+void QT_FASTCALL rasterop_solid_NotSource(uint *dest, int length,
+                                          uint color, uint const_alpha)
+{
+    Q_UNUSED(const_alpha);
+    qt_memfill(dest, ~color | 0xff000000, length);
+}
+
+void QT_FASTCALL rasterop_NotSource(uint *dest, const uint *src,
+                                    int length, uint const_alpha)
+{
+    Q_UNUSED(const_alpha);
+    while (length--)
+        *dest++ = ~(*src++) | 0xff000000;
+}
+
+void QT_FASTCALL rasterop_solid_NotSourceAndDestination(uint *dest,
+                                                        int length,
+                                                        uint color,
+                                                        uint const_alpha)
+{
+    Q_UNUSED(const_alpha);
+    color = ~color | 0xff000000;
+    while (length--) {
+        *dest = color & *dest;
+        ++dest;
+    }
+}
+
+void QT_FASTCALL rasterop_NotSourceAndDestination(uint *dest,
+                                                  const uint *src,
+                                                  int length,
+                                                  uint const_alpha)
+{
+    Q_UNUSED(const_alpha);
+    while (length--) {
+        *dest = (~(*src) & *dest) | 0xff000000;
+        ++dest; ++src;
+    }
+}
+
+void QT_FASTCALL rasterop_solid_SourceAndNotDestination(uint *dest,
+                                                        int length,
+                                                        uint color,
+                                                        uint const_alpha)
+{
+    Q_UNUSED(const_alpha);
+    while (length--) {
+        *dest = (color & ~(*dest)) | 0xff000000;
+        ++dest;
+    }
+}
+
+void QT_FASTCALL rasterop_SourceAndNotDestination(uint *dest,
+                                                  const uint *src,
+                                                  int length,
+                                                  uint const_alpha)
+{
+    Q_UNUSED(const_alpha);
+    while (length--) {
+        *dest = (*src & ~(*dest)) | 0xff000000;
+        ++dest; ++src;
+    }
+}
+
+static CompositionFunctionSolid functionForModeSolid_C[] = {
+        comp_func_solid_SourceOver,
+        comp_func_solid_DestinationOver,
+        comp_func_solid_Clear,
+        comp_func_solid_Source,
+        comp_func_solid_Destination,
+        comp_func_solid_SourceIn,
+        comp_func_solid_DestinationIn,
+        comp_func_solid_SourceOut,
+        comp_func_solid_DestinationOut,
+        comp_func_solid_SourceAtop,
+        comp_func_solid_DestinationAtop,
+        comp_func_solid_XOR,
+        comp_func_solid_Plus,
+        comp_func_solid_Multiply,
+        comp_func_solid_Screen,
+        comp_func_solid_Overlay,
+        comp_func_solid_Darken,
+        comp_func_solid_Lighten,
+        comp_func_solid_ColorDodge,
+        comp_func_solid_ColorBurn,
+        comp_func_solid_HardLight,
+        comp_func_solid_SoftLight,
+        comp_func_solid_Difference,
+        comp_func_solid_Exclusion,
+        rasterop_solid_SourceOrDestination,
+        rasterop_solid_SourceAndDestination,
+        rasterop_solid_SourceXorDestination,
+        rasterop_solid_NotSourceAndNotDestination,
+        rasterop_solid_NotSourceOrNotDestination,
+        rasterop_solid_NotSourceXorDestination,
+        rasterop_solid_NotSource,
+        rasterop_solid_NotSourceAndDestination,
+        rasterop_solid_SourceAndNotDestination
+};
+
+static const CompositionFunctionSolid *functionForModeSolid = functionForModeSolid_C;
+
+static CompositionFunction functionForMode_C[] = {
+        comp_func_SourceOver,
+        comp_func_DestinationOver,
+        comp_func_Clear,
+        comp_func_Source,
+        comp_func_Destination,
+        comp_func_SourceIn,
+        comp_func_DestinationIn,
+        comp_func_SourceOut,
+        comp_func_DestinationOut,
+        comp_func_SourceAtop,
+        comp_func_DestinationAtop,
+        comp_func_XOR,
+        comp_func_Plus,
+        comp_func_Multiply,
+        comp_func_Screen,
+        comp_func_Overlay,
+        comp_func_Darken,
+        comp_func_Lighten,
+        comp_func_ColorDodge,
+        comp_func_ColorBurn,
+        comp_func_HardLight,
+        comp_func_SoftLight,
+        comp_func_Difference,
+        comp_func_Exclusion,
+        rasterop_SourceOrDestination,
+        rasterop_SourceAndDestination,
+        rasterop_SourceXorDestination,
+        rasterop_NotSourceAndNotDestination,
+        rasterop_NotSourceOrNotDestination,
+        rasterop_NotSourceXorDestination,
+        rasterop_NotSource,
+        rasterop_NotSourceAndDestination,
+        rasterop_SourceAndNotDestination
+};
+
+static const CompositionFunction *functionForMode = functionForMode_C;
+
+static TextureBlendType getBlendType(const QSpanData *data)
+{
+    TextureBlendType ft;
+    if (data->txop <= QTransform::TxTranslate)
+        if (data->texture.type == QTextureData::Tiled)
+            ft = BlendTiled;
+        else
+            ft = BlendUntransformed;
+    else if (data->bilinear)
+        if (data->texture.type == QTextureData::Tiled)
+            ft = BlendTransformedBilinearTiled;
+        else
+            ft = BlendTransformedBilinear;
+    else
+        if (data->texture.type == QTextureData::Tiled)
+            ft = BlendTransformedTiled;
+        else
+            ft = BlendTransformed;
+    return ft;
+}
+
+static inline Operator getOperator(const QSpanData *data, const QSpan *spans, int spanCount)
+{
+    Operator op;
+    bool solidSource = false;
+
+    switch(data->type) {
+    case QSpanData::Solid:
+        solidSource = (qAlpha(data->solid.color) == 255);
+        break;
+    case QSpanData::LinearGradient:
+        solidSource = !data->gradient.alphaColor;
+        getLinearGradientValues(&op.linear, data);
+        op.src_fetch = fetchLinearGradient;
+        break;
+    case QSpanData::RadialGradient:
+        solidSource = !data->gradient.alphaColor;
+        getRadialGradientValues(&op.radial, data);
+        op.src_fetch = fetchRadialGradient;
+        break;
+    case QSpanData::ConicalGradient:
+        solidSource = !data->gradient.alphaColor;
+        op.src_fetch = fetchConicalGradient;
+        break;
+    case QSpanData::Texture:
+        op.src_fetch = sourceFetch[getBlendType(data)][data->texture.format];
+        solidSource = !data->texture.hasAlpha;
+    default:
+        break;
+    }
+
+    op.mode = data->rasterBuffer->compositionMode;
+    if (op.mode == QPainter::CompositionMode_SourceOver && solidSource)
+        op.mode = QPainter::CompositionMode_Source;
+
+    op.dest_fetch = destFetchProc[data->rasterBuffer->format];
+    if (op.mode == QPainter::CompositionMode_Source) {
+        switch (data->rasterBuffer->format) {
+        case QImage::Format_RGB32:
+        case QImage::Format_ARGB32_Premultiplied:
+            // don't clear dest_fetch as it sets up the pointer correctly to save one copy
+            break;
+        default: {
+            const QSpan *lastSpan = spans + spanCount;
+            bool alphaSpans = false;
+            while (spans < lastSpan) {
+                if (spans->coverage != 255) {
+                    alphaSpans = true;
+                    break;
+                }
+                ++spans;
+            }
+            if (!alphaSpans)
+                op.dest_fetch = 0;
+        }
+        }
+    }
+
+    op.dest_store = destStoreProc[data->rasterBuffer->format];
+
+    op.funcSolid = functionForModeSolid[op.mode];
+    op.func = functionForMode[op.mode];
+
+    return op;
+}
+
+
+
+// -------------------- blend methods ---------------------
+
+enum SpanMethod {
+    RegularSpans,
+    CallbackSpans
+};
+
+#if !defined(Q_CC_SUN)
+static
+#endif
+void drawBufferSpan(QSpanData *data, const uint *buffer, int bufsize,
+                           int x, int y, int length, uint const_alpha)
+{
+#if defined (Q_WS_QWS) && !defined(QT_NO_RASTERCALLBACKS)
+    data->rasterEngine->drawBufferSpan(buffer, bufsize, x, y, length, const_alpha);
+#else
+    Q_UNUSED(data);
+    Q_UNUSED(buffer);
+    Q_UNUSED(bufsize);
+    Q_UNUSED(x);
+    Q_UNUSED(y);
+    Q_UNUSED(length);
+    Q_UNUSED(const_alpha);
+#endif
+}
+
+#if !defined(Q_CC_SUN)
+static
+#endif
+void blend_color_generic(int count, const QSpan *spans, void *userData)
+{
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+    uint buffer[buffer_size];
+    Operator op = getOperator(data, spans, count);
+
+    while (count--) {
+        int x = spans->x;
+        int length = spans->len;
+        while (length) {
+            int l = qMin(buffer_size, length);
+            uint *dest = op.dest_fetch ? op.dest_fetch(buffer, data->rasterBuffer, x, spans->y, l) : buffer;
+            op.funcSolid(dest, l, data->solid.color, spans->coverage);
+            if (op.dest_store)
+                op.dest_store(data->rasterBuffer, x, spans->y, dest, l);
+            length -= l;
+            x += l;
+        }
+        ++spans;
+    }
+}
+
+#if defined (Q_WS_QWS) && !defined(QT_NO_RASTERCALLBACKS)
+static void blend_color_generic_callback(int count, const QSpan *spans, void *userData)
+{
+    // ### Falcon
+    Q_UNUSED(count);
+    Q_UNUSED(spans);
+    Q_UNUSED(userData);
+//     QSpanData *data = reinterpret_cast<QSpanData*>(userData);
+//     data->rasterEngine->drawColorSpans(spans, count, data->solid.color);
+}
+#endif // QT_NO_RASTERCALLBACKS
+
+static void blend_color_argb(int count, const QSpan *spans, void *userData)
+{
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    Operator op = getOperator(data, spans, count);
+
+    if (op.mode == QPainter::CompositionMode_Source) {
+        // inline for performance
+        while (count--) {
+            uint *target = ((uint *)data->rasterBuffer->scanLine(spans->y)) + spans->x;
+            if (spans->coverage == 255) {
+                QT_MEMFILL_UINT(target, spans->len, data->solid.color);
+            } else {
+                uint c = BYTE_MUL(data->solid.color, spans->coverage);
+                int ialpha = 255 - spans->coverage;
+                for (int i = 0; i < spans->len; ++i)
+                    target[i] = c + BYTE_MUL(target[i], ialpha);
+            }
+            ++spans;
+        }
+        return;
+    }
+
+    while (count--) {
+        uint *target = ((uint *)data->rasterBuffer->scanLine(spans->y)) + spans->x;
+        op.funcSolid(target, spans->len, data->solid.color, spans->coverage);
+        ++spans;
+    }
+}
+
+template <class T>
+Q_STATIC_TEMPLATE_FUNCTION void blendColor(int count, const QSpan *spans, void *userData)
+{
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+    Operator op = getOperator(data, spans, count);
+
+    if (op.mode == QPainter::CompositionMode_Source) {
+        const T c = qt_colorConvert<T, quint32p>(quint32p::fromRawData(data->solid.color), 0);
+        while (count--) {
+            T *target = ((T*)data->rasterBuffer->scanLine(spans->y))
+                        + spans->x;
+            if (spans->coverage == 255) {
+                qt_memfill(target, c, spans->len);
+            } else {
+                const quint8 alpha = T::alpha(spans->coverage);
+                const T color = c.byte_mul(alpha);
+                const int ialpha = T::ialpha(spans->coverage);
+                const T *end = target + spans->len;
+                while (target < end) {
+                    *target = color + target->byte_mul(ialpha);
+                    ++target;
+                }
+            }
+            ++spans;
+        }
+        return;
+    }
+
+    if (op.mode == QPainter::CompositionMode_SourceOver) {
+        while (count--) {
+            const quint32 color = BYTE_MUL(data->solid.color, spans->coverage);
+            const T c = qt_colorConvert<T, quint32p>(quint32p::fromRawData(color), 0);
+            const quint8 ialpha = T::alpha(qAlpha(~color));
+            T *target = ((T*)data->rasterBuffer->scanLine(spans->y)) + spans->x;
+            const T *end = target + spans->len;
+            while (target != end) {
+                *target = c + target->byte_mul(ialpha);
+                ++target;
+            }
+            ++spans;
+        }
+        return;
+    }
+
+    blend_color_generic(count, spans, userData);
+}
+
+#define SPANFUNC_POINTER_BLENDCOLOR(DST) blendColor<DST>
+
+static void blend_color_rgb16(int count, const QSpan *spans, void *userData)
+{
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    /*
+        We duplicate a little logic from getOperator() and calculate the
+        composition mode directly.  This allows blend_color_rgb16 to be used
+        from qt_gradient_quint16 with minimal overhead.
+     */
+    QPainter::CompositionMode mode = data->rasterBuffer->compositionMode;
+    if (mode == QPainter::CompositionMode_SourceOver &&
+        qAlpha(data->solid.color) == 255)
+        mode = QPainter::CompositionMode_Source;
+
+    if (mode == QPainter::CompositionMode_Source) {
+        // inline for performance
+        ushort c = qConvertRgb32To16(data->solid.color);
+        while (count--) {
+            ushort *target = ((ushort *)data->rasterBuffer->scanLine(spans->y)) + spans->x;
+            if (spans->coverage == 255) {
+                QT_MEMFILL_USHORT(target, spans->len, c);
+            } else {
+                ushort color = BYTE_MUL_RGB16(c, spans->coverage);
+                int ialpha = 255 - spans->coverage;
+                const ushort *end = target + spans->len;
+                while (target < end) {
+                    *target = color + BYTE_MUL_RGB16(*target, ialpha);
+                    ++target;
+                }
+            }
+            ++spans;
+        }
+        return;
+    }
+
+    if (mode == QPainter::CompositionMode_SourceOver) {
+        while (count--) {
+            uint color = BYTE_MUL(data->solid.color, spans->coverage);
+            int ialpha = qAlpha(~color);
+            ushort c = qConvertRgb32To16(color);
+            ushort *target = ((ushort *)data->rasterBuffer->scanLine(spans->y)) + spans->x;
+            int len = spans->len;
+            bool pre = (((quintptr)target) & 0x3) != 0;
+            bool post = false;
+            if (pre) {
+                // skip to word boundary
+                *target = c + BYTE_MUL_RGB16(*target, ialpha);
+                ++target;
+                --len;
+            }
+            if (len & 0x1) {
+                post = true;
+                --len;
+            }
+            uint *target32 = (uint*)target;
+            uint c32 = c | (c<<16);
+            len >>= 1;
+            uint salpha = (ialpha+1) >> 3; // calculate here rather than in loop
+            while (len--) {
+                // blend full words
+                *target32 = c32 + BYTE_MUL_RGB16_32(*target32, salpha);
+                ++target32;
+                target += 2;
+            }
+            if (post) {
+                // one last pixel beyond a full word
+                *target = c + BYTE_MUL_RGB16(*target, ialpha);
+            }
+            ++spans;
+        }
+        return;
+    }
+
+    blend_color_generic(count, spans, userData);
+}
+
+template <typename T>
+void handleSpans(int count, const QSpan *spans, const QSpanData *data, T &handler)
+{
+    uint const_alpha = 256;
+    if (data->type == QSpanData::Texture)
+        const_alpha = data->texture.const_alpha;
+
+    int coverage = 0;
+    while (count) {
+        int x = spans->x;
+        const int y = spans->y;
+        int right = x + spans->len;
+
+        // compute length of adjacent spans
+        for (int i = 1; i < count && spans[i].y == y && spans[i].x == right; ++i)
+            right += spans[i].len;
+        int length = right - x;
+
+        while (length) {
+            int l = qMin(buffer_size, length);
+            length -= l;
+
+            int process_length = l;
+            int process_x = x;
+
+            const uint *src = handler.fetch(process_x, y, process_length);
+            int offset = 0;
+            while (l > 0) {
+                if (x == spans->x) // new span?
+                    coverage = (spans->coverage * const_alpha) >> 8;
+
+                int right = spans->x + spans->len;
+                int len = qMin(l, right - x);
+
+                handler.process(x, y, len, coverage, src, offset);
+
+                l -= len;
+                x += len;
+                offset += len;
+
+                if (x == right) { // done with current span?
+                    ++spans;
+                    --count;
+                }
+            }
+            handler.store(process_x, y, process_length);
+        }
+    }
+}
+
+struct QBlendBase
+{
+    QBlendBase(QSpanData *d, Operator o)
+        : data(d)
+        , op(o)
+        , dest(0)
+    {
+    }
+
+    QSpanData *data;
+    Operator op;
+
+    uint *dest;
+
+    uint buffer[buffer_size];
+    uint src_buffer[buffer_size];
+};
+
+template <SpanMethod spanMethod>
+class BlendSrcGeneric : public QBlendBase
+{
+public:
+    BlendSrcGeneric(QSpanData *d, Operator o)
+        : QBlendBase(d, o)
+    {
+    }
+
+    const uint *fetch(int x, int y, int len)
+    {
+        if (spanMethod == RegularSpans)
+            dest = op.dest_fetch ? op.dest_fetch(buffer, data->rasterBuffer, x, y, len) : buffer;
+
+        return op.src_fetch(src_buffer, &op, data, y, x, len);
+    }
+
+    void process(int x, int y, int len, int coverage, const uint *src, int offset)
+    {
+        if (spanMethod == RegularSpans)
+            op.func(dest + offset, src + offset, len, coverage);
+        else
+            drawBufferSpan(data, src + offset, len, x, y, len, coverage);
+    }
+
+    void store(int x, int y, int len)
+    {
+        if (spanMethod == RegularSpans && op.dest_store) {
+            op.dest_store(data->rasterBuffer, x, y, dest, len);
+        }
+    }
+};
+
+template <SpanMethod spanMethod>
+Q_STATIC_TEMPLATE_FUNCTION void blend_src_generic(int count, const QSpan *spans, void *userData)
+{
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+    BlendSrcGeneric<spanMethod> blend(data, getOperator(data, spans, count));
+    handleSpans(count, spans, data, blend);
+}
+
+template <SpanMethod spanMethod>
+Q_STATIC_TEMPLATE_FUNCTION void blend_untransformed_generic(int count, const QSpan *spans, void *userData)
+{
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    uint buffer[buffer_size];
+    uint src_buffer[buffer_size];
+    Operator op = getOperator(data, spans, count);
+
+    const int image_width = data->texture.width;
+    const int image_height = data->texture.height;
+    int xoff = -qRound(-data->dx);
+    int yoff = -qRound(-data->dy);
+
+    while (count--) {
+        int x = spans->x;
+        int length = spans->len;
+        int sx = xoff + x;
+        int sy = yoff + spans->y;
+        if (sy >= 0 && sy < image_height && sx < image_width) {
+            if (sx < 0) {
+                x -= sx;
+                length += sx;
+                sx = 0;
+            }
+            if (sx + length > image_width)
+                length = image_width - sx;
+            if (length > 0) {
+                const int coverage = (spans->coverage * data->texture.const_alpha) >> 8;
+                while (length) {
+                    int l = qMin(buffer_size, length);
+                    const uint *src = op.src_fetch(src_buffer, &op, data, sy, sx, l);
+                    if (spanMethod == RegularSpans) {
+                        uint *dest = op.dest_fetch ? op.dest_fetch(buffer, data->rasterBuffer, x, spans->y, l) : buffer;
+                        op.func(dest, src, l, coverage);
+                        if (op.dest_store)
+                            op.dest_store(data->rasterBuffer, x, spans->y, dest, l);
+                    } else {
+                        drawBufferSpan(data, src, l, x, spans->y,
+                                       l, coverage);
+                    }
+                    x += l;
+                    sx += l;
+                    length -= l;
+                }
+            }
+        }
+        ++spans;
+    }
+}
+
+template <SpanMethod spanMethod>
+Q_STATIC_TEMPLATE_FUNCTION void blend_untransformed_argb(int count, const QSpan *spans, void *userData)
+{
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+    if (data->texture.format != QImage::Format_ARGB32_Premultiplied
+        && data->texture.format != QImage::Format_RGB32) {
+        blend_untransformed_generic<spanMethod>(count, spans, userData);
+        return;
+    }
+
+    Operator op = getOperator(data, spans, count);
+
+    const int image_width = data->texture.width;
+    const int image_height = data->texture.height;
+    int xoff = -qRound(-data->dx);
+    int yoff = -qRound(-data->dy);
+
+    while (count--) {
+        int x = spans->x;
+        int length = spans->len;
+        int sx = xoff + x;
+        int sy = yoff + spans->y;
+        if (sy >= 0 && sy < image_height && sx < image_width) {
+            if (sx < 0) {
+                x -= sx;
+                length += sx;
+                sx = 0;
+            }
+            if (sx + length > image_width)
+                length = image_width - sx;
+            if (length > 0) {
+                const int coverage = (spans->coverage * data->texture.const_alpha) >> 8;
+                const uint *src = (uint *)data->texture.scanLine(sy) + sx;
+                if (spanMethod == RegularSpans) {
+                    uint *dest = ((uint *)data->rasterBuffer->scanLine(spans->y)) + x;
+                    op.func(dest, src, length, coverage);
+                } else {
+                    drawBufferSpan(data, src, length, x,
+                                   spans->y, length, coverage);
+                }
+            }
+        }
+        ++spans;
+    }
+}
+
+static inline quint16 interpolate_pixel_rgb16_255(quint16 x, quint8 a,
+                                                  quint16 y, quint8 b)
+{
+    quint16 t = ((((x & 0x07e0) * a) + ((y & 0x07e0) * b)) >> 5) & 0x07e0;
+    t |= ((((x & 0xf81f) * a) + ((y & 0xf81f) * b)) >> 5) & 0xf81f;
+
+    return t;
+}
+
+static inline quint32 interpolate_pixel_rgb16x2_255(quint32 x, quint8 a,
+                                                    quint32 y, quint8 b)
+{
+    uint t;
+    t = ((((x & 0xf81f07e0) >> 5) * a) + (((y & 0xf81f07e0) >> 5) * b)) & 0xf81f07e0;
+    t |= ((((x & 0x07e0f81f) * a) + ((y & 0x07e0f81f) * b)) >> 5) & 0x07e0f81f;
+    return t;
+}
+
+static inline void blend_sourceOver_rgb16_rgb16(quint16 *dest,
+                                                const quint16 *src,
+                                                int length,
+                                                const quint8 alpha,
+                                                const quint8 ialpha)
+{
+    const int dstAlign = ((quintptr)dest) & 0x3;
+    if (dstAlign) {
+        *dest = interpolate_pixel_rgb16_255(*src, alpha, *dest, ialpha);
+        ++dest;
+        ++src;
+        --length;
+    }
+    const int srcAlign = ((quintptr)src) & 0x3;
+    int length32 = length >> 1;
+    if (length32 && srcAlign == 0) {
+        while (length32--) {
+            const quint32 *src32 = reinterpret_cast<const quint32*>(src);
+            quint32 *dest32 = reinterpret_cast<quint32*>(dest);
+            *dest32 = interpolate_pixel_rgb16x2_255(*src32, alpha,
+                                                    *dest32, ialpha);
+            dest += 2;
+            src += 2;
+        }
+        length &= 0x1;
+    }
+    while (length--) {
+        *dest = interpolate_pixel_rgb16_255(*src, alpha, *dest, ialpha);
+        ++dest;
+        ++src;
+    }
+}
+
+template <class DST, class SRC>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline void madd_2(DST *dest, const quint16 alpha, const SRC *src)
+{
+    Q_ASSERT((quintptr(dest) & 0x3) == 0);
+    Q_ASSERT((quintptr(src) & 0x3) == 0);
+    dest[0] = dest[0].byte_mul(alpha >> 8) + DST(src[0]);
+    dest[1] = dest[1].byte_mul(alpha & 0xff) + DST(src[1]);
+}
+
+template <class DST, class SRC>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline void madd_4(DST *dest, const quint32 alpha, const SRC *src)
+{
+    Q_ASSERT((quintptr(dest) & 0x3) == 0);
+    Q_ASSERT((quintptr(src) & 0x3) == 0);
+    dest[0] = dest[0].byte_mul(alpha >> 24) + DST(src[0]);
+    dest[1] = dest[1].byte_mul((alpha >> 16) & 0xff) + DST(src[1]);
+    dest[2] = dest[2].byte_mul((alpha >> 8) & 0xff) + DST(src[2]);
+    dest[3] = dest[3].byte_mul(alpha & 0xff) + DST(src[3]);
+}
+
+#if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline void madd_4(qargb8565 *dest, const quint32 a, const qargb8565 *src)
+{
+    Q_ASSERT((quintptr(dest) & 0x3) == 0);
+    Q_ASSERT((quintptr(src) & 0x3) == 0);
+
+    const quint32 *src32 = reinterpret_cast<const quint32*>(src);
+    quint32 *dest32 = reinterpret_cast<quint32*>(dest);
+    quint32 x, y, t;
+    quint8 a8;
+
+    {
+        x = dest32[0];
+        y = src32[0];
+
+        a8 = a >> 24;
+
+        // a0,g0
+        t = ((((x & 0x0007e0ff) * a8) >> 5) & 0x0007e0ff) + (y & 0x0007c0f8);
+
+        // r0,b0
+        t |= ((((x & 0x00f81f00) * a8) >> 5) & 0x00f81f00) + (y & 0x00f81f00);
+
+        a8 = (a >> 16) & 0xff;
+
+        // a1
+        t |= ((((x & 0xff000000) >> 5) * a8) & 0xff000000) + (y & 0xf8000000);
+
+        dest32[0] = t;
+    }
+    {
+        x = dest32[1];
+        y = src32[1];
+
+        // r1,b1
+        t = ((((x & 0x0000f81f) * a8) >> 5) & 0x0000f81f) + (y & 0x0000f81f);
+
+        // g1
+        t |= ((((x & 0x000007e0) * a8) >> 5) & 0x000007e0) + (y & 0x000007c0);
+
+        a8 = (a >> 8) & 0xff;
+
+        // a2
+        t |= ((((x & 0x00ff0000) * a8) >> 5)  & 0x00ff0000) + (y & 0x00f80000);
+
+        {
+            // rgb2
+            quint16 x16 = (x >> 24) | ((dest32[2] & 0x000000ff) << 8);
+            quint16 y16 = (y >> 24) | ((src32[2] & 0x000000ff) << 8);
+            quint16 t16;
+
+            t16 = ((((x16 & 0xf81f) * a8) >> 5) & 0xf81f)  + (y16 & 0xf81f);
+            t16 |= ((((x16 & 0x07e0) * a8) >> 5) & 0x07e0)  + (y16 & 0x07c0);
+
+            // rg2
+            t |= ((t16 & 0x00ff) << 24);
+
+            dest32[1] = t;
+
+            x = dest32[2];
+            y = src32[2];
+
+            // gb2
+            t = (t16 >> 8);
+        }
+    }
+    {
+        a8 = a & 0xff;
+
+        // g3,a3
+        t |= ((((x & 0x07e0ff00) * a8) >> 5) & 0x07e0ff00) + (y & 0x07c0f800);
+
+        // r3,b3
+        t |= ((((x & 0xf81f0000) >> 5) * a8) & 0xf81f0000)+ (y & 0xf81f0000);
+
+        dest32[2] = t;
+    }
+}
+#endif
+
+#if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline void madd_4(qargb8555 *dest, const quint32 a, const qargb8555 *src)
+{
+    Q_ASSERT((quintptr(dest) & 0x3) == 0);
+    Q_ASSERT((quintptr(src) & 0x3) == 0);
+
+    const quint32 *src32 = reinterpret_cast<const quint32*>(src);
+    quint32 *dest32 = reinterpret_cast<quint32*>(dest);
+    quint32 x, y, t;
+    quint8 a8;
+
+    {
+        x = dest32[0];
+        y = src32[0];
+
+        a8 = a >> 24;
+
+        // a0,g0
+        t = ((((x & 0x0003e0ff) * a8) >> 5) & 0x0003e0ff) + (y & 0x0003e0f8);
+
+        // r0,b0
+        t |= ((((x & 0x007c1f00) * a8) >> 5) & 0x007c1f00) + (y & 0x007c1f00);
+
+        a8 = (a >> 16) & 0xff;
+
+        // a1
+        t |= ((((x & 0xff000000) >> 5) * a8) & 0xff000000) + (y & 0xf8000000);
+
+        dest32[0] = t;
+    }
+    {
+        x = dest32[1];
+        y = src32[1];
+
+        // r1,b1
+        t = ((((x & 0x00007c1f) * a8) >> 5) & 0x00007c1f) + (y & 0x00007c1f);
+
+        // g1
+        t |= ((((x & 0x000003e0) * a8) >> 5) & 0x000003e0) + (y & 0x000003e0);
+
+        a8 = (a >> 8) & 0xff;
+
+        // a2
+        t |= ((((x & 0x00ff0000) * a8) >> 5)  & 0x00ff0000) + (y & 0x00f80000);
+
+        {
+            // rgb2
+            quint16 x16 = (x >> 24) | ((dest32[2] & 0x000000ff) << 8);
+            quint16 y16 = (y >> 24) | ((src32[2] & 0x000000ff) << 8);
+            quint16 t16;
+
+            t16 = ((((x16 & 0x7c1f) * a8) >> 5) & 0x7c1f)  + (y16 & 0x7c1f);
+            t16 |= ((((x16 & 0x03e0) * a8) >> 5) & 0x03e0)  + (y16 & 0x03e0);
+
+            // rg2
+            t |= ((t16 & 0x00ff) << 24);
+
+            dest32[1] = t;
+
+            x = dest32[2];
+            y = src32[2];
+
+            // gb2
+            t = (t16 >> 8);
+        }
+    }
+    {
+        a8 = a & 0xff;
+
+        // g3,a3
+        t |= ((((x & 0x03e0ff00) * a8) >> 5) & 0x03e0ff00) + (y & 0x03e0f800);
+
+        // r3,b3
+        t |= ((((x & 0x7c1f0000) >> 5) * a8) & 0x7c1f0000)+ (y & 0x7c1f0000);
+
+        dest32[2] = t;
+    }
+}
+#endif
+
+template <class T>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint16 alpha_2(const T *src)
+{
+    Q_ASSERT((quintptr(src) & 0x3) == 0);
+
+    if (T::hasAlpha())
+        return (src[0].alpha() << 8) | src[1].alpha();
+    else
+        return 0xffff;
+}
+
+template <class T>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint32 alpha_4(const T *src)
+{
+    Q_ASSERT((quintptr(src) & 0x3) == 0);
+
+    if (T::hasAlpha()) {
+        return (src[0].alpha() << 24) | (src[1].alpha() << 16)
+            | (src[2].alpha() << 8) | src[3].alpha();
+    } else {
+        return 0xffffffff;
+    }
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint32 alpha_4(const qargb8565 *src)
+{
+    const quint8 *src8 = reinterpret_cast<const quint8*>(src);
+    return src8[0] << 24 | src8[3] << 16 | src8[6] << 8 | src8[9];
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint32 alpha_4(const qargb6666 *src)
+{
+    const quint8 *src8 = reinterpret_cast<const quint8*>(src);
+    return ((src8[2] & 0xfc) | (src8[2] >> 6)) << 24
+        | ((src8[5] & 0xfc) | (src8[5] >> 6))  << 16
+        | ((src8[8] & 0xfc) | (src8[8] >> 6)) << 8
+        | ((src8[11] & 0xfc) | (src8[11] >> 6));
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint32 alpha_4(const qargb8555 *src)
+{
+    Q_ASSERT((quintptr(src) & 0x3) == 0);
+    const quint8 *src8 = reinterpret_cast<const quint8*>(src);
+    return src8[0] << 24 | src8[3] << 16 | src8[6] << 8 | src8[9];
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint16 alpha_2(const qargb4444 *src)
+{
+    const quint32 *src32 = reinterpret_cast<const quint32*>(src);
+    const quint32 t = (*src32 & 0xf000f000) |
+                      ((*src32 & 0xf000f000) >> 4);
+    return (t >> 24) | (t & 0xff00);
+}
+
+template <class T>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint16 eff_alpha_2(quint16 alpha, const T*)
+{
+    return (T::alpha((alpha >> 8) & 0xff) << 8)
+        | T::alpha(alpha & 0xff);
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint16 eff_alpha_2(quint16 a, const qrgb565*)
+{
+    return ((((a & 0xff00) + 0x0100) >> 3) & 0xff00)
+        | ((((a & 0x00ff) + 0x0001) >> 3) & 0x00ff);
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint16 eff_alpha_2(quint16 a, const qrgb444*)
+{
+    return (((a & 0x00ff) + 0x0001) >> 4)
+        | ((((a & 0xff00) + 0x0100) >> 4) & 0xff00);
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint16 eff_alpha_2(quint16 a, const qargb4444*)
+{
+    return (((a & 0x00ff) + 0x0001) >> 4)
+        | ((((a & 0xff00) + 0x0100) >> 4) & 0xff00);
+}
+
+template <class T>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint16 eff_ialpha_2(quint16 alpha, const T*)
+{
+    return (T::ialpha((alpha >> 8) & 0xff) << 8)
+        | T::ialpha(alpha & 0xff);
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint16 eff_ialpha_2(quint16 a, const qrgb565 *dummy)
+{
+    return 0x2020 - eff_alpha_2(a, dummy);
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint16 eff_ialpha_2(quint16 a, const qargb4444 *dummy)
+{
+    return 0x1010 - eff_alpha_2(a, dummy);
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint16 eff_ialpha_2(quint16 a, const qrgb444 *dummy)
+{
+    return 0x1010 - eff_alpha_2(a, dummy);
+}
+
+template <class T>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint32 eff_alpha_4(quint32 alpha, const T*)
+{
+    return (T::alpha(alpha >> 24) << 24)
+        | (T::alpha((alpha >> 16) & 0xff) << 16)
+        | (T::alpha((alpha >> 8) & 0xff) << 8)
+        | T::alpha(alpha & 0xff);
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint32 eff_alpha_4(quint32 a, const qrgb888*)
+{
+    return a;
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint32 eff_alpha_4(quint32 a, const qargb8565*)
+{
+    return ((((a & 0xff00ff00) + 0x01000100) >> 3) & 0xff00ff00)
+        | ((((a & 0x00ff00ff) + 0x00010001) >> 3) & 0x00ff00ff);
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint32 eff_alpha_4(quint32 a, const qargb6666*)
+{
+    return ((((a & 0xff00ff00) >> 2) + 0x00400040) & 0xff00ff00)
+        | ((((a & 0x00ff00ff) + 0x00010001) >> 2) & 0x00ff00ff);
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint32 eff_alpha_4(quint32 a, const qrgb666*)
+{
+    return ((((a & 0xff00ff00) >> 2) + 0x00400040) & 0xff00ff00)
+        | ((((a & 0x00ff00ff) + 0x00010001) >> 2) & 0x00ff00ff);
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint32 eff_alpha_4(quint32 a, const qargb8555*)
+{
+    return ((((a & 0xff00ff00) + 0x01000100) >> 3) & 0xff00ff00)
+        | ((((a & 0x00ff00ff) + 0x00010001) >> 3) & 0x00ff00ff);
+}
+
+template <class T>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint32 eff_ialpha_4(quint32 alpha, const T*)
+{
+    return (T::ialpha(alpha >> 24) << 24)
+        | (T::ialpha((alpha >> 16) & 0xff) << 16)
+        | (T::ialpha((alpha >> 8) & 0xff) << 8)
+        | T::ialpha(alpha & 0xff);
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint32 eff_ialpha_4(quint32 a, const qrgb888*)
+{
+    return ~a;
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint32 eff_ialpha_4(quint32 a, const qargb8565 *dummy)
+{
+    return 0x20202020 - eff_alpha_4(a, dummy);
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint32 eff_ialpha_4(quint32 a, const qargb6666 *dummy)
+{
+    return 0x40404040 - eff_alpha_4(a, dummy);
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint32 eff_ialpha_4(quint32 a, const qrgb666 *dummy)
+{
+    return 0x40404040 - eff_alpha_4(a, dummy);
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint32 eff_ialpha_4(quint32 a, const qargb8555 *dummy)
+{
+    return 0x20202020 - eff_alpha_4(a, dummy);
+}
+
+template <class DST, class SRC>
+inline void interpolate_pixel_unaligned_2(DST *dest, const SRC *src,
+                                          quint16 alpha)
+{
+    const quint16 a = eff_alpha_2(alpha, dest);
+    const quint16 ia = eff_ialpha_2(alpha, dest);
+    dest[0] = DST(src[0]).byte_mul(a >> 8) + dest[0].byte_mul(ia >> 8);
+    dest[1] = DST(src[1]).byte_mul(a & 0xff) + dest[1].byte_mul(ia & 0xff);
+}
+
+template <class DST, class SRC>
+inline void interpolate_pixel_2(DST *dest, const SRC *src, quint16 alpha)
+{
+    Q_ASSERT((quintptr(dest) & 0x3) == 0);
+    Q_ASSERT((quintptr(src) & 0x3) == 0);
+
+    const quint16 a = eff_alpha_2(alpha, dest);
+    const quint16 ia = eff_ialpha_2(alpha, dest);
+
+    dest[0] = DST(src[0]).byte_mul(a >> 8) + dest[0].byte_mul(ia >> 8);
+    dest[1] = DST(src[1]).byte_mul(a & 0xff) + dest[1].byte_mul(ia & 0xff);
+}
+
+template <class DST, class SRC>
+inline void interpolate_pixel(DST &dest, quint8 a, const SRC &src, quint8 b)
+{
+    if (SRC::hasAlpha() && !DST::hasAlpha())
+        interpolate_pixel(dest, a, DST(src), b);
+    else
+        dest = dest.byte_mul(a) + DST(src).byte_mul(b);
+}
+
+template <>
+inline void interpolate_pixel(qargb8565 &dest, quint8 a,
+                              const qargb8565 &src, quint8 b)
+{
+    quint8 *d = reinterpret_cast<quint8*>(&dest);
+    const quint8 *s = reinterpret_cast<const quint8*>(&src);
+    d[0] = (d[0] * a + s[0] * b) >> 5;
+
+    const quint16 x = (d[2] << 8) | d[1];
+    const quint16 y = (s[2] << 8) | s[1];
+    quint16 t = (((x & 0x07e0) * a + (y & 0x07e0) * b) >> 5) & 0x07e0;
+    t |= (((x & 0xf81f) * a + (y & 0xf81f) * b) >> 5) & 0xf81f;
+
+    d[1] = t & 0xff;
+    d[2] = t >> 8;
+}
+
+template <>
+inline void interpolate_pixel(qrgb565 &dest, quint8 a,
+                              const qrgb565 &src, quint8 b)
+{
+    const quint16 x = dest.rawValue();
+    const quint16 y = src.rawValue();
+    quint16 t = (((x & 0x07e0) * a + (y & 0x07e0) * b) >> 5) & 0x07e0;
+    t |= (((x & 0xf81f) * a + (y & 0xf81f) * b) >> 5) & 0xf81f;
+    dest = t;
+}
+
+template <>
+inline void interpolate_pixel(qrgb555 &dest, quint8 a,
+                              const qrgb555 &src, quint8 b)
+{
+    const quint16 x = dest.rawValue();
+    const quint16 y = src.rawValue();
+    quint16 t = (((x & 0x03e0) * a + (y & 0x03e0) * b) >> 5) & 0x03e0;
+    t |= ((((x & 0x7c1f) * a) + ((y & 0x7c1f) * b)) >> 5) & 0x7c1f;
+    dest = t;
+}
+
+template <>
+inline void interpolate_pixel(qrgb444 &dest, quint8 a,
+                              const qrgb444 &src, quint8 b)
+{
+    const quint16 x = dest.rawValue();
+    const quint16 y = src.rawValue();
+    quint16 t = ((x & 0x00f0) * a + (y & 0x00f0) * b) & 0x0f00;
+    t |= ((x & 0x0f0f) * a + (y & 0x0f0f) * b) & 0xf0f0;
+    quint16 *d = reinterpret_cast<quint16*>(&dest);
+    *d = (t >> 4);
+}
+
+template <class DST, class SRC>
+inline void interpolate_pixel_2(DST *dest, quint8 a,
+                                const SRC *src, quint8 b)
+{
+    Q_ASSERT((quintptr(dest) & 0x3) == 0);
+    Q_ASSERT((quintptr(src) & 0x3) == 0);
+
+    Q_ASSERT(!SRC::hasAlpha());
+
+    dest[0] = dest[0].byte_mul(a) + DST(src[0]).byte_mul(b);
+    dest[1] = dest[1].byte_mul(a) + DST(src[1]).byte_mul(b);
+}
+
+template <>
+inline void interpolate_pixel_2(qrgb565 *dest, quint8 a,
+                                const qrgb565 *src, quint8 b)
+{
+    quint32 *x = reinterpret_cast<quint32*>(dest);
+    const quint32 *y = reinterpret_cast<const quint32*>(src);
+    quint32 t = (((*x & 0xf81f07e0) >> 5) * a +
+                 ((*y & 0xf81f07e0) >> 5) * b) & 0xf81f07e0;
+    t |= (((*x & 0x07e0f81f) * a
+           + (*y & 0x07e0f81f) * b) >> 5) & 0x07e0f81f;
+    *x = t;
+}
+
+template <>
+inline void interpolate_pixel_2(qrgb555 *dest, quint8 a,
+                                const qrgb555 *src, quint8 b)
+{
+    quint32 *x = reinterpret_cast<quint32*>(dest);
+    const quint32 *y = reinterpret_cast<const quint32*>(src);
+    quint32 t = (((*x & 0x7c1f03e0) >> 5) * a +
+                 ((*y & 0x7c1f03e0) >> 5) * b) & 0x7c1f03e0;
+    t |= (((*x & 0x03e07c1f) * a
+           + (*y & 0x03e07c1f) * b) >> 5) & 0x03e07c1f;
+    *x = t;
+}
+
+template <>
+inline void interpolate_pixel_2(qrgb444 *dest, quint8 a,
+                                const qrgb444 *src, quint8 b)
+{
+    quint32 *x = reinterpret_cast<quint32*>(dest);
+    const quint32 *y = reinterpret_cast<const quint32*>(src);
+    quint32 t = ((*x & 0x0f0f0f0f) * a + (*y & 0x0f0f0f0f) * b) & 0xf0f0f0f0;
+    t |= ((*x & 0x00f000f0) * a + (*y & 0x00f000f0) * b) & 0x0f000f00;
+    *x = t >> 4;
+}
+
+template <class DST, class SRC>
+inline void interpolate_pixel_4(DST *dest, const SRC *src, quint32 alpha)
+{
+    Q_ASSERT((quintptr(dest) & 0x3) == 0);
+    Q_ASSERT((quintptr(src) & 0x3) == 0);
+
+    const quint32 a = eff_alpha_4(alpha, dest);
+    const quint32 ia = eff_ialpha_4(alpha, dest);
+    dest[0] = DST(src[0]).byte_mul(a >> 24)
+              + dest[0].byte_mul(ia >> 24);
+    dest[1] = DST(src[1]).byte_mul((a >> 16) & 0xff)
+              + dest[1].byte_mul((ia >> 16) & 0xff);
+    dest[2] = DST(src[2]).byte_mul((a >> 8) & 0xff)
+              + dest[2].byte_mul((ia >> 8) & 0xff);
+    dest[3] = DST(src[3]).byte_mul(a & 0xff)
+              + dest[3].byte_mul(ia & 0xff);
+}
+
+#if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
+template <>
+inline void interpolate_pixel_4(qargb8565 *dest, const qargb8565 *src,
+                                quint32 alpha)
+{
+    Q_ASSERT((quintptr(dest) & 0x3) == 0);
+    Q_ASSERT((quintptr(src) & 0x3) == 0);
+
+    const quint32 a = eff_alpha_4(alpha, dest);
+    const quint32 ia = eff_ialpha_4(alpha, dest);
+    const quint32 *src32 = reinterpret_cast<const quint32*>(src);
+    quint32 *dest32 = reinterpret_cast<quint32*>(dest);
+
+    quint32 x, y, t;
+    quint8 a8, ia8;
+    {
+        x = src32[0];
+        y = dest32[0];
+
+        a8 = a >> 24;
+        ia8 = ia >> 24;
+
+        // a0,g0
+        t = (((x & 0x0007e0ff) * a8 + (y & 0x0007e0ff) * ia8) >> 5)
+            & 0x0007e0ff;
+
+        // r0,b0
+        t |= (((x & 0x00f81f00) * a8 + (y & 0x00f81f00) * ia8) >> 5)
+             & 0x00f81f00;
+
+        a8 = (a >> 16) & 0xff;
+        ia8 = (ia >> 16) & 0xff;
+
+        // a1
+        t |= (((x & 0xff000000) >> 5) * a8 + ((y & 0xff000000) >> 5) * ia8)
+             & 0xff000000;
+
+        dest32[0] = t;
+    }
+    {
+        x = src32[1];
+        y = dest32[1];
+
+        // r1,b1
+        t = (((x & 0x0000f81f) * a8 + (y & 0x0000f81f) * ia8) >> 5)
+            & 0x0000f81f;
+
+        // g1
+        t |= (((x & 0x000007e0) * a8 + (y & 0x000007e0) * ia8) >> 5)
+             & 0x000007e0;
+
+        a8 = (a >> 8) & 0xff;
+        ia8 = (ia >> 8) & 0xff;
+
+        // a2
+        t |= (((x & 0x00ff0000) * a8 + (y & 0x00ff0000) * ia8) >> 5)
+             & 0x00ff0000;
+
+        {
+            // rgb2
+            quint16 x16 = (x >> 24) | ((src32[2] & 0x000000ff) << 8);
+            quint16 y16 = (y >> 24) | ((dest32[2] & 0x000000ff) << 8);
+            quint16 t16;
+
+            t16 = (((x16 & 0xf81f) * a8 + (y16 & 0xf81f) * ia8) >> 5) & 0xf81f;
+            t16 |= (((x16 & 0x07e0) * a8 + (y16 & 0x07e0) * ia8) >> 5) & 0x07e0;
+
+            // rg2
+            t |= ((t16 & 0x00ff) << 24);
+
+            dest32[1] = t;
+
+            x = src32[2];
+            y = dest32[2];
+
+            // gb2
+            t = (t16 >> 8);
+        }
+    }
+    {
+        a8 = a & 0xff;
+        ia8 = ia & 0xff;
+
+        // g3,a3
+        t |= (((x & 0x07e0ff00) * a8 + (y & 0x07e0ff00) * ia8) >> 5)
+             & 0x07e0ff00;
+
+        // r3,b3
+        t |= (((x & 0xf81f0000) >> 5) * a8 + ((y & 0xf81f0000) >> 5) * ia8)
+             & 0xf81f0000;
+
+        dest32[2] = t;
+    }
+}
+#endif
+
+#if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
+template <>
+inline void interpolate_pixel_4(qargb8555 *dest, const qargb8555 *src,
+                                quint32 alpha)
+{
+    Q_ASSERT((quintptr(dest) & 0x3) == 0);
+    Q_ASSERT((quintptr(src) & 0x3) == 0);
+
+
+    const quint32 a = eff_alpha_4(alpha, dest);
+    const quint32 ia = eff_ialpha_4(alpha, dest);
+    const quint32 *src32 = reinterpret_cast<const quint32*>(src);
+    quint32 *dest32 = reinterpret_cast<quint32*>(dest);
+
+    quint32 x, y, t;
+    quint8 a8, ia8;
+    {
+        x = src32[0];
+        y = dest32[0];
+
+        a8 = a >> 24;
+        ia8 = ia >> 24;
+
+        // a0,g0
+        t = (((x & 0x0003e0ff) * a8 + (y & 0x0003e0ff) * ia8) >> 5)
+            & 0x0003e0ff;
+
+        // r0,b0
+        t |= (((x & 0x007c1f00) * a8 + (y & 0x007c1f00) * ia8) >> 5)
+             & 0x007c1f00;
+
+        a8 = (a >> 16) & 0xff;
+        ia8 = (ia >> 16) & 0xff;
+
+        // a1
+        t |= (((x & 0xff000000) >> 5) * a8 + ((y & 0xff000000) >> 5) * ia8)
+             & 0xff000000;
+
+        dest32[0] = t;
+    }
+    {
+        x = src32[1];
+        y = dest32[1];
+
+        // r1,b1
+        t = (((x & 0x00007c1f) * a8 + (y & 0x00007c1f) * ia8) >> 5)
+            & 0x00007c1f;
+
+        // g1
+        t |= (((x & 0x000003e0) * a8 + (y & 0x000003e0) * ia8) >> 5)
+             & 0x000003e0;
+
+        a8 = (a >> 8) & 0xff;
+        ia8 = (ia >> 8) & 0xff;
+
+        // a2
+        t |= (((x & 0x00ff0000) * a8 + (y & 0x00ff0000) * ia8) >> 5)
+             & 0x00ff0000;
+
+        {
+            // rgb2
+            quint16 x16 = (x >> 24) | ((src32[2] & 0x000000ff) << 8);
+            quint16 y16 = (y >> 24) | ((dest32[2] & 0x000000ff) << 8);
+            quint16 t16;
+
+            t16 = (((x16 & 0x7c1f) * a8 + (y16 & 0x7c1f) * ia8) >> 5) & 0x7c1f;
+            t16 |= (((x16 & 0x03e0) * a8 + (y16 & 0x03e0) * ia8) >> 5) & 0x03e0;
+
+            // rg2
+            t |= ((t16 & 0x00ff) << 24);
+
+            dest32[1] = t;
+
+            x = src32[2];
+            y = dest32[2];
+
+            // gb2
+            t = (t16 >> 8);
+        }
+    }
+    {
+        a8 = a & 0xff;
+        ia8 = ia & 0xff;
+
+        // g3,a3
+        t |= (((x & 0x03e0ff00) * a8 + (y & 0x03e0ff00) * ia8) >> 5)
+             & 0x03e0ff00;
+
+        // r3,b3
+        t |= (((x & 0x7c1f0000) >> 5) * a8 + ((y & 0x7c1f0000) >> 5) * ia8)
+             & 0x7c1f0000;
+
+        dest32[2] = t;
+    }
+}
+#endif
+
+template <>
+inline void interpolate_pixel_4(qrgb888 *dest, const qrgb888 *src,
+                                quint32 alpha)
+{
+    Q_ASSERT((quintptr(dest) & 0x3) == 0);
+    Q_ASSERT((quintptr(src) & 0x3) == 0);
+
+    const quint32 a = eff_alpha_4(alpha, dest);
+    const quint32 ia = eff_ialpha_4(alpha, dest);
+    const quint32 *src32 = reinterpret_cast<const quint32*>(src);
+    quint32 *dest32 = reinterpret_cast<quint32*>(dest);
+
+    {
+        quint32 x = src32[0];
+        quint32 y = dest32[0];
+
+        quint32 t;
+        t = ((x >> 8) & 0xff00ff) * (a >> 24)
+            + ((y >> 8) & 0xff00ff) * (ia >> 24);
+        t = (t + ((t >> 8) & 0xff00ff) + 0x800080);
+        t &= 0xff00ff00;
+
+        x = (x & 0xff0000) * (a >> 24)
+            + (x & 0x0000ff) * ((a >> 16) & 0xff)
+            + (y & 0xff0000) * (ia >> 24)
+            + (y & 0x0000ff) * ((ia >> 16) & 0xff);
+        x = (x + ((x >> 8) & 0xff00ff) + 0x800080) >> 8;
+        x &= 0x00ff00ff;
+
+        dest32[0] = x | t;
+    }
+    {
+        quint32 x = src32[1];
+        quint32 y = dest32[1];
+
+        quint32 t;
+        t = ((x >> 8) & 0xff0000) * ((a >> 16) & 0xff)
+            + ((x >> 8) & 0x0000ff) * ((a >> 8) & 0xff)
+            + ((y >> 8) & 0xff0000) * ((ia >> 16) & 0xff)
+            + ((y >> 8) & 0x0000ff) * ((ia >> 8) & 0xff);
+        t = (t + ((t >> 8) & 0xff00ff) + 0x800080);
+        t &= 0xff00ff00;
+
+        x = (x & 0xff0000) * ((a >> 16) & 0xff)
+            + (x & 0x0000ff) * ((a >> 8) & 0xff)
+            + (y & 0xff0000) * ((ia >> 16) & 0xff)
+            + (y & 0x0000ff) * ((ia >> 8) & 0xff);
+        x = (x + ((x >> 8) & 0xff00ff) + 0x800080) >> 8;
+        x &= 0x00ff00ff;
+
+        dest32[1] = x | t;
+    }
+    {
+        quint32 x = src32[2];
+        quint32 y = dest32[2];
+
+        quint32 t;
+        t = ((x >> 8) & 0xff0000) * ((a >> 8) & 0xff)
+            + ((x >> 8) & 0x0000ff) * (a & 0xff)
+            + ((y >> 8) & 0xff0000) * ((ia >> 8) & 0xff)
+            + ((y >> 8) & 0x0000ff) * (ia & 0xff);
+        t = (t + ((t >> 8) & 0xff00ff) + 0x800080);
+        t &= 0xff00ff00;
+
+        x = (x & 0xff00ff) * (a & 0xff)
+            + (y & 0xff00ff) * (ia & 0xff);
+        x = (x + ((x >> 8) & 0xff00ff) + 0x800080) >> 8;
+        x &= 0x00ff00ff;
+
+        dest32[2] = x | t;
+    }
+}
+
+template <class DST, class SRC>
+inline void interpolate_pixel_4(DST *dest, quint8 a,
+                                const SRC *src, quint8 b)
+{
+    Q_ASSERT((quintptr(dest) & 0x3) == 0);
+    Q_ASSERT((quintptr(src) & 0x3) == 0);
+
+    dest[0] = dest[0].byte_mul(a) + DST(src[0]).byte_mul(b);
+    dest[1] = dest[1].byte_mul(a) + DST(src[1]).byte_mul(b);
+    dest[2] = dest[2].byte_mul(a) + DST(src[2]).byte_mul(b);
+    dest[3] = dest[3].byte_mul(a) + DST(src[3]).byte_mul(b);
+}
+
+template <class DST, class SRC>
+inline void blend_sourceOver_4(DST *dest, const SRC *src)
+{
+    Q_ASSERT((quintptr(dest) & 0x3) == 0);
+    Q_ASSERT((quintptr(src) & 0x3) == 0);
+
+    const quint32 a = alpha_4(src);
+    if (a == 0xffffffff) {
+        qt_memconvert(dest, src, 4);
+    } else if (a > 0) {
+        quint32 buf[3]; // array of quint32 to get correct alignment
+        qt_memconvert((DST*)(void*)buf, src, 4);
+        madd_4(dest, eff_ialpha_4(a, dest), (DST*)(void*)buf);
+    }
+}
+
+template <>
+inline void blend_sourceOver_4(qargb8565 *dest, const qargb8565 *src)
+{
+    Q_ASSERT((quintptr(dest) & 0x3) == 0);
+    Q_ASSERT((quintptr(src) & 0x3) == 0);
+
+    const quint32 a = alpha_4(src);
+    if (a == 0xffffffff) {
+        qt_memconvert(dest, src, 4);
+    } else if (a > 0) {
+        madd_4(dest, eff_ialpha_4(a, dest), src);
+    }
+}
+
+template <>
+inline void blend_sourceOver_4(qargb8555 *dest, const qargb8555 *src)
+{
+    Q_ASSERT((quintptr(dest) & 0x3) == 0);
+    Q_ASSERT((quintptr(src) & 0x3) == 0);
+
+    const quint32 a = alpha_4(src);
+    if (a == 0xffffffff) {
+        qt_memconvert(dest, src, 4);
+    } else if (a > 0) {
+        madd_4(dest, eff_ialpha_4(a, dest), src);
+    }
+}
+
+template <>
+inline void blend_sourceOver_4(qargb6666 *dest, const qargb6666 *src)
+{
+    Q_ASSERT((quintptr(dest) & 0x3) == 0);
+    Q_ASSERT((quintptr(src) & 0x3) == 0);
+
+    const quint32 a = alpha_4(src);
+    if (a == 0xffffffff) {
+        qt_memconvert(dest, src, 4);
+    } else if (a > 0) {
+        madd_4(dest, eff_ialpha_4(a, dest), src);
+    }
+}
+
+template <class DST, class SRC>
+void QT_FASTCALL blendUntransformed_unaligned(DST *dest, const SRC *src,
+                                              quint8 coverage, int length)
+{
+    Q_ASSERT(coverage > 0);
+
+    if (coverage < 255) {
+        if (SRC::hasAlpha()) {
+            for (int i = 0; i < length; ++i) {
+                if (src[i].alpha()) {
+                    const quint8 alpha = qt_div_255(int(src[i].alpha()) * int(coverage));
+                    interpolate_pixel(dest[i], DST::ialpha(alpha),
+                            src[i], DST::alpha(alpha));
+                }
+            }
+        } else {
+            const quint8 alpha = DST::alpha(coverage);
+            const quint8 ialpha = DST::ialpha(coverage);
+            if (alpha) {
+                for (int i = 0; i < length; ++i)
+                    interpolate_pixel(dest[i], ialpha, src[i], alpha);
+            }
+        }
+        return;
+    }
+
+    Q_ASSERT(coverage == 0xff);
+    Q_ASSERT(SRC::hasAlpha());
+
+    if (SRC::hasAlpha()) {
+        for (int i = 0; i < length; ++i) {
+            const quint8 a = src->alpha();
+            if (a == 0xff)
+                *dest = DST(*src);
+            else if (a > 0) {
+                if (DST::hasAlpha())
+                    *dest = DST(*src).truncedAlpha() + dest->byte_mul(DST::ialpha(a));
+                else
+                    *dest = DST(SRC(*src).truncedAlpha()) + dest->byte_mul(DST::ialpha(a));
+            }
+            ++src;
+            ++dest;
+        }
+    }
+}
+
+template <class DST, class SRC>
+void QT_FASTCALL blendUntransformed_dest16(DST *dest, const SRC *src,
+                                           quint8 coverage, int length)
+{
+    Q_ASSERT(sizeof(DST) == 2);
+    Q_ASSERT(sizeof(SRC) == 2);
+    Q_ASSERT((quintptr(dest) & 0x3) == (quintptr(src) & 0x3));
+    Q_ASSERT(coverage > 0);
+
+    const int align = quintptr(dest) & 0x3;
+
+    if (coverage < 255) {
+        // align
+        if (align) {
+            const quint8 alpha = SRC::hasAlpha()
+                                 ? qt_div_255(int(src->alpha()) * int(coverage))
+                                 : coverage;
+            if (alpha) {
+                interpolate_pixel(*dest, DST::ialpha(alpha),
+                                  *src, DST::alpha(alpha));
+            }
+            ++dest;
+            ++src;
+            --length;
+        }
+
+        if (SRC::hasAlpha()) {
+            while (length >= 2) {
+                const quint16 alpha16 = BYTE_MUL(uint(alpha_2(src)), uint(coverage));
+                interpolate_pixel_2(dest, src, alpha16);
+                length -= 2;
+                src += 2;
+                dest += 2;
+            }
+        } else {
+            const quint8 alpha = DST::alpha(coverage);
+            const quint8 ialpha = DST::ialpha(coverage);
+
+            while (length >= 2) {
+                interpolate_pixel_2(dest, ialpha, src, alpha);
+                length -= 2;
+                src += 2;
+                dest += 2;
+            }
+        }
+
+        // tail
+        if (length) {
+            const quint8 alpha = SRC::hasAlpha()
+                                 ? qt_div_255(int(src->alpha()) * int(coverage))
+                                 : coverage;
+            if (alpha) {
+                interpolate_pixel(*dest, DST::ialpha(alpha),
+                                  *src, DST::alpha(alpha));
+            }
+        }
+
+        return;
+    }
+
+    Q_ASSERT(SRC::hasAlpha());
+    if (SRC::hasAlpha()) {
+        if (align) {
+            const quint8 alpha = src->alpha();
+            if (alpha == 0xff)
+                *dest = DST(*src);
+            else if (alpha > 0)
+                *dest = DST(*src).truncedAlpha() + dest->byte_mul(DST::ialpha(alpha));
+            ++dest;
+            ++src;
+            --length;
+        }
+
+        while (length >= 2) {
+            Q_ASSERT((quintptr(dest) & 3) == 0);
+            Q_ASSERT((quintptr(src) & 3) == 0);
+
+            const quint16 a = alpha_2(src);
+            if (a == 0xffff) {
+                qt_memconvert(dest, src, 2);
+            } else if (a > 0) {
+                quint32 buf;
+                if (sizeof(DST) == 2)
+                    qt_memconvert((DST*)(void*)&buf, src, 2);
+                madd_2(dest, eff_ialpha_2(a, dest), (DST*)(void*)&buf);
+            }
+
+            length -= 2;
+            src += 2;
+            dest += 2;
+        }
+
+        if (length) {
+            const quint8 alpha = src->alpha();
+            if (alpha == 0xff)
+                *dest = DST(*src);
+            else if (alpha > 0)
+                *dest = DST(*src).truncedAlpha() + dest->byte_mul(DST::ialpha(alpha));
+        }
+    }
+}
+
+template <class DST, class SRC>
+void QT_FASTCALL blendUntransformed_dest24(DST *dest, const SRC *src,
+                                           quint8 coverage, int length)
+{
+    Q_ASSERT((quintptr(dest) & 0x3) == (quintptr(src) & 0x3));
+    Q_ASSERT(sizeof(DST) == 3);
+    Q_ASSERT(coverage > 0);
+
+    const int align = quintptr(dest) & 0x3;
+
+    if (coverage < 255) {
+        // align
+        for (int i = 0; i < align; ++i) {
+            if (SRC::hasAlpha()) {
+                const quint8 alpha = qt_div_255(int(src->alpha()) * int(coverage));
+                if (alpha)
+                    interpolate_pixel(*dest, DST::ialpha(alpha),
+                                      *src, DST::alpha(alpha));
+            } else {
+                interpolate_pixel(*dest, DST::ialpha(coverage),
+                                  *src, DST::alpha(coverage));
+            }
+            ++dest;
+            ++src;
+            --length;
+        }
+
+        if (SRC::hasAlpha()) {
+            while (length >= 4) {
+                const quint32 alpha = QT_PREPEND_NAMESPACE(BYTE_MUL)(uint(alpha_4(src)), uint(coverage));
+                if (alpha)
+                    interpolate_pixel_4(dest, src, alpha);
+                length -= 4;
+                src += 4;
+                dest += 4;
+            }
+        } else {
+            const quint8 alpha = DST::alpha(coverage);
+            const quint8 ialpha = DST::ialpha(coverage);
+            while (length >= 4) {
+                interpolate_pixel_4(dest, ialpha, src, alpha);
+                length -= 4;
+                src += 4;
+                dest += 4;
+            }
+        }
+
+        // tail
+        while (length--) {
+            if (SRC::hasAlpha()) {
+                const quint8 alpha = qt_div_255(int(src->alpha()) * int(coverage));
+                if (alpha)
+                    interpolate_pixel(*dest, DST::ialpha(alpha),
+                                      *src, DST::alpha(alpha));
+            } else {
+                interpolate_pixel(*dest, DST::ialpha(coverage),
+                                  *src, DST::alpha(coverage));
+            }
+            ++dest;
+            ++src;
+        }
+
+        return;
+    }
+
+
+    Q_ASSERT(coverage == 255);
+    Q_ASSERT(SRC::hasAlpha());
+
+    if (SRC::hasAlpha()) {
+        // align
+        for (int i = 0; i < align; ++i) {
+            const quint8 a = src->alpha();
+            if (a == 0xff) {
+                *dest = DST(*src);
+            } else if (a > 0) {
+                *dest = DST(*src).truncedAlpha() + dest->byte_mul(DST::ialpha(a));
+            }
+            ++dest;
+            ++src;
+            --length;
+        }
+
+        while (length >= 4) {
+            blend_sourceOver_4(dest, src);
+            length -= 4;
+            src += 4;
+            dest += 4;
+        }
+
+        // tail
+        while (length--) {
+            const quint8 a = src->alpha();
+            if (a == 0xff) {
+                *dest = DST(*src);
+            } else if (a > 0) {
+                *dest = DST(*src).truncedAlpha() + dest->byte_mul(DST::ialpha(a));
+            }
+            ++dest;
+            ++src;
+        }
+    }
+}
+
+template <class DST, class SRC>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+void QT_FASTCALL blendUntransformed(int count, const QSpan *spans, void *userData)
+{
+    QSpanData *data = reinterpret_cast<QSpanData*>(userData);
+    QPainter::CompositionMode mode = data->rasterBuffer->compositionMode;
+
+    if (mode != QPainter::CompositionMode_SourceOver &&
+        mode != QPainter::CompositionMode_Source)
+    {
+        blend_src_generic<RegularSpans>(count, spans, userData);
+        return;
+    }
+
+    const bool modeSource = !SRC::hasAlpha() ||
+                            mode == QPainter::CompositionMode_Source;
+    const int image_width = data->texture.width;
+    const int image_height = data->texture.height;
+    int xoff = -qRound(-data->dx);
+    int yoff = -qRound(-data->dy);
+
+    while (count--) {
+        const quint8 coverage = (data->texture.const_alpha * spans->coverage) >> 8;
+        if (coverage == 0) {
+            ++spans;
+            continue;
+        }
+
+        int x = spans->x;
+        int length = spans->len;
+        int sx = xoff + x;
+        int sy = yoff + spans->y;
+        if (sy >= 0 && sy < image_height && sx < image_width) {
+            if (sx < 0) {
+                x -= sx;
+                length += sx;
+                sx = 0;
+            }
+            if (sx + length > image_width)
+                length = image_width - sx;
+            if (length > 0) {
+                DST *dest = ((DST*)data->rasterBuffer->scanLine(spans->y)) + x;
+                const SRC *src = (SRC*)data->texture.scanLine(sy) + sx;
+                if (modeSource && coverage == 255) {
+                    qt_memconvert<DST, SRC>(dest, src, length);
+                } else if (sizeof(DST) == 3 && sizeof(SRC) == 3 && length >= 3 &&
+                           (quintptr(dest) & 3) == (quintptr(src) & 3))
+                {
+                    blendUntransformed_dest24(dest, src, coverage, length);
+                } else if (sizeof(DST) == 2 && sizeof(SRC) == 2 && length >= 3 &&
+                           (quintptr(dest) & 3) == (quintptr(src) & 3))
+                {
+                    blendUntransformed_dest16(dest, src, coverage, length);
+                } else {
+                    blendUntransformed_unaligned(dest, src, coverage, length);
+                }
+            }
+        }
+        ++spans;
+    }
+}
+
+static void blend_untransformed_rgb888(int count, const QSpan *spans,
+                                       void *userData)
+{
+#if defined(QT_QWS_DEPTH_24)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_RGB888)
+        blendUntransformed<qrgb888, qrgb888>(count, spans, userData);
+    else
+#endif
+        blend_untransformed_generic<RegularSpans>(count, spans, userData);
+}
+
+static void blend_untransformed_argb6666(int count, const QSpan *spans,
+                                         void *userData)
+{
+#if defined(QT_QWS_DEPTH_18)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB6666_Premultiplied)
+        blendUntransformed<qargb6666, qargb6666>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB666)
+        blendUntransformed<qargb6666, qrgb666>(count, spans, userData);
+    else
+#endif
+        blend_untransformed_generic<RegularSpans>(count, spans, userData);
+}
+
+static void blend_untransformed_rgb666(int count, const QSpan *spans,
+                                       void *userData)
+{
+#if defined(QT_QWS_DEPTH_18)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB6666_Premultiplied)
+        blendUntransformed<qrgb666, qargb6666>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB666)
+        blendUntransformed<qrgb666, qrgb666>(count, spans, userData);
+    else
+#endif
+        blend_untransformed_generic<RegularSpans>(count, spans, userData);
+}
+
+static void blend_untransformed_argb8565(int count, const QSpan *spans,
+                                         void *userData)
+{
+#if defined(QT_QWS_DEPTH_16)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB8565_Premultiplied)
+        blendUntransformed<qargb8565, qargb8565>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB16)
+        blendUntransformed<qargb8565, qrgb565>(count, spans, userData);
+    else
+#endif
+        blend_untransformed_generic<RegularSpans>(count, spans, userData);
+}
+
+static void blend_untransformed_rgb565(int count, const QSpan *spans,
+                                       void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_16)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB8565_Premultiplied)
+        blendUntransformed<qrgb565, qargb8565>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB16)
+        blendUntransformed<qrgb565, qrgb565>(count, spans, userData);
+    else
+#endif
+        blend_untransformed_generic<RegularSpans>(count, spans, userData);
+}
+
+static void blend_untransformed_argb8555(int count, const QSpan *spans,
+                                         void *userData)
+{
+#if defined(QT_QWS_DEPTH_15)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB8555_Premultiplied)
+        blendUntransformed<qargb8555, qargb8555>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB555)
+        blendUntransformed<qargb8555, qrgb555>(count, spans, userData);
+    else
+#endif
+        blend_untransformed_generic<RegularSpans>(count, spans, userData);
+}
+
+static void blend_untransformed_rgb555(int count, const QSpan *spans,
+                                       void *userData)
+{
+#if defined(QT_QWS_DEPTH_15)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB8555_Premultiplied)
+        blendUntransformed<qrgb555, qargb8555>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB555)
+        blendUntransformed<qrgb555, qrgb555>(count, spans, userData);
+    else
+#endif
+        blend_untransformed_generic<RegularSpans>(count, spans, userData);
+}
+
+static void blend_untransformed_argb4444(int count, const QSpan *spans,
+                                         void *userData)
+{
+#if defined(QT_QWS_DEPTH_12)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB4444_Premultiplied)
+        blendUntransformed<qargb4444, qargb4444>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB444)
+        blendUntransformed<qargb4444, qrgb444>(count, spans, userData);
+    else
+#endif
+        blend_untransformed_generic<RegularSpans>(count, spans, userData);
+}
+
+static void blend_untransformed_rgb444(int count, const QSpan *spans,
+                                       void *userData)
+{
+#if defined(QT_QWS_DEPTH_12)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB4444_Premultiplied)
+        blendUntransformed<qrgb444, qargb4444>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB444)
+        blendUntransformed<qrgb444, qrgb444>(count, spans, userData);
+    else
+#endif
+        blend_untransformed_generic<RegularSpans>(count, spans, userData);
+}
+
+template <SpanMethod spanMethod>
+Q_STATIC_TEMPLATE_FUNCTION void blend_tiled_generic(int count, const QSpan *spans, void *userData)
+{
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    uint buffer[buffer_size];
+    uint src_buffer[buffer_size];
+    Operator op = getOperator(data, spans, count);
+
+    const int image_width = data->texture.width;
+    const int image_height = data->texture.height;
+    int xoff = -qRound(-data->dx) % image_width;
+    int yoff = -qRound(-data->dy) % image_height;
+
+    if (xoff < 0)
+        xoff += image_width;
+    if (yoff < 0)
+        yoff += image_height;
+
+    while (count--) {
+        int x = spans->x;
+        int length = spans->len;
+        int sx = (xoff + spans->x) % image_width;
+        int sy = (spans->y + yoff) % image_height;
+        if (sx < 0)
+            sx += image_width;
+        if (sy < 0)
+            sy += image_height;
+
+        const int coverage = (spans->coverage * data->texture.const_alpha) >> 8;
+        while (length) {
+            int l = qMin(image_width - sx, length);
+            if (buffer_size < l)
+                l = buffer_size;
+            const uint *src = op.src_fetch(src_buffer, &op, data, sy, sx, l);
+            if (spanMethod == RegularSpans) {
+                uint *dest = op.dest_fetch ? op.dest_fetch(buffer, data->rasterBuffer, x, spans->y, l) : buffer;
+                op.func(dest, src, l, coverage);
+                if (op.dest_store)
+                    op.dest_store(data->rasterBuffer, x, spans->y, dest, l);
+            } else {
+                drawBufferSpan(data, src, l, x, spans->y, l,
+                               coverage);
+            }
+            x += l;
+            sx += l;
+            length -= l;
+            if (sx >= image_width)
+                sx = 0;
+        }
+        ++spans;
+    }
+}
+
+template <SpanMethod spanMethod>
+Q_STATIC_TEMPLATE_FUNCTION void blend_tiled_argb(int count, const QSpan *spans, void *userData)
+{
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+    if (data->texture.format != QImage::Format_ARGB32_Premultiplied
+        && data->texture.format != QImage::Format_RGB32) {
+        blend_tiled_generic<spanMethod>(count, spans, userData);
+        return;
+    }
+
+    Operator op = getOperator(data, spans, count);
+
+    int image_width = data->texture.width;
+    int image_height = data->texture.height;
+    int xoff = -qRound(-data->dx) % image_width;
+    int yoff = -qRound(-data->dy) % image_height;
+
+    if (xoff < 0)
+        xoff += image_width;
+    if (yoff < 0)
+        yoff += image_height;
+
+    while (count--) {
+        int x = spans->x;
+        int length = spans->len;
+        int sx = (xoff + spans->x) % image_width;
+        int sy = (spans->y + yoff) % image_height;
+        if (sx < 0)
+            sx += image_width;
+        if (sy < 0)
+            sy += image_height;
+
+        const int coverage = (spans->coverage * data->texture.const_alpha) >> 8;
+        while (length) {
+            int l = qMin(image_width - sx, length);
+            if (buffer_size < l)
+                l = buffer_size;
+            const uint *src = (uint *)data->texture.scanLine(sy) + sx;
+            if (spanMethod == RegularSpans) {
+                uint *dest = ((uint *)data->rasterBuffer->scanLine(spans->y)) + x;
+                op.func(dest, src, l, coverage);
+            } else {
+                drawBufferSpan(data, src, buffer_size,
+                               x, spans->y, l, coverage);
+            }
+            x += l;
+            length -= l;
+            sx = 0;
+        }
+        ++spans;
+    }
+}
+
+template <class DST, class SRC>
+Q_STATIC_TEMPLATE_FUNCTION void blendTiled(int count, const QSpan *spans, void *userData)
+{
+    QSpanData *data = reinterpret_cast<QSpanData*>(userData);
+    QPainter::CompositionMode mode = data->rasterBuffer->compositionMode;
+
+    if (mode != QPainter::CompositionMode_SourceOver &&
+        mode != QPainter::CompositionMode_Source)
+    {
+        blend_src_generic<RegularSpans>(count, spans, userData);
+        return;
+    }
+
+    const bool modeSource = !SRC::hasAlpha() ||
+                            mode == QPainter::CompositionMode_Source;
+    const int image_width = data->texture.width;
+    const int image_height = data->texture.height;
+    int xoff = -qRound(-data->dx) % image_width;
+    int yoff = -qRound(-data->dy) % image_height;
+
+    if (xoff < 0)
+        xoff += image_width;
+    if (yoff < 0)
+        yoff += image_height;
+
+    while (count--) {
+        const quint8 coverage = (data->texture.const_alpha * spans->coverage) >> 8;
+        if (coverage == 0) {
+            ++spans;
+            continue;
+        }
+
+        int x = spans->x;
+        int length = spans->len;
+        int sx = (xoff + spans->x) % image_width;
+        int sy = (spans->y + yoff) % image_height;
+        if (sx < 0)
+            sx += image_width;
+        if (sy < 0)
+            sy += image_height;
+
+        if (modeSource && coverage == 255) {
+            // Copy the first texture block
+            length = qMin(image_width,length);
+            int tx = x;
+            while (length) {
+                int l = qMin(image_width - sx, length);
+                if (buffer_size < l)
+                    l = buffer_size;
+                DST *dest = ((DST*)data->rasterBuffer->scanLine(spans->y)) + tx;
+                const SRC *src = (SRC*)data->texture.scanLine(sy) + sx;
+
+                qt_memconvert<DST, SRC>(dest, src, l);
+                length -= l;
+                tx += l;
+                sx = 0;
+            }
+
+            // Now use the rasterBuffer as the source of the texture,
+            // We can now progressively copy larger blocks
+            // - Less cpu time in code figuring out what to copy
+            // We are dealing with one block of data
+            // - More likely to fit in the cache
+            // - can use memcpy
+            int copy_image_width = qMin(image_width, int(spans->len));
+            length = spans->len - copy_image_width;
+            DST *src = ((DST*)data->rasterBuffer->scanLine(spans->y)) + x;
+            DST *dest = src + copy_image_width;
+            while (copy_image_width < length) {
+                qt_memconvert(dest, src, copy_image_width);
+                dest += copy_image_width;
+                length -= copy_image_width;
+                copy_image_width *= 2;
+            }
+            if (length > 0)
+                qt_memconvert(dest, src, length);
+        } else {
+            while (length) {
+                int l = qMin(image_width - sx, length);
+                if (buffer_size < l)
+                    l = buffer_size;
+                DST *dest = ((DST*)data->rasterBuffer->scanLine(spans->y)) + x;
+                const SRC *src = (SRC*)data->texture.scanLine(sy) + sx;
+                if (sizeof(DST) == 3 && sizeof(SRC) == 3 && l >= 4 &&
+                           (quintptr(dest) & 3) == (quintptr(src) & 3))
+                {
+                    blendUntransformed_dest24(dest, src, coverage, l);
+                } else if (sizeof(DST) == 2 && sizeof(SRC) == 2 && l >= 2 &&
+                           (quintptr(dest) & 3) == (quintptr(src) & 3))
+                {
+                    blendUntransformed_dest16(dest, src, coverage, l);
+                } else {
+                    blendUntransformed_unaligned(dest, src, coverage, l);
+                }
+
+                x += l;
+                length -= l;
+                sx = 0;
+            }
+        }
+        ++spans;
+    }
+}
+
+static void blend_tiled_rgb888(int count, const QSpan *spans, void *userData)
+{
+#if defined(QT_QWS_DEPTH_24)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_RGB888)
+        blendTiled<qrgb888, qrgb888>(count, spans, userData);
+    else
+#endif
+        blend_tiled_generic<RegularSpans>(count, spans, userData);
+}
+
+static void blend_tiled_argb6666(int count, const QSpan *spans, void *userData)
+{
+#if defined(QT_QWS_DEPTH_18)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB6666_Premultiplied)
+        blendTiled<qargb6666, qargb6666>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB666)
+        blendTiled<qargb6666, qrgb666>(count, spans, userData);
+    else
+#endif
+        blend_tiled_generic<RegularSpans>(count, spans, userData);
+}
+
+static void blend_tiled_rgb666(int count, const QSpan *spans, void *userData)
+{
+#if defined(QT_QWS_DEPTH_18)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB6666_Premultiplied)
+        blendTiled<qrgb666, qargb6666>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB666)
+        blendTiled<qrgb666, qrgb666>(count, spans, userData);
+    else
+#endif
+        blend_tiled_generic<RegularSpans>(count, spans, userData);
+}
+
+static void blend_tiled_argb8565(int count, const QSpan *spans, void *userData)
+{
+#if defined(QT_QWS_DEPTH_16)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB8565_Premultiplied)
+        blendTiled<qargb8565, qargb8565>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB16)
+        blendTiled<qargb8565, qrgb565>(count, spans, userData);
+    else
+#endif
+        blend_tiled_generic<RegularSpans>(count, spans, userData);
+}
+
+static void blend_tiled_rgb565(int count, const QSpan *spans, void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_16)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB8565_Premultiplied)
+        blendTiled<qrgb565, qargb8565>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB16)
+        blendTiled<qrgb565, qrgb565>(count, spans, userData);
+    else
+#endif
+        blend_tiled_generic<RegularSpans>(count, spans, userData);
+}
+
+static void blend_tiled_argb8555(int count, const QSpan *spans, void *userData)
+{
+#if defined(QT_QWS_DEPTH_15)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB8555_Premultiplied)
+        blendTiled<qargb8555, qargb8555>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB555)
+        blendTiled<qargb8555, qrgb555>(count, spans, userData);
+    else
+#endif
+        blend_tiled_generic<RegularSpans>(count, spans, userData);
+}
+
+static void blend_tiled_rgb555(int count, const QSpan *spans, void *userData)
+{
+#if defined(QT_QWS_DEPTH_15)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB8555_Premultiplied)
+        blendTiled<qrgb555, qargb8555>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB555)
+        blendTiled<qrgb555, qrgb555>(count, spans, userData);
+    else
+#endif
+        blend_tiled_generic<RegularSpans>(count, spans, userData);
+}
+
+static void blend_tiled_argb4444(int count, const QSpan *spans, void *userData)
+{
+#if defined(QT_QWS_DEPTH_12)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB4444_Premultiplied)
+        blendTiled<qargb4444, qargb4444>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB444)
+        blendTiled<qargb4444, qrgb444>(count, spans, userData);
+    else
+#endif
+        blend_tiled_generic<RegularSpans>(count, spans, userData);
+}
+
+static void blend_tiled_rgb444(int count, const QSpan *spans, void *userData)
+{
+#if defined(QT_QWS_DEPTH_12)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB4444_Premultiplied)
+        blendTiled<qrgb444, qargb4444>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB444)
+        blendTiled<qrgb444, qrgb444>(count, spans, userData);
+    else
+#endif
+        blend_tiled_generic<RegularSpans>(count, spans, userData);
+}
+
+template <class DST, class SRC>
+Q_STATIC_TEMPLATE_FUNCTION void blendTransformedBilinear(int count, const QSpan *spans,
+                                     void *userData)
+{
+    QSpanData *data = reinterpret_cast<QSpanData*>(userData);
+    QPainter::CompositionMode mode = data->rasterBuffer->compositionMode;
+
+
+    if (mode != QPainter::CompositionMode_SourceOver) {
+        blend_src_generic<RegularSpans>(count, spans, userData);
+        return;
+    }
+
+    SRC buffer[buffer_size];
+
+    const int src_minx = data->texture.x1;
+    const int src_miny = data->texture.y1;
+    const int src_maxx = data->texture.x2 - 1;
+    const int src_maxy = data->texture.y2 - 1;
+
+    if (data->fast_matrix) {
+        // The increment pr x in the scanline
+        const int fdx = (int)(data->m11 * fixed_scale);
+        const int fdy = (int)(data->m12 * fixed_scale);
+
+        while (count--) {
+            const quint8 coverage = (data->texture.const_alpha * spans->coverage) >> 8;
+            if (coverage == 0) {
+                ++spans;
+                continue;
+            }
+
+            DST *dest = (DST*)data->rasterBuffer->scanLine(spans->y)
+                        + spans->x;
+            const qreal cx = spans->x + qreal(0.5);
+            const qreal cy = spans->y + qreal(0.5);
+            int x = int((data->m21 * cy
+                         + data->m11 * cx + data->dx) * fixed_scale) - half_point;
+            int y = int((data->m22 * cy
+                         + data->m12 * cx + data->dy) * fixed_scale) - half_point;
+            int length = spans->len;
+
+            while (length) {
+                const int l = qMin(length, buffer_size);
+
+                const SRC *end = buffer + l;
+                SRC *b = buffer;
+                while (b < end) {
+                    int x1 = (x >> 16);
+                    int x2;
+                    int y1 = (y >> 16);
+                    int y2;
+
+                    const int distx = (x & 0x0000ffff) >> 8;
+                    const int disty = (y & 0x0000ffff) >> 8;
+
+                    if (x1 < src_minx) {
+                        x2 = x1 = src_minx;
+                    } else if (x1 >= src_maxx) {
+                        x2 = x1 = src_maxx;
+                    } else {
+                        x2 = x1 + 1;
+                    }
+                    if (y1 < src_miny) {
+                        y2 = y1 = src_miny;
+                    } else if (y1 >= src_maxy) {
+                        y2 = y1 = src_maxy;
+                    } else {
+                        y2 = y1 + 1;
+                    }
+#if 0
+                    if (x1 == x2) {
+                        if (y1 == y2) {
+                            *b = ((SRC*)data->texture.scanLine(y1))[x1];
+                        } else {
+                            *b = ((SRC*)data->texture.scanLine(y1))[x1];
+                            const SRC t = data->texture.scanLine(y2)[x1];
+                            interpolate_pixel(*b, SRC::ialpha(disty),
+                                              t, SRC::alpha(disty));
+                        }
+                    } else if (y1 == y2) {
+                        *b = ((SRC*)data->texture.scanLine(y1))[x1];
+                        const SRC t = ((SRC*)data->texture.scanLine(y1))[x2];
+                        interpolate_pixel(*b, SRC::ialpha(distx),
+                                          t, SRC::alpha(distx));
+                    } else
+#endif
+                    {
+                        const SRC *src1 = (SRC*)data->texture.scanLine(y1);
+                        const SRC *src2 = (SRC*)data->texture.scanLine(y2);
+                        SRC tl = src1[x1];
+                        const SRC tr = src1[x2];
+                        SRC bl = src2[x1];
+                        const SRC br = src2[x2];
+                        const quint8 ax = SRC::alpha(distx);
+                        const quint8 iax = SRC::ialpha(distx);
+
+                        interpolate_pixel(tl, iax, tr, ax);
+                        interpolate_pixel(bl, iax, br, ax);
+                        interpolate_pixel(tl, SRC::ialpha(disty),
+                                          bl, SRC::alpha(disty));
+                        *b = tl;
+                    }
+                    ++b;
+
+                    x += fdx;
+                    y += fdy;
+                }
+
+                if (!SRC::hasAlpha() && coverage == 255) {
+                    qt_memconvert(dest, buffer, l);
+                } else if (sizeof(DST) == 3 && l >= 4 &&
+                           (quintptr(dest) & 3) == (quintptr(buffer) & 3))
+                {
+                    blendUntransformed_dest24(dest, buffer, coverage, l);
+                } else if (sizeof(DST) == 2 && sizeof(SRC) == 2 && l >= 2 &&
+                           (quintptr(dest) & 3) == (quintptr(buffer) & 3)) {
+                    blendUntransformed_dest16(dest, buffer, coverage, l);
+                } else {
+                    blendUntransformed_unaligned(dest, buffer, coverage, l);
+                }
+
+                dest += l;
+                length -= l;
+            }
+            ++spans;
+        }
+    } else {
+        const qreal fdx = data->m11;
+        const qreal fdy = data->m12;
+        const qreal fdw = data->m13;
+
+        while (count--) {
+            const quint8 coverage = (data->texture.const_alpha * spans->coverage) >> 8;
+            if (coverage == 0) {
+                ++spans;
+                continue;
+            }
+
+            DST *dest = (DST*)data->rasterBuffer->scanLine(spans->y)
+                        + spans->x;
+
+            const qreal cx = spans->x + qreal(0.5);
+            const qreal cy = spans->y + qreal(0.5);
+
+            qreal x = data->m21 * cy + data->m11 * cx + data->dx;
+            qreal y = data->m22 * cy + data->m12 * cx + data->dy;
+            qreal w = data->m23 * cy + data->m13 * cx + data->m33;
+
+            int length = spans->len;
+            while (length) {
+                const int l = qMin(length, buffer_size);
+                const SRC *end = buffer + l;
+                SRC *b = buffer;
+                while (b < end) {
+                    const qreal iw = w == 0 ? 1 : 1 / w;
+                    const qreal px = x * iw - qreal(0.5);
+                    const qreal py = y * iw - qreal(0.5);
+
+                    int x1 = int(px) - (px < 0);
+                    int x2;
+                    int y1 = int(py) - (py < 0);
+                    int y2;
+
+                    const int distx = int((px - x1) * 256);
+                    const int disty = int((py - y1) * 256);
+
+                    if (x1 < src_minx) {
+                        x2 = x1 = src_minx;
+                    } else if (x1 >= src_maxx) {
+                        x2 = x1 = src_maxx;
+                    } else {
+                        x2 = x1 + 1;
+                    }
+                    if (y1 < src_miny) {
+                        y2 = y1 = src_miny;
+                    } else if (y1 >= src_maxy) {
+                        y2 = y1 = src_maxy;
+                    } else {
+                        y2 = y1 + 1;
+                    }
+
+                    const SRC *src1 = (SRC*)data->texture.scanLine(y1);
+                    const SRC *src2 = (SRC*)data->texture.scanLine(y2);
+                    SRC tl = src1[x1];
+                    const SRC tr = src1[x2];
+                    SRC bl = src2[x1];
+                    const SRC br = src2[x2];
+                    const quint8 ax = SRC::alpha(distx);
+                    const quint8 iax = SRC::ialpha(distx);
+
+                    interpolate_pixel(tl, iax, tr, ax);
+                    interpolate_pixel(bl, iax, br, ax);
+                    interpolate_pixel(tl, SRC::ialpha(disty),
+                                      bl, SRC::alpha(disty));
+                    *b = tl;
+                    ++b;
+
+                    x += fdx;
+                    y += fdy;
+                    w += fdw;
+                }
+                if (!SRC::hasAlpha() && coverage == 255) {
+                    qt_memconvert(dest, buffer, l);
+                } else if (sizeof(DST) == 3 && l >= 4 &&
+                           (quintptr(dest) & 3) == (quintptr(buffer) & 3))
+                {
+                    blendUntransformed_dest24(dest, buffer, coverage, l);
+                } else if (sizeof(DST) == 2 && sizeof(SRC) == 2 && l >= 2 &&
+                           (quintptr(dest) & 3) == (quintptr(buffer) & 3)) {
+                    blendUntransformed_dest16(dest, buffer, coverage, l);
+                } else {
+                    blendUntransformed_unaligned(dest, buffer, coverage, l);
+                }
+
+                dest += l;
+                length -= l;
+            }
+            ++spans;
+        }
+    }
+}
+
+static void blend_transformed_bilinear_rgb888(int count, const QSpan *spans, void *userData)
+{
+#if defined(QT_QWS_DEPTH_24)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_RGB888)
+        blendTransformedBilinear<qrgb888, qrgb888>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData);
+}
+
+static void blend_transformed_bilinear_argb6666(int count, const QSpan *spans, void *userData)
+{
+#if defined(QT_QWS_DEPTH_18)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB6666_Premultiplied)
+        blendTransformedBilinear<qargb6666, qargb6666>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB666)
+        blendTransformedBilinear<qargb6666, qrgb666>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData);
+}
+
+static void blend_transformed_bilinear_rgb666(int count, const QSpan *spans, void *userData)
+{
+#if defined(QT_QWS_DEPTH_18)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB6666_Premultiplied)
+        blendTransformedBilinear<qrgb666, qargb6666>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB666)
+        blendTransformedBilinear<qrgb666, qrgb666>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData);
+}
+
+static void blend_transformed_bilinear_argb8565(int count, const QSpan *spans, void *userData)
+{
+#if defined(QT_QWS_DEPTH_16)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB8565_Premultiplied)
+        blendTransformedBilinear<qargb8565, qargb8565>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB16)
+        blendTransformedBilinear<qargb8565, qrgb565>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData);
+}
+
+static void blend_transformed_bilinear_rgb565(int count, const QSpan *spans,
+                                              void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_16)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_RGB16)
+        blendTransformedBilinear<qrgb565, qrgb565>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_ARGB8565_Premultiplied)
+        blendTransformedBilinear<qrgb565, qargb8565>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData);
+}
+
+static void blend_transformed_bilinear_argb8555(int count, const QSpan *spans, void *userData)
+{
+#if defined(QT_QWS_DEPTH_15)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB8555_Premultiplied)
+        blendTransformedBilinear<qargb8555, qargb8555>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB555)
+        blendTransformedBilinear<qargb8555, qrgb555>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData);
+}
+
+static void blend_transformed_bilinear_rgb555(int count, const QSpan *spans, void *userData)
+{
+#if defined(QT_QWS_DEPTH_15)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB8555_Premultiplied)
+        blendTransformedBilinear<qrgb555, qargb8555>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB555)
+        blendTransformedBilinear<qrgb555, qrgb555>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData);
+}
+
+static void blend_transformed_bilinear_argb4444(int count, const QSpan *spans, void *userData)
+{
+#if defined(QT_QWS_DEPTH_12)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB4444_Premultiplied)
+        blendTransformedBilinear<qargb4444, qargb4444>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB444)
+        blendTransformedBilinear<qargb4444, qrgb444>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData);
+}
+
+static void blend_transformed_bilinear_rgb444(int count, const QSpan *spans, void *userData)
+{
+#if defined(QT_QWS_DEPTH_12)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB4444_Premultiplied)
+        blendTransformedBilinear<qrgb444, qargb4444>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB444)
+        blendTransformedBilinear<qrgb444, qrgb444>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData);
+}
+
+template <SpanMethod spanMethod>
+Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_argb(int count, const QSpan *spans, void *userData)
+{
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+    if (data->texture.format != QImage::Format_ARGB32_Premultiplied
+        && data->texture.format != QImage::Format_RGB32) {
+        blend_src_generic<spanMethod>(count, spans, userData);
+        return;
+    }
+
+    CompositionFunction func = functionForMode[data->rasterBuffer->compositionMode];
+    uint buffer[buffer_size];
+
+    int image_width = data->texture.width;
+    int image_height = data->texture.height;
+    const int scanline_offset = data->texture.bytesPerLine / 4;
+
+    if (data->fast_matrix) {
+        // The increment pr x in the scanline
+        int fdx = (int)(data->m11 * fixed_scale);
+        int fdy = (int)(data->m12 * fixed_scale);
+
+        while (count--) {
+            void *t = data->rasterBuffer->scanLine(spans->y);
+
+            uint *target = ((uint *)t) + spans->x;
+            uint *image_bits = (uint *)data->texture.imageData;
+
+            const qreal cx = spans->x + qreal(0.5);
+            const qreal cy = spans->y + qreal(0.5);
+
+            int x = int((data->m21 * cy
+                         + data->m11 * cx + data->dx) * fixed_scale);
+            int y = int((data->m22 * cy
+                         + data->m12 * cx + data->dy) * fixed_scale);
+
+            int length = spans->len;
+            const int coverage = (spans->coverage * data->texture.const_alpha) >> 8;
+            while (length) {
+                int l = qMin(length, buffer_size);
+                const uint *end = buffer + l;
+                uint *b = buffer;
+                while (b < end) {
+                    int px = x >> 16;
+                    int py = y >> 16;
+
+                    bool out = (px < 0) || (px >= image_width)
+                               || (py < 0) || (py >= image_height);
+
+                    int y_offset = py * scanline_offset;
+                    *b = out ? uint(0) : image_bits[y_offset + px];
+                    x += fdx;
+                    y += fdy;
+                    ++b;
+                }
+                if (spanMethod == RegularSpans)
+                    func(target, buffer, l, coverage);
+                else
+                    drawBufferSpan(data, buffer, buffer_size,
+                                   spans->x + spans->len - length,
+                                   spans->y, l, coverage);
+                target += l;
+                length -= l;
+            }
+            ++spans;
+        }
+    } else {
+        const qreal fdx = data->m11;
+        const qreal fdy = data->m12;
+        const qreal fdw = data->m13;
+        while (count--) {
+            void *t = data->rasterBuffer->scanLine(spans->y);
+
+            uint *target = ((uint *)t) + spans->x;
+            uint *image_bits = (uint *)data->texture.imageData;
+
+            const qreal cx = spans->x + qreal(0.5);
+            const qreal cy = spans->y + qreal(0.5);
+
+            qreal x = data->m21 * cy + data->m11 * cx + data->dx;
+            qreal y = data->m22 * cy + data->m12 * cx + data->dy;
+            qreal w = data->m23 * cy + data->m13 * cx + data->m33;
+
+            int length = spans->len;
+            const int coverage = (spans->coverage * data->texture.const_alpha) >> 8;
+            while (length) {
+                int l = qMin(length, buffer_size);
+                const uint *end = buffer + l;
+                uint *b = buffer;
+                while (b < end) {
+                    const qreal iw = w == 0 ? 1 : 1 / w;
+                    const qreal tx = x * iw;
+                    const qreal ty = y * iw;
+                    const int px = int(tx) - (tx < 0);
+                    const int py = int(ty) - (ty < 0);
+
+                    bool out = (px < 0) || (px >= image_width)
+                               || (py < 0) || (py >= image_height);
+
+                    int y_offset = py * scanline_offset;
+                    *b = out ? uint(0) : image_bits[y_offset + px];
+                    x += fdx;
+                    y += fdy;
+                    w += fdw;
+
+                    ++b;
+                }
+                if (spanMethod == RegularSpans)
+                    func(target, buffer, l, coverage);
+                else
+                    drawBufferSpan(data, buffer, buffer_size,
+                                   spans->x + spans->len - length,
+                                   spans->y, l, coverage);
+                target += l;
+                length -= l;
+            }
+            ++spans;
+        }
+    }
+}
+
+template <class DST, class SRC>
+Q_STATIC_TEMPLATE_FUNCTION void blendTransformed(int count, const QSpan *spans, void *userData)
+{
+    QSpanData *data = reinterpret_cast<QSpanData*>(userData);
+    QPainter::CompositionMode mode = data->rasterBuffer->compositionMode;
+
+    if (mode != QPainter::CompositionMode_SourceOver) {
+        blend_src_generic<RegularSpans>(count, spans, userData);
+        return;
+    }
+
+    SRC buffer[buffer_size];
+    const int image_width = data->texture.width;
+    const int image_height = data->texture.height;
+
+    if (data->fast_matrix) {
+        // The increment pr x in the scanline
+        const int fdx = (int)(data->m11 * fixed_scale);
+        const int fdy = (int)(data->m12 * fixed_scale);
+
+        while (count--) {
+            const quint8 coverage = (data->texture.const_alpha * spans->coverage) >> 8;
+            if (coverage == 0) {
+                ++spans;
+                continue;
+            }
+
+            DST *dest = (DST*)data->rasterBuffer->scanLine(spans->y)
+                        + spans->x;
+            const qreal cx = spans->x + qreal(0.5);
+            const qreal cy = spans->y + qreal(0.5);
+            int x = int((data->m21 * cy
+                         + data->m11 * cx + data->dx) * fixed_scale);
+            int y = int((data->m22 * cy
+                         + data->m12 * cx + data->dy) * fixed_scale);
+            int length = spans->len;
+
+            while (length) {
+                const int l = qMin(length, buffer_size);
+
+                const SRC *end = buffer + l;
+                SRC *b = buffer;
+                while (b < end) {
+                    const int px = (x >> 16);
+                    const int py = (y >> 16);
+
+                    if ((px < 0) || (px >= image_width) ||
+                        (py < 0) || (py >= image_height))
+                    {
+                        *b = 0;
+                    } else {
+                        *b = ((SRC*)data->texture.scanLine(py))[px];
+                    }
+                    ++b;
+
+                    x += fdx;
+                    y += fdy;
+                }
+
+                if (!SRC::hasAlpha() && coverage == 255) {
+                    qt_memconvert(dest, buffer, l);
+                } else if (sizeof(DST) == 3 && sizeof(SRC) == 3 && l >= 4 &&
+                           (quintptr(dest) & 3) == (quintptr(buffer) & 3))
+                {
+                    blendUntransformed_dest24(dest, buffer, coverage, l);
+                } else if (sizeof(DST) == 2 && sizeof(SRC) == 2 && l >= 2 &&
+                           (quintptr(dest) & 3) == (quintptr(buffer) & 3)) {
+                    blendUntransformed_dest16(dest, buffer, coverage, l);
+                } else {
+                    blendUntransformed_unaligned(dest, buffer, coverage, l);
+                }
+
+                dest += l;
+                length -= l;
+            }
+            ++spans;
+        }
+    } else {
+        const qreal fdx = data->m11;
+        const qreal fdy = data->m12;
+        const qreal fdw = data->m13;
+
+        while (count--) {
+            const quint8 coverage = (data->texture.const_alpha * spans->coverage) >> 8;
+            if (coverage == 0) {
+                ++spans;
+                continue;
+            }
+
+            DST *dest = (DST*)data->rasterBuffer->scanLine(spans->y)
+                        + spans->x;
+
+            const qreal cx = spans->x + qreal(0.5);
+            const qreal cy = spans->y + qreal(0.5);
+
+            qreal x = data->m21 * cy + data->m11 * cx + data->dx;
+            qreal y = data->m22 * cy + data->m12 * cx + data->dy;
+            qreal w = data->m23 * cy + data->m13 * cx + data->m33;
+
+            int length = spans->len;
+            while (length) {
+                const int l = qMin(length, buffer_size);
+                const SRC *end = buffer + l;
+                SRC *b = buffer;
+                while (b < end) {
+                    const qreal iw = w == 0 ? 1 : 1 / w;
+                    const qreal tx = x * iw;
+                    const qreal ty = y * iw;
+
+                    const int px = int(tx) - (tx < 0);
+                    const int py = int(ty) - (ty < 0);
+
+                    if ((px < 0) || (px >= image_width) ||
+                        (py < 0) || (py >= image_height))
+                    {
+                        *b = 0;
+                    } else {
+                        *b = ((SRC*)data->texture.scanLine(py))[px];
+                    }
+                    ++b;
+
+                    x += fdx;
+                    y += fdy;
+                    w += fdw;
+                }
+                if (!SRC::hasAlpha() && coverage == 255) {
+                    qt_memconvert(dest, buffer, l);
+                } else if (sizeof(DST) == 3 && sizeof(SRC) == 3 && l >= 4 &&
+                           (quintptr(dest) & 3) == (quintptr(buffer) & 3))
+                {
+                    blendUntransformed_dest24(dest, buffer, coverage, l);
+                } else if (sizeof(DST) == 2 && sizeof(SRC) == 2 && l >= 2 &&
+                           (quintptr(dest) & 3) == (quintptr(buffer) & 3)) {
+                    blendUntransformed_dest16(dest, buffer, coverage, l);
+                } else {
+                    blendUntransformed_unaligned(dest, buffer, coverage, l);
+                }
+
+                dest += l;
+                length -= l;
+            }
+            ++spans;
+        }
+    }
+}
+
+static void blend_transformed_rgb888(int count, const QSpan *spans,
+                                     void *userData)
+{
+#if defined(QT_QWS_DEPTH_24)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_RGB888)
+        blendTransformed<qrgb888, qrgb888>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData);
+}
+
+static void blend_transformed_argb6666(int count, const QSpan *spans,
+                                       void *userData)
+{
+#if defined(QT_QWS_DEPTH_18)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB6666_Premultiplied)
+        blendTransformed<qargb6666, qargb6666>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB666)
+        blendTransformed<qargb6666, qrgb666>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData);
+}
+
+static void blend_transformed_rgb666(int count, const QSpan *spans,
+                                       void *userData)
+{
+#if defined(QT_QWS_DEPTH_18)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB6666_Premultiplied)
+        blendTransformed<qrgb666, qargb6666>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB666)
+        blendTransformed<qrgb666, qrgb666>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData);
+}
+
+static void blend_transformed_argb8565(int count, const QSpan *spans,
+                                         void *userData)
+{
+#if defined(QT_QWS_DEPTH_16)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB8565_Premultiplied)
+        blendTransformed<qargb8565, qargb8565>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB16)
+        blendTransformed<qargb8565, qrgb565>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData);
+}
+
+static void blend_transformed_rgb565(int count, const QSpan *spans,
+                                       void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_16)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB8565_Premultiplied)
+        blendTransformed<qrgb565, qargb8565>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB16)
+        blendTransformed<qrgb565, qrgb565>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData);
+}
+
+static void blend_transformed_argb8555(int count, const QSpan *spans,
+                                         void *userData)
+{
+#if defined(QT_QWS_DEPTH_15)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB8555_Premultiplied)
+        blendTransformed<qargb8555, qargb8555>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB555)
+        blendTransformed<qargb8555, qrgb555>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData);
+}
+
+static void blend_transformed_rgb555(int count, const QSpan *spans,
+                                       void *userData)
+{
+#if defined(QT_QWS_DEPTH_15)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB8555_Premultiplied)
+        blendTransformed<qrgb555, qargb8555>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB555)
+        blendTransformed<qrgb555, qrgb555>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData);
+}
+
+static void blend_transformed_argb4444(int count, const QSpan *spans,
+                                         void *userData)
+{
+#if defined(QT_QWS_DEPTH_12)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB4444_Premultiplied)
+        blendTransformed<qargb4444, qargb4444>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB444)
+        blendTransformed<qargb4444, qrgb444>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData);
+}
+
+static void blend_transformed_rgb444(int count, const QSpan *spans,
+                                       void *userData)
+{
+#if defined(QT_QWS_DEPTH_12)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB4444_Premultiplied)
+        blendTransformed<qrgb444, qargb4444>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB444)
+        blendTransformed<qrgb444, qrgb444>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData);
+}
+
+template <SpanMethod spanMethod>
+Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_tiled_argb(int count, const QSpan *spans, void *userData)
+{
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+    if (data->texture.format != QImage::Format_ARGB32_Premultiplied
+        && data->texture.format != QImage::Format_RGB32) {
+        blend_src_generic<spanMethod>(count, spans, userData);
+        return;
+    }
+
+    CompositionFunction func = functionForMode[data->rasterBuffer->compositionMode];
+    uint buffer[buffer_size];
+
+    int image_width = data->texture.width;
+    int image_height = data->texture.height;
+    const int scanline_offset = data->texture.bytesPerLine / 4;
+
+    if (data->fast_matrix) {
+        // The increment pr x in the scanline
+        int fdx = (int)(data->m11 * fixed_scale);
+        int fdy = (int)(data->m12 * fixed_scale);
+
+        while (count--) {
+            void *t = data->rasterBuffer->scanLine(spans->y);
+
+            uint *target = ((uint *)t) + spans->x;
+            uint *image_bits = (uint *)data->texture.imageData;
+
+            const qreal cx = spans->x + qreal(0.5);
+            const qreal cy = spans->y + qreal(0.5);
+
+            int x = int((data->m21 * cy
+                         + data->m11 * cx + data->dx) * fixed_scale);
+            int y = int((data->m22 * cy
+                         + data->m12 * cx + data->dy) * fixed_scale);
+
+            const int coverage = (spans->coverage * data->texture.const_alpha) >> 8;
+            int length = spans->len;
+            while (length) {
+                int l = qMin(length, buffer_size);
+                const uint *end = buffer + l;
+                uint *b = buffer;
+                while (b < end) {
+                    int px = x >> 16;
+                    int py = y >> 16;
+                    px %= image_width;
+                    py %= image_height;
+                    if (px < 0) px += image_width;
+                    if (py < 0) py += image_height;
+                    int y_offset = py * scanline_offset;
+
+                    Q_ASSERT(px >= 0 && px < image_width);
+                    Q_ASSERT(py >= 0 && py < image_height);
+
+                    *b = image_bits[y_offset + px];
+                    x += fdx;
+                    y += fdy;
+                    ++b;
+                }
+                if (spanMethod == RegularSpans)
+                    func(target, buffer, l, coverage);
+                else
+                    drawBufferSpan(data, buffer, buffer_size,
+                                   spans->x + spans->len - length,
+                                   spans->y, l, coverage);
+                target += l;
+                length -= l;
+            }
+            ++spans;
+        }
+    } else {
+        const qreal fdx = data->m11;
+        const qreal fdy = data->m12;
+        const qreal fdw = data->m13;
+        while (count--) {
+            void *t = data->rasterBuffer->scanLine(spans->y);
+
+            uint *target = ((uint *)t) + spans->x;
+            uint *image_bits = (uint *)data->texture.imageData;
+
+            const qreal cx = spans->x + qreal(0.5);
+            const qreal cy = spans->y + qreal(0.5);
+
+            qreal x = data->m21 * cy + data->m11 * cx + data->dx;
+            qreal y = data->m22 * cy + data->m12 * cx + data->dy;
+            qreal w = data->m23 * cy + data->m13 * cx + data->m33;
+
+            const int coverage = (spans->coverage * data->texture.const_alpha) >> 8;
+            int length = spans->len;
+            while (length) {
+                int l = qMin(length, buffer_size);
+                const uint *end = buffer + l;
+                uint *b = buffer;
+                while (b < end) {
+                    const qreal iw = w == 0 ? 1 : 1 / w;
+                    const qreal tx = x * iw;
+                    const qreal ty = y * iw;
+                    int px = int(tx) - (tx < 0);
+                    int py = int(ty) - (ty < 0);
+
+                    px %= image_width;
+                    py %= image_height;
+                    if (px < 0) px += image_width;
+                    if (py < 0) py += image_height;
+                    int y_offset = py * scanline_offset;
+
+                    Q_ASSERT(px >= 0 && px < image_width);
+                    Q_ASSERT(py >= 0 && py < image_height);
+
+                    *b = image_bits[y_offset + px];
+                    x += fdx;
+                    y += fdy;
+                    w += fdw;
+                    //force increment to avoid /0
+                    if (!w) {
+                        w += fdw;
+                    }
+                    ++b;
+                }
+                if (spanMethod == RegularSpans)
+                    func(target, buffer, l, coverage);
+                else
+                    drawBufferSpan(data, buffer, buffer_size,
+                                   spans->x + spans->len - length,
+                                   spans->y, l, coverage);
+                target += l;
+                length -= l;
+            }
+            ++spans;
+        }
+    }
+}
+
+template <class DST, class SRC>
+Q_STATIC_TEMPLATE_FUNCTION void blendTransformedTiled(int count, const QSpan *spans, void *userData)
+{
+    QSpanData *data = reinterpret_cast<QSpanData*>(userData);
+    QPainter::CompositionMode mode = data->rasterBuffer->compositionMode;
+
+    if (mode != QPainter::CompositionMode_SourceOver) {
+        blend_src_generic<RegularSpans>(count, spans, userData);
+        return;
+    }
+
+    SRC buffer[buffer_size];
+    const int image_width = data->texture.width;
+    const int image_height = data->texture.height;
+
+    if (data->fast_matrix) {
+        // The increment pr x in the scanline
+        const int fdx = (int)(data->m11 * fixed_scale);
+        const int fdy = (int)(data->m12 * fixed_scale);
+
+        while (count--) {
+            const quint8 coverage = (data->texture.const_alpha * spans->coverage) >> 8;
+            if (coverage == 0) {
+                ++spans;
+                continue;
+            }
+
+            DST *dest = (DST*)data->rasterBuffer->scanLine(spans->y)
+                        + spans->x;
+            const qreal cx = spans->x + qreal(0.5);
+            const qreal cy = spans->y + qreal(0.5);
+            int x = int((data->m21 * cy
+                         + data->m11 * cx + data->dx) * fixed_scale);
+            int y = int((data->m22 * cy
+                         + data->m12 * cx + data->dy) * fixed_scale);
+            int length = spans->len;
+
+            while (length) {
+                const int l = qMin(length, buffer_size);
+
+                const SRC *end = buffer + l;
+                SRC *b = buffer;
+                while (b < end) {
+                    int px = (x >> 16) % image_width;
+                    int py = (y >> 16) % image_height;
+
+                    if (px < 0)
+                        px += image_width;
+                    if (py < 0)
+                        py += image_height;
+
+                    *b = ((SRC*)data->texture.scanLine(py))[px];
+                    ++b;
+
+                    x += fdx;
+                    y += fdy;
+                }
+
+                if (!SRC::hasAlpha() && coverage == 255) {
+                    qt_memconvert(dest, buffer, l);
+                } else if (sizeof(DST) == 3 && sizeof(SRC) == 3 && l >= 4 &&
+                           (quintptr(dest) & 3) == (quintptr(buffer) & 3))
+                {
+                    blendUntransformed_dest24(dest, buffer, coverage, l);
+                } else if (sizeof(DST) == 2 && sizeof(SRC) == 2 && l >= 2 &&
+                           (quintptr(dest) & 3) == (quintptr(buffer) & 3)) {
+                    blendUntransformed_dest16(dest, buffer, coverage, l);
+                } else {
+                    blendUntransformed_unaligned(dest, buffer, coverage, l);
+                }
+
+                dest += l;
+                length -= l;
+            }
+            ++spans;
+        }
+    } else {
+        const qreal fdx = data->m11;
+        const qreal fdy = data->m12;
+        const qreal fdw = data->m13;
+
+        while (count--) {
+            const quint8 coverage = (data->texture.const_alpha * spans->coverage) >> 8;
+            if (coverage == 0) {
+                ++spans;
+                continue;
+            }
+
+            DST *dest = (DST*)data->rasterBuffer->scanLine(spans->y)
+                        + spans->x;
+
+            const qreal cx = spans->x + qreal(0.5);
+            const qreal cy = spans->y + qreal(0.5);
+
+            qreal x = data->m21 * cy + data->m11 * cx + data->dx;
+            qreal y = data->m22 * cy + data->m12 * cx + data->dy;
+            qreal w = data->m23 * cy + data->m13 * cx + data->m33;
+
+            int length = spans->len;
+            while (length) {
+                const int l = qMin(length, buffer_size);
+                const SRC *end = buffer + l;
+                SRC *b = buffer;
+                while (b < end) {
+                    const qreal iw = w == 0 ? 1 : 1 / w;
+                    const qreal tx = x * iw;
+                    const qreal ty = y * iw;
+
+                    int px = int(tx) - (tx < 0);
+                    int py = int(ty) - (ty < 0);
+
+                    px %= image_width;
+                    py %= image_height;
+                    if (px < 0)
+                        px += image_width;
+                    if (py < 0)
+                        py += image_height;
+
+                    *b = ((SRC*)data->texture.scanLine(py))[px];
+                    ++b;
+
+                    x += fdx;
+                    y += fdy;
+                    w += fdw;
+                    // force increment to avoid /0
+                    if (!w)
+                        w += fdw;
+                }
+                if (!SRC::hasAlpha() && coverage == 255) {
+                    qt_memconvert(dest, buffer, l);
+                } else if (sizeof(DST) == 3 && sizeof(SRC) == 3 && l >= 4 &&
+                           (quintptr(dest) & 3) == (quintptr(buffer) & 3))
+                {
+                    blendUntransformed_dest24(dest, buffer, coverage, l);
+                } else if (sizeof(DST) == 2 && sizeof(SRC) == 2 && l >= 2 &&
+                           (quintptr(dest) & 3) == (quintptr(buffer) & 3)) {
+                    blendUntransformed_dest16(dest, buffer, coverage, l);
+                } else {
+                    blendUntransformed_unaligned(dest, buffer, coverage, l);
+                }
+
+                dest += l;
+                length -= l;
+            }
+            ++spans;
+        }
+    }
+}
+
+static void blend_transformed_tiled_rgb888(int count, const QSpan *spans,
+                                           void *userData)
+{
+#if defined(QT_QWS_DEPTH_24)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_RGB888)
+        blendTransformedTiled<qrgb888, qrgb888>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData);
+}
+
+static void blend_transformed_tiled_argb6666(int count, const QSpan *spans,
+                                             void *userData)
+{
+#if defined(QT_QWS_DEPTH_18)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB6666_Premultiplied)
+        blendTransformedTiled<qargb6666, qargb6666>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB666)
+        blendTransformedTiled<qargb6666, qrgb666>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData);
+}
+
+static void blend_transformed_tiled_rgb666(int count, const QSpan *spans,
+                                           void *userData)
+{
+#if defined(QT_QWS_DEPTH_18)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB6666_Premultiplied)
+        blendTransformedTiled<qrgb666, qargb6666>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB666)
+        blendTransformedTiled<qrgb666, qrgb666>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData);
+}
+
+static void blend_transformed_tiled_argb8565(int count, const QSpan *spans,
+                                             void *userData)
+{
+#if defined(QT_QWS_DEPTH_16)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB8565_Premultiplied)
+        blendTransformedTiled<qargb8565, qargb8565>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB16)
+        blendTransformedTiled<qargb8565, qrgb565>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData);
+}
+
+static void blend_transformed_tiled_rgb565(int count, const QSpan *spans,
+                                           void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_16)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB8565_Premultiplied)
+        blendTransformedTiled<qrgb565, qargb8565>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB16)
+        blendTransformedTiled<qrgb565, qrgb565>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData);
+}
+
+static void blend_transformed_tiled_argb8555(int count, const QSpan *spans,
+                                             void *userData)
+{
+#if defined(QT_QWS_DEPTH_15)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB8555_Premultiplied)
+        blendTransformedTiled<qargb8555, qargb8555>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB555)
+        blendTransformedTiled<qargb8555, qrgb555>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData);
+}
+
+static void blend_transformed_tiled_rgb555(int count, const QSpan *spans,
+                                           void *userData)
+{
+#if defined(QT_QWS_DEPTH_15)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB8555_Premultiplied)
+        blendTransformedTiled<qrgb555, qargb8555>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB555)
+        blendTransformedTiled<qrgb555, qrgb555>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData);
+}
+
+static void blend_transformed_tiled_argb4444(int count, const QSpan *spans,
+                                             void *userData)
+{
+#if defined(QT_QWS_DEPTH_12)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB4444_Premultiplied)
+        blendTransformedTiled<qargb4444, qargb4444>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB444)
+        blendTransformedTiled<qargb4444, qrgb444>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData);
+}
+
+static void blend_transformed_tiled_rgb444(int count, const QSpan *spans,
+                                           void *userData)
+{
+#if defined(QT_QWS_DEPTH_12)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB4444_Premultiplied)
+        blendTransformedTiled<qrgb444, qargb4444>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB444)
+        blendTransformedTiled<qrgb444, qrgb444>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData);
+}
+
+# define SPANFUNC_POINTER(Name, Arg) Name<Arg>
+
+
+/* Image formats here are target formats */
+static const ProcessSpans processTextureSpans[NBlendTypes][QImage::NImageFormats] = {
+    // Untransformed
+    {
+        0, // Invalid
+        SPANFUNC_POINTER(blend_untransformed_generic, RegularSpans), // Mono
+        SPANFUNC_POINTER(blend_untransformed_generic, RegularSpans), // MonoLsb
+        SPANFUNC_POINTER(blend_untransformed_generic, RegularSpans), // Indexed8
+        SPANFUNC_POINTER(blend_untransformed_generic, RegularSpans), // RGB32
+        SPANFUNC_POINTER(blend_untransformed_generic, RegularSpans), // ARGB32
+        SPANFUNC_POINTER(blend_untransformed_argb, RegularSpans), // ARGB32_Premultiplied
+        blend_untransformed_rgb565,
+        blend_untransformed_argb8565,
+        blend_untransformed_rgb666,
+        blend_untransformed_argb6666,
+        blend_untransformed_rgb555,
+        blend_untransformed_argb8555,
+        blend_untransformed_rgb888,
+        blend_untransformed_rgb444,
+        blend_untransformed_argb4444,
+    },
+    // Tiled
+    {
+        0, // Invalid
+        SPANFUNC_POINTER(blend_tiled_generic, RegularSpans), // Mono
+        SPANFUNC_POINTER(blend_tiled_generic, RegularSpans), // MonoLsb
+        SPANFUNC_POINTER(blend_tiled_generic, RegularSpans), // Indexed8
+        SPANFUNC_POINTER(blend_tiled_generic, RegularSpans), // RGB32
+        SPANFUNC_POINTER(blend_tiled_generic, RegularSpans), // ARGB32
+        SPANFUNC_POINTER(blend_tiled_argb, RegularSpans), // ARGB32_Premultiplied
+        blend_tiled_rgb565,
+        blend_tiled_argb8565,
+        blend_tiled_rgb666,
+        blend_tiled_argb6666,
+        blend_tiled_rgb555,
+        blend_tiled_argb8555,
+        blend_tiled_rgb888,
+        blend_tiled_rgb444,
+        blend_tiled_argb4444,
+    },
+    // Transformed
+    {
+        0, // Invalid
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // Mono
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // MonoLsb
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // Indexed8
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // RGB32
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // ARGB32
+        SPANFUNC_POINTER(blend_transformed_argb, RegularSpans), // ARGB32_Premultiplied
+        blend_transformed_rgb565,
+        blend_transformed_argb8565,
+        blend_transformed_rgb666,
+        blend_transformed_argb6666,
+        blend_transformed_rgb555,
+        blend_transformed_argb8555,
+        blend_transformed_rgb888,
+        blend_transformed_rgb444,
+        blend_transformed_argb4444,
+    },
+     // TransformedTiled
+    {
+        0,
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // Mono
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // MonoLsb
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // Indexed8
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // RGB32
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // ARGB32
+        SPANFUNC_POINTER(blend_transformed_tiled_argb, RegularSpans), // ARGB32_Premultiplied
+        blend_transformed_tiled_rgb565,
+        blend_transformed_tiled_argb8565,
+        blend_transformed_tiled_rgb666,
+        blend_transformed_tiled_argb6666,
+        blend_transformed_tiled_rgb555,
+        blend_transformed_tiled_argb8555,
+        blend_transformed_tiled_rgb888,
+        blend_transformed_tiled_rgb444,
+        blend_transformed_tiled_argb4444
+    },
+    // Bilinear
+    {
+        0,
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // Mono
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // MonoLsb
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // Indexed8
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // RGB32
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // ARGB32
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // ARGB32_Premultiplied
+        blend_transformed_bilinear_rgb565,
+        blend_transformed_bilinear_argb8565,
+        blend_transformed_bilinear_rgb666,
+        blend_transformed_bilinear_argb6666,
+        blend_transformed_bilinear_rgb555,
+        blend_transformed_bilinear_argb8555,
+        blend_transformed_bilinear_rgb888,
+        blend_transformed_bilinear_rgb444,
+        blend_transformed_bilinear_argb4444,
+    },
+    // BilinearTiled
+    {
+        0,
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // Mono
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // MonoLsb
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // Indexed8
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // RGB32
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // ARGB32
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // ARGB32_Premultiplied
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // RGB16
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // ARGB8565_Premultiplied
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // RGB666
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // ARGB6666_Premultiplied
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // RGB555
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // ARGB8555_Premultiplied
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // RGB888
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // RGB444
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // ARGB4444_Premultiplied
+    }
+};
+
+#if defined (Q_WS_QWS) && !defined(QT_NO_RASTERCALLBACKS)
+static const ProcessSpans processTextureSpansCallback[NBlendTypes][QImage::NImageFormats] = {
+    // Untransformed
+    {
+        0, // Invalid
+        blend_untransformed_generic<CallbackSpans>,   // Mono
+        blend_untransformed_generic<CallbackSpans>,   // MonoLsb
+        blend_untransformed_generic<CallbackSpans>,   // Indexed8
+        blend_untransformed_generic<CallbackSpans>,   // RGB32
+        blend_untransformed_generic<CallbackSpans>,   // ARGB32
+        blend_untransformed_argb<CallbackSpans>,      // ARGB32_Premultiplied
+        blend_untransformed_generic<CallbackSpans>,   // RGB16
+        blend_untransformed_generic<CallbackSpans>,   // ARGB8565_Premultiplied
+        blend_untransformed_generic<CallbackSpans>,   // RGB666
+        blend_untransformed_generic<CallbackSpans>,   // ARGB6666_Premultiplied
+        blend_untransformed_generic<CallbackSpans>,   // RGB555
+        blend_untransformed_generic<CallbackSpans>,   // ARGB8555_Premultiplied
+        blend_untransformed_generic<CallbackSpans>,   // RGB888
+        blend_untransformed_generic<CallbackSpans>,   // RGB444
+        blend_untransformed_generic<CallbackSpans>    // ARGB4444_Premultiplied
+    },
+    // Tiled
+    {
+        0, // Invalid
+        blend_tiled_generic<CallbackSpans>,   // Mono
+        blend_tiled_generic<CallbackSpans>,   // MonoLsb
+        blend_tiled_generic<CallbackSpans>,   // Indexed8
+        blend_tiled_generic<CallbackSpans>,   // RGB32
+        blend_tiled_generic<CallbackSpans>,   // ARGB32
+        blend_tiled_argb<CallbackSpans>,      // ARGB32_Premultiplied
+        blend_tiled_generic<CallbackSpans>,   // RGB16
+        blend_tiled_generic<CallbackSpans>,   // ARGB8565_Premultiplied
+        blend_tiled_generic<CallbackSpans>,   // RGB666
+        blend_tiled_generic<CallbackSpans>,   // ARGB6666_Premultiplied
+        blend_tiled_generic<CallbackSpans>,   // RGB555
+        blend_tiled_generic<CallbackSpans>,   // ARGB8555_Premultiplied
+        blend_tiled_generic<CallbackSpans>,   // RGB888
+        blend_tiled_generic<CallbackSpans>,   // RGB444
+        blend_tiled_generic<CallbackSpans>    // ARGB4444_Premultiplied
+    },
+    // Transformed
+    {
+        0, // Invalid
+        blend_src_generic<CallbackSpans>,   // Mono
+        blend_src_generic<CallbackSpans>,   // MonoLsb
+        blend_src_generic<CallbackSpans>,   // Indexed8
+        blend_src_generic<CallbackSpans>,   // RGB32
+        blend_src_generic<CallbackSpans>,   // ARGB32
+        blend_transformed_argb<CallbackSpans>, // ARGB32_Premultiplied
+        blend_src_generic<CallbackSpans>,   // RGB16
+        blend_src_generic<CallbackSpans>,   // ARGB8565_Premultiplied
+        blend_src_generic<CallbackSpans>,   // RGB666
+        blend_src_generic<CallbackSpans>,   // ARGB6666_Premultiplied
+        blend_src_generic<CallbackSpans>,   // RGB555
+        blend_src_generic<CallbackSpans>,   // ARGB8555_Premultiplied
+        blend_src_generic<CallbackSpans>,   // RGB888
+        blend_src_generic<CallbackSpans>,   // RGB444
+        blend_src_generic<CallbackSpans>,   // ARGB4444_Premultiplied
+    },
+     // TransformedTiled
+    {
+        0,
+        blend_src_generic<CallbackSpans>,   // Mono
+        blend_src_generic<CallbackSpans>,   // MonoLsb
+        blend_src_generic<CallbackSpans>,   // Indexed8
+        blend_src_generic<CallbackSpans>,   // RGB32
+        blend_src_generic<CallbackSpans>,   // ARGB32
+        blend_transformed_tiled_argb<CallbackSpans>, // ARGB32_Premultiplied
+        blend_src_generic<CallbackSpans>,   // RGB16
+        blend_src_generic<CallbackSpans>,   // ARGB8565_Premultiplied
+        blend_src_generic<CallbackSpans>,   // RGB666
+        blend_src_generic<CallbackSpans>,   // ARGB6666_Premultiplied
+        blend_src_generic<CallbackSpans>,   // RGB555
+        blend_src_generic<CallbackSpans>,   // ARGB8555_Premultiplied
+        blend_src_generic<CallbackSpans>,   // RGB888
+        blend_src_generic<CallbackSpans>,   // RGB444
+        blend_src_generic<CallbackSpans>    // ARGB4444_Premultiplied
+    },
+    // Bilinear
+    {
+        0,
+        blend_src_generic<CallbackSpans>,   // Mono
+        blend_src_generic<CallbackSpans>,   // MonoLsb
+        blend_src_generic<CallbackSpans>,   // Indexed8
+        blend_src_generic<CallbackSpans>,   // RGB32
+        blend_src_generic<CallbackSpans>,   // ARGB32
+        blend_src_generic<CallbackSpans>, // ARGB32_Premultiplied
+        blend_src_generic<CallbackSpans>,   // RGB16
+        blend_src_generic<CallbackSpans>,   // ARGB8565_Premultiplied
+        blend_src_generic<CallbackSpans>,   // RGB666
+        blend_src_generic<CallbackSpans>,   // ARGB6666_Premultiplied
+        blend_src_generic<CallbackSpans>,   // RGB555
+        blend_src_generic<CallbackSpans>,   // ARGB8555_Premultiplied
+        blend_src_generic<CallbackSpans>,   // RGB888
+        blend_src_generic<CallbackSpans>,   // RGB444
+        blend_src_generic<CallbackSpans>    // ARGB4444_Premultiplied
+    },
+    // BilinearTiled
+    {
+        0,
+        blend_src_generic<CallbackSpans>,   // Mono
+        blend_src_generic<CallbackSpans>,   // MonoLsb
+        blend_src_generic<CallbackSpans>,   // Indexed8
+        blend_src_generic<CallbackSpans>,   // RGB32
+        blend_src_generic<CallbackSpans>,   // ARGB32
+        blend_src_generic<CallbackSpans>, // ARGB32_Premultiplied
+        blend_src_generic<CallbackSpans>,   // RGB16
+        blend_src_generic<CallbackSpans>,   // ARGB8565_Premultiplied
+        blend_src_generic<CallbackSpans>,   // RGB666
+        blend_src_generic<CallbackSpans>,   // ARGB6666_Premultiplied
+        blend_src_generic<CallbackSpans>,   // RGB555
+        blend_src_generic<CallbackSpans>,   // ARGB8555_Premultiplied
+        blend_src_generic<CallbackSpans>,   // RGB888
+        blend_src_generic<CallbackSpans>,   // RGB444
+        blend_src_generic<CallbackSpans>    // ARGB4444_Premultiplied
+    }
+};
+#endif // QT_NO_RASTERCALLBACKS
+
+void qBlendTexture(int count, const QSpan *spans, void *userData)
+{
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+    ProcessSpans proc = processTextureSpans[getBlendType(data)][data->rasterBuffer->format];
+    proc(count, spans, userData);
+}
+
+#if defined (Q_WS_QWS) &&  !defined(QT_NO_RASTERCALLBACKS)
+void qBlendTextureCallback(int count, const QSpan *spans, void *userData)
+{
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+    ProcessSpans proc = processTextureSpansCallback[getBlendType(data)][data->rasterBuffer->format];
+    proc(count, spans, userData);
+}
+#endif // QT_NO_RASTERCALLBACKS
+
+template <class DST>
+inline void qt_bitmapblit_template(QRasterBuffer *rasterBuffer,
+                                   int x, int y, quint32 color,
+                                   const uchar *map,
+                                   int mapWidth, int mapHeight, int mapStride,
+                                   DST dummy = 0)
+{
+    Q_UNUSED(dummy);
+    const DST c = qt_colorConvert<DST, quint32>(color, 0);
+    DST *dest = reinterpret_cast<DST*>(rasterBuffer->scanLine(y)) + x;
+    const int destStride = rasterBuffer->bytesPerLine() / sizeof(DST);
+
+    if (mapWidth > 8) {
+        while (mapHeight--) {
+            int x0 = 0;
+            int n = 0;
+            for (int x = 0; x < mapWidth; x += 8) {
+                uchar s = map[x >> 3];
+                for (int i = 0; i < 8; ++i) {
+                    if (s & 0x80) {
+                        ++n;
+                    } else {
+                        if (n) {
+                            qt_memfill(dest + x0, c, n);
+                            x0 += n + 1;
+                            n = 0;
+                        } else {
+                            ++x0;
+                        }
+                        if (!s) {
+                            x0 += 8 - 1 - i;
+                            break;
+                        }
+                    }
+                    s <<= 1;
+                }
+            }
+            if (n)
+                qt_memfill(dest + x0, c, n);
+            dest += destStride;
+            map += mapStride;
+        }
+    } else {
+        while (mapHeight--) {
+            int x0 = 0;
+            int n = 0;
+            for (uchar s = *map; s; s <<= 1) {
+                if (s & 0x80) {
+                    ++n;
+                } else if (n) {
+                    qt_memfill(dest + x0, c, n);
+                    x0 += n + 1;
+                    n = 0;
+                } else {
+                    ++x0;
+                }
+            }
+            if (n)
+                qt_memfill(dest + x0, c, n);
+            dest += destStride;
+            map += mapStride;
+        }
+    }
+}
+
+static void qt_gradient_quint32(int count, const QSpan *spans, void *userData)
+{
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    bool isVerticalGradient =
+        data->txop <= QTransform::TxScale &&
+        data->type == QSpanData::LinearGradient &&
+        data->gradient.linear.end.x == data->gradient.linear.origin.x;
+
+    if (isVerticalGradient) {
+        LinearGradientValues linear;
+        getLinearGradientValues(&linear, data);
+
+        CompositionFunctionSolid funcSolid =
+            functionForModeSolid[data->rasterBuffer->compositionMode];
+
+        /*
+            The logic for vertical gradient calculations is a mathematically
+            reduced copy of that in fetchLinearGradient() - which is basically:
+
+                qreal ry = data->m22 * (y + 0.5) + data->dy;
+                qreal t = linear.dy*ry + linear.off;
+                t *= (GRADIENT_STOPTABLE_SIZE - 1);
+                quint32 color =
+                    qt_gradient_pixel_fixed(&data->gradient,
+                                            int(t * FIXPT_SIZE));
+
+            This has then been converted to fixed point to improve performance.
+         */
+        const int gss = GRADIENT_STOPTABLE_SIZE - 1;
+        int yinc = int((linear.dy * data->m22 * gss) * FIXPT_SIZE);
+        int off = int((((linear.dy * (data->m22 * qreal(0.5) + data->dy) + linear.off) * gss) * FIXPT_SIZE));
+
+        while (count--) {
+            int y = spans->y;
+            int x = spans->x;
+
+            quint32 *dst = (quint32 *)(data->rasterBuffer->scanLine(y)) + x;
+            quint32 color =
+                qt_gradient_pixel_fixed(&data->gradient, yinc * y + off);
+
+            funcSolid(dst, spans->len, color, spans->coverage);
+            ++spans;
+        }
+
+    } else {
+        blend_src_generic<RegularSpans>(count, spans, userData);
+    }
+}
+
+static void qt_gradient_quint16(int count, const QSpan *spans, void *userData)
+{
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    bool isVerticalGradient =
+        data->txop <= QTransform::TxScale &&
+        data->type == QSpanData::LinearGradient &&
+        data->gradient.linear.end.x == data->gradient.linear.origin.x;
+
+    if (isVerticalGradient) {
+
+        LinearGradientValues linear;
+        getLinearGradientValues(&linear, data);
+
+        /*
+            The logic for vertical gradient calculations is a mathematically
+            reduced copy of that in fetchLinearGradient() - which is basically:
+
+                qreal ry = data->m22 * (y + 0.5) + data->dy;
+                qreal t = linear.dy*ry + linear.off;
+                t *= (GRADIENT_STOPTABLE_SIZE - 1);
+                quint32 color =
+                    qt_gradient_pixel_fixed(&data->gradient,
+                                            int(t * FIXPT_SIZE));
+
+            This has then been converted to fixed point to improve performance.
+         */
+        const int gss = GRADIENT_STOPTABLE_SIZE - 1;
+        int yinc = int((linear.dy * data->m22 * gss) * FIXPT_SIZE);
+        int off = int((((linear.dy * (data->m22 * qreal(0.5) + data->dy) + linear.off) * gss) * FIXPT_SIZE));
+
+        uint oldColor = data->solid.color;
+        while (count--) {
+            int y = spans->y;
+
+            quint32 color = qt_gradient_pixel_fixed(&data->gradient, yinc * y + off);
+
+            data->solid.color = color;
+            blend_color_rgb16(1, spans, userData);
+            ++spans;
+        }
+        data->solid.color = oldColor;
+
+    } else {
+        blend_src_generic<RegularSpans>(count, spans, userData);
+    }
+}
+
+inline static void qt_bitmapblit_quint32(QRasterBuffer *rasterBuffer,
+                                   int x, int y, quint32 color,
+                                   const uchar *map,
+                                   int mapWidth, int mapHeight, int mapStride)
+{
+    qt_bitmapblit_template<quint32>(rasterBuffer, x,  y,  color,
+                                    map, mapWidth, mapHeight, mapStride);
+}
+
+inline static void qt_bitmapblit_quint16(QRasterBuffer *rasterBuffer,
+                                   int x, int y, quint32 color,
+                                   const uchar *map,
+                                   int mapWidth, int mapHeight, int mapStride)
+{
+    qt_bitmapblit_template<quint16>(rasterBuffer, x,  y,  color,
+                                    map, mapWidth, mapHeight, mapStride);
+}
+
+
+uchar qt_pow_rgb_gamma[256];
+uchar qt_pow_rgb_invgamma[256];
+
+uint qt_pow_gamma[256];
+uchar qt_pow_invgamma[2048];
+
+static void qt_alphamapblit_quint16(QRasterBuffer *rasterBuffer,
+                                    int x, int y, quint32 color,
+                                    const uchar *map,
+                                    int mapWidth, int mapHeight, int mapStride,
+                                    const QClipData *)
+{
+    const quint16 c = qt_colorConvert<quint16, quint32>(color, 0);
+    quint16 *dest = reinterpret_cast<quint16*>(rasterBuffer->scanLine(y)) + x;
+    const int destStride = rasterBuffer->bytesPerLine() / sizeof(quint16);
+
+    while (mapHeight--) {
+        for (int i = 0; i < mapWidth; ++i) {
+            const int coverage = map[i];
+
+            if (coverage == 0) {
+                // nothing
+            } else if (coverage == 255) {
+                dest[i] = c;
+            } else {
+                int ialpha = 255 - coverage;
+                dest[i] = BYTE_MUL_RGB16(c, coverage)
+                          + BYTE_MUL_RGB16(dest[i], ialpha);
+            }
+        }
+        dest += destStride;
+        map += mapStride;
+    }
+}
+
+void qt_build_pow_tables() {
+    qreal smoothing = qreal(1.7);
+
+#ifdef Q_WS_MAC
+    // decided by testing a few things on an iMac, should probably get this from the
+    // system...
+    smoothing = qreal(2.0);
+#endif
+
+#ifdef Q_WS_WIN
+    int winSmooth;
+    if (SystemParametersInfo(0x200C /* SPI_GETFONTSMOOTHINGCONTRAST */, 0, &winSmooth, 0))
+        smoothing = winSmooth / qreal(1000.0);
+
+    // Safeguard ourselves against corrupt registry values...
+    if (smoothing > 5 || smoothing < 1)
+        smoothing = qreal(1.4);
+
+#endif
+
+#ifdef Q_WS_X11
+    Q_UNUSED(smoothing);
+    for (int i=0; i<256; ++i) {
+        qt_pow_rgb_gamma[i] = uchar(i);
+        qt_pow_rgb_invgamma[i] = uchar(i);
+    }
+#else
+    for (int i=0; i<256; ++i) {
+        qt_pow_rgb_gamma[i] = uchar(qRound(qPow(i / qreal(255.0), smoothing) * 255));
+        qt_pow_rgb_invgamma[i] = uchar(qRound(qPow(i / qreal(255.), 1 / smoothing) * 255));
+    }
+#endif
+
+#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)
+    const qreal gray_gamma = 2.31;
+    for (int i=0; i<256; ++i)
+        qt_pow_gamma[i] = uint(qRound(qPow(i / qreal(255.), gray_gamma) * 2047));
+    for (int i=0; i<2048; ++i)
+        qt_pow_invgamma[i] = uchar(qRound(qPow(i / qreal(2047.0), 1 / gray_gamma) * 255));
+#endif
+}
+
+static inline void rgbBlendPixel(quint32 *dst, int coverage, int sr, int sg, int sb)
+{
+    // Do a gray alphablend...
+    int da = qAlpha(*dst);
+    int dr = qRed(*dst);
+    int dg = qGreen(*dst);
+    int db = qBlue(*dst);
+
+    if (da != 255
+#if defined (Q_WS_WIN)
+        // Work around GDI messing up alpha channel
+        && qRed(*dst) <= da && qBlue(*dst) <= da && qGreen(*dst) <= da
+#endif
+        ) {
+
+        int a = qGray(coverage);
+        sr = qt_div_255(qt_pow_rgb_invgamma[sr] * a);
+        sg = qt_div_255(qt_pow_rgb_invgamma[sg] * a);
+        sb = qt_div_255(qt_pow_rgb_invgamma[sb] * a);
+
+        int ia = 255 - a;
+        dr = qt_div_255(dr * ia);
+        dg = qt_div_255(dg * ia);
+        db = qt_div_255(db * ia);
+
+        *dst = ((a + qt_div_255((255 - a) * da)) << 24)
+            |  ((sr + dr) << 16)
+            |  ((sg + dg) << 8)
+            |  ((sb + db));
+        return;
+    }
+
+    int mr = qRed(coverage);
+    int mg = qGreen(coverage);
+    int mb = qBlue(coverage);
+
+    dr = qt_pow_rgb_gamma[dr];
+    dg = qt_pow_rgb_gamma[dg];
+    db = qt_pow_rgb_gamma[db];
+
+    int nr = qt_div_255((sr - dr) * mr) + dr;
+    int ng = qt_div_255((sg - dg) * mg) + dg;
+    int nb = qt_div_255((sb - db) * mb) + db;
+
+    nr = qt_pow_rgb_invgamma[nr];
+    ng = qt_pow_rgb_invgamma[ng];
+    nb = qt_pow_rgb_invgamma[nb];
+
+    *dst = qRgb(nr, ng, nb);
+}
+
+#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)
+static inline void grayBlendPixel(quint32 *dst, int coverage, int sr, int sg, int sb)
+{
+    // Do a gammacorrected gray alphablend...
+    int dr = qRed(*dst);
+    int dg = qGreen(*dst);
+    int db = qBlue(*dst);
+
+    dr = qt_pow_gamma[dr];
+    dg = qt_pow_gamma[dg];
+    db = qt_pow_gamma[db];
+
+    int alpha = coverage;
+    int ialpha = 255 - alpha;
+    int nr = (sr * alpha + ialpha * dr) / 255;
+    int ng = (sg * alpha + ialpha * dg) / 255;
+    int nb = (sb * alpha + ialpha * db) / 255;
+
+    nr = qt_pow_invgamma[nr];
+    ng = qt_pow_invgamma[ng];
+    nb = qt_pow_invgamma[nb];
+
+    *dst = qRgb(nr, ng, nb);
+}
+#endif
+
+static void qt_alphamapblit_quint32(QRasterBuffer *rasterBuffer,
+                                    int x, int y, quint32 color,
+                                    const uchar *map,
+                                    int mapWidth, int mapHeight, int mapStride,
+                                    const QClipData *clip)
+{
+    const quint32 c = color;
+    const int destStride = rasterBuffer->bytesPerLine() / sizeof(quint32);
+
+#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)
+    int sr = qRed(color);
+    int sg = qGreen(color);
+    int sb = qBlue(color);
+
+    sr = qt_pow_gamma[sr];
+    sg = qt_pow_gamma[sg];
+    sb = qt_pow_gamma[sb];
+    bool opaque_src = (qAlpha(color) == 255);
+#endif
+
+    if (!clip) {
+        quint32 *dest = reinterpret_cast<quint32*>(rasterBuffer->scanLine(y)) + x;
+        while (mapHeight--) {
+            for (int i = 0; i < mapWidth; ++i) {
+                const int coverage = map[i];
+
+                if (coverage == 0) {
+                    // nothing
+                } else if (coverage == 255) {
+                    dest[i] = c;
+                } else {
+#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)
+                    if (QSysInfo::WindowsVersion >= QSysInfo::WV_XP && opaque_src
+                        && qAlpha(dest[i]) == 255) {
+                        grayBlendPixel(dest+i, coverage, sr, sg, sb);
+                    } else
+#endif
+                    {
+                        int ialpha = 255 - coverage;
+                        dest[i] = INTERPOLATE_PIXEL_255(c, coverage, dest[i], ialpha);
+                    }
+                }
+            }
+            dest += destStride;
+            map += mapStride;
+        }
+    } else {
+        int bottom = qMin(y + mapHeight, rasterBuffer->height());
+
+        int top = qMax(y, 0);
+        map += (top - y) * mapStride;
+
+        const_cast<QClipData *>(clip)->initialize();
+        for (int yp = top; yp<bottom; ++yp) {
+            const QClipData::ClipLine &line = clip->m_clipLines[yp];
+
+            quint32 *dest = reinterpret_cast<quint32 *>(rasterBuffer->scanLine(yp));
+
+            for (int i=0; i<line.count; ++i) {
+                const QSpan &clip = line.spans[i];
+
+                int start = qMax<int>(x, clip.x);
+                int end = qMin<int>(x + mapWidth, clip.x + clip.len);
+
+                for (int xp=start; xp<end; ++xp) {
+                    const int coverage = map[xp - x];
+
+                    if (coverage == 0) {
+                        // nothing
+                    } else if (coverage == 255) {
+                        dest[xp] = c;
+                    } else {
+#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)
+                        if (QSysInfo::WindowsVersion >= QSysInfo::WV_XP && opaque_src
+                            && qAlpha(dest[xp]) == 255) {
+                            grayBlendPixel(dest+xp, coverage, sr, sg, sb);
+                        } else
+#endif
+                        {
+                            int ialpha = 255 - coverage;
+                            dest[xp] = INTERPOLATE_PIXEL_255(c, coverage, dest[xp], ialpha);
+                        }
+                    }
+
+                } // for (i -> line.count)
+            } // for (yp -> bottom)
+            map += mapStride;
+        }
+    }
+}
+
+static void qt_alphargbblit_quint32(QRasterBuffer *rasterBuffer,
+                                    int x, int y, quint32 color,
+                                    const uint *src, int mapWidth, int mapHeight, int srcStride,
+                                    const QClipData *clip)
+{
+    const quint32 c = color;
+
+    int sr = qRed(color);
+    int sg = qGreen(color);
+    int sb = qBlue(color);
+    int sa = qAlpha(color);
+
+    sr = qt_pow_rgb_gamma[sr];
+    sg = qt_pow_rgb_gamma[sg];
+    sb = qt_pow_rgb_gamma[sb];
+
+    if (sa == 0)
+        return;
+
+    if (!clip) {
+        quint32 *dst = reinterpret_cast<quint32*>(rasterBuffer->scanLine(y)) + x;
+        const int destStride = rasterBuffer->bytesPerLine() / sizeof(quint32);
+        while (mapHeight--) {
+            for (int i = 0; i < mapWidth; ++i) {
+                const uint coverage = src[i];
+                if (coverage == 0xffffffff) {
+                    dst[i] = c;
+                } else if (coverage != 0xff000000) {
+                    rgbBlendPixel(dst+i, coverage, sr, sg, sb);
+                }
+            }
+
+            dst += destStride;
+            src += srcStride;
+        }
+    } else {
+        int bottom = qMin(y + mapHeight, rasterBuffer->height());
+
+        int top = qMax(y, 0);
+        src += (top - y) * srcStride;
+
+        const_cast<QClipData *>(clip)->initialize();
+        for (int yp = top; yp<bottom; ++yp) {
+            const QClipData::ClipLine &line = clip->m_clipLines[yp];
+
+            quint32 *dst = reinterpret_cast<quint32 *>(rasterBuffer->scanLine(yp));
+
+            for (int i=0; i<line.count; ++i) {
+                const QSpan &clip = line.spans[i];
+
+                int start = qMax<int>(x, clip.x);
+                int end = qMin<int>(x + mapWidth, clip.x + clip.len);
+
+                for (int xp=start; xp<end; ++xp) {
+                    const uint coverage = src[xp - x];
+                    if (coverage == 0xffffffff) {
+                        dst[xp] = c;
+                    } else if (coverage != 0xff000000) {
+                        rgbBlendPixel(dst+xp, coverage, sr, sg, sb);
+                    }
+                }
+            } // for (i -> line.count)
+            src += srcStride;
+        } // for (yp -> bottom)
+
+    }
+}
+
+template <class T>
+inline void qt_rectfill_template(QRasterBuffer *rasterBuffer,
+                                 int x, int y, int width, int height,
+                                 quint32 color, T dummy = 0)
+{
+    Q_UNUSED(dummy);
+
+    qt_rectfill<T>(reinterpret_cast<T*>(rasterBuffer->buffer()),
+                   qt_colorConvert<T, quint32p>(quint32p::fromRawData(color), 0),
+                   x, y, width, height, rasterBuffer->bytesPerLine());
+}
+
+#define QT_RECTFILL(T)                                                  \
+    inline static void qt_rectfill_##T(QRasterBuffer *rasterBuffer,     \
+                                       int x, int y, int width, int height, \
+                                       quint32 color)                   \
+    {                                                                   \
+        qt_rectfill_template<T>(rasterBuffer, x, y, width, height, color); \
+    }
+
+QT_RECTFILL(quint32)
+QT_RECTFILL(quint16)
+QT_RECTFILL(qargb8565)
+QT_RECTFILL(qrgb666)
+QT_RECTFILL(qargb6666)
+QT_RECTFILL(qrgb555)
+QT_RECTFILL(qargb8555)
+QT_RECTFILL(qrgb888)
+QT_RECTFILL(qrgb444)
+QT_RECTFILL(qargb4444)
+#undef QT_RECTFILL
+
+inline static void qt_rectfill_nonpremul_quint32(QRasterBuffer *rasterBuffer,
+                                                 int x, int y, int width, int height,
+                                                 quint32 color)
+{
+    qt_rectfill<quint32>(reinterpret_cast<quint32 *>(rasterBuffer->buffer()),
+                         INV_PREMUL(color), x, y, width, height, rasterBuffer->bytesPerLine());
+}
+
+
+// Map table for destination image format. Contains function pointers
+// for blends of various types unto the destination
+
+DrawHelper qDrawHelper[QImage::NImageFormats] =
+{
+    // Format_Invalid,
+    { 0, 0, 0, 0, 0, 0 },
+    // Format_Mono,
+    {
+        blend_color_generic,
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans),
+        0, 0, 0, 0
+    },
+    // Format_MonoLSB,
+    {
+        blend_color_generic,
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans),
+        0, 0, 0, 0
+    },
+    // Format_Indexed8,
+    {
+        blend_color_generic,
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans),
+        0, 0, 0, 0
+    },
+    // Format_RGB32,
+    {
+        blend_color_argb,
+        qt_gradient_quint32,
+        qt_bitmapblit_quint32,
+        qt_alphamapblit_quint32,
+        qt_alphargbblit_quint32,
+        qt_rectfill_quint32
+    },
+    // Format_ARGB32,
+    {
+        blend_color_generic,
+        qt_gradient_quint32,
+        qt_bitmapblit_quint32,
+        qt_alphamapblit_quint32,
+        qt_alphargbblit_quint32,
+        qt_rectfill_nonpremul_quint32
+    },
+    // Format_ARGB32_Premultiplied
+    {
+        blend_color_argb,
+        qt_gradient_quint32,
+        qt_bitmapblit_quint32,
+        qt_alphamapblit_quint32,
+        qt_alphargbblit_quint32,
+        qt_rectfill_quint32
+    },
+    // Format_RGB16
+    {
+        blend_color_rgb16,
+        qt_gradient_quint16,
+        qt_bitmapblit_quint16,
+        qt_alphamapblit_quint16,
+        0,
+        qt_rectfill_quint16
+    },
+    // Format_ARGB8565_Premultiplied
+    {
+        SPANFUNC_POINTER_BLENDCOLOR(qargb8565),
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans),
+        0, 0, 0,
+        qt_rectfill_qargb8565
+    },
+    // Format_RGB666
+    {
+        SPANFUNC_POINTER_BLENDCOLOR(qrgb666),
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans),
+        0, 0, 0,
+        qt_rectfill_qrgb666
+    },
+    // Format_ARGB6666_Premultiplied
+    {
+        SPANFUNC_POINTER_BLENDCOLOR(qargb6666),
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans),
+        0, 0, 0,
+        qt_rectfill_qargb6666
+    },
+    // Format_RGB555
+    {
+        SPANFUNC_POINTER_BLENDCOLOR(qrgb555),
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans),
+        0, 0, 0,
+        qt_rectfill_qrgb555
+    },
+    // Format_ARGB8555_Premultiplied
+    {
+        SPANFUNC_POINTER_BLENDCOLOR(qargb8555),
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans),
+        0, 0, 0,
+        qt_rectfill_qargb8555
+    },
+    // Format_RGB888
+    {
+        SPANFUNC_POINTER_BLENDCOLOR(qrgb888),
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans),
+        0, 0, 0,
+        qt_rectfill_qrgb888
+    },
+    // Format_RGB444
+    {
+        SPANFUNC_POINTER_BLENDCOLOR(qrgb444),
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans),
+        0, 0, 0,
+        qt_rectfill_qrgb444
+    },
+    // Format_ARGB4444_Premultiplied
+    {
+        SPANFUNC_POINTER_BLENDCOLOR(qargb4444),
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans),
+        0, 0, 0,
+        qt_rectfill_qargb4444
+    }
+};
+
+#if defined (Q_WS_QWS) && !defined(QT_NO_RASTERCALLBACKS)
+DrawHelper qDrawHelperCallback[QImage::NImageFormats] =
+{
+    // Format_Invalid,
+    { 0, 0, 0, 0, 0, 0 },
+    // Format_Mono,
+    {
+        blend_color_generic_callback,
+        blend_src_generic<CallbackSpans>,
+        0, 0, 0, 0
+    },
+    // Format_MonoLSB,
+    {
+        blend_color_generic_callback,
+        blend_src_generic<CallbackSpans>,
+        0, 0, 0, 0
+    },
+    // Format_Indexed8,
+    {
+        blend_color_generic_callback,
+        blend_src_generic<CallbackSpans>,
+        0, 0, 0, 0
+    },
+    // Format_RGB32,
+    {
+        blend_color_generic_callback,
+        blend_src_generic<CallbackSpans>,
+        0, 0, 0, 0
+    },
+    // Format_ARGB32,
+    {
+        blend_color_generic_callback,
+        blend_src_generic<CallbackSpans>,
+        0, 0, 0, 0
+    },
+    // Format_ARGB32_Premultiplied
+    {
+        blend_color_generic_callback,
+        blend_src_generic<CallbackSpans>,
+        0, 0, 0, 0
+    },
+    // Format_RGB16
+    {
+        blend_color_generic_callback,
+        blend_src_generic<CallbackSpans>,
+        0, 0, 0, 0
+    },
+    // Format_ARGB8565_Premultiplied
+    {
+        blend_color_generic_callback,
+        blend_src_generic<CallbackSpans>,
+        0, 0, 0, 0
+    },
+    // Format_RGB666
+    {
+        blend_color_generic_callback,
+        blend_src_generic<CallbackSpans>,
+        0, 0, 0, 0
+    },
+    // Format_ARGB6666_Premultiplied
+    {
+        blend_color_generic_callback,
+        blend_src_generic<CallbackSpans>,
+        0, 0, 0, 0
+    },
+    // Format_RGB555
+    {
+        blend_color_generic_callback,
+        blend_src_generic<CallbackSpans>,
+        0, 0, 0, 0
+    },
+    // Format_ARGB8555_Premultiplied
+    {
+        blend_color_generic_callback,
+        blend_src_generic<CallbackSpans>,
+        0, 0, 0, 0
+    },
+    // Format_RGB888
+    {
+        blend_color_generic_callback,
+        blend_src_generic<CallbackSpans>,
+        0, 0, 0, 0
+    },
+    // Format_RGB444
+    {
+        blend_color_generic_callback,
+        blend_src_generic<CallbackSpans>,
+        0, 0, 0, 0
+    },
+    // Format_ARGB4444_Premultiplied
+    {
+        blend_color_generic_callback,
+        blend_src_generic<CallbackSpans>,
+        0, 0, 0, 0
+    }
+};
+#endif
+
+
+
+#if defined(Q_CC_MSVC) && !defined(_MIPS_)
+template <class DST, class SRC>
+inline void qt_memfill_template(DST *dest, SRC color, int count)
+{
+    const DST c = qt_colorConvert<DST, SRC>(color, 0);
+    while (count--)
+        *dest++ = c;
+}
+
+#else
+
+template <class DST, class SRC>
+inline void qt_memfill_template(DST *dest, SRC color, int count)
+{
+    const DST c = qt_colorConvert<DST, SRC>(color, 0);
+    int n = (count + 7) / 8;
+    switch (count & 0x07)
+    {
+    case 0: do { *dest++ = c;
+    case 7:      *dest++ = c;
+    case 6:      *dest++ = c;
+    case 5:      *dest++ = c;
+    case 4:      *dest++ = c;
+    case 3:      *dest++ = c;
+    case 2:      *dest++ = c;
+    case 1:      *dest++ = c;
+    } while (--n > 0);
+    }
+}
+
+template <>
+inline void qt_memfill_template(quint16 *dest, quint16 value, int count)
+{
+    if (count < 3) {
+        switch (count) {
+        case 2: *dest++ = value;
+        case 1: *dest = value;
+        }
+        return;
+    }
+
+    const int align = (quintptr)(dest) & 0x3;
+    switch (align) {
+    case 2: *dest++ = value; --count;
+    }
+
+    const quint32 value32 = (value << 16) | value;
+    qt_memfill(reinterpret_cast<quint32*>(dest), value32, count / 2);
+    if (count & 0x1)
+        dest[count - 1] = value;
+}
+#endif
+
+static void qt_memfill_quint16(quint16 *dest, quint16 color, int count)
+{
+    qt_memfill_template<quint16, quint16>(dest, color, count);
+}
+
+typedef void (*qt_memfill32_func)(quint32 *dest, quint32 value, int count);
+typedef void (*qt_memfill16_func)(quint16 *dest, quint16 value, int count);
+static void qt_memfill32_setup(quint32 *dest, quint32 value, int count);
+static void qt_memfill16_setup(quint16 *dest, quint16 value, int count);
+
+qt_memfill32_func qt_memfill32 = qt_memfill32_setup;
+qt_memfill16_func qt_memfill16 = qt_memfill16_setup;
+
+void qInitDrawhelperAsm()
+{
+
+    qt_memfill32 = qt_memfill_template<quint32, quint32>;
+    qt_memfill16 = qt_memfill_quint16; //qt_memfill_template<quint16, quint16>;
+
+    CompositionFunction *functionForModeAsm = 0;
+    CompositionFunctionSolid *functionForModeSolidAsm = 0;
+
+    const uint features = qDetectCPUFeatures();
+    if (false) {
+#ifdef QT_HAVE_SSE2
+    } else if (features & SSE2) {
+        qt_memfill32 = qt_memfill32_sse2;
+        qt_memfill16 = qt_memfill16_sse2;
+        qDrawHelper[QImage::Format_RGB32].bitmapBlit = qt_bitmapblit32_sse2;
+        qDrawHelper[QImage::Format_ARGB32].bitmapBlit = qt_bitmapblit32_sse2;
+        qDrawHelper[QImage::Format_ARGB32_Premultiplied].bitmapBlit = qt_bitmapblit32_sse2;
+        qDrawHelper[QImage::Format_RGB16].bitmapBlit = qt_bitmapblit16_sse2;
+#endif
+#ifdef QT_HAVE_SSE
+    } else if (features & SSE) {
+//        qt_memfill32 = qt_memfill32_sse;
+        qDrawHelper[QImage::Format_RGB16].bitmapBlit = qt_bitmapblit16_sse;
+#ifdef QT_HAVE_3DNOW
+        if (features & MMX3DNOW) {
+            qt_memfill32 = qt_memfill32_sse3dnow;
+            qDrawHelper[QImage::Format_RGB16].bitmapBlit = qt_bitmapblit16_sse3dnow;
+        }
+#endif
+#endif // SSE
+    }
+#ifdef QT_HAVE_MMX
+    if (features & MMX) {
+        functionForModeAsm = qt_functionForMode_MMX;
+
+        functionForModeSolidAsm = qt_functionForModeSolid_MMX;
+        qDrawHelper[QImage::Format_ARGB32_Premultiplied].blendColor = qt_blend_color_argb_mmx;
+#ifdef QT_HAVE_3DNOW
+        if (features & MMX3DNOW) {
+            functionForModeAsm = qt_functionForMode_MMX3DNOW;
+            functionForModeSolidAsm = qt_functionForModeSolid_MMX3DNOW;
+            qDrawHelper[QImage::Format_ARGB32_Premultiplied].blendColor = qt_blend_color_argb_mmx3dnow;
+        }
+#endif // 3DNOW
+
+        extern void qt_blend_rgb32_on_rgb32_mmx(uchar *destPixels, int dbpl,
+                                                const uchar *srcPixels, int sbpl,
+                                                int w, int h,
+                                                int const_alpha);
+        extern void qt_blend_argb32_on_argb32_mmx(uchar *destPixels, int dbpl,
+                                                  const uchar *srcPixels, int sbpl,
+                                                  int w, int h,
+                                                  int const_alpha);
+
+        qBlendFunctions[QImage::Format_RGB32][QImage::Format_RGB32] = qt_blend_rgb32_on_rgb32_mmx;
+        qBlendFunctions[QImage::Format_ARGB32_Premultiplied][QImage::Format_RGB32] = qt_blend_rgb32_on_rgb32_mmx;
+        qBlendFunctions[QImage::Format_RGB32][QImage::Format_ARGB32_Premultiplied] = qt_blend_argb32_on_argb32_mmx;
+        qBlendFunctions[QImage::Format_ARGB32_Premultiplied][QImage::Format_ARGB32_Premultiplied] = qt_blend_argb32_on_argb32_mmx;
+
+    }
+#endif // MMX
+
+#ifdef QT_HAVE_SSE
+    if (features & SSE) {
+        extern void qt_blend_rgb32_on_rgb32_sse(uchar *destPixels, int dbpl,
+                                                const uchar *srcPixels, int sbpl,
+                                                int w, int h,
+                                                int const_alpha);
+        extern void qt_blend_argb32_on_argb32_sse(uchar *destPixels, int dbpl,
+                                                  const uchar *srcPixels, int sbpl,
+                                                  int w, int h,
+                                                  int const_alpha);
+
+        qBlendFunctions[QImage::Format_RGB32][QImage::Format_RGB32] = qt_blend_rgb32_on_rgb32_sse;
+        qBlendFunctions[QImage::Format_ARGB32_Premultiplied][QImage::Format_RGB32] = qt_blend_rgb32_on_rgb32_sse;
+        qBlendFunctions[QImage::Format_RGB32][QImage::Format_ARGB32_Premultiplied] = qt_blend_argb32_on_argb32_sse;
+        qBlendFunctions[QImage::Format_ARGB32_Premultiplied][QImage::Format_ARGB32_Premultiplied] = qt_blend_argb32_on_argb32_sse;
+    }
+#endif // SSE
+
+#ifdef QT_HAVE_SSE2
+    if (features & SSE2) {
+        extern void qt_blend_rgb32_on_rgb32_sse2(uchar *destPixels, int dbpl,
+                                                 const uchar *srcPixels, int sbpl,
+                                                 int w, int h,
+                                                 int const_alpha);
+        extern void qt_blend_argb32_on_argb32_sse2(uchar *destPixels, int dbpl,
+                                                   const uchar *srcPixels, int sbpl,
+                                                   int w, int h,
+                                                   int const_alpha);
+
+        qBlendFunctions[QImage::Format_RGB32][QImage::Format_RGB32] = qt_blend_rgb32_on_rgb32_sse2;
+        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;
+    }
+
+#ifdef QT_HAVE_SSSE3
+    if (features & SSSE3) {
+        extern void qt_blend_argb32_on_argb32_ssse3(uchar *destPixels, int dbpl,
+                                                    const uchar *srcPixels, int sbpl,
+                                                    int w, int h,
+                                                    int const_alpha);
+
+        qBlendFunctions[QImage::Format_RGB32][QImage::Format_ARGB32_Premultiplied] = qt_blend_argb32_on_argb32_ssse3;
+        qBlendFunctions[QImage::Format_ARGB32_Premultiplied][QImage::Format_ARGB32_Premultiplied] = qt_blend_argb32_on_argb32_ssse3;
+    }
+#endif // SSSE3
+
+#endif // SSE2
+
+#ifdef QT_HAVE_SSE
+    if (features & SSE) {
+        functionForModeAsm = qt_functionForMode_SSE;
+        functionForModeSolidAsm = qt_functionForModeSolid_SSE;
+        qDrawHelper[QImage::Format_ARGB32_Premultiplied].blendColor = qt_blend_color_argb_sse;
+#ifdef QT_HAVE_3DNOW
+        if (features & MMX3DNOW) {
+            functionForModeAsm = qt_functionForMode_SSE3DNOW;
+            functionForModeSolidAsm = qt_functionForModeSolid_SSE3DNOW;
+            qDrawHelper[QImage::Format_ARGB32_Premultiplied].blendColor = qt_blend_color_argb_sse3dnow;
+        }
+#endif // 3DNOW
+
+
+#ifdef QT_HAVE_SSE2
+        if (features & SSE2) {
+            extern void QT_FASTCALL comp_func_SourceOver_sse2(uint *destPixels,
+                                                              const uint *srcPixels,
+                                                              int length,
+                                                              uint const_alpha);
+            extern void QT_FASTCALL comp_func_solid_SourceOver_sse2(uint *destPixels, int length, uint color, uint const_alpha);
+            extern void QT_FASTCALL comp_func_Plus_sse2(uint *dst, const uint *src, int length, uint const_alpha);
+            extern void QT_FASTCALL comp_func_Source_sse2(uint *dst, const uint *src, int length, uint const_alpha);
+
+            functionForModeAsm[0] = comp_func_SourceOver_sse2;
+            functionForModeAsm[QPainter::CompositionMode_Source] = comp_func_Source_sse2;
+            functionForModeAsm[QPainter::CompositionMode_Plus] = comp_func_Plus_sse2;
+            functionForModeSolidAsm[0] = comp_func_solid_SourceOver_sse2;
+        }
+#endif
+    }
+#elif defined(QT_HAVE_SSE2)
+    // this is the special case when SSE2 is usable but MMX/SSE is not usable (e.g.: Windows x64 + visual studio)
+    if (features & SSE2) {
+        functionForModeAsm = qt_functionForMode_onlySSE2;
+        functionForModeSolidAsm = qt_functionForModeSolid_onlySSE2;
+    }
+#endif
+
+#ifdef QT_HAVE_IWMMXT
+    if (features & IWMMXT) {
+        functionForModeAsm = qt_functionForMode_IWMMXT;
+        functionForModeSolidAsm = qt_functionForModeSolid_IWMMXT;
+        qDrawHelper[QImage::Format_ARGB32_Premultiplied].blendColor = qt_blend_color_argb_iwmmxt;
+    }
+#endif // IWMMXT
+
+#if defined(QT_HAVE_ARM_SIMD)
+    qBlendFunctions[QImage::Format_RGB32][QImage::Format_RGB32] = qt_blend_rgb32_on_rgb32_arm_simd;
+    qBlendFunctions[QImage::Format_ARGB32_Premultiplied][QImage::Format_RGB32] = qt_blend_rgb32_on_rgb32_arm_simd;
+    qBlendFunctions[QImage::Format_RGB32][QImage::Format_ARGB32_Premultiplied] = qt_blend_argb32_on_argb32_arm_simd;
+    qBlendFunctions[QImage::Format_ARGB32_Premultiplied][QImage::Format_ARGB32_Premultiplied] = qt_blend_argb32_on_argb32_arm_simd;
+#elif defined(QT_HAVE_NEON)
+    if (features & NEON) {
+        qBlendFunctions[QImage::Format_RGB32][QImage::Format_RGB32] = qt_blend_rgb32_on_rgb32_neon;
+        qBlendFunctions[QImage::Format_ARGB32_Premultiplied][QImage::Format_RGB32] = qt_blend_rgb32_on_rgb32_neon;
+        qBlendFunctions[QImage::Format_RGB32][QImage::Format_ARGB32_Premultiplied] = qt_blend_argb32_on_argb32_neon;
+        qBlendFunctions[QImage::Format_ARGB32_Premultiplied][QImage::Format_ARGB32_Premultiplied] = qt_blend_argb32_on_argb32_neon;
+        qBlendFunctions[QImage::Format_RGB16][QImage::Format_ARGB32_Premultiplied] = qt_blend_argb32_on_rgb16_neon;
+        qBlendFunctions[QImage::Format_ARGB32_Premultiplied][QImage::Format_RGB16] = qt_blend_rgb16_on_argb32_neon;
+        qBlendFunctions[QImage::Format_RGB16][QImage::Format_RGB16] = qt_blend_rgb16_on_rgb16_neon;
+
+        qScaleFunctions[QImage::Format_RGB16][QImage::Format_ARGB32_Premultiplied] = qt_scale_image_argb32_on_rgb16_neon;
+        qScaleFunctions[QImage::Format_RGB16][QImage::Format_RGB16] = qt_scale_image_rgb16_on_rgb16_neon;
+
+        qTransformFunctions[QImage::Format_RGB16][QImage::Format_ARGB32_Premultiplied] = qt_transform_image_argb32_on_rgb16_neon;
+        qTransformFunctions[QImage::Format_RGB16][QImage::Format_RGB16] = qt_transform_image_rgb16_on_rgb16_neon;
+
+        qDrawHelper[QImage::Format_RGB16].alphamapBlit = qt_alphamapblit_quint16_neon;
+
+        functionForMode_C[QPainter::CompositionMode_SourceOver] = qt_blend_argb32_on_argb32_scanline_neon;
+        functionForModeSolid_C[QPainter::CompositionMode_SourceOver] = comp_func_solid_SourceOver_neon;
+        functionForMode_C[QPainter::CompositionMode_Plus] = comp_func_Plus_neon;
+        destFetchProc[QImage::Format_RGB16] = qt_destFetchRGB16_neon;
+        destStoreProc[QImage::Format_RGB16] = qt_destStoreRGB16_neon;
+
+        qMemRotateFunctions[QImage::Format_RGB16][0] = qt_memrotate90_16_neon;
+        qMemRotateFunctions[QImage::Format_RGB16][2] = qt_memrotate270_16_neon;
+        qt_memfill32 = qt_memfill32_neon;
+    }
+#endif
+
+    if (functionForModeSolidAsm) {
+        const int destinationMode = QPainter::CompositionMode_Destination;
+        functionForModeSolidAsm[destinationMode] = functionForModeSolid_C[destinationMode];
+
+        // use the default qdrawhelper implementation for the
+        // extended composition modes
+        for (int mode = 12; mode < 24; ++mode)
+            functionForModeSolidAsm[mode] = functionForModeSolid_C[mode];
+
+        functionForModeSolid = functionForModeSolidAsm;
+    }
+    if (functionForModeAsm)
+        functionForMode = functionForModeAsm;
+
+    qt_build_pow_tables();
+}
+
+static void qt_memfill32_setup(quint32 *dest, quint32 value, int count)
+{
+    qInitDrawhelperAsm();
+    qt_memfill32(dest, value, count);
+}
+
+static void qt_memfill16_setup(quint16 *dest, quint16 value, int count)
+{
+    qInitDrawhelperAsm();
+    qt_memfill16(dest, value, count);
+}
+
+#ifdef QT_QWS_DEPTH_GENERIC
+
+int qrgb::bpp = 0;
+int qrgb::len_red = 0;
+int qrgb::len_green = 0;
+int qrgb::len_blue = 0;
+int qrgb::len_alpha = 0;
+int qrgb::off_red = 0;
+int qrgb::off_green = 0;
+int qrgb::off_blue = 0;
+int qrgb::off_alpha = 0;
+
+template <typename SRC>
+Q_STATIC_TEMPLATE_FUNCTION inline void qt_rectconvert_rgb(qrgb *dest, const SRC *src,
+                                      int x, int y, int width, int height,
+                                      int dstStride, int srcStride)
+{
+    quint8 *dest8 = reinterpret_cast<quint8*>(dest)
+                    + y * dstStride + x * qrgb::bpp;
+
+    srcStride = srcStride / sizeof(SRC) - width;
+    dstStride -= (width * qrgb::bpp);
+
+    for (int j = 0;  j < height; ++j) {
+        for (int i = 0; i < width; ++i) {
+            const quint32 v = qt_convertToRgb<SRC>(*src++);
+#if Q_BYTE_ORDER == Q_BIG_ENDIAN
+            for (int j = qrgb::bpp - 1; j >= 0; --j)
+                *dest8++ = (v >> (8 * j)) & 0xff;
+#else
+            for (int j = 0; j < qrgb::bpp; ++j)
+                *dest8++ = (v >> (8 * j)) & 0xff;
+#endif
+        }
+
+        dest8 += dstStride;
+        src += srcStride;
+    }
+}
+
+template <>
+void qt_rectconvert(qrgb *dest, const quint32 *src,
+                    int x, int y, int width, int height,
+                    int dstStride, int srcStride)
+{
+    qt_rectconvert_rgb<quint32>(dest, src, x, y, width, height,
+                                dstStride, srcStride);
+}
+
+template <>
+void qt_rectconvert(qrgb *dest, const quint16 *src,
+                    int x, int y, int width, int height,
+                    int dstStride, int srcStride)
+{
+    qt_rectconvert_rgb<quint16>(dest, src, x, y, width, height,
+                                dstStride, srcStride);
+}
+
+#endif // QT_QWS_DEPTH_GENERIC
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qdrawhelper_arm_simd.cpp b/src/gui/painting/qdrawhelper_arm_simd.cpp
new file mode 100644
index 0000000000..af9854c03b
--- /dev/null
+++ b/src/gui/painting/qdrawhelper_arm_simd.cpp
@@ -0,0 +1,332 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qdrawhelper_arm_simd_p.h"
+
+#include <private/qpaintengine_raster_p.h>
+#include <private/qblendfunctions_p.h>
+
+#ifdef QT_HAVE_ARM_SIMD
+
+#if defined(Q_OS_SYMBIAN)
+#if !defined(__SWITCH_TO_ARM)
+#ifdef __MARM_THUMB__
+#ifndef __ARMCC__
+#define __SWITCH_TO_ARM      asm("push {r0} ");\
+                             asm("add r0, pc, #4 ");\
+                             asm("bx r0 ");\
+                             asm("nop ");\
+                             asm(".align 2 ");\
+                             asm(".code 32 ");\
+                             asm("ldr r0, [sp], #4 ")
+#define __END_ARM            asm(".code 16 ")
+#else
+#define __SWITCH_TO_ARM      asm(".code 32 ");
+#define __END_ARM
+#endif // __ARMCC__
+#else
+#define __SWITCH_TO_ARM
+#define __END_ARM
+#endif //__MARM_THUMB__
+#endif
+#endif
+
+#if defined(Q_OS_SYMBIAN) && defined(Q_CC_RVCT)
+__asm void qt_blend_argb32_on_argb32_arm_simd(uchar *destPixels, int dbpl,
+                                        const uchar *srcPixels, int sbpl,
+                                        int w, int h,
+                                        int const_alpha)
+{
+#ifndef __ARMCC__
+    __SWITCH_TO_ARM;
+#else
+    CODE32
+#endif // __ARMCC__
+
+    stmfd   sp!, {r4-r12, r14}
+
+    // read arguments off the stack
+    add     r8, sp, #10 * 4
+    ldmia   r8, {r4-r6}
+
+    // adjust dbpl and sbpl
+    mov     r14, #4
+    mul     r14, r4, r14
+    sub     r1, r1, r14
+    sub     r3, r3, r14
+
+    // load 0xFF00FF00 to r12
+    mov     r12, #0xFF000000
+    add     r12, r12, #0xFF00
+
+    // load 0x800080 to r14
+    mov     r14, #0x800000
+    add     r14, r14, #0x80
+
+    /*
+      Registers:
+       r0 dst
+       r1 dbpl
+       r2 src
+       r3 sbpl
+       r4 w
+       r5 h
+       r6 const_alpha
+       r12 0xFF0000
+       r14 0x800080
+    */
+
+    cmp     r6, #256 //test if we have fully opaque constant alpha value
+    bne     argb32constalpha // branch if not
+
+argb32_next_row
+
+    mov     r7, r4
+
+argb32_next_pixel
+
+    ldr     r8, [r2], #4 // load src pixel
+
+    // Negate r8 and extract src alpha
+    mvn     r11, r8 // bitwise not
+    uxtb    r11, r11, ror #24
+
+    cmp     r11, #0 // test for full src opacity (negated)
+    beq     argb32_no_blend
+
+    cmp     r11, #255 // test for full src transparency (negated)
+    addeq   r0, #4
+    beq     argb32_nop
+
+    ldr     r9, [r0] // load dst pixel
+
+    // blend
+    uxtb16  r10, r9
+    uxtb16  r6, r9, ror #8
+    mla     r10, r11, r10, r14
+    mla     r9, r6, r11, r14
+    uxtab16 r10, r10, r10, ror #8
+    uxtab16 r9, r9, r9, ror #8
+    and     r9, r9, r12
+    uxtab16 r10, r9, r10, ror #8
+
+    uqadd8  r8, r10, r8
+
+argb32_no_blend
+
+    str     r8, [r0], #4
+
+argb32_nop
+
+    subs    r7, r7, #1
+    bgt     argb32_next_pixel
+
+    add     r0, r0, r1 // dest = dest + dbpl
+    add     r2, r2, r3 // src = src + sbpl
+
+    subs    r5, r5, #1
+    bgt     argb32_next_row
+
+    b       argb32_blend_exit
+
+argb32constalpha
+
+    cmp     r6, #0
+    beq     argb32_blend_exit
+
+    ; const_alpha = (const_alpha * 255) >> 8;
+    mov     r11, #255
+    mul     r6, r6, r11
+    mov     r11, r6, lsr #8
+
+argb32constalpha_next_row
+
+    mov     r7, r4
+
+argb32constalpha_next_pixel
+
+    ldr     r9, [r2], #4 // load src pixel
+
+    // blend
+    uxtb16  r10, r9
+    uxtb16  r6, r9, ror #8
+    mla     r10, r11, r10, r14
+    mla     r9, r6, r11, r14
+    uxtab16 r10, r10, r10, ror #8
+    uxtab16 r9, r9, r9, ror #8
+    and     r9, r9, r12
+    uxtab16 r8, r9, r10, ror #8
+
+    ldr     r9, [r0] // load dst pixel
+
+    // blend
+    uxtb16  r10, r9
+    uxtb16  r6, r9, ror #8
+
+    // Negate r8 and extract src alpha
+    mvn     r9, r8 // bitwise not
+    uxtb    r9, r9, ror #24
+
+    mla     r10, r9, r10, r14
+    mla     r9, r6, r9, r14
+    uxtab16 r10, r10, r10, ror #8
+    uxtab16 r9, r9, r9, ror #8
+    and     r9, r9, r12
+    uxtab16 r10, r9, r10, ror #8
+
+    uqadd8  r8, r10, r8
+
+    str     r8, [r0], #4
+
+    subs    r7, r7, #1
+    bgt     argb32constalpha_next_pixel
+
+    add     r0, r0, r1 // dest = dest + dbpl
+    add     r2, r2, r3 // src = src + sbpl
+
+    subs    r5, r5, #1
+    bgt     argb32constalpha_next_row
+
+argb32_blend_exit
+
+    // Restore registers
+    ldmfd   sp!, {r4-r12, lr}
+    bx      lr
+
+    __END_ARM
+}
+
+void qt_blend_rgb32_on_rgb32_arm_simd(uchar *destPixels, int dbpl,
+                             const uchar *srcPixels, int sbpl,
+                             int w, int h,
+                             int const_alpha)
+{
+    if (const_alpha != 256) {
+        qt_blend_argb32_on_argb32_arm_simd(destPixels, dbpl, srcPixels, sbpl, w, h, const_alpha);
+        return;
+    }
+
+    const uint *src = (const uint *) srcPixels;
+    uint *dst = (uint *) destPixels;
+    if (w <= 64) {
+        for (int y=0; y<h; ++y) {
+            qt_memconvert(dst, src, w);
+            dst = (quint32 *)(((uchar *) dst) + dbpl);
+            src = (const quint32 *)(((const uchar *) src) + sbpl);
+        }
+    } else {
+        int len = w * 4;
+        for (int y=0; y<h; ++y) {
+            memcpy(dst, src, len);
+            dst = (quint32 *)(((uchar *) dst) + dbpl);
+            src = (const quint32 *)(((const uchar *) src) + sbpl);
+        }
+    }
+}
+
+#else // defined(Q_OS_SYMBIAN) && defined(Q_CC_RVCT)
+
+// TODO: add GNU assembler instructions and support for other platforms.
+//       Default to C code for now
+
+void qt_blend_argb32_on_argb32_arm_simd(uchar *destPixels, int dbpl,
+                                        const uchar *srcPixels, int sbpl,
+                                        int w, int h,
+                                        int const_alpha)
+{
+    const uint *src = (const uint *) srcPixels;
+    uint *dst = (uint *) destPixels;
+    if (const_alpha == 256) {
+        for (int y=0; y<h; ++y) {
+            for (int x=0; x<w; ++x) {
+                uint s = src[x];
+                if (s >= 0xff000000)
+                    dst[x] = s;
+                else if (s != 0)
+                    dst[x] = s + BYTE_MUL(dst[x], qAlpha(~s));
+            }
+            dst = (quint32 *)(((uchar *) dst) + dbpl);
+            src = (const quint32 *)(((const uchar *) src) + sbpl);
+        }
+    } else if (const_alpha != 0) {
+        const_alpha = (const_alpha * 255) >> 8;
+        for (int y=0; y<h; ++y) {
+            for (int x=0; x<w; ++x) {
+                uint s = BYTE_MUL(src[x], const_alpha);
+                dst[x] = s + BYTE_MUL(dst[x], qAlpha(~s));
+            }
+            dst = (quint32 *)(((uchar *) dst) + dbpl);
+            src = (const quint32 *)(((const uchar *) src) + sbpl);
+        }
+    }
+}
+
+void qt_blend_rgb32_on_rgb32_arm_simd(uchar *destPixels, int dbpl,
+                             const uchar *srcPixels, int sbpl,
+                             int w, int h,
+                             int const_alpha)
+{
+    if (const_alpha != 256) {
+        qt_blend_argb32_on_argb32_arm_simd(destPixels, dbpl, srcPixels, sbpl, w, h, const_alpha);
+        return;
+    }
+
+    const uint *src = (const uint *) srcPixels;
+    uint *dst = (uint *) destPixels;
+    if (w <= 64) {
+        for (int y=0; y<h; ++y) {
+            qt_memconvert(dst, src, w);
+            dst = (quint32 *)(((uchar *) dst) + dbpl);
+            src = (const quint32 *)(((const uchar *) src) + sbpl);
+        }
+    } else {
+        int len = w * 4;
+        for (int y=0; y<h; ++y) {
+            memcpy(dst, src, len);
+            dst = (quint32 *)(((uchar *) dst) + dbpl);
+            src = (const quint32 *)(((const uchar *) src) + sbpl);
+        }
+    }
+}
+
+#endif
+
+#endif // QT_HAVE_ARMV_SIMD
diff --git a/src/gui/painting/qdrawhelper_arm_simd_p.h b/src/gui/painting/qdrawhelper_arm_simd_p.h
new file mode 100644
index 0000000000..975a0244d2
--- /dev/null
+++ b/src/gui/painting/qdrawhelper_arm_simd_p.h
@@ -0,0 +1,76 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QDRAWHELPER_ARM_SIMD_P_H
+#define QDRAWHELPER_ARM_SIMD_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <private/qdrawhelper_p.h>
+
+QT_BEGIN_NAMESPACE
+
+#if defined(QT_HAVE_ARM_SIMD)
+
+void qt_blend_argb32_on_argb32_arm_simd(uchar *destPixels, int dbpl,
+                                            const uchar *srcPixels, int sbpl,
+                                            int w, int h,
+                                            int const_alpha);
+
+void qt_blend_rgb32_on_rgb32_arm_simd(uchar *destPixels, int dbpl,
+                                            const uchar *srcPixels, int sbpl,
+                                            int w, int h,
+                                            int const_alpha);
+
+#endif // QT_HAVE_ARM_SIMD
+
+QT_END_NAMESPACE
+
+#endif // QDRAWHELPER_ARM_SIMD_P_H
diff --git a/src/gui/painting/qdrawhelper_iwmmxt.cpp b/src/gui/painting/qdrawhelper_iwmmxt.cpp
new file mode 100644
index 0000000000..969224f1c8
--- /dev/null
+++ b/src/gui/painting/qdrawhelper_iwmmxt.cpp
@@ -0,0 +1,148 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifdef QT_HAVE_IWMMXT
+
+#include <mmintrin.h>
+#if defined(Q_OS_WINCE)
+#  include "qplatformdefs.h"
+#endif
+#if !defined(__IWMMXT__) && !defined(Q_OS_WINCE)
+#  include <xmmintrin.h>
+#elif defined(Q_OS_WINCE_STD) && defined(_X86_)
+#  pragma warning(disable: 4391)
+#  include <xmmintrin.h>
+#endif
+
+#include <private/qdrawhelper_sse_p.h>
+
+QT_BEGIN_NAMESPACE
+
+#ifndef _MM_SHUFFLE
+#define _MM_SHUFFLE(fp3,fp2,fp1,fp0) \
+ (((fp3) << 6) | ((fp2) << 4) | ((fp1) << 2) | (fp0))
+#endif
+
+struct QIWMMXTIntrinsics : public QMMXCommonIntrinsics
+{
+    static inline m64 alpha(m64 x) {
+        return _mm_shuffle_pi16 (x, _MM_SHUFFLE(3, 3, 3, 3));
+    }
+
+    static inline m64 _load_alpha(uint x, const m64 &mmx_0x0000) {
+        m64 t = _mm_unpacklo_pi8(_mm_cvtsi32_si64(x), mmx_0x0000);
+        return _mm_shuffle_pi16(t, _MM_SHUFFLE(0, 0, 0, 0));
+    }
+
+    static inline void end() {
+    }
+};
+
+CompositionFunctionSolid qt_functionForModeSolid_IWMMXT[numCompositionFunctions] = {
+    comp_func_solid_SourceOver<QIWMMXTIntrinsics>,
+    comp_func_solid_DestinationOver<QIWMMXTIntrinsics>,
+    comp_func_solid_Clear<QIWMMXTIntrinsics>,
+    comp_func_solid_Source<QIWMMXTIntrinsics>,
+    0,
+    comp_func_solid_SourceIn<QIWMMXTIntrinsics>,
+    comp_func_solid_DestinationIn<QIWMMXTIntrinsics>,
+    comp_func_solid_SourceOut<QIWMMXTIntrinsics>,
+    comp_func_solid_DestinationOut<QIWMMXTIntrinsics>,
+    comp_func_solid_SourceAtop<QIWMMXTIntrinsics>,
+    comp_func_solid_DestinationAtop<QIWMMXTIntrinsics>,
+    comp_func_solid_XOR<QIWMMXTIntrinsics>,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // svg 1.2 modes
+    rasterop_solid_SourceOrDestination<QIWMMXTIntrinsics>,
+    rasterop_solid_SourceAndDestination<QIWMMXTIntrinsics>,
+    rasterop_solid_SourceXorDestination<QIWMMXTIntrinsics>,
+    rasterop_solid_NotSourceAndNotDestination<QIWMMXTIntrinsics>,
+    rasterop_solid_NotSourceOrNotDestination<QIWMMXTIntrinsics>,
+    rasterop_solid_NotSourceXorDestination<QIWMMXTIntrinsics>,
+    rasterop_solid_NotSource<QIWMMXTIntrinsics>,
+    rasterop_solid_NotSourceAndDestination<QIWMMXTIntrinsics>,
+    rasterop_solid_SourceAndNotDestination<QIWMMXTIntrinsics>
+};
+
+CompositionFunction qt_functionForMode_IWMMXT[] = {
+    comp_func_SourceOver<QIWMMXTIntrinsics>,
+    comp_func_DestinationOver<QIWMMXTIntrinsics>,
+    comp_func_Clear<QIWMMXTIntrinsics>,
+    comp_func_Source<QIWMMXTIntrinsics>,
+    comp_func_Destination,
+    comp_func_SourceIn<QIWMMXTIntrinsics>,
+    comp_func_DestinationIn<QIWMMXTIntrinsics>,
+    comp_func_SourceOut<QIWMMXTIntrinsics>,
+    comp_func_DestinationOut<QIWMMXTIntrinsics>,
+    comp_func_SourceAtop<QIWMMXTIntrinsics>,
+    comp_func_DestinationAtop<QIWMMXTIntrinsics>,
+    comp_func_XOR<QIWMMXTIntrinsics>,
+    comp_func_Plus,
+    comp_func_Multiply,
+    comp_func_Screen,
+    comp_func_Overlay,
+    comp_func_Darken,
+    comp_func_Lighten,
+    comp_func_ColorDodge,
+    comp_func_ColorBurn,
+    comp_func_HardLight,
+    comp_func_SoftLight,
+    comp_func_Difference,
+    comp_func_Exclusion,
+    rasterop_SourceOrDestination,
+    rasterop_SourceAndDestination,
+    rasterop_SourceXorDestination,
+    rasterop_NotSourceAndNotDestination,
+    rasterop_NotSourceOrNotDestination,
+    rasterop_NotSourceXorDestination,
+    rasterop_NotSource,
+    rasterop_NotSourceAndDestination,
+    rasterop_SourceAndNotDestination
+};
+
+void qt_blend_color_argb_iwmmxt(int count, const QSpan *spans, void *userData)
+{
+    qt_blend_color_argb_x86<QIWMMXTIntrinsics>(count, spans, userData,
+                                               (CompositionFunctionSolid*)qt_functionForModeSolid_IWMMXT);
+}
+
+#endif // QT_HAVE_IWMMXT
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qdrawhelper_mmx.cpp b/src/gui/painting/qdrawhelper_mmx.cpp
new file mode 100644
index 0000000000..dd1f3d41e3
--- /dev/null
+++ b/src/gui/painting/qdrawhelper_mmx.cpp
@@ -0,0 +1,155 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <private/qdrawhelper_p.h>
+
+#if defined(QT_HAVE_MMX)
+
+#include <private/qdrawhelper_mmx_p.h>
+
+QT_BEGIN_NAMESPACE
+
+CompositionFunctionSolid qt_functionForModeSolid_MMX[numCompositionFunctions] = {
+    comp_func_solid_SourceOver<QMMXIntrinsics>,
+    comp_func_solid_DestinationOver<QMMXIntrinsics>,
+    comp_func_solid_Clear<QMMXIntrinsics>,
+    comp_func_solid_Source<QMMXIntrinsics>,
+    0,
+    comp_func_solid_SourceIn<QMMXIntrinsics>,
+    comp_func_solid_DestinationIn<QMMXIntrinsics>,
+    comp_func_solid_SourceOut<QMMXIntrinsics>,
+    comp_func_solid_DestinationOut<QMMXIntrinsics>,
+    comp_func_solid_SourceAtop<QMMXIntrinsics>,
+    comp_func_solid_DestinationAtop<QMMXIntrinsics>,
+    comp_func_solid_XOR<QMMXIntrinsics>,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // svg 1.2 modes
+    rasterop_solid_SourceOrDestination<QMMXIntrinsics>,
+    rasterop_solid_SourceAndDestination<QMMXIntrinsics>,
+    rasterop_solid_SourceXorDestination<QMMXIntrinsics>,
+    rasterop_solid_NotSourceAndNotDestination<QMMXIntrinsics>,
+    rasterop_solid_NotSourceOrNotDestination<QMMXIntrinsics>,
+    rasterop_solid_NotSourceXorDestination<QMMXIntrinsics>,
+    rasterop_solid_NotSource<QMMXIntrinsics>,
+    rasterop_solid_NotSourceAndDestination<QMMXIntrinsics>,
+    rasterop_solid_SourceAndNotDestination<QMMXIntrinsics>
+};
+
+CompositionFunction qt_functionForMode_MMX[numCompositionFunctions] = {
+    comp_func_SourceOver<QMMXIntrinsics>,
+    comp_func_DestinationOver<QMMXIntrinsics>,
+    comp_func_Clear<QMMXIntrinsics>,
+    comp_func_Source<QMMXIntrinsics>,
+    comp_func_Destination,
+    comp_func_SourceIn<QMMXIntrinsics>,
+    comp_func_DestinationIn<QMMXIntrinsics>,
+    comp_func_SourceOut<QMMXIntrinsics>,
+    comp_func_DestinationOut<QMMXIntrinsics>,
+    comp_func_SourceAtop<QMMXIntrinsics>,
+    comp_func_DestinationAtop<QMMXIntrinsics>,
+    comp_func_XOR<QMMXIntrinsics>,
+    comp_func_Plus,
+    comp_func_Multiply,
+    comp_func_Screen,
+    comp_func_Overlay,
+    comp_func_Darken,
+    comp_func_Lighten,
+    comp_func_ColorDodge,
+    comp_func_ColorBurn,
+    comp_func_HardLight,
+    comp_func_SoftLight,
+    comp_func_Difference,
+    comp_func_Exclusion,
+    rasterop_SourceOrDestination,
+    rasterop_SourceAndDestination,
+    rasterop_SourceXorDestination,
+    rasterop_NotSourceAndNotDestination,
+    rasterop_NotSourceOrNotDestination,
+    rasterop_NotSourceXorDestination,
+    rasterop_NotSource,
+    rasterop_NotSourceAndDestination,
+    rasterop_SourceAndNotDestination
+};
+
+void qt_blend_color_argb_mmx(int count, const QSpan *spans, void *userData)
+{
+    qt_blend_color_argb_x86<QMMXIntrinsics>(count, spans, userData,
+                                            (CompositionFunctionSolid*)qt_functionForModeSolid_MMX);
+}
+
+
+void qt_blend_argb32_on_argb32_mmx(uchar *destPixels, int dbpl,
+                                   const uchar *srcPixels, int sbpl,
+                                   int w, int h,
+                                   int const_alpha)
+{
+    const uint *src = (const uint *) srcPixels;
+    uint *dst = (uint *) destPixels;
+
+    uint ca = const_alpha - 1;
+
+    for (int y=0; y<h; ++y) {
+        comp_func_SourceOver<QMMXIntrinsics>(dst, src, w, ca);
+        dst = (quint32 *)(((uchar *) dst) + dbpl);
+        src = (const quint32 *)(((const uchar *) src) + sbpl);
+    }
+}
+
+void qt_blend_rgb32_on_rgb32_mmx(uchar *destPixels, int dbpl,
+                                 const uchar *srcPixels, int sbpl,
+                                 int w, int h,
+                                 int const_alpha)
+{
+    const uint *src = (const uint *) srcPixels;
+    uint *dst = (uint *) destPixels;
+
+    uint ca = const_alpha - 1;
+
+    for (int y=0; y<h; ++y) {
+        comp_func_Source<QMMXIntrinsics>(dst, src, w, ca);
+        dst = (quint32 *)(((uchar *) dst) + dbpl);
+        src = (const quint32 *)(((const uchar *) src) + sbpl);
+    }
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_HAVE_MMX
+
diff --git a/src/gui/painting/qdrawhelper_mmx3dnow.cpp b/src/gui/painting/qdrawhelper_mmx3dnow.cpp
new file mode 100644
index 0000000000..12dde9e5bc
--- /dev/null
+++ b/src/gui/painting/qdrawhelper_mmx3dnow.cpp
@@ -0,0 +1,128 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <private/qdrawhelper_x86_p.h>
+
+#ifdef QT_HAVE_3DNOW
+
+#include <private/qdrawhelper_mmx_p.h>
+#include <mm3dnow.h>
+
+QT_BEGIN_NAMESPACE
+
+struct QMMX3DNOWIntrinsics : public QMMXCommonIntrinsics
+{
+    static inline void end() {
+        _m_femms();
+    }
+};
+
+CompositionFunctionSolid qt_functionForModeSolid_MMX3DNOW[numCompositionFunctions] = {
+    comp_func_solid_SourceOver<QMMX3DNOWIntrinsics>,
+    comp_func_solid_DestinationOver<QMMX3DNOWIntrinsics>,
+    comp_func_solid_Clear<QMMX3DNOWIntrinsics>,
+    comp_func_solid_Source<QMMX3DNOWIntrinsics>,
+    0,
+    comp_func_solid_SourceIn<QMMX3DNOWIntrinsics>,
+    comp_func_solid_DestinationIn<QMMX3DNOWIntrinsics>,
+    comp_func_solid_SourceOut<QMMX3DNOWIntrinsics>,
+    comp_func_solid_DestinationOut<QMMX3DNOWIntrinsics>,
+    comp_func_solid_SourceAtop<QMMX3DNOWIntrinsics>,
+    comp_func_solid_DestinationAtop<QMMX3DNOWIntrinsics>,
+    comp_func_solid_XOR<QMMX3DNOWIntrinsics>,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // svg 1.2 modes
+    rasterop_solid_SourceOrDestination<QMMX3DNOWIntrinsics>,
+    rasterop_solid_SourceAndDestination<QMMX3DNOWIntrinsics>,
+    rasterop_solid_SourceXorDestination<QMMX3DNOWIntrinsics>,
+    rasterop_solid_NotSourceAndNotDestination<QMMX3DNOWIntrinsics>,
+    rasterop_solid_NotSourceOrNotDestination<QMMX3DNOWIntrinsics>,
+    rasterop_solid_NotSourceXorDestination<QMMX3DNOWIntrinsics>,
+    rasterop_solid_NotSource<QMMX3DNOWIntrinsics>,
+    rasterop_solid_NotSourceAndDestination<QMMX3DNOWIntrinsics>,
+    rasterop_solid_SourceAndNotDestination<QMMX3DNOWIntrinsics>
+};
+
+CompositionFunction qt_functionForMode_MMX3DNOW[numCompositionFunctions] = {
+    comp_func_SourceOver<QMMX3DNOWIntrinsics>,
+    comp_func_DestinationOver<QMMX3DNOWIntrinsics>,
+    comp_func_Clear<QMMX3DNOWIntrinsics>,
+    comp_func_Source<QMMX3DNOWIntrinsics>,
+    comp_func_Destination,
+    comp_func_SourceIn<QMMX3DNOWIntrinsics>,
+    comp_func_DestinationIn<QMMX3DNOWIntrinsics>,
+    comp_func_SourceOut<QMMX3DNOWIntrinsics>,
+    comp_func_DestinationOut<QMMX3DNOWIntrinsics>,
+    comp_func_SourceAtop<QMMX3DNOWIntrinsics>,
+    comp_func_DestinationAtop<QMMX3DNOWIntrinsics>,
+    comp_func_XOR<QMMX3DNOWIntrinsics>,
+    comp_func_Plus,
+    comp_func_Multiply,
+    comp_func_Screen,
+    comp_func_Overlay,
+    comp_func_Darken,
+    comp_func_Lighten,
+    comp_func_ColorDodge,
+    comp_func_ColorBurn,
+    comp_func_HardLight,
+    comp_func_SoftLight,
+    comp_func_Difference,
+    comp_func_Exclusion,
+    rasterop_SourceOrDestination,
+    rasterop_SourceAndDestination,
+    rasterop_SourceXorDestination,
+    rasterop_NotSourceAndNotDestination,
+    rasterop_NotSourceOrNotDestination,
+    rasterop_NotSourceXorDestination,
+    rasterop_NotSource,
+    rasterop_NotSourceAndDestination,
+    rasterop_SourceAndNotDestination
+};
+
+void qt_blend_color_argb_mmx3dnow(int count, const QSpan *spans, void *userData)
+{
+    qt_blend_color_argb_x86<QMMX3DNOWIntrinsics>(count, spans, userData,
+                                                 (CompositionFunctionSolid*)qt_functionForModeSolid_MMX3DNOW);
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_HAVE_3DNOW
+
diff --git a/src/gui/painting/qdrawhelper_mmx_p.h b/src/gui/painting/qdrawhelper_mmx_p.h
new file mode 100644
index 0000000000..06e945b882
--- /dev/null
+++ b/src/gui/painting/qdrawhelper_mmx_p.h
@@ -0,0 +1,892 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QDRAWHELPER_MMX_P_H
+#define QDRAWHELPER_MMX_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <private/qdrawhelper_p.h>
+#include <private/qdrawhelper_x86_p.h>
+#include <private/qpaintengine_raster_p.h>
+
+#ifdef QT_HAVE_MMX
+#include <mmintrin.h>
+#endif
+
+#define C_FF const m64 mmx_0x00ff = _mm_set1_pi16(0xff)
+#define C_80 const m64 mmx_0x0080 = _mm_set1_pi16(0x80)
+#define C_00 const m64 mmx_0x0000 = _mm_setzero_si64()
+
+#ifdef Q_CC_MSVC
+#  pragma warning(disable: 4799) // No EMMS at end of function
+#endif
+
+typedef __m64 m64;
+
+QT_BEGIN_NAMESPACE
+
+struct QMMXCommonIntrinsics
+{
+    static inline m64 alpha(m64 x) {
+        x = _mm_unpackhi_pi16(x, x);
+        x = _mm_unpackhi_pi16(x, x);
+        return x;
+    }
+
+    static inline m64 _negate(const m64 &x, const m64 &mmx_0x00ff) {
+        return _mm_xor_si64(x, mmx_0x00ff);
+    }
+
+    static inline m64 add(const m64 &a, const m64 &b) {
+        return  _mm_adds_pu16 (a, b);
+    }
+
+    static inline m64 _byte_mul(const m64 &a, const m64 &b,
+                                const m64 &mmx_0x0080)
+    {
+        m64 res = _mm_mullo_pi16(a, b);
+        res = _mm_adds_pu16(res, mmx_0x0080);
+        res = _mm_adds_pu16(res, _mm_srli_pi16 (res, 8));
+        return _mm_srli_pi16(res, 8);
+    }
+
+    static inline m64 interpolate_pixel_256(const m64 &x, const m64 &a,
+                                           const m64 &y, const m64 &b)
+    {
+        m64 res = _mm_adds_pu16(_mm_mullo_pi16(x, a), _mm_mullo_pi16(y, b));
+        return _mm_srli_pi16(res, 8);
+    }
+
+    static inline m64 _interpolate_pixel_255(const m64 &x, const m64 &a,
+                                             const m64 &y, const m64 &b,
+                                             const m64 &mmx_0x0080)
+    {
+        m64 res = _mm_adds_pu16(_mm_mullo_pi16(x, a), _mm_mullo_pi16(y, b));
+        res = _mm_adds_pu16(res, mmx_0x0080);
+        res = _mm_adds_pu16(res, _mm_srli_pi16 (res, 8));
+        return _mm_srli_pi16(res, 8);
+    }
+
+    static inline m64 _premul(m64 x, const m64 &mmx_0x0080) {
+        m64 a = alpha(x);
+        return _byte_mul(x, a, mmx_0x0080);
+    }
+
+    static inline m64 _load(uint x, const m64 &mmx_0x0000) {
+        return _mm_unpacklo_pi8(_mm_cvtsi32_si64(x), mmx_0x0000);
+    }
+
+    static inline m64 _load_alpha(uint x, const m64 &) {
+        x |= (x << 16);
+        return _mm_set1_pi32(x);
+    }
+
+    static inline uint _store(const m64 &x, const m64 &mmx_0x0000) {
+        return _mm_cvtsi64_si32(_mm_packs_pu16(x, mmx_0x0000));
+    }
+};
+
+#define negate(x) _negate(x, mmx_0x00ff)
+#define byte_mul(a, b) _byte_mul(a, b, mmx_0x0080)
+#define interpolate_pixel_255(x, a, y, b) _interpolate_pixel_255(x, a, y, b, mmx_0x0080)
+#define premul(x) _premul(x, mmx_0x0080)
+#define load(x) _load(x, mmx_0x0000)
+#define load_alpha(x) _load_alpha(x, mmx_0x0000)
+#define store(x) _store(x, mmx_0x0000)
+
+/*
+  result = 0
+  d = d * cia
+*/
+#define comp_func_Clear_impl(dest, length, const_alpha)\
+{\
+    if (const_alpha == 255) {\
+        qt_memfill(static_cast<quint32*>(dest), quint32(0), length);\
+    } else {\
+        C_FF; C_80; C_00;\
+        m64 ia = MM::negate(MM::load_alpha(const_alpha));\
+        for (int i = 0; i < length; ++i) {\
+            dest[i] = MM::store(MM::byte_mul(MM::load(dest[i]), ia));\
+        }\
+        MM::end();\
+    }\
+}
+
+template <class MM>
+static void QT_FASTCALL comp_func_solid_Clear(uint *dest, int length, uint, uint const_alpha)
+{
+    comp_func_Clear_impl(dest, length, const_alpha);
+}
+
+template <class MM>
+static void QT_FASTCALL comp_func_Clear(uint *dest, const uint *, int length, uint const_alpha)
+{
+    comp_func_Clear_impl(dest, length, const_alpha);
+}
+
+/*
+  result = s
+  dest = s * ca + d * cia
+*/
+template <class MM>
+static void QT_FASTCALL comp_func_solid_Source(uint *dest, int length, uint src, uint const_alpha)
+{
+    if (const_alpha == 255) {
+        qt_memfill(static_cast<quint32*>(dest), quint32(src), length);
+    } else {
+        C_FF; C_80; C_00;
+        const m64 a = MM::load_alpha(const_alpha);
+        const m64 ia = MM::negate(a);
+        const m64 s = MM::byte_mul(MM::load(src), a);
+        for (int i = 0; i < length; ++i) {
+            dest[i] = MM::store(MM::add(s, MM::byte_mul(MM::load(dest[i]), ia)));
+        }
+        MM::end();
+    }
+}
+
+template <class MM>
+static void QT_FASTCALL comp_func_Source(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    if (const_alpha == 255) {
+        ::memcpy(dest, src, length * sizeof(uint));
+    } else {
+        C_FF; C_80; C_00;
+        const m64 a = MM::load_alpha(const_alpha);
+        const m64 ia = MM::negate(a);
+        for (int i = 0; i < length; ++i)
+            dest[i] = MM::store(MM::interpolate_pixel_255(MM::load(src[i]), a,
+                                                        MM::load(dest[i]), ia));
+    }
+    MM::end();
+}
+
+/*
+  result = s + d * sia
+  dest = (s + d * sia) * ca + d * cia
+       = s * ca + d * (sia * ca + cia)
+       = s * ca + d * (1 - sa*ca)
+*/
+template <class MM>
+static void QT_FASTCALL comp_func_solid_SourceOver(uint *dest, int length, uint src, uint const_alpha)
+{
+    if ((const_alpha & qAlpha(src)) == 255) {
+        qt_memfill(static_cast<quint32*>(dest), quint32(src), length);
+    } else {
+        C_FF; C_80; C_00;
+        m64 s = MM::load(src);
+        if (const_alpha != 255) {
+            m64 ca = MM::load_alpha(const_alpha);
+            s = MM::byte_mul(s, ca);
+        }
+        m64 a = MM::negate(MM::alpha(s));
+        for (int i = 0; i < length; ++i)
+            dest[i] = MM::store(MM::add(s, MM::byte_mul(MM::load(dest[i]), a)));
+        MM::end();
+    }
+}
+
+template <class MM>
+static void QT_FASTCALL comp_func_SourceOver(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    C_FF; C_80; C_00;
+    if (const_alpha == 255) {
+        for (int i = 0; i < length; ++i) {
+            const uint alphaMaskedSource = 0xff000000 & src[i];
+            if (alphaMaskedSource == 0)
+                continue;
+            if (alphaMaskedSource == 0xff000000) {
+                dest[i] = src[i];
+            } else {
+                m64 s = MM::load(src[i]);
+                m64 ia = MM::negate(MM::alpha(s));
+                dest[i] = MM::store(MM::add(s, MM::byte_mul(MM::load(dest[i]), ia)));
+            }
+        }
+    } else {
+        m64 ca = MM::load_alpha(const_alpha);
+        for (int i = 0; i < length; ++i) {
+            if ((0xff000000 & src[i]) == 0)
+                continue;
+            m64 s = MM::byte_mul(MM::load(src[i]), ca);
+            m64 ia = MM::negate(MM::alpha(s));
+            dest[i] = MM::store(MM::add(s, MM::byte_mul(MM::load(dest[i]), ia)));
+        }
+    }
+    MM::end();
+}
+
+/*
+  result = d + s * dia
+  dest = (d + s * dia) * ca + d * cia
+       = d + s * dia * ca
+*/
+template <class MM>
+static void QT_FASTCALL comp_func_solid_DestinationOver(uint *dest, int length, uint src, uint const_alpha)
+{
+    C_FF; C_80; C_00;
+    m64 s = MM::load(src);
+    if (const_alpha != 255)
+        s = MM::byte_mul(s, MM::load_alpha(const_alpha));
+
+    for (int i = 0; i < length; ++i) {
+        m64 d = MM::load(dest[i]);
+        m64 dia = MM::negate(MM::alpha(d));
+        dest[i] = MM::store(MM::add(d, MM::byte_mul(s, dia)));
+    }
+    MM::end();
+}
+
+template <class MM>
+static void QT_FASTCALL comp_func_DestinationOver(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    C_FF; C_80; C_00;
+    if (const_alpha == 255) {
+        for (int i = 0; i < length; ++i) {
+            m64 d = MM::load(dest[i]);
+            m64 ia = MM::negate(MM::alpha(d));
+            dest[i] = MM::store(MM::add(d, MM::byte_mul(MM::load(src[i]), ia)));
+        }
+    } else {
+        m64 ca = MM::load_alpha(const_alpha);
+        for (int i = 0; i < length; ++i) {
+            m64 d = MM::load(dest[i]);
+            m64 dia = MM::negate(MM::alpha(d));
+            dia = MM::byte_mul(dia, ca);
+            dest[i] = MM::store(MM::add(d, MM::byte_mul(MM::load(src[i]), dia)));
+        }
+    }
+    MM::end();
+}
+
+/*
+  result = s * da
+  dest = s * da * ca + d * cia
+*/
+template <class MM>
+static void QT_FASTCALL comp_func_solid_SourceIn(uint *dest, int length, uint src, uint const_alpha)
+{
+    C_80; C_00;
+    if (const_alpha == 255) {
+        m64 s = MM::load(src);
+        for (int i = 0; i < length; ++i) {
+            m64 da = MM::alpha(MM::load(dest[i]));
+            dest[i] = MM::store(MM::byte_mul(s, da));
+        }
+    } else {
+        C_FF;
+        m64 s = MM::load(src);
+        m64 ca = MM::load_alpha(const_alpha);
+        s = MM::byte_mul(s, ca);
+        m64 cia = MM::negate(ca);
+        for (int i = 0; i < length; ++i) {
+            m64 d = MM::load(dest[i]);
+            dest[i] = MM::store(MM::interpolate_pixel_255(s, MM::alpha(d), d, cia));
+        }
+    }
+    MM::end();
+}
+
+template <class MM>
+static void QT_FASTCALL comp_func_SourceIn(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    C_FF; C_80; C_00;
+    if (const_alpha == 255) {
+        for (int i = 0; i < length; ++i) {
+            m64 a = MM::alpha(MM::load(dest[i]));
+            dest[i] = MM::store(MM::byte_mul(MM::load(src[i]), a));
+        }
+    } else {
+        m64 ca = MM::load_alpha(const_alpha);
+        m64 cia = MM::negate(ca);
+        for (int i = 0; i < length; ++i) {
+            m64 d = MM::load(dest[i]);
+            m64 da = MM::byte_mul(MM::alpha(d), ca);
+            dest[i] = MM::store(MM::interpolate_pixel_255(
+                                   MM::load(src[i]), da, d, cia));
+        }
+    }
+    MM::end();
+}
+
+/*
+  result = d * sa
+  dest = d * sa * ca + d * cia
+       = d * (sa * ca + cia)
+*/
+template <class MM>
+static void QT_FASTCALL comp_func_solid_DestinationIn(uint *dest, int length, uint src, uint const_alpha)
+{
+    C_80; C_00;
+    m64 a = MM::alpha(MM::load(src));
+    if (const_alpha != 255) {
+        C_FF;
+        m64 ca = MM::load_alpha(const_alpha);
+        m64 cia = MM::negate(ca);
+        a = MM::byte_mul(a, ca);
+        a = MM::add(a, cia);
+    }
+    for (int i = 0; i < length; ++i)
+        dest[i] = MM::store(MM::byte_mul(MM::load(dest[i]), a));
+    MM::end();
+}
+
+template <class MM>
+static void QT_FASTCALL comp_func_DestinationIn(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    C_FF; C_80; C_00;
+    if (const_alpha == 255) {
+        for (int i = 0; i < length; ++i) {
+            m64 a = MM::alpha(MM::load(src[i]));
+            dest[i] = MM::store(MM::byte_mul(MM::load(dest[i]), a));
+        }
+    } else {
+        m64 ca = MM::load_alpha(const_alpha);
+        m64 cia = MM::negate(ca);
+        for (int i = 0; i < length; ++i) {
+            m64 d = MM::load(dest[i]);
+            m64 a = MM::alpha(MM::load(src[i]));
+            a = MM::byte_mul(a, ca);
+            a = MM::add(a, cia);
+            dest[i] = MM::store(MM::byte_mul(d, a));
+        }
+    }
+    MM::end();
+}
+
+/*
+  result = s * dia
+  dest = s * dia * ca + d * cia
+*/
+template <class MM>
+static void QT_FASTCALL comp_func_solid_SourceOut(uint *dest, int length, uint src, uint const_alpha)
+{
+    C_FF; C_80; C_00;
+    m64 s = MM::load(src);
+    if (const_alpha == 255) {
+        for (int i = 0; i < length; ++i) {
+            m64 dia = MM::negate(MM::alpha(MM::load(dest[i])));
+            dest[i] = MM::store(MM::byte_mul(s, dia));
+        }
+    } else {
+        m64 ca = MM::load_alpha(const_alpha);
+        m64 cia = MM::negate(ca);
+        s = MM::byte_mul(s, ca);
+        for (int i = 0; i < length; ++i) {
+            m64 d = MM::load(dest[i]);
+            dest[i] = MM::store(MM::interpolate_pixel_255(s, MM::negate(MM::alpha(d)), d, cia));
+        }
+    }
+    MM::end();
+}
+
+template <class MM>
+static void QT_FASTCALL comp_func_SourceOut(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    C_FF; C_80; C_00;
+    if (const_alpha == 255) {
+        for (int i = 0; i < length; ++i) {
+            m64 ia = MM::negate(MM::alpha(MM::load(dest[i])));
+            dest[i] = MM::store(MM::byte_mul(MM::load(src[i]), ia));
+        }
+    } else {
+        m64 ca = MM::load_alpha(const_alpha);
+        m64 cia = MM::negate(ca);
+        for (int i = 0; i < length; ++i) {
+            m64 d = MM::load(dest[i]);
+            m64 dia = MM::byte_mul(MM::negate(MM::alpha(d)), ca);
+            dest[i] = MM::store(MM::interpolate_pixel_255(MM::load(src[i]), dia, d, cia));
+        }
+    }
+    MM::end();
+}
+
+/*
+  result = d * sia
+  dest = d * sia * ca + d * cia
+       = d * (sia * ca + cia)
+*/
+template <class MM>
+static void QT_FASTCALL comp_func_solid_DestinationOut(uint *dest, int length, uint src, uint const_alpha)
+{
+    C_FF; C_80; C_00;
+    m64 a = MM::negate(MM::alpha(MM::load(src)));
+    if (const_alpha != 255) {
+        m64 ca = MM::load_alpha(const_alpha);
+        a = MM::byte_mul(a, ca);
+        a = MM::add(a, MM::negate(ca));
+    }
+    for (int i = 0; i < length; ++i)
+        dest[i] = MM::store(MM::byte_mul(MM::load(dest[i]), a));
+    MM::end();
+}
+
+template <class MM>
+static void QT_FASTCALL comp_func_DestinationOut(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    C_FF; C_80; C_00;
+    if (const_alpha == 255) {
+        for (int i = 0; i < length; ++i) {
+            m64 a = MM::negate(MM::alpha(MM::load(src[i])));
+            dest[i] = MM::store(MM::byte_mul(MM::load(dest[i]), a));
+        }
+    } else {
+        m64 ca = MM::load_alpha(const_alpha);
+        m64 cia = MM::negate(ca);
+        for (int i = 0; i < length; ++i) {
+            m64 d = MM::load(dest[i]);
+            m64 a = MM::negate(MM::alpha(MM::load(src[i])));
+            a = MM::byte_mul(a, ca);
+            a = MM::add(a, cia);
+            dest[i] = MM::store(MM::byte_mul(d, a));
+        }
+    }
+    MM::end();
+}
+
+/*
+  result = s*da + d*sia
+  dest = s*da*ca + d*sia*ca + d *cia
+       = s*ca * da + d * (sia*ca + cia)
+       = s*ca * da + d * (1 - sa*ca)
+*/
+template <class MM>
+static void QT_FASTCALL comp_func_solid_SourceAtop(uint *dest, int length, uint src, uint const_alpha)
+{
+    C_FF; C_80; C_00;
+    m64 s = MM::load(src);
+    if (const_alpha != 255) {
+        m64 ca = MM::load_alpha(const_alpha);
+        s = MM::byte_mul(s, ca);
+    }
+    m64 a = MM::negate(MM::alpha(s));
+    for (int i = 0; i < length; ++i) {
+        m64 d = MM::load(dest[i]);
+        dest[i] = MM::store(MM::interpolate_pixel_255(s, MM::alpha(d), d, a));
+    }
+    MM::end();
+}
+
+template <class MM>
+static void QT_FASTCALL comp_func_SourceAtop(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    C_FF; C_80; C_00;
+    if (const_alpha == 255) {
+        for (int i = 0; i < length; ++i) {
+            m64 s = MM::load(src[i]);
+            m64 d = MM::load(dest[i]);
+            dest[i] = MM::store(MM::interpolate_pixel_255(s, MM::alpha(d), d,
+                                                        MM::negate(MM::alpha(s))));
+        }
+    } else {
+        m64 ca = MM::load_alpha(const_alpha);
+        for (int i = 0; i < length; ++i) {
+            m64 s = MM::load(src[i]);
+            s = MM::byte_mul(s, ca);
+            m64 d = MM::load(dest[i]);
+            dest[i] = MM::store(MM::interpolate_pixel_255(s, MM::alpha(d), d,
+                                                        MM::negate(MM::alpha(s))));
+        }
+    }
+    MM::end();
+}
+
+/*
+  result = d*sa + s*dia
+  dest = d*sa*ca + s*dia*ca + d *cia
+       = s*ca * dia + d * (sa*ca + cia)
+*/
+template <class MM>
+static void QT_FASTCALL comp_func_solid_DestinationAtop(uint *dest, int length, uint src, uint const_alpha)
+{
+    C_FF; C_80; C_00;
+    m64 s = MM::load(src);
+    m64 a = MM::alpha(s);
+    if (const_alpha != 255) {
+        m64 ca = MM::load_alpha(const_alpha);
+        s = MM::byte_mul(s, ca);
+        a = MM::alpha(s);
+        a = MM::add(a, MM::negate(ca));
+    }
+    for (int i = 0; i < length; ++i) {
+        m64 d = MM::load(dest[i]);
+        dest[i] = MM::store(MM::interpolate_pixel_255(s, MM::negate(MM::alpha(d)), d, a));
+    }
+    MM::end();
+}
+
+template <class MM>
+static void QT_FASTCALL comp_func_DestinationAtop(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    C_FF; C_80; C_00;
+    if (const_alpha == 255) {
+        for (int i = 0; i < length; ++i) {
+            m64 s = MM::load(src[i]);
+            m64 d = MM::load(dest[i]);
+            dest[i] = MM::store(MM::interpolate_pixel_255(d, MM::alpha(s), s,
+                                                        MM::negate(MM::alpha(d))));
+        }
+    } else {
+        m64 ca = MM::load_alpha(const_alpha);
+        for (int i = 0; i < length; ++i) {
+            m64 s = MM::load(src[i]);
+            s = MM::byte_mul(s, ca);
+            m64 d = MM::load(dest[i]);
+            m64 a = MM::alpha(s);
+            a = MM::add(a, MM::negate(ca));
+            dest[i] = MM::store(MM::interpolate_pixel_255(s, MM::negate(MM::alpha(d)),
+                                                        d, a));
+        }
+    }
+    MM::end();
+}
+
+/*
+  result = d*sia + s*dia
+  dest = d*sia*ca + s*dia*ca + d *cia
+       = s*ca * dia + d * (sia*ca + cia)
+       = s*ca * dia + d * (1 - sa*ca)
+*/
+template <class MM>
+static void QT_FASTCALL comp_func_solid_XOR(uint *dest, int length, uint src, uint const_alpha)
+{
+    C_FF; C_80; C_00;
+    m64 s = MM::load(src);
+    if (const_alpha != 255) {
+        m64 ca = MM::load_alpha(const_alpha);
+        s = MM::byte_mul(s, ca);
+    }
+    m64 a = MM::negate(MM::alpha(s));
+    for (int i = 0; i < length; ++i) {
+        m64 d = MM::load(dest[i]);
+        dest[i] = MM::store(MM::interpolate_pixel_255(s, MM::negate(MM::alpha(d)),
+                                                    d, a));
+    }
+    MM::end();
+}
+
+template <class MM>
+static void QT_FASTCALL comp_func_XOR(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    C_FF; C_80; C_00;
+    if (const_alpha == 255) {
+        for (int i = 0; i < length; ++i) {
+            m64 s = MM::load(src[i]);
+            m64 d = MM::load(dest[i]);
+            dest[i] = MM::store(MM::interpolate_pixel_255(s, MM::negate(MM::alpha(d)),
+                                                        d, MM::negate(MM::alpha(s))));
+        }
+    } else {
+        m64 ca = MM::load_alpha(const_alpha);
+        for (int i = 0; i < length; ++i) {
+            m64 s = MM::load(src[i]);
+            s = MM::byte_mul(s, ca);
+            m64 d = MM::load(dest[i]);
+            dest[i] = MM::store(MM::interpolate_pixel_255(s, MM::negate(MM::alpha(d)),
+                                                        d, MM::negate(MM::alpha(s))));
+        }
+    }
+    MM::end();
+}
+
+template <class MM>
+static void QT_FASTCALL rasterop_solid_SourceOrDestination(uint *dest,
+                                                           int length,
+                                                           uint color,
+                                                           uint const_alpha)
+{
+    Q_UNUSED(const_alpha);
+
+    if ((quintptr)(dest) & 0x7) {
+        *dest++ |= color;
+        --length;
+    }
+
+    const int length64 = length / 2;
+    if (length64) {
+        __m64 *dst64 = reinterpret_cast<__m64*>(dest);
+        const __m64 color64 = _mm_set_pi32(color, color);
+
+        int n = (length64 + 3) / 4;
+        switch (length64 & 0x3) {
+        case 0: do { *dst64 = _mm_or_si64(*dst64, color64); ++dst64;
+        case 3:      *dst64 = _mm_or_si64(*dst64, color64); ++dst64;
+        case 2:      *dst64 = _mm_or_si64(*dst64, color64); ++dst64;
+        case 1:      *dst64 = _mm_or_si64(*dst64, color64); ++dst64;
+        } while (--n > 0);
+        }
+    }
+
+    if (length & 0x1) {
+        dest[length - 1] |= color;
+    }
+
+    MM::end();
+}
+
+template <class MM>
+static void QT_FASTCALL rasterop_solid_SourceAndDestination(uint *dest,
+                                                            int length,
+                                                            uint color,
+                                                            uint const_alpha)
+{
+    Q_UNUSED(const_alpha);
+
+    color |= 0xff000000;
+
+    if ((quintptr)(dest) & 0x7) { // align
+        *dest++ &= color;
+        --length;
+    }
+
+    const int length64 = length / 2;
+    if (length64) {
+        __m64 *dst64 = reinterpret_cast<__m64*>(dest);
+        const __m64 color64 = _mm_set_pi32(color, color);
+
+        int n = (length64 + 3) / 4;
+        switch (length64 & 0x3) {
+        case 0: do { *dst64 = _mm_and_si64(*dst64, color64); ++dst64;
+        case 3:      *dst64 = _mm_and_si64(*dst64, color64); ++dst64;
+        case 2:      *dst64 = _mm_and_si64(*dst64, color64); ++dst64;
+        case 1:      *dst64 = _mm_and_si64(*dst64, color64); ++dst64;
+        } while (--n > 0);
+        }
+    }
+
+    if (length & 0x1) {
+        dest[length - 1] &= color;
+    }
+
+    MM::end();
+}
+
+template <class MM>
+static void QT_FASTCALL rasterop_solid_SourceXorDestination(uint *dest,
+                                                            int length,
+                                                            uint color,
+                                                            uint const_alpha)
+{
+    Q_UNUSED(const_alpha);
+
+    color &= 0x00ffffff;
+
+    if ((quintptr)(dest) & 0x7) {
+        *dest++ ^= color;
+        --length;
+    }
+
+    const int length64 = length / 2;
+    if (length64) {
+        __m64 *dst64 = reinterpret_cast<__m64*>(dest);
+        const __m64 color64 = _mm_set_pi32(color, color);
+
+        int n = (length64 + 3) / 4;
+        switch (length64 & 0x3) {
+        case 0: do { *dst64 = _mm_xor_si64(*dst64, color64); ++dst64;
+        case 3:      *dst64 = _mm_xor_si64(*dst64, color64); ++dst64;
+        case 2:      *dst64 = _mm_xor_si64(*dst64, color64); ++dst64;
+        case 1:      *dst64 = _mm_xor_si64(*dst64, color64); ++dst64;
+        } while (--n > 0);
+        }
+    }
+
+    if (length & 0x1) {
+        dest[length - 1] ^= color;
+    }
+
+    MM::end();
+}
+
+template <class MM>
+static void QT_FASTCALL rasterop_solid_SourceAndNotDestination(uint *dest,
+                                                               int length,
+                                                               uint color,
+                                                               uint const_alpha)
+{
+
+    Q_UNUSED(const_alpha);
+
+    if ((quintptr)(dest) & 0x7) {
+        *dest = (color & ~(*dest)) | 0xff000000;
+        ++dest;
+        --length;
+    }
+
+    const int length64 = length / 2;
+    if (length64) {
+        __m64 *dst64 = reinterpret_cast<__m64*>(dest);
+        const __m64 color64 = _mm_set_pi32(color, color);
+        const m64 mmx_0xff000000 = _mm_set1_pi32(0xff000000);
+        __m64 tmp1, tmp2, tmp3, tmp4;
+
+        int n = (length64 + 3) / 4;
+        switch (length64 & 0x3) {
+        case 0: do { tmp1 = _mm_andnot_si64(*dst64, color64);
+                     *dst64++ = _mm_or_si64(tmp1, mmx_0xff000000);
+        case 3:      tmp2 = _mm_andnot_si64(*dst64, color64);
+                     *dst64++ = _mm_or_si64(tmp2, mmx_0xff000000);
+        case 2:      tmp3 = _mm_andnot_si64(*dst64, color64);
+                     *dst64++ = _mm_or_si64(tmp3, mmx_0xff000000);
+        case 1:      tmp4 = _mm_andnot_si64(*dst64, color64);
+                     *dst64++ = _mm_or_si64(tmp4, mmx_0xff000000);
+        } while (--n > 0);
+        }
+    }
+
+    if (length & 0x1) {
+        dest[length - 1] = (color & ~(dest[length - 1])) | 0xff000000;
+    }
+
+    MM::end();
+}
+
+template <class MM>
+static void QT_FASTCALL rasterop_solid_NotSourceAndNotDestination(uint *dest,
+                                                                  int length,
+                                                                  uint color,
+                                                                  uint const_alpha)
+{
+    rasterop_solid_SourceAndNotDestination<MM>(dest, length,
+                                               ~color, const_alpha);
+}
+
+template <class MM>
+static void QT_FASTCALL rasterop_solid_NotSourceOrNotDestination(uint *dest,
+                                                                 int length,
+                                                                 uint color,
+                                                                 uint const_alpha)
+{
+    Q_UNUSED(const_alpha);
+    color = ~color | 0xff000000;
+    while (length--) {
+        *dest = color | ~(*dest);
+        ++dest;
+    }
+}
+
+template <class MM>
+static void QT_FASTCALL rasterop_solid_NotSourceXorDestination(uint *dest,
+                                                               int length,
+                                                               uint color,
+                                                               uint const_alpha)
+{
+    rasterop_solid_SourceXorDestination<MM>(dest, length, ~color, const_alpha);
+}
+
+template <class MM>
+static void QT_FASTCALL rasterop_solid_NotSource(uint *dest, int length,
+                                                 uint color, uint const_alpha)
+{
+    Q_UNUSED(const_alpha);
+    qt_memfill((quint32*)dest, ~color | 0xff000000, length);
+}
+
+template <class MM>
+static void QT_FASTCALL rasterop_solid_NotSourceAndDestination(uint *dest,
+                                                               int length,
+                                                               uint color,
+                                                               uint const_alpha)
+{
+    rasterop_solid_SourceAndDestination<MM>(dest, length,
+                                            ~color, const_alpha);
+}
+
+template <class MM>
+static inline void qt_blend_color_argb_x86(int count, const QSpan *spans,
+                                           void *userData,
+                                           CompositionFunctionSolid *solidFunc)
+{
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+    if (data->rasterBuffer->compositionMode == QPainter::CompositionMode_Source
+        || (data->rasterBuffer->compositionMode == QPainter::CompositionMode_SourceOver
+            && qAlpha(data->solid.color) == 255)) {
+        // inline for performance
+        C_FF; C_80; C_00;
+        while (count--) {
+            uint *target = ((uint *)data->rasterBuffer->scanLine(spans->y)) + spans->x;
+            if (spans->coverage == 255) {
+                qt_memfill(static_cast<quint32*>(target), quint32(data->solid.color), spans->len);
+            } else {
+                // dest = s * ca + d * (1 - sa*ca) --> dest = s * ca + d * (1-ca)
+                m64 ca = MM::load_alpha(spans->coverage);
+                m64 s = MM::byte_mul(MM::load(data->solid.color), ca);
+                m64 ica = MM::negate(ca);
+                for (int i = 0; i < spans->len; ++i)
+                    target[i] = MM::store(MM::add(s, MM::byte_mul(MM::load(target[i]), ica)));
+            }
+            ++spans;
+        }
+        MM::end();
+        return;
+    }
+    CompositionFunctionSolid func = solidFunc[data->rasterBuffer->compositionMode];
+    while (count--) {
+        uint *target = ((uint *)data->rasterBuffer->scanLine(spans->y)) + spans->x;
+        func(target, spans->len, data->solid.color, spans->coverage);
+        ++spans;
+    }
+}
+
+#ifdef QT_HAVE_MMX
+struct QMMXIntrinsics : public QMMXCommonIntrinsics
+{
+    static inline void end() {
+#if !defined(Q_OS_WINCE) || defined(_X86_)
+       _mm_empty();
+#endif
+    }
+};
+#endif // QT_HAVE_MMX
+
+QT_END_NAMESPACE
+
+#endif // QDRAWHELPER_MMX_P_H
diff --git a/src/gui/painting/qdrawhelper_neon.cpp b/src/gui/painting/qdrawhelper_neon.cpp
new file mode 100644
index 0000000000..debca37486
--- /dev/null
+++ b/src/gui/painting/qdrawhelper_neon.cpp
@@ -0,0 +1,961 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <private/qdrawhelper_p.h>
+#include <private/qblendfunctions_p.h>
+#include <private/qmath_p.h>
+
+#ifdef QT_HAVE_NEON
+
+#include <private/qdrawhelper_neon_p.h>
+#include <private/qpaintengine_raster_p.h>
+#include <arm_neon.h>
+
+QT_BEGIN_NAMESPACE
+
+void qt_memfill32_neon(quint32 *dest, quint32 value, int count)
+{
+    const int epilogueSize = count % 16;
+    if (count >= 16) {
+        quint32 *const neonEnd = dest + count - epilogueSize;
+        register uint32x4_t valueVector1 asm ("q0") = vdupq_n_u32(value);
+        register uint32x4_t valueVector2 asm ("q1") = valueVector1;
+        while (dest != neonEnd) {
+            asm volatile (
+                "vst2.32     { d0, d1, d2, d3 }, [%[DST]] !\n\t"
+                "vst2.32     { d0, d1, d2, d3 }, [%[DST]] !\n\t"
+                : [DST]"+r" (dest)
+                : [VALUE1]"w"(valueVector1), [VALUE2]"w"(valueVector2)
+                : "memory"
+            );
+        }
+    }
+
+    switch (epilogueSize)
+    {
+    case 15:     *dest++ = value;
+    case 14:     *dest++ = value;
+    case 13:     *dest++ = value;
+    case 12:     *dest++ = value;
+    case 11:     *dest++ = value;
+    case 10:     *dest++ = value;
+    case 9:      *dest++ = value;
+    case 8:      *dest++ = value;
+    case 7:      *dest++ = value;
+    case 6:      *dest++ = value;
+    case 5:      *dest++ = value;
+    case 4:      *dest++ = value;
+    case 3:      *dest++ = value;
+    case 2:      *dest++ = value;
+    case 1:      *dest++ = value;
+    }
+}
+
+static inline uint16x8_t qvdiv_255_u16(uint16x8_t x, uint16x8_t half)
+{
+    // result = (x + (x >> 8) + 0x80) >> 8
+
+    const uint16x8_t temp = vshrq_n_u16(x, 8); // x >> 8
+    const uint16x8_t sum_part = vaddq_u16(x, half); // x + 0x80
+    const uint16x8_t sum = vaddq_u16(temp, sum_part);
+
+    return vshrq_n_u16(sum, 8);
+}
+
+static inline uint16x8_t qvbyte_mul_u16(uint16x8_t x, uint16x8_t alpha, uint16x8_t half)
+{
+    // t = qRound(x * alpha / 255.0)
+
+    const uint16x8_t t = vmulq_u16(x, alpha); // t
+    return qvdiv_255_u16(t, half);
+}
+
+static inline uint16x8_t qvinterpolate_pixel_255(uint16x8_t x, uint16x8_t a, uint16x8_t y, uint16x8_t b, uint16x8_t half)
+{
+    // t = x * a + y * b
+
+    const uint16x8_t ta = vmulq_u16(x, a);
+    const uint16x8_t tb = vmulq_u16(y, b);
+
+    return qvdiv_255_u16(vaddq_u16(ta, tb), half);
+}
+
+static inline uint16x8_t qvsource_over_u16(uint16x8_t src16, uint16x8_t dst16, uint16x8_t half, uint16x8_t full)
+{
+    const uint16x4_t alpha16_high = vdup_lane_u16(vget_high_u16(src16), 3);
+    const uint16x4_t alpha16_low = vdup_lane_u16(vget_low_u16(src16), 3);
+
+    const uint16x8_t alpha16 = vsubq_u16(full, vcombine_u16(alpha16_low, alpha16_high));
+
+    return vaddq_u16(src16, qvbyte_mul_u16(dst16, alpha16, half));
+}
+
+extern "C" void
+pixman_composite_over_8888_0565_asm_neon (int32_t   w,
+                                          int32_t   h,
+                                          uint16_t *dst,
+                                          int32_t   dst_stride,
+                                          uint32_t *src,
+                                          int32_t   src_stride);
+
+extern "C" void
+pixman_composite_over_8888_8888_asm_neon (int32_t   w,
+                                          int32_t   h,
+                                          uint32_t *dst,
+                                          int32_t   dst_stride,
+                                          uint32_t *src,
+                                          int32_t   src_stride);
+
+extern "C" void
+pixman_composite_src_0565_8888_asm_neon (int32_t   w,
+                                         int32_t   h,
+                                         uint32_t *dst,
+                                         int32_t   dst_stride,
+                                         uint16_t *src,
+                                         int32_t   src_stride);
+
+extern "C" void
+pixman_composite_over_n_8_0565_asm_neon (int32_t    w,
+                                         int32_t    h,
+                                         uint16_t  *dst,
+                                         int32_t    dst_stride,
+                                         uint32_t   src,
+                                         int32_t    unused,
+                                         uint8_t   *mask,
+                                         int32_t    mask_stride);
+
+extern "C" void
+pixman_composite_scanline_over_asm_neon (int32_t         w,
+                                         const uint32_t *dst,
+                                         const uint32_t *src);
+
+extern "C" void
+pixman_composite_src_0565_0565_asm_neon (int32_t   w,
+                                         int32_t   h,
+                                         uint16_t *dst,
+                                         int32_t   dst_stride,
+                                         uint16_t *src,
+                                         int32_t   src_stride);
+
+// qblendfunctions.cpp
+void qt_blend_argb32_on_rgb16_const_alpha(uchar *destPixels, int dbpl,
+                                          const uchar *srcPixels, int sbpl,
+                                          int w, int h,
+                                          int const_alpha);
+
+void qt_blend_rgb16_on_argb32_neon(uchar *destPixels, int dbpl,
+                                   const uchar *srcPixels, int sbpl,
+                                   int w, int h,
+                                   int const_alpha)
+{
+    dbpl /= 4;
+    sbpl /= 2;
+
+    quint32 *dst = (quint32 *) destPixels;
+    quint16 *src = (quint16 *) srcPixels;
+
+    if (const_alpha != 256) {
+        quint8 a = (255 * const_alpha) >> 8;
+        quint8 ia = 255 - a;
+
+        while (h--) {
+            for (int x=0; x<w; ++x)
+                dst[x] = INTERPOLATE_PIXEL_255(qt_colorConvert(src[x], dst[x]), a, dst[x], ia);
+            dst += dbpl;
+            src += sbpl;
+        }
+        return;
+    }
+
+    pixman_composite_src_0565_8888_asm_neon(w, h, dst, dbpl, src, sbpl);
+}
+
+// qblendfunctions.cpp
+void qt_blend_rgb16_on_rgb16(uchar *dst, int dbpl,
+                             const uchar *src, int sbpl,
+                             int w, int h,
+                             int const_alpha);
+
+template <int N>
+static inline void scanLineBlit16(quint16 *dst, quint16 *src, int dstride)
+{
+    if (N >= 2) {
+        ((quint32 *)dst)[0] = ((quint32 *)src)[0];
+        __builtin_prefetch(dst + dstride, 1, 0);
+    }
+    for (int i = 1; i < N/2; ++i)
+        ((quint32 *)dst)[i] = ((quint32 *)src)[i];
+    if (N & 1)
+        dst[N-1] = src[N-1];
+}
+
+template <int Width>
+static inline void blockBlit16(quint16 *dst, quint16 *src, int dstride, int sstride, int h)
+{
+    union {
+        quintptr address;
+        quint16 *pointer;
+    } u;
+
+    u.pointer = dst;
+
+    if (u.address & 2) {
+        while (h--) {
+            // align dst
+            dst[0] = src[0];
+            if (Width > 1)
+                scanLineBlit16<Width-1>(dst + 1, src + 1, dstride);
+            dst += dstride;
+            src += sstride;
+        }
+    } else {
+        while (h--) {
+            scanLineBlit16<Width>(dst, src, dstride);
+
+            dst += dstride;
+            src += sstride;
+        }
+    }
+}
+
+void qt_blend_rgb16_on_rgb16_neon(uchar *destPixels, int dbpl,
+                                  const uchar *srcPixels, int sbpl,
+                                  int w, int h,
+                                  int const_alpha)
+{
+    // testing show that the default memcpy is faster for widths 150 and up
+    if (const_alpha != 256 || w >= 150) {
+        qt_blend_rgb16_on_rgb16(destPixels, dbpl, srcPixels, sbpl, w, h, const_alpha);
+        return;
+    }
+
+    int dstride = dbpl / 2;
+    int sstride = sbpl / 2;
+
+    quint16 *dst = (quint16 *) destPixels;
+    quint16 *src = (quint16 *) srcPixels;
+
+    switch (w) {
+#define BLOCKBLIT(n) case n: blockBlit16<n>(dst, src, dstride, sstride, h); return;
+    BLOCKBLIT(1);
+    BLOCKBLIT(2);
+    BLOCKBLIT(3);
+    BLOCKBLIT(4);
+    BLOCKBLIT(5);
+    BLOCKBLIT(6);
+    BLOCKBLIT(7);
+    BLOCKBLIT(8);
+    BLOCKBLIT(9);
+    BLOCKBLIT(10);
+    BLOCKBLIT(11);
+    BLOCKBLIT(12);
+    BLOCKBLIT(13);
+    BLOCKBLIT(14);
+    BLOCKBLIT(15);
+#undef BLOCKBLIT
+    default:
+        break;
+    }
+
+    pixman_composite_src_0565_0565_asm_neon (w, h, dst, dstride, src, sstride);
+}
+
+extern "C" void blend_8_pixels_argb32_on_rgb16_neon(quint16 *dst, const quint32 *src, int const_alpha);
+
+void qt_blend_argb32_on_rgb16_neon(uchar *destPixels, int dbpl,
+                                   const uchar *srcPixels, int sbpl,
+                                   int w, int h,
+                                   int const_alpha)
+{
+    quint16 *dst = (quint16 *) destPixels;
+    quint32 *src = (quint32 *) srcPixels;
+
+    if (const_alpha != 256) {
+        for (int y=0; y<h; ++y) {
+            int i = 0;
+            for (; i < w-7; i += 8)
+                blend_8_pixels_argb32_on_rgb16_neon(&dst[i], &src[i], const_alpha);
+
+            if (i < w) {
+                int tail = w - i;
+
+                quint16 dstBuffer[8];
+                quint32 srcBuffer[8];
+
+                for (int j = 0; j < tail; ++j) {
+                    dstBuffer[j] = dst[i + j];
+                    srcBuffer[j] = src[i + j];
+                }
+
+                blend_8_pixels_argb32_on_rgb16_neon(dstBuffer, srcBuffer, const_alpha);
+
+                for (int j = 0; j < tail; ++j)
+                    dst[i + j] = dstBuffer[j];
+            }
+
+            dst = (quint16 *)(((uchar *) dst) + dbpl);
+            src = (quint32 *)(((uchar *) src) + sbpl);
+        }
+        return;
+    }
+
+    pixman_composite_over_8888_0565_asm_neon(w, h, dst, dbpl / 2, src, sbpl / 4);
+}
+
+void qt_blend_argb32_on_argb32_scanline_neon(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    if (const_alpha == 255) {
+        pixman_composite_scanline_over_asm_neon(length, dest, src);
+    } else {
+        qt_blend_argb32_on_argb32_neon((uchar *)dest, 4 * length, (uchar *)src, 4 * length, length, 1, (const_alpha * 256) / 255);
+    }
+}
+
+void qt_blend_argb32_on_argb32_neon(uchar *destPixels, int dbpl,
+                                    const uchar *srcPixels, int sbpl,
+                                    int w, int h,
+                                    int const_alpha)
+{
+    const uint *src = (const uint *) srcPixels;
+    uint *dst = (uint *) destPixels;
+    uint16x8_t half = vdupq_n_u16(0x80);
+    uint16x8_t full = vdupq_n_u16(0xff);
+    if (const_alpha == 256) {
+        pixman_composite_over_8888_8888_asm_neon(w, h, (uint32_t *)destPixels, dbpl / 4, (uint32_t *)srcPixels, sbpl / 4);
+    } else if (const_alpha != 0) {
+        const_alpha = (const_alpha * 255) >> 8;
+        uint16x8_t const_alpha16 = vdupq_n_u16(const_alpha);
+        for (int y = 0; y < h; ++y) {
+            int x = 0;
+            for (; x < w-3; x += 4) {
+                if (src[x] | src[x+1] | src[x+2] | src[x+3]) {
+                    uint32x4_t src32 = vld1q_u32((uint32_t *)&src[x]);
+                    uint32x4_t dst32 = vld1q_u32((uint32_t *)&dst[x]);
+
+                    const uint8x16_t src8 = vreinterpretq_u8_u32(src32);
+                    const uint8x16_t dst8 = vreinterpretq_u8_u32(dst32);
+
+                    const uint8x8_t src8_low = vget_low_u8(src8);
+                    const uint8x8_t dst8_low = vget_low_u8(dst8);
+
+                    const uint8x8_t src8_high = vget_high_u8(src8);
+                    const uint8x8_t dst8_high = vget_high_u8(dst8);
+
+                    const uint16x8_t src16_low = vmovl_u8(src8_low);
+                    const uint16x8_t dst16_low = vmovl_u8(dst8_low);
+
+                    const uint16x8_t src16_high = vmovl_u8(src8_high);
+                    const uint16x8_t dst16_high = vmovl_u8(dst8_high);
+
+                    const uint16x8_t srcalpha16_low = qvbyte_mul_u16(src16_low, const_alpha16, half);
+                    const uint16x8_t srcalpha16_high = qvbyte_mul_u16(src16_high, const_alpha16, half);
+
+                    const uint16x8_t result16_low = qvsource_over_u16(srcalpha16_low, dst16_low, half, full);
+                    const uint16x8_t result16_high = qvsource_over_u16(srcalpha16_high, dst16_high, half, full);
+
+                    const uint32x2_t result32_low = vreinterpret_u32_u8(vmovn_u16(result16_low));
+                    const uint32x2_t result32_high = vreinterpret_u32_u8(vmovn_u16(result16_high));
+
+                    vst1q_u32((uint32_t *)&dst[x], vcombine_u32(result32_low, result32_high));
+                }
+            }
+            for (; x<w; ++x) {
+                uint s = src[x];
+                if (s != 0) {
+                    s = BYTE_MUL(s, const_alpha);
+                    dst[x] = s + BYTE_MUL(dst[x], qAlpha(~s));
+                }
+            }
+            dst = (quint32 *)(((uchar *) dst) + dbpl);
+            src = (const quint32 *)(((const uchar *) src) + sbpl);
+        }
+    }
+}
+
+// qblendfunctions.cpp
+void qt_blend_rgb32_on_rgb32(uchar *destPixels, int dbpl,
+                             const uchar *srcPixels, int sbpl,
+                             int w, int h,
+                             int const_alpha);
+
+void qt_blend_rgb32_on_rgb32_neon(uchar *destPixels, int dbpl,
+                                  const uchar *srcPixels, int sbpl,
+                                  int w, int h,
+                                  int const_alpha)
+{
+    if (const_alpha != 256) {
+        if (const_alpha != 0) {
+            const uint *src = (const uint *) srcPixels;
+            uint *dst = (uint *) destPixels;
+            uint16x8_t half = vdupq_n_u16(0x80);
+            const_alpha = (const_alpha * 255) >> 8;
+            int one_minus_const_alpha = 255 - const_alpha;
+            uint16x8_t const_alpha16 = vdupq_n_u16(const_alpha);
+            uint16x8_t one_minus_const_alpha16 = vdupq_n_u16(255 - const_alpha);
+            for (int y = 0; y < h; ++y) {
+                int x = 0;
+                for (; x < w-3; x += 4) {
+                    uint32x4_t src32 = vld1q_u32((uint32_t *)&src[x]);
+                    uint32x4_t dst32 = vld1q_u32((uint32_t *)&dst[x]);
+
+                    const uint8x16_t src8 = vreinterpretq_u8_u32(src32);
+                    const uint8x16_t dst8 = vreinterpretq_u8_u32(dst32);
+
+                    const uint8x8_t src8_low = vget_low_u8(src8);
+                    const uint8x8_t dst8_low = vget_low_u8(dst8);
+
+                    const uint8x8_t src8_high = vget_high_u8(src8);
+                    const uint8x8_t dst8_high = vget_high_u8(dst8);
+
+                    const uint16x8_t src16_low = vmovl_u8(src8_low);
+                    const uint16x8_t dst16_low = vmovl_u8(dst8_low);
+
+                    const uint16x8_t src16_high = vmovl_u8(src8_high);
+                    const uint16x8_t dst16_high = vmovl_u8(dst8_high);
+
+                    const uint16x8_t result16_low = qvinterpolate_pixel_255(src16_low, const_alpha16, dst16_low, one_minus_const_alpha16, half);
+                    const uint16x8_t result16_high = qvinterpolate_pixel_255(src16_high, const_alpha16, dst16_high, one_minus_const_alpha16, half);
+
+                    const uint32x2_t result32_low = vreinterpret_u32_u8(vmovn_u16(result16_low));
+                    const uint32x2_t result32_high = vreinterpret_u32_u8(vmovn_u16(result16_high));
+
+                    vst1q_u32((uint32_t *)&dst[x], vcombine_u32(result32_low, result32_high));
+                }
+                for (; x<w; ++x) {
+                    uint 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);
+                src = (const quint32 *)(((const uchar *) src) + sbpl);
+            }
+        }
+    } else {
+        qt_blend_rgb32_on_rgb32(destPixels, dbpl, srcPixels, sbpl, w, h, const_alpha);
+    }
+}
+
+void qt_alphamapblit_quint16_neon(QRasterBuffer *rasterBuffer,
+                                  int x, int y, quint32 color,
+                                  const uchar *bitmap,
+                                  int mapWidth, int mapHeight, int mapStride,
+                                  const QClipData *)
+{
+    quint16 *dest = reinterpret_cast<quint16*>(rasterBuffer->scanLine(y)) + x;
+    const int destStride = rasterBuffer->bytesPerLine() / sizeof(quint16);
+
+    uchar *mask = const_cast<uchar *>(bitmap);
+
+    pixman_composite_over_n_8_0565_asm_neon(mapWidth, mapHeight, dest, destStride, color, 0, mask, mapStride);
+}
+
+extern "C" void blend_8_pixels_rgb16_on_rgb16_neon(quint16 *dst, const quint16 *src, int const_alpha);
+
+template <typename SRC, typename BlendFunc>
+struct Blend_on_RGB16_SourceAndConstAlpha_Neon {
+    Blend_on_RGB16_SourceAndConstAlpha_Neon(BlendFunc blender, int const_alpha)
+        : m_index(0)
+        , m_blender(blender)
+        , m_const_alpha(const_alpha)
+    {
+    }
+
+    inline void write(quint16 *dst, quint32 src)
+    {
+        srcBuffer[m_index++] = src;
+
+        if (m_index == 8) {
+            m_blender(dst - 7, srcBuffer, m_const_alpha);
+            m_index = 0;
+        }
+    }
+
+    inline void flush(quint16 *dst)
+    {
+        if (m_index > 0) {
+            quint16 dstBuffer[8];
+            for (int i = 0; i < m_index; ++i)
+                dstBuffer[i] = dst[i - m_index];
+
+            m_blender(dstBuffer, srcBuffer, m_const_alpha);
+
+            for (int i = 0; i < m_index; ++i)
+                dst[i - m_index] = dstBuffer[i];
+
+            m_index = 0;
+        }
+    }
+
+    SRC srcBuffer[8];
+
+    int m_index;
+    BlendFunc m_blender;
+    int m_const_alpha;
+};
+
+template <typename SRC, typename BlendFunc>
+Blend_on_RGB16_SourceAndConstAlpha_Neon<SRC, BlendFunc>
+Blend_on_RGB16_SourceAndConstAlpha_Neon_create(BlendFunc blender, int const_alpha)
+{
+    return Blend_on_RGB16_SourceAndConstAlpha_Neon<SRC, BlendFunc>(blender, const_alpha);
+}
+
+void qt_scale_image_argb32_on_rgb16_neon(uchar *destPixels, int dbpl,
+                                         const uchar *srcPixels, int sbpl,
+                                         const QRectF &targetRect,
+                                         const QRectF &sourceRect,
+                                         const QRect &clip,
+                                         int const_alpha)
+{
+    if (const_alpha == 0)
+        return;
+
+    qt_scale_image_16bit<quint32>(destPixels, dbpl, srcPixels, sbpl, targetRect, sourceRect, clip,
+        Blend_on_RGB16_SourceAndConstAlpha_Neon_create<quint32>(blend_8_pixels_argb32_on_rgb16_neon, const_alpha));
+}
+
+void qt_scale_image_rgb16_on_rgb16(uchar *destPixels, int dbpl,
+                                   const uchar *srcPixels, int sbpl,
+                                   const QRectF &targetRect,
+                                   const QRectF &sourceRect,
+                                   const QRect &clip,
+                                   int const_alpha);
+
+void qt_scale_image_rgb16_on_rgb16_neon(uchar *destPixels, int dbpl,
+                                        const uchar *srcPixels, int sbpl,
+                                        const QRectF &targetRect,
+                                        const QRectF &sourceRect,
+                                        const QRect &clip,
+                                        int const_alpha)
+{
+    if (const_alpha == 0)
+        return;
+
+    if (const_alpha == 256) {
+        qt_scale_image_rgb16_on_rgb16(destPixels, dbpl, srcPixels, sbpl, targetRect, sourceRect, clip, const_alpha);
+        return;
+    }
+
+    qt_scale_image_16bit<quint16>(destPixels, dbpl, srcPixels, sbpl, targetRect, sourceRect, clip,
+        Blend_on_RGB16_SourceAndConstAlpha_Neon_create<quint16>(blend_8_pixels_rgb16_on_rgb16_neon, const_alpha));
+}
+
+extern void qt_transform_image_rgb16_on_rgb16(uchar *destPixels, int dbpl,
+                                              const uchar *srcPixels, int sbpl,
+                                              const QRectF &targetRect,
+                                              const QRectF &sourceRect,
+                                              const QRect &clip,
+                                              const QTransform &targetRectTransform,
+                                              int const_alpha);
+
+void qt_transform_image_rgb16_on_rgb16_neon(uchar *destPixels, int dbpl,
+                                            const uchar *srcPixels, int sbpl,
+                                            const QRectF &targetRect,
+                                            const QRectF &sourceRect,
+                                            const QRect &clip,
+                                            const QTransform &targetRectTransform,
+                                            int const_alpha)
+{
+    if (const_alpha == 0)
+        return;
+
+    if (const_alpha == 256) {
+        qt_transform_image_rgb16_on_rgb16(destPixels, dbpl, srcPixels, sbpl, targetRect, sourceRect, clip, targetRectTransform, const_alpha);
+        return;
+    }
+
+    qt_transform_image(reinterpret_cast<quint16 *>(destPixels), dbpl,
+                       reinterpret_cast<const quint16 *>(srcPixels), sbpl, targetRect, sourceRect, clip, targetRectTransform,
+        Blend_on_RGB16_SourceAndConstAlpha_Neon_create<quint16>(blend_8_pixels_rgb16_on_rgb16_neon, const_alpha));
+}
+
+void qt_transform_image_argb32_on_rgb16_neon(uchar *destPixels, int dbpl,
+                                             const uchar *srcPixels, int sbpl,
+                                             const QRectF &targetRect,
+                                             const QRectF &sourceRect,
+                                             const QRect &clip,
+                                             const QTransform &targetRectTransform,
+                                             int const_alpha)
+{
+    if (const_alpha == 0)
+        return;
+
+    qt_transform_image(reinterpret_cast<quint16 *>(destPixels), dbpl,
+                       reinterpret_cast<const quint32 *>(srcPixels), sbpl, targetRect, sourceRect, clip, targetRectTransform,
+        Blend_on_RGB16_SourceAndConstAlpha_Neon_create<quint32>(blend_8_pixels_argb32_on_rgb16_neon, const_alpha));
+}
+
+static inline void convert_8_pixels_rgb16_to_argb32(quint32 *dst, const quint16 *src)
+{
+    asm volatile (
+        "vld1.16     { d0, d1 }, [%[SRC]]\n\t"
+
+        /* convert 8 r5g6b5 pixel data from {d0, d1} to planar 8-bit format
+           and put data into d4 - red, d3 - green, d2 - blue */
+        "vshrn.u16   d4,  q0,  #8\n\t"
+        "vshrn.u16   d3,  q0,  #3\n\t"
+        "vsli.u16    q0,  q0,  #5\n\t"
+        "vsri.u8     d4,  d4,  #5\n\t"
+        "vsri.u8     d3,  d3,  #6\n\t"
+        "vshrn.u16   d2,  q0,  #2\n\t"
+
+        /* fill d5 - alpha with 0xff */
+        "mov         r2, #255\n\t"
+        "vdup.8      d5, r2\n\t"
+
+        "vst4.8      { d2, d3, d4, d5 }, [%[DST]]"
+        : : [DST]"r" (dst), [SRC]"r" (src)
+        : "memory", "r2", "d0", "d1", "d2", "d3", "d4", "d5"
+    );
+}
+
+uint * QT_FASTCALL qt_destFetchRGB16_neon(uint *buffer, QRasterBuffer *rasterBuffer, int x, int y, int length)
+{
+    const ushort *data = (const ushort *)rasterBuffer->scanLine(y) + x;
+
+    int i = 0;
+    for (; i < length - 7; i += 8)
+        convert_8_pixels_rgb16_to_argb32(&buffer[i], &data[i]);
+
+    if (i < length) {
+        quint16 srcBuffer[8];
+        quint32 dstBuffer[8];
+
+        int tail = length - i;
+        for (int j = 0; j < tail; ++j)
+            srcBuffer[j] = data[i + j];
+
+        convert_8_pixels_rgb16_to_argb32(dstBuffer, srcBuffer);
+
+        for (int j = 0; j < tail; ++j)
+            buffer[i + j] = dstBuffer[j];
+    }
+
+    return buffer;
+}
+
+static inline void convert_8_pixels_argb32_to_rgb16(quint16 *dst, const quint32 *src)
+{
+    asm volatile (
+        "vld4.8      { d0, d1, d2, d3 }, [%[SRC]]\n\t"
+
+        /* convert to r5g6b5 and store it into {d28, d29} */
+        "vshll.u8    q14, d2, #8\n\t"
+        "vshll.u8    q8,  d1, #8\n\t"
+        "vshll.u8    q9,  d0, #8\n\t"
+        "vsri.u16    q14, q8, #5\n\t"
+        "vsri.u16    q14, q9, #11\n\t"
+
+        "vst1.16     { d28, d29 }, [%[DST]]"
+        : : [DST]"r" (dst), [SRC]"r" (src)
+        : "memory", "d0", "d1", "d2", "d3", "d16", "d17", "d18", "d19", "d28", "d29"
+    );
+}
+
+void QT_FASTCALL qt_destStoreRGB16_neon(QRasterBuffer *rasterBuffer, int x, int y, const uint *buffer, int length)
+{
+    quint16 *data = (quint16*)rasterBuffer->scanLine(y) + x;
+
+    int i = 0;
+    for (; i < length - 7; i += 8)
+        convert_8_pixels_argb32_to_rgb16(&data[i], &buffer[i]);
+
+    if (i < length) {
+        quint32 srcBuffer[8];
+        quint16 dstBuffer[8];
+
+        int tail = length - i;
+        for (int j = 0; j < tail; ++j)
+            srcBuffer[j] = buffer[i + j];
+
+        convert_8_pixels_argb32_to_rgb16(dstBuffer, srcBuffer);
+
+        for (int j = 0; j < tail; ++j)
+            data[i + j] = dstBuffer[j];
+    }
+}
+
+void QT_FASTCALL comp_func_solid_SourceOver_neon(uint *destPixels, int length, uint color, uint const_alpha)
+{
+    if ((const_alpha & qAlpha(color)) == 255) {
+        QT_MEMFILL_UINT(destPixels, length, color);
+    } else {
+        if (const_alpha != 255)
+            color = BYTE_MUL(color, const_alpha);
+
+        const quint32 minusAlphaOfColor = qAlpha(~color);
+        int x = 0;
+
+        uint32_t *dst = (uint32_t *) destPixels;
+        const uint32x4_t colorVector = vdupq_n_u32(color);
+        uint16x8_t half = vdupq_n_u16(0x80);
+        const uint16x8_t minusAlphaOfColorVector = vdupq_n_u16(minusAlphaOfColor);
+
+        for (; x < length-3; x += 4) {
+            uint32x4_t dstVector = vld1q_u32(&dst[x]);
+
+            const uint8x16_t dst8 = vreinterpretq_u8_u32(dstVector);
+
+            const uint8x8_t dst8_low = vget_low_u8(dst8);
+            const uint8x8_t dst8_high = vget_high_u8(dst8);
+
+            const uint16x8_t dst16_low = vmovl_u8(dst8_low);
+            const uint16x8_t dst16_high = vmovl_u8(dst8_high);
+
+            const uint16x8_t result16_low = qvbyte_mul_u16(dst16_low, minusAlphaOfColorVector, half);
+            const uint16x8_t result16_high = qvbyte_mul_u16(dst16_high, minusAlphaOfColorVector, half);
+
+            const uint32x2_t result32_low = vreinterpret_u32_u8(vmovn_u16(result16_low));
+            const uint32x2_t result32_high = vreinterpret_u32_u8(vmovn_u16(result16_high));
+
+            uint32x4_t blendedPixels = vcombine_u32(result32_low, result32_high);
+            uint32x4_t colorPlusBlendedPixels = vaddq_u32(colorVector, blendedPixels);
+            vst1q_u32(&dst[x], colorPlusBlendedPixels);
+        }
+
+        for (;x < length; ++x)
+            destPixels[x] = color + BYTE_MUL(destPixels[x], minusAlphaOfColor);
+    }
+}
+
+void QT_FASTCALL comp_func_Plus_neon(uint *dst, const uint *src, int length, uint const_alpha)
+{
+    if (const_alpha == 255) {
+        uint *const end = dst + length;
+        uint *const neonEnd = end - 3;
+
+        while (dst < neonEnd) {
+            asm volatile (
+                "vld2.8     { d0, d1 }, [%[SRC]] !\n\t"
+                "vld2.8     { d2, d3 }, [%[DST]]\n\t"
+                "vqadd.u8 q0, q0, q1\n\t"
+                "vst2.8     { d0, d1 }, [%[DST]] !\n\t"
+                : [DST]"+r" (dst), [SRC]"+r" (src)
+                :
+                : "memory", "d0", "d1", "d2", "d3", "q0", "q1"
+            );
+        }
+
+        while (dst != end) {
+            *dst = comp_func_Plus_one_pixel(*dst, *src);
+            ++dst;
+            ++src;
+        }
+    } else {
+        int x = 0;
+        const int one_minus_const_alpha = 255 - const_alpha;
+        const uint16x8_t constAlphaVector = vdupq_n_u16(const_alpha);
+        const uint16x8_t oneMinusconstAlphaVector = vdupq_n_u16(one_minus_const_alpha);
+
+        const uint16x8_t half = vdupq_n_u16(0x80);
+        for (; x < length - 3; x += 4) {
+            const uint32x4_t src32 = vld1q_u32((uint32_t *)&src[x]);
+            const uint8x16_t src8 = vreinterpretq_u8_u32(src32);
+            uint8x16_t dst8 = vld1q_u8((uint8_t *)&dst[x]);
+            uint8x16_t result = vqaddq_u8(dst8, src8);
+
+            uint16x8_t result_low = vmovl_u8(vget_low_u8(result));
+            uint16x8_t result_high = vmovl_u8(vget_high_u8(result));
+
+            uint16x8_t dst_low = vmovl_u8(vget_low_u8(dst8));
+            uint16x8_t dst_high = vmovl_u8(vget_high_u8(dst8));
+
+            result_low = qvinterpolate_pixel_255(result_low, constAlphaVector, dst_low, oneMinusconstAlphaVector, half);
+            result_high = qvinterpolate_pixel_255(result_high, constAlphaVector, dst_high, oneMinusconstAlphaVector, half);
+
+            const uint32x2_t result32_low = vreinterpret_u32_u8(vmovn_u16(result_low));
+            const uint32x2_t result32_high = vreinterpret_u32_u8(vmovn_u16(result_high));
+            vst1q_u32((uint32_t *)&dst[x], vcombine_u32(result32_low, result32_high));
+        }
+
+        for (; x < length; ++x)
+            dst[x] = comp_func_Plus_one_pixel_const_alpha(dst[x], src[x], const_alpha, one_minus_const_alpha);
+    }
+}
+
+static const int tileSize = 32;
+
+extern "C" void qt_rotate90_16_neon(quint16 *dst, const quint16 *src, int sstride, int dstride, int count);
+
+void qt_memrotate90_16_neon(const uchar *srcPixels, int w, int h, int sstride, uchar *destPixels, int dstride)
+{
+    const ushort *src = (const ushort *)srcPixels;
+    ushort *dest = (ushort *)destPixels;
+
+    sstride /= sizeof(ushort);
+    dstride /= sizeof(ushort);
+
+    const int pack = sizeof(quint32) / sizeof(ushort);
+    const int unaligned =
+        qMin(uint((quintptr(dest) & (sizeof(quint32)-1)) / sizeof(ushort)), uint(h));
+    const int restX = w % tileSize;
+    const int restY = (h - unaligned) % tileSize;
+    const int unoptimizedY = restY % pack;
+    const int numTilesX = w / tileSize + (restX > 0);
+    const int numTilesY = (h - unaligned) / tileSize + (restY >= pack);
+
+    for (int tx = 0; tx < numTilesX; ++tx) {
+        const int startx = w - tx * tileSize - 1;
+        const int stopx = qMax(startx - tileSize, 0);
+
+        if (unaligned) {
+            for (int x = startx; x >= stopx; --x) {
+                ushort *d = dest + (w - x - 1) * dstride;
+                for (int y = 0; y < unaligned; ++y) {
+                    *d++ = src[y * sstride + x];
+                }
+            }
+        }
+
+        for (int ty = 0; ty < numTilesY; ++ty) {
+            const int starty = ty * tileSize + unaligned;
+            const int stopy = qMin(starty + tileSize, h - unoptimizedY);
+
+            int x = startx;
+            // qt_rotate90_16_neon writes to eight rows, four pixels at a time
+            for (; x >= stopx + 7; x -= 8) {
+                ushort *d = dest + (w - x - 1) * dstride + starty;
+                const ushort *s = &src[starty * sstride + x - 7];
+                qt_rotate90_16_neon(d, s, sstride * 2, dstride * 2, stopy - starty);
+            }
+
+            for (; x >= stopx; --x) {
+                quint32 *d = reinterpret_cast<quint32*>(dest + (w - x - 1) * dstride + starty);
+                for (int y = starty; y < stopy; y += pack) {
+                    quint32 c = src[y * sstride + x];
+                    for (int i = 1; i < pack; ++i) {
+                        const int shift = (sizeof(int) * 8 / pack * i);
+                        const ushort color = src[(y + i) * sstride + x];
+                        c |= color << shift;
+                    }
+                    *d++ = c;
+                }
+            }
+        }
+
+        if (unoptimizedY) {
+            const int starty = h - unoptimizedY;
+            for (int x = startx; x >= stopx; --x) {
+                ushort *d = dest + (w - x - 1) * dstride + starty;
+                for (int y = starty; y < h; ++y) {
+                    *d++ = src[y * sstride + x];
+                }
+            }
+        }
+    }
+}
+
+extern "C" void qt_rotate270_16_neon(quint16 *dst, const quint16 *src, int sstride, int dstride, int count);
+
+void qt_memrotate270_16_neon(const uchar *srcPixels, int w, int h,
+                             int sstride,
+                             uchar *destPixels, int dstride)
+{
+    const ushort *src = (const ushort *)srcPixels;
+    ushort *dest = (ushort *)destPixels;
+
+    sstride /= sizeof(ushort);
+    dstride /= sizeof(ushort);
+
+    const int pack = sizeof(quint32) / sizeof(ushort);
+    const int unaligned =
+        qMin(uint((long(dest) & (sizeof(quint32)-1)) / sizeof(ushort)), uint(h));
+    const int restX = w % tileSize;
+    const int restY = (h - unaligned) % tileSize;
+    const int unoptimizedY = restY % pack;
+    const int numTilesX = w / tileSize + (restX > 0);
+    const int numTilesY = (h - unaligned) / tileSize + (restY >= pack);
+
+    for (int tx = 0; tx < numTilesX; ++tx) {
+        const int startx = tx * tileSize;
+        const int stopx = qMin(startx + tileSize, w);
+
+        if (unaligned) {
+            for (int x = startx; x < stopx; ++x) {
+                ushort *d = dest + x * dstride;
+                for (int y = h - 1; y >= h - unaligned; --y) {
+                    *d++ = src[y * sstride + x];
+                }
+            }
+        }
+
+        for (int ty = 0; ty < numTilesY; ++ty) {
+            const int starty = h - 1 - unaligned - ty * tileSize;
+            const int stopy = qMax(starty - tileSize, unoptimizedY);
+
+            int x = startx;
+            // qt_rotate90_16_neon writes to eight rows, four pixels at a time
+            for (; x < stopx - 7; x += 8) {
+                ushort *d = dest + x * dstride + h - 1 - starty;
+                const ushort *s = &src[starty * sstride + x];
+                qt_rotate90_16_neon(d + 7 * dstride, s, -sstride * 2, -dstride * 2, starty - stopy);
+            }
+
+            for (; x < stopx; ++x) {
+                quint32 *d = reinterpret_cast<quint32*>(dest + x * dstride
+                                                        + h - 1 - starty);
+                for (int y = starty; y > stopy; y -= pack) {
+                    quint32 c = src[y * sstride + x];
+                    for (int i = 1; i < pack; ++i) {
+                        const int shift = (sizeof(int) * 8 / pack * i);
+                        const ushort color = src[(y - i) * sstride + x];
+                        c |= color << shift;
+                    }
+                    *d++ = c;
+                }
+            }
+        }
+        if (unoptimizedY) {
+            const int starty = unoptimizedY - 1;
+            for (int x = startx; x < stopx; ++x) {
+                ushort *d = dest + x * dstride + h - 1 - starty;
+                for (int y = starty; y >= 0; --y) {
+                    *d++ = src[y * sstride + x];
+                }
+            }
+        }
+    }
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_HAVE_NEON
+
diff --git a/src/gui/painting/qdrawhelper_neon_asm.S b/src/gui/painting/qdrawhelper_neon_asm.S
new file mode 100644
index 0000000000..e8434fc8e7
--- /dev/null
+++ b/src/gui/painting/qdrawhelper_neon_asm.S
@@ -0,0 +1,297 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/* Prevent the stack from becoming executable for no reason... */
+#if defined(__linux__) && defined(__ELF__)
+.section .note.GNU-stack,"",%progbits
+#endif
+
+.text
+.fpu neon
+.arch armv7a
+.altmacro
+
+/* void blend_8_pixels_argb32_on_rgb16_neon(quint16 *dst, const quint32 *src, int const_alpha) */
+
+    .func blend_8_pixels_argb32_on_rgb16_neon
+    .global blend_8_pixels_argb32_on_rgb16_neon
+    /* For ELF format also set function visibility to hidden */
+#ifdef __ELF__
+    .hidden blend_8_pixels_argb32_on_rgb16_neon
+    .type blend_8_pixels_argb32_on_rgb16_neon, %function
+#endif
+blend_8_pixels_argb32_on_rgb16_neon:
+    vld4.8      { d0, d1, d2, d3 }, [r1]
+    vld1.16     { d4, d5 }, [r0]
+
+    cmp         r2, #256
+    beq         .blend_32_inner
+
+    vdup.8      d6, r2
+
+    /* multiply by const_alpha */
+    vmull.u8    q8,   d6, d0
+    vmull.u8    q9,   d6, d1
+    vmull.u8    q10,  d6, d2
+    vmull.u8    q11,  d6, d3
+
+    vshrn.u16   d0,  q8, #8
+    vshrn.u16   d1,  q9, #8
+    vshrn.u16   d2, q10, #8
+    vshrn.u16   d3, q11, #8
+
+.blend_32_inner:
+    /* convert 8 r5g6b5 pixel data from {d4, d5} to planar 8-bit format
+       and put data into d6 - red, d7 - green, d30 - blue */
+    vshrn.u16   d6, q2, #8
+    vshrn.u16   d7, q2, #3
+    vsli.u16    q2, q2, #5
+    vsri.u8     d6, d6, #5
+    vmvn.8      d3, d3
+    vsri.u8     d7, d7, #6
+    vshrn.u16   d30, q2, #2
+
+    pld [r0, #128]
+
+    /* now do alpha blending, storing results in 8-bit planar format
+       into d16 - red, d19 - green, d18 - blue */
+    vmull.u8    q10, d3, d6
+    vmull.u8    q11, d3, d7
+    vmull.u8    q12, d3, d30
+    vrshr.u16   q13, q10, #8
+    vrshr.u16   q3,  q11, #8
+    vrshr.u16   q15, q12, #8
+    vraddhn.u16 d20, q10, q13
+    vraddhn.u16 d23, q11, q3
+    vraddhn.u16 d22, q12, q15
+    vqadd.u8    d16, d2, d20
+    vqadd.u8    q9, q0, q11
+    /* convert the result to r5g6b5 and store it into {d28, d29} */
+    vshll.u8    q14, d16, #8
+    vshll.u8    q8, d19, #8
+    vshll.u8    q9, d18, #8
+    vsri.u16    q14, q8, #5
+    vsri.u16    q14, q9, #11
+
+    vst1.16     { d28, d29 }, [r0]
+
+    bx          lr
+
+    .endfunc
+
+/* void blend_8_pixels_rgb16_on_rgb16_neon(quint16 *dst, const quint16 *src, int const_alpha) */
+
+    .func blend_8_pixels_rgb16_on_rgb16_neon
+    .global blend_8_pixels_rgb16_on_rgb16_neon
+    /* For ELF format also set function visibility to hidden */
+#ifdef __ELF__
+    .hidden blend_8_pixels_rgb16_on_rgb16_neon
+    .type blend_8_pixels_rgb16_on_rgb16_neon, %function
+#endif
+blend_8_pixels_rgb16_on_rgb16_neon:
+    vld1.16     { d0, d1 }, [r0]
+    vld1.16     { d2, d3 }, [r1]
+
+    rsb         r3, r2, #256
+    vdup.8      d4, r2
+    vdup.8      d5, r3
+
+    /* convert 8 r5g6b5 pixel data from {d0, d1} to planar 8-bit format
+       and put data into d6 - red, d7 - green, d30 - blue */
+    vshrn.u16   d6,  q0,  #8
+    vshrn.u16   d7,  q0,  #3
+    vsli.u16    q0,  q0,  #5
+    vsri.u8     d6,  d6,  #5
+    vsri.u8     d7,  d7,  #6
+    vshrn.u16   d30, q0,  #2
+
+    /* same from {d2, d3} into {d26, d27, d28} */
+    vshrn.u16   d26, q1,  #8
+    vshrn.u16   d27, q1,  #3
+    vsli.u16    q1,  q1,  #5
+    vsri.u8     d26, d26, #5
+    vsri.u8     d27, d27, #6
+    vshrn.u16   d28, q1,  #2
+
+    /* multiply dst by inv const_alpha */
+    vmull.u8    q10, d5,  d6
+    vmull.u8    q11, d5,  d7
+    vmull.u8    q12, d5,  d30
+
+    vshrn.u16   d6,  q10, #8
+    vshrn.u16   d7,  q11, #8
+    vshrn.u16   d30, q12, #8
+
+    /* multiply src by const_alpha */
+    vmull.u8    q10,  d4, d26
+    vmull.u8    q11,  d4, d27
+    vmull.u8    q12,  d4, d28
+
+    vshrn.u16   d26, q10, #8
+    vshrn.u16   d27, q11, #8
+    vshrn.u16   d28, q12, #8
+
+    /* preload dst + 128 */
+    pld [r0, #128]
+
+    /* add components, storing results in 8-bit planar format
+       into d16 - red, d19 - green, d18 - blue */
+    vadd.u8     d16, d26, d6
+    vadd.u8     d19, d27, d7
+    vadd.u8     d18, d28, d30
+
+    /* convert the result to r5g6b5 and store it into {d28, d29} */
+    vshll.u8    q14, d16, #8
+    vshll.u8    q8,  d19, #8
+    vshll.u8    q9,  d18, #8
+    vsri.u16    q14,  q8, #5
+    vsri.u16    q14,  q9, #11
+
+    vst1.16     { d28, d29 }, [r0]
+
+    bx          lr
+
+    .endfunc
+
+/* void qt_rotate90_16_neon(quint16 *dst, const quint16 *src, int sstride, int dstride, int count) */
+    .func qt_rotate90_16_neon
+    .global qt_rotate90_16_neon
+    /* For ELF format also set function visibility to hidden */
+#ifdef __ELF__
+    .hidden qt_rotate90_16_neon
+    .type qt_rotate90_16_neon, %function
+#endif
+qt_rotate90_16_neon:
+    push { r4-r11, lr }
+    ldr r5, [sp, #(9*4)]
+
+    /* The preloads are the key to getting good performance */
+    pld [r1]
+
+    mov r4, r5, asr #2
+    add r6, r0, r3
+    add r7, r6, r3
+
+    add r8, r7, r3
+    add r9, r8, r3
+
+    pld [r1, r2]
+
+    add r10, r9, r3
+    add r11, r10, r3
+
+    add r3, r3, r11
+    and r5, r5, #3
+
+    pld [r1, r2, lsl #1]
+
+    cmp r4, #0
+    beq .rotate90_16_tail
+
+.rotate90_16_loop:
+    vld1.16 { q8  }, [r1], r2
+
+    pld [r1, r2, lsl #1]
+
+    vld1.16 { q9  }, [r1], r2
+    vld1.16 { q10 }, [r1], r2
+    vld1.16 { q11 }, [r1], r2
+
+    pld [r1]
+
+    /* Could have used four quad-word zips instead,
+       but those take three cycles as opposed to one. */
+    vzip.16 d16, d20
+    vzip.16 d17, d21
+
+    vzip.16 d18, d22
+
+    pld [r1, r2]
+
+    vzip.16 d19, d23
+
+    vzip.16 d16, d18
+    vzip.16 d17, d19
+
+    pld [r1, r2, lsl #1]
+
+    vzip.16 d20, d22
+    vzip.16 d21, d23
+
+    vst1.16 { d23 }, [r0]!
+    vst1.16 { d21 }, [r6]!
+    vst1.16 { d19 }, [r7]!
+    vst1.16 { d17 }, [r8]!
+    vst1.16 { d22 }, [r9]!
+    vst1.16 { d20 }, [r10]!
+    vst1.16 { d18 }, [r11]!
+    vst1.16 { d16 }, [r3]!
+
+    sub r4, r4, #1
+    cmp r4, #0
+    bne .rotate90_16_loop
+    b .rotate90_16_tail
+
+.rotate90_16_tail_loop:
+    sub r5, r5, #2
+
+    vld1.16 { q8 }, [r1], r2
+    vld1.16 { q9 }, [r1], r2
+
+    vzip.16 d16, d18
+    vzip.16 d17, d19
+
+    vst1.32 { d19[1] }, [r0]!
+    vst1.32 { d19[0] }, [r6]!
+    vst1.32 { d17[1] }, [r7]!
+    vst1.32 { d17[0] }, [r8]!
+    vst1.32 { d18[1] }, [r9]!
+    vst1.32 { d18[0] }, [r10]!
+    vst1.32 { d16[1] }, [r11]!
+    vst1.32 { d16[0] }, [r3]!
+
+.rotate90_16_tail:
+    cmp r5, #0
+    bgt .rotate90_16_tail_loop
+
+    pop { r4-r11, pc }
+
+    .endfunc
diff --git a/src/gui/painting/qdrawhelper_neon_p.h b/src/gui/painting/qdrawhelper_neon_p.h
new file mode 100644
index 0000000000..5db66932a1
--- /dev/null
+++ b/src/gui/painting/qdrawhelper_neon_p.h
@@ -0,0 +1,146 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QDRAWHELPER_NEON_P_H
+#define QDRAWHELPER_NEON_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <private/qdrawhelper_p.h>
+
+QT_BEGIN_NAMESPACE
+
+#ifdef QT_HAVE_NEON
+
+void qt_blend_argb32_on_argb32_neon(uchar *destPixels, int dbpl,
+                                            const uchar *srcPixels, int sbpl,
+                                            int w, int h,
+                                            int const_alpha);
+
+void qt_blend_rgb32_on_rgb32_neon(uchar *destPixels, int dbpl,
+                                  const uchar *srcPixels, int sbpl,
+                                  int w, int h,
+                                  int const_alpha);
+
+void qt_blend_argb32_on_rgb16_neon(uchar *destPixels, int dbpl,
+                                   const uchar *srcPixels, int sbpl,
+                                   int w, int h,
+                                   int const_alpha);
+
+void qt_blend_argb32_on_argb32_scanline_neon(uint *dest,
+                                             const uint *src,
+                                             int length,
+                                             uint const_alpha);
+
+void qt_blend_rgb16_on_argb32_neon(uchar *destPixels, int dbpl,
+                                   const uchar *srcPixels, int sbpl,
+                                   int w, int h,
+                                   int const_alpha);
+
+void qt_blend_rgb16_on_rgb16_neon(uchar *destPixels, int dbpl,
+                                  const uchar *srcPixels, int sbpl,
+                                  int w, int h,
+                                  int const_alpha);
+
+void qt_alphamapblit_quint16_neon(QRasterBuffer *rasterBuffer,
+                                  int x, int y, quint32 color,
+                                  const uchar *bitmap,
+                                  int mapWidth, int mapHeight, int mapStride,
+                                  const QClipData *clip);
+
+void qt_scale_image_argb32_on_rgb16_neon(uchar *destPixels, int dbpl,
+                                         const uchar *srcPixels, int sbpl,
+                                         const QRectF &targetRect,
+                                         const QRectF &sourceRect,
+                                         const QRect &clip,
+                                         int const_alpha);
+
+void qt_scale_image_rgb16_on_rgb16_neon(uchar *destPixels, int dbpl,
+                                        const uchar *srcPixels, int sbpl,
+                                        const QRectF &targetRect,
+                                        const QRectF &sourceRect,
+                                        const QRect &clip,
+                                        int const_alpha);
+
+void qt_transform_image_argb32_on_rgb16_neon(uchar *destPixels, int dbpl,
+                                             const uchar *srcPixels, int sbpl,
+                                             const QRectF &targetRect,
+                                             const QRectF &sourceRect,
+                                             const QRect &clip,
+                                             const QTransform &targetRectTransform,
+                                             int const_alpha);
+
+void qt_transform_image_rgb16_on_rgb16_neon(uchar *destPixels, int dbpl,
+                                            const uchar *srcPixels, int sbpl,
+                                            const QRectF &targetRect,
+                                            const QRectF &sourceRect,
+                                            const QRect &clip,
+                                            const QTransform &targetRectTransform,
+                                            int const_alpha);
+
+void qt_memfill32_neon(quint32 *dest, quint32 value, int count);
+void qt_memrotate90_16_neon(const uchar *srcPixels, int w, int h, int sbpl, uchar *destPixels, int dbpl);
+void qt_memrotate270_16_neon(const uchar *srcPixels, int w, int h, int sbpl, uchar *destPixels, int dbpl);
+
+uint * QT_FASTCALL qt_destFetchRGB16_neon(uint *buffer,
+                                          QRasterBuffer *rasterBuffer,
+                                          int x, int y, int length);
+
+void QT_FASTCALL qt_destStoreRGB16_neon(QRasterBuffer *rasterBuffer,
+                                        int x, int y, const uint *buffer, int length);
+
+void QT_FASTCALL comp_func_solid_SourceOver_neon(uint *destPixels, int length, uint color, uint const_alpha);
+void QT_FASTCALL comp_func_Plus_neon(uint *dst, const uint *src, int length, uint const_alpha);
+
+#endif // QT_HAVE_NEON
+
+QT_END_NAMESPACE
+
+#endif // QDRAWHELPER_NEON_P_H
diff --git a/src/gui/painting/qdrawhelper_p.h b/src/gui/painting/qdrawhelper_p.h
new file mode 100644
index 0000000000..d4e731bbb2
--- /dev/null
+++ b/src/gui/painting/qdrawhelper_p.h
@@ -0,0 +1,2033 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QDRAWHELPER_P_H
+#define QDRAWHELPER_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "QtCore/qglobal.h"
+#include "QtGui/qcolor.h"
+#include "QtGui/qpainter.h"
+#include "QtGui/qimage.h"
+#ifndef QT_FT_BEGIN_HEADER
+#define QT_FT_BEGIN_HEADER
+#define QT_FT_END_HEADER
+#endif
+#include "private/qrasterdefs_p.h"
+#include <private/qsimd_p.h>
+
+#ifdef Q_WS_QWS
+#include "QtGui/qscreen_qws.h"
+#endif
+
+QT_BEGIN_NAMESPACE
+
+#if defined(Q_CC_MSVC) && _MSCVER <= 1300 && !defined(Q_CC_INTEL)
+#define Q_STATIC_TEMPLATE_SPECIALIZATION static
+#else
+#define Q_STATIC_TEMPLATE_SPECIALIZATION
+#endif
+
+#if defined(Q_CC_RVCT)
+// RVCT doesn't like static template functions
+#  define Q_STATIC_TEMPLATE_FUNCTION
+#  define Q_STATIC_INLINE_FUNCTION static __forceinline
+#else
+#  define Q_STATIC_TEMPLATE_FUNCTION static
+#  define Q_STATIC_INLINE_FUNCTION static inline
+#endif
+
+static const uint AMASK = 0xff000000;
+static const uint RMASK = 0x00ff0000;
+static const uint GMASK = 0x0000ff00;
+static const uint BMASK = 0x000000ff;
+
+/*******************************************************************************
+ * QSpan
+ *
+ * duplicate definition of FT_Span
+ */
+typedef QT_FT_Span QSpan;
+
+struct QSolidData;
+struct QTextureData;
+struct QGradientData;
+struct QLinearGradientData;
+struct QRadialGradientData;
+struct QConicalGradientData;
+struct QSpanData;
+class QGradient;
+class QRasterBuffer;
+class QClipData;
+class QRasterPaintEngineState;
+
+typedef QT_FT_SpanFunc ProcessSpans;
+typedef void (*BitmapBlitFunc)(QRasterBuffer *rasterBuffer,
+                               int x, int y, quint32 color,
+                               const uchar *bitmap,
+                               int mapWidth, int mapHeight, int mapStride);
+
+typedef void (*AlphamapBlitFunc)(QRasterBuffer *rasterBuffer,
+                                 int x, int y, quint32 color,
+                                 const uchar *bitmap,
+                                 int mapWidth, int mapHeight, int mapStride,
+                                 const QClipData *clip);
+
+typedef void (*AlphaRGBBlitFunc)(QRasterBuffer *rasterBuffer,
+                                 int x, int y, quint32 color,
+                                 const uint *rgbmask,
+                                 int mapWidth, int mapHeight, int mapStride,
+                                 const QClipData *clip);
+
+typedef void (*RectFillFunc)(QRasterBuffer *rasterBuffer,
+                             int x, int y, int width, int height,
+                             quint32 color);
+
+typedef void (*SrcOverBlendFunc)(uchar *destPixels, int dbpl,
+                                 const uchar *src, int spbl,
+                                 int w, int h,
+                                 int const_alpha);
+
+typedef void (*SrcOverScaleFunc)(uchar *destPixels, int dbpl,
+                                 const uchar *src, int spbl,
+                                 const QRectF &targetRect,
+                                 const QRectF &sourceRect,
+                                 const QRect &clipRect,
+                                 int const_alpha);
+
+typedef void (*SrcOverTransformFunc)(uchar *destPixels, int dbpl,
+                                     const uchar *src, int spbl,
+                                     const QRectF &targetRect,
+                                     const QRectF &sourceRect,
+                                     const QRect &clipRect,
+                                     const QTransform &targetRectTransform,
+                                     int const_alpha);
+
+typedef void (*MemRotateFunc)(const uchar *srcPixels, int w, int h, int sbpl, uchar *destPixels, int dbpl);
+
+struct DrawHelper {
+    ProcessSpans blendColor;
+    ProcessSpans blendGradient;
+    BitmapBlitFunc bitmapBlit;
+    AlphamapBlitFunc alphamapBlit;
+    AlphaRGBBlitFunc alphaRGBBlit;
+    RectFillFunc fillRect;
+};
+
+extern SrcOverBlendFunc qBlendFunctions[QImage::NImageFormats][QImage::NImageFormats];
+extern SrcOverScaleFunc qScaleFunctions[QImage::NImageFormats][QImage::NImageFormats];
+extern SrcOverTransformFunc qTransformFunctions[QImage::NImageFormats][QImage::NImageFormats];
+extern MemRotateFunc qMemRotateFunctions[QImage::NImageFormats][3];
+
+extern DrawHelper qDrawHelper[QImage::NImageFormats];
+
+void qBlendTexture(int count, const QSpan *spans, void *userData);
+#if defined(Q_WS_QWS) && !defined(QT_NO_RASTERCALLBACKS)
+extern DrawHelper qDrawHelperCallback[QImage::NImageFormats];
+void qBlendTextureCallback(int count, const QSpan *spans, void *userData);
+#endif
+
+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);
+
+void qInitDrawhelperAsm();
+
+class QRasterPaintEngine;
+
+struct QSolidData
+{
+    uint color;
+};
+
+struct QLinearGradientData
+{
+    struct {
+        qreal x;
+        qreal y;
+    } origin;
+    struct {
+        qreal x;
+        qreal y;
+    } end;
+};
+
+struct QRadialGradientData
+{
+    struct {
+        qreal x;
+        qreal y;
+    } center;
+    struct {
+        qreal x;
+        qreal y;
+    } focal;
+    qreal radius;
+};
+
+struct QConicalGradientData
+{
+    struct {
+        qreal x;
+        qreal y;
+    } center;
+    qreal angle;
+};
+
+struct QGradientData
+{
+    QGradient::Spread spread;
+
+    union {
+        QLinearGradientData linear;
+        QRadialGradientData radial;
+        QConicalGradientData conical;
+    };
+
+#ifdef Q_WS_QWS
+#define GRADIENT_STOPTABLE_SIZE 256
+#else
+#define GRADIENT_STOPTABLE_SIZE 1024
+#endif
+
+    uint* colorTable; //[GRADIENT_STOPTABLE_SIZE];
+
+    uint alphaColor : 1;
+};
+
+struct QTextureData
+{
+    const uchar *imageData;
+    const uchar *scanLine(int y) const { return imageData + y*bytesPerLine; }
+
+    int width;
+    int height;
+    // clip rect
+    int x1;
+    int y1;
+    int x2;
+    int y2;
+    int bytesPerLine;
+    QImage::Format format;
+    const QVector<QRgb> *colorTable;
+    bool hasAlpha;
+    enum Type {
+        Plain,
+        Tiled
+    };
+    Type type;
+    int const_alpha;
+};
+
+struct QSpanData
+{
+    QSpanData() : tempImage(0) {}
+    ~QSpanData() { delete tempImage; }
+
+    QRasterBuffer *rasterBuffer;
+#ifdef Q_WS_QWS
+    QRasterPaintEngine *rasterEngine;
+#endif
+    ProcessSpans blend;
+    ProcessSpans unclipped_blend;
+    BitmapBlitFunc bitmapBlit;
+    AlphamapBlitFunc alphamapBlit;
+    AlphaRGBBlitFunc alphaRGBBlit;
+    RectFillFunc fillRect;
+    qreal m11, m12, m13, m21, m22, m23, m33, dx, dy;   // inverse xform matrix
+    const QClipData *clip;
+    enum Type {
+        None,
+        Solid,
+        LinearGradient,
+        RadialGradient,
+        ConicalGradient,
+        Texture
+    } type : 8;
+    int txop : 8;
+    int fast_matrix : 1;
+    bool bilinear;
+    QImage *tempImage;
+    union {
+        QSolidData solid;
+        QGradientData gradient;
+        QTextureData texture;
+    };
+
+    void init(QRasterBuffer *rb, const QRasterPaintEngine *pe);
+    void setup(const QBrush &brush, int alpha, QPainter::CompositionMode compositionMode);
+    void setupMatrix(const QTransform &matrix, int bilinear);
+    void initTexture(const QImage *image, int alpha, QTextureData::Type = QTextureData::Plain, const QRect &sourceRect = QRect());
+    void adjustSpanMethods();
+};
+
+#if defined(Q_CC_RVCT)
+#  pragma push
+#  pragma arm
+#endif
+Q_STATIC_INLINE_FUNCTION uint INTERPOLATE_PIXEL_255(uint x, uint a, uint y, uint b) {
+    uint t = (x & 0xff00ff) * a + (y & 0xff00ff) * b;
+    t = (t + ((t >> 8) & 0xff00ff) + 0x800080) >> 8;
+    t &= 0xff00ff;
+
+    x = ((x >> 8) & 0xff00ff) * a + ((y >> 8) & 0xff00ff) * b;
+    x = (x + ((x >> 8) & 0xff00ff) + 0x800080);
+    x &= 0xff00ff00;
+    x |= t;
+    return x;
+}
+#if defined(Q_CC_RVCT)
+#  pragma pop
+#endif
+
+#if QT_POINTER_SIZE == 8 // 64-bit versions
+
+Q_STATIC_INLINE_FUNCTION uint INTERPOLATE_PIXEL_256(uint x, uint a, uint y, uint b) {
+    quint64 t = (((quint64(x)) | ((quint64(x)) << 24)) & 0x00ff00ff00ff00ff) * a;
+    t += (((quint64(y)) | ((quint64(y)) << 24)) & 0x00ff00ff00ff00ff) * b;
+    t >>= 8;
+    t &= 0x00ff00ff00ff00ff;
+    return (uint(t)) | (uint(t >> 24));
+}
+
+Q_STATIC_INLINE_FUNCTION uint BYTE_MUL(uint x, uint a) {
+    quint64 t = (((quint64(x)) | ((quint64(x)) << 24)) & 0x00ff00ff00ff00ff) * a;
+    t = (t + ((t >> 8) & 0xff00ff00ff00ff) + 0x80008000800080) >> 8;
+    t &= 0x00ff00ff00ff00ff;
+    return (uint(t)) | (uint(t >> 24));
+}
+
+Q_STATIC_INLINE_FUNCTION uint PREMUL(uint x) {
+    uint a = x >> 24;
+    quint64 t = (((quint64(x)) | ((quint64(x)) << 24)) & 0x00ff00ff00ff00ff) * a;
+    t = (t + ((t >> 8) & 0xff00ff00ff00ff) + 0x80008000800080) >> 8;
+    t &= 0x000000ff00ff00ff;
+    return (uint(t)) | (uint(t >> 24)) | (a << 24);
+}
+
+#else // 32-bit versions
+
+Q_STATIC_INLINE_FUNCTION uint INTERPOLATE_PIXEL_256(uint x, uint a, uint y, uint b) {
+    uint t = (x & 0xff00ff) * a + (y & 0xff00ff) * b;
+    t >>= 8;
+    t &= 0xff00ff;
+
+    x = ((x >> 8) & 0xff00ff) * a + ((y >> 8) & 0xff00ff) * b;
+    x &= 0xff00ff00;
+    x |= t;
+    return x;
+}
+
+#if defined(Q_CC_RVCT)
+#  pragma push
+#  pragma arm
+#endif
+Q_STATIC_INLINE_FUNCTION uint BYTE_MUL(uint x, uint a) {
+    uint t = (x & 0xff00ff) * a;
+    t = (t + ((t >> 8) & 0xff00ff) + 0x800080) >> 8;
+    t &= 0xff00ff;
+
+    x = ((x >> 8) & 0xff00ff) * a;
+    x = (x + ((x >> 8) & 0xff00ff) + 0x800080);
+    x &= 0xff00ff00;
+    x |= t;
+    return x;
+}
+#if defined(Q_CC_RVCT)
+#  pragma pop
+#endif
+
+Q_STATIC_INLINE_FUNCTION uint PREMUL(uint x) {
+    uint a = x >> 24;
+    uint t = (x & 0xff00ff) * a;
+    t = (t + ((t >> 8) & 0xff00ff) + 0x800080) >> 8;
+    t &= 0xff00ff;
+
+    x = ((x >> 8) & 0xff) * a;
+    x = (x + ((x >> 8) & 0xff) + 0x80);
+    x &= 0xff00;
+    x |= t | (a << 24);
+    return x;
+}
+#endif
+
+
+Q_STATIC_INLINE_FUNCTION uint BYTE_MUL_RGB16(uint x, uint a) {
+    a += 1;
+    uint t = (((x & 0x07e0)*a) >> 8) & 0x07e0;
+    t |= (((x & 0xf81f)*(a>>2)) >> 6) & 0xf81f;
+    return t;
+}
+
+Q_STATIC_INLINE_FUNCTION uint BYTE_MUL_RGB16_32(uint x, uint a) {
+    uint t = (((x & 0xf81f07e0) >> 5)*a) & 0xf81f07e0;
+    t |= (((x & 0x07e0f81f)*a) >> 5) & 0x07e0f81f;
+    return t;
+}
+
+#define INV_PREMUL(p)                                   \
+    (qAlpha(p) == 0 ? 0 :                               \
+    ((qAlpha(p) << 24)                                  \
+     | (((255*qRed(p))/ qAlpha(p)) << 16)               \
+     | (((255*qGreen(p)) / qAlpha(p))  << 8)            \
+     | ((255*qBlue(p)) / qAlpha(p))))
+
+template <class DST, class SRC>
+inline DST qt_colorConvert(SRC color, DST dummy)
+{
+    Q_UNUSED(dummy);
+    return DST(color);
+}
+
+
+template <>
+inline quint32 qt_colorConvert(quint16 color, quint32 dummy)
+{
+    Q_UNUSED(dummy);
+    const int r = (color & 0xf800);
+    const int g = (color & 0x07e0);
+    const int b = (color & 0x001f);
+    const int tr = (r >> 8) | (r >> 13);
+    const int tg = (g >> 3) | (g >> 9);
+    const int tb = (b << 3) | (b >> 2);
+
+    return qRgb(tr, tg, tb);
+}
+
+template <>
+inline quint16 qt_colorConvert(quint32 color, quint16 dummy)
+{
+    Q_UNUSED(dummy);
+    const int r = qRed(color) << 8;
+    const int g = qGreen(color) << 3;
+    const int b = qBlue(color) >> 3;
+
+    return (r & 0xf800) | (g & 0x07e0)| (b & 0x001f);
+}
+
+class quint32p
+{
+public:
+    inline quint32p(quint32 v) : data(PREMUL(v)) {}
+
+    inline operator quint32() const { return data; }
+
+    inline operator quint16() const
+    {
+        return qt_colorConvert<quint16, quint32>(data, 0);
+    }
+
+    Q_STATIC_INLINE_FUNCTION quint32p fromRawData(quint32 v)
+    {
+        quint32p p;
+        p.data = v;
+        return p;
+    }
+
+private:
+    quint32p() {}
+    quint32 data;
+} Q_PACKED;
+
+class qabgr8888
+{
+public:
+    inline qabgr8888(quint32 v)
+    {
+        data = qRgba(qBlue(v), qGreen(v), qRed(v), qAlpha(v));
+    }
+
+    inline bool operator==(const qabgr8888 &v) const { return data == v.data; }
+
+private:
+    quint32 data;
+} Q_PACKED;
+
+class qrgb565;
+
+class qargb8565
+{
+public:
+    Q_STATIC_INLINE_FUNCTION bool hasAlpha() { return true; }
+
+    inline qargb8565() {}
+    inline qargb8565(quint32 v);
+    inline explicit qargb8565(quint32p v);
+    inline qargb8565(const qargb8565 &v);
+    inline qargb8565(const qrgb565 &v);
+
+    inline operator quint32() const;
+    inline operator quint16() const;
+
+    inline quint8 alpha() const { return data[0]; }
+    inline qargb8565 truncedAlpha() {
+        data[0] &= 0xf8;
+        data[1] &= 0xdf;
+        return *this;
+    }
+    Q_STATIC_INLINE_FUNCTION quint8 alpha(quint8 a) { return (a + 1) >> 3; }
+    Q_STATIC_INLINE_FUNCTION quint8 ialpha(quint8 a) { return 0x20 - alpha(a); }
+
+    inline qargb8565 byte_mul(quint8 a) const;
+    inline qargb8565 operator+(qargb8565 v) const;
+    inline bool operator==(const qargb8565 &v) const;
+
+    inline quint32 rawValue() const;
+    inline quint16 rawValue16() const;
+
+private:
+    friend class qrgb565;
+
+    quint8 data[3];
+} Q_PACKED;
+
+class qrgb565
+{
+public:
+    Q_STATIC_INLINE_FUNCTION bool hasAlpha() { return false; }
+
+    qrgb565(int v = 0) : data(v) {}
+
+    inline explicit qrgb565(quint32p v);
+    inline explicit qrgb565(quint32 v);
+    inline explicit qrgb565(const qargb8565 &v);
+
+    inline operator quint32() const;
+    inline operator quint16() const;
+
+    inline qrgb565 operator+(qrgb565 v) const;
+
+    inline quint8 alpha() const { return 0xff; }
+    inline qrgb565 truncedAlpha() { return *this; }
+    Q_STATIC_INLINE_FUNCTION quint8 alpha(quint8 a) { return (a + 1) >> 3; }
+    Q_STATIC_INLINE_FUNCTION quint8 ialpha(quint8 a) { return 0x20 - alpha(a); }
+
+    inline qrgb565 byte_mul(quint8 a) const;
+
+    inline bool operator==(const qrgb565 &v) const;
+    inline quint16 rawValue() const { return data; }
+
+private:
+    friend class qargb8565;
+
+    quint16 data;
+} Q_PACKED;
+
+qargb8565::qargb8565(quint32 v)
+{
+    *this = qargb8565(quint32p(v));
+}
+
+qargb8565::qargb8565(quint32p v)
+{
+    data[0] = qAlpha(v);
+    const int r = qRed(v);
+    const int g = qGreen(v);
+    const int b = qBlue(v);
+    data[1] = ((g << 3) & 0xe0) | (b >> 3);
+    data[2] = (r & 0xf8) | (g >> 5);
+}
+
+qargb8565::qargb8565(const qargb8565 &v)
+{
+    data[0] = v.data[0];
+    data[1] = v.data[1];
+    data[2] = v.data[2];
+}
+
+qargb8565::qargb8565(const qrgb565 &v)
+{
+    data[0] = 0xff;
+    data[1] = v.data & 0xff;
+    data[2] = v.data >> 8;
+}
+
+qargb8565::operator quint32() const
+{
+    const quint16 rgb = (data[2] << 8) | data[1];
+    const int a = data[0];
+    const int r = (rgb & 0xf800);
+    const int g = (rgb & 0x07e0);
+    const int b = (rgb & 0x001f);
+    const int tr = qMin(a, (r >> 8) | (r >> 13));
+    const int tg = qMin(a, (g >> 3) | (g >> 9));
+    const int tb = qMin(a, (b << 3) | (b >> 2));
+    return qRgba(tr, tg, tb, data[0]);
+}
+
+qargb8565::operator quint16() const
+{
+    return (data[2] << 8) | data[1];
+}
+
+qargb8565 qargb8565::operator+(qargb8565 v) const
+{
+    qargb8565 t;
+    t.data[0] = data[0] + v.data[0];
+    const quint16 rgb =  ((data[2] + v.data[2]) << 8)
+                         + (data[1] + v.data[1]);
+    t.data[1] = rgb & 0xff;
+    t.data[2] = rgb >> 8;
+    return t;
+}
+
+qargb8565 qargb8565::byte_mul(quint8 a) const
+{
+    qargb8565 result;
+    result.data[0] = (data[0] * a) >> 5;
+
+    const quint16 x = (data[2] << 8) | data[1];
+    const quint16 t = ((((x & 0x07e0) >> 5) * a) & 0x07e0) |
+                      ((((x & 0xf81f) * a) >> 5) & 0xf81f);
+    result.data[1] = t & 0xff;
+    result.data[2] = t >> 8;
+    return result;
+}
+
+bool qargb8565::operator==(const qargb8565 &v) const
+{
+    return data[0] == v.data[0]
+        && data[1] == v.data[1]
+        && data[2] == v.data[2];
+}
+
+quint32 qargb8565::rawValue() const
+{
+    return (data[2] << 16) | (data[1] << 8) | data[0];
+}
+
+quint16 qargb8565::rawValue16() const
+{
+    return (data[2] << 8) | data[1];
+}
+
+qrgb565::qrgb565(quint32p v)
+{
+    *this = qrgb565(quint32(v));
+}
+
+qrgb565::qrgb565(quint32 v)
+{
+    const int r = qRed(v) << 8;
+    const int g = qGreen(v) << 3;
+    const int b = qBlue(v) >> 3;
+
+    data = (r & 0xf800) | (g & 0x07e0)| (b & 0x001f);
+}
+
+qrgb565::qrgb565(const qargb8565 &v)
+{
+    data = (v.data[2] << 8) | v.data[1];
+}
+
+qrgb565::operator quint32() const
+{
+    const int r = (data & 0xf800);
+    const int g = (data & 0x07e0);
+    const int b = (data & 0x001f);
+    const int tr = (r >> 8) | (r >> 13);
+    const int tg = (g >> 3) | (g >> 9);
+    const int tb = (b << 3) | (b >> 2);
+    return qRgb(tr, tg, tb);
+}
+
+qrgb565::operator quint16() const
+{
+    return data;
+}
+
+qrgb565 qrgb565::operator+(qrgb565 v) const
+{
+    qrgb565 t;
+    t.data = data + v.data;
+    return t;
+}
+
+qrgb565 qrgb565::byte_mul(quint8 a) const
+{
+    qrgb565 result;
+    result.data = ((((data & 0x07e0) >> 5) * a) & 0x07e0) |
+                  ((((data & 0xf81f) * a) >> 5) & 0xf81f);
+    return result;
+}
+
+bool qrgb565::operator==(const qrgb565 &v) const
+{
+    return data == v.data;
+}
+
+class qbgr565
+{
+public:
+    inline qbgr565(quint16 v)
+    {
+        data = ((v & 0x001f) << 11) |
+               (v & 0x07e0) |
+               ((v & 0xf800) >> 11);
+    }
+
+    inline bool operator==(const qbgr565 &v) const
+    {
+        return data == v.data;
+    }
+
+private:
+    quint16 data;
+} Q_PACKED;
+
+class qrgb555;
+
+class qargb8555
+{
+public:
+    Q_STATIC_INLINE_FUNCTION bool hasAlpha() { return true; }
+
+    qargb8555() {}
+    inline qargb8555(quint32 v);
+    inline explicit qargb8555(quint32p v);
+    inline qargb8555(const qargb8555 &v);
+    inline qargb8555(const qrgb555 &v);
+
+    inline operator quint32() const;
+
+    inline quint8 alpha() const { return data[0]; }
+    inline qargb8555 truncedAlpha() { data[0] &= 0xf8; return *this; }
+    Q_STATIC_INLINE_FUNCTION quint8 alpha(quint8 a) { return (a + 1) >> 3; }
+    Q_STATIC_INLINE_FUNCTION quint8 ialpha(quint8 a) { return 0x20 - alpha(a); }
+
+    inline qargb8555 operator+(qargb8555 v) const;
+    inline qargb8555 byte_mul(quint8 a) const;
+
+    inline bool operator==(const qargb8555 &v) const;
+
+    inline quint32 rawValue() const;
+
+private:
+    friend class qrgb555;
+    quint8 data[3];
+} Q_PACKED;
+
+class qrgb555
+{
+public:
+    Q_STATIC_INLINE_FUNCTION bool hasAlpha() { return false; }
+
+    inline qrgb555(int v = 0) : data(v) {}
+
+    inline explicit qrgb555(quint32p v) { *this = qrgb555(quint32(v)); }
+
+    inline explicit qrgb555(quint32 v)
+    {
+        const int r = qRed(v) << 7;
+        const int g = qGreen(v) << 2;
+        const int b = qBlue(v) >> 3;
+
+        data = (r & 0x7c00) | (g & 0x03e0) | (b & 0x001f);
+    }
+
+    inline explicit qrgb555(quint16 v)
+    {
+        data = ((v >> 1) & (0x7c00 | 0x03e0)) |
+               (v & 0x001f);
+    }
+
+    inline explicit qrgb555(const qargb8555 &v);
+
+    inline operator quint32() const
+    {
+        const int r = (data & 0x7c00);
+        const int g = (data & 0x03e0);
+        const int b = (data & 0x001f);
+        const int tr = (r >> 7) | (r >> 12);
+        const int tg = (g >> 2) | (g >> 7);
+        const int tb = (b << 3) | (b >> 2);
+
+        return qRgb(tr, tg, tb);
+    }
+
+    inline operator quint16() const
+    {
+        const int r = ((data & 0x7c00) << 1) & 0xf800;
+        const int g = (((data & 0x03e0) << 1) | ((data >> 4) & 0x0020)) & 0x07e0;
+        const int b = (data & 0x001f);
+
+        return r | g | b;
+    }
+
+    inline qrgb555 operator+(qrgb555 v) const;
+    inline qrgb555 byte_mul(quint8 a) const;
+
+    inline quint8 alpha() const { return 0xff; }
+    inline qrgb555 truncedAlpha() { return *this; }
+    Q_STATIC_INLINE_FUNCTION quint8 alpha(quint8 a) { return (a + 1) >> 3; }
+    Q_STATIC_INLINE_FUNCTION quint8 ialpha(quint8 a) { return 0x20 - alpha(a); }
+
+    inline bool operator==(const qrgb555 &v) const { return v.data == data; }
+    inline bool operator!=(const qrgb555 &v) const { return v.data != data; }
+
+    inline quint16 rawValue() const { return data; }
+
+private:
+    friend class qargb8555;
+    friend class qbgr555;
+    quint16 data;
+
+} Q_PACKED;
+
+qrgb555::qrgb555(const qargb8555 &v)
+{
+    data = (v.data[2] << 8) | v.data[1];
+}
+
+qrgb555 qrgb555::operator+(qrgb555 v) const
+{
+    qrgb555 t;
+    t.data = data + v.data;
+    return t;
+}
+
+qrgb555 qrgb555::byte_mul(quint8 a) const
+{
+    quint16 t = (((data & 0x3e0) * a) >> 5) & 0x03e0;
+    t |= (((data & 0x7c1f) * a) >> 5) & 0x7c1f;
+
+    qrgb555 result;
+    result.data = t;
+    return result;
+}
+
+class qbgr555
+{
+public:
+    inline qbgr555(quint32 v) { *this = qbgr555(qrgb555(v)); }
+
+    inline qbgr555(qrgb555 v)
+    {
+        data = ((v.data & 0x001f) << 10) |
+               (v.data & 0x03e0) |
+               ((v.data & 0x7c00) >> 10);
+    }
+
+    inline bool operator==(const qbgr555 &v) const
+    {
+        return data == v.data;
+    }
+
+private:
+    quint16 data;
+} Q_PACKED;
+
+qargb8555::qargb8555(quint32 v)
+{
+    v = quint32p(v);
+    data[0] = qAlpha(v);
+    const int r = qRed(v);
+    const int g = qGreen(v);
+    const int b = qBlue(v);
+    data[1] = ((g << 2) & 0xe0) | (b >> 3);
+    data[2] = ((r >> 1) & 0x7c) | (g >> 6);
+
+}
+
+qargb8555::qargb8555(quint32p v)
+{
+    data[0] = qAlpha(v);
+    const int r = qRed(v);
+    const int g = qGreen(v);
+    const int b = qBlue(v);
+    data[1] = ((g << 2) & 0xe0) | (b >> 3);
+    data[2] = ((r >> 1) & 0x7c) | (g >> 6);
+}
+
+qargb8555::qargb8555(const qargb8555 &v)
+{
+    data[0] = v.data[0];
+    data[1] = v.data[1];
+    data[2] = v.data[2];
+}
+
+qargb8555::qargb8555(const qrgb555 &v)
+{
+    data[0] = 0xff;
+    data[1] = v.data & 0xff;
+    data[2] = v.data >> 8;
+}
+
+qargb8555::operator quint32() const
+{
+    const quint16 rgb = (data[2] << 8) | data[1];
+    const int r = (rgb & 0x7c00);
+    const int g = (rgb & 0x03e0);
+    const int b = (rgb & 0x001f);
+    const int tr = (r >> 7) | (r >> 12);
+    const int tg = (g >> 2) | (g >> 7);
+    const int tb = (b << 3) | (b >> 2);
+
+    return qRgba(tr, tg, tb, data[0]);
+}
+
+bool qargb8555::operator==(const qargb8555 &v) const
+{
+    return data[0] == v.data[0]
+        && data[1] == v.data[1]
+        && data[2] == v.data[2];
+}
+
+quint32 qargb8555::rawValue() const
+{
+    return (data[2] << 16) | (data[1] << 8) | data[0];
+}
+
+qargb8555 qargb8555::operator+(qargb8555 v) const
+{
+    qargb8555 t;
+    t.data[0] = data[0] + v.data[0];
+    const quint16 rgb =  ((data[2] + v.data[2]) << 8)
+                         + (data[1] + v.data[1]);
+    t.data[1] = rgb & 0xff;
+    t.data[2] = rgb >> 8;
+    return t;
+}
+
+qargb8555 qargb8555::byte_mul(quint8 a) const
+{
+    qargb8555 result;
+    result.data[0] = (data[0] * a) >> 5;
+
+    const quint16 x = (data[2] << 8) | data[1];
+    quint16 t = (((x & 0x3e0) * a) >> 5) & 0x03e0;
+    t |= (((x & 0x7c1f) * a) >> 5) & 0x7c1f;
+    result.data[1] = t & 0xff;
+    result.data[2] = t >> 8;
+    return result;
+
+}
+
+class qrgb666;
+
+class qargb6666
+{
+public:
+    Q_STATIC_INLINE_FUNCTION bool hasAlpha() { return true; }
+
+    inline qargb6666() {}
+    inline qargb6666(quint32 v) { *this = qargb6666(quint32p(v)); }
+    inline explicit qargb6666(quint32p v);
+    inline qargb6666(const qargb6666 &v);
+    inline qargb6666(const qrgb666 &v);
+
+    inline operator quint32 () const;
+
+    inline quint8 alpha() const;
+    inline qargb6666 truncedAlpha() { return *this; }
+    Q_STATIC_INLINE_FUNCTION quint8 alpha(quint8 a) { return (a + 1) >> 2; }
+    Q_STATIC_INLINE_FUNCTION quint8 ialpha(quint8 a) { return (255 - a + 1) >> 2; }
+
+    inline qargb6666 byte_mul(quint8 a) const;
+    inline qargb6666 operator+(qargb6666 v) const;
+    inline bool operator==(const qargb6666 &v) const;
+
+    inline quint32 rawValue() const;
+
+private:
+    friend class qrgb666;
+    quint8 data[3];
+
+} Q_PACKED;
+
+class qrgb666
+{
+public:
+    Q_STATIC_INLINE_FUNCTION bool hasAlpha() { return false; }
+
+    inline qrgb666() {}
+    inline qrgb666(quint32 v);
+    inline qrgb666(const qargb6666 &v);
+
+    inline operator quint32 () const;
+
+    inline quint8 alpha() const { return 0xff; }
+    inline qrgb666 truncedAlpha() { return *this; }
+    Q_STATIC_INLINE_FUNCTION quint8 alpha(quint8 a) { return (a + 1) >> 2; }
+    Q_STATIC_INLINE_FUNCTION quint8 ialpha(quint8 a) { return (255 - a + 1) >> 2; }
+
+    inline qrgb666 operator+(qrgb666 v) const;
+    inline qrgb666 byte_mul(quint8 a) const;
+
+    inline bool operator==(const qrgb666 &v) const;
+    inline bool operator!=(const qrgb666 &v) const { return !(*this == v); }
+
+    inline quint32 rawValue() const
+    {
+        return (data[2] << 16) | (data[1] << 8) | data[0];
+    }
+
+private:
+    friend class qargb6666;
+
+    quint8 data[3];
+} Q_PACKED;
+
+qrgb666::qrgb666(quint32 v)
+{
+    const uchar b = qBlue(v);
+    const uchar g = qGreen(v);
+    const uchar r = qRed(v);
+    const uint p = (b >> 2) | ((g >> 2) << 6) | ((r >> 2) << 12);
+    data[0] = qBlue(p);
+    data[1] = qGreen(p);
+    data[2] = qRed(p);
+}
+
+qrgb666::qrgb666(const qargb6666 &v)
+{
+    data[0] = v.data[0];
+    data[1] = v.data[1];
+    data[2] = v.data[2] & 0x03;
+}
+
+qrgb666::operator quint32 () const
+{
+    const uchar r = (data[2] << 6) | ((data[1] & 0xf0) >> 2) | (data[2] & 0x3);
+    const uchar g = (data[1] << 4) | ((data[0] & 0xc0) >> 4) | ((data[1] & 0x0f) >> 2);
+    const uchar b = (data[0] << 2) | ((data[0] & 0x3f) >> 4);
+    return qRgb(r, g, b);
+}
+
+qrgb666 qrgb666::operator+(qrgb666 v) const
+{
+    const quint32 x1 = (data[2] << 16) | (data[1] << 8) | data[0];
+    const quint32 x2 = (v.data[2] << 16) | (v.data[1] << 8) | v.data[0];
+    const quint32 t = x1 + x2;
+    qrgb666 r;
+    r.data[0] = t & 0xff;
+    r.data[1] = (t >> 8) & 0xff;
+    r.data[2] = (t >> 16) & 0xff;
+    return r;
+}
+
+qrgb666 qrgb666::byte_mul(quint8 a) const
+{
+    const quint32 x = (data[2] << 16) | (data[1] << 8) | data[0];
+    const quint32 t = ((((x & 0x03f03f) * a) >> 6) & 0x03f03f) |
+                      ((((x & 0x000fc0) * a) >> 6) & 0x000fc0);
+
+    qrgb666 r;
+    r.data[0] = t & 0xff;
+    r.data[1] = (t >> 8) & 0xff;
+    r.data[2] = (t >> 16) & 0xff;
+    return r;
+}
+
+bool qrgb666::operator==(const qrgb666 &v) const
+{
+    return (data[0] == v.data[0] &&
+            data[1] == v.data[1] &&
+            data[2] == v.data[2]);
+}
+
+qargb6666::qargb6666(quint32p v)
+{
+    const quint8 b = qBlue(v) >> 2;
+    const quint8 g = qGreen(v) >> 2;
+    const quint8 r = qRed(v) >> 2;
+    const quint8 a = qAlpha(v) >> 2;
+    const uint p = (a << 18) | (r << 12) | (g << 6) | b;
+    data[0] = qBlue(p);
+    data[1] = qGreen(p);
+    data[2] = qRed(p);
+}
+
+qargb6666::qargb6666(const qargb6666 &v)
+{
+    data[0] = v.data[0];
+    data[1] = v.data[1];
+    data[2] = v.data[2];
+}
+
+qargb6666::qargb6666(const qrgb666 &v)
+{
+    data[0] = v.data[0];
+    data[1] = v.data[1];
+    data[2] = (v.data[2] | 0xfc);
+}
+
+qargb6666::operator quint32 () const
+{
+    const quint8 r = (data[2] << 6) | ((data[1] & 0xf0) >> 2) | (data[2] & 0x3);
+    const quint8 g = (data[1] << 4) | ((data[0] & 0xc0) >> 4) | ((data[1] & 0x0f) >> 2);
+    const quint8 b = (data[0] << 2) | ((data[0] & 0x3f) >> 4);
+    const quint8 a = (data[2] & 0xfc) | (data[2] >> 6);
+    return qRgba(r, g, b, a);
+}
+
+qargb6666 qargb6666::operator+(qargb6666 v) const
+{
+    const quint32 x1 = (data[2] << 16) | (data[1] << 8) | data[0];
+    const quint32 x2 = (v.data[2] << 16) | (v.data[1] << 8) | v.data[0];
+    const quint32 t = x1 + x2;
+    qargb6666 r;
+    r.data[0] = t & 0xff;
+    r.data[1] = (t >> 8) & 0xff;
+    r.data[2] = (t >> 16) & 0xff;
+    return r;
+}
+
+quint8 qargb6666::alpha() const
+{
+    return (data[2] & 0xfc) | (data[2] >> 6);
+}
+
+inline qargb6666 qargb6666::byte_mul(quint8 a) const
+{
+    const quint32 x = (data[2] << 16) | (data[1] << 8) | data[0];
+    const quint32 t = ((((x & 0x03f03f) * a) >> 6) & 0x03f03f) |
+                      ((((x & 0xfc0fc0) * a) >> 6) & 0xfc0fc0);
+
+    qargb6666 r;
+    r.data[0] = t & 0xff;
+    r.data[1] = (t >> 8) & 0xff;
+    r.data[2] = (t >> 16) & 0xff;
+    return r;
+}
+
+bool qargb6666::operator==(const qargb6666 &v) const
+{
+    return data[0] == v.data[0]
+        && data[1] == v.data[1]
+        && data[2] == v.data[2];
+}
+
+quint32 qargb6666::rawValue() const
+{
+    return (data[2] << 16) | (data[1] << 8) | data[0];
+}
+
+class qrgb888
+{
+public:
+    Q_STATIC_INLINE_FUNCTION bool hasAlpha() { return false; }
+
+    inline qrgb888() {}
+    inline qrgb888(quint32 v);
+
+    inline operator quint32() const;
+
+    inline quint8 alpha() const { return 0xff; }
+    inline qrgb888 truncedAlpha() { return *this; }
+    Q_STATIC_INLINE_FUNCTION quint8 alpha(quint8 a) { return a; }
+    Q_STATIC_INLINE_FUNCTION quint8 ialpha(quint8 a) { return 255 - a; }
+
+    inline qrgb888 byte_mul(quint8 a) const;
+    inline qrgb888 operator+(qrgb888 v) const;
+    inline bool operator==(qrgb888 v) const;
+
+    inline quint32 rawValue() const;
+
+private:
+    uchar data[3];
+
+} Q_PACKED;
+
+qrgb888::qrgb888(quint32 v)
+{
+    data[0] = qRed(v);
+    data[1] = qGreen(v);
+    data[2] = qBlue(v);
+}
+
+qrgb888::operator quint32() const
+{
+    return qRgb(data[0], data[1], data[2]);
+}
+
+qrgb888 qrgb888::operator+(qrgb888 v) const
+{
+    qrgb888 t = *this;
+    t.data[0] += v.data[0];
+    t.data[1] += v.data[1];
+    t.data[2] += v.data[2];
+    return t;
+}
+
+qrgb888 qrgb888::byte_mul(quint8 a) const
+{
+    quint32 x(*this);
+
+    quint32 t = (x & 0xff00ff) * a;
+    t = (t + ((t >> 8) & 0xff00ff) + 0x800080) >> 8;
+    t &= 0xff00ff;
+
+    x = ((x >> 8) & 0xff00ff) * a;
+    x = (x + ((x >> 8) & 0xff00ff) + 0x800080);
+    x &= 0xff00ff00;
+    x |= t;
+    return qrgb888(x);
+}
+
+bool qrgb888::operator==(qrgb888 v) const
+{
+    return (data[0] == v.data[0] &&
+            data[1] == v.data[1] &&
+            data[2] == v.data[2]);
+}
+
+quint32 qrgb888::rawValue() const
+{
+    return (data[2] << 16) | (data[1] << 8) | data[0];
+}
+
+template <>
+inline qrgb888 qt_colorConvert(quint32 color, qrgb888 dummy)
+{
+    Q_UNUSED(dummy);
+    return qrgb888(color);
+}
+
+template <>
+inline quint32 qt_colorConvert(qrgb888 color, quint32 dummy)
+{
+    Q_UNUSED(dummy);
+    return quint32(color);
+}
+
+#ifdef QT_QWS_DEPTH_8
+template <>
+inline quint8 qt_colorConvert(quint32 color, quint8 dummy)
+{
+    Q_UNUSED(dummy);
+
+    uchar r = ((qRed(color) & 0xf8) + 0x19) / 0x33;
+    uchar g = ((qGreen(color) &0xf8) + 0x19) / 0x33;
+    uchar b = ((qBlue(color) &0xf8) + 0x19) / 0x33;
+
+    return r*6*6 + g*6 + b;
+}
+
+template <>
+inline quint8 qt_colorConvert(quint16 color, quint8 dummy)
+{
+    Q_UNUSED(dummy);
+
+    uchar r = (color & 0xf800) >> (11-3);
+    uchar g = (color & 0x07c0) >> (6-3);
+    uchar b = (color & 0x001f) << 3;
+
+    uchar tr = (r + 0x19) / 0x33;
+    uchar tg = (g + 0x19) / 0x33;
+    uchar tb = (b + 0x19) / 0x33;
+
+    return tr*6*6 + tg*6 + tb;
+}
+
+#endif // QT_QWS_DEPTH_8
+
+// hw: endianess??
+class quint24
+{
+public:
+    inline quint24(quint32 v)
+    {
+        data[0] = qBlue(v);
+        data[1] = qGreen(v);
+        data[2] = qRed(v);
+    }
+
+    inline operator quint32 ()
+    {
+        return qRgb(data[2], data[1], data[0]);
+    }
+
+    inline bool operator==(const quint24 &v) const
+    {
+        return data[0] == v.data[0]
+            && data[1] == v.data[1]
+            && data[2] == v.data[2];
+    }
+
+private:
+    uchar data[3];
+} Q_PACKED;
+
+template <>
+inline quint24 qt_colorConvert(quint32 color, quint24 dummy)
+{
+    Q_UNUSED(dummy);
+    return quint24(color);
+}
+
+// hw: endianess??
+class quint18
+{
+public:
+    inline quint18(quint32 v)
+    {
+        uchar b = qBlue(v);
+        uchar g = qGreen(v);
+        uchar r = qRed(v);
+        uint p = (b >> 2) | ((g >> 2) << 6) | ((r >> 2) << 12);
+        data[0] = qBlue(p);
+        data[1] = qGreen(p);
+        data[2] = qRed(p);
+    }
+
+    inline operator quint32 ()
+    {
+        const uchar r = (data[2] << 6) | ((data[1] & 0xf0) >> 2) | (data[2] & 0x3);
+        const uchar g = (data[1] << 4) | ((data[0] & 0xc0) >> 4) | ((data[1] & 0x0f) >> 2);
+        const uchar b = (data[0] << 2) | ((data[0] & 0x3f) >> 4);
+        return qRgb(r, g, b);
+    }
+
+private:
+    uchar data[3];
+} Q_PACKED;
+
+template <>
+inline quint18 qt_colorConvert(quint32 color, quint18 dummy)
+{
+    Q_UNUSED(dummy);
+    return quint18(color);
+}
+
+class qrgb444;
+
+class qargb4444
+{
+public:
+    Q_STATIC_INLINE_FUNCTION bool hasAlpha() { return true; }
+
+    inline qargb4444() {}
+    inline qargb4444(quint32 v) { *this = qargb4444(quint32p(v)); }
+    inline explicit qargb4444(quint32p v);
+    inline qargb4444(const qrgb444 &v);
+
+    inline operator quint32() const;
+    inline operator quint8() const;
+
+    inline qargb4444 operator+(qargb4444 v) const;
+
+    inline quint8 alpha() const { return ((data & 0xf000) >> 8) | ((data & 0xf000) >> 12); }
+    inline qargb4444 truncedAlpha() { return *this; }
+    Q_STATIC_INLINE_FUNCTION quint8 alpha(quint8 a) { return (a + 1) >> 4; }
+    Q_STATIC_INLINE_FUNCTION quint8 ialpha(quint8 a) { return 0x10 - alpha(a); }
+    inline qargb4444 byte_mul(quint8 a) const;
+
+    inline bool operator==(const qargb4444 &v) const { return data == v.data; }
+
+    inline quint16 rawValue() const { return data; }
+
+private:
+    friend class qrgb444;
+    quint16 data;
+
+} Q_PACKED;
+
+class qrgb444
+{
+public:
+    Q_STATIC_INLINE_FUNCTION bool hasAlpha() { return false; }
+
+    inline qrgb444() {}
+    inline qrgb444(quint32 v);
+    inline explicit qrgb444(qargb4444 v);
+
+    inline operator quint32() const;
+    inline operator quint8() const;
+
+    inline qrgb444 operator+(qrgb444 v) const;
+    inline quint8 alpha() const { return 0xff; }
+    inline qrgb444 truncedAlpha() { return *this; }
+    Q_STATIC_INLINE_FUNCTION quint8 alpha(quint8 a) { return (a + 1) >> 4; }
+    Q_STATIC_INLINE_FUNCTION quint8 ialpha(quint8 a) { return 0x10 - alpha(a); }
+    inline qrgb444 byte_mul(quint8 a) const;
+
+    inline bool operator==(const qrgb444 &v) const { return data == v.data; }
+    inline bool operator!=(const qrgb444 &v) const { return data != v.data; }
+
+    inline quint16 rawValue() const { return data; }
+
+private:
+    friend class qargb4444;
+    quint16 data;
+
+} Q_PACKED;
+
+
+qargb4444::qargb4444(quint32p color)
+{
+    quint32 v = color;
+    v &= 0xf0f0f0f0;
+    const int a = qAlpha(v) << 8;
+    const int r = qRed(v) << 4;
+    const int g = qGreen(v);
+    const int b = qBlue(v) >> 4;
+
+    data = a | r | g | b;
+}
+
+qargb4444::qargb4444(const qrgb444 &v)
+{
+    data = v.data | 0xf000;
+}
+
+qargb4444::operator quint32() const
+{
+    const int a = (data & 0xf000);
+    const int r = (data & 0x0f00);
+    const int g = (data & 0x00f0);
+    const int b = (data & 0x000f);
+    const int ta = (a >> 8) | (a >> 12);
+    const int tr = (r >> 4) | (r >> 8);
+    const int tg = g | (g >> 4);
+    const int tb = (b << 4) | b;
+
+    return qRgba(tr, tg, tb, ta);
+}
+
+qargb4444::operator quint8() const
+{
+    // hw: optimize!
+    return qt_colorConvert<quint8, quint32>(operator quint32(), 0);
+}
+
+qargb4444 qargb4444::operator+(qargb4444 v) const
+{
+    qargb4444 t;
+    t.data = data + v.data;
+    return t;
+}
+
+qargb4444 qargb4444::byte_mul(quint8 a) const
+{
+    quint16 t = (((data & 0xf0f0) * a) >> 4) & 0xf0f0;
+    t |= (((data & 0x0f0f) * a) >> 4) & 0x0f0f;
+
+    qargb4444 result;
+    result.data = t;
+    return result;
+}
+
+qrgb444::qrgb444(quint32 v)
+{
+    v &= 0xf0f0f0f0;
+    const int r = qRed(v) << 4;
+    const int g = qGreen(v);
+    const int b = qBlue(v) >> 4;
+
+    data = r | g | b;
+}
+
+qrgb444::qrgb444(qargb4444 v)
+{
+    data = v.data & 0x0fff;
+}
+
+qrgb444::operator quint32() const
+{
+    const int r = (data & 0x0f00);
+    const int g = (data & 0x00f0);
+    const int b = (data & 0x000f);
+    const int tr = (r >> 4) | (r >> 8);
+    const int tg = g | (g >> 4);
+    const int tb = (b << 4) | b;
+
+    return qRgb(tr, tg, tb);
+}
+
+qrgb444::operator quint8() const
+{
+    // hw: optimize!
+    return qt_colorConvert<quint8, quint32>(operator quint32(), 0);
+}
+
+qrgb444 qrgb444::operator+(qrgb444 v) const
+{
+    qrgb444 t;
+    t.data = data + v.data;
+    return t;
+}
+
+qrgb444 qrgb444::byte_mul(quint8 a) const
+{
+    quint16 t = (((data & 0xf0f0) * a) >> 4) & 0xf0f0;
+    t |= (((data & 0x0f0f) * a) >> 4) & 0x0f0f;
+
+    qrgb444 result;
+    result.data = t;
+    return result;
+}
+
+#ifdef QT_QWS_DEPTH_GENERIC
+
+struct qrgb
+{
+public:
+    static int bpp;
+    static int len_red;
+    static int len_green;
+    static int len_blue;
+    static int len_alpha;
+    static int off_red;
+    static int off_green;
+    static int off_blue;
+    static int off_alpha;
+} Q_PACKED;
+
+template <typename SRC>
+Q_STATIC_TEMPLATE_FUNCTION inline quint32 qt_convertToRgb(SRC color);
+
+template <>
+inline quint32 qt_convertToRgb(quint32 color)
+{
+    const int r = qRed(color) >> (8 - qrgb::len_red);
+    const int g = qGreen(color) >> (8 - qrgb::len_green);
+    const int b = qBlue(color) >> (8 - qrgb::len_blue);
+    const int a = qAlpha(color) >> (8 - qrgb::len_alpha);
+    const quint32 v = (r << qrgb::off_red)
+                      | (g << qrgb::off_green)
+                      | (b << qrgb::off_blue)
+                      | (a << qrgb::off_alpha);
+
+    return v;
+}
+
+template <>
+inline quint32 qt_convertToRgb(quint16 color)
+{
+    return qt_convertToRgb(qt_colorConvert<quint32, quint16>(color, 0));
+}
+
+class qrgb_generic16
+{
+public:
+    inline qrgb_generic16(quint32 color)
+    {
+        const int r = qRed(color) >> (8 - qrgb::len_red);
+        const int g = qGreen(color) >> (8 - qrgb::len_green);
+        const int b = qBlue(color) >> (8 - qrgb::len_blue);
+        const int a = qAlpha(color) >> (8 - qrgb::len_alpha);
+        data = (r << qrgb::off_red)
+               | (g << qrgb::off_green)
+               | (b << qrgb::off_blue)
+               | (a << qrgb::off_alpha);
+    }
+
+    inline operator quint16 () { return data; }
+    inline quint32 operator<<(int shift) const { return data << shift; }
+
+private:
+    quint16 data;
+} Q_PACKED;
+
+template <>
+inline qrgb_generic16 qt_colorConvert(quint32 color, qrgb_generic16 dummy)
+{
+    Q_UNUSED(dummy);
+    return qrgb_generic16(color);
+}
+
+template <>
+inline qrgb_generic16 qt_colorConvert(quint16 color, qrgb_generic16 dummy)
+{
+    Q_UNUSED(dummy);
+    return qrgb_generic16(qt_colorConvert<quint32, quint16>(color, 0));
+}
+
+#endif // QT_QWS_DEPTH_GENERIC
+
+template <class T>
+void qt_memfill(T *dest, T value, int count);
+
+template<> inline void qt_memfill(quint32 *dest, quint32 color, int count)
+{
+    extern void (*qt_memfill32)(quint32 *dest, quint32 value, int count);
+    qt_memfill32(dest, color, count);
+}
+
+template<> inline void qt_memfill(quint16 *dest, quint16 color, int count)
+{
+    extern void (*qt_memfill16)(quint16 *dest, quint16 value, int count);
+    qt_memfill16(dest, color, count);
+}
+
+template<> inline void qt_memfill(quint8 *dest, quint8 color, int count)
+{
+    memset(dest, color, count);
+}
+
+template <class T>
+inline void qt_memfill(T *dest, T value, int count)
+{
+    if (!count)
+        return;
+
+    int n = (count + 7) / 8;
+    switch (count & 0x07)
+    {
+    case 0: do { *dest++ = value;
+    case 7:      *dest++ = value;
+    case 6:      *dest++ = value;
+    case 5:      *dest++ = value;
+    case 4:      *dest++ = value;
+    case 3:      *dest++ = value;
+    case 2:      *dest++ = value;
+    case 1:      *dest++ = value;
+    } while (--n > 0);
+    }
+}
+
+template <class T>
+inline void qt_rectfill(T *dest, T value,
+                        int x, int y, int width, int height, int stride)
+{
+    char *d = reinterpret_cast<char*>(dest + x) + y * stride;
+    if (uint(stride) == (width * sizeof(T))) {
+        qt_memfill(reinterpret_cast<T*>(d), value, width * height);
+    } else {
+        for (int j = 0; j < height; ++j) {
+            dest = reinterpret_cast<T*>(d);
+            qt_memfill(dest, value, width);
+            d += stride;
+        }
+    }
+}
+
+template <class DST, class SRC>
+inline void qt_memconvert(DST *dest, const SRC *src, int count)
+{
+    if (sizeof(DST) == 1) {
+        while (count) {
+            int n = 1;
+            const SRC color = *src++;
+            const DST dstColor = qt_colorConvert<DST, SRC>(color, 0);
+            while (--count && (*src == color || dstColor == qt_colorConvert<DST, SRC>(*src, 0))) {
+                ++n;
+                ++src;
+            }
+            qt_memfill(dest, dstColor, n);
+            dest += n;
+        }
+    } else {
+        /* Duff's device */
+        int n = (count + 7) / 8;
+        switch (count & 0x07)
+        {
+        case 0: do { *dest++ = qt_colorConvert<DST, SRC>(*src++, 0);
+            case 7:      *dest++ = qt_colorConvert<DST, SRC>(*src++, 0);
+            case 6:      *dest++ = qt_colorConvert<DST, SRC>(*src++, 0);
+            case 5:      *dest++ = qt_colorConvert<DST, SRC>(*src++, 0);
+            case 4:      *dest++ = qt_colorConvert<DST, SRC>(*src++, 0);
+            case 3:      *dest++ = qt_colorConvert<DST, SRC>(*src++, 0);
+            case 2:      *dest++ = qt_colorConvert<DST, SRC>(*src++, 0);
+            case 1:      *dest++ = qt_colorConvert<DST, SRC>(*src++, 0);
+            } while (--n > 0);
+        }
+    }
+}
+
+#define QT_TRIVIAL_MEMCONVERT_IMPL(T) \
+    template <> \
+    inline void qt_memconvert(T *dest, const T *src, int count) \
+    { \
+        memcpy(dest, src, count * sizeof(T)); \
+    }
+QT_TRIVIAL_MEMCONVERT_IMPL(quint32)
+QT_TRIVIAL_MEMCONVERT_IMPL(qrgb888)
+QT_TRIVIAL_MEMCONVERT_IMPL(qargb6666)
+QT_TRIVIAL_MEMCONVERT_IMPL(qrgb666)
+QT_TRIVIAL_MEMCONVERT_IMPL(quint16)
+QT_TRIVIAL_MEMCONVERT_IMPL(qrgb565)
+QT_TRIVIAL_MEMCONVERT_IMPL(qargb8565)
+QT_TRIVIAL_MEMCONVERT_IMPL(qargb8555)
+QT_TRIVIAL_MEMCONVERT_IMPL(qrgb555)
+QT_TRIVIAL_MEMCONVERT_IMPL(qargb4444)
+QT_TRIVIAL_MEMCONVERT_IMPL(qrgb444)
+#undef QT_TRIVIAL_MEMCONVERT_IMPL
+
+#if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
+template <>
+inline void qt_memconvert(qrgb666 *dest, const quint32 *src, int count)
+{
+    if (count < 3) {
+        switch (count) {
+        case 2: *dest++ = qrgb666(*src++);
+        case 1: *dest = qrgb666(*src);
+        }
+        return;
+    }
+
+    const int align = (quintptr(dest) & 3);
+    switch (align) {
+    case 1: *dest++ = qrgb666(*src++); --count;
+    case 2: *dest++ = qrgb666(*src++); --count;
+    case 3: *dest++ = qrgb666(*src++); --count;
+    }
+
+    quint32 *dest32 = reinterpret_cast<quint32*>(dest);
+    int sourceCount = count >> 2;
+    while (sourceCount--) {
+        dest32[0] = ((src[1] & 0x00000c00) << 20)
+                    | ((src[1] & 0x000000fc) << 22)
+                    | ((src[0] & 0x00fc0000) >> 6)
+                    | ((src[0] & 0x0000fc00) >> 4)
+                    |  ((src[0] & 0x000000fc) >> 2);
+        dest32[1] = ((src[2] & 0x003c0000) << 10)
+                    | ((src[2] & 0x0000fc00) << 12)
+                    | ((src[2] & 0x000000fc) << 14)
+                    | ((src[1] & 0x00fc0000) >> 14)
+                    | ((src[1] & 0x0000f000) >> 12);
+        dest32[2] = ((src[3] & 0x00fc0000) << 2)
+                    | ((src[3] & 0x0000fc00) << 4)
+                    | ((src[3] & 0x000000fc) << 6)
+                    | ((src[2] & 0x00c00000) >> 22);
+        dest32 += 3;
+        src += 4;
+    }
+
+    dest = reinterpret_cast<qrgb666*>(dest32);
+    switch (count & 3) {
+    case 3: *dest++ = qrgb666(*src++);
+    case 2: *dest++ = qrgb666(*src++);
+    case 1: *dest = qrgb666(*src);
+    }
+}
+#endif // Q_BYTE_ORDER
+
+template <class T>
+inline void qt_rectcopy(T *dest, const T *src,
+                        int x, int y, int width, int height,
+                        int dstStride, int srcStride)
+{
+    char *d = (char*)(dest + x) + y * dstStride;
+    const char *s = (char*)(src);
+    for (int i = 0; i < height; ++i) {
+        ::memcpy(d, s, width * sizeof(T));
+        d += dstStride;
+        s += srcStride;
+    }
+}
+
+template <class DST, class SRC>
+inline void qt_rectconvert(DST *dest, const SRC *src,
+                           int x, int y, int width, int height,
+                           int dstStride, int srcStride)
+{
+    char *d = (char*)(dest + x) + y * dstStride;
+    const char *s = (char*)(src);
+    for (int i = 0; i < height; ++i) {
+        qt_memconvert<DST,SRC>((DST*)d, (const SRC*)s, width);
+        d += dstStride;
+        s += srcStride;
+    }
+}
+
+#define QT_RECTCONVERT_TRIVIAL_IMPL(T)                                  \
+    template <>                                                         \
+    inline void qt_rectconvert(T *dest, const T *src,                   \
+                               int x, int y, int width, int height,     \
+                               int dstStride, int srcStride)            \
+    {                                                                   \
+        qt_rectcopy(dest, src, x, y, width, height, dstStride, srcStride); \
+    }
+QT_RECTCONVERT_TRIVIAL_IMPL(quint32)
+QT_RECTCONVERT_TRIVIAL_IMPL(qrgb888)
+QT_RECTCONVERT_TRIVIAL_IMPL(qargb6666)
+QT_RECTCONVERT_TRIVIAL_IMPL(qrgb666)
+QT_RECTCONVERT_TRIVIAL_IMPL(qrgb565)
+QT_RECTCONVERT_TRIVIAL_IMPL(qargb8565)
+QT_RECTCONVERT_TRIVIAL_IMPL(quint16)
+QT_RECTCONVERT_TRIVIAL_IMPL(qargb8555)
+QT_RECTCONVERT_TRIVIAL_IMPL(qrgb555)
+QT_RECTCONVERT_TRIVIAL_IMPL(qargb4444)
+QT_RECTCONVERT_TRIVIAL_IMPL(qrgb444)
+#undef QT_RECTCONVERT_TRIVIAL_IMPL
+
+#ifdef QT_QWS_DEPTH_GENERIC
+template <> void qt_rectconvert(qrgb *dest, const quint32 *src,
+                                int x, int y, int width, int height,
+                                int dstStride, int srcStride);
+
+template <> void qt_rectconvert(qrgb *dest, const quint16 *src,
+                                int x, int y, int width, int height,
+                                int dstStride, int srcStride);
+#endif // QT_QWS_DEPTH_GENERIC
+
+#define QT_MEMFILL_UINT(dest, length, color)            \
+    qt_memfill<quint32>(dest, color, length);
+
+#define QT_MEMFILL_USHORT(dest, length, color) \
+    qt_memfill<quint16>(dest, color, length);
+
+#define QT_MEMCPY_REV_UINT(dest, src, length) \
+do {                                          \
+    /* Duff's device */                       \
+    uint *_d = (uint*)(dest) + length;         \
+    const uint *_s = (uint*)(src) + length;    \
+    register int n = ((length) + 7) / 8;      \
+    switch ((length) & 0x07)                  \
+    {                                         \
+    case 0: do { *--_d = *--_s;                 \
+    case 7:      *--_d = *--_s;                 \
+    case 6:      *--_d = *--_s;                 \
+    case 5:      *--_d = *--_s;                 \
+    case 4:      *--_d = *--_s;                 \
+    case 3:      *--_d = *--_s;                 \
+    case 2:      *--_d = *--_s;                 \
+    case 1:      *--_d = *--_s;                 \
+    } while (--n > 0);                        \
+    }                                         \
+} while (0)
+
+#define QT_MEMCPY_USHORT(dest, src, length) \
+do {                                          \
+    /* Duff's device */                       \
+    ushort *_d = (ushort*)(dest);         \
+    const ushort *_s = (ushort*)(src);    \
+    register int n = ((length) + 7) / 8;      \
+    switch ((length) & 0x07)                  \
+    {                                         \
+    case 0: do { *_d++ = *_s++;                 \
+    case 7:      *_d++ = *_s++;                 \
+    case 6:      *_d++ = *_s++;                 \
+    case 5:      *_d++ = *_s++;                 \
+    case 4:      *_d++ = *_s++;                 \
+    case 3:      *_d++ = *_s++;                 \
+    case 2:      *_d++ = *_s++;                 \
+    case 1:      *_d++ = *_s++;                 \
+    } while (--n > 0);                        \
+    }                                         \
+} while (0)
+
+#if defined(Q_CC_RVCT)
+#  pragma push
+#  pragma arm
+#endif
+Q_STATIC_INLINE_FUNCTION int qt_div_255(int x) { return (x + (x>>8) + 0x80) >> 8; }
+#if defined(Q_CC_RVCT)
+#  pragma pop
+#endif
+
+inline ushort qConvertRgb32To16(uint c)
+{
+   return (((c) >> 3) & 0x001f)
+       | (((c) >> 5) & 0x07e0)
+       | (((c) >> 8) & 0xf800);
+}
+
+#if defined(Q_WS_QWS) || (QT_VERSION >= 0x040400)
+inline quint32 qConvertRgb32To16x2(quint64 c)
+{
+    c = (((c) >> 3) & Q_UINT64_C(0x001f0000001f))
+        | (((c) >> 5) & Q_UINT64_C(0x07e0000007e0))
+        | (((c) >> 8) & Q_UINT64_C(0xf8000000f800));
+    return c | (c >> 16);
+}
+#endif
+
+inline QRgb qConvertRgb16To32(uint c)
+{
+    return 0xff000000
+        | ((((c) << 3) & 0xf8) | (((c) >> 2) & 0x7))
+        | ((((c) << 5) & 0xfc00) | (((c) >> 1) & 0x300))
+        | ((((c) << 8) & 0xf80000) | (((c) << 3) & 0x70000));
+}
+
+inline int qRed565(quint16 rgb) {
+    const int r = (rgb & 0xf800);
+    return (r >> 8) | (r >> 13);
+}
+
+inline int qGreen565(quint16 rgb) {
+    const int g = (rgb & 0x07e0);
+    return (g >> 3) | (g >> 9);
+}
+
+inline int qBlue565(quint16 rgb) {
+    const int b = (rgb & 0x001f);
+    return (b << 3) | (b >> 2);
+}
+
+const uint qt_bayer_matrix[16][16] = {
+    { 0x1, 0xc0, 0x30, 0xf0, 0xc, 0xcc, 0x3c, 0xfc,
+      0x3, 0xc3, 0x33, 0xf3, 0xf, 0xcf, 0x3f, 0xff},
+    { 0x80, 0x40, 0xb0, 0x70, 0x8c, 0x4c, 0xbc, 0x7c,
+      0x83, 0x43, 0xb3, 0x73, 0x8f, 0x4f, 0xbf, 0x7f},
+    { 0x20, 0xe0, 0x10, 0xd0, 0x2c, 0xec, 0x1c, 0xdc,
+      0x23, 0xe3, 0x13, 0xd3, 0x2f, 0xef, 0x1f, 0xdf},
+    { 0xa0, 0x60, 0x90, 0x50, 0xac, 0x6c, 0x9c, 0x5c,
+      0xa3, 0x63, 0x93, 0x53, 0xaf, 0x6f, 0x9f, 0x5f},
+    { 0x8, 0xc8, 0x38, 0xf8, 0x4, 0xc4, 0x34, 0xf4,
+      0xb, 0xcb, 0x3b, 0xfb, 0x7, 0xc7, 0x37, 0xf7},
+    { 0x88, 0x48, 0xb8, 0x78, 0x84, 0x44, 0xb4, 0x74,
+      0x8b, 0x4b, 0xbb, 0x7b, 0x87, 0x47, 0xb7, 0x77},
+    { 0x28, 0xe8, 0x18, 0xd8, 0x24, 0xe4, 0x14, 0xd4,
+      0x2b, 0xeb, 0x1b, 0xdb, 0x27, 0xe7, 0x17, 0xd7},
+    { 0xa8, 0x68, 0x98, 0x58, 0xa4, 0x64, 0x94, 0x54,
+      0xab, 0x6b, 0x9b, 0x5b, 0xa7, 0x67, 0x97, 0x57},
+    { 0x2, 0xc2, 0x32, 0xf2, 0xe, 0xce, 0x3e, 0xfe,
+      0x1, 0xc1, 0x31, 0xf1, 0xd, 0xcd, 0x3d, 0xfd},
+    { 0x82, 0x42, 0xb2, 0x72, 0x8e, 0x4e, 0xbe, 0x7e,
+      0x81, 0x41, 0xb1, 0x71, 0x8d, 0x4d, 0xbd, 0x7d},
+    { 0x22, 0xe2, 0x12, 0xd2, 0x2e, 0xee, 0x1e, 0xde,
+      0x21, 0xe1, 0x11, 0xd1, 0x2d, 0xed, 0x1d, 0xdd},
+    { 0xa2, 0x62, 0x92, 0x52, 0xae, 0x6e, 0x9e, 0x5e,
+      0xa1, 0x61, 0x91, 0x51, 0xad, 0x6d, 0x9d, 0x5d},
+    { 0xa, 0xca, 0x3a, 0xfa, 0x6, 0xc6, 0x36, 0xf6,
+      0x9, 0xc9, 0x39, 0xf9, 0x5, 0xc5, 0x35, 0xf5},
+    { 0x8a, 0x4a, 0xba, 0x7a, 0x86, 0x46, 0xb6, 0x76,
+      0x89, 0x49, 0xb9, 0x79, 0x85, 0x45, 0xb5, 0x75},
+    { 0x2a, 0xea, 0x1a, 0xda, 0x26, 0xe6, 0x16, 0xd6,
+      0x29, 0xe9, 0x19, 0xd9, 0x25, 0xe5, 0x15, 0xd5},
+    { 0xaa, 0x6a, 0x9a, 0x5a, 0xa6, 0x66, 0x96, 0x56,
+      0xa9, 0x69, 0x99, 0x59, 0xa5, 0x65, 0x95, 0x55}
+};
+
+#define ARGB_COMBINE_ALPHA(argb, alpha) \
+    ((((argb >> 24) * alpha) >> 8) << 24) | (argb & 0x00ffffff)
+
+
+#if QT_POINTER_SIZE == 8 // 64-bit versions
+#define AMIX(mask) (qMin(((qint64(s)&mask) + (qint64(d)&mask)), qint64(mask)))
+#define MIX(mask) (qMin(((qint64(s)&mask) + (qint64(d)&mask)), qint64(mask)))
+#else // 32 bits
+// The mask for alpha can overflow over 32 bits
+#define AMIX(mask) quint32(qMin(((qint64(s)&mask) + (qint64(d)&mask)), qint64(mask)))
+#define MIX(mask) (qMin(((quint32(s)&mask) + (quint32(d)&mask)), quint32(mask)))
+#endif
+
+inline int comp_func_Plus_one_pixel_const_alpha(uint d, const uint s, const uint const_alpha, const uint one_minus_const_alpha)
+{
+    const int result = (AMIX(AMASK) | MIX(RMASK) | MIX(GMASK) | MIX(BMASK));
+    return INTERPOLATE_PIXEL_255(result, const_alpha, d, one_minus_const_alpha);
+}
+
+inline int comp_func_Plus_one_pixel(uint d, const uint s)
+{
+    const int result = (AMIX(AMASK) | MIX(RMASK) | MIX(GMASK) | MIX(BMASK));
+    return result;
+}
+
+#undef MIX
+#undef AMIX
+
+// prototypes of all the composition functions
+void QT_FASTCALL comp_func_SourceOver(uint *dest, const uint *src, int length, uint const_alpha);
+void QT_FASTCALL comp_func_DestinationOver(uint *dest, const uint *src, int length, uint const_alpha);
+void QT_FASTCALL comp_func_Clear(uint *dest, const uint *, int length, uint const_alpha);
+void QT_FASTCALL comp_func_Source(uint *dest, const uint *src, int length, uint const_alpha);
+void QT_FASTCALL comp_func_Destination(uint *, const uint *, int, uint);
+void QT_FASTCALL comp_func_SourceIn(uint *dest, const uint *src, int length, uint const_alpha);
+void QT_FASTCALL comp_func_DestinationIn(uint *dest, const uint *src, int length, uint const_alpha);
+void QT_FASTCALL comp_func_SourceOut(uint *dest, const uint *src, int length, uint const_alpha);
+void QT_FASTCALL comp_func_DestinationOut(uint *dest, const uint *src, int length, uint const_alpha);
+void QT_FASTCALL comp_func_SourceAtop(uint *dest, const uint *src, int length, uint const_alpha);
+void QT_FASTCALL comp_func_DestinationAtop(uint *dest, const uint *src, int length, uint const_alpha);
+void QT_FASTCALL comp_func_XOR(uint *dest, const uint *src, int length, uint const_alpha);
+void QT_FASTCALL comp_func_Plus(uint *dest, const uint *src, int length, uint const_alpha);
+void QT_FASTCALL comp_func_Multiply(uint *dest, const uint *src, int length, uint const_alpha);
+void QT_FASTCALL comp_func_Screen(uint *dest, const uint *src, int length, uint const_alpha);
+void QT_FASTCALL comp_func_Overlay(uint *dest, const uint *src, int length, uint const_alpha);
+void QT_FASTCALL comp_func_Darken(uint *dest, const uint *src, int length, uint const_alpha);
+void QT_FASTCALL comp_func_Lighten(uint *dest, const uint *src, int length, uint const_alpha);
+void QT_FASTCALL comp_func_ColorDodge(uint *dest, const uint *src, int length, uint const_alpha);
+void QT_FASTCALL comp_func_ColorBurn(uint *dest, const uint *src, int length, uint const_alpha);
+void QT_FASTCALL comp_func_HardLight(uint *dest, const uint *src, int length, uint const_alpha);
+void QT_FASTCALL comp_func_SoftLight(uint *dest, const uint *src, int length, uint const_alpha);
+void QT_FASTCALL comp_func_Difference(uint *dest, const uint *src, int length, uint const_alpha);
+void QT_FASTCALL comp_func_Exclusion(uint *dest, const uint *src, int length, uint const_alpha);
+void QT_FASTCALL rasterop_SourceOrDestination(uint *dest, const uint *src, int length, uint const_alpha);
+void QT_FASTCALL rasterop_SourceAndDestination(uint *dest, const uint *src, int length, uint const_alpha);
+void QT_FASTCALL rasterop_SourceXorDestination(uint *dest, const uint *src, int length, uint const_alpha);
+void QT_FASTCALL rasterop_NotSourceAndNotDestination(uint *dest, const uint *src, int length, uint const_alpha);
+void QT_FASTCALL rasterop_NotSourceOrNotDestination(uint *dest, const uint *src, int length, uint const_alpha);
+void QT_FASTCALL rasterop_NotSourceXorDestination(uint *dest, const uint *src, int length, uint const_alpha);
+void QT_FASTCALL rasterop_NotSource(uint *dest, const uint *src, int length, uint const_alpha);
+void QT_FASTCALL rasterop_NotSourceAndDestination(uint *dest, const uint *src, int length, uint const_alpha);
+void QT_FASTCALL rasterop_SourceAndNotDestination(uint *dest, const uint *src, int length, uint const_alpha);
+
+// prototypes of all the solid composition functions
+void QT_FASTCALL comp_func_solid_SourceOver(uint *dest, int length, uint color, uint const_alpha);
+void QT_FASTCALL comp_func_solid_DestinationOver(uint *dest, int length, uint color, uint const_alpha);
+void QT_FASTCALL comp_func_solid_Clear(uint *dest, int length, uint color, uint const_alpha);
+void QT_FASTCALL comp_func_solid_Source(uint *dest, int length, uint color, uint const_alpha);
+void QT_FASTCALL comp_func_solid_Destination(uint *dest, int length, uint color, uint const_alpha);
+void QT_FASTCALL comp_func_solid_SourceIn(uint *dest, int length, uint color, uint const_alpha);
+void QT_FASTCALL comp_func_solid_DestinationIn(uint *dest, int length, uint color, uint const_alpha);
+void QT_FASTCALL comp_func_solid_SourceOut(uint *dest, int length, uint color, uint const_alpha);
+void QT_FASTCALL comp_func_solid_DestinationOut(uint *dest, int length, uint color, uint const_alpha);
+void QT_FASTCALL comp_func_solid_SourceAtop(uint *dest, int length, uint color, uint const_alpha);
+void QT_FASTCALL comp_func_solid_DestinationAtop(uint *dest, int length, uint color, uint const_alpha);
+void QT_FASTCALL comp_func_solid_XOR(uint *dest, int length, uint color, uint const_alpha);
+void QT_FASTCALL comp_func_solid_Plus(uint *dest, int length, uint color, uint const_alpha);
+void QT_FASTCALL comp_func_solid_Multiply(uint *dest, int length, uint color, uint const_alpha);
+void QT_FASTCALL comp_func_solid_Screen(uint *dest, int length, uint color, uint const_alpha);
+void QT_FASTCALL comp_func_solid_Overlay(uint *dest, int length, uint color, uint const_alpha);
+void QT_FASTCALL comp_func_solid_Darken(uint *dest, int length, uint color, uint const_alpha);
+void QT_FASTCALL comp_func_solid_Lighten(uint *dest, int length, uint color, uint const_alpha);
+void QT_FASTCALL comp_func_solid_ColorDodge(uint *dest, int length, uint color, uint const_alpha);
+void QT_FASTCALL comp_func_solid_ColorBurn(uint *dest, int length, uint color, uint const_alpha);
+void QT_FASTCALL comp_func_solid_HardLight(uint *dest, int length, uint color, uint const_alpha);
+void QT_FASTCALL comp_func_solid_SoftLight(uint *dest, int length, uint color, uint const_alpha);
+void QT_FASTCALL comp_func_solid_Difference(uint *dest, int length, uint color, uint const_alpha);
+void QT_FASTCALL comp_func_solid_Exclusion(uint *dest, int length, uint color, uint const_alpha);
+void QT_FASTCALL rasterop_solid_SourceOrDestination(uint *dest, int length, uint color, uint const_alpha);
+void QT_FASTCALL rasterop_solid_SourceAndDestination(uint *dest, int length, uint color, uint const_alpha);
+void QT_FASTCALL rasterop_solid_SourceXorDestination(uint *dest, int length, uint color, uint const_alpha);
+void QT_FASTCALL rasterop_solid_NotSourceAndNotDestination(uint *dest, int length, uint color, uint const_alpha);
+void QT_FASTCALL rasterop_solid_NotSourceOrNotDestination(uint *dest, int length, uint color, uint const_alpha);
+void QT_FASTCALL rasterop_solid_NotSourceXorDestination(uint *dest, int length, uint color, uint const_alpha);
+void QT_FASTCALL rasterop_solid_NotSource(uint *dest, int length, uint color, uint const_alpha);
+void QT_FASTCALL rasterop_solid_NotSourceAndDestination(uint *dest, int length, uint color, uint const_alpha);
+void QT_FASTCALL rasterop_solid_SourceAndNotDestination(uint *dest, int length, uint color, uint const_alpha);
+
+QT_END_NAMESPACE
+
+#endif // QDRAWHELPER_P_H
diff --git a/src/gui/painting/qdrawhelper_sse.cpp b/src/gui/painting/qdrawhelper_sse.cpp
new file mode 100644
index 0000000000..7f7aee650a
--- /dev/null
+++ b/src/gui/painting/qdrawhelper_sse.cpp
@@ -0,0 +1,168 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <private/qdrawhelper_p.h>
+
+#ifdef QT_HAVE_SSE
+
+#include <private/qdrawhelper_sse_p.h>
+
+QT_BEGIN_NAMESPACE
+
+CompositionFunctionSolid qt_functionForModeSolid_SSE[numCompositionFunctions] = {
+    comp_func_solid_SourceOver<QSSEIntrinsics>,
+    comp_func_solid_DestinationOver<QSSEIntrinsics>,
+    comp_func_solid_Clear<QSSEIntrinsics>,
+    comp_func_solid_Source<QSSEIntrinsics>,
+    0,
+    comp_func_solid_SourceIn<QSSEIntrinsics>,
+    comp_func_solid_DestinationIn<QSSEIntrinsics>,
+    comp_func_solid_SourceOut<QSSEIntrinsics>,
+    comp_func_solid_DestinationOut<QSSEIntrinsics>,
+    comp_func_solid_SourceAtop<QSSEIntrinsics>,
+    comp_func_solid_DestinationAtop<QSSEIntrinsics>,
+    comp_func_solid_XOR<QSSEIntrinsics>,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // svg 1.2 modes
+    rasterop_solid_SourceOrDestination<QMMXIntrinsics>,
+    rasterop_solid_SourceAndDestination<QMMXIntrinsics>,
+    rasterop_solid_SourceXorDestination<QMMXIntrinsics>,
+    rasterop_solid_NotSourceAndNotDestination<QMMXIntrinsics>,
+    rasterop_solid_NotSourceOrNotDestination<QMMXIntrinsics>,
+    rasterop_solid_NotSourceXorDestination<QMMXIntrinsics>,
+    rasterop_solid_NotSource<QMMXIntrinsics>,
+    rasterop_solid_NotSourceAndDestination<QMMXIntrinsics>,
+    rasterop_solid_SourceAndNotDestination<QMMXIntrinsics>
+};
+
+CompositionFunction qt_functionForMode_SSE[numCompositionFunctions] = {
+    comp_func_SourceOver<QSSEIntrinsics>,
+    comp_func_DestinationOver<QSSEIntrinsics>,
+    comp_func_Clear<QSSEIntrinsics>,
+    comp_func_Source<QSSEIntrinsics>,
+    comp_func_Destination,
+    comp_func_SourceIn<QSSEIntrinsics>,
+    comp_func_DestinationIn<QSSEIntrinsics>,
+    comp_func_SourceOut<QSSEIntrinsics>,
+    comp_func_DestinationOut<QSSEIntrinsics>,
+    comp_func_SourceAtop<QSSEIntrinsics>,
+    comp_func_DestinationAtop<QSSEIntrinsics>,
+    comp_func_XOR<QSSEIntrinsics>,
+    comp_func_Plus,
+    comp_func_Multiply,
+    comp_func_Screen,
+    comp_func_Overlay,
+    comp_func_Darken,
+    comp_func_Lighten,
+    comp_func_ColorDodge,
+    comp_func_ColorBurn,
+    comp_func_HardLight,
+    comp_func_SoftLight,
+    comp_func_Difference,
+    comp_func_Exclusion,
+    rasterop_SourceOrDestination,
+    rasterop_SourceAndDestination,
+    rasterop_SourceXorDestination,
+    rasterop_NotSourceAndNotDestination,
+    rasterop_NotSourceOrNotDestination,
+    rasterop_NotSourceXorDestination,
+    rasterop_NotSource,
+    rasterop_NotSourceAndDestination,
+    rasterop_SourceAndNotDestination
+};
+
+void qt_blend_color_argb_sse(int count, const QSpan *spans, void *userData)
+{
+    qt_blend_color_argb_x86<QSSEIntrinsics>(count, spans, userData,
+                                            (CompositionFunctionSolid*)qt_functionForModeSolid_SSE);
+}
+
+void qt_memfill32_sse(quint32 *dest, quint32 value, int count)
+{
+    return qt_memfill32_sse_template<QSSEIntrinsics>(dest, value, count);
+}
+
+void qt_bitmapblit16_sse(QRasterBuffer *rasterBuffer, int x, int y,
+                         quint32 color,
+                         const uchar *src,
+                         int width, int height, int stride)
+{
+    return qt_bitmapblit16_sse_template<QSSEIntrinsics>(rasterBuffer, x,y,
+                                                        color, src, width,
+                                                        height, stride);
+}
+
+void qt_blend_argb32_on_argb32_sse(uchar *destPixels, int dbpl,
+                                   const uchar *srcPixels, int sbpl,
+                                   int w, int h,
+                                   int const_alpha)
+{
+    const uint *src = (const uint *) srcPixels;
+    uint *dst = (uint *) destPixels;
+
+    uint ca = const_alpha - 1;
+
+    for (int y=0; y<h; ++y) {
+        comp_func_SourceOver<QSSEIntrinsics>(dst, src, w, ca);
+        dst = (quint32 *)(((uchar *) dst) + dbpl);
+        src = (const quint32 *)(((const uchar *) src) + sbpl);
+    }
+}
+
+void qt_blend_rgb32_on_rgb32_sse(uchar *destPixels, int dbpl,
+                                 const uchar *srcPixels, int sbpl,
+                                 int w, int h,
+                                 int const_alpha)
+{
+    const uint *src = (const uint *) srcPixels;
+    uint *dst = (uint *) destPixels;
+
+    uint ca = const_alpha - 1;
+
+    for (int y=0; y<h; ++y) {
+        comp_func_Source<QSSEIntrinsics>(dst, src, w, ca);
+        dst = (quint32 *)(((uchar *) dst) + dbpl);
+        src = (const quint32 *)(((const uchar *) src) + sbpl);
+    }
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_HAVE_SSE
diff --git a/src/gui/painting/qdrawhelper_sse2.cpp b/src/gui/painting/qdrawhelper_sse2.cpp
new file mode 100644
index 0000000000..aad6bc9254
--- /dev/null
+++ b/src/gui/painting/qdrawhelper_sse2.cpp
@@ -0,0 +1,496 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <private/qdrawhelper_x86_p.h>
+
+#ifdef QT_HAVE_SSE2
+
+#include <private/qdrawingprimitive_sse2_p.h>
+#include <private/qpaintengine_raster_p.h>
+
+QT_BEGIN_NAMESPACE
+
+void qt_blend_argb32_on_argb32_sse2(uchar *destPixels, int dbpl,
+                                    const uchar *srcPixels, int sbpl,
+                                    int w, int h,
+                                    int const_alpha)
+{
+    const quint32 *src = (const quint32 *) srcPixels;
+    quint32 *dst = (quint32 *) destPixels;
+    if (const_alpha == 256) {
+        const __m128i alphaMask = _mm_set1_epi32(0xff000000);
+        const __m128i nullVector = _mm_set1_epi32(0);
+        const __m128i half = _mm_set1_epi16(0x80);
+        const __m128i one = _mm_set1_epi16(0xff);
+        const __m128i colorMask = _mm_set1_epi32(0x00ff00ff);
+        for (int y = 0; y < h; ++y) {
+            BLEND_SOURCE_OVER_ARGB32_SSE2(dst, src, w, nullVector, half, one, colorMask, alphaMask);
+            dst = (quint32 *)(((uchar *) dst) + dbpl);
+            src = (const quint32 *)(((const uchar *) src) + sbpl);
+        }
+    } else if (const_alpha != 0) {
+        // dest = (s + d * sia) * ca + d * cia
+        //      = s * ca + d * (sia * ca + cia)
+        //      = s * ca + d * (1 - sa*ca)
+        const_alpha = (const_alpha * 255) >> 8;
+        const __m128i nullVector = _mm_set1_epi32(0);
+        const __m128i half = _mm_set1_epi16(0x80);
+        const __m128i one = _mm_set1_epi16(0xff);
+        const __m128i colorMask = _mm_set1_epi32(0x00ff00ff);
+        const __m128i constAlphaVector = _mm_set1_epi16(const_alpha);
+        for (int y = 0; y < h; ++y) {
+            BLEND_SOURCE_OVER_ARGB32_WITH_CONST_ALPHA_SSE2(dst, src, w, nullVector, half, one, colorMask, constAlphaVector)
+            dst = (quint32 *)(((uchar *) dst) + dbpl);
+            src = (const quint32 *)(((const uchar *) src) + sbpl);
+        }
+    }
+}
+
+// qblendfunctions.cpp
+void qt_blend_rgb32_on_rgb32(uchar *destPixels, int dbpl,
+                             const uchar *srcPixels, int sbpl,
+                             int w, int h,
+                             int const_alpha);
+
+void qt_blend_rgb32_on_rgb32_sse2(uchar *destPixels, int dbpl,
+                                 const uchar *srcPixels, int sbpl,
+                                 int w, int h,
+                                 int const_alpha)
+{
+    const quint32 *src = (const quint32 *) srcPixels;
+    quint32 *dst = (quint32 *) destPixels;
+    if (const_alpha != 256) {
+        if (const_alpha != 0) {
+            const __m128i nullVector = _mm_set1_epi32(0);
+            const __m128i half = _mm_set1_epi16(0x80);
+            const __m128i colorMask = _mm_set1_epi32(0x00ff00ff);
+
+            const_alpha = (const_alpha * 255) >> 8;
+            int one_minus_const_alpha = 255 - const_alpha;
+            const __m128i constAlphaVector = _mm_set1_epi16(const_alpha);
+            const __m128i oneMinusConstAlpha =  _mm_set1_epi16(one_minus_const_alpha);
+            for (int y = 0; y < h; ++y) {
+                int x = 0;
+
+                // 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);
+                }
+
+                for (; x < w-3; x += 4) {
+                    __m128i srcVector = _mm_loadu_si128((__m128i *)&src[x]);
+                    if (_mm_movemask_epi8(_mm_cmpeq_epi32(srcVector, nullVector)) != 0xffff) {
+                        const __m128i dstVector = _mm_load_si128((__m128i *)&dst[x]);
+                        __m128i result;
+                        INTERPOLATE_PIXEL_255_SSE2(result, srcVector, dstVector, constAlphaVector, oneMinusConstAlpha, colorMask, half);
+                        _mm_store_si128((__m128i *)&dst[x], result);
+                    }
+                }
+                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);
+                src = (const quint32 *)(((const uchar *) src) + sbpl);
+            }
+        }
+    } else {
+        qt_blend_rgb32_on_rgb32(destPixels, dbpl, srcPixels, sbpl, w, h, const_alpha);
+    }
+}
+
+void QT_FASTCALL comp_func_SourceOver_sse2(uint *destPixels, const uint *srcPixels, int length, uint const_alpha)
+{
+    Q_ASSERT(const_alpha < 256);
+
+    const quint32 *src = (const quint32 *) srcPixels;
+    quint32 *dst = (quint32 *) destPixels;
+
+    const __m128i nullVector = _mm_set1_epi32(0);
+    const __m128i half = _mm_set1_epi16(0x80);
+    const __m128i one = _mm_set1_epi16(0xff);
+    const __m128i colorMask = _mm_set1_epi32(0x00ff00ff);
+    if (const_alpha == 255) {
+        const __m128i alphaMask = _mm_set1_epi32(0xff000000);
+        BLEND_SOURCE_OVER_ARGB32_SSE2(dst, src, length, nullVector, half, one, colorMask, alphaMask);
+    } else {
+        const __m128i constAlphaVector = _mm_set1_epi16(const_alpha);
+        BLEND_SOURCE_OVER_ARGB32_WITH_CONST_ALPHA_SSE2(dst, src, length, nullVector, half, one, colorMask, constAlphaVector);
+    }
+}
+
+void QT_FASTCALL comp_func_Plus_sse2(uint *dst, const uint *src, int length, uint const_alpha)
+{
+    int x = 0;
+
+    if (const_alpha == 255) {
+        // 1) Prologue: align destination on 16 bytes
+        ALIGNMENT_PROLOGUE_16BYTES(dst, x, length)
+            dst[x] = comp_func_Plus_one_pixel(dst[x], src[x]);
+
+        // 2) composition with SSE2
+        for (; x < length - 3; x += 4) {
+            const __m128i srcVector = _mm_loadu_si128((__m128i *)&src[x]);
+            const __m128i dstVector = _mm_load_si128((__m128i *)&dst[x]);
+
+            const __m128i result = _mm_adds_epu8(srcVector, dstVector);
+            _mm_store_si128((__m128i *)&dst[x], result);
+        }
+
+        // 3) Epilogue:
+        for (; x < length; ++x)
+            dst[x] = comp_func_Plus_one_pixel(dst[x], src[x]);
+    } else {
+        const int one_minus_const_alpha = 255 - const_alpha;
+        const __m128i constAlphaVector = _mm_set1_epi16(const_alpha);
+        const __m128i oneMinusConstAlpha =  _mm_set1_epi16(one_minus_const_alpha);
+
+        // 1) Prologue: align destination on 16 bytes
+        ALIGNMENT_PROLOGUE_16BYTES(dst, x, length)
+            dst[x] = comp_func_Plus_one_pixel_const_alpha(dst[x], src[x], const_alpha, one_minus_const_alpha);
+
+        const __m128i half = _mm_set1_epi16(0x80);
+        const __m128i colorMask = _mm_set1_epi32(0x00ff00ff);
+        // 2) composition with SSE2
+        for (; x < length - 3; x += 4) {
+            const __m128i srcVector = _mm_loadu_si128((__m128i *)&src[x]);
+            const __m128i dstVector = _mm_load_si128((__m128i *)&dst[x]);
+
+            __m128i result = _mm_adds_epu8(srcVector, dstVector);
+            INTERPOLATE_PIXEL_255_SSE2(result, result, dstVector, constAlphaVector, oneMinusConstAlpha, colorMask, half)
+            _mm_store_si128((__m128i *)&dst[x], result);
+        }
+
+        // 3) Epilogue:
+        for (; x < length; ++x)
+            dst[x] = comp_func_Plus_one_pixel_const_alpha(dst[x], src[x], const_alpha, one_minus_const_alpha);
+    }
+}
+
+void QT_FASTCALL comp_func_Source_sse2(uint *dst, const uint *src, int length, uint const_alpha)
+{
+    if (const_alpha == 255) {
+        ::memcpy(dst, src, length * sizeof(uint));
+    } else {
+        const int ialpha = 255 - const_alpha;
+
+        int x = 0;
+
+        // 1) prologue, align on 16 bytes
+        ALIGNMENT_PROLOGUE_16BYTES(dst, x, length)
+            dst[x] = INTERPOLATE_PIXEL_255(src[x], const_alpha, dst[x], ialpha);
+
+        // 2) interpolate pixels with SSE2
+        const __m128i half = _mm_set1_epi16(0x80);
+        const __m128i colorMask = _mm_set1_epi32(0x00ff00ff);
+        const __m128i constAlphaVector = _mm_set1_epi16(const_alpha);
+        const __m128i oneMinusConstAlpha =  _mm_set1_epi16(ialpha);
+        for (; x < length - 3; x += 4) {
+            const __m128i srcVector = _mm_loadu_si128((__m128i *)&src[x]);
+            __m128i dstVector = _mm_load_si128((__m128i *)&dst[x]);
+            INTERPOLATE_PIXEL_255_SSE2(dstVector, srcVector, dstVector, constAlphaVector, oneMinusConstAlpha, colorMask, half)
+            _mm_store_si128((__m128i *)&dst[x], dstVector);
+        }
+
+        // 3) Epilogue
+        for (; x < length; ++x)
+            dst[x] = INTERPOLATE_PIXEL_255(src[x], const_alpha, dst[x], ialpha);
+    }
+}
+
+void qt_memfill32_sse2(quint32 *dest, quint32 value, int count)
+{
+    if (count < 7) {
+        switch (count) {
+        case 6: *dest++ = value;
+        case 5: *dest++ = value;
+        case 4: *dest++ = value;
+        case 3: *dest++ = value;
+        case 2: *dest++ = value;
+        case 1: *dest   = value;
+        }
+        return;
+    };
+
+    const int align = (quintptr)(dest) & 0xf;
+    switch (align) {
+    case 4:  *dest++ = value; --count;
+    case 8:  *dest++ = value; --count;
+    case 12: *dest++ = value; --count;
+    }
+
+    int count128 = count / 4;
+    __m128i *dst128 = reinterpret_cast<__m128i*>(dest);
+    const __m128i value128 = _mm_set_epi32(value, value, value, value);
+
+    int n = (count128 + 3) / 4;
+    switch (count128 & 0x3) {
+    case 0: do { _mm_stream_si128(dst128++, value128);
+    case 3:      _mm_stream_si128(dst128++, value128);
+    case 2:      _mm_stream_si128(dst128++, value128);
+    case 1:      _mm_stream_si128(dst128++, value128);
+    } while (--n > 0);
+    }
+
+    const int rest = count & 0x3;
+    if (rest) {
+        switch (rest) {
+        case 3: dest[count - 3] = value;
+        case 2: dest[count - 2] = value;
+        case 1: dest[count - 1] = value;
+        }
+    }
+}
+
+void QT_FASTCALL comp_func_solid_SourceOver_sse2(uint *destPixels, int length, uint color, uint const_alpha)
+{
+    if ((const_alpha & qAlpha(color)) == 255) {
+        qt_memfill32_sse2(destPixels, color, length);
+    } else {
+        if (const_alpha != 255)
+            color = BYTE_MUL(color, const_alpha);
+
+        const quint32 minusAlphaOfColor = qAlpha(~color);
+        int x = 0;
+
+        quint32 *dst = (quint32 *) destPixels;
+        const __m128i colorVector = _mm_set1_epi32(color);
+        const __m128i colorMask = _mm_set1_epi32(0x00ff00ff);
+        const __m128i half = _mm_set1_epi16(0x80);
+        const __m128i minusAlphaOfColorVector = _mm_set1_epi16(minusAlphaOfColor);
+
+        ALIGNMENT_PROLOGUE_16BYTES(dst, x, length)
+            destPixels[x] = color + BYTE_MUL(destPixels[x], minusAlphaOfColor);
+
+        for (; x < length-3; x += 4) {
+            __m128i dstVector = _mm_load_si128((__m128i *)&dst[x]);
+            BYTE_MUL_SSE2(dstVector, dstVector, minusAlphaOfColorVector, colorMask, half);
+            dstVector = _mm_add_epi8(colorVector, dstVector);
+            _mm_store_si128((__m128i *)&dst[x], dstVector);
+        }
+        for (;x < length; ++x)
+            destPixels[x] = color + BYTE_MUL(destPixels[x], minusAlphaOfColor);
+    }
+}
+
+CompositionFunctionSolid qt_functionForModeSolid_onlySSE2[numCompositionFunctions] = {
+    comp_func_solid_SourceOver_sse2,
+    comp_func_solid_DestinationOver,
+    comp_func_solid_Clear,
+    comp_func_solid_Source,
+    comp_func_solid_Destination,
+    comp_func_solid_SourceIn,
+    comp_func_solid_DestinationIn,
+    comp_func_solid_SourceOut,
+    comp_func_solid_DestinationOut,
+    comp_func_solid_SourceAtop,
+    comp_func_solid_DestinationAtop,
+    comp_func_solid_XOR,
+    comp_func_solid_Plus,
+    comp_func_solid_Multiply,
+    comp_func_solid_Screen,
+    comp_func_solid_Overlay,
+    comp_func_solid_Darken,
+    comp_func_solid_Lighten,
+    comp_func_solid_ColorDodge,
+    comp_func_solid_ColorBurn,
+    comp_func_solid_HardLight,
+    comp_func_solid_SoftLight,
+    comp_func_solid_Difference,
+    comp_func_solid_Exclusion,
+    rasterop_solid_SourceOrDestination,
+    rasterop_solid_SourceAndDestination,
+    rasterop_solid_SourceXorDestination,
+    rasterop_solid_NotSourceAndNotDestination,
+    rasterop_solid_NotSourceOrNotDestination,
+    rasterop_solid_NotSourceXorDestination,
+    rasterop_solid_NotSource,
+    rasterop_solid_NotSourceAndDestination,
+    rasterop_solid_SourceAndNotDestination
+};
+
+CompositionFunction qt_functionForMode_onlySSE2[numCompositionFunctions] = {
+    comp_func_SourceOver_sse2,
+    comp_func_DestinationOver,
+    comp_func_Clear,
+    comp_func_Source_sse2,
+    comp_func_Destination,
+    comp_func_SourceIn,
+    comp_func_DestinationIn,
+    comp_func_SourceOut,
+    comp_func_DestinationOut,
+    comp_func_SourceAtop,
+    comp_func_DestinationAtop,
+    comp_func_XOR,
+    comp_func_Plus_sse2,
+    comp_func_Multiply,
+    comp_func_Screen,
+    comp_func_Overlay,
+    comp_func_Darken,
+    comp_func_Lighten,
+    comp_func_ColorDodge,
+    comp_func_ColorBurn,
+    comp_func_HardLight,
+    comp_func_SoftLight,
+    comp_func_Difference,
+    comp_func_Exclusion,
+    rasterop_SourceOrDestination,
+    rasterop_SourceAndDestination,
+    rasterop_SourceXorDestination,
+    rasterop_NotSourceAndNotDestination,
+    rasterop_NotSourceOrNotDestination,
+    rasterop_NotSourceXorDestination,
+    rasterop_NotSource,
+    rasterop_NotSourceAndDestination,
+    rasterop_SourceAndNotDestination
+};
+
+void qt_memfill16_sse2(quint16 *dest, quint16 value, int count)
+{
+    if (count < 3) {
+        switch (count) {
+        case 2: *dest++ = value;
+        case 1: *dest = value;
+        }
+        return;
+    }
+
+    const int align = (quintptr)(dest) & 0x3;
+    switch (align) {
+    case 2: *dest++ = value; --count;
+    }
+
+    const quint32 value32 = (value << 16) | value;
+    qt_memfill32_sse2(reinterpret_cast<quint32*>(dest), value32, count / 2);
+
+    if (count & 0x1)
+        dest[count - 1] = value;
+}
+
+void qt_bitmapblit32_sse2(QRasterBuffer *rasterBuffer, int x, int y,
+                          quint32 color,
+                          const uchar *src, int width, int height, int stride)
+{
+    quint32 *dest = reinterpret_cast<quint32*>(rasterBuffer->scanLine(y)) + x;
+    const int destStride = rasterBuffer->bytesPerLine() / sizeof(quint32);
+
+    const __m128i c128 = _mm_set1_epi32(color);
+    const __m128i maskmask1 = _mm_set_epi32(0x10101010, 0x20202020,
+                                            0x40404040, 0x80808080);
+    const __m128i maskadd1 = _mm_set_epi32(0x70707070, 0x60606060,
+                                           0x40404040, 0x00000000);
+
+    if (width > 4) {
+        const __m128i maskmask2 = _mm_set_epi32(0x01010101, 0x02020202,
+                                                0x04040404, 0x08080808);
+        const __m128i maskadd2 = _mm_set_epi32(0x7f7f7f7f, 0x7e7e7e7e,
+                                               0x7c7c7c7c, 0x78787878);
+        while (height--) {
+            for (int x = 0; x < width; x += 8) {
+                const quint8 s = src[x >> 3];
+                if (!s)
+                    continue;
+                __m128i mask1 = _mm_set1_epi8(s);
+                __m128i mask2 = mask1;
+
+                mask1 = _mm_and_si128(mask1, maskmask1);
+                mask1 = _mm_add_epi8(mask1, maskadd1);
+                _mm_maskmoveu_si128(c128, mask1, (char*)(dest + x));
+                mask2 = _mm_and_si128(mask2, maskmask2);
+                mask2 = _mm_add_epi8(mask2, maskadd2);
+                _mm_maskmoveu_si128(c128, mask2, (char*)(dest + x + 4));
+            }
+            dest += destStride;
+            src += stride;
+        }
+    } else {
+        while (height--) {
+            const quint8 s = *src;
+            if (s) {
+                __m128i mask1 = _mm_set1_epi8(s);
+                mask1 = _mm_and_si128(mask1, maskmask1);
+                mask1 = _mm_add_epi8(mask1, maskadd1);
+                _mm_maskmoveu_si128(c128, mask1, (char*)(dest));
+            }
+            dest += destStride;
+            src += stride;
+        }
+    }
+}
+
+void qt_bitmapblit16_sse2(QRasterBuffer *rasterBuffer, int x, int y,
+                          quint32 color,
+                          const uchar *src, int width, int height, int stride)
+{
+    const quint16 c = qt_colorConvert<quint16, quint32>(color, 0);
+    quint16 *dest = reinterpret_cast<quint16*>(rasterBuffer->scanLine(y)) + x;
+    const int destStride = rasterBuffer->bytesPerLine() / sizeof(quint16);
+
+    const __m128i c128 = _mm_set1_epi16(c);
+#if defined(Q_CC_MSVC)
+#  pragma warning(disable: 4309) // truncation of constant value
+#endif
+    const __m128i maskmask = _mm_set_epi16(0x0101, 0x0202, 0x0404, 0x0808,
+                                           0x1010, 0x2020, 0x4040, 0x8080);
+    const __m128i maskadd = _mm_set_epi16(0x7f7f, 0x7e7e, 0x7c7c, 0x7878,
+                                          0x7070, 0x6060, 0x4040, 0x0000);
+
+    while (height--) {
+        for (int x = 0; x < width; x += 8) {
+            const quint8 s = src[x >> 3];
+            if (!s)
+                continue;
+            __m128i mask = _mm_set1_epi8(s);
+            mask = _mm_and_si128(mask, maskmask);
+            mask = _mm_add_epi8(mask, maskadd);
+            _mm_maskmoveu_si128(c128, mask, (char*)(dest + x));
+        }
+        dest += destStride;
+        src += stride;
+    }
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_HAVE_SSE2
diff --git a/src/gui/painting/qdrawhelper_sse3dnow.cpp b/src/gui/painting/qdrawhelper_sse3dnow.cpp
new file mode 100644
index 0000000000..fd351ed2bf
--- /dev/null
+++ b/src/gui/painting/qdrawhelper_sse3dnow.cpp
@@ -0,0 +1,143 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <private/qdrawhelper_x86_p.h>
+
+#if defined(QT_HAVE_3DNOW) && defined(QT_HAVE_SSE)
+
+#include <private/qdrawhelper_sse_p.h>
+#include <mm3dnow.h>
+
+QT_BEGIN_NAMESPACE
+
+struct QSSE3DNOWIntrinsics : public QSSEIntrinsics
+{
+    static inline void end() {
+        _m_femms();
+    }
+};
+
+CompositionFunctionSolid qt_functionForModeSolid_SSE3DNOW[numCompositionFunctions] = {
+    comp_func_solid_SourceOver<QSSE3DNOWIntrinsics>,
+    comp_func_solid_DestinationOver<QSSE3DNOWIntrinsics>,
+    comp_func_solid_Clear<QSSE3DNOWIntrinsics>,
+    comp_func_solid_Source<QSSE3DNOWIntrinsics>,
+    0,
+    comp_func_solid_SourceIn<QSSE3DNOWIntrinsics>,
+    comp_func_solid_DestinationIn<QSSE3DNOWIntrinsics>,
+    comp_func_solid_SourceOut<QSSE3DNOWIntrinsics>,
+    comp_func_solid_DestinationOut<QSSE3DNOWIntrinsics>,
+    comp_func_solid_SourceAtop<QSSE3DNOWIntrinsics>,
+    comp_func_solid_DestinationAtop<QSSE3DNOWIntrinsics>,
+    comp_func_solid_XOR<QSSE3DNOWIntrinsics>,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // svg 1.2 modes
+    rasterop_solid_SourceOrDestination<QSSE3DNOWIntrinsics>,
+    rasterop_solid_SourceAndDestination<QSSE3DNOWIntrinsics>,
+    rasterop_solid_SourceXorDestination<QSSE3DNOWIntrinsics>,
+    rasterop_solid_NotSourceAndNotDestination<QSSE3DNOWIntrinsics>,
+    rasterop_solid_NotSourceOrNotDestination<QSSE3DNOWIntrinsics>,
+    rasterop_solid_NotSourceXorDestination<QSSE3DNOWIntrinsics>,
+    rasterop_solid_NotSource<QSSE3DNOWIntrinsics>,
+    rasterop_solid_NotSourceAndDestination<QSSE3DNOWIntrinsics>,
+    rasterop_solid_SourceAndNotDestination<QSSE3DNOWIntrinsics>
+};
+
+CompositionFunction qt_functionForMode_SSE3DNOW[numCompositionFunctions] = {
+    comp_func_SourceOver<QSSE3DNOWIntrinsics>,
+    comp_func_DestinationOver<QSSE3DNOWIntrinsics>,
+    comp_func_Clear<QSSE3DNOWIntrinsics>,
+    comp_func_Source<QSSE3DNOWIntrinsics>,
+    comp_func_Destination,
+    comp_func_SourceIn<QSSE3DNOWIntrinsics>,
+    comp_func_DestinationIn<QSSE3DNOWIntrinsics>,
+    comp_func_SourceOut<QSSE3DNOWIntrinsics>,
+    comp_func_DestinationOut<QSSE3DNOWIntrinsics>,
+    comp_func_SourceAtop<QSSE3DNOWIntrinsics>,
+    comp_func_DestinationAtop<QSSE3DNOWIntrinsics>,
+    comp_func_XOR<QSSE3DNOWIntrinsics>,
+    comp_func_Plus,
+    comp_func_Multiply,
+    comp_func_Screen,
+    comp_func_Overlay,
+    comp_func_Darken,
+    comp_func_Lighten,
+    comp_func_ColorDodge,
+    comp_func_ColorBurn,
+    comp_func_HardLight,
+    comp_func_SoftLight,
+    comp_func_Difference,
+    comp_func_Exclusion,
+    rasterop_SourceOrDestination,
+    rasterop_SourceAndDestination,
+    rasterop_SourceXorDestination,
+    rasterop_NotSourceAndNotDestination,
+    rasterop_NotSourceOrNotDestination,
+    rasterop_NotSourceXorDestination,
+    rasterop_NotSource,
+    rasterop_NotSourceAndDestination,
+    rasterop_SourceAndNotDestination
+};
+
+void qt_blend_color_argb_sse3dnow(int count, const QSpan *spans, void *userData)
+{
+    qt_blend_color_argb_x86<QSSE3DNOWIntrinsics>(count, spans, userData,
+                                                 (CompositionFunctionSolid*)qt_functionForModeSolid_SSE3DNOW);
+}
+
+void qt_memfill32_sse3dnow(quint32 *dest, quint32 value, int count)
+{
+    return qt_memfill32_sse_template<QSSE3DNOWIntrinsics>(dest, value, count);
+}
+
+
+void qt_bitmapblit16_sse3dnow(QRasterBuffer *rasterBuffer, int x, int y,
+                              quint32 color,
+                              const uchar *src,
+                              int width, int height, int stride)
+{
+    return qt_bitmapblit16_sse_template<QSSE3DNOWIntrinsics>(rasterBuffer, x,y,
+                                                             color, src, width,
+                                                             height, stride);
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_HAVE_3DNOW && QT_HAVE_SSE
diff --git a/src/gui/painting/qdrawhelper_sse_p.h b/src/gui/painting/qdrawhelper_sse_p.h
new file mode 100644
index 0000000000..fff1e07152
--- /dev/null
+++ b/src/gui/painting/qdrawhelper_sse_p.h
@@ -0,0 +1,182 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QDRAWHELPER_SSE_P_H
+#define QDRAWHELPER_SSE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <private/qdrawhelper_mmx_p.h>
+
+#ifdef QT_HAVE_SSE
+
+#ifdef QT_LINUXBASE
+// this is an evil hack - the posix_memalign declaration in LSB
+// is wrong - see http://bugs.linuxbase.org/show_bug.cgi?id=2431
+#  define posix_memalign _lsb_hack_posix_memalign
+#  include <xmmintrin.h>
+#  undef posix_memalign
+#else
+#  include <xmmintrin.h>
+#endif
+
+QT_BEGIN_NAMESPACE
+
+#ifndef _MM_SHUFFLE
+#define _MM_SHUFFLE(fp3,fp2,fp1,fp0) \
+ (((fp3) << 6) | ((fp2) << 4) | ((fp1) << 2) | (fp0))
+#endif
+
+struct QSSEIntrinsics : public QMMXIntrinsics
+{
+    static inline m64 alpha(m64 x) {
+        return _mm_shuffle_pi16 (x, _MM_SHUFFLE(3, 3, 3, 3));
+    }
+
+    static inline m64 _load_alpha(uint x, const m64 &mmx_0x0000) {
+        m64 t = _mm_unpacklo_pi8(_mm_cvtsi32_si64(x), mmx_0x0000);
+        return _mm_shuffle_pi16 (t, _MM_SHUFFLE(0, 0, 0, 0));
+    }
+};
+
+template <class MM>
+inline void qt_memfill32_sse_template(quint32 *dest, quint32 value, int count)
+{
+    if (count < 7) {
+        switch (count) {
+        case 6: *dest++ = value;
+        case 5: *dest++ = value;
+        case 4: *dest++ = value;
+        case 3: *dest++ = value;
+        case 2: *dest++ = value;
+        case 1: *dest   = value;
+        }
+        return;
+    };
+
+    __m64 *dst64 = reinterpret_cast<__m64*>(dest);
+    const __m64 value64 = _mm_set_pi32(value, value);
+    int count64 = count / 2;
+
+    int n = (count64 + 3) / 4;
+    switch (count64 & 0x3) {
+    case 0: do { _mm_stream_pi(dst64++, value64);
+    case 3:      _mm_stream_pi(dst64++, value64);
+    case 2:      _mm_stream_pi(dst64++, value64);
+    case 1:      _mm_stream_pi(dst64++, value64);
+    } while (--n > 0);
+    }
+
+    if (count & 0x1)
+        dest[count - 1] = value;
+
+    MM::end();
+}
+
+template <class MM>
+inline void qt_bitmapblit16_sse_template(QRasterBuffer *rasterBuffer,
+                                         int x, int y,
+                                         quint32 color,
+                                         const uchar *src,
+                                         int width, int height, int stride)
+{
+    const quint16 c = qt_colorConvert<quint16, quint32>(color, 0);
+    quint16 *dest = reinterpret_cast<quint16*>(rasterBuffer->scanLine(y)) + x;
+    const int destStride = rasterBuffer->bytesPerLine() / sizeof(quint16);
+
+    const __m64 c64 = _mm_set1_pi16(c);
+#ifdef Q_CC_MSVC
+#  pragma warning(disable: 4309) // truncation of constant value
+#endif
+    const __m64 maskmask1 = _mm_set_pi16(0x1010, 0x2020, 0x4040, 0x8080);
+    const __m64 maskadd1 = _mm_set_pi16(0x7070, 0x6060, 0x4040, 0x0000);
+
+    if (width > 4) {
+        const __m64 maskmask2 = _mm_set_pi16(0x0101, 0x0202, 0x0404, 0x0808);
+        const __m64 maskadd2 = _mm_set_pi16(0x7f7f, 0x7e7e, 0x7c7c, 0x7878);
+
+        while (height--) {
+            for (int x = 0; x < width; x += 8) {
+                const quint8 s = src[x >> 3];
+                if (!s)
+                    continue;
+                __m64 mask1 = _mm_set1_pi8(s);
+                __m64 mask2 = mask1;
+                mask1 = _m_pand(mask1, maskmask1);
+                mask1 = _mm_add_pi16(mask1, maskadd1);
+                _mm_maskmove_si64(c64, mask1, (char*)(dest + x));
+                mask2 = _m_pand(mask2, maskmask2);
+                mask2 = _mm_add_pi16(mask2, maskadd2);
+                _mm_maskmove_si64(c64, mask2, (char*)(dest + x + 4));
+            }
+            dest += destStride;
+            src += stride;
+        }
+    } else {
+        while (height--) {
+            const quint8 s = *src;
+            if (s) {
+                __m64 mask1 = _mm_set1_pi8(s);
+                mask1 = _m_pand(mask1, maskmask1);
+                mask1 = _mm_add_pi16(mask1, maskadd1);
+                _mm_maskmove_si64(c64, mask1, (char*)(dest));
+            }
+            dest += destStride;
+            src += stride;
+        }
+    }
+
+    MM::end();
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_HAVE_SSE
+#endif // QDRAWHELPER_SSE_P_H
diff --git a/src/gui/painting/qdrawhelper_ssse3.cpp b/src/gui/painting/qdrawhelper_ssse3.cpp
new file mode 100644
index 0000000000..e392de2541
--- /dev/null
+++ b/src/gui/painting/qdrawhelper_ssse3.cpp
@@ -0,0 +1,183 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <private/qdrawhelper_x86_p.h>
+
+#ifdef QT_HAVE_SSSE3
+
+#include <private/qdrawingprimitive_sse2_p.h>
+
+QT_BEGIN_NAMESPACE
+
+inline static void blend_pixel(quint32 &dst, const quint32 src)
+{
+    if (src >= 0xff000000)
+        dst = src;
+    else if (src != 0)
+        dst = src + BYTE_MUL(dst, qAlpha(~src));
+}
+
+
+/* The instruction palignr uses direct arguments, so we have to generate the code fo the different
+   shift (4, 8, 12). Checking the alignment inside the loop is unfortunatelly way too slow.
+ */
+#define BLENDING_LOOP(palignrOffset, length)\
+    for (; x < length-3; x += 4) { \
+        const __m128i srcVectorLastLoaded = _mm_load_si128((__m128i *)&src[x - minusOffsetToAlignSrcOn16Bytes + 4]);\
+        const __m128i srcVector = _mm_alignr_epi8(srcVectorLastLoaded, srcVectorPrevLoaded, palignrOffset); \
+        const __m128i srcVectorAlpha = _mm_and_si128(srcVector, alphaMask); \
+        if (_mm_movemask_epi8(_mm_cmpeq_epi32(srcVectorAlpha, alphaMask)) == 0xffff) { \
+            _mm_store_si128((__m128i *)&dst[x], srcVector); \
+        } else if (_mm_movemask_epi8(_mm_cmpeq_epi32(srcVectorAlpha, nullVector)) != 0xffff) { \
+            __m128i alphaChannel = _mm_shuffle_epi8(srcVector, alphaShuffleMask); \
+            alphaChannel = _mm_sub_epi16(one, alphaChannel); \
+            const __m128i dstVector = _mm_load_si128((__m128i *)&dst[x]); \
+            __m128i destMultipliedByOneMinusAlpha; \
+            BYTE_MUL_SSE2(destMultipliedByOneMinusAlpha, dstVector, alphaChannel, colorMask, half); \
+            const __m128i result = _mm_add_epi8(srcVector, destMultipliedByOneMinusAlpha); \
+            _mm_store_si128((__m128i *)&dst[x], result); \
+        } \
+        srcVectorPrevLoaded = srcVectorLastLoaded;\
+    }
+
+
+// Basically blend src over dst with the const alpha defined as constAlphaVector.
+// nullVector, half, one, colorMask are constant across the whole image/texture, and should be defined as:
+//const __m128i nullVector = _mm_set1_epi32(0);
+//const __m128i half = _mm_set1_epi16(0x80);
+//const __m128i one = _mm_set1_epi16(0xff);
+//const __m128i colorMask = _mm_set1_epi32(0x00ff00ff);
+//const __m128i alphaMask = _mm_set1_epi32(0xff000000);
+//
+// The computation being done is:
+// result = s + d * (1-alpha)
+// with shortcuts if fully opaque or fully transparent.
+#define BLEND_SOURCE_OVER_ARGB32_SSSE3(dst, src, length, nullVector, half, one, colorMask, alphaMask) { \
+    int x = 0; \
+\
+    /* First, get dst aligned. */ \
+    ALIGNMENT_PROLOGUE_16BYTES(dst, x, length) { \
+        blend_pixel(dst[x], src[x]); \
+    } \
+\
+    const int minusOffsetToAlignSrcOn16Bytes = (reinterpret_cast<quintptr>(&(src[x])) >> 2) & 0x3;\
+\
+    if (!minusOffsetToAlignSrcOn16Bytes) {\
+        /* src is aligned, usual algorithm but with aligned operations.\
+           See the SSE2 version for more documentation on the algorithm itself. */\
+        const __m128i alphaShuffleMask = _mm_set_epi8(0xff,15,0xff,15,0xff,11,0xff,11,0xff,7,0xff,7,0xff,3,0xff,3);\
+        for (; x < length-3; x += 4) { \
+            const __m128i srcVector = _mm_load_si128((__m128i *)&src[x]); \
+            const __m128i srcVectorAlpha = _mm_and_si128(srcVector, alphaMask); \
+            if (_mm_movemask_epi8(_mm_cmpeq_epi32(srcVectorAlpha, alphaMask)) == 0xffff) { \
+                _mm_store_si128((__m128i *)&dst[x], srcVector); \
+            } else if (_mm_movemask_epi8(_mm_cmpeq_epi32(srcVectorAlpha, nullVector)) != 0xffff) { \
+                __m128i alphaChannel = _mm_shuffle_epi8(srcVector, alphaShuffleMask); \
+                alphaChannel = _mm_sub_epi16(one, alphaChannel); \
+                const __m128i dstVector = _mm_load_si128((__m128i *)&dst[x]); \
+                __m128i destMultipliedByOneMinusAlpha; \
+                BYTE_MUL_SSE2(destMultipliedByOneMinusAlpha, dstVector, alphaChannel, colorMask, half); \
+                const __m128i result = _mm_add_epi8(srcVector, destMultipliedByOneMinusAlpha); \
+                _mm_store_si128((__m128i *)&dst[x], result); \
+            } \
+        } /* end for() */\
+    } else if ((length - x) >= 8) {\
+        /* We use two vectors to extract the src: prevLoaded for the first pixels, lastLoaded for the current pixels. */\
+        __m128i srcVectorPrevLoaded = _mm_load_si128((__m128i *)&src[x - minusOffsetToAlignSrcOn16Bytes]);\
+        const int palignrOffset = minusOffsetToAlignSrcOn16Bytes << 2;\
+\
+        const __m128i alphaShuffleMask = _mm_set_epi8(0xff,15,0xff,15,0xff,11,0xff,11,0xff,7,0xff,7,0xff,3,0xff,3);\
+        switch (palignrOffset) {\
+        case 4:\
+            BLENDING_LOOP(4, length)\
+            break;\
+        case 8:\
+            BLENDING_LOOP(8, length)\
+            break;\
+        case 12:\
+            BLENDING_LOOP(12, length)\
+            break;\
+        }\
+    }\
+    for (; x < length; ++x) \
+        blend_pixel(dst[x], src[x]); \
+}
+
+void qt_blend_argb32_on_argb32_ssse3(uchar *destPixels, int dbpl,
+                                     const uchar *srcPixels, int sbpl,
+                                     int w, int h,
+                                     int const_alpha)
+{
+    const quint32 *src = (const quint32 *) srcPixels;
+    quint32 *dst = (quint32 *) destPixels;
+    if (const_alpha == 256) {
+        const __m128i alphaMask = _mm_set1_epi32(0xff000000);
+        const __m128i nullVector = _mm_setzero_si128();
+        const __m128i half = _mm_set1_epi16(0x80);
+        const __m128i one = _mm_set1_epi16(0xff);
+        const __m128i colorMask = _mm_set1_epi32(0x00ff00ff);
+
+        for (int y = 0; y < h; ++y) {
+            BLEND_SOURCE_OVER_ARGB32_SSSE3(dst, src, w, nullVector, half, one, colorMask, alphaMask);
+            dst = (quint32 *)(((uchar *) dst) + dbpl);
+            src = (const quint32 *)(((const uchar *) src) + sbpl);
+        }
+    } else if (const_alpha != 0) {
+        // dest = (s + d * sia) * ca + d * cia
+        //      = s * ca + d * (sia * ca + cia)
+        //      = s * ca + d * (1 - sa*ca)
+        const_alpha = (const_alpha * 255) >> 8;
+        const __m128i nullVector = _mm_setzero_si128();
+        const __m128i half = _mm_set1_epi16(0x80);
+        const __m128i one = _mm_set1_epi16(0xff);
+        const __m128i colorMask = _mm_set1_epi32(0x00ff00ff);
+        const __m128i constAlphaVector = _mm_set1_epi16(const_alpha);
+        for (int y = 0; y < h; ++y) {
+            BLEND_SOURCE_OVER_ARGB32_WITH_CONST_ALPHA_SSE2(dst, src, w, nullVector, half, one, colorMask, constAlphaVector)
+            dst = (quint32 *)(((uchar *) dst) + dbpl);
+            src = (const quint32 *)(((const uchar *) src) + sbpl);
+        }
+    }
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_HAVE_SSSE3
diff --git a/src/gui/painting/qdrawhelper_x86_p.h b/src/gui/painting/qdrawhelper_x86_p.h
new file mode 100644
index 0000000000..496ca8d141
--- /dev/null
+++ b/src/gui/painting/qdrawhelper_x86_p.h
@@ -0,0 +1,141 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QDRAWHELPER_X86_P_H
+#define QDRAWHELPER_X86_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <private/qdrawhelper_p.h>
+
+QT_BEGIN_NAMESPACE
+
+#ifdef QT_HAVE_MMX
+extern CompositionFunction qt_functionForMode_MMX[];
+extern CompositionFunctionSolid qt_functionForModeSolid_MMX[];
+void qt_blend_color_argb_mmx(int count, const QSpan *spans, void *userData);
+#endif
+
+#ifdef QT_HAVE_MMXEXT
+void qt_memfill32_mmxext(quint32 *dest, quint32 value, int count);
+void qt_bitmapblit16_mmxext(QRasterBuffer *rasterBuffer, int x, int y,
+                            quint32 color, const uchar *src,
+                            int width, int height, int stride);
+#endif
+
+#ifdef QT_HAVE_3DNOW
+#if defined(QT_HAVE_MMX) || !defined(QT_HAVE_SSE)
+extern CompositionFunction qt_functionForMode_MMX3DNOW[];
+extern CompositionFunctionSolid qt_functionForModeSolid_MMX3DNOW[];
+
+void qt_blend_color_argb_mmx3dnow(int count, const QSpan *spans,
+                                  void *userData);
+#endif // MMX
+
+#ifdef QT_HAVE_SSE
+extern CompositionFunction qt_functionForMode_SSE3DNOW[];
+extern CompositionFunctionSolid qt_functionForModeSolid_SSE3DNOW[];
+
+void qt_memfill32_sse3dnow(quint32 *dest, quint32 value, int count);
+void qt_bitmapblit16_sse3dnow(QRasterBuffer *rasterBuffer, int x, int y,
+                              quint32 color,
+                              const uchar *src, int width, int height,
+                              int stride);
+void qt_blend_color_argb_sse3dnow(int count, const QSpan *spans,
+                                  void *userData);
+#endif // SSE
+#endif // QT_HAVE_3DNOW
+
+#ifdef QT_HAVE_SSE
+void qt_memfill32_sse(quint32 *dest, quint32 value, int count);
+void qt_bitmapblit16_sse(QRasterBuffer *rasterBuffer, int x, int y,
+                         quint32 color,
+                         const uchar *src, int width, int height, int stride);
+
+void qt_blend_color_argb_sse(int count, const QSpan *spans, void *userData);
+
+extern CompositionFunction qt_functionForMode_SSE[];
+extern CompositionFunctionSolid qt_functionForModeSolid_SSE[];
+#endif // QT_HAVE_SSE
+
+#ifdef QT_HAVE_SSE2
+void qt_memfill32_sse2(quint32 *dest, quint32 value, int count);
+void qt_memfill16_sse2(quint16 *dest, quint16 value, int count);
+void qt_bitmapblit32_sse2(QRasterBuffer *rasterBuffer, int x, int y,
+                          quint32 color,
+                          const uchar *src, int width, int height, int stride);
+void qt_bitmapblit16_sse2(QRasterBuffer *rasterBuffer, int x, int y,
+                          quint32 color,
+                          const uchar *src, int width, int height, int stride);
+void qt_blend_argb32_on_argb32_sse2(uchar *destPixels, int dbpl,
+                                    const uchar *srcPixels, int sbpl,
+                                    int w, int h,
+                                    int const_alpha);
+void qt_blend_rgb32_on_rgb32_sse2(uchar *destPixels, int dbpl,
+                                 const uchar *srcPixels, int sbpl,
+                                 int w, int h,
+                                 int const_alpha);
+
+extern CompositionFunction qt_functionForMode_onlySSE2[];
+extern CompositionFunctionSolid qt_functionForModeSolid_onlySSE2[];
+#endif // QT_HAVE_SSE2
+
+#ifdef QT_HAVE_IWMMXT
+void qt_blend_color_argb_iwmmxt(int count, const QSpan *spans, void *userData);
+
+extern CompositionFunction qt_functionForMode_IWMMXT[];
+extern CompositionFunctionSolid qt_functionForModeSolid_IWMMXT[];
+#endif
+
+static const int numCompositionFunctions = 33;
+
+QT_END_NAMESPACE
+
+#endif // QDRAWHELPER_X86_P_H
diff --git a/src/gui/painting/qdrawingprimitive_sse2_p.h b/src/gui/painting/qdrawingprimitive_sse2_p.h
new file mode 100644
index 0000000000..d8793c3900
--- /dev/null
+++ b/src/gui/painting/qdrawingprimitive_sse2_p.h
@@ -0,0 +1,241 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QDRAWINGPRIMITIVE_SSE2_P_H
+#define QDRAWINGPRIMITIVE_SSE2_P_H
+
+#include <private/qsimd_p.h>
+
+#ifdef QT_HAVE_SSE2
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+QT_BEGIN_NAMESPACE
+
+/*
+ * Multiply the components of pixelVector by alphaChannel
+ * Each 32bits components of alphaChannel must be in the form 0x00AA00AA
+ * colorMask must have 0x00ff00ff on each 32 bits component
+ * half must have the value 128 (0x80) for each 32 bits compnent
+ */
+#define BYTE_MUL_SSE2(result, pixelVector, alphaChannel, colorMask, half) \
+{ \
+    /* 1. separate the colors in 2 vectors so each color is on 16 bits \
+       (in order to be multiplied by the alpha \
+       each 32 bit of dstVectorAG are in the form 0x00AA00GG \
+       each 32 bit of dstVectorRB are in the form 0x00RR00BB */\
+    __m128i pixelVectorAG = _mm_srli_epi16(pixelVector, 8); \
+    __m128i pixelVectorRB = _mm_and_si128(pixelVector, colorMask); \
+ \
+    /* 2. multiply the vectors by the alpha channel */\
+    pixelVectorAG = _mm_mullo_epi16(pixelVectorAG, alphaChannel); \
+    pixelVectorRB = _mm_mullo_epi16(pixelVectorRB, alphaChannel); \
+ \
+    /* 3. divide by 255, that's the tricky part. \
+       we do it like for BYTE_MUL(), with bit shift: X/255 ~= (X + X/256 + rounding)/256 */ \
+    /** so first (X + X/256 + rounding) */\
+    pixelVectorRB = _mm_add_epi16(pixelVectorRB, _mm_srli_epi16(pixelVectorRB, 8)); \
+    pixelVectorRB = _mm_add_epi16(pixelVectorRB, half); \
+    pixelVectorAG = _mm_add_epi16(pixelVectorAG, _mm_srli_epi16(pixelVectorAG, 8)); \
+    pixelVectorAG = _mm_add_epi16(pixelVectorAG, half); \
+ \
+    /** second divide by 256 */\
+    pixelVectorRB = _mm_srli_epi16(pixelVectorRB, 8); \
+    /** for AG, we could >> 8 to divide followed by << 8 to put the \
+        bytes in the correct position. By masking instead, we execute \
+        only one instruction */\
+    pixelVectorAG = _mm_andnot_si128(colorMask, pixelVectorAG); \
+ \
+    /* 4. combine the 2 pairs of colors */ \
+    result = _mm_or_si128(pixelVectorAG, pixelVectorRB); \
+}
+
+/*
+ * Each 32bits components of alphaChannel must be in the form 0x00AA00AA
+ * oneMinusAlphaChannel must be 255 - alpha for each 32 bits component
+ * colorMask must have 0x00ff00ff on each 32 bits component
+ * half must have the value 128 (0x80) for each 32 bits compnent
+ */
+#define INTERPOLATE_PIXEL_255_SSE2(result, srcVector, dstVector, alphaChannel, oneMinusAlphaChannel, colorMask, half) { \
+    /* interpolate AG */\
+    __m128i srcVectorAG = _mm_srli_epi16(srcVector, 8); \
+    __m128i dstVectorAG = _mm_srli_epi16(dstVector, 8); \
+    __m128i srcVectorAGalpha = _mm_mullo_epi16(srcVectorAG, alphaChannel); \
+    __m128i dstVectorAGoneMinusAlphalpha = _mm_mullo_epi16(dstVectorAG, oneMinusAlphaChannel); \
+    __m128i finalAG = _mm_add_epi16(srcVectorAGalpha, dstVectorAGoneMinusAlphalpha); \
+    finalAG = _mm_add_epi16(finalAG, _mm_srli_epi16(finalAG, 8)); \
+    finalAG = _mm_add_epi16(finalAG, half); \
+    finalAG = _mm_andnot_si128(colorMask, finalAG); \
+ \
+    /* interpolate RB */\
+    __m128i srcVectorRB = _mm_and_si128(srcVector, colorMask); \
+    __m128i dstVectorRB = _mm_and_si128(dstVector, colorMask); \
+    __m128i srcVectorRBalpha = _mm_mullo_epi16(srcVectorRB, alphaChannel); \
+    __m128i dstVectorRBoneMinusAlphalpha = _mm_mullo_epi16(dstVectorRB, oneMinusAlphaChannel); \
+    __m128i finalRB = _mm_add_epi16(srcVectorRBalpha, dstVectorRBoneMinusAlphalpha); \
+    finalRB = _mm_add_epi16(finalRB, _mm_srli_epi16(finalRB, 8)); \
+    finalRB = _mm_add_epi16(finalRB, half); \
+    finalRB = _mm_srli_epi16(finalRB, 8); \
+ \
+    /* combine */\
+    result = _mm_or_si128(finalAG, finalRB); \
+}
+
+// Basically blend src over dst with the const alpha defined as constAlphaVector.
+// nullVector, half, one, colorMask are constant across the whole image/texture, and should be defined as:
+//const __m128i nullVector = _mm_set1_epi32(0);
+//const __m128i half = _mm_set1_epi16(0x80);
+//const __m128i one = _mm_set1_epi16(0xff);
+//const __m128i colorMask = _mm_set1_epi32(0x00ff00ff);
+//const __m128i alphaMask = _mm_set1_epi32(0xff000000);
+//
+// The computation being done is:
+// result = s + d * (1-alpha)
+// with shortcuts if fully opaque or fully transparent.
+#define BLEND_SOURCE_OVER_ARGB32_SSE2(dst, src, length, nullVector, half, one, colorMask, alphaMask) { \
+    int x = 0; \
+\
+    /* First, get dst aligned. */ \
+    ALIGNMENT_PROLOGUE_16BYTES(dst, x, length) { \
+        uint s = src[x]; \
+        if (s >= 0xff000000) \
+            dst[x] = s; \
+        else if (s != 0) \
+            dst[x] = s + BYTE_MUL(dst[x], qAlpha(~s)); \
+    } \
+\
+    for (; x < length-3; x += 4) { \
+        const __m128i srcVector = _mm_loadu_si128((__m128i *)&src[x]); \
+        const __m128i srcVectorAlpha = _mm_and_si128(srcVector, alphaMask); \
+        if (_mm_movemask_epi8(_mm_cmpeq_epi32(srcVectorAlpha, alphaMask)) == 0xffff) { \
+            /* all opaque */ \
+            _mm_store_si128((__m128i *)&dst[x], srcVector); \
+        } else if (_mm_movemask_epi8(_mm_cmpeq_epi32(srcVectorAlpha, nullVector)) != 0xffff) { \
+            /* not fully transparent */ \
+            /* extract the alpha channel on 2 x 16 bits */ \
+            /* so we have room for the multiplication */ \
+            /* each 32 bits will be in the form 0x00AA00AA */ \
+            /* with A being the 1 - alpha */ \
+            __m128i alphaChannel = _mm_srli_epi32(srcVector, 24); \
+            alphaChannel = _mm_or_si128(alphaChannel, _mm_slli_epi32(alphaChannel, 16)); \
+            alphaChannel = _mm_sub_epi16(one, alphaChannel); \
+ \
+            const __m128i dstVector = _mm_load_si128((__m128i *)&dst[x]); \
+            __m128i destMultipliedByOneMinusAlpha; \
+            BYTE_MUL_SSE2(destMultipliedByOneMinusAlpha, dstVector, alphaChannel, colorMask, half); \
+ \
+            /* result = s + d * (1-alpha) */\
+            const __m128i result = _mm_add_epi8(srcVector, destMultipliedByOneMinusAlpha); \
+            _mm_store_si128((__m128i *)&dst[x], result); \
+        } \
+    } \
+    for (; x < length; ++x) { \
+        uint s = src[x]; \
+        if (s >= 0xff000000) \
+            dst[x] = s; \
+        else if (s != 0) \
+            dst[x] = s + BYTE_MUL(dst[x], qAlpha(~s)); \
+    } \
+}
+
+// Basically blend src over dst with the const alpha defined as constAlphaVector.
+// nullVector, half, one, colorMask are constant across the whole image/texture, and should be defined as:
+//const __m128i nullVector = _mm_set1_epi32(0);
+//const __m128i half = _mm_set1_epi16(0x80);
+//const __m128i one = _mm_set1_epi16(0xff);
+//const __m128i colorMask = _mm_set1_epi32(0x00ff00ff);
+//
+// The computation being done is:
+// dest = (s + d * sia) * ca + d * cia
+//      = s * ca + d * (sia * ca + cia)
+//      = s * ca + d * (1 - sa*ca)
+#define BLEND_SOURCE_OVER_ARGB32_WITH_CONST_ALPHA_SSE2(dst, src, length, nullVector, half, one, colorMask, constAlphaVector) \
+{ \
+    int x = 0; \
+\
+    ALIGNMENT_PROLOGUE_16BYTES(dst, x, length) { \
+        quint32 s = src[x]; \
+        if (s != 0) { \
+            s = BYTE_MUL(s, const_alpha); \
+            dst[x] = s + BYTE_MUL(dst[x], qAlpha(~s)); \
+        } \
+    } \
+\
+    for (; x < length-3; x += 4) { \
+        __m128i srcVector = _mm_loadu_si128((__m128i *)&src[x]); \
+        if (_mm_movemask_epi8(_mm_cmpeq_epi32(srcVector, nullVector)) != 0xffff) { \
+            BYTE_MUL_SSE2(srcVector, srcVector, constAlphaVector, colorMask, half); \
+\
+            __m128i alphaChannel = _mm_srli_epi32(srcVector, 24); \
+            alphaChannel = _mm_or_si128(alphaChannel, _mm_slli_epi32(alphaChannel, 16)); \
+            alphaChannel = _mm_sub_epi16(one, alphaChannel); \
+ \
+            const __m128i dstVector = _mm_load_si128((__m128i *)&dst[x]); \
+            __m128i destMultipliedByOneMinusAlpha; \
+            BYTE_MUL_SSE2(destMultipliedByOneMinusAlpha, dstVector, alphaChannel, colorMask, half); \
+ \
+            const __m128i result = _mm_add_epi8(srcVector, destMultipliedByOneMinusAlpha); \
+            _mm_store_si128((__m128i *)&dst[x], result); \
+        } \
+    } \
+    for (; x < length; ++x) { \
+        quint32 s = src[x]; \
+        if (s != 0) { \
+            s = BYTE_MUL(s, const_alpha); \
+            dst[x] = s + BYTE_MUL(dst[x], qAlpha(~s)); \
+        } \
+    } \
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_HAVE_SSE2
+
+#endif // QDRAWINGPRIMITIVE_SSE2_P_H
diff --git a/src/gui/painting/qdrawutil.cpp b/src/gui/painting/qdrawutil.cpp
new file mode 100644
index 0000000000..89474d9679
--- /dev/null
+++ b/src/gui/painting/qdrawutil.cpp
@@ -0,0 +1,1360 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qdrawutil.h"
+#include "qbitmap.h"
+#include "qpixmapcache.h"
+#include "qapplication.h"
+#include "qpainter.h"
+#include "qpalette.h"
+#include <private/qpaintengineex_p.h>
+#include <qvarlengtharray.h>
+#include <qmath.h>
+#include <private/qstylehelper_p.h>
+
+QT_BEGIN_NAMESPACE
+
+/*!
+    \headerfile <qdrawutil.h>
+    \title Drawing Utility Functions
+
+    \sa QPainter
+*/
+
+/*!
+    \fn void qDrawShadeLine(QPainter *painter, int x1, int y1, int x2, int y2,
+                     const QPalette &palette, bool sunken,
+                     int lineWidth, int midLineWidth)
+    \relates <qdrawutil.h>
+
+    Draws a horizontal (\a y1 == \a y2) or vertical (\a x1 == \a x2)
+    shaded line using the given \a painter.  Note that nothing is
+    drawn if \a y1 != \a y2 and \a x1 != \a x2 (i.e. the line is
+    neither horizontal nor vertical).
+
+    The provided \a palette specifies the shading colors (\l
+    {QPalette::light()}{light}, \l {QPalette::dark()}{dark} and \l
+    {QPalette::mid()}{middle} colors).  The given \a lineWidth
+    specifies the line width for each of the lines; it is not the
+    total line width. The given \a midLineWidth specifies the width of
+    a middle line drawn in the QPalette::mid() color.
+
+    The line appears sunken if \a sunken is true, otherwise raised.
+
+    \warning This function does not look at QWidget::style() or
+    QApplication::style().  Use the drawing functions in QStyle to
+    make widgets that follow the current GUI style.
+
+
+    Alternatively you can use a QFrame widget and apply the
+    QFrame::setFrameStyle() function to display a shaded line:
+
+    \snippet doc/src/snippets/code/src_gui_painting_qdrawutil.cpp 0
+
+    \sa qDrawShadeRect(), qDrawShadePanel(), QStyle
+*/
+
+void qDrawShadeLine(QPainter *p, int x1, int y1, int x2, int y2,
+                     const QPalette &pal, bool sunken,
+                     int lineWidth, int midLineWidth)
+{
+    if (!(p && lineWidth >= 0 && midLineWidth >= 0))        {
+        qWarning("qDrawShadeLine: Invalid parameters");
+        return;
+    }
+    int tlw = lineWidth*2 + midLineWidth;        // total line width
+    QPen oldPen = p->pen();                        // save pen
+    if (sunken)
+        p->setPen(pal.color(QPalette::Dark));
+    else
+        p->setPen(pal.light().color());
+    QPolygon a;
+    int i;
+    if (y1 == y2) {                                // horizontal line
+        int y = y1 - tlw/2;
+        if (x1 > x2) {                        // swap x1 and x2
+            int t = x1;
+            x1 = x2;
+            x2 = t;
+        }
+        x2--;
+        for (i=0; i<lineWidth; i++) {                // draw top shadow
+            a.setPoints(3, x1+i, y+tlw-1-i,
+                         x1+i, y+i,
+                         x2-i, y+i);
+            p->drawPolyline(a);
+        }
+        if (midLineWidth > 0) {
+            p->setPen(pal.mid().color());
+            for (i=0; i<midLineWidth; i++)        // draw lines in the middle
+                p->drawLine(x1+lineWidth, y+lineWidth+i,
+                             x2-lineWidth, y+lineWidth+i);
+        }
+        if (sunken)
+            p->setPen(pal.light().color());
+        else
+            p->setPen(pal.dark().color());
+        for (i=0; i<lineWidth; i++) {                // draw bottom shadow
+            a.setPoints(3, x1+i, y+tlw-i-1,
+                         x2-i, y+tlw-i-1,
+                         x2-i, y+i+1);
+            p->drawPolyline(a);
+        }
+    }
+    else if (x1 == x2) {                        // vertical line
+        int x = x1 - tlw/2;
+        if (y1 > y2) {                        // swap y1 and y2
+            int t = y1;
+            y1 = y2;
+            y2 = t;
+        }
+        y2--;
+        for (i=0; i<lineWidth; i++) {                // draw left shadow
+            a.setPoints(3, x+i, y2,
+                         x+i, y1+i,
+                         x+tlw-1, y1+i);
+            p->drawPolyline(a);
+        }
+        if (midLineWidth > 0) {
+            p->setPen(pal.mid().color());
+            for (i=0; i<midLineWidth; i++)        // draw lines in the middle
+                p->drawLine(x+lineWidth+i, y1+lineWidth, x+lineWidth+i, y2);
+        }
+        if (sunken)
+            p->setPen(pal.light().color());
+        else
+            p->setPen(pal.dark().color());
+        for (i=0; i<lineWidth; i++) {                // draw right shadow
+            a.setPoints(3, x+lineWidth, y2-i,
+                         x+tlw-i-1, y2-i,
+                         x+tlw-i-1, y1+lineWidth);
+            p->drawPolyline(a);
+        }
+    }
+    p->setPen(oldPen);
+}
+
+/*!
+    \fn void qDrawShadeRect(QPainter *painter, int x, int y, int width, int height,
+                     const QPalette &palette, bool sunken,
+                     int lineWidth, int midLineWidth,
+                     const QBrush *fill)
+    \relates <qdrawutil.h>
+
+    Draws the shaded rectangle beginning at (\a x, \a y) with the
+    given \a width and \a height using the provided \a painter.
+
+    The provide \a palette specifies the shading colors (\l
+    {QPalette::light()}{light}, \l {QPalette::dark()}{dark} and \l
+    {QPalette::mid()}{middle} colors.  The given \a lineWidth
+    specifies the line width for each of the lines; it is not the
+    total line width.  The \a midLineWidth specifies the width of a
+    middle line drawn in the QPalette::mid() color.  The rectangle's
+    interior is filled with the \a fill brush unless \a fill is 0.
+
+    The rectangle appears sunken if \a sunken is true, otherwise
+    raised.
+
+    \warning This function does not look at QWidget::style() or
+    QApplication::style(). Use the drawing functions in QStyle to make
+    widgets that follow the current GUI style.
+
+    Alternatively you can use a QFrame widget and apply the
+    QFrame::setFrameStyle() function to display a shaded rectangle:
+
+    \snippet doc/src/snippets/code/src_gui_painting_qdrawutil.cpp 1
+
+    \sa qDrawShadeLine(), qDrawShadePanel(), qDrawPlainRect(), QStyle
+*/
+
+void qDrawShadeRect(QPainter *p, int x, int y, int w, int h,
+                     const QPalette &pal, bool sunken,
+                     int lineWidth, int midLineWidth,
+                     const QBrush *fill)
+{
+    if (w == 0 || h == 0)
+        return;
+    if (! (w > 0 && h > 0 && lineWidth >= 0 && midLineWidth >= 0)) {
+        qWarning("qDrawShadeRect: Invalid parameters");
+        return;
+    }
+    QPen oldPen = p->pen();
+    if (sunken)
+        p->setPen(pal.dark().color());
+    else
+        p->setPen(pal.light().color());
+    int x1=x, y1=y, x2=x+w-1, y2=y+h-1;
+
+    if (lineWidth == 1 && midLineWidth == 0) {// standard shade rectangle
+        p->drawRect(x1, y1, w-2, h-2);
+        if (sunken)
+            p->setPen(pal.light().color());
+        else
+            p->setPen(pal.dark().color());
+        QLineF lines[4] = { QLineF(x1+1, y1+1, x2-2, y1+1),
+                            QLineF(x1+1, y1+2, x1+1, y2-2),
+                            QLineF(x1, y2, x2, y2),
+                            QLineF(x2,y1, x2,y2-1) };
+        p->drawLines(lines, 4);              // draw bottom/right lines
+    } else {                                        // more complicated
+        int m = lineWidth+midLineWidth;
+        int i, j=0, k=m;
+        for (i=0; i<lineWidth; i++) {                // draw top shadow
+            QLineF lines[4] = { QLineF(x1+i, y2-i, x1+i, y1+i),
+                                QLineF(x1+i, y1+i, x2-i, y1+i),
+                                QLineF(x1+k, y2-k, x2-k, y2-k),
+                                QLineF(x2-k, y2-k, x2-k, y1+k) };
+            p->drawLines(lines, 4);
+            k++;
+        }
+        p->setPen(pal.mid().color());
+        j = lineWidth*2;
+        for (i=0; i<midLineWidth; i++) {        // draw lines in the middle
+            p->drawRect(x1+lineWidth+i, y1+lineWidth+i, w-j-1, h-j-1);
+            j += 2;
+        }
+        if (sunken)
+            p->setPen(pal.light().color());
+        else
+            p->setPen(pal.dark().color());
+        k = m;
+        for (i=0; i<lineWidth; i++) {                // draw bottom shadow
+            QLineF lines[4] = { QLineF(x1+1+i, y2-i, x2-i, y2-i),
+                                QLineF(x2-i, y2-i, x2-i, y1+i+1),
+                                QLineF(x1+k, y2-k, x1+k, y1+k),
+                                QLineF(x1+k, y1+k, x2-k, y1+k) };
+            p->drawLines(lines, 4);
+            k++;
+        }
+    }
+    if (fill) {
+        QBrush oldBrush = p->brush();
+        int tlw = lineWidth + midLineWidth;
+        p->setPen(Qt::NoPen);
+        p->setBrush(*fill);
+        p->drawRect(x+tlw, y+tlw, w-2*tlw, h-2*tlw);
+        p->setBrush(oldBrush);
+    }
+    p->setPen(oldPen);                        // restore pen
+}
+
+
+/*!
+    \fn void qDrawShadePanel(QPainter *painter, int x, int y, int width, int height,
+                      const QPalette &palette, bool sunken,
+                      int lineWidth, const QBrush *fill)
+    \relates <qdrawutil.h>
+
+    Draws the shaded panel beginning at (\a x, \a y) with the given \a
+    width and \a height using the provided \a painter and the given \a
+    lineWidth.
+
+    The given \a palette specifies the shading colors (\l
+    {QPalette::light()}{light}, \l {QPalette::dark()}{dark} and \l
+    {QPalette::mid()}{middle} colors).  The panel's interior is filled
+    with the \a fill brush unless \a fill is 0.
+
+    The panel appears sunken if \a sunken is true, otherwise raised.
+
+    \warning This function does not look at QWidget::style() or
+    QApplication::style(). Use the drawing functions in QStyle to make
+    widgets that follow the current GUI style.
+
+    Alternatively you can use a QFrame widget and apply the
+    QFrame::setFrameStyle() function to display a shaded panel:
+
+    \snippet doc/src/snippets/code/src_gui_painting_qdrawutil.cpp 2
+
+    \sa qDrawWinPanel(), qDrawShadeLine(), qDrawShadeRect(), QStyle
+*/
+
+void qDrawShadePanel(QPainter *p, int x, int y, int w, int h,
+                      const QPalette &pal, bool sunken,
+                      int lineWidth, const QBrush *fill)
+{
+    if (w == 0 || h == 0)
+        return;
+    if (!(w > 0 && h > 0 && lineWidth >= 0)) {
+        qWarning("qDrawShadePanel: Invalid parameters");
+    }
+    QColor shade = pal.dark().color();
+    QColor light = pal.light().color();
+    if (fill) {
+        if (fill->color() == shade)
+            shade = pal.shadow().color();
+        if (fill->color() == light)
+            light = pal.midlight().color();
+    }
+    QPen oldPen = p->pen();                        // save pen
+    QVector<QLineF> lines;
+    lines.reserve(2*lineWidth);
+
+    if (sunken)
+        p->setPen(shade);
+    else
+        p->setPen(light);
+    int x1, y1, x2, y2;
+    int i;
+    x1 = x;
+    y1 = y2 = y;
+    x2 = x+w-2;
+    for (i=0; i<lineWidth; i++) {                // top shadow
+        lines << QLineF(x1, y1++, x2--, y2++);
+    }
+    x2 = x1;
+    y1 = y+h-2;
+    for (i=0; i<lineWidth; i++) {                // left shado
+        lines << QLineF(x1++, y1, x2++, y2--);
+    }
+    p->drawLines(lines);
+    lines.clear();
+    if (sunken)
+        p->setPen(light);
+    else
+        p->setPen(shade);
+    x1 = x;
+    y1 = y2 = y+h-1;
+    x2 = x+w-1;
+    for (i=0; i<lineWidth; i++) {                // bottom shadow
+        lines << QLineF(x1++, y1--, x2, y2--);
+    }
+    x1 = x2;
+    y1 = y;
+    y2 = y+h-lineWidth-1;
+    for (i=0; i<lineWidth; i++) {                // right shadow
+        lines << QLineF(x1--, y1++, x2--, y2);
+    }
+    p->drawLines(lines);
+    if (fill)                                // fill with fill color
+        p->fillRect(x+lineWidth, y+lineWidth, w-lineWidth*2, h-lineWidth*2, *fill);
+    p->setPen(oldPen);                        // restore pen
+}
+
+
+/*!
+  \internal
+  This function draws a rectangle with two pixel line width.
+  It is called from qDrawWinButton() and qDrawWinPanel().
+
+  c1..c4 and fill are used:
+
+    1 1 1 1 1 2
+    1 3 3 3 4 2
+    1 3 F F 4 2
+    1 3 F F 4 2
+    1 4 4 4 4 2
+    2 2 2 2 2 2
+*/
+
+static void qDrawWinShades(QPainter *p,
+                           int x, int y, int w, int h,
+                           const QColor &c1, const QColor &c2,
+                           const QColor &c3, const QColor &c4,
+                           const QBrush *fill)
+{
+    if (w < 2 || h < 2)                        // can't do anything with that
+        return;
+    QPen oldPen = p->pen();
+    QPoint a[3] = { QPoint(x, y+h-2), QPoint(x, y), QPoint(x+w-2, y) };
+    p->setPen(c1);
+    p->drawPolyline(a, 3);
+    QPoint b[3] = { QPoint(x, y+h-1), QPoint(x+w-1, y+h-1), QPoint(x+w-1, y) };
+    p->setPen(c2);
+    p->drawPolyline(b, 3);
+    if (w > 4 && h > 4) {
+        QPoint c[3] = { QPoint(x+1, y+h-3), QPoint(x+1, y+1), QPoint(x+w-3, y+1) };
+        p->setPen(c3);
+        p->drawPolyline(c, 3);
+        QPoint d[3] = { QPoint(x+1, y+h-2), QPoint(x+w-2, y+h-2), QPoint(x+w-2, y+1) };
+        p->setPen(c4);
+        p->drawPolyline(d, 3);
+        if (fill)
+            p->fillRect(QRect(x+2, y+2, w-4, h-4), *fill);
+    }
+    p->setPen(oldPen);
+}
+
+
+/*!
+    \fn void qDrawWinButton(QPainter *painter, int x, int y, int width, int height,
+                     const QPalette &palette, bool sunken,
+                     const QBrush *fill)
+    \relates <qdrawutil.h>
+
+    Draws the Windows-style button specified by the given point (\a x,
+    \a y}, \a width and \a height using the provided \a painter with a
+    line width of 2 pixels. The button's interior is filled with the
+    \a{fill} brush unless \a fill is 0.
+
+    The given \a palette specifies the shading colors (\l
+    {QPalette::light()}{light}, \l {QPalette::dark()}{dark} and \l
+    {QPalette::mid()}{middle} colors).
+
+    The button appears sunken if \a sunken is true, otherwise raised.
+
+    \warning This function does not look at QWidget::style() or
+    QApplication::style()-> Use the drawing functions in QStyle to make
+    widgets that follow the current GUI style.
+
+    \sa qDrawWinPanel(), QStyle
+*/
+
+void qDrawWinButton(QPainter *p, int x, int y, int w, int h,
+                     const QPalette &pal, bool sunken,
+                     const QBrush *fill)
+{
+    if (sunken)
+        qDrawWinShades(p, x, y, w, h,
+                       pal.shadow().color(), pal.light().color(), pal.dark().color(),
+                       pal.button().color(), fill);
+    else
+        qDrawWinShades(p, x, y, w, h,
+                       pal.light().color(), pal.shadow().color(), pal.button().color(),
+                       pal.dark().color(), fill);
+}
+
+/*!
+    \fn void qDrawWinPanel(QPainter *painter, int x, int y, int width, int height,
+                    const QPalette &palette, bool        sunken,
+                    const QBrush *fill)
+    \relates <qdrawutil.h>
+
+    Draws the Windows-style panel specified by the given point(\a x,
+    \a y), \a width and \a height using the provided \a painter with a
+    line width of 2 pixels. The button's interior is filled with the
+    \a fill brush unless \a fill is 0.
+
+    The given \a palette specifies the shading colors.  The panel
+    appears sunken if \a sunken is true, otherwise raised.
+
+    \warning This function does not look at QWidget::style() or
+    QApplication::style(). Use the drawing functions in QStyle to make
+    widgets that follow the current GUI style.
+
+    Alternatively you can use a QFrame widget and apply the
+    QFrame::setFrameStyle() function to display a shaded panel:
+
+    \snippet doc/src/snippets/code/src_gui_painting_qdrawutil.cpp 3
+
+    \sa qDrawShadePanel(), qDrawWinButton(), QStyle
+*/
+
+void qDrawWinPanel(QPainter *p, int x, int y, int w, int h,
+                    const QPalette &pal, bool        sunken,
+                    const QBrush *fill)
+{
+    if (sunken)
+        qDrawWinShades(p, x, y, w, h,
+                        pal.dark().color(), pal.light().color(), pal.shadow().color(),
+                       pal.midlight().color(), fill);
+    else
+        qDrawWinShades(p, x, y, w, h,
+                       pal.light().color(), pal.shadow().color(), pal.midlight().color(),
+                       pal.dark().color(), fill);
+}
+
+/*!
+    \fn void qDrawPlainRect(QPainter *painter, int x, int y, int width, int height, const QColor &lineColor,
+                     int lineWidth, const QBrush *fill)
+    \relates <qdrawutil.h>
+
+    Draws the plain rectangle beginning at (\a x, \a y) with the given
+    \a width and \a height, using the specified \a painter, \a lineColor
+    and \a lineWidth. The rectangle's interior is filled with the \a
+    fill brush unless \a fill is 0.
+
+    \warning This function does not look at QWidget::style() or
+    QApplication::style(). Use the drawing functions in QStyle to make
+    widgets that follow the current GUI style.
+
+    Alternatively you can use a QFrame widget and apply the
+    QFrame::setFrameStyle() function to display a plain rectangle:
+
+    \snippet doc/src/snippets/code/src_gui_painting_qdrawutil.cpp 4
+
+    \sa qDrawShadeRect(), QStyle
+*/
+
+void qDrawPlainRect(QPainter *p, int x, int y, int w, int h, const QColor &c,
+                     int lineWidth, const QBrush *fill)
+{
+    if (w == 0 || h == 0)
+        return;
+    if (!(w > 0 && h > 0 && lineWidth >= 0)) {
+        qWarning("qDrawPlainRect: Invalid parameters");
+    }
+    QPen   oldPen   = p->pen();
+    QBrush oldBrush = p->brush();
+    p->setPen(c);
+    p->setBrush(Qt::NoBrush);
+    for (int i=0; i<lineWidth; i++)
+        p->drawRect(x+i, y+i, w-i*2 - 1, h-i*2 - 1);
+    if (fill) {                                // fill with fill color
+        p->setPen(Qt::NoPen);
+        p->setBrush(*fill);
+        p->drawRect(x+lineWidth, y+lineWidth, w-lineWidth*2, h-lineWidth*2);
+    }
+    p->setPen(oldPen);
+    p->setBrush(oldBrush);
+}
+
+/*****************************************************************************
+  Overloaded functions.
+ *****************************************************************************/
+
+/*!
+    \fn void qDrawShadeLine(QPainter *painter, const QPoint &p1, const QPoint &p2,
+             const QPalette &palette, bool sunken, int lineWidth, int midLineWidth)
+    \relates <qdrawutil.h>
+    \overload
+
+    Draws a horizontal or vertical shaded line between \a p1 and \a p2
+    using the given \a painter.  Note that nothing is drawn if the line
+    between the points would be neither horizontal nor vertical.
+
+    The provided \a palette specifies the shading colors (\l
+    {QPalette::light()}{light}, \l {QPalette::dark()}{dark} and \l
+    {QPalette::mid()}{middle} colors).  The given \a lineWidth
+    specifies the line width for each of the lines; it is not the
+    total line width. The given \a midLineWidth specifies the width of
+    a middle line drawn in the QPalette::mid() color.
+
+    The line appears sunken if \a sunken is true, otherwise raised.
+
+    \warning This function does not look at QWidget::style() or
+    QApplication::style().  Use the drawing functions in QStyle to
+    make widgets that follow the current GUI style.
+
+
+    Alternatively you can use a QFrame widget and apply the
+    QFrame::setFrameStyle() function to display a shaded line:
+
+    \snippet doc/src/snippets/code/src_gui_painting_qdrawutil.cpp 5
+
+    \sa qDrawShadeRect(), qDrawShadePanel(), QStyle
+*/
+
+void qDrawShadeLine(QPainter *p, const QPoint &p1, const QPoint &p2,
+                     const QPalette &pal, bool sunken,
+                     int lineWidth, int midLineWidth)
+{
+    qDrawShadeLine(p, p1.x(), p1.y(), p2.x(), p2.y(), pal, sunken,
+                    lineWidth, midLineWidth);
+}
+
+/*!
+    \fn void qDrawShadeRect(QPainter *painter, const QRect &rect, const QPalette &palette,
+             bool sunken, int lineWidth, int midLineWidth, const QBrush *fill)
+    \relates <qdrawutil.h>
+    \overload
+
+    Draws the shaded rectangle specified by \a rect using the given \a painter.
+
+    The provide \a palette specifies the shading colors (\l
+    {QPalette::light()}{light}, \l {QPalette::dark()}{dark} and \l
+    {QPalette::mid()}{middle} colors.  The given \a lineWidth
+    specifies the line width for each of the lines; it is not the
+    total line width.  The \a midLineWidth specifies the width of a
+    middle line drawn in the QPalette::mid() color.  The rectangle's
+    interior is filled with the \a fill brush unless \a fill is 0.
+
+    The rectangle appears sunken if \a sunken is true, otherwise
+    raised.
+
+    \warning This function does not look at QWidget::style() or
+    QApplication::style(). Use the drawing functions in QStyle to make
+    widgets that follow the current GUI style.
+
+    Alternatively you can use a QFrame widget and apply the
+    QFrame::setFrameStyle() function to display a shaded rectangle:
+
+    \snippet doc/src/snippets/code/src_gui_painting_qdrawutil.cpp 6
+
+    \sa qDrawShadeLine(), qDrawShadePanel(), qDrawPlainRect(), QStyle
+*/
+
+void qDrawShadeRect(QPainter *p, const QRect &r,
+                     const QPalette &pal, bool sunken,
+                     int lineWidth, int midLineWidth,
+                     const QBrush *fill)
+{
+    qDrawShadeRect(p, r.x(), r.y(), r.width(), r.height(), pal, sunken,
+                    lineWidth, midLineWidth, fill);
+}
+
+/*!
+    \fn void qDrawShadePanel(QPainter *painter, const QRect &rect, const QPalette &palette,
+             bool sunken, int lineWidth, const QBrush *fill)
+    \relates <qdrawutil.h>
+    \overload
+
+    Draws the shaded panel at the rectangle specified by \a rect using the
+    given \a painter and the given \a lineWidth.
+
+    The given \a palette specifies the shading colors (\l
+    {QPalette::light()}{light}, \l {QPalette::dark()}{dark} and \l
+    {QPalette::mid()}{middle} colors).  The panel's interior is filled
+    with the \a fill brush unless \a fill is 0.
+
+    The panel appears sunken if \a sunken is true, otherwise raised.
+
+    \warning This function does not look at QWidget::style() or
+    QApplication::style(). Use the drawing functions in QStyle to make
+    widgets that follow the current GUI style.
+
+    Alternatively you can use a QFrame widget and apply the
+    QFrame::setFrameStyle() function to display a shaded panel:
+
+    \snippet doc/src/snippets/code/src_gui_painting_qdrawutil.cpp 7
+
+    \sa qDrawWinPanel(), qDrawShadeLine(), qDrawShadeRect(), QStyle
+*/
+
+void qDrawShadePanel(QPainter *p, const QRect &r,
+                      const QPalette &pal, bool sunken,
+                      int lineWidth, const QBrush *fill)
+{
+    qDrawShadePanel(p, r.x(), r.y(), r.width(), r.height(), pal, sunken,
+                     lineWidth, fill);
+}
+
+/*!
+    \fn void qDrawWinButton(QPainter *painter, const QRect &rect, const QPalette &palette,
+             bool sunken, const QBrush *fill)
+    \relates <qdrawutil.h>
+    \overload
+
+    Draws the Windows-style button at the rectangle specified by \a rect using
+    the given \a painter with a line width of 2 pixels. The button's interior
+    is filled with the \a{fill} brush unless \a fill is 0.
+
+    The given \a palette specifies the shading colors (\l
+    {QPalette::light()}{light}, \l {QPalette::dark()}{dark} and \l
+    {QPalette::mid()}{middle} colors).
+
+    The button appears sunken if \a sunken is true, otherwise raised.
+
+    \warning This function does not look at QWidget::style() or
+    QApplication::style()-> Use the drawing functions in QStyle to make
+    widgets that follow the current GUI style.
+
+    \sa qDrawWinPanel(), QStyle
+*/
+
+void qDrawWinButton(QPainter *p, const QRect &r,
+                     const QPalette &pal, bool sunken, const QBrush *fill)
+{
+    qDrawWinButton(p, r.x(), r.y(), r.width(), r.height(), pal, sunken, fill);
+}
+
+/*!
+    \fn void qDrawWinPanel(QPainter *painter, const QRect &rect, const QPalette &palette,
+             bool sunken, const QBrush *fill)
+    \overload
+
+    Draws the Windows-style panel at the rectangle specified by \a rect using
+    the given \a painter with a line width of 2 pixels. The button's interior
+    is filled with the \a fill brush unless \a fill is 0.
+
+    The given \a palette specifies the shading colors.  The panel
+    appears sunken if \a sunken is true, otherwise raised.
+
+    \warning This function does not look at QWidget::style() or
+    QApplication::style(). Use the drawing functions in QStyle to make
+    widgets that follow the current GUI style.
+
+    Alternatively you can use a QFrame widget and apply the
+    QFrame::setFrameStyle() function to display a shaded panel:
+
+    \snippet doc/src/snippets/code/src_gui_painting_qdrawutil.cpp 8
+
+    \sa qDrawShadePanel(), qDrawWinButton(), QStyle
+*/
+
+void qDrawWinPanel(QPainter *p, const QRect &r,
+                    const QPalette &pal, bool sunken, const QBrush *fill)
+{
+    qDrawWinPanel(p, r.x(), r.y(), r.width(), r.height(), pal, sunken, fill);
+}
+
+/*!
+    \fn void qDrawPlainRect(QPainter *painter, const QRect &rect, const QColor &lineColor, int lineWidth, const QBrush *fill)
+    \relates <qdrawutil.h>
+    \overload
+
+    Draws the plain rectangle specified by \a rect using the given \a painter,
+    \a lineColor and \a lineWidth. The rectangle's interior is filled with the
+    \a fill brush unless \a fill is 0.
+
+    \warning This function does not look at QWidget::style() or
+    QApplication::style(). Use the drawing functions in QStyle to make
+    widgets that follow the current GUI style.
+
+    Alternatively you can use a QFrame widget and apply the
+    QFrame::setFrameStyle() function to display a plain rectangle:
+
+    \snippet doc/src/snippets/code/src_gui_painting_qdrawutil.cpp 9
+
+    \sa qDrawShadeRect(), QStyle
+*/
+
+void qDrawPlainRect(QPainter *p, const QRect &r, const QColor &c,
+                     int lineWidth, const QBrush *fill)
+{
+    qDrawPlainRect(p, r.x(), r.y(), r.width(), r.height(), c,
+                    lineWidth, fill);
+}
+
+#ifdef QT3_SUPPORT
+static void qDrawWinArrow(QPainter *p, Qt::ArrowType type, bool down,
+                           int x, int y, int w, int h,
+                           const QPalette &pal, bool enabled)
+{
+    QPolygon a;                                // arrow polygon
+    switch (type) {
+    case Qt::UpArrow:
+        a.setPoints(7, -3,1, 3,1, -2,0, 2,0, -1,-1, 1,-1, 0,-2);
+        break;
+    case Qt::DownArrow:
+        a.setPoints(7, -3,-1, 3,-1, -2,0, 2,0, -1,1, 1,1, 0,2);
+        break;
+    case Qt::LeftArrow:
+        a.setPoints(7, 1,-3, 1,3, 0,-2, 0,2, -1,-1, -1,1, -2,0);
+        break;
+    case Qt::RightArrow:
+        a.setPoints(7, -1,-3, -1,3, 0,-2, 0,2, 1,-1, 1,1, 2,0);
+        break;
+    default:
+        break;
+    }
+    if (a.isEmpty())
+        return;
+
+    if (down) {
+        x++;
+        y++;
+    }
+
+    QPen savePen = p->pen();                        // save current pen
+    if (down)
+        p->setBrushOrigin(p->brushOrigin() + QPoint(1,1));
+    p->fillRect(x, y, w, h, pal.brush(QPalette::Button));
+    if (down)
+        p->setBrushOrigin(p->brushOrigin() - QPoint(1,1));
+    if (enabled) {
+        a.translate(x+w/2, y+h/2);
+        p->setPen(pal.foreground().color());
+        p->drawLine(a.at(0), a.at(1));
+        p->drawLine(a.at(2), a.at(2));
+        p->drawPoint(a[6]);
+    } else {
+        a.translate(x+w/2+1, y+h/2+1);
+        p->setPen(pal.light().color());
+        p->drawLine(a.at(0), a.at(1));
+        p->drawLine(a.at(2), a.at(2));
+        p->drawPoint(a[6]);
+        a.translate(-1, -1);
+        p->setPen(pal.mid().color());
+        p->drawLine(a.at(0), a.at(1));
+        p->drawLine(a.at(2), a.at(2));
+        p->drawPoint(a[6]);
+    }
+    p->setPen(savePen);                        // restore pen
+}
+#endif // QT3_SUPPORT
+
+#if defined(Q_CC_MSVC)
+#pragma warning(disable: 4244)
+#endif
+
+#ifdef QT3_SUPPORT
+#ifndef QT_NO_STYLE_MOTIF
+// motif arrows look the same whether they are used or not
+// is this correct?
+static void qDrawMotifArrow(QPainter *p, Qt::ArrowType type, bool down,
+                             int x, int y, int w, int h,
+                             const QPalette &pal, bool)
+{
+    QPolygon bFill;                                // fill polygon
+    QPolygon bTop;                                // top shadow.
+    QPolygon bBot;                                // bottom shadow.
+    QPolygon bLeft;                                // left shadow.
+    QTransform matrix;                            // xform matrix
+    bool vertical = type == Qt::UpArrow || type == Qt::DownArrow;
+    bool horizontal = !vertical;
+    int         dim = w < h ? w : h;
+    int         colspec = 0x0000;                        // color specification array
+
+    if (dim < 2)                                // too small arrow
+        return;
+
+    if (dim > 3) {
+        if (dim > 6)
+            bFill.resize(dim & 1 ? 3 : 4);
+        bTop.resize((dim/2)*2);
+        bBot.resize(dim & 1 ? dim + 1 : dim);
+        bLeft.resize(dim > 4 ? 4 : 2);
+        bLeft.putPoints(0, 2, 0,0, 0,dim-1);
+        if (dim > 4)
+            bLeft.putPoints(2, 2, 1,2, 1,dim-3);
+        bTop.putPoints(0, 4, 1,0, 1,1, 2,1, 3,1);
+        bBot.putPoints(0, 4, 1,dim-1, 1,dim-2, 2,dim-2, 3,dim-2);
+
+        for(int i=0; i<dim/2-2 ; i++) {
+            bTop.putPoints(i*2+4, 2, 2+i*2,2+i, 5+i*2, 2+i);
+            bBot.putPoints(i*2+4, 2, 2+i*2,dim-3-i, 5+i*2,dim-3-i);
+        }
+        if (dim & 1)                                // odd number size: extra line
+            bBot.putPoints(dim-1, 2, dim-3,dim/2, dim-1,dim/2);
+        if (dim > 6) {                        // dim>6: must fill interior
+            bFill.putPoints(0, 2, 1,dim-3, 1,2);
+            if (dim & 1)                        // if size is an odd number
+                bFill.setPoint(2, dim - 3, dim / 2);
+            else
+                bFill.putPoints(2, 2, dim-4,dim/2-1, dim-4,dim/2);
+        }
+    }
+    else {
+        if (dim == 3) {                        // 3x3 arrow pattern
+            bLeft.setPoints(4, 0,0, 0,2, 1,1, 1,1);
+            bTop .setPoints(2, 1,0, 1,0);
+            bBot .setPoints(2, 1,2, 2,1);
+        }
+        else {                                        // 2x2 arrow pattern
+            bLeft.setPoints(2, 0,0, 0,1);
+            bTop .setPoints(2, 1,0, 1,0);
+            bBot .setPoints(2, 1,1, 1,1);
+        }
+    }
+
+    if (type == Qt::UpArrow || type == Qt::LeftArrow) {
+        matrix.translate(x, y);
+        if (vertical) {
+            matrix.translate(0, h - 1);
+            matrix.rotate(-90);
+        } else {
+            matrix.translate(w - 1, h - 1);
+            matrix.rotate(180);
+        }
+        if (down)
+            colspec = horizontal ? 0x2334 : 0x2343;
+        else
+            colspec = horizontal ? 0x1443 : 0x1434;
+    }
+    else if (type == Qt::DownArrow || type == Qt::RightArrow) {
+        matrix.translate(x, y);
+        if (vertical) {
+            matrix.translate(w-1, 0);
+            matrix.rotate(90);
+        }
+        if (down)
+            colspec = horizontal ? 0x2443 : 0x2434;
+        else
+            colspec = horizontal ? 0x1334 : 0x1343;
+    }
+
+    const QColor *cols[5];
+    cols[0] = 0;
+    cols[1] = &pal.button().color();
+    cols[2] = &pal.mid().color();
+    cols[3] = &pal.light().color();
+    cols[4] = &pal.dark().color();
+#define CMID        *cols[(colspec>>12) & 0xf]
+#define CLEFT        *cols[(colspec>>8) & 0xf]
+#define CTOP        *cols[(colspec>>4) & 0xf]
+#define CBOT        *cols[colspec & 0xf]
+
+    QPen     savePen   = p->pen();                // save current pen
+    QBrush   saveBrush = p->brush();                // save current brush
+    QTransform wxm = p->transform();
+    QPen     pen(Qt::NoPen);
+    const QBrush &brush = pal.brush(QPalette::Button);
+
+    p->setPen(pen);
+    p->setBrush(brush);
+    p->setTransform(matrix, true);                // set transformation matrix
+    p->drawPolygon(bFill);                        // fill arrow
+    p->setBrush(Qt::NoBrush);                        // don't fill
+
+    p->setPen(CLEFT);
+    p->drawLines(bLeft);
+    p->setPen(CTOP);
+    p->drawLines(bTop);
+    p->setPen(CBOT);
+    p->drawLines(bBot);
+
+    p->setTransform(wxm);
+    p->setBrush(saveBrush);                        // restore brush
+    p->setPen(savePen);                        // restore pen
+
+#undef CMID
+#undef CLEFT
+#undef CTOP
+#undef CBOT
+}
+#endif // QT_NO_STYLE_MOTIF
+
+QRect qItemRect(QPainter *p, Qt::GUIStyle gs,
+                int x, int y, int w, int h,
+                int flags,
+                bool enabled,
+                const QPixmap *pixmap,
+                const QString& text, int len)
+{
+    QRect result;
+
+    if (pixmap) {
+        if ((flags & Qt::AlignVCenter) == Qt::AlignVCenter)
+            y += h/2 - pixmap->height()/2;
+        else if ((flags & Qt::AlignBottom) == Qt::AlignBottom)
+            y += h - pixmap->height();
+        if ((flags & Qt::AlignRight) == Qt::AlignRight)
+            x += w - pixmap->width();
+        else if ((flags & Qt::AlignHCenter) == Qt::AlignHCenter)
+            x += w/2 - pixmap->width()/2;
+        else if ((flags & Qt::AlignLeft) != Qt::AlignLeft && QApplication::isRightToLeft())
+            x += w - pixmap->width();
+        result = QRect(x, y, pixmap->width(), pixmap->height());
+    } else if (!text.isNull() && p) {
+        result = p->boundingRect(QRect(x, y, w, h), flags, text.left(len));
+        if (gs == Qt::WindowsStyle && !enabled) {
+            result.setWidth(result.width()+1);
+            result.setHeight(result.height()+1);
+        }
+    } else {
+        result = QRect(x, y, w, h);
+    }
+
+    return result;
+}
+
+void qDrawArrow(QPainter *p, Qt::ArrowType type, Qt::GUIStyle style, bool down,
+                 int x, int y, int w, int h,
+                 const QPalette &pal, bool enabled)
+{
+    switch (style) {
+        case Qt::WindowsStyle:
+            qDrawWinArrow(p, type, down, x, y, w, h, pal, enabled);
+            break;
+#ifndef QT_NO_STYLE_MOTIF
+        case Qt::MotifStyle:
+            qDrawMotifArrow(p, type, down, x, y, w, h, pal, enabled);
+            break;
+#endif
+        default:
+            qWarning("qDrawArrow: Requested unsupported GUI style");
+    }
+}
+
+void qDrawItem(QPainter *p, Qt::GUIStyle gs,
+                int x, int y, int w, int h,
+                int flags,
+                const QPalette &pal, bool enabled,
+                const QPixmap *pixmap,
+                const QString& text, int len , const QColor* penColor)
+{
+    p->setPen(penColor?*penColor:pal.foreground().color());
+    if (pixmap) {
+        QPixmap  pm(*pixmap);
+        bool clip = (flags & Qt::TextDontClip) == 0;
+        if (clip) {
+            if (pm.width() < w && pm.height() < h)
+                clip = false;
+            else
+                p->setClipRect(x, y, w, h);
+        }
+        if ((flags & Qt::AlignVCenter) == Qt::AlignVCenter)
+            y += h/2 - pm.height()/2;
+        else if ((flags & Qt::AlignBottom) == Qt::AlignBottom)
+            y += h - pm.height();
+        if ((flags & Qt::AlignRight) == Qt::AlignRight)
+            x += w - pm.width();
+        else if ((flags & Qt::AlignHCenter) == Qt::AlignHCenter)
+            x += w/2 - pm.width()/2;
+        else if (((flags & Qt::AlignLeft) != Qt::AlignLeft) && QApplication::isRightToLeft()) // Qt::AlignAuto && rightToLeft
+            x += w - pm.width();
+
+        if (!enabled) {
+            if (pm.hasAlphaChannel()) {                        // pixmap with a mask
+                pm = pm.mask();
+            } else if (pm.depth() == 1) {        // monochrome pixmap, no mask
+                ;
+#ifndef QT_NO_IMAGE_HEURISTIC_MASK
+            } else {                                // color pixmap, no mask
+                QString k = QLatin1Literal("$qt-drawitem")
+                              % HexString<qint64>(pm.cacheKey());
+
+                if (!QPixmapCache::find(k, pm)) {
+                    pm = pm.createHeuristicMask();
+                    pm.setMask((QBitmap&)pm);
+                    QPixmapCache::insert(k, pm);
+                }
+#endif
+            }
+            if (gs == Qt::WindowsStyle) {
+                p->setPen(pal.light().color());
+                p->drawPixmap(x+1, y+1, pm);
+                p->setPen(pal.text().color());
+            }
+        }
+        p->drawPixmap(x, y, pm);
+        if (clip)
+            p->setClipping(false);
+    } else if (!text.isNull()) {
+        if (gs == Qt::WindowsStyle && !enabled) {
+            p->setPen(pal.light().color());
+            p->drawText(x+1, y+1, w, h, flags, text.left(len));
+            p->setPen(pal.text().color());
+        }
+        p->drawText(x, y, w, h, flags, text.left(len));
+    }
+}
+
+#endif
+
+/*!
+    \class QTileRules
+    \since 4.6
+
+    Holds the rules used to draw a pixmap or image split into nine segments,
+    similar to \l{http://www.w3.org/TR/css3-background/}{CSS3 border-images}.
+
+    \sa Qt::TileRule, QMargins
+*/
+
+/*! \fn QTileRules::QTileRules(Qt::TileRule horizontalRule, Qt::TileRule verticalRule)
+  Constructs a QTileRules with the given \a horizontalRule and
+  \a verticalRule.
+ */
+
+/*! \fn QTileRules::QTileRules(Qt::TileRule rule)
+  Constructs a QTileRules with the given \a rule used for both
+  the horizontal rule and the vertical rule.
+ */
+
+/*!
+    \fn void qDrawBorderPixmap(QPainter *painter, const QRect &target, const QMargins &margins, const QPixmap &pixmap)
+    \relates <qdrawutil.h>
+    \since 4.6
+    \overload
+
+    \brief The qDrawBorderPixmap function is for drawing a pixmap into
+    the margins of a rectangle.
+
+    Draws the given \a pixmap into the given \a target rectangle, using the
+    given \a painter. The pixmap will be split into nine segments and drawn
+    according to the \a margins structure.
+*/
+
+typedef QVarLengthArray<QPainter::PixmapFragment, 16> QPixmapFragmentsArray;
+
+/*!
+    \since 4.6
+
+    Draws the indicated \a sourceRect rectangle from the given \a pixmap into
+    the given \a targetRect rectangle, using the given \a painter. The pixmap
+    will be split into nine segments according to the given \a targetMargins
+    and \a sourceMargins structures. Finally, the pixmap will be drawn
+    according to the given \a rules.
+
+    This function is used to draw a scaled pixmap, similar to
+    \l{http://www.w3.org/TR/css3-background/}{CSS3 border-images}
+
+    \sa Qt::TileRule, QTileRules, QMargins
+*/
+
+void qDrawBorderPixmap(QPainter *painter, const QRect &targetRect, const QMargins &targetMargins,
+                       const QPixmap &pixmap, const QRect &sourceRect,const QMargins &sourceMargins,
+                       const QTileRules &rules, QDrawBorderPixmap::DrawingHints hints)
+{
+    QPainter::PixmapFragment d;
+    d.opacity = 1.0;
+    d.rotation = 0.0;
+
+    QPixmapFragmentsArray opaqueData;
+    QPixmapFragmentsArray translucentData;
+
+    // source center
+    const int sourceCenterTop = sourceRect.top() + sourceMargins.top();
+    const int sourceCenterLeft = sourceRect.left() + sourceMargins.left();
+    const int sourceCenterBottom = sourceRect.bottom() - sourceMargins.bottom() + 1;
+    const int sourceCenterRight = sourceRect.right() - sourceMargins.right() + 1;
+    const int sourceCenterWidth = sourceCenterRight - sourceCenterLeft;
+    const int sourceCenterHeight = sourceCenterBottom - sourceCenterTop;
+    // target center
+    const int targetCenterTop = targetRect.top() + targetMargins.top();
+    const int targetCenterLeft = targetRect.left() + targetMargins.left();
+    const int targetCenterBottom = targetRect.bottom() - targetMargins.bottom() + 1;
+    const int targetCenterRight = targetRect.right() - targetMargins.right() + 1;
+    const int targetCenterWidth = targetCenterRight - targetCenterLeft;
+    const int targetCenterHeight = targetCenterBottom - targetCenterTop;
+
+    QVarLengthArray<qreal, 16> xTarget; // x-coordinates of target rectangles
+    QVarLengthArray<qreal, 16> yTarget; // y-coordinates of target rectangles
+
+    int columns = 3;
+    int rows = 3;
+    if (rules.horizontal != Qt::StretchTile && sourceCenterWidth != 0)
+        columns = qMax(3, 2 + qCeil(targetCenterWidth / qreal(sourceCenterWidth)));
+    if (rules.vertical != Qt::StretchTile && sourceCenterHeight != 0)
+        rows = qMax(3, 2 + qCeil(targetCenterHeight / qreal(sourceCenterHeight)));
+
+    xTarget.resize(columns + 1);
+    yTarget.resize(rows + 1);
+
+    bool oldAA = painter->testRenderHint(QPainter::Antialiasing);
+    if (painter->paintEngine()->type() != QPaintEngine::OpenGL
+        && painter->paintEngine()->type() != QPaintEngine::OpenGL2
+        && oldAA && painter->combinedTransform().type() != QTransform::TxNone) {
+        painter->setRenderHint(QPainter::Antialiasing, false);
+    }
+
+    xTarget[0] = targetRect.left();
+    xTarget[1] = targetCenterLeft;
+    xTarget[columns - 1] = targetCenterRight;
+    xTarget[columns] = targetRect.left() + targetRect.width();
+
+    yTarget[0] = targetRect.top();
+    yTarget[1] = targetCenterTop;
+    yTarget[rows - 1] = targetCenterBottom;
+    yTarget[rows] = targetRect.top() + targetRect.height();
+
+    qreal dx = targetCenterWidth;
+    qreal dy = targetCenterHeight;
+
+    switch (rules.horizontal) {
+    case Qt::StretchTile:
+        dx = targetCenterWidth;
+        break;
+    case Qt::RepeatTile:
+        dx = sourceCenterWidth;
+        break;
+    case Qt::RoundTile:
+        dx = targetCenterWidth / qreal(columns - 2);
+        break;
+    }
+
+    for (int i = 2; i < columns - 1; ++i)
+        xTarget[i] = xTarget[i - 1] + dx;
+
+    switch (rules.vertical) {
+    case Qt::StretchTile:
+        dy = targetCenterHeight;
+        break;
+    case Qt::RepeatTile:
+        dy = sourceCenterHeight;
+        break;
+    case Qt::RoundTile:
+        dy = targetCenterHeight / qreal(rows - 2);
+        break;
+    }
+
+    for (int i = 2; i < rows - 1; ++i)
+        yTarget[i] = yTarget[i - 1] + dy;
+
+    // corners
+    if (targetMargins.top() > 0 && targetMargins.left() > 0 && sourceMargins.top() > 0 && sourceMargins.left() > 0) { // top left
+        d.x = (0.5 * (xTarget[1] + xTarget[0]));
+        d.y = (0.5 * (yTarget[1] + yTarget[0]));
+        d.sourceLeft = sourceRect.left();
+        d.sourceTop = sourceRect.top();
+        d.width = sourceMargins.left();
+        d.height = sourceMargins.top();
+        d.scaleX = qreal(xTarget[1] - xTarget[0]) / d.width;
+        d.scaleY = qreal(yTarget[1] - yTarget[0]) / d.height;
+        if (hints & QDrawBorderPixmap::OpaqueTopLeft)
+            opaqueData.append(d);
+        else
+            translucentData.append(d);
+    }
+    if (targetMargins.top() > 0 && targetMargins.right() > 0 && sourceMargins.top() > 0 && sourceMargins.right() > 0) { // top right
+        d.x = (0.5 * (xTarget[columns] + xTarget[columns - 1]));
+        d.y = (0.5 * (yTarget[1] + yTarget[0]));
+        d.sourceLeft = sourceCenterRight;
+        d.sourceTop = sourceRect.top();
+        d.width = sourceMargins.right();
+        d.height = sourceMargins.top();
+        d.scaleX = qreal(xTarget[columns] - xTarget[columns - 1]) / d.width;
+        d.scaleY = qreal(yTarget[1] - yTarget[0]) / d.height;
+        if (hints & QDrawBorderPixmap::OpaqueTopRight)
+            opaqueData.append(d);
+        else
+            translucentData.append(d);
+    }
+    if (targetMargins.bottom() > 0 && targetMargins.left() > 0 && sourceMargins.bottom() > 0 && sourceMargins.left() > 0) { // bottom left
+        d.x = (0.5 * (xTarget[1] + xTarget[0]));
+        d.y =(0.5 * (yTarget[rows] + yTarget[rows - 1]));
+        d.sourceLeft = sourceRect.left();
+        d.sourceTop = sourceCenterBottom;
+        d.width = sourceMargins.left();
+        d.height = sourceMargins.bottom();
+        d.scaleX = qreal(xTarget[1] - xTarget[0]) / d.width;
+        d.scaleY = qreal(yTarget[rows] - yTarget[rows - 1]) / d.height;
+        if (hints & QDrawBorderPixmap::OpaqueBottomLeft)
+            opaqueData.append(d);
+        else
+            translucentData.append(d);
+    }
+    if (targetMargins.bottom() > 0 && targetMargins.right() > 0 && sourceMargins.bottom() > 0 && sourceMargins.right() > 0) { // bottom right
+        d.x = (0.5 * (xTarget[columns] + xTarget[columns - 1]));
+        d.y = (0.5 * (yTarget[rows] + yTarget[rows - 1]));
+        d.sourceLeft = sourceCenterRight;
+        d.sourceTop = sourceCenterBottom;
+        d.width = sourceMargins.right();
+        d.height = sourceMargins.bottom();
+        d.scaleX = qreal(xTarget[columns] - xTarget[columns - 1]) / d.width;
+        d.scaleY = qreal(yTarget[rows] - yTarget[rows - 1]) / d.height;
+        if (hints & QDrawBorderPixmap::OpaqueBottomRight)
+            opaqueData.append(d);
+        else
+            translucentData.append(d);
+    }
+
+    // horizontal edges
+    if (targetCenterWidth > 0 && sourceCenterWidth > 0) {
+        if (targetMargins.top() > 0 && sourceMargins.top() > 0) { // top
+            QPixmapFragmentsArray &data = hints & QDrawBorderPixmap::OpaqueTop ? opaqueData : translucentData;
+            d.sourceLeft = sourceCenterLeft;
+            d.sourceTop = sourceRect.top();
+            d.width = sourceCenterWidth;
+            d.height = sourceMargins.top();
+            d.y = (0.5 * (yTarget[1] + yTarget[0]));
+            d.scaleX = dx / d.width;
+            d.scaleY = qreal(yTarget[1] - yTarget[0]) / d.height;
+            for (int i = 1; i < columns - 1; ++i) {
+                d.x = (0.5 * (xTarget[i + 1] + xTarget[i]));
+                data.append(d);
+            }
+            if (rules.horizontal == Qt::RepeatTile)
+                data[data.size() - 1].width = ((xTarget[columns - 1] - xTarget[columns - 2]) / d.scaleX);
+        }
+        if (targetMargins.bottom() > 0 && sourceMargins.bottom() > 0) { // bottom
+            QPixmapFragmentsArray &data = hints & QDrawBorderPixmap::OpaqueBottom ? opaqueData : translucentData;
+            d.sourceLeft = sourceCenterLeft;
+            d.sourceTop = sourceCenterBottom;
+            d.width = sourceCenterWidth;
+            d.height = sourceMargins.bottom();
+            d.y = (0.5 * (yTarget[rows] + yTarget[rows - 1]));
+            d.scaleX = dx / d.width;
+            d.scaleY = qreal(yTarget[rows] - yTarget[rows - 1]) / d.height;
+            for (int i = 1; i < columns - 1; ++i) {
+                d.x = (0.5 * (xTarget[i + 1] + xTarget[i]));
+                data.append(d);
+            }
+            if (rules.horizontal == Qt::RepeatTile)
+                data[data.size() - 1].width = ((xTarget[columns - 1] - xTarget[columns - 2]) / d.scaleX);
+        }
+    }
+
+    // vertical edges
+    if (targetCenterHeight > 0 && sourceCenterHeight > 0) {
+        if (targetMargins.left() > 0 && sourceMargins.left() > 0) { // left
+            QPixmapFragmentsArray &data = hints & QDrawBorderPixmap::OpaqueLeft ? opaqueData : translucentData;
+            d.sourceLeft = sourceRect.left();
+            d.sourceTop = sourceCenterTop;
+            d.width = sourceMargins.left();
+            d.height = sourceCenterHeight;
+            d.x = (0.5 * (xTarget[1] + xTarget[0]));
+            d.scaleX = qreal(xTarget[1] - xTarget[0]) / d.width;
+            d.scaleY = dy / d.height;
+            for (int i = 1; i < rows - 1; ++i) {
+                d.y = (0.5 * (yTarget[i + 1] + yTarget[i]));
+                data.append(d);
+            }
+            if (rules.vertical == Qt::RepeatTile)
+                data[data.size() - 1].height = ((yTarget[rows - 1] - yTarget[rows - 2]) / d.scaleY);
+        }
+        if (targetMargins.right() > 0 && sourceMargins.right() > 0) { // right
+            QPixmapFragmentsArray &data = hints & QDrawBorderPixmap::OpaqueRight ? opaqueData : translucentData;
+            d.sourceLeft = sourceCenterRight;
+            d.sourceTop = sourceCenterTop;
+            d.width = sourceMargins.right();
+            d.height = sourceCenterHeight;
+            d.x = (0.5 * (xTarget[columns] + xTarget[columns - 1]));
+            d.scaleX = qreal(xTarget[columns] - xTarget[columns - 1]) / d.width;
+            d.scaleY = dy / d.height;
+            for (int i = 1; i < rows - 1; ++i) {
+                d.y = (0.5 * (yTarget[i + 1] + yTarget[i]));
+                data.append(d);
+            }
+            if (rules.vertical == Qt::RepeatTile)
+                data[data.size() - 1].height = ((yTarget[rows - 1] - yTarget[rows - 2]) / d.scaleY);
+        }
+    }
+
+    // center
+    if (targetCenterWidth > 0 && targetCenterHeight > 0 && sourceCenterWidth > 0 && sourceCenterHeight > 0) {
+        QPixmapFragmentsArray &data = hints & QDrawBorderPixmap::OpaqueCenter ? opaqueData : translucentData;
+        d.sourceLeft = sourceCenterLeft;
+        d.sourceTop = sourceCenterTop;
+        d.width = sourceCenterWidth;
+        d.height = sourceCenterHeight;
+        d.scaleX = dx / d.width;
+        d.scaleY = dy / d.height;
+
+        qreal repeatWidth = (xTarget[columns - 1] - xTarget[columns - 2]) / d.scaleX;
+        qreal repeatHeight = (yTarget[rows - 1] - yTarget[rows - 2]) / d.scaleY;
+
+        for (int j = 1; j < rows - 1; ++j) {
+            d.y = (0.5 * (yTarget[j + 1] + yTarget[j]));
+            for (int i = 1; i < columns - 1; ++i) {
+                d.x = (0.5 * (xTarget[i + 1] + xTarget[i]));
+                data.append(d);
+            }
+            if (rules.horizontal == Qt::RepeatTile)
+                data[data.size() - 1].width = repeatWidth;
+        }
+        if (rules.vertical == Qt::RepeatTile) {
+            for (int i = 1; i < columns - 1; ++i)
+                data[data.size() - i].height = repeatHeight;
+        }
+    }
+
+    if (opaqueData.size())
+        painter->drawPixmapFragments(opaqueData.data(), opaqueData.size(), pixmap, QPainter::OpaqueHint);
+    if (translucentData.size())
+        painter->drawPixmapFragments(translucentData.data(), translucentData.size(), pixmap);
+
+    if (oldAA)
+        painter->setRenderHint(QPainter::Antialiasing, true);
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qdrawutil.h b/src/gui/painting/qdrawutil.h
new file mode 100644
index 0000000000..20b558d411
--- /dev/null
+++ b/src/gui/painting/qdrawutil.h
@@ -0,0 +1,195 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QDRAWUTIL_H
+#define QDRAWUTIL_H
+
+#include <QtCore/qnamespace.h>
+#include <QtCore/qstring.h> // char*->QString conversion
+#include <QtCore/qmargins.h>
+#include <QtGui/qpixmap.h>
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+class QPainter;
+#ifndef QT3_SUPPORT
+class QColorGroup;
+#endif
+class QPalette;
+class QPoint;
+class QColor;
+class QBrush;
+class QRect;
+
+//
+// Standard shade drawing
+//
+
+Q_GUI_EXPORT void qDrawShadeLine(QPainter *p, int x1, int y1, int x2, int y2,
+                              const QPalette &pal, bool sunken = true,
+                              int lineWidth = 1, int midLineWidth = 0);
+
+Q_GUI_EXPORT void qDrawShadeLine(QPainter *p, const QPoint &p1, const QPoint &p2,
+                              const QPalette &pal, bool sunken = true,
+                              int lineWidth = 1, int midLineWidth = 0);
+
+Q_GUI_EXPORT void qDrawShadeRect(QPainter *p, int x, int y, int w, int h,
+                              const QPalette &pal, bool sunken = false,
+                              int lineWidth = 1, int midLineWidth = 0,
+                              const QBrush *fill = 0);
+
+Q_GUI_EXPORT void qDrawShadeRect(QPainter *p, const QRect &r,
+                              const QPalette &pal, bool sunken = false,
+                              int lineWidth = 1, int midLineWidth = 0,
+                              const QBrush *fill = 0);
+
+Q_GUI_EXPORT void qDrawShadePanel(QPainter *p, int x, int y, int w, int h,
+                               const QPalette &pal, bool sunken = false,
+                               int lineWidth = 1, const QBrush *fill = 0);
+
+Q_GUI_EXPORT void qDrawShadePanel(QPainter *p, const QRect &r,
+                               const QPalette &pal, bool sunken = false,
+                               int lineWidth = 1, const QBrush *fill = 0);
+
+Q_GUI_EXPORT void qDrawWinButton(QPainter *p, int x, int y, int w, int h,
+                              const QPalette &pal, bool sunken = false,
+                              const QBrush *fill = 0);
+
+Q_GUI_EXPORT void qDrawWinButton(QPainter *p, const QRect &r,
+                              const QPalette &pal, bool sunken = false,
+                              const QBrush *fill = 0);
+
+Q_GUI_EXPORT void qDrawWinPanel(QPainter *p, int x, int y, int w, int h,
+                              const QPalette &pal, bool sunken = false,
+                             const QBrush *fill = 0);
+
+Q_GUI_EXPORT void qDrawWinPanel(QPainter *p, const QRect &r,
+                              const QPalette &pal, bool sunken = false,
+                             const QBrush *fill = 0);
+
+Q_GUI_EXPORT void qDrawPlainRect(QPainter *p, int x, int y, int w, int h, const QColor &,
+                              int lineWidth = 1, const QBrush *fill = 0);
+
+Q_GUI_EXPORT void qDrawPlainRect(QPainter *p, const QRect &r, const QColor &,
+                              int lineWidth = 1, const QBrush *fill = 0);
+
+
+#ifdef QT3_SUPPORT
+//
+// Use QStyle::itemRect(), QStyle::drawItem() and QStyle::drawArrow() instead.
+//
+Q_GUI_EXPORT QT3_SUPPORT QRect qItemRect(QPainter *p, Qt::GUIStyle gs, int x, int y, int w, int h,
+                          int flags, bool enabled,
+                          const QPixmap *pixmap, const QString& text, int len=-1);
+
+Q_GUI_EXPORT QT3_SUPPORT void qDrawItem(QPainter *p, Qt::GUIStyle gs, int x, int y, int w, int h,
+                         int flags, const QPalette &pal, bool enabled,
+                         const QPixmap *pixmap, const QString& text,
+                         int len=-1, const QColor* penColor = 0);
+
+Q_GUI_EXPORT QT3_SUPPORT void qDrawArrow(QPainter *p, Qt::ArrowType type, Qt::GUIStyle style, bool down,
+                          int x, int y, int w, int h,
+                          const QPalette &pal, bool enabled);
+#endif
+
+struct QTileRules
+{
+    inline QTileRules(Qt::TileRule horizontalRule, Qt::TileRule verticalRule)
+            : horizontal(horizontalRule), vertical(verticalRule) {}
+    inline QTileRules(Qt::TileRule rule = Qt::StretchTile)
+            : horizontal(rule), vertical(rule) {}
+    Qt::TileRule horizontal;
+    Qt::TileRule vertical;
+};
+
+#ifndef Q_QDOC
+// For internal use only.
+namespace QDrawBorderPixmap
+{
+    enum DrawingHint
+    {
+        OpaqueTopLeft = 0x0001,
+        OpaqueTop = 0x0002,
+        OpaqueTopRight = 0x0004,
+        OpaqueLeft = 0x0008,
+        OpaqueCenter = 0x0010,
+        OpaqueRight = 0x0020,
+        OpaqueBottomLeft = 0x0040,
+        OpaqueBottom = 0x0080,
+        OpaqueBottomRight = 0x0100,
+        OpaqueCorners = OpaqueTopLeft | OpaqueTopRight | OpaqueBottomLeft | OpaqueBottomRight,
+        OpaqueEdges = OpaqueTop | OpaqueLeft | OpaqueRight | OpaqueBottom,
+        OpaqueFrame = OpaqueCorners | OpaqueEdges,
+        OpaqueAll = OpaqueCenter | OpaqueFrame
+    };
+
+    Q_DECLARE_FLAGS(DrawingHints, DrawingHint)
+}
+#endif
+
+Q_GUI_EXPORT void qDrawBorderPixmap(QPainter *painter,
+                                    const QRect &targetRect,
+                                    const QMargins &targetMargins,
+                                    const QPixmap &pixmap,
+                                    const QRect &sourceRect,
+                                    const QMargins &sourceMargins,
+                                    const QTileRules &rules = QTileRules()
+#ifndef Q_QDOC
+                                    , QDrawBorderPixmap::DrawingHints hints = 0
+#endif
+                                    );
+
+inline void qDrawBorderPixmap(QPainter *painter,
+                                           const QRect &target,
+                                           const QMargins &margins,
+                                           const QPixmap &pixmap)
+{
+    qDrawBorderPixmap(painter, target, margins, pixmap, pixmap.rect(), margins);
+}
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QDRAWUTIL_H
diff --git a/src/gui/painting/qemulationpaintengine.cpp b/src/gui/painting/qemulationpaintengine.cpp
new file mode 100644
index 0000000000..6fec3f3641
--- /dev/null
+++ b/src/gui/painting/qemulationpaintengine.cpp
@@ -0,0 +1,289 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <private/qemulationpaintengine_p.h>
+#include <private/qpainter_p.h>
+#include <private/qtextengine_p.h>
+#include <qdebug.h>
+
+QT_BEGIN_NAMESPACE
+
+QEmulationPaintEngine::QEmulationPaintEngine(QPaintEngineEx *engine)
+    : real_engine(engine)
+{
+    QPaintEngine::state = real_engine->state();
+}
+
+
+QPaintEngine::Type QEmulationPaintEngine::type() const
+{
+    return real_engine->type();
+}
+
+bool QEmulationPaintEngine::begin(QPaintDevice *)
+{
+    return true;
+}
+
+bool QEmulationPaintEngine::end()
+{
+    return true;
+}
+
+
+QPainterState *QEmulationPaintEngine::createState(QPainterState *orig) const
+{
+    return real_engine->createState(orig);
+}
+
+void QEmulationPaintEngine::fill(const QVectorPath &path, const QBrush &brush)
+{
+    QPainterState *s = state();
+
+    if (s->bgMode == Qt::OpaqueMode) {
+        Qt::BrushStyle style = brush.style();
+        if (style >= Qt::Dense1Pattern && style <= Qt::DiagCrossPattern)
+            real_engine->fill(path, s->bgBrush);
+    }
+
+    Qt::BrushStyle style = qbrush_style(brush);
+    if (style >= Qt::LinearGradientPattern && style <= Qt::ConicalGradientPattern) {
+        const QGradient *g = brush.gradient();
+
+        if (g->coordinateMode() > QGradient::LogicalMode) {
+            if (g->coordinateMode() == QGradient::StretchToDeviceMode) {
+                QBrush copy = brush;
+                QTransform mat = copy.transform();
+                mat.scale(real_engine->painter()->device()->width(), real_engine->painter()->device()->height());
+                copy.setTransform(mat);
+                real_engine->fill(path, copy);
+                return;
+            } else if (g->coordinateMode() == QGradient::ObjectBoundingMode) {
+                QBrush copy = brush;
+                QTransform mat = copy.transform();
+                QRectF r = path.controlPointRect();
+                mat.translate(r.x(), r.y());
+                mat.scale(r.width(), r.height());
+                copy.setTransform(mat);
+                real_engine->fill(path, copy);
+                return;
+            }
+        }
+    }
+
+    real_engine->fill(path, brush);
+}
+
+void QEmulationPaintEngine::stroke(const QVectorPath &path, const QPen &pen)
+{
+    QPainterState *s = state();
+
+    if (s->bgMode == Qt::OpaqueMode && pen.style() > Qt::SolidLine) {
+        QPen bgPen = pen;
+        bgPen.setBrush(s->bgBrush);
+        bgPen.setStyle(Qt::SolidLine);
+        real_engine->stroke(path, bgPen);
+    }
+
+    QBrush brush = pen.brush();
+    QPen copy = pen;
+    Qt::BrushStyle style = qbrush_style(brush);
+    if (style >= Qt::LinearGradientPattern && style <= Qt::ConicalGradientPattern) {
+        const QGradient *g = brush.gradient();
+
+        if (g->coordinateMode() > QGradient::LogicalMode) {
+            if (g->coordinateMode() == QGradient::StretchToDeviceMode) {
+                QTransform mat = brush.transform();
+                mat.scale(real_engine->painter()->device()->width(), real_engine->painter()->device()->height());
+                brush.setTransform(mat);
+                copy.setBrush(brush);
+                real_engine->stroke(path, copy);
+                return;
+            } else if (g->coordinateMode() == QGradient::ObjectBoundingMode) {
+                QTransform mat = brush.transform();
+                QRectF r = path.controlPointRect();
+                mat.translate(r.x(), r.y());
+                mat.scale(r.width(), r.height());
+                brush.setTransform(mat);
+                copy.setBrush(brush);
+                real_engine->stroke(path, copy);
+                return;
+            }
+        }
+    }
+
+    real_engine->stroke(path, pen);
+}
+
+void QEmulationPaintEngine::clip(const QVectorPath &path, Qt::ClipOperation op)
+{
+    real_engine->clip(path, op);
+}
+
+void QEmulationPaintEngine::drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr)
+{
+    if (state()->bgMode == Qt::OpaqueMode && pm.isQBitmap())
+        fillBGRect(r);
+    real_engine->drawPixmap(r, pm, sr);
+}
+
+void QEmulationPaintEngine::drawTextItem(const QPointF &p, const QTextItem &textItem)
+{
+    if (state()->bgMode == Qt::OpaqueMode) {
+        const QTextItemInt &ti = static_cast<const QTextItemInt &>(textItem);
+        QRectF rect(p.x(), p.y() - ti.ascent.toReal(), ti.width.toReal(), (ti.ascent + ti.descent + 1).toReal());
+        fillBGRect(rect);
+    }
+
+    QPainterState *s = state();
+    Qt::BrushStyle style = qbrush_style(s->pen.brush());
+    if (style >= Qt::LinearGradientPattern && style <= Qt::ConicalGradientPattern)
+    {
+        QPen savedPen = s->pen;
+        QGradient g = *s->pen.brush().gradient();
+
+        if (g.coordinateMode() > QGradient::LogicalMode) {
+            QTransform mat = s->pen.brush().transform();
+            if (g.coordinateMode() == QGradient::StretchToDeviceMode) {
+                mat.scale(real_engine->painter()->device()->width(), real_engine->painter()->device()->height());
+            } else if (g.coordinateMode() == QGradient::ObjectBoundingMode) {
+                const QTextItemInt &ti = static_cast<const QTextItemInt &>(textItem);
+                QRectF r(p.x(), p.y() - ti.ascent.toReal(), ti.width.toReal(), (ti.ascent + ti.descent + 1).toReal());
+                mat.translate(r.x(), r.y());
+                mat.scale(r.width(), r.height());
+            }
+            g.setCoordinateMode(QGradient::LogicalMode);
+            QBrush brush(g);
+            brush.setTransform(mat);
+            s->pen.setBrush(brush);
+            penChanged();
+            real_engine->drawTextItem(p, textItem);
+            s->pen = savedPen;
+            penChanged();
+            return;
+        }
+    }
+
+    real_engine->drawTextItem(p, textItem);
+}
+
+void QEmulationPaintEngine::drawStaticTextItem(QStaticTextItem *item)
+{
+    real_engine->drawStaticTextItem(item);
+}
+
+void QEmulationPaintEngine::drawTiledPixmap(const QRectF &r, const QPixmap &pixmap, const QPointF &s)
+{
+    if (state()->bgMode == Qt::OpaqueMode && pixmap.isQBitmap())
+        fillBGRect(r);
+    real_engine->drawTiledPixmap(r, pixmap, s);
+}
+
+void QEmulationPaintEngine::drawImage(const QRectF &r, const QImage &pm, const QRectF &sr, Qt::ImageConversionFlags flags)
+{
+    real_engine->drawImage(r, pm, sr, flags);
+}
+
+void QEmulationPaintEngine::clipEnabledChanged()
+{
+    real_engine->clipEnabledChanged();
+}
+
+void QEmulationPaintEngine::penChanged()
+{
+    real_engine->penChanged();
+}
+
+void QEmulationPaintEngine::brushChanged()
+{
+    real_engine->brushChanged();
+}
+
+void QEmulationPaintEngine::brushOriginChanged()
+{
+    real_engine->brushOriginChanged();
+}
+
+void QEmulationPaintEngine::opacityChanged()
+{
+    real_engine->opacityChanged();
+}
+
+void QEmulationPaintEngine::compositionModeChanged()
+{
+    real_engine->compositionModeChanged();
+}
+
+void QEmulationPaintEngine::renderHintsChanged()
+{
+    real_engine->renderHintsChanged();
+}
+
+void QEmulationPaintEngine::transformChanged()
+{
+    real_engine->transformChanged();
+}
+
+void QEmulationPaintEngine::setState(QPainterState *s)
+{
+    QPaintEngine::state = s;
+    real_engine->setState(s);
+}
+
+void QEmulationPaintEngine::beginNativePainting()
+{
+    real_engine->beginNativePainting();
+}
+
+void QEmulationPaintEngine::endNativePainting()
+{
+    real_engine->endNativePainting();
+}
+
+void QEmulationPaintEngine::fillBGRect(const QRectF &r)
+{
+    qreal pts[] = { r.x(), r.y(), r.x() + r.width(), r.y(),
+                    r.x() + r.width(), r.y() + r.height(), r.x(), r.y() + r.height() };
+    QVectorPath vp(pts, 4, 0, QVectorPath::RectangleHint);
+    real_engine->fill(vp, state()->bgBrush);
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qemulationpaintengine_p.h b/src/gui/painting/qemulationpaintengine_p.h
new file mode 100644
index 0000000000..20c399074d
--- /dev/null
+++ b/src/gui/painting/qemulationpaintengine_p.h
@@ -0,0 +1,113 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QEMULATIONPAINTENGINE_P_H
+#define QEMULATIONPAINTENGINE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <private/qpaintengineex_p.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+class QEmulationPaintEngine : public QPaintEngineEx
+{
+public:
+    QEmulationPaintEngine(QPaintEngineEx *engine);
+    
+    virtual bool begin(QPaintDevice *pdev);
+    virtual bool end();
+    
+    virtual Type type() const;
+    virtual QPainterState *createState(QPainterState *orig) const;
+
+    virtual void fill(const QVectorPath &path, const QBrush &brush);
+    virtual void stroke(const QVectorPath &path, const QPen &pen);
+    virtual void clip(const QVectorPath &path, Qt::ClipOperation op);
+
+    virtual void drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr);
+    virtual void drawTextItem(const QPointF &p, const QTextItem &textItem);
+    virtual void drawStaticTextItem(QStaticTextItem *item);
+    virtual void drawTiledPixmap(const QRectF &r, const QPixmap &pixmap, const QPointF &s);
+    virtual void drawImage(const QRectF &r, const QImage &pm, const QRectF &sr, Qt::ImageConversionFlags flags);
+    
+    virtual void clipEnabledChanged();
+    virtual void penChanged();
+    virtual void brushChanged();
+    virtual void brushOriginChanged();
+    virtual void opacityChanged();
+    virtual void compositionModeChanged();
+    virtual void renderHintsChanged();
+    virtual void transformChanged();
+
+    virtual void setState(QPainterState *s);
+
+    virtual void beginNativePainting();
+    virtual void endNativePainting();
+
+    virtual uint flags() const {return QPaintEngineEx::IsEmulationEngine | QPaintEngineEx::DoNotEmulate;}
+
+    inline QPainterState *state() { return (QPainterState *)QPaintEngine::state; }
+    inline const QPainterState *state() const { return (const QPainterState *)QPaintEngine::state; }
+
+    QPaintEngineEx *real_engine;
+private:
+    void fillBGRect(const QRectF &r);
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/gui/painting/qfixed_p.h b/src/gui/painting/qfixed_p.h
new file mode 100644
index 0000000000..cd96f9a0ef
--- /dev/null
+++ b/src/gui/painting/qfixed_p.h
@@ -0,0 +1,221 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QFIXED_P_H
+#define QFIXED_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of other Qt classes.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "QtCore/qdebug.h"
+#include "QtCore/qpoint.h"
+#include "QtCore/qsize.h"
+
+QT_BEGIN_NAMESPACE
+
+struct QFixed {
+public:
+    QFixed() : val(0) {}
+    QFixed(int i) : val(i<<6) {}
+    QFixed(long i) : val(i<<6) {}
+    QFixed &operator=(int i) { val = (i<<6); return *this; }
+    QFixed &operator=(long i) { val = (i<<6); return *this; }
+
+    static QFixed fromReal(qreal r) { QFixed f; f.val = (int)(r*qreal(64)); return f; }
+    static QFixed fromFixed(int fixed) { QFixed f; f.val = fixed; return f; }
+
+    inline int value() const { return val; }
+    inline void setValue(int value) { val = value; }
+
+    inline int toInt() const { return (((val)+32) & -64)>>6; }
+    inline qreal toReal() const { return ((qreal)val)/(qreal)64; }
+
+    inline int truncate() const { return val>>6; }
+    inline QFixed round() const { QFixed f; f.val = ((val)+32) & -64; return f; }
+    inline QFixed floor() const { QFixed f; f.val = (val) & -64; return f; }
+    inline QFixed ceil() const { QFixed f; f.val = (val+63) & -64; return f; }
+
+    inline QFixed operator+(int i) const { QFixed f; f.val = (val + (i<<6)); return f; }
+    inline QFixed operator+(uint i) const { QFixed f; f.val = (val + (i<<6)); return f; }
+    inline QFixed operator+(const QFixed &other) const { QFixed f; f.val = (val + other.val); return f; }
+    inline QFixed &operator+=(int i) { val += (i<<6); return *this; }
+    inline QFixed &operator+=(uint i) { val += (i<<6); return *this; }
+    inline QFixed &operator+=(const QFixed &other) { val += other.val; return *this; }
+    inline QFixed operator-(int i) const { QFixed f; f.val = (val - (i<<6)); return f; }
+    inline QFixed operator-(uint i) const { QFixed f; f.val = (val - (i<<6)); return f; }
+    inline QFixed operator-(const QFixed &other) const { QFixed f; f.val = (val - other.val); return f; }
+    inline QFixed &operator-=(int i) { val -= (i<<6); return *this; }
+    inline QFixed &operator-=(uint i) { val -= (i<<6); return *this; }
+    inline QFixed &operator-=(const QFixed &other) { val -= other.val; return *this; }
+    inline QFixed operator-() const { QFixed f; f.val = -val; return f; }
+
+    inline bool operator==(const QFixed &other) const { return val == other.val; }
+    inline bool operator!=(const QFixed &other) const { return val != other.val; }
+    inline bool operator<(const QFixed &other) const { return val < other.val; }
+    inline bool operator>(const QFixed &other) const { return val > other.val; }
+    inline bool operator<=(const QFixed &other) const { return val <= other.val; }
+    inline bool operator>=(const QFixed &other) const { return val >= other.val; }
+    inline bool operator!() const { return !val; }
+
+    inline QFixed &operator/=(int x) { val /= x; return *this; }
+    inline QFixed &operator/=(const QFixed &o) {
+        if (o.val == 0) {
+            val = 0x7FFFFFFFL;
+        } else {
+            bool neg = false;
+            qint64 a = val;
+            qint64 b = o.val;
+            if (a < 0) { a = -a; neg = true; }
+            if (b < 0) { b = -b; neg = !neg; }
+
+            int res = (int)(((a << 6) + (b >> 1)) / b);
+
+            val = (neg ? -res : res);
+        }
+        return *this;
+    }
+    inline QFixed operator/(int d) const { QFixed f; f.val = val/d; return f; }
+    inline QFixed operator/(QFixed b) const { QFixed f = *this; return (f /= b); }
+    inline QFixed operator>>(int d) const { QFixed f = *this; f.val >>= d; return f; }
+    inline QFixed &operator*=(int i) { val *= i; return *this; }
+    inline QFixed &operator*=(uint i) { val *= i; return *this; }
+    inline QFixed &operator*=(const QFixed &o) {
+        bool neg = false;
+        qint64 a = val;
+        qint64 b = o.val;
+        if (a < 0) { a = -a; neg = true; }
+        if (b < 0) { b = -b; neg = !neg; }
+
+        int res = (int)((a * b + 0x20L) >> 6);
+        val = neg ? -res : res;
+        return *this;
+    }
+    inline QFixed operator*(int i) const { QFixed f = *this; return (f *= i); }
+    inline QFixed operator*(uint i) const { QFixed f = *this; return (f *= i); }
+    inline QFixed operator*(const QFixed &o) const { QFixed f = *this; return (f *= o); }
+
+private:
+    QFixed(qreal i) : val((int)(i*qreal(64))) {}
+    QFixed &operator=(qreal i) { val = (int)(i*qreal(64)); return *this; }
+    inline QFixed operator+(qreal i) const { QFixed f; f.val = (val + (int)(i*qreal(64))); return f; }
+    inline QFixed &operator+=(qreal i) { val += (int)(i*64); return *this; }
+    inline QFixed operator-(qreal i) const { QFixed f; f.val = (val - (int)(i*qreal(64))); return f; }
+    inline QFixed &operator-=(qreal i) { val -= (int)(i*64); return *this; }
+    inline QFixed &operator/=(qreal r) { val = (int)(val/r); return *this; }
+    inline QFixed operator/(qreal d) const { QFixed f; f.val = (int)(val/d); return f; }
+    inline QFixed &operator*=(qreal d) { val = (int) (val*d); return *this; }
+    inline QFixed operator*(qreal d) const { QFixed f = *this; return (f *= d); }
+    int val;
+};
+Q_DECLARE_TYPEINFO(QFixed, Q_PRIMITIVE_TYPE);
+
+#define QFIXED_MAX (INT_MAX/256)
+
+inline int qRound(const QFixed &f) { return f.toInt(); }
+inline int qFloor(const QFixed &f) { return f.floor().truncate(); }
+
+inline QFixed operator*(int i, const QFixed &d) { return d*i; }
+inline QFixed operator+(int i, const QFixed &d) { return d+i; }
+inline QFixed operator-(int i, const QFixed &d) { return -(d-i); }
+inline QFixed operator*(uint i, const QFixed &d) { return d*i; }
+inline QFixed operator+(uint i, const QFixed &d) { return d+i; }
+inline QFixed operator-(uint i, const QFixed &d) { return -(d-i); }
+// inline QFixed operator*(qreal d, const QFixed &d2) { return d2*d; }
+
+inline bool operator==(const QFixed &f, int i) { return f.value() == (i<<6); }
+inline bool operator==(int i, const QFixed &f) { return f.value() == (i<<6); }
+inline bool operator!=(const QFixed &f, int i) { return f.value() != (i<<6); }
+inline bool operator!=(int i, const QFixed &f) { return f.value() != (i<<6); }
+inline bool operator<=(const QFixed &f, int i) { return f.value() <= (i<<6); }
+inline bool operator<=(int i, const QFixed &f) { return (i<<6) <= f.value(); }
+inline bool operator>=(const QFixed &f, int i) { return f.value() >= (i<<6); }
+inline bool operator>=(int i, const QFixed &f) { return (i<<6) >= f.value(); }
+inline bool operator<(const QFixed &f, int i) { return f.value() < (i<<6); }
+inline bool operator<(int i, const QFixed &f) { return (i<<6) < f.value(); }
+inline bool operator>(const QFixed &f, int i) { return f.value() > (i<<6); }
+inline bool operator>(int i, const QFixed &f) { return (i<<6) > f.value(); }
+
+#ifndef QT_NO_DEBUG_STREAM
+inline QDebug &operator<<(QDebug &dbg, const QFixed &f)
+{ return dbg << f.toReal(); }
+#endif
+
+struct QFixedPoint {
+    QFixed x;
+    QFixed y;
+    inline QFixedPoint() {}
+    inline QFixedPoint(const QFixed &_x, const QFixed &_y) : x(_x), y(_y) {}
+    QPointF toPointF() const { return QPointF(x.toReal(), y.toReal()); }
+    static QFixedPoint fromPointF(const QPointF &p) {
+        return QFixedPoint(QFixed::fromReal(p.x()), QFixed::fromReal(p.y()));
+    }
+};
+Q_DECLARE_TYPEINFO(QFixedPoint, Q_PRIMITIVE_TYPE);
+
+inline QFixedPoint operator-(const QFixedPoint &p1, const QFixedPoint &p2)
+{ return QFixedPoint(p1.x - p2.x, p1.y - p2.y); }
+inline QFixedPoint operator+(const QFixedPoint &p1, const QFixedPoint &p2)
+{ return QFixedPoint(p1.x + p2.x, p1.y + p2.y); }
+
+struct QFixedSize {
+    QFixed width;
+    QFixed height;
+    QSizeF toSizeF() const { return QSizeF(width.toReal(), height.toReal()); }
+    static QFixedSize fromSizeF(const QSizeF &s) {
+        QFixedSize size;
+        size.width = QFixed::fromReal(s.width());
+        size.height = QFixed::fromReal(s.height());
+        return size;
+    }
+};
+Q_DECLARE_TYPEINFO(QFixedSize, Q_PRIMITIVE_TYPE);
+
+QT_END_NAMESPACE
+
+#endif // QTEXTENGINE_P_H
diff --git a/src/gui/painting/qgraphicssystem.cpp b/src/gui/painting/qgraphicssystem.cpp
new file mode 100644
index 0000000000..171ef46f98
--- /dev/null
+++ b/src/gui/painting/qgraphicssystem.cpp
@@ -0,0 +1,97 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qgraphicssystem_p.h"
+
+#ifdef Q_WS_X11
+# include <private/qpixmap_x11_p.h>
+#endif
+#if defined(Q_WS_WIN)
+# include <private/qpixmap_raster_p.h>
+#endif
+#ifdef Q_WS_MAC
+# include <private/qpixmap_mac_p.h>
+#endif
+#ifdef Q_WS_QPA
+# include <QtGui/private/qapplication_p.h>
+#endif
+#ifdef Q_OS_SYMBIAN
+# include <private/qpixmap_s60_p.h>
+#endif
+
+QT_BEGIN_NAMESPACE
+
+QGraphicsSystem::~QGraphicsSystem()
+{
+}
+
+QPixmapData *QGraphicsSystem::createDefaultPixmapData(QPixmapData::PixelType type)
+{
+#ifdef Q_WS_QWS
+    Q_UNUSED(type);
+#endif
+#if defined(Q_WS_X11)
+    return new QX11PixmapData(type);
+#elif defined(Q_WS_WIN)
+    return new QRasterPixmapData(type);
+#elif defined(Q_WS_MAC)
+    return new QMacPixmapData(type);
+#elif defined(Q_WS_QPA)
+    return QApplicationPrivate::platformIntegration()->createPixmapData(type);
+#elif defined(Q_OS_SYMBIAN)
+    return new QS60PixmapData(type);
+#elif !defined(Q_WS_QWS)
+#error QGraphicsSystem::createDefaultPixmapData() not implemented
+#endif
+    return 0;
+}
+
+QPixmapData *QGraphicsSystem::createPixmapData(QPixmapData *origin)
+{
+    return createPixmapData(origin->pixelType());
+}
+
+void QGraphicsSystem::releaseCachedResources()
+{
+    // Do nothing here
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qgraphicssystem_mac.cpp b/src/gui/painting/qgraphicssystem_mac.cpp
new file mode 100644
index 0000000000..4f0be1f86a
--- /dev/null
+++ b/src/gui/painting/qgraphicssystem_mac.cpp
@@ -0,0 +1,59 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qgraphicssystem_mac_p.h"
+
+#include <private/qpixmap_mac_p.h>
+#include <private/qwindowsurface_mac_p.h>
+
+QT_BEGIN_NAMESPACE
+
+QPixmapData *QCoreGraphicsSystem::createPixmapData(QPixmapData::PixelType type) const
+{
+    return new QMacPixmapData(type);
+}
+
+QWindowSurface *QCoreGraphicsSystem::createWindowSurface(QWidget *widget) const
+{
+    return new QMacWindowSurface(widget);
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qgraphicssystem_mac_p.h b/src/gui/painting/qgraphicssystem_mac_p.h
new file mode 100644
index 0000000000..4d2eae84d7
--- /dev/null
+++ b/src/gui/painting/qgraphicssystem_mac_p.h
@@ -0,0 +1,69 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QGRAPHICSSYSTEM_MAC_P_H
+#define QGRAPHICSSYSTEM_MAC_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of other Qt classes.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "private/qgraphicssystem_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class Q_GUI_EXPORT QCoreGraphicsSystem : public QGraphicsSystem
+{
+public:
+    QPixmapData *createPixmapData(QPixmapData::PixelType type) const;
+    QWindowSurface *createWindowSurface(QWidget *widget) const;
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/gui/painting/qgraphicssystem_p.h b/src/gui/painting/qgraphicssystem_p.h
new file mode 100644
index 0000000000..0f99a311a6
--- /dev/null
+++ b/src/gui/painting/qgraphicssystem_p.h
@@ -0,0 +1,85 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QGRAPHICSSYSTEM_P_H
+#define QGRAPHICSSYSTEM_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "private/qpixmapdata_p.h"
+#include "private/qwindowsurface_p.h"
+#include "private/qpaintengine_blitter_p.h"
+
+#include <qdebug.h>
+
+QT_BEGIN_NAMESPACE
+
+class QPixmapFilter;
+class QBlittable;
+
+class Q_GUI_EXPORT QGraphicsSystem
+{
+public:
+    virtual QPixmapData *createPixmapData(QPixmapData::PixelType type) const = 0;
+    virtual QPixmapData *createPixmapData(QPixmapData *origin);
+    virtual QWindowSurface *createWindowSurface(QWidget *widget) const = 0;
+
+    virtual ~QGraphicsSystem();
+
+    //### Remove this & change qpixmap.cpp & qbitmap.cpp once every platform is gaurenteed
+    //    to have a graphics system.
+    static QPixmapData *createDefaultPixmapData(QPixmapData::PixelType type);
+
+    virtual void releaseCachedResources();
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/gui/painting/qgraphicssystem_qws.cpp b/src/gui/painting/qgraphicssystem_qws.cpp
new file mode 100644
index 0000000000..40f9ad4839
--- /dev/null
+++ b/src/gui/painting/qgraphicssystem_qws.cpp
@@ -0,0 +1,62 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <qscreen_qws.h>
+#include "qgraphicssystem_qws_p.h"
+#include <private/qpixmap_raster_p.h>
+#include <private/qwindowsurface_qws_p.h>
+
+QT_BEGIN_NAMESPACE
+
+QPixmapData *QWSGraphicsSystem::createPixmapData(QPixmapData::PixelType type) const
+{
+    if (screen->pixmapDataFactory())
+        return screen->pixmapDataFactory()->create(type); //### For 4.4 compatibility
+    else
+        return new QRasterPixmapData(type);
+}
+
+QWindowSurface *QWSGraphicsSystem::createWindowSurface(QWidget *widget) const
+{
+    return screen->createSurface(widget);
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qgraphicssystem_qws_p.h b/src/gui/painting/qgraphicssystem_qws_p.h
new file mode 100644
index 0000000000..92b92628cd
--- /dev/null
+++ b/src/gui/painting/qgraphicssystem_qws_p.h
@@ -0,0 +1,79 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QGRAPHICSSYSTEM_QWS_P_H
+#define QGRAPHICSSYSTEM_QWS_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of other Qt classes.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qgraphicssystem_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class Q_GUI_EXPORT QWSGraphicsSystem : public QGraphicsSystem
+{
+public:
+
+    QWSGraphicsSystem()
+        : screen(QScreen::instance()) {}
+
+    QWSGraphicsSystem(QScreen* s)
+        : screen(s) {}
+
+    virtual QPixmapData *createPixmapData(QPixmapData::PixelType type) const;
+    QWindowSurface *createWindowSurface(QWidget *widget) const;
+
+private:
+    QScreen* screen;
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/gui/painting/qgraphicssystem_raster.cpp b/src/gui/painting/qgraphicssystem_raster.cpp
new file mode 100644
index 0000000000..69bf588292
--- /dev/null
+++ b/src/gui/painting/qgraphicssystem_raster.cpp
@@ -0,0 +1,72 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qgraphicssystem_raster_p.h"
+
+#ifdef Q_OS_SYMBIAN
+#include "private/qpixmap_s60_p.h"
+#include "private/qwindowsurface_s60_p.h"
+#else
+#include "private/qpixmap_raster_p.h"
+#include "private/qwindowsurface_raster_p.h"
+#endif
+
+QT_BEGIN_NAMESPACE
+
+QPixmapData *QRasterGraphicsSystem::createPixmapData(QPixmapData::PixelType type) const
+{
+#ifdef Q_OS_SYMBIAN
+    return new QS60PixmapData(type);
+#else
+    return new QRasterPixmapData(type);
+#endif
+}
+
+QWindowSurface *QRasterGraphicsSystem::createWindowSurface(QWidget *widget) const
+{
+#ifdef Q_OS_SYMBIAN
+    return new QS60WindowSurface(widget);
+#else
+    return new QRasterWindowSurface(widget);
+#endif
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qgraphicssystem_raster_p.h b/src/gui/painting/qgraphicssystem_raster_p.h
new file mode 100644
index 0000000000..a66c56903f
--- /dev/null
+++ b/src/gui/painting/qgraphicssystem_raster_p.h
@@ -0,0 +1,69 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QGRAPHICSSYSTEM_RASTER_P_H
+#define QGRAPHICSSYSTEM_RASTER_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of other Qt classes.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qgraphicssystem_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QRasterGraphicsSystem : public QGraphicsSystem
+{
+public:
+    QPixmapData *createPixmapData(QPixmapData::PixelType type) const;
+    QWindowSurface *createWindowSurface(QWidget *widget) const;
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/gui/painting/qgraphicssystem_runtime.cpp b/src/gui/painting/qgraphicssystem_runtime.cpp
new file mode 100644
index 0000000000..d1dd7ef392
--- /dev/null
+++ b/src/gui/painting/qgraphicssystem_runtime.cpp
@@ -0,0 +1,426 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <private/qgraphicssystem_runtime_p.h>
+#include <private/qgraphicssystem_raster_p.h>
+#include <private/qgraphicssystemfactory_p.h>
+#include <private/qapplication_p.h>
+#include <private/qwidget_p.h>
+#include <QtCore/QDebug>
+#include <QtCore/QTimer>
+#include <QtGui/QBitmap>
+
+QT_BEGIN_NAMESPACE
+
+static int qt_pixmap_serial = 0;
+
+#define READBACK(f)                                         \
+    f                                                       \
+    readBackInfo();
+
+
+class QDeferredGraphicsSystemChange : public QObject
+{
+    Q_OBJECT
+
+public:
+    QDeferredGraphicsSystemChange(QRuntimeGraphicsSystem *gs, const QString& graphicsSystemName)
+    : m_graphicsSystem(gs), m_graphicsSystemName(graphicsSystemName)
+    {
+    }
+
+    void launch()
+    {
+        QTimer::singleShot(0, this, SLOT(doChange()));
+    }
+
+private slots:
+
+    void doChange()
+    {
+        m_graphicsSystem->setGraphicsSystem(m_graphicsSystemName);
+        deleteLater();
+    }
+
+private:
+
+    QRuntimeGraphicsSystem *m_graphicsSystem;
+    QString m_graphicsSystemName;
+};
+
+QRuntimePixmapData::QRuntimePixmapData(const QRuntimeGraphicsSystem *gs, PixelType type)
+        : QPixmapData(type, RuntimeClass), m_graphicsSystem(gs)
+{
+    setSerialNumber(++qt_pixmap_serial);
+}
+
+QRuntimePixmapData::~QRuntimePixmapData()
+{
+    if (QApplicationPrivate::graphics_system)
+        m_graphicsSystem->removePixmapData(this);
+    delete m_data;
+}
+
+void QRuntimePixmapData::readBackInfo()
+{
+    w = m_data->width();
+    h = m_data->height();
+    d = m_data->depth();
+    is_null = m_data->isNull();
+}
+
+
+QPixmapData *QRuntimePixmapData::createCompatiblePixmapData() const
+{
+    QRuntimePixmapData *rtData = new QRuntimePixmapData(m_graphicsSystem, pixelType());
+    rtData->m_data = m_data->createCompatiblePixmapData();
+    return rtData;
+}
+
+
+void QRuntimePixmapData::resize(int width, int height)
+{
+    READBACK(
+        m_data->resize(width, height);
+    )
+}
+
+
+void QRuntimePixmapData::fromImage(const QImage &image,
+                                   Qt::ImageConversionFlags flags)
+{
+    READBACK(
+        m_data->fromImage(image, flags);
+    )
+}
+
+
+bool QRuntimePixmapData::fromFile(const QString &filename, const char *format,
+                                  Qt::ImageConversionFlags flags)
+{
+    bool success(false);
+    READBACK(
+        success = m_data->fromFile(filename, format, flags);
+    )
+    return success;
+}
+
+bool QRuntimePixmapData::fromData(const uchar *buffer, uint len, const char *format,
+                                  Qt::ImageConversionFlags flags)
+{
+    bool success(false);
+    READBACK(
+        success = m_data->fromData(buffer, len, format, flags);
+    )
+    return success;
+}
+
+
+void QRuntimePixmapData::copy(const QPixmapData *data, const QRect &rect)
+{
+    if (data->runtimeData()) {
+        READBACK(
+            m_data->copy(data->runtimeData(), rect);
+        )
+    } else {
+        READBACK(
+            m_data->copy(data, rect);
+        )
+    }
+}
+
+bool QRuntimePixmapData::scroll(int dx, int dy, const QRect &rect)
+{
+    return m_data->scroll(dx, dy, rect);
+}
+
+
+int QRuntimePixmapData::metric(QPaintDevice::PaintDeviceMetric metric) const
+{
+    return m_data->metric(metric);
+}
+
+void QRuntimePixmapData::fill(const QColor &color)
+{
+    return m_data->fill(color);
+}
+
+QBitmap QRuntimePixmapData::mask() const
+{
+    return m_data->mask();
+}
+
+void QRuntimePixmapData::setMask(const QBitmap &mask)
+{
+    READBACK(
+        m_data->setMask(mask);
+    )
+}
+
+bool QRuntimePixmapData::hasAlphaChannel() const
+{
+    return m_data->hasAlphaChannel();
+}
+
+QPixmap QRuntimePixmapData::transformed(const QTransform &matrix,
+                                        Qt::TransformationMode mode) const
+{
+    return m_data->transformed(matrix, mode);
+}
+
+void QRuntimePixmapData::setAlphaChannel(const QPixmap &alphaChannel)
+{
+    READBACK(
+        m_data->setAlphaChannel(alphaChannel);
+    )
+}
+
+QPixmap QRuntimePixmapData::alphaChannel() const
+{
+    return m_data->alphaChannel();
+}
+
+QImage QRuntimePixmapData::toImage() const
+{
+    return m_data->toImage();
+}
+
+QPaintEngine* QRuntimePixmapData::paintEngine() const
+{
+    return m_data->paintEngine();
+}
+
+QImage* QRuntimePixmapData::buffer()
+{
+    return m_data->buffer();
+}
+
+#if defined(Q_OS_SYMBIAN)
+void* QRuntimePixmapData::toNativeType(NativeType type)
+{
+    return m_data->toNativeType(type);
+}
+
+void QRuntimePixmapData::fromNativeType(void *pixmap, NativeType type)
+{
+    m_data->fromNativeType(pixmap, type);
+    readBackInfo();
+}
+#endif
+
+QPixmapData* QRuntimePixmapData::runtimeData() const
+{
+    return m_data;
+}
+
+QRuntimeWindowSurface::QRuntimeWindowSurface(const QRuntimeGraphicsSystem *gs, QWidget *window)
+    : QWindowSurface(window), m_graphicsSystem(gs)
+{
+
+}
+
+QRuntimeWindowSurface::~QRuntimeWindowSurface()
+{
+    if (QApplicationPrivate::graphics_system)
+        m_graphicsSystem->removeWindowSurface(this);
+}
+
+QPaintDevice *QRuntimeWindowSurface::paintDevice()
+{
+    return m_windowSurface->paintDevice();
+}
+
+void QRuntimeWindowSurface::flush(QWidget *widget, const QRegion &region,
+                                  const QPoint &offset)
+{
+    m_windowSurface->flush(widget, region, offset);
+
+    int destroyPolicy = m_graphicsSystem->windowSurfaceDestroyPolicy();
+    if(m_pendingWindowSurface &&
+        destroyPolicy == QRuntimeGraphicsSystem::DestroyAfterFirstFlush) {
+#ifdef QT_DEBUG
+        qDebug() << "QRuntimeWindowSurface::flush() - destroy pending window surface";
+#endif
+        m_pendingWindowSurface.reset();
+    }
+}
+
+void QRuntimeWindowSurface::setGeometry(const QRect &rect)
+{
+    QWindowSurface::setGeometry(rect);
+    m_windowSurface->setGeometry(rect);
+}
+
+bool QRuntimeWindowSurface::scroll(const QRegion &area, int dx, int dy)
+{
+    return m_windowSurface->scroll(area, dx, dy);
+}
+
+void QRuntimeWindowSurface::beginPaint(const QRegion &rgn)
+{
+    m_windowSurface->beginPaint(rgn);
+}
+
+void QRuntimeWindowSurface::endPaint(const QRegion &rgn)
+{
+    m_windowSurface->endPaint(rgn);
+}
+
+QImage* QRuntimeWindowSurface::buffer(const QWidget *widget)
+{
+    return m_windowSurface->buffer(widget);
+}
+
+QPixmap QRuntimeWindowSurface::grabWidget(const QWidget *widget, const QRect& rectangle) const
+{
+    return m_windowSurface->grabWidget(widget, rectangle);
+}
+
+QPoint QRuntimeWindowSurface::offset(const QWidget *widget) const
+{
+    return m_windowSurface->offset(widget);
+}
+
+QWindowSurface::WindowSurfaceFeatures QRuntimeWindowSurface::features() const
+{
+    return m_windowSurface->features();
+}
+
+QRuntimeGraphicsSystem::QRuntimeGraphicsSystem()
+    : m_windowSurfaceDestroyPolicy(DestroyImmediately),
+      m_graphicsSystem(0)
+{
+    QApplicationPrivate::runtime_graphics_system = true;
+
+#ifdef QT_DEFAULT_RUNTIME_SYSTEM
+    m_graphicsSystemName = QLatin1String(QT_DEFAULT_RUNTIME_SYSTEM);
+    if (m_graphicsSystemName.isNull())
+#endif
+        m_graphicsSystemName = QLatin1String("raster");
+
+#ifdef Q_OS_SYMBIAN
+    m_windowSurfaceDestroyPolicy = DestroyAfterFirstFlush;
+#endif
+
+    m_graphicsSystem = QGraphicsSystemFactory::create(m_graphicsSystemName);
+
+    QApplicationPrivate::graphics_system_name = QLatin1String("runtime");
+}
+
+
+QPixmapData *QRuntimeGraphicsSystem::createPixmapData(QPixmapData::PixelType type) const
+{
+    Q_ASSERT(m_graphicsSystem);
+    QPixmapData *data = m_graphicsSystem->createPixmapData(type);
+
+    QRuntimePixmapData *rtData = new QRuntimePixmapData(this, type);
+    rtData->m_data = data;
+    m_pixmapDatas << rtData;
+
+    return rtData;
+}
+
+QWindowSurface *QRuntimeGraphicsSystem::createWindowSurface(QWidget *widget) const
+{
+    Q_ASSERT(m_graphicsSystem);
+    QRuntimeWindowSurface *rtSurface = new QRuntimeWindowSurface(this, widget);
+    rtSurface->m_windowSurface.reset(m_graphicsSystem->createWindowSurface(widget));
+    widget->setWindowSurface(rtSurface);
+    m_windowSurfaces << rtSurface;
+    return rtSurface;
+}
+
+void QRuntimeGraphicsSystem::setGraphicsSystem(const QString &name)
+{
+    if (m_graphicsSystemName == name)
+        return;
+#ifdef QT_DEBUG
+    qDebug() << "QRuntimeGraphicsSystem::setGraphicsSystem( " << name << " )";
+#endif
+    QGraphicsSystem *oldSystem = m_graphicsSystem;
+    m_graphicsSystem = QGraphicsSystemFactory::create(name);
+    m_graphicsSystemName = name;
+
+    Q_ASSERT(m_graphicsSystem);
+
+    m_pendingGraphicsSystemName = QString();
+
+    for (int i = 0; i < m_pixmapDatas.size(); ++i) {
+        QRuntimePixmapData *proxy = m_pixmapDatas.at(i);
+        QPixmapData *newData = m_graphicsSystem->createPixmapData(proxy->m_data);
+        newData->fromImage(proxy->m_data->toImage(), Qt::NoOpaqueDetection);
+        delete proxy->m_data;
+        proxy->m_data = newData;
+        proxy->readBackInfo();
+    }
+
+    for (int i = 0; i < m_windowSurfaces.size(); ++i) {
+        QRuntimeWindowSurface *proxy = m_windowSurfaces.at(i);
+        QWidget *widget = proxy->m_windowSurface->window();
+
+        if(m_windowSurfaceDestroyPolicy == DestroyAfterFirstFlush)
+            proxy->m_pendingWindowSurface.reset(proxy->m_windowSurface.take());
+
+        QWindowSurface *newWindowSurface = m_graphicsSystem->createWindowSurface(widget);
+        newWindowSurface->setGeometry(proxy->geometry());
+
+        proxy->m_windowSurface.reset(newWindowSurface);
+        qt_widget_private(widget)->invalidateBuffer(widget->rect());
+    }
+
+    delete oldSystem;
+}
+
+void QRuntimeGraphicsSystem::removePixmapData(QRuntimePixmapData *pixmapData) const
+{
+    int index = m_pixmapDatas.lastIndexOf(pixmapData);
+    m_pixmapDatas.removeAt(index);
+}
+
+void QRuntimeGraphicsSystem::removeWindowSurface(QRuntimeWindowSurface *windowSurface) const
+{
+    int index = m_windowSurfaces.lastIndexOf(windowSurface);
+    m_windowSurfaces.removeAt(index);
+}
+
+#include "qgraphicssystem_runtime.moc"
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qgraphicssystem_runtime_p.h b/src/gui/painting/qgraphicssystem_runtime_p.h
new file mode 100644
index 0000000000..26d3777ad9
--- /dev/null
+++ b/src/gui/painting/qgraphicssystem_runtime_p.h
@@ -0,0 +1,187 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QGRAPHICSSYSTEM_RUNTIME_P_H
+#define QGRAPHICSSYSTEM_RUNTIME_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of other Qt classes.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qgraphicssystem_p.h"
+
+#include <private/qpixmapdata_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QRuntimeGraphicsSystem;
+
+class Q_GUI_EXPORT QRuntimePixmapData : public QPixmapData {
+public:
+    QRuntimePixmapData(const QRuntimeGraphicsSystem *gs, PixelType type);
+    ~QRuntimePixmapData();
+
+    virtual QPixmapData *createCompatiblePixmapData() const;
+    virtual void resize(int width, int height);
+    virtual void fromImage(const QImage &image,
+                           Qt::ImageConversionFlags flags);
+
+    virtual bool fromFile(const QString &filename, const char *format,
+                          Qt::ImageConversionFlags flags);
+    virtual bool fromData(const uchar *buffer, uint len, const char *format,
+                          Qt::ImageConversionFlags flags);
+
+    virtual void copy(const QPixmapData *data, const QRect &rect);
+    virtual bool scroll(int dx, int dy, const QRect &rect);
+
+    virtual int metric(QPaintDevice::PaintDeviceMetric metric) const;
+    virtual void fill(const QColor &color);
+    virtual QBitmap mask() const;
+    virtual void setMask(const QBitmap &mask);
+    virtual bool hasAlphaChannel() const;
+    virtual QPixmap transformed(const QTransform &matrix,
+                                Qt::TransformationMode mode) const;
+    virtual void setAlphaChannel(const QPixmap &alphaChannel);
+    virtual QPixmap alphaChannel() const;
+    virtual QImage toImage() const;
+    virtual QPaintEngine *paintEngine() const;
+
+    virtual QImage *buffer();
+
+    void readBackInfo();
+
+    QPixmapData *m_data;
+
+#if defined(Q_OS_SYMBIAN)
+    void* toNativeType(NativeType type);
+    void fromNativeType(void* pixmap, NativeType type);
+#endif
+
+    virtual QPixmapData *runtimeData() const;
+
+private:
+    const QRuntimeGraphicsSystem *m_graphicsSystem;
+
+};
+
+class QRuntimeWindowSurface : public QWindowSurface {
+public:
+    QRuntimeWindowSurface(const QRuntimeGraphicsSystem *gs, QWidget *window);
+    ~QRuntimeWindowSurface();
+
+    virtual QPaintDevice *paintDevice();
+    virtual void flush(QWidget *widget, const QRegion &region,
+                       const QPoint &offset);
+    virtual void setGeometry(const QRect &rect);
+
+    virtual bool scroll(const QRegion &area, int dx, int dy);
+
+    virtual void beginPaint(const QRegion &);
+    virtual void endPaint(const QRegion &);
+
+    virtual QImage* buffer(const QWidget *widget);
+    virtual QPixmap grabWidget(const QWidget *widget, const QRect& rectangle = QRect()) const;
+
+    virtual QPoint offset(const QWidget *widget) const;
+
+    virtual WindowSurfaceFeatures features() const;
+
+    QScopedPointer<QWindowSurface> m_windowSurface;
+    QScopedPointer<QWindowSurface> m_pendingWindowSurface;
+
+private:
+    const QRuntimeGraphicsSystem *m_graphicsSystem;
+};
+
+class QRuntimeGraphicsSystem : public QGraphicsSystem
+{
+public:
+
+    enum WindowSurfaceDestroyPolicy
+    {
+        DestroyImmediately,
+        DestroyAfterFirstFlush
+    };
+
+public:
+    QRuntimeGraphicsSystem();
+
+    QPixmapData *createPixmapData(QPixmapData::PixelType type) const;
+    QWindowSurface *createWindowSurface(QWidget *widget) const;
+
+    void removePixmapData(QRuntimePixmapData *pixmapData) const;
+    void removeWindowSurface(QRuntimeWindowSurface *windowSurface) const;
+
+    void setGraphicsSystem(const QString &name);
+    QString graphicsSystemName() const { return m_graphicsSystemName; }
+
+    void setWindowSurfaceDestroyPolicy(WindowSurfaceDestroyPolicy policy)
+    {
+        m_windowSurfaceDestroyPolicy = policy;
+    }
+
+    int windowSurfaceDestroyPolicy() const { return m_windowSurfaceDestroyPolicy; }
+
+
+private:
+    int m_windowSurfaceDestroyPolicy;
+    QGraphicsSystem *m_graphicsSystem;
+    mutable QList<QRuntimePixmapData *> m_pixmapDatas;
+    mutable QList<QRuntimeWindowSurface *> m_windowSurfaces;
+    QString m_graphicsSystemName;
+
+    QString m_pendingGraphicsSystemName;
+
+    friend class QRuntimePixmapData;
+    friend class QRuntimeWindowSurface;
+    friend class QMeeGoGraphicsSystem;
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/gui/painting/qgraphicssystemfactory.cpp b/src/gui/painting/qgraphicssystemfactory.cpp
new file mode 100644
index 0000000000..62a60d77c0
--- /dev/null
+++ b/src/gui/painting/qgraphicssystemfactory.cpp
@@ -0,0 +1,123 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qgraphicssystemfactory_p.h"
+#include "qgraphicssystemplugin_p.h"
+#include "private/qfactoryloader_p.h"
+#include "qmutex.h"
+
+#include "qapplication.h"
+#include <private/qapplication_p.h>
+#include "qgraphicssystem_raster_p.h"
+#include "qgraphicssystem_runtime_p.h"
+#include "qdebug.h"
+
+QT_BEGIN_NAMESPACE
+
+#ifndef QT_NO_LIBRARY
+Q_GLOBAL_STATIC_WITH_ARGS(QFactoryLoader, loader,
+    (QGraphicsSystemFactoryInterface_iid, QLatin1String("/graphicssystems"), Qt::CaseInsensitive))
+#endif
+
+QGraphicsSystem *QGraphicsSystemFactory::create(const QString& key)
+{
+    QGraphicsSystem *ret = 0;
+    QString system = key.toLower();
+
+#if defined (QT_GRAPHICSSYSTEM_OPENGL)
+    if (system.isEmpty()) {
+        system = QLatin1String("opengl");
+    }
+#elif defined (QT_GRAPHICSSYSTEM_OPENVG)
+    if (system.isEmpty()) {
+        system = QLatin1String("openvg");
+    }
+#elif defined (QT_GRAPHICSSYSTEM_RUNTIME)
+    if (system.isEmpty()) {
+        system = QLatin1String("runtime");
+    }
+#elif defined (QT_GRAPHICSSYSTEM_RASTER) && !defined(Q_WS_WIN) && !defined(Q_OS_SYMBIAN) || defined(Q_WS_X11)
+    if (system.isEmpty()) {
+        system = QLatin1String("raster");
+    }
+#endif
+
+    QApplicationPrivate::graphics_system_name = system;
+    if (system == QLatin1String("raster"))
+        return new QRasterGraphicsSystem;
+    else if (system == QLatin1String("runtime"))
+        return new QRuntimeGraphicsSystem;
+    else if (system.isEmpty() || system == QLatin1String("native"))
+        return 0;
+
+#ifndef QT_NO_LIBRARY
+    if (!ret) {
+        if (QGraphicsSystemFactoryInterface *factory = qobject_cast<QGraphicsSystemFactoryInterface*>(loader()->instance(system)))
+            ret = factory->create(system);
+    }
+#endif
+
+    if (!ret)
+        qWarning() << "Unable to load graphicssystem" << system;
+
+    return ret;
+}
+
+/*!
+    Returns the list of valid keys, i.e. the keys this factory can
+    create styles for.
+
+    \sa create()
+*/
+QStringList QGraphicsSystemFactory::keys()
+{
+#ifndef QT_NO_LIBRARY
+    QStringList list = loader()->keys();
+#else
+    QStringList list;
+#endif
+    if (!list.contains(QLatin1String("Raster")))
+        list << QLatin1String("raster");
+    return list;
+}
+
+QT_END_NAMESPACE
+
diff --git a/src/gui/painting/qgraphicssystemfactory_p.h b/src/gui/painting/qgraphicssystemfactory_p.h
new file mode 100644
index 0000000000..8a2e2b14e0
--- /dev/null
+++ b/src/gui/painting/qgraphicssystemfactory_p.h
@@ -0,0 +1,78 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QGRAPHICSSYSTEMFACTORY_H
+#define QGRAPHICSSYSTEMFACTORY_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtCore/qstringlist.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+class QGraphicsSystem;
+
+class QGraphicsSystemFactory
+{
+public:
+    static QStringList keys();
+    static QGraphicsSystem *create(const QString&);
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QGRAPHICSSYSTEMFACTORY_H
+
diff --git a/src/gui/painting/qgraphicssystemplugin.cpp b/src/gui/painting/qgraphicssystemplugin.cpp
new file mode 100644
index 0000000000..8eb1278373
--- /dev/null
+++ b/src/gui/painting/qgraphicssystemplugin.cpp
@@ -0,0 +1,56 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qgraphicssystemplugin_p.h"
+#include "qgraphicssystem_p.h"
+
+QT_BEGIN_NAMESPACE
+
+QGraphicsSystemPlugin::QGraphicsSystemPlugin(QObject *parent)
+    : QObject(parent)
+{
+}
+
+QGraphicsSystemPlugin::~QGraphicsSystemPlugin()
+{
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qgraphicssystemplugin_p.h b/src/gui/painting/qgraphicssystemplugin_p.h
new file mode 100644
index 0000000000..1dafe82243
--- /dev/null
+++ b/src/gui/painting/qgraphicssystemplugin_p.h
@@ -0,0 +1,92 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QGRAPHICSSYSTEMPLUGIN_H
+#define QGRAPHICSSYSTEMPLUGIN_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtCore/qplugin.h>
+#include <QtCore/qfactoryinterface.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+class QGraphicsSystem;
+
+struct QGraphicsSystemFactoryInterface : public QFactoryInterface
+{
+    virtual QGraphicsSystem *create(const QString &key) = 0;
+};
+
+#define QGraphicsSystemFactoryInterface_iid "com.trolltech.Qt.QGraphicsSystemFactoryInterface"
+
+Q_DECLARE_INTERFACE(QGraphicsSystemFactoryInterface, QGraphicsSystemFactoryInterface_iid)
+
+class Q_GUI_EXPORT QGraphicsSystemPlugin : public QObject, public QGraphicsSystemFactoryInterface
+{
+    Q_OBJECT
+    Q_INTERFACES(QGraphicsSystemFactoryInterface:QFactoryInterface)
+public:
+    explicit QGraphicsSystemPlugin(QObject *parent = 0);
+    ~QGraphicsSystemPlugin();
+
+    virtual QStringList keys() const = 0;
+    virtual QGraphicsSystem *create(const QString &key) = 0;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QGRAPHICSSYSTEMEPLUGIN_H
diff --git a/src/gui/painting/qgrayraster.c b/src/gui/painting/qgrayraster.c
new file mode 100644
index 0000000000..e5e8ba4fa1
--- /dev/null
+++ b/src/gui/painting/qgrayraster.c
@@ -0,0 +1,1942 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/***************************************************************************/
+/*                                                                         */
+/*  qgrayraster.c, derived from ftgrays.c                                  */
+/*                                                                         */
+/*    A new `perfect' anti-aliasing renderer (body).                       */
+/*                                                                         */
+/*  Copyright 2000-2001, 2002, 2003 by                                     */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, ../../3rdparty/freetype/docs/FTL.TXT.  By continuing to use,  */
+/*  modify, or distribute this file you indicate that you have read        */
+/*  the license and understand and accept it fully.                        */
+/*                                                                         */
+/***************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* This file can be compiled without the rest of the FreeType engine, by */
+  /* defining the _STANDALONE_ macro when compiling it.  You also need to  */
+  /* put the files `ftgrays.h' and `ftimage.h' into the current            */
+  /* compilation directory.  Typically, you could do something like        */
+  /*                                                                       */
+  /* - copy `src/smooth/ftgrays.c' (this file) to your current directory   */
+  /*                                                                       */
+  /* - copy `include/freetype/ftimage.h' and `src/smooth/ftgrays.h' to the */
+  /*   same directory                                                      */
+  /*                                                                       */
+  /* - compile `ftgrays' with the _STANDALONE_ macro defined, as in        */
+  /*                                                                       */
+  /*     cc -c -D_STANDALONE_ ftgrays.c                                    */
+  /*                                                                       */
+  /* The renderer can be initialized with a call to                        */
+  /* `qt_ft_gray_raster.raster_new'; an anti-aliased bitmap can be generated  */
+  /* with a call to `qt_ft_gray_raster.raster_render'.                        */
+  /*                                                                       */
+  /* See the comments and documentation in the file `ftimage.h' for more   */
+  /* details on how the raster works.                                      */
+  /*                                                                       */
+  /*************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* This is a new anti-aliasing scan-converter for FreeType 2.  The       */
+  /* algorithm used here is _very_ different from the one in the standard  */
+  /* `ftraster' module.  Actually, `ftgrays' computes the _exact_          */
+  /* coverage of the outline on each pixel cell.                           */
+  /*                                                                       */
+  /* It is based on ideas that I initially found in Raph Levien's          */
+  /* excellent LibArt graphics library (see http://www.levien.com/libart   */
+  /* for more information, though the web pages do not tell anything       */
+  /* about the renderer; you'll have to dive into the source code to       */
+  /* understand how it works).                                             */
+  /*                                                                       */
+  /* Note, however, that this is a _very_ different implementation         */
+  /* compared to Raph's.  Coverage information is stored in a very         */
+  /* different way, and I don't use sorted vector paths.  Also, it doesn't */
+  /* use floating point values.                                            */
+  /*                                                                       */
+  /* This renderer has the following advantages:                           */
+  /*                                                                       */
+  /* - It doesn't need an intermediate bitmap.  Instead, one can supply a  */
+  /*   callback function that will be called by the renderer to draw gray  */
+  /*   spans on any target surface.  You can thus do direct composition on */
+  /*   any kind of bitmap, provided that you give the renderer the right   */
+  /*   callback.                                                           */
+  /*                                                                       */
+  /* - A perfect anti-aliaser, i.e., it computes the _exact_ coverage on   */
+  /*   each pixel cell.                                                    */
+  /*                                                                       */
+  /* - It performs a single pass on the outline (the `standard' FT2        */
+  /*   renderer makes two passes).                                         */
+  /*                                                                       */
+  /* - It can easily be modified to render to _any_ number of gray levels  */
+  /*   cheaply.                                                            */
+  /*                                                                       */
+  /* - For small (< 20) pixel sizes, it is faster than the standard        */
+  /*   renderer.                                                           */
+  /*                                                                       */
+  /*************************************************************************/
+
+/* experimental support for gamma correction within the rasterizer */
+#define xxxGRAYS_USE_GAMMA
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* The macro QT_FT_COMPONENT is used in trace mode.  It is an implicit      */
+  /* parameter of the QT_FT_TRACE() and QT_FT_ERROR() macros, used to print/log  */
+  /* messages during execution.                                            */
+  /*                                                                       */
+#undef  QT_FT_COMPONENT
+#define QT_FT_COMPONENT  trace_smooth
+
+
+#define ErrRaster_MemoryOverflow   -4
+
+#if defined(VXWORKS)
+#  include <vxWorksCommon.h>    /* needed for setjmp.h */
+#endif
+#include <string.h>             /* for qt_ft_memcpy() */
+#include <setjmp.h>
+#include <limits.h>
+
+#define QT_FT_UINT_MAX  UINT_MAX
+
+#define qt_ft_memset   memset
+
+#define qt_ft_setjmp   setjmp
+#define qt_ft_longjmp  longjmp
+#define qt_ft_jmp_buf  jmp_buf
+
+#define ErrRaster_Invalid_Mode      -2
+#define ErrRaster_Invalid_Outline   -1
+#define ErrRaster_Invalid_Argument  -3
+#define ErrRaster_Memory_Overflow   -4
+#define ErrRaster_OutOfMemory       -6
+
+#define QT_FT_BEGIN_HEADER
+#define QT_FT_END_HEADER
+
+#include <private/qrasterdefs_p.h>
+#include <private/qgrayraster_p.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+
+  /* This macro is used to indicate that a function parameter is unused. */
+  /* Its purpose is simply to reduce compiler warnings.  Note also that  */
+  /* simply defining it as `(void)x' doesn't avoid warnings with certain */
+  /* ANSI compilers (e.g. LCC).                                          */
+#define QT_FT_UNUSED( x )  (x) = (x)
+
+  /* Disable the tracing mechanism for simplicity -- developers can      */
+  /* activate it easily by redefining these two macros.                  */
+#ifndef QT_FT_ERROR
+#define QT_FT_ERROR( x )  do ; while ( 0 )     /* nothing */
+#endif
+
+#ifndef QT_FT_TRACE
+#define QT_FT_TRACE( x )  do ; while ( 0 )     /* nothing */
+#endif
+
+#ifndef QT_FT_MEM_SET
+#define QT_FT_MEM_SET( d, s, c )  qt_ft_memset( d, s, c )
+#endif
+
+#ifndef QT_FT_MEM_ZERO
+#define QT_FT_MEM_ZERO( dest, count )  QT_FT_MEM_SET( dest, 0, count )
+#endif
+
+  /* define this to dump debugging information */
+#define xxxDEBUG_GRAYS
+
+
+#define RAS_ARG   PWorker  worker
+#define RAS_ARG_  PWorker  worker,
+
+#define RAS_VAR   worker
+#define RAS_VAR_  worker,
+
+#define ras       (*worker)
+
+
+  /* must be at least 6 bits! */
+#define PIXEL_BITS  8
+
+#define ONE_PIXEL       ( 1L << PIXEL_BITS )
+#define PIXEL_MASK      ( -1L << PIXEL_BITS )
+#define TRUNC( x )      ( (TCoord)( (x) >> PIXEL_BITS ) )
+#define SUBPIXELS( x )  ( (TPos)(x) << PIXEL_BITS )
+#define FLOOR( x )      ( (x) & -ONE_PIXEL )
+#define CEILING( x )    ( ( (x) + ONE_PIXEL - 1 ) & -ONE_PIXEL )
+#define ROUND( x )      ( ( (x) + ONE_PIXEL / 2 ) & -ONE_PIXEL )
+
+#if PIXEL_BITS >= 6
+#define UPSCALE( x )    ( (x) << ( PIXEL_BITS - 6 ) )
+#define DOWNSCALE( x )  ( (x) >> ( PIXEL_BITS - 6 ) )
+#else
+#define UPSCALE( x )    ( (x) >> ( 6 - PIXEL_BITS ) )
+#define DOWNSCALE( x )  ( (x) << ( 6 - PIXEL_BITS ) )
+#endif
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*   TYPE DEFINITIONS                                                    */
+  /*                                                                       */
+
+  /* don't change the following types to QT_FT_Int or QT_FT_Pos, since we might */
+  /* need to define them to "float" or "double" when experimenting with   */
+  /* new algorithms                                                       */
+
+  typedef int   TCoord;   /* integer scanline/pixel coordinate */
+  typedef int   TPos;     /* sub-pixel coordinate              */
+
+  /* determine the type used to store cell areas.  This normally takes at */
+  /* least PIXEL_BITS*2 + 1 bits.  On 16-bit systems, we need to use      */
+  /* `long' instead of `int', otherwise bad things happen                 */
+
+#if PIXEL_BITS <= 7
+
+  typedef int  TArea;
+
+#else /* PIXEL_BITS >= 8 */
+
+  /* approximately determine the size of integers using an ANSI-C header */
+#if QT_FT_UINT_MAX == 0xFFFFU
+  typedef long  TArea;
+#else
+  typedef int   TArea;
+#endif
+
+#endif /* PIXEL_BITS >= 8 */
+
+
+  /* maximal number of gray spans in a call to the span callback */
+#define QT_FT_MAX_GRAY_SPANS  256
+
+
+  typedef struct TCell_*  PCell;
+
+  typedef struct  TCell_
+  {
+    int    x;
+    int    cover;
+    TArea  area;
+    PCell  next;
+
+  } TCell;
+
+
+  typedef struct  TWorker_
+  {
+    TCoord  ex, ey;
+    TPos    min_ex, max_ex;
+    TPos    min_ey, max_ey;
+    TPos    count_ex, count_ey;
+
+    TArea   area;
+    int     cover;
+    int     invalid;
+
+    PCell   cells;
+    int     max_cells;
+    int     num_cells;
+
+    TCoord  cx, cy;
+    TPos    x,  y;
+
+    TPos    last_ey;
+
+    QT_FT_Vector   bez_stack[32 * 3 + 1];
+    int         lev_stack[32];
+
+    QT_FT_Outline  outline;
+    QT_FT_Bitmap   target;
+    QT_FT_BBox     clip_box;
+
+    QT_FT_Span     gray_spans[QT_FT_MAX_GRAY_SPANS];
+    int         num_gray_spans;
+
+    QT_FT_Raster_Span_Func  render_span;
+    void*                render_span_data;
+
+    int  band_size;
+    int  band_shoot;
+    int  conic_level;
+    int  cubic_level;
+
+    qt_ft_jmp_buf  jump_buffer;
+
+    void*       buffer;
+    long        buffer_size;
+
+    PCell*     ycells;
+    int        ycount;
+
+    int        skip_spans;
+  } TWorker, *PWorker;
+
+
+  typedef struct TRaster_
+  {
+    void*    buffer;
+    long     buffer_size;
+    long     buffer_allocated_size;
+    int      band_size;
+    void*    memory;
+    PWorker  worker;
+
+  } TRaster, *PRaster;
+
+  int q_gray_rendered_spans(TRaster *raster)
+  {
+    if ( raster && raster->worker )
+      return raster->worker->skip_spans > 0 ? 0 : -raster->worker->skip_spans;
+    return 0;
+  }
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Initialize the cells table.                                           */
+  /*                                                                       */
+  static void
+  gray_init_cells( RAS_ARG_ void*  buffer,
+                   long            byte_size )
+  {
+    ras.buffer      = buffer;
+    ras.buffer_size = byte_size;
+
+    ras.ycells      = (PCell*) buffer;
+    ras.cells       = NULL;
+    ras.max_cells   = 0;
+    ras.num_cells   = 0;
+    ras.area        = 0;
+    ras.cover       = 0;
+    ras.invalid     = 1;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Compute the outline bounding box.                                     */
+  /*                                                                       */
+  static void
+  gray_compute_cbox( RAS_ARG )
+  {
+    QT_FT_Outline*  outline = &ras.outline;
+    QT_FT_Vector*   vec     = outline->points;
+    QT_FT_Vector*   limit   = vec + outline->n_points;
+
+
+    if ( outline->n_points <= 0 )
+    {
+      ras.min_ex = ras.max_ex = 0;
+      ras.min_ey = ras.max_ey = 0;
+      return;
+    }
+
+    ras.min_ex = ras.max_ex = vec->x;
+    ras.min_ey = ras.max_ey = vec->y;
+
+    vec++;
+
+    for ( ; vec < limit; vec++ )
+    {
+      TPos  x = vec->x;
+      TPos  y = vec->y;
+
+
+      if ( x < ras.min_ex ) ras.min_ex = x;
+      if ( x > ras.max_ex ) ras.max_ex = x;
+      if ( y < ras.min_ey ) ras.min_ey = y;
+      if ( y > ras.max_ey ) ras.max_ey = y;
+    }
+
+    /* truncate the bounding box to integer pixels */
+    ras.min_ex = ras.min_ex >> 6;
+    ras.min_ey = ras.min_ey >> 6;
+    ras.max_ex = ( ras.max_ex + 63 ) >> 6;
+    ras.max_ey = ( ras.max_ey + 63 ) >> 6;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Record the current cell in the table.                                 */
+  /*                                                                       */
+  static void
+  gray_record_cell( RAS_ARG )
+  {
+    PCell  *pcell, cell;
+    int     x = ras.ex;
+
+    if ( ras.invalid || !( ras.area | ras.cover ) )
+        return;
+
+    if ( x > ras.max_ex )
+      x = ras.max_ex;
+
+    pcell = &ras.ycells[ras.ey];
+
+    for (;;)
+    {
+      cell = *pcell;
+      if ( cell == NULL || cell->x > x )
+        break;
+
+      if ( cell->x == x ) {
+          cell->area  += ras.area;
+          cell->cover += ras.cover;
+          return;
+      }
+
+      pcell = &cell->next;
+    }
+
+    if ( ras.num_cells >= ras.max_cells )
+      qt_ft_longjmp( ras.jump_buffer, 1 );
+
+    cell        = ras.cells + ras.num_cells++;
+    cell->x     = x;
+    cell->area  = ras.area;
+    cell->cover = ras.cover;
+
+    cell->next  = *pcell;
+    *pcell      = cell;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Set the current cell to a new position.                               */
+  /*                                                                       */
+  static void
+  gray_set_cell( RAS_ARG_ TCoord  ex,
+                          TCoord  ey )
+  {
+    /* Move the cell pointer to a new position.  We set the `invalid'      */
+    /* flag to indicate that the cell isn't part of those we're interested */
+    /* in during the render phase.  This means that:                       */
+    /*                                                                     */
+    /* . the new vertical position must be within min_ey..max_ey-1.        */
+    /* . the new horizontal position must be strictly less than max_ex     */
+    /*                                                                     */
+    /* Note that if a cell is to the left of the clipping region, it is    */
+    /* actually set to the (min_ex-1) horizontal position.                 */
+
+    /* All cells that are on the left of the clipping region go to the */
+    /* min_ex - 1 horizontal position.                                 */
+    ey -= ras.min_ey;
+
+    if ( ex > ras.max_ex )
+      ex = ras.max_ex;
+
+    ex -= ras.min_ex;
+    if ( ex < 0 )
+      ex = -1;
+
+    /* are we moving to a different cell ? */
+    if ( ex != ras.ex || ey != ras.ey )
+    {
+      /* record the current one if it is valid */
+      if ( !ras.invalid )
+        gray_record_cell( RAS_VAR );
+
+      ras.area  = 0;
+      ras.cover = 0;
+    }
+
+    ras.ex      = ex;
+    ras.ey      = ey;
+    ras.invalid = ( (unsigned)ey >= (unsigned)ras.count_ey ||
+                              ex >= ras.count_ex           );
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Start a new contour at a given cell.                                  */
+  /*                                                                       */
+  static void
+  gray_start_cell( RAS_ARG_ TCoord  ex,
+                            TCoord  ey )
+  {
+    if ( ex > ras.max_ex )
+      ex = (TCoord)( ras.max_ex );
+
+    if ( ex < ras.min_ex )
+      ex = (TCoord)( ras.min_ex - 1 );
+
+    ras.area    = 0;
+    ras.cover   = 0;
+    ras.ex      = ex - ras.min_ex;
+    ras.ey      = ey - ras.min_ey;
+    ras.last_ey = SUBPIXELS( ey );
+    ras.invalid = 0;
+
+    gray_set_cell( RAS_VAR_ ex, ey );
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Render a scanline as one or more cells.                               */
+  /*                                                                       */
+  static void
+  gray_render_scanline( RAS_ARG_ TCoord  ey,
+                                 TPos    x1,
+                                 TCoord  y1,
+                                 TPos    x2,
+                                 TCoord  y2 )
+  {
+    TCoord  ex1, ex2, fx1, fx2, delta;
+    int     p, first, dx;
+    int     incr, lift, mod, rem;
+
+
+    dx = x2 - x1;
+
+    ex1 = TRUNC( x1 );
+    ex2 = TRUNC( x2 );
+    fx1 = (TCoord)( x1 - SUBPIXELS( ex1 ) );
+    fx2 = (TCoord)( x2 - SUBPIXELS( ex2 ) );
+
+    /* trivial case.  Happens often */
+    if ( y1 == y2 )
+    {
+      gray_set_cell( RAS_VAR_ ex2, ey );
+      return;
+    }
+
+    /* everything is located in a single cell.  That is easy! */
+    /*                                                        */
+    if ( ex1 == ex2 )
+    {
+      delta      = y2 - y1;
+      ras.area  += (TArea)( fx1 + fx2 ) * delta;
+      ras.cover += delta;
+      return;
+    }
+
+    /* ok, we'll have to render a run of adjacent cells on the same */
+    /* scanline...                                                  */
+    /*                                                              */
+    p     = ( ONE_PIXEL - fx1 ) * ( y2 - y1 );
+    first = ONE_PIXEL;
+    incr  = 1;
+
+    if ( dx < 0 )
+    {
+      p     = fx1 * ( y2 - y1 );
+      first = 0;
+      incr  = -1;
+      dx    = -dx;
+    }
+
+    delta = (TCoord)( p / dx );
+    mod   = (TCoord)( p % dx );
+    if ( mod < 0 )
+    {
+      delta--;
+      mod += (TCoord)dx;
+    }
+
+    ras.area  += (TArea)( fx1 + first ) * delta;
+    ras.cover += delta;
+
+    ex1 += incr;
+    gray_set_cell( RAS_VAR_ ex1, ey );
+    y1  += delta;
+
+    if ( ex1 != ex2 )
+    {
+      p    = ONE_PIXEL * ( y2 - y1 + delta );
+      lift = (TCoord)( p / dx );
+      rem  = (TCoord)( p % dx );
+      if ( rem < 0 )
+      {
+        lift--;
+        rem += (TCoord)dx;
+      }
+
+      mod -= (int)dx;
+
+      while ( ex1 != ex2 )
+      {
+        delta = lift;
+        mod  += rem;
+        if ( mod >= 0 )
+        {
+          mod -= (TCoord)dx;
+          delta++;
+        }
+
+        ras.area  += (TArea)ONE_PIXEL * delta;
+        ras.cover += delta;
+        y1        += delta;
+        ex1       += incr;
+        gray_set_cell( RAS_VAR_ ex1, ey );
+      }
+    }
+
+    delta      = y2 - y1;
+    ras.area  += (TArea)( fx2 + ONE_PIXEL - first ) * delta;
+    ras.cover += delta;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Render a given line as a series of scanlines.                         */
+  /*                                                                       */
+  static void
+  gray_render_line( RAS_ARG_ TPos  to_x,
+                             TPos  to_y )
+  {
+    TCoord  ey1, ey2, fy1, fy2;
+    TPos    dx, dy, x, x2;
+    int     p, first;
+    int     delta, rem, mod, lift, incr;
+
+
+    ey1 = TRUNC( ras.last_ey );
+    ey2 = TRUNC( to_y );     /* if (ey2 >= ras.max_ey) ey2 = ras.max_ey-1; */
+    fy1 = (TCoord)( ras.y - ras.last_ey );
+    fy2 = (TCoord)( to_y - SUBPIXELS( ey2 ) );
+
+    dx = to_x - ras.x;
+    dy = to_y - ras.y;
+
+    /* XXX: we should do something about the trivial case where dx == 0, */
+    /*      as it happens very often!                                    */
+
+    /* perform vertical clipping */
+    {
+      TCoord  min, max;
+
+
+      min = ey1;
+      max = ey2;
+      if ( ey1 > ey2 )
+      {
+        min = ey2;
+        max = ey1;
+      }
+      if ( min >= ras.max_ey || max < ras.min_ey )
+        goto End;
+    }
+
+    /* everything is on a single scanline */
+    if ( ey1 == ey2 )
+    {
+      gray_render_scanline( RAS_VAR_ ey1, ras.x, fy1, to_x, fy2 );
+      goto End;
+    }
+
+    /* vertical line - avoid calling gray_render_scanline */
+    incr = 1;
+
+    if ( dx == 0 )
+    {
+      TCoord  ex     = TRUNC( ras.x );
+      TCoord  two_fx = (TCoord)( ( ras.x - SUBPIXELS( ex ) ) << 1 );
+      TPos    area;
+
+
+      first = ONE_PIXEL;
+      if ( dy < 0 )
+      {
+        first = 0;
+        incr  = -1;
+      }
+
+      delta      = (int)( first - fy1 );
+      ras.area  += (TArea)two_fx * delta;
+      ras.cover += delta;
+      ey1       += incr;
+
+      gray_set_cell( &ras, ex, ey1 );
+
+      delta = (int)( first + first - ONE_PIXEL );
+      area  = (TArea)two_fx * delta;
+      while ( ey1 != ey2 )
+      {
+        ras.area  += area;
+        ras.cover += delta;
+        ey1       += incr;
+
+        gray_set_cell( &ras, ex, ey1 );
+      }
+
+      delta      = (int)( fy2 - ONE_PIXEL + first );
+      ras.area  += (TArea)two_fx * delta;
+      ras.cover += delta;
+
+      goto End;
+    }
+
+    /* ok, we have to render several scanlines */
+    p     = ( ONE_PIXEL - fy1 ) * dx;
+    first = ONE_PIXEL;
+    incr  = 1;
+
+    if ( dy < 0 )
+    {
+      p     = fy1 * dx;
+      first = 0;
+      incr  = -1;
+      dy    = -dy;
+    }
+
+    delta = (int)( p / dy );
+    mod   = (int)( p % dy );
+    if ( mod < 0 )
+    {
+      delta--;
+      mod += (TCoord)dy;
+    }
+
+    x = ras.x + delta;
+    gray_render_scanline( RAS_VAR_ ey1, ras.x, fy1, x, (TCoord)first );
+
+    ey1 += incr;
+    gray_set_cell( RAS_VAR_ TRUNC( x ), ey1 );
+
+    if ( ey1 != ey2 )
+    {
+      p     = ONE_PIXEL * dx;
+      lift  = (int)( p / dy );
+      rem   = (int)( p % dy );
+      if ( rem < 0 )
+      {
+        lift--;
+        rem += (int)dy;
+      }
+      mod -= (int)dy;
+
+      while ( ey1 != ey2 )
+      {
+        delta = lift;
+        mod  += rem;
+        if ( mod >= 0 )
+        {
+          mod -= (int)dy;
+          delta++;
+        }
+
+        x2 = x + delta;
+        gray_render_scanline( RAS_VAR_ ey1, x,
+                                       (TCoord)( ONE_PIXEL - first ), x2,
+                                       (TCoord)first );
+        x = x2;
+
+        ey1 += incr;
+        gray_set_cell( RAS_VAR_ TRUNC( x ), ey1 );
+      }
+    }
+
+    gray_render_scanline( RAS_VAR_ ey1, x,
+                                   (TCoord)( ONE_PIXEL - first ), to_x,
+                                   fy2 );
+
+  End:
+    ras.x       = to_x;
+    ras.y       = to_y;
+    ras.last_ey = SUBPIXELS( ey2 );
+  }
+
+
+  static void
+  gray_split_conic( QT_FT_Vector*  base )
+  {
+    TPos  a, b;
+
+
+    base[4].x = base[2].x;
+    b = base[1].x;
+    a = base[3].x = ( base[2].x + b ) / 2;
+    b = base[1].x = ( base[0].x + b ) / 2;
+    base[2].x = ( a + b ) / 2;
+
+    base[4].y = base[2].y;
+    b = base[1].y;
+    a = base[3].y = ( base[2].y + b ) / 2;
+    b = base[1].y = ( base[0].y + b ) / 2;
+    base[2].y = ( a + b ) / 2;
+  }
+
+
+  static void
+  gray_render_conic( RAS_ARG_ const QT_FT_Vector*  control,
+                              const QT_FT_Vector*  to )
+  {
+    TPos        dx, dy;
+    int         top, level;
+    int*        levels;
+    QT_FT_Vector*  arc;
+
+
+    dx = DOWNSCALE( ras.x ) + to->x - ( control->x << 1 );
+    if ( dx < 0 )
+      dx = -dx;
+    dy = DOWNSCALE( ras.y ) + to->y - ( control->y << 1 );
+    if ( dy < 0 )
+      dy = -dy;
+    if ( dx < dy )
+      dx = dy;
+
+    level = 1;
+    dx = dx / ras.conic_level;
+    while ( dx > 0 )
+    {
+      dx >>= 2;
+      level++;
+    }
+
+    /* a shortcut to speed things up */
+    if ( level <= 1 )
+    {
+      /* we compute the mid-point directly in order to avoid */
+      /* calling gray_split_conic()                          */
+      TPos  to_x, to_y, mid_x, mid_y;
+
+
+      to_x  = UPSCALE( to->x );
+      to_y  = UPSCALE( to->y );
+      mid_x = ( ras.x + to_x + 2 * UPSCALE( control->x ) ) / 4;
+      mid_y = ( ras.y + to_y + 2 * UPSCALE( control->y ) ) / 4;
+
+      gray_render_line( RAS_VAR_ mid_x, mid_y );
+      gray_render_line( RAS_VAR_ to_x, to_y );
+
+      return;
+    }
+
+    arc       = ras.bez_stack;
+    levels    = ras.lev_stack;
+    top       = 0;
+    levels[0] = level;
+
+    arc[0].x = UPSCALE( to->x );
+    arc[0].y = UPSCALE( to->y );
+    arc[1].x = UPSCALE( control->x );
+    arc[1].y = UPSCALE( control->y );
+    arc[2].x = ras.x;
+    arc[2].y = ras.y;
+
+    while ( top >= 0 )
+    {
+      level = levels[top];
+      if ( level > 1 )
+      {
+        /* check that the arc crosses the current band */
+        TPos  min, max, y;
+
+
+        min = max = arc[0].y;
+
+        y = arc[1].y;
+        if ( y < min ) min = y;
+        if ( y > max ) max = y;
+
+        y = arc[2].y;
+        if ( y < min ) min = y;
+        if ( y > max ) max = y;
+
+        if ( TRUNC( min ) >= ras.max_ey || TRUNC( max ) < ras.min_ey )
+          goto Draw;
+
+        gray_split_conic( arc );
+        arc += 2;
+        top++;
+        levels[top] = levels[top - 1] = level - 1;
+        continue;
+      }
+
+    Draw:
+      {
+        TPos  to_x, to_y, mid_x, mid_y;
+
+
+        to_x  = arc[0].x;
+        to_y  = arc[0].y;
+        mid_x = ( ras.x + to_x + 2 * arc[1].x ) / 4;
+        mid_y = ( ras.y + to_y + 2 * arc[1].y ) / 4;
+
+        gray_render_line( RAS_VAR_ mid_x, mid_y );
+        gray_render_line( RAS_VAR_ to_x, to_y );
+
+        top--;
+        arc -= 2;
+      }
+    }
+
+    return;
+  }
+
+
+  static void
+  gray_split_cubic( QT_FT_Vector*  base )
+  {
+    TPos  a, b, c, d;
+
+
+    base[6].x = base[3].x;
+    c = base[1].x;
+    d = base[2].x;
+    base[1].x = a = ( base[0].x + c ) / 2;
+    base[5].x = b = ( base[3].x + d ) / 2;
+    c = ( c + d ) / 2;
+    base[2].x = a = ( a + c ) / 2;
+    base[4].x = b = ( b + c ) / 2;
+    base[3].x = ( a + b ) / 2;
+
+    base[6].y = base[3].y;
+    c = base[1].y;
+    d = base[2].y;
+    base[1].y = a = ( base[0].y + c ) / 2;
+    base[5].y = b = ( base[3].y + d ) / 2;
+    c = ( c + d ) / 2;
+    base[2].y = a = ( a + c ) / 2;
+    base[4].y = b = ( b + c ) / 2;
+    base[3].y = ( a + b ) / 2;
+  }
+
+
+  static void
+  gray_render_cubic( RAS_ARG_ const QT_FT_Vector*  control1,
+                              const QT_FT_Vector*  control2,
+                              const QT_FT_Vector*  to )
+  {
+    TPos        dx, dy, da, db;
+    int         top, level;
+    int*        levels;
+    QT_FT_Vector*  arc;
+
+
+    dx = DOWNSCALE( ras.x ) + to->x - ( control1->x << 1 );
+    if ( dx < 0 )
+      dx = -dx;
+    dy = DOWNSCALE( ras.y ) + to->y - ( control1->y << 1 );
+    if ( dy < 0 )
+      dy = -dy;
+    if ( dx < dy )
+      dx = dy;
+    da = dx;
+
+    dx = DOWNSCALE( ras.x ) + to->x - 3 * ( control1->x + control2->x );
+    if ( dx < 0 )
+      dx = -dx;
+    dy = DOWNSCALE( ras.y ) + to->y - 3 * ( control1->y + control2->y );
+    if ( dy < 0 )
+      dy = -dy;
+    if ( dx < dy )
+      dx = dy;
+    db = dx;
+
+    level = 1;
+    da    = da / ras.cubic_level;
+    db    = db / ras.conic_level;
+    while ( da > 0 || db > 0 )
+    {
+      da >>= 2;
+      db >>= 3;
+      level++;
+    }
+
+    if ( level <= 1 )
+    {
+      TPos   to_x, to_y, mid_x, mid_y;
+
+
+      to_x  = UPSCALE( to->x );
+      to_y  = UPSCALE( to->y );
+      mid_x = ( ras.x + to_x +
+                3 * UPSCALE( control1->x + control2->x ) ) / 8;
+      mid_y = ( ras.y + to_y +
+                3 * UPSCALE( control1->y + control2->y ) ) / 8;
+
+      gray_render_line( RAS_VAR_ mid_x, mid_y );
+      gray_render_line( RAS_VAR_ to_x, to_y );
+      return;
+    }
+
+    arc      = ras.bez_stack;
+    arc[0].x = UPSCALE( to->x );
+    arc[0].y = UPSCALE( to->y );
+    arc[1].x = UPSCALE( control2->x );
+    arc[1].y = UPSCALE( control2->y );
+    arc[2].x = UPSCALE( control1->x );
+    arc[2].y = UPSCALE( control1->y );
+    arc[3].x = ras.x;
+    arc[3].y = ras.y;
+
+    levels    = ras.lev_stack;
+    top       = 0;
+    levels[0] = level;
+
+    while ( top >= 0 )
+    {
+      level = levels[top];
+      if ( level > 1 )
+      {
+        /* check that the arc crosses the current band */
+        TPos  min, max, y;
+
+
+        min = max = arc[0].y;
+        y = arc[1].y;
+        if ( y < min ) min = y;
+        if ( y > max ) max = y;
+        y = arc[2].y;
+        if ( y < min ) min = y;
+        if ( y > max ) max = y;
+        y = arc[3].y;
+        if ( y < min ) min = y;
+        if ( y > max ) max = y;
+        if ( TRUNC( min ) >= ras.max_ey || TRUNC( max ) < 0 )
+          goto Draw;
+        gray_split_cubic( arc );
+        arc += 3;
+        top ++;
+        levels[top] = levels[top - 1] = level - 1;
+        continue;
+      }
+
+    Draw:
+      {
+        TPos  to_x, to_y, mid_x, mid_y;
+
+
+        to_x  = arc[0].x;
+        to_y  = arc[0].y;
+        mid_x = ( ras.x + to_x + 3 * ( arc[1].x + arc[2].x ) ) / 8;
+        mid_y = ( ras.y + to_y + 3 * ( arc[1].y + arc[2].y ) ) / 8;
+
+        gray_render_line( RAS_VAR_ mid_x, mid_y );
+        gray_render_line( RAS_VAR_ to_x, to_y );
+        top --;
+        arc -= 3;
+      }
+    }
+
+    return;
+  }
+
+
+
+  static int
+  gray_move_to( const QT_FT_Vector*  to,
+                PWorker           worker )
+  {
+    TPos  x, y;
+
+
+    /* record current cell, if any */
+    gray_record_cell( worker );
+
+    /* start to a new position */
+    x = UPSCALE( to->x );
+    y = UPSCALE( to->y );
+
+    gray_start_cell( worker, TRUNC( x ), TRUNC( y ) );
+
+    worker->x = x;
+    worker->y = y;
+    return 0;
+  }
+
+
+  static int
+  gray_line_to( const QT_FT_Vector*  to,
+                PWorker           worker )
+  {
+    gray_render_line( worker, UPSCALE( to->x ), UPSCALE( to->y ) );
+    return 0;
+  }
+
+
+  static int
+  gray_conic_to( const QT_FT_Vector*  control,
+                 const QT_FT_Vector*  to,
+                 PWorker           worker )
+  {
+    gray_render_conic( worker, control, to );
+    return 0;
+  }
+
+
+  static int
+  gray_cubic_to( const QT_FT_Vector*  control1,
+                 const QT_FT_Vector*  control2,
+                 const QT_FT_Vector*  to,
+                 PWorker           worker )
+  {
+    gray_render_cubic( worker, control1, control2, to );
+    return 0;
+  }
+
+
+  static void
+  gray_render_span( int             count,
+                    const QT_FT_Span*  spans,
+                    PWorker         worker )
+  {
+    unsigned char*  p;
+    QT_FT_Bitmap*      map = &worker->target;
+
+    for ( ; count > 0; count--, spans++ )
+    {
+      unsigned char  coverage = spans->coverage;
+
+      /* first of all, compute the scanline offset */
+      p = (unsigned char*)map->buffer - spans->y * map->pitch;
+      if ( map->pitch >= 0 )
+        p += ( map->rows - 1 ) * map->pitch;
+
+
+      if ( coverage )
+      {
+        /* For small-spans it is faster to do it by ourselves than
+         * calling `memset'.  This is mainly due to the cost of the
+         * function call.
+         */
+        if ( spans->len >= 8 )
+          QT_FT_MEM_SET( p + spans->x, (unsigned char)coverage, spans->len );
+        else
+        {
+          unsigned char*  q = p + spans->x;
+
+
+          switch ( spans->len )
+          {
+          case 7: *q++ = (unsigned char)coverage;
+          case 6: *q++ = (unsigned char)coverage;
+          case 5: *q++ = (unsigned char)coverage;
+          case 4: *q++ = (unsigned char)coverage;
+          case 3: *q++ = (unsigned char)coverage;
+          case 2: *q++ = (unsigned char)coverage;
+          case 1: *q   = (unsigned char)coverage;
+          default:
+            ;
+          }
+        }
+      }
+    }
+  }
+
+
+  static void
+  gray_hline( RAS_ARG_ TCoord  x,
+                       TCoord  y,
+                       TPos    area,
+                       int     acount )
+  {
+    QT_FT_Span*  span;
+    int       coverage;
+    int       skip;
+
+
+    /* compute the coverage line's coverage, depending on the    */
+    /* outline fill rule                                         */
+    /*                                                           */
+    /* the coverage percentage is area/(PIXEL_BITS*PIXEL_BITS*2) */
+    /*                                                           */
+    coverage = (int)( area >> ( PIXEL_BITS * 2 + 1 - 8 ) );
+                                                    /* use range 0..256 */
+    if ( coverage < 0 )
+      coverage = -coverage;
+
+    if ( ras.outline.flags & QT_FT_OUTLINE_EVEN_ODD_FILL )
+    {
+      coverage &= 511;
+
+      if ( coverage > 256 )
+        coverage = 512 - coverage;
+      else if ( coverage == 256 )
+        coverage = 255;
+    }
+    else
+    {
+      /* normal non-zero winding rule */
+      if ( coverage >= 256 )
+        coverage = 255;
+    }
+
+    y += (TCoord)ras.min_ey;
+    x += (TCoord)ras.min_ex;
+
+    /* QT_FT_Span.x is a 16-bit short, so limit our coordinates appropriately */
+    if ( x >= 32768 )
+      x = 32767;
+
+    if ( coverage )
+    {
+      /* see whether we can add this span to the current list */
+      span  = ras.gray_spans + ras.num_gray_spans - 1;
+      if ( ras.num_gray_spans > 0             &&
+           span->y == y                       &&
+           (int)span->x + span->len == (int)x &&
+           span->coverage == coverage         )
+      {
+        span->len = (unsigned short)( span->len + acount );
+        return;
+      }
+
+      if ( ras.num_gray_spans >= QT_FT_MAX_GRAY_SPANS )
+      {
+        if ( ras.render_span && ras.num_gray_spans > ras.skip_spans )
+        {
+          skip = ras.skip_spans > 0 ? ras.skip_spans : 0;
+          ras.render_span( ras.num_gray_spans - skip,
+                           ras.gray_spans + skip,
+                           ras.render_span_data );
+        }
+
+        ras.skip_spans -= ras.num_gray_spans;
+
+        /* ras.render_span( span->y, ras.gray_spans, count ); */
+
+#ifdef DEBUG_GRAYS
+
+        if ( 1 )
+        {
+          int  n;
+
+
+          fprintf( stderr, "y=%3d ", y );
+          span = ras.gray_spans;
+          for ( n = 0; n < count; n++, span++ )
+            fprintf( stderr, "[%d..%d]:%02x ",
+                     span->x, span->x + span->len - 1, span->coverage );
+          fprintf( stderr, "\n" );
+        }
+
+#endif /* DEBUG_GRAYS */
+
+        ras.num_gray_spans = 0;
+
+        span  = ras.gray_spans;
+      }
+      else
+        span++;
+
+      /* add a gray span to the current list */
+      span->x        = (short)x;
+      span->len      = (unsigned short)acount;
+      span->y        = (short)y;
+      span->coverage = (unsigned char)coverage;
+
+      ras.num_gray_spans++;
+    }
+  }
+
+
+#ifdef DEBUG_GRAYS
+
+  /* to be called while in the debugger */
+  gray_dump_cells( RAS_ARG )
+  {
+    int  yindex;
+
+
+    for ( yindex = 0; yindex < ras.ycount; yindex++ )
+    {
+      PCell  cell;
+
+
+      printf( "%3d:", yindex );
+
+      for ( cell = ras.ycells[yindex]; cell != NULL; cell = cell->next )
+        printf( " (%3d, c:%4d, a:%6d)", cell->x, cell->cover, cell->area );
+      printf( "\n" );
+    }
+  }
+
+#endif /* DEBUG_GRAYS */
+
+
+  static void
+  gray_sweep( RAS_ARG_ const QT_FT_Bitmap*  target )
+  {
+    int  yindex;
+
+    QT_FT_UNUSED( target );
+
+
+    if ( ras.num_cells == 0 )
+      return;
+
+    for ( yindex = 0; yindex < ras.ycount; yindex++ )
+    {
+      PCell   cell  = ras.ycells[yindex];
+      TCoord  cover = 0;
+      TCoord  x     = 0;
+
+
+      for ( ; cell != NULL; cell = cell->next )
+      {
+        TArea  area;
+
+
+        if ( cell->x > x && cover != 0 )
+          gray_hline( RAS_VAR_ x, yindex, cover * ( ONE_PIXEL * 2 ),
+                      cell->x - x );
+
+        cover += cell->cover;
+        area   = cover * ( ONE_PIXEL * 2 ) - cell->area;
+
+        if ( area != 0 && cell->x >= 0 )
+          gray_hline( RAS_VAR_ cell->x, yindex, area, 1 );
+
+        x = cell->x + 1;
+      }
+
+      if ( ras.count_ex > x && cover != 0 )
+        gray_hline( RAS_VAR_ x, yindex, cover * ( ONE_PIXEL * 2 ),
+                    ras.count_ex - x );
+    }
+  }
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*  The following function should only compile in stand_alone mode,      */
+  /*  i.e., when building this component without the rest of FreeType.     */
+  /*                                                                       */
+  /*************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    QT_FT_Outline_Decompose                                               */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Walks over an outline's structure to decompose it into individual  */
+  /*    segments and Bezier arcs.  This function is also able to emit      */
+  /*    `move to' and `close to' operations to indicate the start and end  */
+  /*    of new contours in the outline.                                    */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    outline        :: A pointer to the source target.                  */
+  /*                                                                       */
+  /*    user           :: A typeless pointer which is passed to each       */
+  /*                      emitter during the decomposition.  It can be     */
+  /*                      used to store the state during the               */
+  /*                      decomposition.                                   */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Error code.  0 means success.                                      */
+  /*                                                                       */
+  static
+  int  QT_FT_Outline_Decompose( const QT_FT_Outline*        outline,
+                             void*                    user )
+  {
+#undef SCALED
+#define SCALED( x )  (x)
+
+    QT_FT_Vector   v_last;
+    QT_FT_Vector   v_control;
+    QT_FT_Vector   v_start;
+
+    QT_FT_Vector*  point;
+    QT_FT_Vector*  limit;
+    char*       tags;
+
+    int   n;         /* index of contour in outline     */
+    int   first;     /* index of first point in contour */
+    int   error;
+    char  tag;       /* current point's state           */
+
+    first = 0;
+
+    for ( n = 0; n < outline->n_contours; n++ )
+    {
+      int  last;  /* index of last point in contour */
+
+
+      last  = outline->contours[n];
+      limit = outline->points + last;
+
+      v_start = outline->points[first];
+      v_last  = outline->points[last];
+
+      v_start.x = SCALED( v_start.x );
+      v_start.y = SCALED( v_start.y );
+
+      v_last.x  = SCALED( v_last.x );
+      v_last.y  = SCALED( v_last.y );
+
+      v_control = v_start;
+
+      point = outline->points + first;
+      tags  = outline->tags  + first;
+      tag   = QT_FT_CURVE_TAG( tags[0] );
+
+      /* A contour cannot start with a cubic control point! */
+      if ( tag == QT_FT_CURVE_TAG_CUBIC )
+        goto Invalid_Outline;
+
+      /* check first point to determine origin */
+      if ( tag == QT_FT_CURVE_TAG_CONIC )
+      {
+        /* first point is conic control.  Yes, this happens. */
+        if ( QT_FT_CURVE_TAG( outline->tags[last] ) == QT_FT_CURVE_TAG_ON )
+        {
+          /* start at last point if it is on the curve */
+          v_start = v_last;
+          limit--;
+        }
+        else
+        {
+          /* if both first and last points are conic,         */
+          /* start at their middle and record its position    */
+          /* for closure                                      */
+          v_start.x = ( v_start.x + v_last.x ) / 2;
+          v_start.y = ( v_start.y + v_last.y ) / 2;
+
+          v_last = v_start;
+        }
+        point--;
+        tags--;
+      }
+
+      error = gray_move_to( &v_start, user );
+      if ( error )
+        goto Exit;
+
+      while ( point < limit )
+      {
+        point++;
+        tags++;
+
+        tag = QT_FT_CURVE_TAG( tags[0] );
+        switch ( tag )
+        {
+        case QT_FT_CURVE_TAG_ON:  /* emit a single line_to */
+          {
+            QT_FT_Vector  vec;
+
+
+            vec.x = SCALED( point->x );
+            vec.y = SCALED( point->y );
+
+            error = gray_line_to( &vec, user );
+            if ( error )
+              goto Exit;
+            continue;
+          }
+
+        case QT_FT_CURVE_TAG_CONIC:  /* consume conic arcs */
+          {
+            v_control.x = SCALED( point->x );
+            v_control.y = SCALED( point->y );
+
+          Do_Conic:
+            if ( point < limit )
+            {
+              QT_FT_Vector  vec;
+              QT_FT_Vector  v_middle;
+
+
+              point++;
+              tags++;
+              tag = QT_FT_CURVE_TAG( tags[0] );
+
+              vec.x = SCALED( point->x );
+              vec.y = SCALED( point->y );
+
+              if ( tag == QT_FT_CURVE_TAG_ON )
+              {
+                error = gray_conic_to( &v_control, &vec,
+                                                  user );
+                if ( error )
+                  goto Exit;
+                continue;
+              }
+
+              if ( tag != QT_FT_CURVE_TAG_CONIC )
+                goto Invalid_Outline;
+
+              v_middle.x = ( v_control.x + vec.x ) / 2;
+              v_middle.y = ( v_control.y + vec.y ) / 2;
+
+              error = gray_conic_to( &v_control, &v_middle,
+                                                user );
+              if ( error )
+                goto Exit;
+
+              v_control = vec;
+              goto Do_Conic;
+            }
+
+            error = gray_conic_to( &v_control, &v_start,
+                                              user );
+            goto Close;
+          }
+
+        default:  /* QT_FT_CURVE_TAG_CUBIC */
+          {
+            QT_FT_Vector  vec1, vec2;
+
+
+            if ( point + 1 > limit                             ||
+                 QT_FT_CURVE_TAG( tags[1] ) != QT_FT_CURVE_TAG_CUBIC )
+              goto Invalid_Outline;
+
+            point += 2;
+            tags  += 2;
+
+            vec1.x = SCALED( point[-2].x );
+            vec1.y = SCALED( point[-2].y );
+
+            vec2.x = SCALED( point[-1].x );
+            vec2.y = SCALED( point[-1].y );
+
+            if ( point <= limit )
+            {
+              QT_FT_Vector  vec;
+
+
+              vec.x = SCALED( point->x );
+              vec.y = SCALED( point->y );
+
+              error = gray_cubic_to( &vec1, &vec2, &vec, user );
+              if ( error )
+                goto Exit;
+              continue;
+            }
+
+            error = gray_cubic_to( &vec1, &vec2, &v_start, user );
+            goto Close;
+          }
+        }
+      }
+
+      /* close the contour with a line segment */
+      error = gray_line_to( &v_start, user );
+
+   Close:
+      if ( error )
+        goto Exit;
+
+      first = last + 1;
+    }
+
+    return 0;
+
+  Exit:
+    return error;
+
+  Invalid_Outline:
+    return ErrRaster_Invalid_Outline;
+  }
+
+  typedef struct  TBand_
+  {
+    TPos  min, max;
+
+  } TBand;
+
+
+  static int
+  gray_convert_glyph_inner( RAS_ARG )
+  {
+    volatile int  error = 0;
+
+    if ( qt_ft_setjmp( ras.jump_buffer ) == 0 )
+    {
+      error = QT_FT_Outline_Decompose( &ras.outline, &ras );
+      gray_record_cell( RAS_VAR );
+    }
+    else
+    {
+      error = ErrRaster_Memory_Overflow;
+    }
+
+    return error;
+  }
+
+
+  static int
+  gray_convert_glyph( RAS_ARG )
+  {
+    TBand            bands[40];
+    TBand* volatile  band;
+    int volatile     n, num_bands;
+    TPos volatile    min, max, max_y;
+    QT_FT_BBox*      clip;
+    int              skip;
+
+    ras.num_gray_spans = 0;
+
+    /* Set up state in the raster object */
+    gray_compute_cbox( RAS_VAR );
+
+    /* clip to target bitmap, exit if nothing to do */
+    clip = &ras.clip_box;
+
+    if ( ras.max_ex <= clip->xMin || ras.min_ex >= clip->xMax ||
+         ras.max_ey <= clip->yMin || ras.min_ey >= clip->yMax )
+      return 0;
+
+    if ( ras.min_ex < clip->xMin ) ras.min_ex = clip->xMin;
+    if ( ras.min_ey < clip->yMin ) ras.min_ey = clip->yMin;
+
+    if ( ras.max_ex > clip->xMax ) ras.max_ex = clip->xMax;
+    if ( ras.max_ey > clip->yMax ) ras.max_ey = clip->yMax;
+
+    ras.count_ex = ras.max_ex - ras.min_ex;
+    ras.count_ey = ras.max_ey - ras.min_ey;
+
+    /* simple heuristic used to speed-up the bezier decomposition -- see */
+    /* the code in gray_render_conic() and gray_render_cubic() for more  */
+    /* details                                                           */
+    ras.conic_level = 32;
+    ras.cubic_level = 16;
+
+    {
+      int level = 0;
+
+
+      if ( ras.count_ex > 24 || ras.count_ey > 24 )
+        level++;
+      if ( ras.count_ex > 120 || ras.count_ey > 120 )
+        level++;
+
+      ras.conic_level <<= level;
+      ras.cubic_level <<= level;
+    }
+
+    /* setup vertical bands */
+    num_bands = (int)( ( ras.max_ey - ras.min_ey ) / ras.band_size );
+    if ( num_bands == 0 )  num_bands = 1;
+    if ( num_bands >= 39 ) num_bands = 39;
+
+    ras.band_shoot = 0;
+
+    min   = ras.min_ey;
+    max_y = ras.max_ey;
+
+    for ( n = 0; n < num_bands; n++, min = max )
+    {
+      max = min + ras.band_size;
+      if ( n == num_bands - 1 || max > max_y )
+        max = max_y;
+
+      bands[0].min = min;
+      bands[0].max = max;
+      band         = bands;
+
+      while ( band >= bands )
+      {
+        TPos  bottom, top, middle;
+        int   error;
+
+        {
+          PCell  cells_max;
+          int    yindex;
+          int    cell_start, cell_end, cell_mod;
+
+
+          ras.ycells = (PCell*)ras.buffer;
+          ras.ycount = band->max - band->min;
+
+          cell_start = sizeof ( PCell ) * ras.ycount;
+          cell_mod   = cell_start % sizeof ( TCell );
+          if ( cell_mod > 0 )
+            cell_start += sizeof ( TCell ) - cell_mod;
+
+          cell_end  = ras.buffer_size;
+          cell_end -= cell_end % sizeof( TCell );
+
+          cells_max = (PCell)( (char*)ras.buffer + cell_end );
+          ras.cells = (PCell)( (char*)ras.buffer + cell_start );
+          if ( ras.cells >= cells_max )
+            goto ReduceBands;
+
+          ras.max_cells = (int)(cells_max - ras.cells);
+          if ( ras.max_cells < 2 )
+            goto ReduceBands;
+
+          for ( yindex = 0; yindex < ras.ycount; yindex++ )
+            ras.ycells[yindex] = NULL;
+        }
+
+        ras.num_cells = 0;
+        ras.invalid   = 1;
+        ras.min_ey    = band->min;
+        ras.max_ey    = band->max;
+        ras.count_ey  = band->max - band->min;
+
+        error = gray_convert_glyph_inner( RAS_VAR );
+
+        if ( !error )
+        {
+          gray_sweep( RAS_VAR_ &ras.target );
+          band--;
+          continue;
+        }
+        else if ( error != ErrRaster_Memory_Overflow )
+          return 1;
+
+      ReduceBands:
+        /* render pool overflow; we will reduce the render band by half */
+        bottom = band->min;
+        top    = band->max;
+        middle = bottom + ( ( top - bottom ) >> 1 );
+
+        /* This is too complex for a single scanline; there must */
+        /* be some problems.                                     */
+        if ( middle == bottom )
+        {
+#ifdef DEBUG_GRAYS
+          fprintf( stderr, "Rotten glyph!\n" );
+#endif
+          return ErrRaster_OutOfMemory;
+        }
+
+        if ( bottom-top >= ras.band_size )
+          ras.band_shoot++;
+
+        band[1].min = bottom;
+        band[1].max = middle;
+        band[0].min = middle;
+        band[0].max = top;
+        band++;
+      }
+    }
+
+    if ( ras.render_span && ras.num_gray_spans > ras.skip_spans )
+    {
+        skip = ras.skip_spans > 0 ? ras.skip_spans : 0;
+        ras.render_span( ras.num_gray_spans - skip,
+                         ras.gray_spans + skip,
+                         ras.render_span_data );
+    }
+
+    ras.skip_spans -= ras.num_gray_spans;
+
+    if ( ras.band_shoot > 8 && ras.band_size > 16 )
+      ras.band_size = ras.band_size / 2;
+
+    return 0;
+  }
+
+
+  static int
+  gray_raster_render( QT_FT_Raster                  raster,
+                      const QT_FT_Raster_Params*  params )
+  {
+    const QT_FT_Outline*  outline    = (const QT_FT_Outline*)params->source;
+    const QT_FT_Bitmap*   target_map = params->target;
+    PWorker            worker;
+
+
+    if ( !raster || !raster->buffer || !raster->buffer_size )
+      return ErrRaster_Invalid_Argument;
+
+    if ( raster->worker )
+      raster->worker->skip_spans = params->skip_spans;
+
+    // If raster object and raster buffer are allocated, but
+    // raster size isn't of the minimum size, indicate out of
+    // memory.
+    if (raster->buffer_allocated_size < MINIMUM_POOL_SIZE )
+      return ErrRaster_OutOfMemory;
+
+    /* return immediately if the outline is empty */
+    if ( outline->n_points == 0 || outline->n_contours <= 0 )
+      return 0;
+
+    if ( !outline || !outline->contours || !outline->points )
+      return ErrRaster_Invalid_Outline;
+
+    if ( outline->n_points !=
+           outline->contours[outline->n_contours - 1] + 1 )
+      return ErrRaster_Invalid_Outline;
+
+    worker = raster->worker;
+
+    /* if direct mode is not set, we must have a target bitmap */
+    if ( ( params->flags & QT_FT_RASTER_FLAG_DIRECT ) == 0 )
+    {
+      if ( !target_map )
+        return ErrRaster_Invalid_Argument;
+
+      /* nothing to do */
+      if ( !target_map->width || !target_map->rows )
+        return 0;
+
+      if ( !target_map->buffer )
+        return ErrRaster_Invalid_Argument;
+    }
+
+    /* this version does not support monochrome rendering */
+    if ( !( params->flags & QT_FT_RASTER_FLAG_AA ) )
+      return ErrRaster_Invalid_Mode;
+
+    /* compute clipping box */
+    if ( ( params->flags & QT_FT_RASTER_FLAG_DIRECT ) == 0 )
+    {
+      /* compute clip box from target pixmap */
+      ras.clip_box.xMin = 0;
+      ras.clip_box.yMin = 0;
+      ras.clip_box.xMax = target_map->width;
+      ras.clip_box.yMax = target_map->rows;
+    }
+    else if ( params->flags & QT_FT_RASTER_FLAG_CLIP )
+    {
+      ras.clip_box = params->clip_box;
+    }
+    else
+    {
+      ras.clip_box.xMin = -32768L;
+      ras.clip_box.yMin = -32768L;
+      ras.clip_box.xMax =  32767L;
+      ras.clip_box.yMax =  32767L;
+    }
+
+    gray_init_cells( worker, raster->buffer, raster->buffer_size );
+
+    ras.outline   = *outline;
+    ras.num_cells = 0;
+    ras.invalid   = 1;
+    ras.band_size = raster->band_size;
+
+    if ( target_map )
+      ras.target = *target_map;
+
+    ras.render_span      = (QT_FT_Raster_Span_Func)gray_render_span;
+    ras.render_span_data = &ras;
+
+    if ( params->flags & QT_FT_RASTER_FLAG_DIRECT )
+    {
+      ras.render_span      = (QT_FT_Raster_Span_Func)params->gray_spans;
+      ras.render_span_data = params->user;
+    }
+
+    return gray_convert_glyph( worker );
+  }
+
+
+  /**** RASTER OBJECT CREATION: In standalone mode, we simply use *****/
+  /****                         a static object.                  *****/
+
+  static int
+  gray_raster_new( QT_FT_Raster*  araster )
+  {
+    *araster = malloc(sizeof(TRaster));
+    if (!*araster) {
+        *araster = 0;
+        return ErrRaster_Memory_Overflow;
+    }
+    QT_FT_MEM_ZERO(*araster, sizeof(TRaster));
+
+    return 0;
+  }
+
+
+  static void
+  gray_raster_done( QT_FT_Raster  raster )
+  {
+    free(raster);
+  }
+
+
+  static void
+  gray_raster_reset( QT_FT_Raster  raster,
+                     char*      pool_base,
+                     long       pool_size )
+  {
+    PRaster  rast = (PRaster)raster;
+
+    if ( raster )
+    {
+      if ( pool_base && ( pool_size >= MINIMUM_POOL_SIZE ) )
+      {
+        PWorker  worker = (PWorker)pool_base;
+
+
+        rast->worker      = worker;
+        rast->buffer      = pool_base +
+                              ( ( sizeof ( TWorker ) + sizeof ( TCell ) - 1 ) &
+                                ~( sizeof ( TCell ) - 1 ) );
+        rast->buffer_size = (long)( ( pool_base + pool_size ) -
+                                    (char*)rast->buffer ) &
+                                      ~( sizeof ( TCell ) - 1 );
+        rast->band_size   = (int)( rast->buffer_size /
+                                     ( sizeof ( TCell ) * 8 ) );
+      }
+      else if ( pool_base)
+      { // Case when there is a raster pool allocated, but it
+        // doesn't have the minimum size (and so memory will be reallocated)
+          rast->buffer = pool_base;
+          rast->worker = NULL;
+          rast->buffer_size = pool_size;
+      }
+      else
+      {
+        rast->buffer      = NULL;
+        rast->buffer_size = 0;
+        rast->worker      = NULL;
+      }
+      rast->buffer_allocated_size = pool_size;
+    }
+  }
+
+  const QT_FT_Raster_Funcs  qt_ft_grays_raster =
+  {
+    QT_FT_GLYPH_FORMAT_OUTLINE,
+
+    (QT_FT_Raster_New_Func)     gray_raster_new,
+    (QT_FT_Raster_Reset_Func)   gray_raster_reset,
+    (QT_FT_Raster_Set_Mode_Func)0,
+    (QT_FT_Raster_Render_Func)  gray_raster_render,
+    (QT_FT_Raster_Done_Func)    gray_raster_done
+  };
+
+/* END */
diff --git a/src/gui/painting/qgrayraster_p.h b/src/gui/painting/qgrayraster_p.h
new file mode 100644
index 0000000000..b9a4aed66d
--- /dev/null
+++ b/src/gui/painting/qgrayraster_p.h
@@ -0,0 +1,105 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/***************************************************************************/
+/*                                                                         */
+/*  qgrayraster_p.h, derived from ftgrays.h                                */
+/*                                                                         */
+/*    FreeType smooth renderer declaration                                 */
+/*                                                                         */
+/*  Copyright 1996-2001 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, ../../3rdparty/freetype/docs/FTL.TXT.  By continuing to use,  */
+/*  modify, or distribute this file you indicate that you have read        */
+/*  the license and understand and accept it fully.                        */
+/***************************************************************************/
+
+
+#ifndef __FTGRAYS_H__
+#define __FTGRAYS_H__
+
+/*
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+*/
+
+#ifdef __cplusplus
+  extern "C" {
+#endif
+
+
+#include <private/qrasterdefs_p.h>
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* To make ftgrays.h independent from configuration files we check       */
+  /* whether QT_FT_EXPORT_VAR has been defined already.                    */
+  /*                                                                       */
+  /* On some systems and compilers (Win32 mostly), an extra keyword is     */
+  /* necessary to compile the library as a DLL.                            */
+  /*                                                                       */
+#ifndef QT_FT_EXPORT_VAR
+#define QT_FT_EXPORT_VAR( x )  extern  x
+#endif
+
+/* Minimum buffer size for raster object, that accounts
+   for TWorker and TCell sizes.*/
+#define MINIMUM_POOL_SIZE 8192
+
+  QT_FT_EXPORT_VAR( const QT_FT_Raster_Funcs )  qt_ft_grays_raster;
+
+
+#ifdef __cplusplus
+  }
+#endif
+
+#endif /* __FTGRAYS_H__ */
+
+/* END */
diff --git a/src/gui/painting/qimagescale.cpp b/src/gui/painting/qimagescale.cpp
new file mode 100644
index 0000000000..87df7976bf
--- /dev/null
+++ b/src/gui/painting/qimagescale.cpp
@@ -0,0 +1,1031 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include <private/qimagescale_p.h>
+#include <private/qdrawhelper_p.h>
+
+#include "qimage.h"
+#include "qcolor.h"
+
+QT_BEGIN_NAMESPACE
+
+namespace QImageScale {
+    struct QImageScaleInfo;
+}
+
+typedef void (*qt_qimageScaleFunc)(QImageScale::QImageScaleInfo *isi, unsigned int *dest,
+                                   int dxx, int dyy, int dx, int dy, int dw,
+                                   int dh, int dow, int sow);
+
+static void qt_qimageScaleAARGB(QImageScale::QImageScaleInfo *isi, unsigned int *dest,
+                         int dxx, int dyy, int dx, int dy, int dw,
+                         int dh, int dow, int sow);
+
+static void qt_qimageScaleAARGBA(QImageScale::QImageScaleInfo *isi, unsigned int *dest,
+                          int dxx, int dyy, int dx, int dy, int dw,
+                          int dh, int dow, int sow);
+
+qt_qimageScaleFunc qt_qimageScaleArgb = qt_qimageScaleAARGBA;
+qt_qimageScaleFunc qt_qimageScaleRgb  = qt_qimageScaleAARGB;
+
+
+/*
+ * Copyright (C) 2004, 2005 Daniel M. Duley
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+/* OTHER CREDITS:
+ *
+ * This is the normal smoothscale method, based on Imlib2's smoothscale.
+ *
+ * Originally I took the algorithm used in NetPBM and Qt and added MMX/3dnow
+ * optimizations. It ran in about 1/2 the time as Qt. Then I ported Imlib's
+ * C algorithm and it ran at about the same speed as my MMX optimized one...
+ * Finally I ported Imlib's MMX version and it ran in less than half the
+ * time as my MMX algorithm, (taking only a quarter of the time Qt does).
+ * After further optimization it seems to run at around 1/6th.
+ *
+ * Changes include formatting, namespaces and other C++'ings, removal of old
+ * #ifdef'ed code, and removal of unneeded border calculation code.
+ *
+ * Imlib2 is (C) Carsten Haitzler and various contributors. The MMX code
+ * is by Willem Monsuwe <willem@stack.nl>. All other modifications are
+ * (C) Daniel M. Duley.
+ */
+
+
+namespace QImageScale {
+    struct QImageScaleInfo {
+        int *xpoints;
+        unsigned int **ypoints;
+        int *xapoints, *yapoints;
+        int xup_yup;
+    };
+
+    unsigned int** qimageCalcYPoints(unsigned int *src, int sw, int sh,
+                                     int dh);
+    int* qimageCalcXPoints(int sw, int dw);
+    int* qimageCalcApoints(int s, int d, int up);
+    QImageScaleInfo* qimageFreeScaleInfo(QImageScaleInfo *isi);
+    QImageScaleInfo *qimageCalcScaleInfo(const QImage &img, int sw, int sh,
+                                         int dw, int dh, char aa);
+}
+
+using namespace QImageScale;
+
+//
+// Code ported from Imlib...
+//
+
+// FIXME: replace with qRed, etc... These work on pointers to pixels, not
+// pixel values
+#define A_VAL(p) (qAlpha(*p))
+#define R_VAL(p) (qRed(*p))
+#define G_VAL(p) (qGreen(*p))
+#define B_VAL(p) (qBlue(*p))
+
+#define INV_XAP                   (256 - xapoints[x])
+#define XAP                       (xapoints[x])
+#define INV_YAP                   (256 - yapoints[dyy + y])
+#define YAP                       (yapoints[dyy + y])
+
+unsigned int** QImageScale::qimageCalcYPoints(unsigned int *src,
+                                              int sw, int sh, int dh)
+{
+    unsigned int **p;
+    int i, j = 0;
+    int val, inc, rv = 0;
+
+    if(dh < 0){
+        dh = -dh;
+        rv = 1;
+    }
+    p = new unsigned int* [dh+1];
+
+    int up = qAbs(dh) >= sh;
+    val = up ? 0x8000 * sh / dh - 0x8000 : 0;
+    inc = (sh << 16) / dh;
+    for(i = 0; i < dh; i++){
+        p[j++] = src + qMax(0, val >> 16) * sw;
+        val += inc;
+    }
+    if(rv){
+        for(i = dh / 2; --i >= 0; ){
+            unsigned int *tmp = p[i];
+            p[i] = p[dh - i - 1];
+            p[dh - i - 1] = tmp;
+        }
+    }
+    return(p);
+}
+
+int* QImageScale::qimageCalcXPoints(int sw, int dw)
+{
+    int *p, i, j = 0;
+    int val, inc, rv = 0;
+
+    if(dw < 0){
+        dw = -dw;
+        rv = 1;
+    }
+    p = new int[dw+1];
+
+    int up = qAbs(dw) >= sw;
+    val = up ? 0x8000 * sw / dw - 0x8000 : 0;
+    inc = (sw << 16) / dw;
+    for(i = 0; i < dw; i++){
+        p[j++] = qMax(0, val >> 16);
+        val += inc;
+    }
+
+    if(rv){
+        for(i = dw / 2; --i >= 0; ){
+            int tmp = p[i];
+            p[i] = p[dw - i - 1];
+            p[dw - i - 1] = tmp;
+        }
+    }
+   return(p);
+}
+
+int* QImageScale::qimageCalcApoints(int s, int d, int up)
+{
+    int *p, i, j = 0, rv = 0;
+
+    if(d < 0){
+        rv = 1;
+        d = -d;
+    }
+    p = new int[d];
+
+    /* scaling up */
+    if(up){
+        int val, inc;
+
+        val = 0x8000 * s / d - 0x8000;
+        inc = (s << 16) / d;
+        for(i = 0; i < d; i++){
+            int pos = val >> 16;
+            if (pos < 0)
+                p[j++] = 0;
+            else if (pos >= (s - 1))
+                p[j++] = 0;
+            else
+                p[j++] = (val >> 8) - ((val >> 8) & 0xffffff00);
+            val += inc;
+        }
+    }
+    /* scaling down */
+    else{
+        int val, inc, ap, Cp;
+        val = 0;
+        inc = (s << 16) / d;
+        Cp = ((d << 14) / s) + 1;
+        for(i = 0; i < d; i++){
+            ap = ((0x100 - ((val >> 8) & 0xff)) * Cp) >> 8;
+            p[j] = ap | (Cp << 16);
+            j++;
+            val += inc;
+        }
+    }
+    if(rv){
+        int tmp;
+        for(i = d / 2; --i >= 0; ){
+            tmp = p[i];
+            p[i] = p[d - i - 1];
+            p[d - i - 1] = tmp;
+        }
+    }
+    return(p);
+}
+
+QImageScaleInfo* QImageScale::qimageFreeScaleInfo(QImageScaleInfo *isi)
+{
+    if(isi){
+        delete[] isi->xpoints;
+        delete[] isi->ypoints;
+        delete[] isi->xapoints;
+        delete[] isi->yapoints;
+        delete isi;
+    }
+    return 0;
+}
+
+QImageScaleInfo* QImageScale::qimageCalcScaleInfo(const QImage &img,
+                                                  int sw, int sh,
+                                                  int dw, int dh, char aa)
+{
+    QImageScaleInfo *isi;
+    int scw, sch;
+
+    scw = dw * qlonglong(img.width()) / sw;
+    sch = dh * qlonglong(img.height()) / sh;
+
+    isi = new QImageScaleInfo;
+    if(!isi)
+        return 0;
+    memset(isi, 0, sizeof(QImageScaleInfo));
+
+    isi->xup_yup = (qAbs(dw) >= sw) + ((qAbs(dh) >= sh) << 1);
+
+    isi->xpoints = qimageCalcXPoints(img.width(), scw);
+    if(!isi->xpoints)
+        return(qimageFreeScaleInfo(isi));
+    isi->ypoints = qimageCalcYPoints((unsigned int *)img.scanLine(0),
+                                     img.bytesPerLine() / 4, img.height(), sch);
+    if (!isi->ypoints)
+        return(qimageFreeScaleInfo(isi));
+    if(aa) {
+        isi->xapoints = qimageCalcApoints(img.width(), scw, isi->xup_yup & 1);
+        if(!isi->xapoints)
+            return(qimageFreeScaleInfo(isi));
+        isi->yapoints = qimageCalcApoints(img.height(), sch, isi->xup_yup & 2);
+        if(!isi->yapoints)
+            return(qimageFreeScaleInfo(isi));
+    }
+    return(isi);
+}
+
+/* FIXME: NEED to optimize ScaleAARGBA - currently its "ok" but needs work*/
+
+/* scale by area sampling */
+static void qt_qimageScaleAARGBA(QImageScaleInfo *isi, unsigned int *dest,
+                                 int dxx, int dyy, int dx, int dy, int dw,
+                                 int dh, int dow, int sow)
+{
+    unsigned int *sptr, *dptr;
+    int x, y, end;
+    unsigned int **ypoints = isi->ypoints;
+    int *xpoints = isi->xpoints;
+    int *xapoints = isi->xapoints;
+    int *yapoints = isi->yapoints;
+
+    end = dxx + dw;
+    /* scaling up both ways */
+    if(isi->xup_yup == 3){
+        /* go through every scanline in the output buffer */
+        for(y = 0; y < dh; y++){
+            /* calculate the source line we'll scan from */
+            dptr = dest + dx + ((y + dy) * dow);
+            sptr = ypoints[dyy + y];
+            if(YAP > 0){
+                for(x = dxx; x < end; x++){
+                    int r, g, b, a;
+                    int rr, gg, bb, aa;
+                    unsigned int *pix;
+
+                    if(XAP > 0){
+                        pix = ypoints[dyy + y] + xpoints[x];
+                        r = R_VAL(pix) * INV_XAP;
+                        g = G_VAL(pix) * INV_XAP;
+                        b = B_VAL(pix) * INV_XAP;
+                        a = A_VAL(pix) * INV_XAP;
+                        pix++;
+                        r += R_VAL(pix) * XAP;
+                        g += G_VAL(pix) * XAP;
+                        b += B_VAL(pix) * XAP;
+                        a += A_VAL(pix) * XAP;
+                        pix += sow;
+                        rr = R_VAL(pix) * XAP;
+                        gg = G_VAL(pix) * XAP;
+                        bb = B_VAL(pix) * XAP;
+                        aa = A_VAL(pix) * XAP;
+                        pix--;
+                        rr += R_VAL(pix) * INV_XAP;
+                        gg += G_VAL(pix) * INV_XAP;
+                        bb += B_VAL(pix) * INV_XAP;
+                        aa += A_VAL(pix) * INV_XAP;
+                        r = ((rr * YAP) + (r * INV_YAP)) >> 16;
+                        g = ((gg * YAP) + (g * INV_YAP)) >> 16;
+                        b = ((bb * YAP) + (b * INV_YAP)) >> 16;
+                        a = ((aa * YAP) + (a * INV_YAP)) >> 16;
+                        *dptr++ = qRgba(r, g, b, a);
+                    }
+                    else{
+                        pix = ypoints[dyy + y] + xpoints[x];
+                        r = R_VAL(pix) * INV_YAP;
+                        g = G_VAL(pix) * INV_YAP;
+                        b = B_VAL(pix) * INV_YAP;
+                        a = A_VAL(pix) * INV_YAP;
+                        pix += sow;
+                        r += R_VAL(pix) * YAP;
+                        g += G_VAL(pix) * YAP;
+                        b += B_VAL(pix) * YAP;
+                        a += A_VAL(pix) * YAP;
+                        r >>= 8;
+                        g >>= 8;
+                        b >>= 8;
+                        a >>= 8;
+                        *dptr++ = qRgba(r, g, b, a);
+                    }
+                }
+            }
+            else{
+                for(x = dxx; x < end; x++){
+                    int r, g, b, a;
+                    unsigned int *pix;
+
+                    if(XAP > 0){
+                        pix = ypoints[dyy + y] + xpoints[x];
+                        r = R_VAL(pix) * INV_XAP;
+                        g = G_VAL(pix) * INV_XAP;
+                        b = B_VAL(pix) * INV_XAP;
+                        a = A_VAL(pix) * INV_XAP;
+                        pix++;
+                        r += R_VAL(pix) * XAP;
+                        g += G_VAL(pix) * XAP;
+                        b += B_VAL(pix) * XAP;
+                        a += A_VAL(pix) * XAP;
+                        r >>= 8;
+                        g >>= 8;
+                        b >>= 8;
+                        a >>= 8;
+                        *dptr++ = qRgba(r, g, b, a);
+                    }
+                    else
+                        *dptr++ = sptr[xpoints[x] ];
+                }
+            }
+        }
+    }
+    /* if we're scaling down vertically */
+    else if(isi->xup_yup == 1){
+        /*\ 'Correct' version, with math units prepared for MMXification \*/
+        int Cy, j;
+        unsigned int *pix;
+        int r, g, b, a, rr, gg, bb, aa;
+        int yap;
+
+        /* go through every scanline in the output buffer */
+        for(y = 0; y < dh; y++){
+            Cy = YAP >> 16;
+            yap = YAP & 0xffff;
+
+            dptr = dest + dx + ((y + dy) * dow);
+            for(x = dxx; x < end; x++){
+                pix = ypoints[dyy + y] + xpoints[x];
+                r = R_VAL(pix) * yap;
+                g = G_VAL(pix) * yap;
+                b = B_VAL(pix) * yap;
+                a = A_VAL(pix) * yap;
+                for(j = (1 << 14) - yap; j > Cy; j -= Cy){
+                    pix += sow;
+                    r += R_VAL(pix) * Cy;
+                    g += G_VAL(pix) * Cy;
+                    b += B_VAL(pix) * Cy;
+                    a += A_VAL(pix) * Cy;
+                }
+                if(j > 0){
+                    pix += sow;
+                    r += R_VAL(pix) * j;
+                    g += G_VAL(pix) * j;
+                    b += B_VAL(pix) * j;
+                    a += A_VAL(pix) * j;
+                }
+                if(XAP > 0){
+                    pix = ypoints[dyy + y] + xpoints[x] + 1;
+                    rr = R_VAL(pix) * yap;
+                    gg = G_VAL(pix) * yap;
+                    bb = B_VAL(pix) * yap;
+                    aa = A_VAL(pix) * yap;
+                    for(j = (1 << 14) - yap; j > Cy; j -= Cy){
+                        pix += sow;
+                        rr += R_VAL(pix) * Cy;
+                        gg += G_VAL(pix) * Cy;
+                        bb += B_VAL(pix) * Cy;
+                        aa += A_VAL(pix) * Cy;
+                    }
+                    if(j > 0){
+                        pix += sow;
+                        rr += R_VAL(pix) * j;
+                        gg += G_VAL(pix) * j;
+                        bb += B_VAL(pix) * j;
+                        aa += A_VAL(pix) * j;
+                    }
+                    r = r * INV_XAP;
+                    g = g * INV_XAP;
+                    b = b * INV_XAP;
+                    a = a * INV_XAP;
+                    r = (r + ((rr * XAP))) >> 12;
+                    g = (g + ((gg * XAP))) >> 12;
+                    b = (b + ((bb * XAP))) >> 12;
+                    a = (a + ((aa * XAP))) >> 12;
+                }
+                else{
+                    r >>= 4;
+                    g >>= 4;
+                    b >>= 4;
+                    a >>= 4;
+                }
+                *dptr = qRgba(r >> 10, g >> 10, b >> 10, a >> 10);
+                dptr++;
+            }
+        }
+    }
+    /* if we're scaling down horizontally */
+    else if(isi->xup_yup == 2){
+        /*\ 'Correct' version, with math units prepared for MMXification \*/
+        int Cx, j;
+        unsigned int *pix;
+        int r, g, b, a, rr, gg, bb, aa;
+        int xap;
+
+        /* go through every scanline in the output buffer */
+        for(y = 0; y < dh; y++){
+            dptr = dest + dx + ((y + dy) * dow);
+            for(x = dxx; x < end; x++){
+                Cx = XAP >> 16;
+                xap = XAP & 0xffff;
+
+                pix = ypoints[dyy + y] + xpoints[x];
+                r = R_VAL(pix) * xap;
+                g = G_VAL(pix) * xap;
+                b = B_VAL(pix) * xap;
+                a = A_VAL(pix) * xap;
+                for(j = (1 << 14) - xap; j > Cx; j -= Cx){
+                    pix++;
+                    r += R_VAL(pix) * Cx;
+                    g += G_VAL(pix) * Cx;
+                    b += B_VAL(pix) * Cx;
+                    a += A_VAL(pix) * Cx;
+                }
+                if(j > 0){
+                    pix++;
+                    r += R_VAL(pix) * j;
+                    g += G_VAL(pix) * j;
+                    b += B_VAL(pix) * j;
+                    a += A_VAL(pix) * j;
+                }
+                if(YAP > 0){
+                    pix = ypoints[dyy + y] + xpoints[x] + sow;
+                    rr = R_VAL(pix) * xap;
+                    gg = G_VAL(pix) * xap;
+                    bb = B_VAL(pix) * xap;
+                    aa = A_VAL(pix) * xap;
+                    for(j = (1 << 14) - xap; j > Cx; j -= Cx){
+                        pix++;
+                        rr += R_VAL(pix) * Cx;
+                        gg += G_VAL(pix) * Cx;
+                        bb += B_VAL(pix) * Cx;
+                        aa += A_VAL(pix) * Cx;
+                    }
+                    if(j > 0){
+                        pix++;
+                        rr += R_VAL(pix) * j;
+                        gg += G_VAL(pix) * j;
+                        bb += B_VAL(pix) * j;
+                        aa += A_VAL(pix) * j;
+                    }
+                    r = r * INV_YAP;
+                    g = g * INV_YAP;
+                    b = b * INV_YAP;
+                    a = a * INV_YAP;
+                    r = (r + ((rr * YAP))) >> 12;
+                    g = (g + ((gg * YAP))) >> 12;
+                    b = (b + ((bb * YAP))) >> 12;
+                    a = (a + ((aa * YAP))) >> 12;
+                }
+                else{
+                    r >>= 4;
+                    g >>= 4;
+                    b >>= 4;
+                    a >>= 4;
+                }
+                *dptr = qRgba(r >> 10, g >> 10, b >> 10, a >> 10);
+                dptr++;
+            }
+        }
+    }
+    /* if we're scaling down horizontally & vertically */
+    else{
+        /*\ 'Correct' version, with math units prepared for MMXification:
+         |*|  The operation 'b = (b * c) >> 16' translates to pmulhw,
+         |*|  so the operation 'b = (b * c) >> d' would translate to
+         |*|  psllw (16 - d), %mmb; pmulh %mmc, %mmb
+         \*/
+        int Cx, Cy, i, j;
+        unsigned int *pix;
+        int a, r, g, b, ax, rx, gx, bx;
+        int xap, yap;
+
+        for(y = 0; y < dh; y++){
+            Cy = YAP >> 16;
+            yap = YAP & 0xffff;
+
+            dptr = dest + dx + ((y + dy) * dow);
+            for(x = dxx; x < end; x++){
+                Cx = XAP >> 16;
+                xap = XAP & 0xffff;
+
+                sptr = ypoints[dyy + y] + xpoints[x];
+                pix = sptr;
+                sptr += sow;
+                rx = R_VAL(pix) * xap;
+                gx = G_VAL(pix) * xap;
+                bx = B_VAL(pix) * xap;
+                ax = A_VAL(pix) * xap;
+
+                pix++;
+                for(i = (1 << 14) - xap; i > Cx; i -= Cx){
+                    rx += R_VAL(pix) * Cx;
+                    gx += G_VAL(pix) * Cx;
+                    bx += B_VAL(pix) * Cx;
+                    ax += A_VAL(pix) * Cx;
+                    pix++;
+                }
+                if(i > 0){
+                    rx += R_VAL(pix) * i;
+                    gx += G_VAL(pix) * i;
+                    bx += B_VAL(pix) * i;
+                    ax += A_VAL(pix) * i;
+                }
+
+                r = (rx >> 5) * yap;
+                g = (gx >> 5) * yap;
+                b = (bx >> 5) * yap;
+                a = (ax >> 5) * yap;
+
+                for(j = (1 << 14) - yap; j > Cy; j -= Cy){
+                    pix = sptr;
+                    sptr += sow;
+                    rx = R_VAL(pix) * xap;
+                    gx = G_VAL(pix) * xap;
+                    bx = B_VAL(pix) * xap;
+                    ax = A_VAL(pix) * xap;
+                    pix++;
+                    for(i = (1 << 14) - xap; i > Cx; i -= Cx){
+                        rx += R_VAL(pix) * Cx;
+                        gx += G_VAL(pix) * Cx;
+                        bx += B_VAL(pix) * Cx;
+                        ax += A_VAL(pix) * Cx;
+                        pix++;
+                    }
+                    if(i > 0){
+                        rx += R_VAL(pix) * i;
+                        gx += G_VAL(pix) * i;
+                        bx += B_VAL(pix) * i;
+                        ax += A_VAL(pix) * i;
+                    }
+
+                    r += (rx >> 5) * Cy;
+                    g += (gx >> 5) * Cy;
+                    b += (bx >> 5) * Cy;
+                    a += (ax >> 5) * Cy;
+                }
+                if(j > 0){
+                    pix = sptr;
+                    sptr += sow;
+                    rx = R_VAL(pix) * xap;
+                    gx = G_VAL(pix) * xap;
+                    bx = B_VAL(pix) * xap;
+                    ax = A_VAL(pix) * xap;
+                    pix++;
+                    for(i = (1 << 14) - xap; i > Cx; i -= Cx){
+                        rx += R_VAL(pix) * Cx;
+                        gx += G_VAL(pix) * Cx;
+                        bx += B_VAL(pix) * Cx;
+                        ax += A_VAL(pix) * Cx;
+                        pix++;
+                    }
+                    if(i > 0){
+                        rx += R_VAL(pix) * i;
+                        gx += G_VAL(pix) * i;
+                        bx += B_VAL(pix) * i;
+                        ax += A_VAL(pix) * i;
+                    }
+
+                    r += (rx >> 5) * j;
+                    g += (gx >> 5) * j;
+                    b += (bx >> 5) * j;
+                    a += (ax >> 5) * j;
+                }
+
+                *dptr = qRgba(r >> 23, g >> 23, b >> 23, a >> 23);
+                dptr++;
+            }
+        }
+    }
+}
+
+/* scale by area sampling - IGNORE the ALPHA byte*/
+static void qt_qimageScaleAARGB(QImageScaleInfo *isi, unsigned int *dest,
+                                int dxx, int dyy, int dx, int dy, int dw,
+                                int dh, int dow, int sow)
+{
+    unsigned int *sptr, *dptr;
+    int x, y, end;
+    unsigned int **ypoints = isi->ypoints;
+    int *xpoints = isi->xpoints;
+    int *xapoints = isi->xapoints;
+    int *yapoints = isi->yapoints;
+
+    end = dxx + dw;
+    /* scaling up both ways */
+    if(isi->xup_yup == 3){
+        /* go through every scanline in the output buffer */
+        for(y = 0; y < dh; y++){
+            /* calculate the source line we'll scan from */
+            dptr = dest + dx + ((y + dy) * dow);
+            sptr = ypoints[dyy + y];
+            if(YAP > 0){
+                for(x = dxx; x < end; x++){
+                    int r = 0, g = 0, b = 0;
+                    int rr = 0, gg = 0, bb = 0;
+                    unsigned int *pix;
+
+                    if(XAP > 0){
+                        pix = ypoints[dyy + y] + xpoints[x];
+                        r = R_VAL(pix) * INV_XAP;
+                        g = G_VAL(pix) * INV_XAP;
+                        b = B_VAL(pix) * INV_XAP;
+                        pix++;
+                        r += R_VAL(pix) * XAP;
+                        g += G_VAL(pix) * XAP;
+                        b += B_VAL(pix) * XAP;
+                        pix += sow;
+                        rr = R_VAL(pix) * XAP;
+                        gg = G_VAL(pix) * XAP;
+                        bb = B_VAL(pix) * XAP;
+                        pix --;
+                        rr += R_VAL(pix) * INV_XAP;
+                        gg += G_VAL(pix) * INV_XAP;
+                        bb += B_VAL(pix) * INV_XAP;
+                        r = ((rr * YAP) + (r * INV_YAP)) >> 16;
+                        g = ((gg * YAP) + (g * INV_YAP)) >> 16;
+                        b = ((bb * YAP) + (b * INV_YAP)) >> 16;
+                        *dptr++ = qRgba(r, g, b, 0xff);
+                    }
+                    else{
+                        pix = ypoints[dyy + y] + xpoints[x];
+                        r = R_VAL(pix) * INV_YAP;
+                        g = G_VAL(pix) * INV_YAP;
+                        b = B_VAL(pix) * INV_YAP;
+                        pix += sow;
+                        r += R_VAL(pix) * YAP;
+                        g += G_VAL(pix) * YAP;
+                        b += B_VAL(pix) * YAP;
+                        r >>= 8;
+                        g >>= 8;
+                        b >>= 8;
+                        *dptr++ = qRgba(r, g, b, 0xff);
+                    }
+                }
+            }
+            else{
+                for(x = dxx; x < end; x++){
+                    int r = 0, g = 0, b = 0;
+                    unsigned int *pix;
+
+                    if(XAP > 0){
+                        pix = ypoints[dyy + y] + xpoints[x];
+                        r = R_VAL(pix) * INV_XAP;
+                        g = G_VAL(pix) * INV_XAP;
+                        b = B_VAL(pix) * INV_XAP;
+                        pix++;
+                        r += R_VAL(pix) * XAP;
+                        g += G_VAL(pix) * XAP;
+                        b += B_VAL(pix) * XAP;
+                        r >>= 8;
+                        g >>= 8;
+                        b >>= 8;
+                        *dptr++ = qRgba(r, g, b, 0xff);
+                    }
+                    else
+                        *dptr++ = sptr[xpoints[x] ];
+                }
+            }
+        }
+    }
+    /* if we're scaling down vertically */
+    else if(isi->xup_yup == 1){
+        /*\ 'Correct' version, with math units prepared for MMXification \*/
+        int Cy, j;
+        unsigned int *pix;
+        int r, g, b, rr, gg, bb;
+        int yap;
+
+        /* go through every scanline in the output buffer */
+        for(y = 0; y < dh; y++){
+            Cy = YAP >> 16;
+            yap = YAP & 0xffff;
+
+            dptr = dest + dx + ((y + dy) * dow);
+            for(x = dxx; x < end; x++){
+                pix = ypoints[dyy + y] + xpoints[x];
+                r = R_VAL(pix) * yap;
+                g = G_VAL(pix) * yap;
+                b = B_VAL(pix) * yap;
+                pix += sow;
+                for(j = (1 << 14) - yap; j > Cy; j -= Cy){
+                    r += R_VAL(pix) * Cy;
+                    g += G_VAL(pix) * Cy;
+                    b += B_VAL(pix) * Cy;
+                    pix += sow;
+                }
+                if(j > 0){
+                    r += R_VAL(pix) * j;
+                    g += G_VAL(pix) * j;
+                    b += B_VAL(pix) * j;
+                }
+                if(XAP > 0){
+                    pix = ypoints[dyy + y] + xpoints[x] + 1;
+                    rr = R_VAL(pix) * yap;
+                    gg = G_VAL(pix) * yap;
+                    bb = B_VAL(pix) * yap;
+                    pix += sow;
+                    for(j = (1 << 14) - yap; j > Cy; j -= Cy){
+                        rr += R_VAL(pix) * Cy;
+                        gg += G_VAL(pix) * Cy;
+                        bb += B_VAL(pix) * Cy;
+                        pix += sow;
+                    }
+                    if(j > 0){
+                        rr += R_VAL(pix) * j;
+                        gg += G_VAL(pix) * j;
+                        bb += B_VAL(pix) * j;
+                    }
+                    r = r * INV_XAP;
+                    g = g * INV_XAP;
+                    b = b * INV_XAP;
+                    r = (r + ((rr * XAP))) >> 12;
+                    g = (g + ((gg * XAP))) >> 12;
+                    b = (b + ((bb * XAP))) >> 12;
+                }
+                else{
+                    r >>= 4;
+                    g >>= 4;
+                    b >>= 4;
+                }
+                *dptr = qRgba(r >> 10, g >> 10, b >> 10, 0xff);
+                dptr++;
+            }
+        }
+    }
+    /* if we're scaling down horizontally */
+    else if(isi->xup_yup == 2){
+        /*\ 'Correct' version, with math units prepared for MMXification \*/
+        int Cx, j;
+        unsigned int *pix;
+        int r, g, b, rr, gg, bb;
+        int xap;
+
+        /* go through every scanline in the output buffer */
+        for(y = 0; y < dh; y++){
+            dptr = dest + dx + ((y + dy) * dow);
+            for(x = dxx; x < end; x++){
+                Cx = XAP >> 16;
+                xap = XAP & 0xffff;
+
+                pix = ypoints[dyy + y] + xpoints[x];
+                r = R_VAL(pix) * xap;
+                g = G_VAL(pix) * xap;
+                b = B_VAL(pix) * xap;
+                pix++;
+                for(j = (1 << 14) - xap; j > Cx; j -= Cx){
+                    r += R_VAL(pix) * Cx;
+                    g += G_VAL(pix) * Cx;
+                    b += B_VAL(pix) * Cx;
+                    pix++;
+                }
+                if(j > 0){
+                    r += R_VAL(pix) * j;
+                    g += G_VAL(pix) * j;
+                    b += B_VAL(pix) * j;
+                }
+                if(YAP > 0){
+                    pix = ypoints[dyy + y] + xpoints[x] + sow;
+                    rr = R_VAL(pix) * xap;
+                    gg = G_VAL(pix) * xap;
+                    bb = B_VAL(pix) * xap;
+                    pix++;
+                    for(j = (1 << 14) - xap; j > Cx; j -= Cx){
+                        rr += R_VAL(pix) * Cx;
+                        gg += G_VAL(pix) * Cx;
+                        bb += B_VAL(pix) * Cx;
+                        pix++;
+                    }
+                    if(j > 0){
+                        rr += R_VAL(pix) * j;
+                        gg += G_VAL(pix) * j;
+                        bb += B_VAL(pix) * j;
+                    }
+                    r = r * INV_YAP;
+                    g = g * INV_YAP;
+                    b = b * INV_YAP;
+                    r = (r + ((rr * YAP))) >> 12;
+                    g = (g + ((gg * YAP))) >> 12;
+                    b = (b + ((bb * YAP))) >> 12;
+                }
+                else{
+                    r >>= 4;
+                    g >>= 4;
+                    b >>= 4;
+                }
+                *dptr = qRgba(r >> 10, g >> 10, b >> 10, 0xff);
+                dptr++;
+            }
+        }
+    }
+    /* fully optimized (i think) - onyl change of algorithm can help */
+    /* if we're scaling down horizontally & vertically */
+    else{
+        /*\ 'Correct' version, with math units prepared for MMXification \*/
+        int Cx, Cy, i, j;
+        unsigned int *pix;
+        int r, g, b, rx, gx, bx;
+        int xap, yap;
+
+        for(y = 0; y < dh; y++){
+            Cy = YAP >> 16;
+            yap = YAP & 0xffff;
+
+            dptr = dest + dx + ((y + dy) * dow);
+            for(x = dxx; x < end; x++){
+                Cx = XAP >> 16;
+                xap = XAP & 0xffff;
+
+                sptr = ypoints[dyy + y] + xpoints[x];
+                pix = sptr;
+                sptr += sow;
+                rx = R_VAL(pix) * xap;
+                gx = G_VAL(pix) * xap;
+                bx = B_VAL(pix) * xap;
+                pix++;
+                for(i = (1 << 14) - xap; i > Cx; i -= Cx){
+                    rx += R_VAL(pix) * Cx;
+                    gx += G_VAL(pix) * Cx;
+                    bx += B_VAL(pix) * Cx;
+                    pix++;
+                }
+                if(i > 0){
+                    rx += R_VAL(pix) * i;
+                    gx += G_VAL(pix) * i;
+                    bx += B_VAL(pix) * i;
+                }
+
+                r = (rx >> 5) * yap;
+                g = (gx >> 5) * yap;
+                b = (bx >> 5) * yap;
+
+                for(j = (1 << 14) - yap; j > Cy; j -= Cy){
+                    pix = sptr;
+                    sptr += sow;
+                    rx = R_VAL(pix) * xap;
+                    gx = G_VAL(pix) * xap;
+                    bx = B_VAL(pix) * xap;
+                    pix++;
+                    for(i = (1 << 14) - xap; i > Cx; i -= Cx){
+                        rx += R_VAL(pix) * Cx;
+                        gx += G_VAL(pix) * Cx;
+                        bx += B_VAL(pix) * Cx;
+                        pix++;
+                    }
+                    if(i > 0){
+                        rx += R_VAL(pix) * i;
+                        gx += G_VAL(pix) * i;
+                        bx += B_VAL(pix) * i;
+                    }
+
+                    r += (rx >> 5) * Cy;
+                    g += (gx >> 5) * Cy;
+                    b += (bx >> 5) * Cy;
+                }
+                if(j > 0){
+                    pix = sptr;
+                    sptr += sow;
+                    rx = R_VAL(pix) * xap;
+                    gx = G_VAL(pix) * xap;
+                    bx = B_VAL(pix) * xap;
+                    pix++;
+                    for(i = (1 << 14) - xap; i > Cx; i -= Cx){
+                        rx += R_VAL(pix) * Cx;
+                        gx += G_VAL(pix) * Cx;
+                        bx += B_VAL(pix) * Cx;
+                        pix++;
+                    }
+                    if(i > 0){
+                        rx += R_VAL(pix) * i;
+                        gx += G_VAL(pix) * i;
+                        bx += B_VAL(pix) * i;
+                    }
+
+                    r += (rx >> 5) * j;
+                    g += (gx >> 5) * j;
+                    b += (bx >> 5) * j;
+                }
+
+                *dptr = qRgb(r >> 23, g >> 23, b >> 23);
+                dptr++;
+            }
+        }
+    }
+}
+
+#if 0
+static void qt_qimageScaleAARGBASetup(QImageScaleInfo *isi, unsigned int *dest,
+                                      int dxx, int dyy, int dx, int dy, int dw,
+                                      int dh, int dow, int sow)
+{
+    qInitDrawhelperAsm();
+    qt_qimageScaleAARGBA(isi, dest, dxx, dyy, dx, dy, dw, dh, dow, sow);
+}
+
+static void qt_qimageScaleAARGBSetup(QImageScaleInfo *isi, unsigned int *dest,
+                                 int dxx, int dyy, int dx, int dy, int dw,
+                                 int dh, int dow, int sow)
+{
+    qInitDrawhelperAsm();
+    qt_qimageScaleAARGB(isi, dest, dxx, dyy, dx, dy, dw, dh, dow, sow);
+}
+#endif
+
+QImage qSmoothScaleImage(const QImage &src, int dw, int dh)
+{
+    QImage buffer;
+    if (src.isNull() || dw <= 0 || dh <= 0)
+        return buffer;
+
+    int w = src.width();
+    int h = src.height();
+    QImageScaleInfo *scaleinfo =
+        qimageCalcScaleInfo(src, w, h, dw, dh, true);
+    if (!scaleinfo)
+        return buffer;
+
+    buffer = QImage(dw, dh, src.format());
+    if (buffer.isNull()) {
+        qWarning("QImage: out of memory, returning null");
+        qimageFreeScaleInfo(scaleinfo);
+        return QImage();
+    }
+
+    if (src.format() == QImage::Format_ARGB32_Premultiplied)
+        qt_qimageScaleArgb(scaleinfo, (unsigned int *)buffer.scanLine(0),
+                           0, 0, 0, 0, dw, dh, dw, src.bytesPerLine() / 4);
+    else
+        qt_qimageScaleRgb(scaleinfo, (unsigned int *)buffer.scanLine(0),
+                          0, 0, 0, 0, dw, dh, dw, src.bytesPerLine() / 4);
+
+    qimageFreeScaleInfo(scaleinfo);
+    return buffer;
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qimagescale_p.h b/src/gui/painting/qimagescale_p.h
new file mode 100644
index 0000000000..fbf162addf
--- /dev/null
+++ b/src/gui/painting/qimagescale_p.h
@@ -0,0 +1,66 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#ifndef QIMAGESCALE_P_H
+#define QIMAGESCALE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <qimage.h>
+
+QT_BEGIN_NAMESPACE
+
+/*
+  This version accepts only supported formats.
+*/
+QImage qSmoothScaleImage(const QImage &img, int w, int h);
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/gui/painting/qmath_p.h b/src/gui/painting/qmath_p.h
new file mode 100644
index 0000000000..63d23e0dcb
--- /dev/null
+++ b/src/gui/painting/qmath_p.h
@@ -0,0 +1,72 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QMATH_P_H
+#define QMATH_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <math.h>
+#include <qmath.h>
+
+QT_BEGIN_NAMESPACE
+
+static const qreal Q_PI   = qreal(3.14159265358979323846);   // pi
+static const qreal Q_2PI  = qreal(6.28318530717958647693);   // 2*pi
+static const qreal Q_PI2  = qreal(1.57079632679489661923);   // pi/2
+
+inline int qIntSqrtInt(int v)
+{
+    return static_cast<int>(qSqrt(static_cast<qreal>(v)));
+}
+
+QT_END_NAMESPACE
+
+#endif // QMATH_P_H
diff --git a/src/gui/painting/qmatrix.cpp b/src/gui/painting/qmatrix.cpp
new file mode 100644
index 0000000000..38f78e1a46
--- /dev/null
+++ b/src/gui/painting/qmatrix.cpp
@@ -0,0 +1,1229 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qdatastream.h"
+#include "qdebug.h"
+#include "qmatrix.h"
+#include "qregion.h"
+#include "qpainterpath.h"
+#include "qvariant.h"
+#include <qmath.h>
+
+#include <limits.h>
+
+QT_BEGIN_NAMESPACE
+
+/*!
+    \class QMatrix
+    \brief The QMatrix class specifies 2D transformations of a
+    coordinate system.
+    \obsolete
+
+    \ingroup painting
+
+    A matrix specifies how to translate, scale, shear or rotate the
+    coordinate system, and is typically used when rendering graphics.
+    QMatrix, in contrast to QTransform, does not allow perspective
+    transformations. QTransform is the recommended transformation
+    class in Qt.
+
+    A QMatrix object can be built using the setMatrix(), scale(),
+    rotate(), translate() and shear() functions.  Alternatively, it
+    can be built by applying \l {QMatrix#Basic Matrix
+    Operations}{basic matrix operations}. The matrix can also be
+    defined when constructed, and it can be reset to the identity
+    matrix (the default) using the reset() function.
+
+    The QMatrix class supports mapping of graphic primitives: A given
+    point, line, polygon, region, or painter path can be mapped to the
+    coordinate system defined by \e this matrix using the map()
+    function. In case of a rectangle, its coordinates can be
+    transformed using the mapRect() function. A rectangle can also be
+    transformed into a \e polygon (mapped to the coordinate system
+    defined by \e this matrix), using the mapToPolygon() function.
+
+    QMatrix provides the isIdentity() function which returns true if
+    the matrix is the identity matrix, and the isInvertible() function
+    which returns true if the matrix is non-singular (i.e. AB = BA =
+    I). The inverted() function returns an inverted copy of \e this
+    matrix if it is invertible (otherwise it returns the identity
+    matrix). In addition, QMatrix provides the determinant() function
+    returning the matrix's determinant.
+
+    Finally, the QMatrix class supports matrix multiplication, and
+    objects of the class can be streamed as well as compared.
+
+    \tableofcontents
+
+    \section1 Rendering Graphics
+
+    When rendering graphics, the matrix defines the transformations
+    but the actual transformation is performed by the drawing routines
+    in QPainter.
+
+    By default, QPainter operates on the associated device's own
+    coordinate system.  The standard coordinate system of a
+    QPaintDevice has its origin located at the top-left position. The
+    \e x values increase to the right; \e y values increase
+    downward. For a complete description, see the \l {Coordinate
+    System}{coordinate system} documentation.
+
+    QPainter has functions to translate, scale, shear and rotate the
+    coordinate system without using a QMatrix. For example:
+
+    \table 100%
+    \row
+    \o \inlineimage qmatrix-simpletransformation.png
+    \o
+    \snippet doc/src/snippets/matrix/matrix.cpp 0
+    \endtable
+
+    Although these functions are very convenient, it can be more
+    efficient to build a QMatrix and call QPainter::setMatrix() if you
+    want to perform more than a single transform operation. For
+    example:
+
+    \table 100%
+    \row
+    \o \inlineimage qmatrix-combinedtransformation.png
+    \o
+    \snippet doc/src/snippets/matrix/matrix.cpp 1
+    \endtable
+
+    \section1 Basic Matrix Operations
+
+    \image qmatrix-representation.png
+
+    A QMatrix object contains a 3 x 3 matrix.  The \c dx and \c dy
+    elements specify horizontal and vertical translation. The \c m11
+    and \c m22 elements specify horizontal and vertical scaling. And
+    finally, the \c m21 and \c m12 elements specify horizontal and
+    vertical \e shearing.
+
+    QMatrix transforms a point in the plane to another point using the
+    following formulas:
+
+    \snippet doc/src/snippets/code/src_gui_painting_qmatrix.cpp 0
+
+    The point \e (x, y) is the original point, and \e (x', y') is the
+    transformed point. \e (x', y') can be transformed back to \e (x,
+    y) by performing the same operation on the inverted() matrix.
+
+    The various matrix elements can be set when constructing the
+    matrix, or by using the setMatrix() function later on. They can also
+    be manipulated using the translate(), rotate(), scale() and
+    shear() convenience functions, The currently set values can be
+    retrieved using the m11(), m12(), m21(), m22(), dx() and dy()
+    functions.
+
+    Translation is the simplest transformation. Setting \c dx and \c
+    dy will move the coordinate system \c dx units along the X axis
+    and \c dy units along the Y axis.  Scaling can be done by setting
+    \c m11 and \c m22. For example, setting \c m11 to 2 and \c m22 to
+    1.5 will double the height and increase the width by 50%.  The
+    identity matrix has \c m11 and \c m22 set to 1 (all others are set
+    to 0) mapping a point to itself. Shearing is controlled by \c m12
+    and \c m21. Setting these elements to values different from zero
+    will twist the coordinate system. Rotation is achieved by
+    carefully setting both the shearing factors and the scaling
+    factors.
+
+    Here's the combined transformations example using basic matrix
+    operations:
+
+    \table 100%
+    \row
+    \o \inlineimage qmatrix-combinedtransformation.png
+    \o
+    \snippet doc/src/snippets/matrix/matrix.cpp 2
+    \endtable
+
+    \sa QPainter, QTransform, {Coordinate System}, 
+    {demos/affine}{Affine Transformations Demo}, {Transformations Example}
+*/
+
+
+// some defines to inline some code
+#define MAPDOUBLE(x, y, nx, ny) \
+{ \
+    qreal fx = x; \
+    qreal fy = y; \
+    nx = _m11*fx + _m21*fy + _dx; \
+    ny = _m12*fx + _m22*fy + _dy; \
+}
+
+#define MAPINT(x, y, nx, ny) \
+{ \
+    qreal fx = x; \
+    qreal fy = y; \
+    nx = qRound(_m11*fx + _m21*fy + _dx); \
+    ny = qRound(_m12*fx + _m22*fy + _dy); \
+}
+
+/*****************************************************************************
+  QMatrix member functions
+ *****************************************************************************/
+/*!
+    \fn QMatrix::QMatrix(Qt::Initialization)
+    \internal
+*/
+
+/*!
+    Constructs an identity matrix.
+
+    All elements are set to zero except \c m11 and \c m22 (specifying
+    the scale), which are set to 1.
+
+    \sa reset()
+*/
+
+QMatrix::QMatrix()
+    : _m11(1.)
+    , _m12(0.)
+    , _m21(0.)
+    , _m22(1.)
+    , _dx(0.)
+    , _dy(0.)
+{
+}
+
+/*!
+    Constructs a matrix with the elements, \a m11, \a m12, \a m21, \a
+    m22, \a dx and \a dy.
+
+    \sa setMatrix()
+*/
+
+QMatrix::QMatrix(qreal m11, qreal m12, qreal m21, qreal m22, qreal dx, qreal dy)
+    : _m11(m11)
+    , _m12(m12)
+    , _m21(m21)
+    , _m22(m22)
+    , _dx(dx)
+    , _dy(dy)
+{
+}
+
+
+/*!
+     Constructs a matrix that is a copy of the given \a matrix.
+ */
+QMatrix::QMatrix(const QMatrix &matrix)
+    : _m11(matrix._m11)
+    , _m12(matrix._m12)
+    , _m21(matrix._m21)
+    , _m22(matrix._m22)
+    , _dx(matrix._dx)
+    , _dy(matrix._dy)
+{
+}
+
+/*!
+    Sets the matrix elements to the specified values, \a m11, \a m12,
+    \a m21, \a m22, \a dx and \a dy.
+
+    Note that this function replaces the previous values. QMatrix
+    provide the translate(), rotate(), scale() and shear() convenience
+    functions to manipulate the various matrix elements based on the
+    currently defined coordinate system.
+
+    \sa QMatrix()
+*/
+
+void QMatrix::setMatrix(qreal m11, qreal m12, qreal m21, qreal m22, qreal dx, qreal dy)
+{
+    _m11 = m11;
+    _m12 = m12;
+    _m21 = m21;
+    _m22 = m22;
+    _dx  = dx;
+    _dy  = dy;
+}
+
+
+/*!
+    \fn qreal QMatrix::m11() const
+
+    Returns the horizontal scaling factor.
+
+    \sa scale(), {QMatrix#Basic Matrix Operations}{Basic Matrix
+    Operations}
+*/
+
+/*!
+    \fn qreal QMatrix::m12() const
+
+    Returns the vertical shearing factor.
+
+    \sa shear(), {QMatrix#Basic Matrix Operations}{Basic Matrix
+    Operations}
+*/
+
+/*!
+    \fn qreal QMatrix::m21() const
+
+    Returns the horizontal shearing factor.
+
+    \sa shear(), {QMatrix#Basic Matrix Operations}{Basic Matrix
+    Operations}
+*/
+
+/*!
+    \fn qreal QMatrix::m22() const
+
+    Returns the vertical scaling factor.
+
+    \sa scale(), {QMatrix#Basic Matrix Operations}{Basic Matrix
+    Operations}
+*/
+
+/*!
+    \fn qreal QMatrix::dx() const
+
+    Returns the horizontal translation factor.
+
+    \sa translate(), {QMatrix#Basic Matrix Operations}{Basic Matrix
+    Operations}
+*/
+
+/*!
+    \fn qreal QMatrix::dy() const
+
+    Returns the vertical translation factor.
+
+    \sa translate(), {QMatrix#Basic Matrix Operations}{Basic Matrix
+    Operations}
+*/
+
+
+/*!
+    Maps the given coordinates \a x and \a y into the coordinate
+    system defined by this matrix. The resulting values are put in *\a
+    tx and *\a ty, respectively.
+
+    The coordinates are transformed using the following formulas:
+
+    \snippet doc/src/snippets/code/src_gui_painting_qmatrix.cpp 1
+
+    The point (x, y) is the original point, and (x', y') is the
+    transformed point.
+
+    \sa {QMatrix#Basic Matrix Operations}{Basic Matrix Operations}
+*/
+
+void QMatrix::map(qreal x, qreal y, qreal *tx, qreal *ty) const
+{
+    MAPDOUBLE(x, y, *tx, *ty);
+}
+
+
+
+/*!
+    \overload
+
+    Maps the given coordinates \a x and \a y into the coordinate
+    system defined by this matrix. The resulting values are put in *\a
+    tx and *\a ty, respectively. Note that the transformed coordinates
+    are rounded to the nearest integer.
+*/
+
+void QMatrix::map(int x, int y, int *tx, int *ty) const
+{
+    MAPINT(x, y, *tx, *ty);
+}
+
+QRect QMatrix::mapRect(const QRect &rect) const
+{
+    QRect result;
+    if (_m12 == 0.0F && _m21 == 0.0F) {
+        int x = qRound(_m11*rect.x() + _dx);
+        int y = qRound(_m22*rect.y() + _dy);
+        int w = qRound(_m11*rect.width());
+        int h = qRound(_m22*rect.height());
+        if (w < 0) {
+            w = -w;
+            x -= w;
+        }
+        if (h < 0) {
+            h = -h;
+            y -= h;
+        }
+        result = QRect(x, y, w, h);
+    } else {
+        // see mapToPolygon for explanations of the algorithm.
+        qreal x0, y0;
+        qreal x, y;
+        MAPDOUBLE(rect.left(), rect.top(), x0, y0);
+        qreal xmin = x0;
+        qreal ymin = y0;
+        qreal xmax = x0;
+        qreal ymax = y0;
+        MAPDOUBLE(rect.right() + 1, rect.top(), x, y);
+        xmin = qMin(xmin, x);
+        ymin = qMin(ymin, y);
+        xmax = qMax(xmax, x);
+        ymax = qMax(ymax, y);
+        MAPDOUBLE(rect.right() + 1, rect.bottom() + 1, x, y);
+        xmin = qMin(xmin, x);
+        ymin = qMin(ymin, y);
+        xmax = qMax(xmax, x);
+        ymax = qMax(ymax, y);
+        MAPDOUBLE(rect.left(), rect.bottom() + 1, x, y);
+        xmin = qMin(xmin, x);
+        ymin = qMin(ymin, y);
+        xmax = qMax(xmax, x);
+        ymax = qMax(ymax, y);
+        result = QRect(qRound(xmin), qRound(ymin), qRound(xmax)-qRound(xmin), qRound(ymax)-qRound(ymin));
+    }
+    return result;
+}
+
+/*!
+    \fn QRectF QMatrix::mapRect(const QRectF &rectangle) const
+
+    Creates and returns a QRectF object that is a copy of the given \a
+    rectangle, mapped into the coordinate system defined by this
+    matrix.
+
+    The rectangle's coordinates are transformed using the following
+    formulas:
+
+    \snippet doc/src/snippets/code/src_gui_painting_qmatrix.cpp 2
+
+    If rotation or shearing has been specified, this function returns
+    the \e bounding rectangle. To retrieve the exact region the given
+    \a rectangle maps to, use the mapToPolygon() function instead.
+
+    \sa mapToPolygon(), {QMatrix#Basic Matrix Operations}{Basic Matrix
+    Operations}
+*/
+QRectF QMatrix::mapRect(const QRectF &rect) const
+{
+    QRectF result;
+    if (_m12 == 0.0F && _m21 == 0.0F) {
+        qreal x = _m11*rect.x() + _dx;
+        qreal y = _m22*rect.y() + _dy;
+        qreal w = _m11*rect.width();
+        qreal h = _m22*rect.height();
+        if (w < 0) {
+            w = -w;
+            x -= w;
+        }
+        if (h < 0) {
+            h = -h;
+            y -= h;
+        }
+        result = QRectF(x, y, w, h);
+    } else {
+        qreal x0, y0;
+        qreal x, y;
+        MAPDOUBLE(rect.x(), rect.y(), x0, y0);
+        qreal xmin = x0;
+        qreal ymin = y0;
+        qreal xmax = x0;
+        qreal ymax = y0;
+        MAPDOUBLE(rect.x() + rect.width(), rect.y(), x, y);
+        xmin = qMin(xmin, x);
+        ymin = qMin(ymin, y);
+        xmax = qMax(xmax, x);
+        ymax = qMax(ymax, y);
+        MAPDOUBLE(rect.x() + rect.width(), rect.y() + rect.height(), x, y);
+        xmin = qMin(xmin, x);
+        ymin = qMin(ymin, y);
+        xmax = qMax(xmax, x);
+        ymax = qMax(ymax, y);
+        MAPDOUBLE(rect.x(), rect.y() + rect.height(), x, y);
+        xmin = qMin(xmin, x);
+        ymin = qMin(ymin, y);
+        xmax = qMax(xmax, x);
+        ymax = qMax(ymax, y);
+        result = QRectF(xmin, ymin, xmax-xmin, ymax - ymin);
+    }
+    return result;
+}
+
+/*!
+    \fn QRect QMatrix::mapRect(const QRect &rectangle) const
+    \overload
+
+    Creates and returns a QRect object that is a copy of the given \a
+    rectangle, mapped into the coordinate system defined by this
+    matrix. Note that the transformed coordinates are rounded to the
+    nearest integer.
+*/
+
+
+/*!
+    \fn QPoint operator*(const QPoint &point, const QMatrix &matrix)
+    \relates QMatrix
+
+    This is the same as \a{matrix}.map(\a{point}).
+
+    \sa QMatrix::map()
+*/
+
+QPoint QMatrix::map(const QPoint &p) const
+{
+    qreal fx = p.x();
+    qreal fy = p.y();
+    return QPoint(qRound(_m11*fx + _m21*fy + _dx),
+                   qRound(_m12*fx + _m22*fy + _dy));
+}
+
+/*!
+    \fn QPointF operator*(const QPointF &point, const QMatrix &matrix)
+    \relates QMatrix
+
+    Same as \a{matrix}.map(\a{point}).
+
+    \sa QMatrix::map()
+*/
+
+/*!
+    \overload
+
+    Creates and returns a QPointF object that is a copy of the given
+    \a point, mapped into the coordinate system defined by this
+    matrix.
+*/
+QPointF QMatrix::map(const QPointF &point) const
+{
+    qreal fx = point.x();
+    qreal fy = point.y();
+    return QPointF(_m11*fx + _m21*fy + _dx, _m12*fx + _m22*fy + _dy);
+}
+
+/*!
+    \fn QPoint QMatrix::map(const QPoint &point) const
+    \overload
+
+    Creates and returns a QPoint object that is a copy of the given \a
+    point, mapped into the coordinate system defined by this
+    matrix. Note that the transformed coordinates are rounded to the
+    nearest integer.
+*/
+
+/*!
+    \fn QLineF operator*(const QLineF &line, const QMatrix &matrix)
+    \relates QMatrix
+
+    This is the same as \a{matrix}.map(\a{line}).
+
+    \sa QMatrix::map()
+*/
+
+/*!
+    \fn QLine operator*(const QLine &line, const QMatrix &matrix)
+    \relates QMatrix
+
+    This is the same as \a{matrix}.map(\a{line}).
+
+    \sa QMatrix::map()
+*/
+
+/*!
+    \overload
+
+    Creates and returns a QLineF object that is a copy of the given \a
+    line, mapped into the coordinate system defined by this matrix.
+*/
+QLineF QMatrix::map(const QLineF &line) const
+{
+    return QLineF(map(line.p1()), map(line.p2()));
+}
+
+/*!
+    \overload
+
+    Creates and returns a QLine object that is a copy of the given \a
+    line, mapped into the coordinate system defined by this matrix.
+    Note that the transformed coordinates are rounded to the nearest
+    integer.
+*/
+QLine QMatrix::map(const QLine &line) const
+{
+    return QLine(map(line.p1()), map(line.p2()));
+}
+
+/*!
+    \fn QPolygonF operator *(const QPolygonF &polygon, const QMatrix &matrix)
+    \relates QMatrix
+
+    This is the same as \a{matrix}.map(\a{polygon}).
+
+    \sa QMatrix::map()
+*/
+
+/*!
+    \fn QPolygon operator*(const QPolygon &polygon, const QMatrix &matrix)
+    \relates QMatrix
+
+    This is the same as \a{matrix}.map(\a{polygon}).
+
+    \sa QMatrix::map()
+*/
+
+QPolygon QMatrix::map(const QPolygon &a) const
+{
+    int size = a.size();
+    int i;
+    QPolygon p(size);
+    const QPoint *da = a.constData();
+    QPoint *dp = p.data();
+    for(i = 0; i < size; i++) {
+        MAPINT(da[i].x(), da[i].y(), dp[i].rx(), dp[i].ry());
+    }
+    return p;
+}
+
+/*!
+    \fn QPolygonF QMatrix::map(const QPolygonF &polygon) const
+    \overload
+
+    Creates and returns a QPolygonF object that is a copy of the given
+    \a polygon, mapped into the coordinate system defined by this
+    matrix.
+*/
+QPolygonF QMatrix::map(const QPolygonF &a) const
+{
+    int size = a.size();
+    int i;
+    QPolygonF p(size);
+    const QPointF *da = a.constData();
+    QPointF *dp = p.data();
+    for(i = 0; i < size; i++) {
+        MAPDOUBLE(da[i].xp, da[i].yp, dp[i].xp, dp[i].yp);
+    }
+    return p;
+}
+
+/*!
+    \fn QPolygon QMatrix::map(const QPolygon &polygon) const
+    \overload
+
+    Creates and returns a QPolygon object that is a copy of the given
+    \a polygon, mapped into the coordinate system defined by this
+    matrix. Note that the transformed coordinates are rounded to the
+    nearest integer.
+*/
+
+/*!
+    \fn QRegion operator*(const QRegion &region, const QMatrix &matrix)
+    \relates QMatrix
+
+    This is the same as \a{matrix}.map(\a{region}).
+
+    \sa QMatrix::map()
+*/
+
+extern QPainterPath qt_regionToPath(const QRegion &region);
+
+/*!
+    \fn QRegion QMatrix::map(const QRegion &region) const
+    \overload
+
+    Creates and returns a QRegion object that is a copy of the given
+    \a region, mapped into the coordinate system defined by this matrix.
+
+    Calling this method can be rather expensive if rotations or
+    shearing are used.
+*/
+QRegion QMatrix::map(const QRegion &r) const
+{
+    if (_m11 == 1.0 && _m22 == 1.0 && _m12 == 0.0 && _m21 == 0.0) { // translate or identity
+        if (_dx == 0.0 && _dy == 0.0) // Identity
+            return r;
+        QRegion copy(r);
+        copy.translate(qRound(_dx), qRound(_dy));
+        return copy;
+    }
+
+    QPainterPath p = map(qt_regionToPath(r));
+    return p.toFillPolygon().toPolygon();
+}
+
+/*!
+    \fn QPainterPath operator *(const QPainterPath &path, const QMatrix &matrix)
+    \relates QMatrix
+
+    This is the same as \a{matrix}.map(\a{path}).
+
+    \sa QMatrix::map()
+*/
+
+/*!
+    \overload
+
+    Creates and returns a QPainterPath object that is a copy of the
+    given \a path, mapped into the coordinate system defined by this
+    matrix.
+*/
+QPainterPath QMatrix::map(const QPainterPath &path) const
+{
+    if (path.isEmpty())
+        return QPainterPath();
+
+    QPainterPath copy = path;
+
+    // Translate or identity
+    if (_m11 == 1.0 && _m22 == 1.0 && _m12 == 0.0 && _m21 == 0.0) {
+
+        // Translate
+        if (_dx != 0.0 || _dy != 0.0) {
+            copy.detach();
+            for (int i=0; i<path.elementCount(); ++i) {
+                QPainterPath::Element &e = copy.d_ptr->elements[i];
+                e.x += _dx;
+                e.y += _dy;
+            }
+        }
+
+    // Full xform
+    } else {
+        copy.detach();
+        for (int i=0; i<path.elementCount(); ++i) {
+            QPainterPath::Element &e = copy.d_ptr->elements[i];
+            qreal fx = e.x, fy = e.y;
+            e.x = _m11*fx + _m21*fy + _dx;
+            e.y =  _m12*fx + _m22*fy + _dy;
+        }
+    }
+
+    return copy;
+}
+
+/*!
+    \fn QRegion QMatrix::mapToRegion(const QRect &rectangle) const
+
+    Returns the transformed rectangle \a rectangle as a QRegion
+    object. A rectangle which has been rotated or sheared may result
+    in a non-rectangular region being returned.
+
+    Use the mapToPolygon() or map() function instead.
+*/
+#ifdef QT3_SUPPORT
+QRegion QMatrix::mapToRegion(const QRect &rect) const
+{
+    QRegion result;
+    if (isIdentity()) {
+        result = rect;
+    } else if (m12() == 0.0F && m21() == 0.0F) {
+        int x = qRound(m11()*rect.x() + dx());
+        int y = qRound(m22()*rect.y() + dy());
+        int w = qRound(m11()*rect.width());
+        int h = qRound(m22()*rect.height());
+        if (w < 0) {
+            w = -w;
+            x -= w - 1;
+        }
+        if (h < 0) {
+            h = -h;
+            y -= h - 1;
+        }
+        result = QRect(x, y, w, h);
+    } else {
+        result = QRegion(mapToPolygon(rect));
+    }
+    return result;
+
+}
+#endif
+/*!
+    \fn QPolygon QMatrix::mapToPolygon(const QRect &rectangle) const
+
+    Creates and returns a QPolygon representation of the given \a
+    rectangle, mapped into the coordinate system defined by this
+    matrix.
+
+    The rectangle's coordinates are transformed using the following
+    formulas:
+
+    \snippet doc/src/snippets/code/src_gui_painting_qmatrix.cpp 3
+
+    Polygons and rectangles behave slightly differently when
+    transformed (due to integer rounding), so
+    \c{matrix.map(QPolygon(rectangle))} is not always the same as
+    \c{matrix.mapToPolygon(rectangle)}.
+
+    \sa mapRect(), {QMatrix#Basic Matrix Operations}{Basic Matrix
+    Operations}
+*/
+QPolygon QMatrix::mapToPolygon(const QRect &rect) const
+{
+    QPolygon a(4);
+    qreal x[4], y[4];
+    if (_m12 == 0.0F && _m21 == 0.0F) {
+        x[0] = _m11*rect.x() + _dx;
+        y[0] = _m22*rect.y() + _dy;
+        qreal w = _m11*rect.width();
+        qreal h = _m22*rect.height();
+        if (w < 0) {
+            w = -w;
+            x[0] -= w;
+        }
+        if (h < 0) {
+            h = -h;
+            y[0] -= h;
+        }
+        x[1] = x[0]+w;
+        x[2] = x[1];
+        x[3] = x[0];
+        y[1] = y[0];
+        y[2] = y[0]+h;
+        y[3] = y[2];
+    } else {
+        qreal right = rect.x() + rect.width();
+        qreal bottom = rect.y() + rect.height();
+        MAPDOUBLE(rect.x(), rect.y(), x[0], y[0]);
+        MAPDOUBLE(right, rect.y(), x[1], y[1]);
+        MAPDOUBLE(right, bottom, x[2], y[2]);
+        MAPDOUBLE(rect.x(), bottom, x[3], y[3]);
+    }
+#if 0
+    int i;
+    for(i = 0; i< 4; i++)
+        qDebug("coords(%d) = (%f/%f) (%d/%d)", i, x[i], y[i], qRound(x[i]), qRound(y[i]));
+    qDebug("width=%f, height=%f", qSqrt((x[1]-x[0])*(x[1]-x[0]) + (y[1]-y[0])*(y[1]-y[0])),
+            qSqrt((x[0]-x[3])*(x[0]-x[3]) + (y[0]-y[3])*(y[0]-y[3])));
+#endif
+    // all coordinates are correctly, tranform to a pointarray
+    // (rounding to the next integer)
+    a.setPoints(4, qRound(x[0]), qRound(y[0]),
+                 qRound(x[1]), qRound(y[1]),
+                 qRound(x[2]), qRound(y[2]),
+                 qRound(x[3]), qRound(y[3]));
+    return a;
+}
+
+/*!
+    Resets the matrix to an identity matrix, i.e. all elements are set
+    to zero, except \c m11 and \c m22 (specifying the scale) which are
+    set to 1.
+
+    \sa QMatrix(), isIdentity(), {QMatrix#Basic Matrix
+    Operations}{Basic Matrix Operations}
+*/
+
+void QMatrix::reset()
+{
+    _m11 = _m22 = 1.0;
+    _m12 = _m21 = _dx = _dy = 0.0;
+}
+
+/*!
+    \fn bool QMatrix::isIdentity() const
+
+    Returns true if the matrix is the identity matrix, otherwise
+    returns false.
+
+    \sa reset()
+*/
+
+/*!
+    Moves the coordinate system \a dx along the x axis and \a dy along
+    the y axis, and returns a reference to the matrix.
+
+    \sa setMatrix()
+*/
+
+QMatrix &QMatrix::translate(qreal dx, qreal dy)
+{
+    _dx += dx*_m11 + dy*_m21;
+    _dy += dy*_m22 + dx*_m12;
+    return *this;
+}
+
+/*!
+    \fn QMatrix &QMatrix::scale(qreal sx, qreal sy)
+
+    Scales the coordinate system by \a sx horizontally and \a sy
+    vertically, and returns a reference to the matrix.
+
+    \sa setMatrix()
+*/
+
+QMatrix &QMatrix::scale(qreal sx, qreal sy)
+{
+    _m11 *= sx;
+    _m12 *= sx;
+    _m21 *= sy;
+    _m22 *= sy;
+    return *this;
+}
+
+/*!
+    Shears the coordinate system by \a sh horizontally and \a sv
+    vertically, and returns a reference to the matrix.
+
+    \sa setMatrix()
+*/
+
+QMatrix &QMatrix::shear(qreal sh, qreal sv)
+{
+    qreal tm11 = sv*_m21;
+    qreal tm12 = sv*_m22;
+    qreal tm21 = sh*_m11;
+    qreal tm22 = sh*_m12;
+    _m11 += tm11;
+    _m12 += tm12;
+    _m21 += tm21;
+    _m22 += tm22;
+    return *this;
+}
+
+const qreal deg2rad = qreal(0.017453292519943295769);        // pi/180
+
+/*!
+    \fn QMatrix &QMatrix::rotate(qreal degrees)
+
+    Rotates the coordinate system the given \a degrees
+    counterclockwise.
+
+    Note that if you apply a QMatrix to a point defined in widget
+    coordinates, the direction of the rotation will be clockwise
+    because the y-axis points downwards.
+
+    Returns a reference to the matrix.
+
+    \sa setMatrix()
+*/
+
+QMatrix &QMatrix::rotate(qreal a)
+{
+    qreal sina = 0;
+    qreal cosa = 0;
+    if (a == 90. || a == -270.)
+        sina = 1.;
+    else if (a == 270. || a == -90.)
+        sina = -1.;
+    else if (a == 180.)
+        cosa = -1.;
+    else{
+        qreal b = deg2rad*a;                        // convert to radians
+        sina = qSin(b);               // fast and convenient
+        cosa = qCos(b);
+    }
+    qreal tm11 = cosa*_m11 + sina*_m21;
+    qreal tm12 = cosa*_m12 + sina*_m22;
+    qreal tm21 = -sina*_m11 + cosa*_m21;
+    qreal tm22 = -sina*_m12 + cosa*_m22;
+    _m11 = tm11; _m12 = tm12;
+    _m21 = tm21; _m22 = tm22;
+    return *this;
+}
+
+/*!
+    \fn bool QMatrix::isInvertible() const
+
+    Returns true if the matrix is invertible, otherwise returns false.
+
+    \sa inverted()
+*/
+
+/*!
+    \obsolete
+    \fn qreal QMatrix::det() const
+
+    Returns the matrix's determinant.
+
+    \sa determinant()
+*/
+
+/*!
+    \since 4.6
+    \fn qreal QMatrix::determinant() const
+
+    Returns the matrix's determinant.
+*/
+
+/*!
+    \fn QMatrix QMatrix::invert(bool *invertible) const
+
+    Returns an inverted copy of this matrix.
+
+    Use the inverted() function instead.
+*/
+
+/*!
+    Returns an inverted copy of this matrix.
+
+    If the matrix is singular (not invertible), the returned matrix is
+    the identity matrix. If \a invertible is valid (i.e. not 0), its
+    value is set to true if the matrix is invertible, otherwise it is
+    set to false.
+
+    \sa isInvertible()
+*/
+
+QMatrix QMatrix::inverted(bool *invertible) const
+{
+    qreal dtr = determinant();
+    if (dtr == 0.0) {
+        if (invertible)
+            *invertible = false;                // singular matrix
+        return QMatrix(true);
+    }
+    else {                                        // invertible matrix
+        if (invertible)
+            *invertible = true;
+        qreal dinv = 1.0/dtr;
+        return QMatrix((_m22*dinv),        (-_m12*dinv),
+                       (-_m21*dinv), (_m11*dinv),
+                       ((_m21*_dy - _m22*_dx)*dinv),
+                       ((_m12*_dx - _m11*_dy)*dinv),
+                       true);
+    }
+}
+
+
+/*!
+    \fn bool QMatrix::operator==(const QMatrix &matrix) const
+
+    Returns true if this matrix is equal to the given \a matrix,
+    otherwise returns false.
+*/
+
+bool QMatrix::operator==(const QMatrix &m) const
+{
+    return _m11 == m._m11 &&
+           _m12 == m._m12 &&
+           _m21 == m._m21 &&
+           _m22 == m._m22 &&
+           _dx == m._dx &&
+           _dy == m._dy;
+}
+
+/*!
+    \fn bool QMatrix::operator!=(const QMatrix &matrix) const
+
+    Returns true if this matrix is not equal to the given \a matrix,
+    otherwise returns false.
+*/
+
+bool QMatrix::operator!=(const QMatrix &m) const
+{
+    return _m11 != m._m11 ||
+           _m12 != m._m12 ||
+           _m21 != m._m21 ||
+           _m22 != m._m22 ||
+           _dx != m._dx ||
+           _dy != m._dy;
+}
+
+/*!
+    \fn QMatrix &QMatrix::operator *=(const QMatrix &matrix)
+    \overload
+
+    Returns the result of multiplying this matrix by the given \a
+    matrix.
+*/
+
+QMatrix &QMatrix::operator *=(const QMatrix &m)
+{
+    qreal tm11 = _m11*m._m11 + _m12*m._m21;
+    qreal tm12 = _m11*m._m12 + _m12*m._m22;
+    qreal tm21 = _m21*m._m11 + _m22*m._m21;
+    qreal tm22 = _m21*m._m12 + _m22*m._m22;
+
+    qreal tdx  = _dx*m._m11  + _dy*m._m21 + m._dx;
+    qreal tdy =  _dx*m._m12  + _dy*m._m22 + m._dy;
+
+    _m11 = tm11; _m12 = tm12;
+    _m21 = tm21; _m22 = tm22;
+    _dx = tdx; _dy = tdy;
+    return *this;
+}
+
+/*!
+    \fn QMatrix QMatrix::operator *(const QMatrix &matrix) const
+
+    Returns the result of multiplying this matrix by the given \a
+    matrix.
+
+    Note that matrix multiplication is not commutative, i.e. a*b !=
+    b*a.
+*/
+
+QMatrix QMatrix::operator *(const QMatrix &m) const
+{
+    qreal tm11 = _m11*m._m11 + _m12*m._m21;
+    qreal tm12 = _m11*m._m12 + _m12*m._m22;
+    qreal tm21 = _m21*m._m11 + _m22*m._m21;
+    qreal tm22 = _m21*m._m12 + _m22*m._m22;
+
+    qreal tdx  = _dx*m._m11  + _dy*m._m21 + m._dx;
+    qreal tdy =  _dx*m._m12  + _dy*m._m22 + m._dy;
+    return QMatrix(tm11, tm12, tm21, tm22, tdx, tdy, true);
+}
+
+/*!
+    Assigns the given \a matrix's values to this matrix.
+*/
+QMatrix &QMatrix::operator=(const QMatrix &matrix)
+{
+    _m11 = matrix._m11;
+    _m12 = matrix._m12;
+    _m21 = matrix._m21;
+    _m22 = matrix._m22;
+    _dx  = matrix._dx;
+    _dy  = matrix._dy;
+    return *this;
+}
+
+/*!
+    \since 4.2
+
+    Returns the matrix as a QVariant.
+*/
+QMatrix::operator QVariant() const
+{
+    return QVariant(QVariant::Matrix, this);
+}
+
+Q_GUI_EXPORT QPainterPath operator *(const QPainterPath &p, const QMatrix &m)
+{
+    return m.map(p);
+}
+
+
+/*****************************************************************************
+  QMatrix stream functions
+ *****************************************************************************/
+#ifndef QT_NO_DATASTREAM
+/*!
+    \fn QDataStream &operator<<(QDataStream &stream, const QMatrix &matrix)
+    \relates QMatrix
+
+    Writes the given \a matrix to the given \a stream and returns a
+    reference to the stream.
+
+    \sa {Serializing Qt Data Types}
+*/
+
+QDataStream &operator<<(QDataStream &s, const QMatrix &m)
+{
+    if (s.version() == 1) {
+        s << (float)m.m11() << (float)m.m12() << (float)m.m21()
+          << (float)m.m22() << (float)m.dx()  << (float)m.dy();
+    } else {
+        s << double(m.m11())
+          << double(m.m12())
+          << double(m.m21())
+          << double(m.m22())
+          << double(m.dx())
+          << double(m.dy());
+    }
+    return s;
+}
+
+/*!
+    \fn QDataStream &operator>>(QDataStream &stream, QMatrix &matrix)
+    \relates QMatrix
+
+    Reads the given \a matrix from the given \a stream and returns a
+    reference to the stream.
+
+    \sa {Serializing Qt Data Types}
+*/
+
+QDataStream &operator>>(QDataStream &s, QMatrix &m)
+{
+    if (s.version() == 1) {
+        float m11, m12, m21, m22, dx, dy;
+        s >> m11;  s >> m12;  s >> m21;  s >> m22;
+        s >> dx;   s >> dy;
+        m.setMatrix(m11, m12, m21, m22, dx, dy);
+    }
+    else {
+        double m11, m12, m21, m22, dx, dy;
+        s >> m11;
+        s >> m12;
+        s >> m21;
+        s >> m22;
+        s >> dx;
+        s >> dy;
+        m.setMatrix(m11, m12, m21, m22, dx, dy);
+    }
+    return s;
+}
+#endif // QT_NO_DATASTREAM
+
+#ifndef QT_NO_DEBUG_STREAM
+QDebug operator<<(QDebug dbg, const QMatrix &m)
+{
+    dbg.nospace() << "QMatrix("
+                  << "11=" << m.m11()
+                  << " 12=" << m.m12()
+                  << " 21=" << m.m21()
+                  << " 22=" << m.m22()
+                  << " dx=" << m.dx()
+                  << " dy=" << m.dy()
+                  << ')';
+    return dbg.space();
+}
+#endif
+
+/*!
+    \fn QRect QMatrix::map(const QRect &rect) const
+    \compat
+
+    Creates and returns a QRect object that is a copy of the given
+    rectangle, mapped into the coordinate system defined by this
+    matrix.
+
+    Use the mapRect() function instead.
+*/
+
+
+/*!
+    \fn bool qFuzzyCompare(const QMatrix& m1, const QMatrix& m2)
+
+    \relates QMatrix
+    \since 4.6
+
+    \brief The qFuzzyCompare function is for comparing two matrices
+    using a fuzziness factor.
+    
+    Returns true if \a m1 and \a m2 are equal, allowing for a small
+    fuzziness factor for floating-point comparisons; false otherwise.
+*/
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qmatrix.h b/src/gui/painting/qmatrix.h
new file mode 100644
index 0000000000..898cfa4cf2
--- /dev/null
+++ b/src/gui/painting/qmatrix.h
@@ -0,0 +1,206 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QMATRIX_H
+#define QMATRIX_H
+
+#include <QtGui/qpolygon.h>
+#include <QtGui/qregion.h>
+#include <QtGui/qwindowdefs.h>
+#include <QtCore/qline.h>
+#include <QtCore/qpoint.h>
+#include <QtCore/qrect.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+class QPainterPath;
+class QVariant;
+
+class Q_GUI_EXPORT QMatrix // 2D transform matrix
+{
+public:
+    inline explicit QMatrix(Qt::Initialization) {}
+    QMatrix();
+    QMatrix(qreal m11, qreal m12, qreal m21, qreal m22,
+            qreal dx, qreal dy);
+    QMatrix(const QMatrix &matrix);
+
+    void setMatrix(qreal m11, qreal m12, qreal m21, qreal m22,
+                   qreal dx, qreal dy);
+
+    qreal m11() const { return _m11; }
+    qreal m12() const { return _m12; }
+    qreal m21() const { return _m21; }
+    qreal m22() const { return _m22; }
+    qreal dx() const { return _dx; }
+    qreal dy() const { return _dy; }
+
+    void map(int x, int y, int *tx, int *ty) const;
+    void map(qreal x, qreal y, qreal *tx, qreal *ty) const;
+    QRect mapRect(const QRect &) const;
+    QRectF mapRect(const QRectF &) const;
+
+    QPoint map(const QPoint &p) const;
+    QPointF map(const QPointF&p) const;
+    QLine map(const QLine &l) const;
+    QLineF map(const QLineF &l) const;
+    QPolygonF map(const QPolygonF &a) const;
+    QPolygon map(const QPolygon &a) const;
+    QRegion map(const QRegion &r) const;
+    QPainterPath map(const QPainterPath &p) const;
+    QPolygon mapToPolygon(const QRect &r) const;
+
+    void reset();
+    inline bool isIdentity() const;
+
+    QMatrix &translate(qreal dx, qreal dy);
+    QMatrix &scale(qreal sx, qreal sy);
+    QMatrix &shear(qreal sh, qreal sv);
+    QMatrix &rotate(qreal a);
+
+    bool isInvertible() const { return !qFuzzyIsNull(_m11*_m22 - _m12*_m21); }
+    qreal determinant() const { return _m11*_m22 - _m12*_m21; }
+#ifdef QT_DEPRECATED
+    QT_DEPRECATED qreal det() const { return _m11*_m22 - _m12*_m21; }
+#endif
+
+    QMatrix inverted(bool *invertible = 0) const;
+
+    bool operator==(const QMatrix &) const;
+    bool operator!=(const QMatrix &) const;
+
+    QMatrix &operator*=(const QMatrix &);
+    QMatrix operator*(const QMatrix &o) const;
+
+    QMatrix &operator=(const QMatrix &);
+
+    operator QVariant() const;
+
+#ifdef QT3_SUPPORT
+    inline QT3_SUPPORT QMatrix invert(bool *invertible=0) const { return inverted(invertible); }
+    inline QT3_SUPPORT QRect map(const QRect &r) const { return mapRect(r); }
+    QT3_SUPPORT QRegion mapToRegion(const QRect &r) const;
+#endif
+
+private:
+    inline QMatrix(bool)
+            : _m11(1.)
+            , _m12(0.)
+            , _m21(0.)
+            , _m22(1.)
+            , _dx(0.)
+            , _dy(0.) {}
+    inline QMatrix(qreal am11, qreal am12, qreal am21, qreal am22, qreal adx, qreal ady, bool)
+            : _m11(am11)
+            , _m12(am12)
+            , _m21(am21)
+            , _m22(am22)
+            , _dx(adx)
+            , _dy(ady) {}
+    friend class QTransform;
+    qreal _m11, _m12;
+    qreal _m21, _m22;
+    qreal _dx, _dy;
+};
+Q_DECLARE_TYPEINFO(QMatrix, Q_MOVABLE_TYPE);
+
+// mathematical semantics
+Q_GUI_EXPORT_INLINE QPoint operator*(const QPoint &p, const QMatrix &m)
+{ return m.map(p); }
+Q_GUI_EXPORT_INLINE QPointF operator*(const QPointF &p, const QMatrix &m)
+{ return m.map(p); }
+Q_GUI_EXPORT_INLINE QLineF operator*(const QLineF &l, const QMatrix &m)
+{ return m.map(l); }
+Q_GUI_EXPORT_INLINE QLine operator*(const QLine &l, const QMatrix &m)
+{ return m.map(l); }
+Q_GUI_EXPORT_INLINE QPolygon operator *(const QPolygon &a, const QMatrix &m)
+{ return m.map(a); }
+Q_GUI_EXPORT_INLINE QPolygonF operator *(const QPolygonF &a, const QMatrix &m)
+{ return m.map(a); }
+Q_GUI_EXPORT_INLINE QRegion operator *(const QRegion &r, const QMatrix &m)
+{ return m.map(r); }
+Q_GUI_EXPORT QPainterPath operator *(const QPainterPath &p, const QMatrix &m);
+
+inline bool QMatrix::isIdentity() const
+{
+    return qFuzzyIsNull(_m11 - 1) && qFuzzyIsNull(_m22 - 1) && qFuzzyIsNull(_m12)
+           && qFuzzyIsNull(_m21) && qFuzzyIsNull(_dx) && qFuzzyIsNull(_dy);
+}
+
+inline bool qFuzzyCompare(const QMatrix& m1, const QMatrix& m2)
+{
+    return qFuzzyCompare(m1.m11(), m2.m11())
+        && qFuzzyCompare(m1.m12(), m2.m12())
+        && qFuzzyCompare(m1.m21(), m2.m21())
+        && qFuzzyCompare(m1.m22(), m2.m22())
+        && qFuzzyCompare(m1.dx(), m2.dx())
+        && qFuzzyCompare(m1.dy(), m2.dy());
+}
+
+
+/*****************************************************************************
+ QMatrix stream functions
+ *****************************************************************************/
+
+#ifndef QT_NO_DATASTREAM
+Q_GUI_EXPORT QDataStream &operator<<(QDataStream &, const QMatrix &);
+Q_GUI_EXPORT QDataStream &operator>>(QDataStream &, QMatrix &);
+#endif
+
+#ifndef QT_NO_DEBUG_STREAM
+Q_GUI_EXPORT QDebug operator<<(QDebug, const QMatrix &);
+#endif
+
+#ifdef QT3_SUPPORT
+QT_BEGIN_INCLUDE_NAMESPACE
+#include <QtGui/qwmatrix.h>
+QT_END_INCLUDE_NAMESPACE
+#endif
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QMATRIX_H
diff --git a/src/gui/painting/qmemrotate.cpp b/src/gui/painting/qmemrotate.cpp
new file mode 100644
index 0000000000..fe524aff3b
--- /dev/null
+++ b/src/gui/painting/qmemrotate.cpp
@@ -0,0 +1,648 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "private/qmemrotate_p.h"
+
+QT_BEGIN_NAMESPACE
+
+#if QT_ROTATION_ALGORITHM == QT_ROTATION_TILED
+static const int tileSize = 32;
+#endif
+
+#if Q_BYTE_ORDER == Q_BIG_ENDIAN
+#if QT_ROTATION_ALGORITHM == QT_ROTATION_PACKED || QT_ROTATION_ALGORITHM == QT_ROTATION_TILED
+#error Big endian version not implemented for the transformed driver!
+#endif
+#endif
+
+template <class DST, class SRC>
+Q_STATIC_TEMPLATE_FUNCTION inline void qt_memrotate90_cachedRead(const SRC *src, int w, int h,
+                                             int sstride,
+                                             DST *dest, int dstride)
+{
+    const char *s = reinterpret_cast<const char*>(src);
+    char *d = reinterpret_cast<char*>(dest);
+    for (int y = 0; y < h; ++y) {
+        for (int x = w - 1; x >= 0; --x) {
+            DST *destline = reinterpret_cast<DST*>(d + (w - x - 1) * dstride);
+            destline[y] = qt_colorConvert<DST,SRC>(src[x], 0);
+        }
+        s += sstride;
+        src = reinterpret_cast<const SRC*>(s);
+    }
+}
+
+template <class DST, class SRC>
+Q_STATIC_TEMPLATE_FUNCTION inline void qt_memrotate270_cachedRead(const SRC *src, int w, int h,
+                                              int sstride,
+                                              DST *dest, int dstride)
+{
+    const char *s = reinterpret_cast<const char*>(src);
+    char *d = reinterpret_cast<char*>(dest);
+    s += (h - 1) * sstride;
+    for (int y = h - 1; y >= 0; --y) {
+        src = reinterpret_cast<const SRC*>(s);
+        for (int x = 0; x < w; ++x) {
+            DST *destline = reinterpret_cast<DST*>(d + x * dstride);
+            destline[h - y - 1] = qt_colorConvert<DST,SRC>(src[x], 0);
+        }
+        s -= sstride;
+    }
+}
+
+#if QT_ROTATION_ALGORITHM == QT_ROTATION_CACHEDWRITE
+
+template <class DST, class SRC>
+Q_STATIC_TEMPLATE_FUNCTION inline void qt_memrotate90_cachedWrite(const SRC *src, int w, int h,
+                                              int sstride,
+                                              DST *dest, int dstride)
+{
+    for (int x = w - 1; x >= 0; --x) {
+        DST *d = dest + (w - x - 1) * dstride;
+        for (int y = 0; y < h; ++y) {
+            *d++ = qt_colorConvert<DST,SRC>(src[y * sstride + x], 0);
+        }
+    }
+
+}
+
+template <class DST, class SRC>
+Q_STATIC_TEMPLATE_FUNCTION inline void qt_memrotate270_cachedWrite(const SRC *src, int w, int h,
+                                               int sstride,
+                                               DST *dest, int dstride)
+{
+    for (int x = 0; x < w; ++x) {
+        DST *d = dest + x * dstride;
+        for (int y = h - 1; y >= 0; --y) {
+            *d++ = qt_colorConvert<DST,SRC>(src[y * sstride + x], 0);
+        }
+    }
+}
+
+#endif // QT_ROTATION_CACHEDWRITE
+
+#if QT_ROTATION_ALGORITHM == QT_ROTATION_PACKING
+
+// TODO: packing algorithms should probably be modified on 64-bit architectures
+
+template <class DST, class SRC>
+Q_STATIC_TEMPLATE_FUNCTION inline void qt_memrotate90_packing(const SRC *src, int w, int h,
+                                          int sstride,
+                                          DST *dest, int dstride)
+{
+    sstride /= sizeof(SRC);
+    dstride /= sizeof(DST);
+
+    const int pack = sizeof(quint32) / sizeof(DST);
+    const int unaligned = int((long(dest) & (sizeof(quint32)-1))) / sizeof(DST);
+
+    for (int x = w - 1; x >= 0; --x) {
+        int y = 0;
+
+        for (int i = 0; i < unaligned; ++i) {
+            dest[(w - x - 1) * dstride + y]
+                = qt_colorConvert<DST,SRC>(src[y * sstride + x], 0);
+            ++y;
+        }
+
+        quint32 *d = reinterpret_cast<quint32*>(dest + (w - x - 1) * dstride
+                                                + unaligned);
+        const int rest = (h - unaligned) % pack;
+        while (y < h - rest) {
+            quint32 c = qt_colorConvert<DST,SRC>(src[y * sstride + x], 0);
+            for (int i = 1; i < pack; ++i) {
+                c |= qt_colorConvert<DST,SRC>(src[(y + i) * sstride + x], 0)
+                     << (sizeof(int) * 8 / pack * i);
+            }
+            *d++ = c;
+            y += pack;
+        }
+
+        while (y < h) {
+            dest[(w - x - 1) * dstride + y]
+                = qt_colorConvert<DST,SRC>(src[y * sstride + x], 0);
+            ++y;
+        }
+    }
+}
+
+template <class DST, class SRC>
+Q_STATIC_TEMPLATE_FUNCTION inline void qt_memrotate270_packing(const SRC *src, int w, int h,
+                                           int sstride,
+                                           DST *dest, int dstride)
+{
+    sstride /= sizeof(SRC);
+    dstride /= sizeof(DST);
+
+    const int pack = sizeof(quint32) / sizeof(DST);
+    const int unaligned = int((long(dest) & (sizeof(quint32)-1))) / sizeof(DST);
+
+    for (int x = 0; x < w; ++x) {
+        int y = h - 1;
+
+        for (int i = 0; i < unaligned; ++i) {
+            dest[x * dstride + h - y - 1]
+                = qt_colorConvert<DST,SRC>(src[y * sstride + x], 0);
+            --y;
+        }
+
+        quint32 *d = reinterpret_cast<quint32*>(dest + x * dstride
+                                                + unaligned);
+        const int rest = (h - unaligned) % pack;
+        while (y > rest) {
+            quint32 c = qt_colorConvert<DST,SRC>(src[y * sstride + x], 0);
+            for (int i = 1; i < pack; ++i) {
+                c |= qt_colorConvert<DST,SRC>(src[(y - i) * sstride + x], 0)
+                     << (sizeof(int) * 8 / pack * i);
+            }
+            *d++ = c;
+            y -= pack;
+        }
+        while (y >= 0) {
+            dest[x * dstride + h - y - 1]
+                = qt_colorConvert<DST,SRC>(src[y * sstride + x], 0);
+            --y;
+        }
+    }
+}
+
+#endif // QT_ROTATION_PACKING
+
+#if QT_ROTATION_ALGORITHM == QT_ROTATION_TILED
+template <class DST, class SRC>
+Q_STATIC_TEMPLATE_FUNCTION inline void qt_memrotate90_tiled(const SRC *src, int w, int h,
+                                        int sstride,
+                                        DST *dest, int dstride)
+{
+    sstride /= sizeof(SRC);
+    dstride /= sizeof(DST);
+
+    const int pack = sizeof(quint32) / sizeof(DST);
+    const int unaligned =
+        qMin(uint((quintptr(dest) & (sizeof(quint32)-1)) / sizeof(DST)), uint(h));
+    const int restX = w % tileSize;
+    const int restY = (h - unaligned) % tileSize;
+    const int unoptimizedY = restY % pack;
+    const int numTilesX = w / tileSize + (restX > 0);
+    const int numTilesY = (h - unaligned) / tileSize + (restY >= pack);
+
+    for (int tx = 0; tx < numTilesX; ++tx) {
+        const int startx = w - tx * tileSize - 1;
+        const int stopx = qMax(startx - tileSize, 0);
+
+        if (unaligned) {
+            for (int x = startx; x >= stopx; --x) {
+                DST *d = dest + (w - x - 1) * dstride;
+                for (int y = 0; y < unaligned; ++y) {
+                    *d++ = qt_colorConvert<DST,SRC>(src[y * sstride + x], 0);
+                }
+            }
+        }
+
+        for (int ty = 0; ty < numTilesY; ++ty) {
+            const int starty = ty * tileSize + unaligned;
+            const int stopy = qMin(starty + tileSize, h - unoptimizedY);
+
+            for (int x = startx; x >= stopx; --x) {
+                quint32 *d = reinterpret_cast<quint32*>(dest + (w - x - 1) * dstride + starty);
+                for (int y = starty; y < stopy; y += pack) {
+                    quint32 c = qt_colorConvert<DST,SRC>(src[y * sstride + x], 0);
+                    for (int i = 1; i < pack; ++i) {
+                        const int shift = (sizeof(int) * 8 / pack * i);
+                        const DST color = qt_colorConvert<DST,SRC>(src[(y + i) * sstride + x], 0);
+                        c |= color << shift;
+                    }
+                    *d++ = c;
+                }
+            }
+        }
+
+        if (unoptimizedY) {
+            const int starty = h - unoptimizedY;
+            for (int x = startx; x >= stopx; --x) {
+                DST *d = dest + (w - x - 1) * dstride + starty;
+                for (int y = starty; y < h; ++y) {
+                    *d++ = qt_colorConvert<DST,SRC>(src[y * sstride + x], 0);
+                }
+            }
+        }
+    }
+}
+
+template <class DST, class SRC>
+Q_STATIC_TEMPLATE_FUNCTION inline void qt_memrotate90_tiled_unpacked(const SRC *src, int w, int h,
+                                                 int sstride,
+                                                 DST *dest, int dstride)
+{
+    const int numTilesX = (w + tileSize - 1) / tileSize;
+    const int numTilesY = (h + tileSize - 1) / tileSize;
+
+    for (int tx = 0; tx < numTilesX; ++tx) {
+        const int startx = w - tx * tileSize - 1;
+        const int stopx = qMax(startx - tileSize, 0);
+
+        for (int ty = 0; ty < numTilesY; ++ty) {
+            const int starty = ty * tileSize;
+            const int stopy = qMin(starty + tileSize, h);
+
+            for (int x = startx; x >= stopx; --x) {
+                DST *d = (DST*)((char*)dest + (w - x - 1) * dstride) + starty;
+                const char *s = (const char*)(src + x) + starty * sstride;
+                for (int y = starty; y < stopy; ++y) {
+                    *d++ = qt_colorConvert<DST,SRC>(*(const SRC*)(s), 0);
+                    s += sstride;
+                }
+            }
+        }
+    }
+}
+
+template <class DST, class SRC>
+Q_STATIC_TEMPLATE_FUNCTION inline void qt_memrotate270_tiled(const SRC *src, int w, int h,
+                                         int sstride,
+                                         DST *dest, int dstride)
+{
+    sstride /= sizeof(SRC);
+    dstride /= sizeof(DST);
+
+    const int pack = sizeof(quint32) / sizeof(DST);
+    const int unaligned =
+        qMin(uint((long(dest) & (sizeof(quint32)-1)) / sizeof(DST)), uint(h));
+    const int restX = w % tileSize;
+    const int restY = (h - unaligned) % tileSize;
+    const int unoptimizedY = restY % pack;
+    const int numTilesX = w / tileSize + (restX > 0);
+    const int numTilesY = (h - unaligned) / tileSize + (restY >= pack);
+
+    for (int tx = 0; tx < numTilesX; ++tx) {
+        const int startx = tx * tileSize;
+        const int stopx = qMin(startx + tileSize, w);
+
+        if (unaligned) {
+            for (int x = startx; x < stopx; ++x) {
+                DST *d = dest + x * dstride;
+                for (int y = h - 1; y >= h - unaligned; --y) {
+                    *d++ = qt_colorConvert<DST,SRC>(src[y * sstride + x], 0);
+                }
+            }
+        }
+
+        for (int ty = 0; ty < numTilesY; ++ty) {
+            const int starty = h - 1 - unaligned - ty * tileSize;
+            const int stopy = qMax(starty - tileSize, unoptimizedY);
+
+            for (int x = startx; x < stopx; ++x) {
+                quint32 *d = reinterpret_cast<quint32*>(dest + x * dstride
+                                                        + h - 1 - starty);
+                for (int y = starty; y > stopy; y -= pack) {
+                    quint32 c = qt_colorConvert<DST,SRC>(src[y * sstride + x], 0);
+                    for (int i = 1; i < pack; ++i) {
+                        const int shift = (sizeof(int) * 8 / pack * i);
+                        const DST color = qt_colorConvert<DST,SRC>(src[(y - i) * sstride + x], 0);
+                        c |= color << shift;
+                    }
+                    *d++ = c;
+                }
+            }
+        }
+        if (unoptimizedY) {
+            const int starty = unoptimizedY - 1;
+            for (int x = startx; x < stopx; ++x) {
+                DST *d = dest + x * dstride + h - 1 - starty;
+                for (int y = starty; y >= 0; --y) {
+                    *d++ = qt_colorConvert<DST,SRC>(src[y * sstride + x], 0);
+                }
+            }
+        }
+    }
+}
+
+template <class DST, class SRC>
+Q_STATIC_TEMPLATE_FUNCTION inline void qt_memrotate270_tiled_unpacked(const SRC *src, int w, int h,
+                                                  int sstride,
+                                                  DST *dest, int dstride)
+{
+    const int numTilesX = (w + tileSize - 1) / tileSize;
+    const int numTilesY = (h + tileSize - 1) / tileSize;
+
+    for (int tx = 0; tx < numTilesX; ++tx) {
+        const int startx = tx * tileSize;
+        const int stopx = qMin(startx + tileSize, w);
+
+        for (int ty = 0; ty < numTilesY; ++ty) {
+            const int starty = h - 1 - ty * tileSize;
+            const int stopy = qMax(starty - tileSize, 0);
+
+            for (int x = startx; x < stopx; ++x) {
+                DST *d = (DST*)((char*)dest + x * dstride) + h - 1 - starty;
+                const char *s = (const char*)(src + x) + starty * sstride;
+                for (int y = starty; y >= stopy; --y) {
+                    *d++ = qt_colorConvert<DST,SRC>(*(const SRC*)s, 0);
+                    s -= sstride;
+                }
+            }
+        }
+    }
+}
+
+#endif // QT_ROTATION_ALGORITHM
+
+template <class DST, class SRC>
+Q_STATIC_TEMPLATE_FUNCTION inline void qt_memrotate90_template(const SRC *src,
+                                           int srcWidth, int srcHeight, int srcStride,
+                                           DST *dest, int dstStride)
+{
+#if QT_ROTATION_ALGORITHM == QT_ROTATION_CACHEDREAD
+    qt_memrotate90_cachedRead<DST,SRC>(src, srcWidth, srcHeight, srcStride,
+                                       dest, dstStride);
+#elif QT_ROTATION_ALGORITHM == QT_ROTATION_CACHEDWRITE
+    qt_memrotate90_cachedWrite<DST,SRC>(src, srcWidth, srcHeight, srcStride,
+                                        dest, dstStride);
+#elif QT_ROTATION_ALGORITHM == QT_ROTATION_PACKING
+    qt_memrotate90_packing<DST,SRC>(src, srcWidth, srcHeight, srcStride,
+                                    dest, dstStride);
+#elif QT_ROTATION_ALGORITHM == QT_ROTATION_TILED
+    qt_memrotate90_tiled<DST,SRC>(src, srcWidth, srcHeight, srcStride,
+                                  dest, dstStride);
+#endif
+}
+
+template <class DST, class SRC>
+Q_STATIC_TEMPLATE_FUNCTION inline void qt_memrotate180_template(const SRC *src,
+                                            int w, int h, int sstride,
+                                            DST *dest, int dstride)
+{
+    const char *s = (const char*)(src) + (h - 1) * sstride;
+    for (int y = h - 1; y >= 0; --y) {
+        DST *d = reinterpret_cast<DST*>((char *)(dest) + (h - y - 1) * dstride);
+        src = reinterpret_cast<const SRC*>(s);
+        for (int x = w - 1; x >= 0; --x) {
+            d[w - x - 1] = qt_colorConvert<DST,SRC>(src[x], 0);
+        }
+        s -= sstride;
+    }
+}
+
+template <class DST, class SRC>
+Q_STATIC_TEMPLATE_FUNCTION inline void qt_memrotate270_template(const SRC *src,
+                                            int srcWidth, int srcHeight, int srcStride,
+                                            DST *dest, int dstStride)
+{
+#if QT_ROTATION_ALGORITHM == QT_ROTATION_CACHEDREAD
+    qt_memrotate270_cachedRead<DST,SRC>(src, srcWidth, srcHeight, srcStride,
+                                        dest, dstStride);
+#elif QT_ROTATION_ALGORITHM == QT_ROTATION_CACHEDWRITE
+    qt_memrotate270_cachedWrite<DST,SRC>(src, srcWidth, srcHeight, srcStride,
+                                         dest, dstStride);
+#elif QT_ROTATION_ALGORITHM == QT_ROTATION_PACKING
+    qt_memrotate270_packing<DST,SRC>(src, srcWidth, srcHeight, srcStride,
+                                     dest, dstStride);
+#elif QT_ROTATION_ALGORITHM == QT_ROTATION_TILED
+    qt_memrotate270_tiled_unpacked<DST,SRC>(src, srcWidth, srcHeight,
+                                            srcStride,
+                                            dest, dstStride);
+#endif
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline void qt_memrotate90_template<quint24, quint24>(const quint24 *src,
+                                                             int srcWidth, int srcHeight, int srcStride,
+                                                             quint24 *dest, int dstStride)
+{
+#if QT_ROTATION_ALGORITHM == QT_ROTATION_CACHEDREAD
+    qt_memrotate90_cachedRead<quint24,quint24>(src, srcWidth, srcHeight,
+                                               srcStride, dest, dstStride);
+#elif QT_ROTATION_ALGORITHM == QT_ROTATION_CACHEDWRITE
+    qt_memrotate90_cachedWrite<quint24,quint24>(src, srcWidth, srcHeight,
+                                                srcStride, dest, dstStride);
+#elif QT_ROTATION_ALGORITHM == QT_ROTATION_PACKING
+    // packed algorithm not implemented
+    qt_memrotate90_cachedRead<quint24,quint24>(src, srcWidth, srcHeight,
+                                               srcStride, dest, dstStride);
+#elif QT_ROTATION_ALGORITHM == QT_ROTATION_TILED
+    // packed algorithm not implemented
+    qt_memrotate90_tiled_unpacked<quint24,quint24>(src, srcWidth, srcHeight,
+                                                   srcStride, dest, dstStride);
+#endif
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline void qt_memrotate90_template<quint24, quint32>(const quint32 *src,
+                                                             int srcWidth, int srcHeight, int srcStride,
+                                                             quint24 *dest, int dstStride)
+{
+#if QT_ROTATION_ALGORITHM == QT_ROTATION_CACHEDREAD
+    qt_memrotate90_cachedRead<quint24,quint32>(src, srcWidth, srcHeight,
+                                               srcStride, dest, dstStride);
+#elif QT_ROTATION_ALGORITHM == QT_ROTATION_CACHEDWRITE
+    qt_memrotate90_cachedWrite<quint24,quint32>(src, srcWidth, srcHeight,
+                                                srcStride, dest, dstStride);
+#elif QT_ROTATION_ALGORITHM == QT_ROTATION_PACKING
+    // packed algorithm not implemented
+    qt_memrotate90_cachedRead<quint24,quint32>(src, srcWidth, srcHeight,
+                                               srcStride, dest, dstStride);
+#elif QT_ROTATION_ALGORITHM == QT_ROTATION_TILED
+    // packed algorithm not implemented
+    qt_memrotate90_tiled_unpacked<quint24,quint32>(src, srcWidth, srcHeight,
+                                                   srcStride, dest, dstStride);
+#endif
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline void qt_memrotate90_template<quint18, quint32>(const quint32 *src,
+                                                             int srcWidth, int srcHeight, int srcStride,
+                                                             quint18 *dest, int dstStride)
+{
+#if QT_ROTATION_ALGORITHM == QT_ROTATION_CACHEDREAD
+    qt_memrotate90_cachedRead<quint18,quint32>(src, srcWidth, srcHeight,
+                                               srcStride, dest, dstStride);
+#elif QT_ROTATION_ALGORITHM == QT_ROTATION_CACHEDWRITE
+    qt_memrotate90_cachedWrite<quint18,quint32>(src, srcWidth, srcHeight,
+                                                srcStride, dest, dstStride);
+#elif QT_ROTATION_ALGORITHM == QT_ROTATION_PACKING
+    // packed algorithm not implemented
+    qt_memrotate90_cachedRead<quint18,quint32>(src, srcWidth, srcHeight,
+                                               srcStride, dest, dstStride);
+#elif QT_ROTATION_ALGORITHM == QT_ROTATION_TILED
+    // packed algorithm not implemented
+    qt_memrotate90_tiled_unpacked<quint18,quint32>(src, srcWidth, srcHeight,
+                                                   srcStride, dest, dstStride);
+#endif
+}
+
+#define QT_IMPL_MEMROTATE(srctype, desttype)                        \
+void qt_memrotate90(const srctype *src, int w, int h, int sstride,  \
+                    desttype *dest, int dstride)                    \
+{                                                                   \
+    qt_memrotate90_template(src, w, h, sstride, dest, dstride);     \
+}                                                                   \
+void qt_memrotate180(const srctype *src, int w, int h, int sstride, \
+                     desttype *dest, int dstride)                   \
+{                                                                   \
+    qt_memrotate180_template(src, w, h, sstride, dest, dstride);    \
+}                                                                   \
+void qt_memrotate270(const srctype *src, int w, int h, int sstride, \
+                     desttype *dest, int dstride)                   \
+{                                                                   \
+    qt_memrotate270_template(src, w, h, sstride, dest, dstride);    \
+}
+
+#define QT_IMPL_SIMPLE_MEMROTATE(srctype, desttype)                 \
+void qt_memrotate90(const srctype *src, int w, int h, int sstride,  \
+                    desttype *dest, int dstride)                    \
+{                                                                   \
+    qt_memrotate90_tiled_unpacked<desttype,srctype>(src, w, h, sstride, dest, dstride); \
+}                                                                   \
+void qt_memrotate180(const srctype *src, int w, int h, int sstride, \
+                     desttype *dest, int dstride)                   \
+{                                                                   \
+    qt_memrotate180_template(src, w, h, sstride, dest, dstride);    \
+}                                                                   \
+void qt_memrotate270(const srctype *src, int w, int h, int sstride, \
+                     desttype *dest, int dstride)                   \
+{                                                                   \
+    qt_memrotate270_tiled_unpacked<desttype,srctype>(src, w, h, sstride, dest, dstride); \
+}
+
+
+
+
+QT_IMPL_MEMROTATE(quint32, quint32)
+QT_IMPL_MEMROTATE(quint32, quint16)
+QT_IMPL_MEMROTATE(quint16, quint32)
+QT_IMPL_MEMROTATE(quint16, quint16)
+QT_IMPL_MEMROTATE(quint24, quint24)
+QT_IMPL_MEMROTATE(quint32, quint24)
+QT_IMPL_MEMROTATE(quint32, quint18)
+QT_IMPL_MEMROTATE(quint32, quint8)
+QT_IMPL_MEMROTATE(quint16, quint8)
+QT_IMPL_MEMROTATE(qrgb444, quint8)
+QT_IMPL_MEMROTATE(quint8, quint8)
+
+#if defined(QT_QWS_ROTATE_BGR)
+QT_IMPL_SIMPLE_MEMROTATE(quint16, qbgr565)
+QT_IMPL_SIMPLE_MEMROTATE(quint32, qbgr565)
+QT_IMPL_SIMPLE_MEMROTATE(qrgb555, qbgr555)
+QT_IMPL_SIMPLE_MEMROTATE(quint32, qbgr555)
+#endif
+
+#ifdef QT_QWS_DEPTH_GENERIC
+QT_IMPL_MEMROTATE(quint32, qrgb_generic16)
+QT_IMPL_MEMROTATE(quint16, qrgb_generic16)
+#endif
+
+struct qrgb_gl_rgba
+{
+public:
+    inline qrgb_gl_rgba(quint32 v) {
+        if (QSysInfo::ByteOrder == QSysInfo::LittleEndian)
+            data = ((v << 16) & 0xff0000) | ((v >> 16) & 0xff) | (v & 0xff00ff00);
+        else
+            data = (v << 8) | ((v >> 24) & 0xff);
+    }
+
+    inline operator quint32() const { return data; }
+
+private:
+    quint32 data;
+} Q_PACKED;
+
+void Q_GUI_EXPORT qt_memrotate90_gl(const quint32 *src, int srcWidth, int srcHeight, int srcStride,
+                                    quint32 *dest, int dstStride)
+{
+    qt_memrotate90_template(src, srcWidth, srcHeight, srcStride, reinterpret_cast<qrgb_gl_rgba *>(dest), dstStride);
+}
+
+void qt_memrotate90_16(const uchar *srcPixels, int w, int h, int sbpl, uchar *destPixels, int dbpl)
+{
+    qt_memrotate90((const ushort *)srcPixels, w, h, sbpl, (ushort *)destPixels, dbpl);
+}
+
+void qt_memrotate180_16(const uchar *srcPixels, int w, int h, int sbpl, uchar *destPixels, int dbpl)
+{
+    qt_memrotate180((const ushort *)srcPixels, w, h, sbpl, (ushort *)destPixels, dbpl);
+}
+
+void qt_memrotate270_16(const uchar *srcPixels, int w, int h, int sbpl, uchar *destPixels, int dbpl)
+{
+    qt_memrotate270((const ushort *)srcPixels, w, h, sbpl, (ushort *)destPixels, dbpl);
+}
+
+void qt_memrotate90_32(const uchar *srcPixels, int w, int h, int sbpl, uchar *destPixels, int dbpl)
+{
+    qt_memrotate90((const uint *)srcPixels, w, h, sbpl, (uint *)destPixels, dbpl);
+}
+
+void qt_memrotate180_32(const uchar *srcPixels, int w, int h, int sbpl, uchar *destPixels, int dbpl)
+{
+    qt_memrotate180((const uint *)srcPixels, w, h, sbpl, (uint *)destPixels, dbpl);
+}
+
+void qt_memrotate270_32(const uchar *srcPixels, int w, int h, int sbpl, uchar *destPixels, int dbpl)
+{
+    qt_memrotate270((const uint *)srcPixels, w, h, sbpl, (uint *)destPixels, dbpl);
+}
+
+MemRotateFunc qMemRotateFunctions[QImage::NImageFormats][3] =
+// 90, 180, 270
+{
+    { 0, 0, 0 },      // Format_Invalid,
+    { 0, 0, 0 },      // Format_Mono,
+    { 0, 0, 0 },      // Format_MonoLSB,
+    { 0, 0, 0 },      // Format_Indexed8,
+    { qt_memrotate90_32, qt_memrotate180_32, qt_memrotate270_32 },      // Format_RGB32,
+    { qt_memrotate90_32, qt_memrotate180_32, qt_memrotate270_32 },      // Format_ARGB32,
+    { qt_memrotate90_32, qt_memrotate180_32, qt_memrotate270_32 },      // Format_ARGB32_Premultiplied,
+    { qt_memrotate90_16, qt_memrotate180_16, qt_memrotate270_16 },      // Format_RGB16,
+    { 0, 0, 0 },      // Format_ARGB8565_Premultiplied,
+    { 0, 0, 0 },      // Format_RGB666,
+    { 0, 0, 0 },      // Format_ARGB6666_Premultiplied,
+    { 0, 0, 0 },      // Format_RGB555,
+    { 0, 0, 0 },      // Format_ARGB8555_Premultiplied,
+    { 0, 0, 0 },      // Format_RGB888,
+    { 0, 0, 0 },      // Format_RGB444,
+    { 0, 0, 0 }       // Format_ARGB4444_Premultiplied,
+};
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qmemrotate_p.h b/src/gui/painting/qmemrotate_p.h
new file mode 100644
index 0000000000..ecfa39397c
--- /dev/null
+++ b/src/gui/painting/qmemrotate_p.h
@@ -0,0 +1,115 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QMEMROTATE_P_H
+#define QMEMROTATE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "private/qdrawhelper_p.h"
+
+QT_BEGIN_NAMESPACE
+
+#define QT_ROTATION_CACHEDREAD 1
+#define QT_ROTATION_CACHEDWRITE 2
+#define QT_ROTATION_PACKING 3
+#define QT_ROTATION_TILED 4
+
+#ifndef QT_ROTATION_ALGORITHM
+#if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
+#define QT_ROTATION_ALGORITHM QT_ROTATION_TILED
+#else
+#define QT_ROTATION_ALGORITHM QT_ROTATION_CACHEDREAD
+#endif
+#endif
+
+#ifdef Q_WS_QWS
+#define Q_GUI_QWS_EXPORT Q_GUI_EXPORT
+#else
+#define Q_GUI_QWS_EXPORT
+#endif
+
+#define QT_DECL_MEMROTATE(srctype, desttype)                            \
+    void Q_GUI_QWS_EXPORT qt_memrotate90(const srctype*, int, int, int, desttype*, int); \
+    void Q_GUI_QWS_EXPORT qt_memrotate180(const srctype*, int, int, int, desttype*, int); \
+    void Q_GUI_QWS_EXPORT qt_memrotate270(const srctype*, int, int, int, desttype*, int)
+
+void Q_GUI_EXPORT qt_memrotate90(const quint32*, int, int, int, quint32*, int);
+void Q_GUI_QWS_EXPORT qt_memrotate180(const quint32*, int, int, int, quint32*, int);
+void Q_GUI_QWS_EXPORT qt_memrotate270(const quint32*, int, int, int, quint32*, int);
+
+QT_DECL_MEMROTATE(quint32, quint16);
+QT_DECL_MEMROTATE(quint16, quint32);
+QT_DECL_MEMROTATE(quint16, quint16);
+QT_DECL_MEMROTATE(quint24, quint24);
+QT_DECL_MEMROTATE(quint32, quint24);
+QT_DECL_MEMROTATE(quint32, quint18);
+QT_DECL_MEMROTATE(quint32, quint8);
+QT_DECL_MEMROTATE(quint16, quint8);
+QT_DECL_MEMROTATE(qrgb444, quint8);
+QT_DECL_MEMROTATE(quint8, quint8);
+
+#ifdef QT_QWS_ROTATE_BGR
+QT_DECL_MEMROTATE(quint16, qbgr565);
+QT_DECL_MEMROTATE(quint32, qbgr565);
+QT_DECL_MEMROTATE(qrgb555, qbgr555);
+QT_DECL_MEMROTATE(quint32, qbgr555);
+#endif
+
+#ifdef QT_QWS_DEPTH_GENERIC
+QT_DECL_MEMROTATE(quint32, qrgb_generic16);
+QT_DECL_MEMROTATE(quint16, qrgb_generic16);
+#endif
+
+#undef QT_DECL_MEMROTATE
+
+QT_END_NAMESPACE
+
+#endif // QMEMROTATE_P_H
diff --git a/src/gui/painting/qoutlinemapper.cpp b/src/gui/painting/qoutlinemapper.cpp
new file mode 100644
index 0000000000..aac50838d7
--- /dev/null
+++ b/src/gui/painting/qoutlinemapper.cpp
@@ -0,0 +1,393 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qoutlinemapper_p.h"
+#include <private/qpainterpath_p.h>
+#include "qmath.h"
+
+#include <stdlib.h>
+
+QT_BEGIN_NAMESPACE
+
+#define qreal_to_fixed_26_6(f) (int(f * 64))
+
+
+
+
+static const QRectF boundingRect(const QPointF *points, int pointCount)
+{
+    const QPointF *e = points;
+    const QPointF *last = points + pointCount;
+    qreal minx, maxx, miny, maxy;
+    minx = maxx = e->x();
+    miny = maxy = e->y();
+    while (++e < last) {
+        if (e->x() < minx)
+            minx = e->x();
+        else if (e->x() > maxx)
+            maxx = e->x();
+        if (e->y() < miny)
+            miny = e->y();
+        else if (e->y() > maxy)
+            maxy = e->y();
+    }
+    return QRectF(QPointF(minx, miny), QPointF(maxx, maxy));
+}
+
+
+QT_FT_Outline *QOutlineMapper::convertPath(const QPainterPath &path)
+{
+    Q_ASSERT(!path.isEmpty());
+    int elmCount = path.elementCount();
+#ifdef QT_DEBUG_CONVERT
+    printf("QOutlineMapper::convertPath(), size=%d\n", elmCount);
+#endif
+    beginOutline(path.fillRule());
+
+    for (int index=0; index<elmCount; ++index) {
+        const QPainterPath::Element &elm = path.elementAt(index);
+
+        switch (elm.type) {
+
+        case QPainterPath::MoveToElement:
+            if (index == elmCount - 1)
+                continue;
+            moveTo(elm);
+            break;
+
+        case QPainterPath::LineToElement:
+            lineTo(elm);
+            break;
+
+        case QPainterPath::CurveToElement:
+            curveTo(elm, path.elementAt(index + 1), path.elementAt(index + 2));
+            index += 2;
+            break;
+
+        default:
+            break; // This will never hit..
+        }
+    }
+
+    endOutline();
+    return outline();
+}
+
+QT_FT_Outline *QOutlineMapper::convertPath(const QVectorPath &path)
+{
+    int count = path.elementCount();
+
+#ifdef QT_DEBUG_CONVERT
+    printf("QOutlineMapper::convertPath(VP), size=%d\n", count);
+#endif
+    beginOutline(path.hasWindingFill() ? Qt::WindingFill : Qt::OddEvenFill);
+
+    if (path.elements()) {
+        // TODO: if we do closing of subpaths in convertElements instead we
+        // could avoid this loop
+        const QPainterPath::ElementType *elements = path.elements();
+        const QPointF *points = reinterpret_cast<const QPointF *>(path.points());
+
+        for (int index = 0; index < count; ++index) {
+            switch (elements[index]) {
+                case QPainterPath::MoveToElement:
+                    if (index == count - 1)
+                        continue;
+                    moveTo(points[index]);
+                    break;
+
+                case QPainterPath::LineToElement:
+                    lineTo(points[index]);
+                    break;
+
+                case QPainterPath::CurveToElement:
+                    curveTo(points[index], points[index+1], points[index+2]);
+                    index += 2;
+                    break;
+
+                default:
+                    break; // This will never hit..
+            }
+        }
+
+    } else {
+        // ### We can kill this copying and just use the buffer straight...
+
+        m_elements.resize(count);
+        if (count)
+            memcpy(m_elements.data(), path.points(), count* sizeof(QPointF));
+
+        m_element_types.resize(0);
+    }
+
+    endOutline();
+    return outline();
+}
+
+
+void QOutlineMapper::endOutline()
+{
+    closeSubpath();
+
+    int element_count = m_elements.size();
+
+    if (element_count == 0) {
+        memset(&m_outline, 0, sizeof(m_outline));
+        return;
+    }
+
+    QPointF *elements;
+
+    // Transform the outline
+    if (m_txop == QTransform::TxNone) {
+        elements = m_elements.data();
+    } else {
+        if (m_txop == QTransform::TxTranslate) {
+            for (int i=0; i<m_elements.size(); ++i) {
+                const QPointF &e = m_elements.at(i);
+                m_elements_dev << QPointF(e.x() + m_dx, e.y() + m_dy);
+            }
+        } else if (m_txop == QTransform::TxScale) {
+            for (int i=0; i<m_elements.size(); ++i) {
+                const QPointF &e = m_elements.at(i);
+                m_elements_dev << QPointF(m_m11 * e.x() + m_dx, m_m22 * e.y() + m_dy);
+            }
+        } else if (m_txop < QTransform::TxProject) {
+            for (int i=0; i<m_elements.size(); ++i) {
+                const QPointF &e = m_elements.at(i);
+                m_elements_dev << QPointF(m_m11 * e.x() + m_m21 * e.y() + m_dx,
+                                          m_m22 * e.y() + m_m12 * e.x() + m_dy);
+            }
+        } else {
+            const QVectorPath vp((qreal *)m_elements.data(), m_elements.size(), m_element_types.size() ? m_element_types.data() : 0);
+            QPainterPath path = vp.convertToPainterPath();
+            path = QTransform(m_m11, m_m12, m_m13, m_m21, m_m22, m_m23, m_dx, m_dy, m_m33).map(path);
+            if (!(m_outline.flags & QT_FT_OUTLINE_EVEN_ODD_FILL))
+                path.setFillRule(Qt::WindingFill);
+            uint old_txop = m_txop;
+            m_txop = QTransform::TxNone;
+            if (path.isEmpty())
+                m_valid = false;
+            else
+                convertPath(path);
+            m_txop = old_txop;
+            return;
+        }
+        elements = m_elements_dev.data();
+    }
+
+    controlPointRect = boundingRect(elements, element_count);
+
+#ifdef QT_DEBUG_CONVERT
+    printf(" - control point rect (%.2f, %.2f) %.2f x %.2f, clip=(%d,%d, %dx%d)\n",
+           controlPointRect.x(), controlPointRect.y(),
+           controlPointRect.width(), controlPointRect.height(),
+           m_clip_rect.x(), m_clip_rect.y(), m_clip_rect.width(), m_clip_rect.height());
+#endif
+
+
+    // Check for out of dev bounds...
+    const bool do_clip = !m_in_clip_elements && ((controlPointRect.left() < -QT_RASTER_COORD_LIMIT
+                          || controlPointRect.right() > QT_RASTER_COORD_LIMIT
+                          || controlPointRect.top() < -QT_RASTER_COORD_LIMIT
+                          || controlPointRect.bottom() > QT_RASTER_COORD_LIMIT
+                          || controlPointRect.width() > QT_RASTER_COORD_LIMIT
+                          || controlPointRect.height() > QT_RASTER_COORD_LIMIT));
+
+    if (do_clip) {
+        clipElements(elements, elementTypes(), element_count);
+    } else {
+        convertElements(elements, elementTypes(), element_count);
+    }
+}
+
+void QOutlineMapper::convertElements(const QPointF *elements,
+                                       const QPainterPath::ElementType *types,
+                                       int element_count)
+{
+
+    if (types) {
+        // Translate into FT coords
+        const QPointF *e = elements;
+        for (int i=0; i<element_count; ++i) {
+            switch (*types) {
+            case QPainterPath::MoveToElement:
+                {
+                    QT_FT_Vector pt_fixed = { qreal_to_fixed_26_6(e->x()),
+                                              qreal_to_fixed_26_6(e->y()) };
+                    if (i != 0)
+                        m_contours << m_points.size() - 1;
+                    m_points << pt_fixed;
+                    m_tags <<  QT_FT_CURVE_TAG_ON;
+                }
+                break;
+
+            case QPainterPath::LineToElement:
+                {
+                    QT_FT_Vector pt_fixed = { qreal_to_fixed_26_6(e->x()),
+                                              qreal_to_fixed_26_6(e->y()) };
+                    m_points << pt_fixed;
+                    m_tags << QT_FT_CURVE_TAG_ON;
+                }
+                break;
+
+            case QPainterPath::CurveToElement:
+                {
+                    QT_FT_Vector cp1_fixed = { qreal_to_fixed_26_6(e->x()),
+                                               qreal_to_fixed_26_6(e->y()) };
+                    ++e;
+                    QT_FT_Vector cp2_fixed = { qreal_to_fixed_26_6((e)->x()),
+                                               qreal_to_fixed_26_6((e)->y()) };
+                    ++e;
+                    QT_FT_Vector ep_fixed = { qreal_to_fixed_26_6((e)->x()),
+                                              qreal_to_fixed_26_6((e)->y()) };
+
+                    m_points << cp1_fixed << cp2_fixed << ep_fixed;
+                    m_tags << QT_FT_CURVE_TAG_CUBIC
+                           << QT_FT_CURVE_TAG_CUBIC
+                           << QT_FT_CURVE_TAG_ON;
+
+                    types += 2;
+                    i += 2;
+                }
+                break;
+            default:
+                break;
+            }
+            ++types;
+            ++e;
+        }
+    } else {
+        // Plain polygon...
+        const QPointF *last = elements + element_count;
+        const QPointF *e = elements;
+        while (e < last) {
+            QT_FT_Vector pt_fixed = { qreal_to_fixed_26_6(e->x()),
+                                      qreal_to_fixed_26_6(e->y()) };
+            m_points << pt_fixed;
+            m_tags << QT_FT_CURVE_TAG_ON;
+            ++e;
+        }
+    }
+
+    // close the very last subpath
+    m_contours << m_points.size() - 1;
+
+    m_outline.n_contours = m_contours.size();
+    m_outline.n_points = m_points.size();
+
+    m_outline.points = m_points.data();
+    m_outline.tags = m_tags.data();
+    m_outline.contours = m_contours.data();
+
+#ifdef QT_DEBUG_CONVERT
+    printf("QOutlineMapper::endOutline\n");
+
+    printf(" - contours: %d\n", m_outline.n_contours);
+    for (int i=0; i<m_outline.n_contours; ++i) {
+        printf("   - %d\n", m_outline.contours[i]);
+    }
+
+    printf(" - points: %d\n", m_outline.n_points);
+    for (int i=0; i<m_outline.n_points; ++i) {
+        printf("   - %d -- %.2f, %.2f, (%d, %d)\n", i,
+               (double) (m_outline.points[i].x / 64.0),
+               (double) (m_outline.points[i].y / 64.0),
+               (int) m_outline.points[i].x, (int) m_outline.points[i].y);
+    }
+#endif
+}
+
+void QOutlineMapper::clipElements(const QPointF *elements,
+                                    const QPainterPath::ElementType *types,
+                                    int element_count)
+{
+    // We could save a bit of time by actually implementing them fully
+    // instead of going through convenience functionallity, but since
+    // this part of code hardly every used, it shouldn't matter.
+
+    m_in_clip_elements = true;
+
+    QPainterPath path;
+
+    if (!(m_outline.flags & QT_FT_OUTLINE_EVEN_ODD_FILL))
+        path.setFillRule(Qt::WindingFill);
+
+    if (types) {
+        for (int i=0; i<element_count; ++i) {
+            switch (types[i]) {
+            case QPainterPath::MoveToElement:
+                path.moveTo(elements[i]);
+                break;
+
+            case QPainterPath::LineToElement:
+                path.lineTo(elements[i]);
+                break;
+
+            case QPainterPath::CurveToElement:
+                path.cubicTo(elements[i], elements[i+1], elements[i+2]);
+                i += 2;
+                break;
+            default:
+                break;
+            }
+        }
+    } else {
+        path.moveTo(elements[0]);
+        for (int i=1; i<element_count; ++i)
+            path.lineTo(elements[i]);
+    }
+
+    QPainterPath clipPath;
+    clipPath.addRect(m_clip_rect);
+    QPainterPath clippedPath = path.intersected(clipPath);
+    uint old_txop = m_txop;
+    m_txop = QTransform::TxNone;
+    if (clippedPath.isEmpty())
+        m_valid = false;
+    else
+        convertPath(clippedPath);
+    m_txop = old_txop;
+
+    m_in_clip_elements = false;
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qoutlinemapper_p.h b/src/gui/painting/qoutlinemapper_p.h
new file mode 100644
index 0000000000..4dd28ac172
--- /dev/null
+++ b/src/gui/painting/qoutlinemapper_p.h
@@ -0,0 +1,241 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QOUTLINEMAPPER_P_H
+#define QOUTLINEMAPPER_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtCore/qrect.h>
+
+#include <QtGui/qtransform.h>
+#include <QtGui/qpainterpath.h>
+
+#define QT_FT_BEGIN_HEADER
+#define QT_FT_END_HEADER
+
+#include <private/qrasterdefs_p.h>
+#include <private/qdatabuffer_p.h>
+#include "qpaintengineex_p.h"
+
+QT_BEGIN_NAMESPACE
+
+// This limitations comes from qgrayraster.c. Any higher and
+// rasterization of shapes will produce incorrect results.
+const int QT_RASTER_COORD_LIMIT = 32767;
+
+//#define QT_DEBUG_CONVERT
+
+/********************************************************************************
+ * class QOutlineMapper
+ *
+ * Used to map between QPainterPath and the QT_FT_Outline structure used by the
+ * freetype scanconvertor.
+ *
+ * The outline mapper uses a path iterator to get points from the path,
+ * so that it is possible to transform the points as they are converted. The
+ * callback can be a noop, translate or full-fledged xform. (Tests indicated
+ * that using a C callback was low cost).
+ */
+class QOutlineMapper
+{
+public:
+    QOutlineMapper() :
+        m_element_types(0),
+        m_elements(0),
+        m_elements_dev(0),
+        m_points(0),
+        m_tags(0),
+        m_contours(0),
+        m_polygon_dev(0),
+        m_in_clip_elements(false)
+    {
+    }
+
+    /*!
+      Sets up the matrix to be used for conversion. This also
+      sets up the qt_path_iterator function that is used as a callback
+      to get points.
+    */
+    void setMatrix(const QTransform &m)
+    {
+        m_m11 = m.m11();
+        m_m12 = m.m12();
+        m_m13 = m.m13();
+        m_m21 = m.m21();
+        m_m22 = m.m22();
+        m_m23 = m.m23();
+        m_m33 = m.m33();
+        m_dx = m.dx();
+        m_dy = m.dy();
+        m_txop = m.type();
+    }
+
+    void beginOutline(Qt::FillRule fillRule)
+    {
+#ifdef QT_DEBUG_CONVERT
+        printf("QOutlineMapper::beginOutline rule=%d\n", fillRule);
+#endif
+        m_valid = true;
+        m_elements.reset();
+        m_elements_dev.reset();
+        m_element_types.reset();
+        m_points.reset();
+        m_tags.reset();
+        m_contours.reset();
+        m_outline.flags = fillRule == Qt::WindingFill
+                          ? QT_FT_OUTLINE_NONE
+                          : QT_FT_OUTLINE_EVEN_ODD_FILL;
+        m_subpath_start = 0;
+    }
+
+    void endOutline();
+
+    void clipElements(const QPointF *points, const QPainterPath::ElementType *types, int count);
+
+    void convertElements(const QPointF *points, const QPainterPath::ElementType *types, int count);
+
+    inline void moveTo(const QPointF &pt) {
+#ifdef QT_DEBUG_CONVERT
+        printf("QOutlineMapper::moveTo() (%f, %f)\n", pt.x(), pt.y());
+#endif
+        closeSubpath();
+        m_subpath_start = m_elements.size();
+        m_elements << pt;
+        m_element_types << QPainterPath::MoveToElement;
+    }
+
+    inline void lineTo(const QPointF &pt) {
+#ifdef QT_DEBUG_CONVERT
+        printf("QOutlineMapper::lineTo() (%f, %f)\n", pt.x(), pt.y());
+#endif
+        m_elements.add(pt);
+        m_element_types << QPainterPath::LineToElement;
+    }
+
+    inline void curveTo(const QPointF &cp1, const QPointF &cp2, const QPointF &ep) {
+#ifdef QT_DEBUG_CONVERT
+        printf("QOutlineMapper::curveTo() (%f, %f)\n", ep.x(), ep.y());
+#endif
+        m_elements << cp1 << cp2 << ep;
+        m_element_types << QPainterPath::CurveToElement
+                        << QPainterPath::CurveToDataElement
+                        << QPainterPath::CurveToDataElement;
+    }
+
+    inline void closeSubpath() {
+        int element_count = m_elements.size();
+        if (element_count > 0) {
+            if (m_elements.at(element_count-1) != m_elements.at(m_subpath_start)) {
+#ifdef QT_DEBUG_CONVERT
+                printf(" - implicitly closing\n");
+#endif
+                // Put the object on the stack to avoid the odd case where
+                // lineTo reallocs the databuffer and the QPointF & will
+                // be invalidated.
+                QPointF pt = m_elements.at(m_subpath_start);
+
+                // only do lineTo if we have element_type array...
+                if (m_element_types.size())
+                    lineTo(pt);
+                else
+                    m_elements << pt;
+
+            }
+        }
+    }
+
+    QT_FT_Outline *outline() {
+        if (m_valid)
+            return &m_outline;
+        return 0;
+    }
+
+    QT_FT_Outline *convertPath(const QPainterPath &path);
+    QT_FT_Outline *convertPath(const QVectorPath &path);
+
+    inline QPainterPath::ElementType *elementTypes() const { return m_element_types.size() == 0 ? 0 : m_element_types.data(); }
+
+public:
+    QDataBuffer<QPainterPath::ElementType> m_element_types;
+    QDataBuffer<QPointF> m_elements;
+    QDataBuffer<QPointF> m_elements_dev;
+    QDataBuffer<QT_FT_Vector> m_points;
+    QDataBuffer<char> m_tags;
+    QDataBuffer<int> m_contours;
+
+    QRect m_clip_rect;
+    QDataBuffer<QPointF> m_polygon_dev;
+
+    QRectF controlPointRect; // only valid after endOutline()
+
+    QT_FT_Outline m_outline;
+    uint m_txop;
+
+    int m_subpath_start;
+
+    // Matrix
+    qreal m_m11;
+    qreal m_m12;
+    qreal m_m13;
+    qreal m_m21;
+    qreal m_m22;
+    qreal m_m23;
+    qreal m_m33;
+    qreal m_dx;
+    qreal m_dy;
+
+    bool m_valid;
+    bool m_in_clip_elements;
+};
+
+QT_END_NAMESPACE
+
+#endif // QOUTLINEMAPPER_P_H
diff --git a/src/gui/painting/qpaintbuffer.cpp b/src/gui/painting/qpaintbuffer.cpp
new file mode 100644
index 0000000000..7870defd22
--- /dev/null
+++ b/src/gui/painting/qpaintbuffer.cpp
@@ -0,0 +1,2287 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include <qmath.h>
+#include <private/qpainterpath_p.h>
+#include <private/qpaintbuffer_p.h>
+//#include <private/qtextengine_p.h>
+#include <private/qfontengine_p.h>
+#include <private/qemulationpaintengine_p.h>
+#include <private/qimage_p.h>
+#include <qstatictext.h>
+#include <private/qstatictext_p.h>
+#include <private/qrawfont_p.h>
+
+#include <QDebug>
+
+// #define QPAINTBUFFER_DEBUG_DRAW
+
+QT_BEGIN_NAMESPACE
+
+extern void qt_format_text(const QFont &font,
+                           const QRectF &_r, int tf, const QTextOption *option, const QString& str, QRectF *brect,
+                           int tabstops, int* tabarray, int tabarraylen,
+                           QPainter *painter);
+
+QTextItemIntCopy::QTextItemIntCopy(const QTextItem &item)
+    : m_item(static_cast<const QTextItemInt &>(item))
+{
+    QChar *chars = new QChar[m_item.num_chars];
+    unsigned short *logClusters = new unsigned short[m_item.num_chars];
+    memcpy(chars, m_item.chars, m_item.num_chars * sizeof(QChar));
+    memcpy(logClusters, m_item.logClusters, m_item.num_chars * sizeof(unsigned short));
+    m_item.chars = chars;
+    m_item.logClusters = logClusters;
+
+    const int size = QGlyphLayout::spaceNeededForGlyphLayout(m_item.glyphs.numGlyphs);
+    char *glyphLayoutData = new char[size];
+    QGlyphLayout glyphs(glyphLayoutData, m_item.glyphs.numGlyphs);
+    memcpy(glyphs.offsets, m_item.glyphs.offsets, m_item.glyphs.numGlyphs * sizeof(QFixedPoint));
+    memcpy(glyphs.glyphs, m_item.glyphs.glyphs, m_item.glyphs.numGlyphs * sizeof(HB_Glyph));
+    memcpy(glyphs.advances_x, m_item.glyphs.advances_x, m_item.glyphs.numGlyphs * sizeof(QFixed));
+    memcpy(glyphs.advances_y, m_item.glyphs.advances_y, m_item.glyphs.numGlyphs * sizeof(QFixed));
+    memcpy(glyphs.justifications, m_item.glyphs.justifications, m_item.glyphs.numGlyphs * sizeof(QGlyphJustification));
+    memcpy(glyphs.attributes, m_item.glyphs.attributes, m_item.glyphs.numGlyphs * sizeof(HB_GlyphAttributes));
+    m_item.glyphs = glyphs;
+
+    m_font = *m_item.f;
+    m_item.f = &m_font;
+
+    m_item.fontEngine->ref.ref(); // Increment reference count.
+}
+
+QTextItemIntCopy::~QTextItemIntCopy()
+{
+    delete m_item.chars;
+    delete m_item.logClusters;
+    delete m_item.glyphs.data();
+    if (!m_item.fontEngine->ref.deref())
+        delete m_item.fontEngine;
+}
+
+/************************************************************************
+ *
+ * QPaintBufferSignalProxy
+ *
+ ************************************************************************/
+
+Q_GLOBAL_STATIC(QPaintBufferSignalProxy, theSignalProxy)
+
+QPaintBufferSignalProxy *QPaintBufferSignalProxy::instance()
+{
+    return theSignalProxy();
+}
+
+/************************************************************************
+ *
+ * QPaintBufferPrivate
+ *
+ ************************************************************************/
+
+QPaintBufferPrivate::QPaintBufferPrivate()
+    : ref(1), engine(0), penWidthAdjustment(0)
+    , calculateBoundingRect(true)
+    , cache(0)
+{
+}
+
+QPaintBufferPrivate::~QPaintBufferPrivate()
+{
+    QPaintBufferSignalProxy::instance()->emitAboutToDestroy(this);
+
+    for (int i = 0; i < commands.size(); ++i) {
+        const QPaintBufferCommand &cmd = commands.at(i);
+        if (cmd.id == QPaintBufferPrivate::Cmd_DrawTextItem)
+            delete reinterpret_cast<QTextItemIntCopy *>(qvariant_cast<void *>(variants.at(cmd.offset)));
+    }
+}
+
+
+inline void QPaintBufferPrivate::updateBoundingRect(const QRectF &br)
+{
+    // transform to device coords and adjust for pen width
+    Q_ASSERT(engine && engine->painter());
+    QPainter *painter = engine->painter();
+    const QTransform transform = painter->transform();
+    QRectF devRect = transform.mapRect(br);
+    if (penWidthAdjustment > 0) {
+        devRect = devRect.adjusted(-penWidthAdjustment, -penWidthAdjustment,
+                                   penWidthAdjustment, penWidthAdjustment);
+    }
+
+    if (boundingRect.isEmpty()) {
+        boundingRect = devRect;
+    } else {
+        qreal min_x = qMin(devRect.left(), boundingRect.left());
+        qreal min_y = qMin(devRect.top(), boundingRect.top());
+        qreal max_x = qMax(devRect.right(), boundingRect.right());
+        qreal max_y = qMax(devRect.bottom(), boundingRect.bottom());
+        boundingRect = QRectF(min_x, min_y, max_x - min_x, max_y - min_y);
+    }
+    if (painter->hasClipping())
+        boundingRect &= transform.mapRect(painter->clipRegion().boundingRect());
+}
+
+
+/************************************************************************
+ *
+ * QPaintBuffer
+ *
+ ************************************************************************/
+
+
+
+QPaintBuffer::QPaintBuffer()
+    : d_ptr(new QPaintBufferPrivate)
+{
+}
+
+QPaintBuffer::~QPaintBuffer()
+{
+    if (!d_ptr->ref.deref())
+        delete d_ptr;
+}
+
+QPaintBuffer::QPaintBuffer(const QPaintBuffer &other)
+    : QPaintDevice(), d_ptr(other.d_ptr)
+{
+    d_ptr->ref.ref();
+}
+
+QPaintEngine *QPaintBuffer::paintEngine() const
+{
+    QPaintBufferPrivate *d = const_cast<QPaintBuffer *>(this)->d_ptr;
+    if (!d->engine)
+        d->engine = new QPaintBufferEngine(d);
+    return d->engine;
+}
+
+
+int QPaintBuffer::metric(PaintDeviceMetric metric) const
+{
+    int val = 0;
+    switch (metric) {
+    case PdmWidth:
+        val = qCeil(d_ptr->boundingRect.width());
+        break;
+    case PdmHeight:
+        val = qCeil(d_ptr->boundingRect.height());
+        break;
+    case PdmDpiX:
+    case PdmPhysicalDpiX:
+        val = qt_defaultDpiX();
+        break;
+    case PdmDpiY:
+    case PdmPhysicalDpiY:
+        val = qt_defaultDpiY();
+        break;
+    default:
+        val = QPaintDevice::metric(metric);
+    }
+
+    return val;
+}
+
+int QPaintBuffer::devType() const
+{
+    return QInternal::PaintBuffer;
+}
+
+QPaintBuffer &QPaintBuffer::operator=(const QPaintBuffer &other)
+{
+    if (other.d_ptr != d_ptr) {
+        QPaintBufferPrivate *data = other.d_ptr;
+        data->ref.ref();
+        if (d_ptr->ref.deref())
+            delete d_ptr;
+        d_ptr = data;
+    }
+    return *this;
+}
+
+bool QPaintBuffer::isEmpty() const
+{
+    return d_ptr->commands.isEmpty();
+}
+
+
+
+void QPaintBuffer::draw(QPainter *painter, int frame) const
+{
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+    qDebug() << "QPaintBuffer::draw() --------------------------------";
+
+    Q_D(const QPaintBuffer);
+    printf("Float buffer:");
+    for (int i=0; i<d->floats.size(); i++) {
+        if ((i % 10) == 0) {
+            printf("\n%4d-%4d: ", i, i+9);
+        }
+        printf("%4.2f  ", d->floats[i]);
+    }
+    printf("\n");
+
+    printf("Int Buffer:");
+    for (int i=0; i<d->ints.size(); i++) {
+        if ((i % 10) == 0) {
+            printf("\n%4d-%4d: ", i, i+10);
+        }
+        printf("%5d", d->ints[i]);
+    }
+    printf("\n");
+#endif
+
+    processCommands(painter, frameStartIndex(frame), frameEndIndex(frame));
+
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+    qDebug() << "QPaintBuffer::draw() -------------------------------- DONE!";
+#endif
+}
+
+int QPaintBuffer::frameStartIndex(int frame) const
+{
+    return (frame == 0) ? 0 : d_ptr->frames.at(frame - 1);
+}
+
+int QPaintBuffer::frameEndIndex(int frame) const
+{
+    return (frame == d_ptr->frames.size()) ? d_ptr->commands.size() : d_ptr->frames.at(frame);
+}
+
+int QPaintBuffer::processCommands(QPainter *painter, int begin, int end) const
+{
+    if (!painter || !painter->isActive())
+        return 0;
+
+    QPaintEngineEx *xengine = painter->paintEngine()->isExtended()
+                              ? (QPaintEngineEx *) painter->paintEngine() : 0;
+    if (xengine) {
+        QPaintEngineExReplayer player;
+        player.processCommands(*this, painter, begin, end);
+    } else {
+        QPainterReplayer player;
+        player.processCommands(*this, painter, begin, end);
+    }
+
+    int depth = 0;
+    for (int i = begin; i < end; ++i) {
+        const QPaintBufferCommand &cmd = d_ptr->commands.at(i);
+        if (cmd.id == QPaintBufferPrivate::Cmd_Save)
+            ++depth;
+        else if (cmd.id == QPaintBufferPrivate::Cmd_Restore)
+            --depth;
+    }
+    return depth;
+}
+
+#ifndef QT_NO_DEBUG_STREAM
+QString QPaintBuffer::commandDescription(int command) const
+{
+    QString desc;
+    QDebug debug(&desc);
+
+    const QPaintBufferCommand &cmd = d_ptr->commands.at(command);
+
+    switch (cmd.id) {
+    case QPaintBufferPrivate::Cmd_Save: {
+        debug << "Cmd_Save";
+        break; }
+
+    case QPaintBufferPrivate::Cmd_Restore: {
+        debug << "Cmd_Restore";
+        break; }
+
+    case QPaintBufferPrivate::Cmd_SetBrush: {
+        QBrush brush = qvariant_cast<QBrush>(d_ptr->variants.at(cmd.offset));
+        debug << "Cmd_SetBrush: " << brush;
+        break; }
+
+    case QPaintBufferPrivate::Cmd_SetBrushOrigin: {
+        debug << "Cmd_SetBrushOrigin: " << d_ptr->variants.at(cmd.offset).toPointF();
+        break; }
+
+    case QPaintBufferPrivate::Cmd_SetCompositionMode: {
+        QPainter::CompositionMode mode = (QPainter::CompositionMode) cmd.extra;
+        debug << "ExCmd_SetCompositionMode, mode: " << mode;
+        break; }
+
+    case QPaintBufferPrivate::Cmd_SetOpacity: {
+        debug << "ExCmd_SetOpacity: " << d_ptr->variants.at(cmd.offset).toDouble();
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawVectorPath: {
+        debug << "ExCmd_DrawVectorPath: size: " << cmd.size
+//                 << ", hints:" << d->ints[cmd.offset2+cmd.size]
+                 << "pts/elms:" << cmd.offset << cmd.offset2;
+        break; }
+
+    case QPaintBufferPrivate::Cmd_StrokeVectorPath: {
+        QPen pen = qvariant_cast<QPen>(d_ptr->variants.at(cmd.extra));
+        debug << "ExCmd_StrokeVectorPath: size: " << cmd.size
+//                 << ", hints:" << d->ints[cmd.offset2+cmd.size]
+                 << "pts/elms:" << cmd.offset << cmd.offset2 << pen;
+        break; }
+
+    case QPaintBufferPrivate::Cmd_FillVectorPath: {
+        QBrush brush = qvariant_cast<QBrush>(d_ptr->variants.at(cmd.extra));
+        debug << "ExCmd_FillVectorPath: size: " << cmd.size
+//                 << ", hints:" << d->ints[cmd.offset2+cmd.size]
+                 << "pts/elms:" << cmd.offset << cmd.offset2 << brush;
+        break; }
+
+    case QPaintBufferPrivate::Cmd_FillRectBrush: {
+        QBrush brush = qvariant_cast<QBrush>(d_ptr->variants.at(cmd.extra));
+        QRectF *rect = (QRectF *)(d_ptr->floats.constData() + cmd.offset);
+        debug << "ExCmd_FillRectBrush, offset: " << cmd.offset << " rect: " << *rect << " brush: " << brush;
+        break; }
+
+    case QPaintBufferPrivate::Cmd_FillRectColor: {
+        QColor color = qvariant_cast<QColor>(d_ptr->variants.at(cmd.extra));
+        QRectF *rect = (QRectF *)(d_ptr->floats.constData() + cmd.offset);
+        debug << "ExCmd_FillRectBrush, offset: " << cmd.offset << " rect: " << *rect << " color: " << color;
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawPolygonF: {
+        debug << "ExCmd_DrawPolygonF, offset: " << cmd.offset << " size: " << cmd.size
+                 << " mode: " << cmd.extra
+                 << d_ptr->floats.at(cmd.offset)
+                 << d_ptr->floats.at(cmd.offset+1);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawPolygonI: {
+        debug << "ExCmd_DrawPolygonI, offset: " << cmd.offset << " size: " << cmd.size
+                 << " mode: " << cmd.extra
+                 << d_ptr->ints.at(cmd.offset)
+                 << d_ptr->ints.at(cmd.offset+1);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawEllipseF: {
+        debug << "ExCmd_DrawEllipseF, offset: " << cmd.offset;
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawLineF: {
+        debug << "ExCmd_DrawLineF, offset: " << cmd.offset << " size: " << cmd.size;
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawLineI: {
+        debug << "ExCmd_DrawLineI, offset: " << cmd.offset << " size: " << cmd.size;
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawPointsF: {
+        debug << "ExCmd_DrawPointsF, offset: " << cmd.offset << " size: " << cmd.size;
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawPointsI: {
+        debug << "ExCmd_DrawPointsI, offset: " << cmd.offset << " size: " << cmd.size;
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawPolylineF: {
+        debug << "ExCmd_DrawPolylineF, offset: " << cmd.offset << " size: " << cmd.size;
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawPolylineI: {
+        debug << "ExCmd_DrawPolylineI, offset: " << cmd.offset << " size: " << cmd.size;
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawRectF: {
+        debug << "ExCmd_DrawRectF, offset: " << cmd.offset << " size: " << cmd.size;
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawRectI: {
+        debug << "ExCmd_DrawRectI, offset: " << cmd.offset << " size: " << cmd.size;
+        break; }
+
+    case QPaintBufferPrivate::Cmd_SetClipEnabled: {
+        bool clipEnabled = d_ptr->variants.at(cmd.offset).toBool();
+        debug << "ExCmd_SetClipEnabled:" << clipEnabled;
+        break; }
+
+    case QPaintBufferPrivate::Cmd_ClipVectorPath: {
+        QVectorPathCmd path(d_ptr, cmd);
+        debug << "ExCmd_ClipVectorPath:" << path().elementCount();
+        break; }
+
+    case QPaintBufferPrivate::Cmd_ClipRect: {
+        QRect rect(QPoint(d_ptr->ints.at(cmd.offset), d_ptr->ints.at(cmd.offset + 1)),
+                   QPoint(d_ptr->ints.at(cmd.offset + 2), d_ptr->ints.at(cmd.offset + 3)));
+        debug << "ExCmd_ClipRect:" << rect << cmd.extra;
+        break; }
+
+    case QPaintBufferPrivate::Cmd_ClipRegion: {
+        QRegion region(d_ptr->variants.at(cmd.offset).value<QRegion>());
+        debug << "ExCmd_ClipRegion:" << region.boundingRect() << cmd.extra;
+        break; }
+
+    case QPaintBufferPrivate::Cmd_SetPen: {
+        QPen pen = qvariant_cast<QPen>(d_ptr->variants.at(cmd.offset));
+        debug << "Cmd_SetPen: " << pen;
+        break; }
+
+    case QPaintBufferPrivate::Cmd_SetTransform: {
+        QTransform xform = qvariant_cast<QTransform>(d_ptr->variants.at(cmd.offset));
+        debug << "Cmd_SetTransform, offset: " << cmd.offset << xform;
+        break; }
+
+    case QPaintBufferPrivate::Cmd_SetRenderHints: {
+        debug << "Cmd_SetRenderHints, hints: " << cmd.extra;
+        break; }
+
+    case QPaintBufferPrivate::Cmd_SetBackgroundMode: {
+        debug << "Cmd_SetBackgroundMode: " << cmd.extra;
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawConvexPolygonF: {
+        debug << "Cmd_DrawConvexPolygonF, offset: " << cmd.offset << " size: " << cmd.size;
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawConvexPolygonI: {
+        debug << "Cmd_DrawConvexPolygonI, offset: " << cmd.offset << " size: " << cmd.size;
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawEllipseI: {
+        debug << "Cmd_DrawEllipseI, offset: " << cmd.offset;
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawPixmapRect: {
+        QPixmap pm(d_ptr->variants.at(cmd.offset).value<QPixmap>());
+        QRectF r(d_ptr->floats.at(cmd.extra), d_ptr->floats.at(cmd.extra+1),
+                 d_ptr->floats.at(cmd.extra+2), d_ptr->floats.at(cmd.extra+3));
+
+        QRectF sr(d_ptr->floats.at(cmd.extra+4), d_ptr->floats.at(cmd.extra+5),
+                  d_ptr->floats.at(cmd.extra+6), d_ptr->floats.at(cmd.extra+7));
+        debug << "Cmd_DrawPixmapRect:" << r << sr << pm.size();
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawPixmapPos: {
+        QPixmap pm(d_ptr->variants.at(cmd.offset).value<QPixmap>());
+        QPointF pos(d_ptr->floats.at(cmd.extra), d_ptr->floats.at(cmd.extra+1));
+        debug << "Cmd_DrawPixmapPos:" << pos << pm.size();
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawTiledPixmap: {
+        QPixmap pm(d_ptr->variants.at(cmd.offset).value<QPixmap>());
+        QRectF r(d_ptr->floats.at(cmd.extra), d_ptr->floats.at(cmd.extra+1),
+                 d_ptr->floats.at(cmd.extra+2), d_ptr->floats.at(cmd.extra+3));
+
+        QPointF offset(d_ptr->floats.at(cmd.extra+4), d_ptr->floats.at(cmd.extra+5));
+        debug << "Cmd_DrawTiledPixmap:" << r << offset << pm.size();
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawImageRect: {
+        QImage image(d_ptr->variants.at(cmd.offset).value<QImage>());
+        QRectF r(d_ptr->floats.at(cmd.extra), d_ptr->floats.at(cmd.extra+1),
+                 d_ptr->floats.at(cmd.extra+2), d_ptr->floats.at(cmd.extra+3));
+        QRectF sr(d_ptr->floats.at(cmd.extra+4), d_ptr->floats.at(cmd.extra+5),
+                  d_ptr->floats.at(cmd.extra+6), d_ptr->floats.at(cmd.extra+7));
+        debug << "Cmd_DrawImageRect:" << r << sr << image.size();
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawImagePos: {
+        QImage image(d_ptr->variants.at(cmd.offset).value<QImage>());
+        QPointF pos(d_ptr->floats.at(cmd.extra), d_ptr->floats.at(cmd.extra+1));
+        debug << "Cmd_DrawImagePos:" << pos << image.size();
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawText: {
+        QPointF pos(d_ptr->floats.at(cmd.extra), d_ptr->floats.at(cmd.extra+1));
+        QList<QVariant> variants(d_ptr->variants.at(cmd.offset).value<QList<QVariant> >());
+
+        QFont font(variants.at(0).value<QFont>());
+        QString text(variants.at(1).value<QString>());
+
+        debug << "Cmd_DrawText:" << pos << text << font.family();
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawTextItem: {
+        QPointF pos(d_ptr->floats.at(cmd.extra), d_ptr->floats.at(cmd.extra+1));
+        QTextItemIntCopy *tiCopy = reinterpret_cast<QTextItemIntCopy *>(qvariant_cast<void *>(d_ptr->variants.at(cmd.offset)));
+        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: {
+        QRegion systemClip(d_ptr->variants.at(cmd.offset).value<QRegion>());
+
+        debug << "Cmd_SystemStateChanged:" << systemClip;
+        break; }
+    case QPaintBufferPrivate::Cmd_Translate: {
+        QPointF delta(d_ptr->floats.at(cmd.extra), d_ptr->floats.at(cmd.extra+1));
+        debug << "Cmd_Translate:" << delta;
+        break; }
+    case QPaintBufferPrivate::Cmd_DrawStaticText: {
+        debug << "Cmd_DrawStaticText";
+        break; }
+    }
+
+    return desc;
+}
+#endif
+
+QRectF QPaintBuffer::boundingRect() const
+{
+    return d_ptr->boundingRect;
+}
+
+void QPaintBuffer::setBoundingRect(const QRectF &rect)
+{
+    d_ptr->boundingRect = rect;
+    d_ptr->calculateBoundingRect = false;
+}
+
+
+class QPaintBufferEnginePrivate : public QPaintEngineExPrivate
+{
+    Q_DECLARE_PUBLIC(QPaintBufferEngine)
+public:
+    void systemStateChanged() {
+        Q_Q(QPaintBufferEngine);
+        q->buffer->addCommand(QPaintBufferPrivate::Cmd_SystemStateChanged, QVariant(systemClip));
+    }
+
+    QTransform last;
+};
+
+
+/************************************************************************
+ *
+ * QPaintBufferEngine
+ *
+ ************************************************************************/
+
+QPaintBufferEngine::QPaintBufferEngine(QPaintBufferPrivate *b)
+    : QPaintEngineEx(*(new QPaintBufferEnginePrivate))
+    , buffer(b)
+    , m_begin_detected(false)
+    , m_save_detected(false)
+    , m_stream_raw_text_items(false)
+{
+}
+
+bool QPaintBufferEngine::begin(QPaintDevice *)
+{
+    Q_D(QPaintBufferEngine);
+    painter()->save();
+    d->systemStateChanged();
+    return true;
+}
+
+bool QPaintBufferEngine::end()
+{
+    painter()->restore();
+    m_created_state = 0;
+    return true;
+}
+
+QPainterState *QPaintBufferEngine::createState(QPainterState *orig) const
+{
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+    qDebug() << "QPaintBufferEngine: createState, orig=" << orig << ", current=" << state();
+#endif
+
+    Q_ASSERT(!m_begin_detected);
+    Q_ASSERT(!m_save_detected);
+
+    if (orig == 0) {
+        m_begin_detected = true;
+        return new QPainterState();
+    } else {
+        m_save_detected = true;
+        return new QPainterState(orig);
+    }
+}
+
+void QPaintBufferEngine::clip(const QVectorPath &path, Qt::ClipOperation op)
+{
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+    qDebug() << "QPaintBufferEngine: clip vpath:" << path.elementCount() << "op:" << op;
+#endif
+    QPaintBufferCommand *cmd =
+        buffer->addCommand(QPaintBufferPrivate::Cmd_ClipVectorPath, path);
+    cmd->extra = op;
+}
+
+void QPaintBufferEngine::clip(const QRect &rect, Qt::ClipOperation op)
+{
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+    qDebug() << "QPaintBufferEngine: clip rect:" << rect << "op:" << op;
+#endif
+    QPaintBufferCommand *cmd =
+        buffer->addCommand(QPaintBufferPrivate::Cmd_ClipRect, (int *) &rect, 4, 1);
+    cmd->extra = op;
+}
+
+void QPaintBufferEngine::clip(const QRegion &region, Qt::ClipOperation op)
+{
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+    qDebug() << "QPaintBufferEngine: clip region br:" << region.boundingRect() << "op:" << op;
+#endif
+    QPaintBufferCommand *cmd =
+        buffer->addCommand(QPaintBufferPrivate::Cmd_ClipRegion, QVariant(region));
+    cmd->extra = op;
+}
+
+void QPaintBufferEngine::clip(const QPainterPath &path, Qt::ClipOperation op)
+{
+    // ### TODO
+//     QPaintBufferCommand *cmd =
+//         buffer->addCommand(QPaintBufferPrivate::Cmd_ClipPath, QVariant(path));
+//     cmd->extra = op;
+    QPaintEngineEx::clip(path, op);
+}
+
+void QPaintBufferEngine::clipEnabledChanged()
+{
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+    qDebug() << "QPaintBufferEngine: clip enable change" << state()->clipEnabled;
+#endif
+
+    buffer->addCommand(QPaintBufferPrivate::Cmd_SetClipEnabled, state()->clipEnabled);
+}
+
+void QPaintBufferEngine::penChanged()
+{
+    const QPen &pen = state()->pen;
+
+    if (!buffer->commands.isEmpty()
+        && buffer->commands.last().id == QPaintBufferPrivate::Cmd_SetPen) {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+    qDebug() << "QPaintBufferEngine: penChanged (compressed)" << state()->pen;
+#endif
+        buffer->variants[buffer->commands.last().offset] = pen;
+        return;
+    }
+
+    if (buffer->calculateBoundingRect) {
+        if (pen.style() == Qt::NoPen) {
+            buffer->penWidthAdjustment = 0;
+        } else {
+            qreal penWidth = (pen.widthF() == 0) ? 1 : pen.widthF();
+            QPointF transformedWidth(penWidth, penWidth);
+            if (!pen.isCosmetic())
+                transformedWidth = painter()->transform().map(transformedWidth);
+            buffer->penWidthAdjustment = transformedWidth.x() / 2.0;
+        }
+    }
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+    qDebug() << "QPaintBufferEngine: penChanged" << state()->pen;
+#endif
+    buffer->addCommand(QPaintBufferPrivate::Cmd_SetPen, pen);
+}
+
+void QPaintBufferEngine::brushChanged()
+{
+    const QBrush &brush = state()->brush;
+
+    if (!buffer->commands.isEmpty()
+        && buffer->commands.last().id == QPaintBufferPrivate::Cmd_SetBrush) {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << "QPaintBufferEngine: brushChanged (compressed)" << state()->brush;
+#endif
+        buffer->variants[buffer->commands.last().offset] = brush;
+        return;
+    }
+
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+    qDebug() << "QPaintBufferEngine: brushChanged" << state()->brush;
+#endif
+    buffer->addCommand(QPaintBufferPrivate::Cmd_SetBrush, brush);
+}
+
+void QPaintBufferEngine::brushOriginChanged()
+{
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+    qDebug() << "QPaintBufferEngine: brush origin changed" << state()->brushOrigin;
+#endif
+    buffer->addCommand(QPaintBufferPrivate::Cmd_SetBrushOrigin, state()->brushOrigin);
+}
+
+void QPaintBufferEngine::opacityChanged()
+{
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+    qDebug() << "QPaintBufferEngine: opacity changed" << state()->opacity;
+#endif
+    buffer->addCommand(QPaintBufferPrivate::Cmd_SetOpacity, state()->opacity);
+}
+
+void QPaintBufferEngine::compositionModeChanged()
+{
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+    qDebug() << "QPaintBufferEngine: composition mode" << state()->composition_mode;
+#endif
+    QPaintBufferCommand *cmd =
+        buffer->addCommand(QPaintBufferPrivate::Cmd_SetCompositionMode);
+    cmd->extra = state()->composition_mode;
+}
+
+void QPaintBufferEngine::renderHintsChanged()
+{
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+    qDebug() << "QPaintBufferEngine: render hints changed" << state()->renderHints;
+#endif
+    QPaintBufferCommand *cmd =
+        buffer->addCommand(QPaintBufferPrivate::Cmd_SetRenderHints);
+    cmd->extra = state()->renderHints;
+}
+
+void QPaintBufferEngine::transformChanged()
+{
+    Q_D(QPaintBufferEngine);
+    const QTransform &transform = state()->matrix;
+
+    QTransform delta;
+
+    bool invertible = false;
+    if (transform.type() <= QTransform::TxScale && transform.type() == d->last.type())
+        delta = transform * d->last.inverted(&invertible);
+
+    d->last = transform;
+
+    if (invertible && delta.type() == QTransform::TxNone)
+        return;
+
+    if (invertible && delta.type() == QTransform::TxTranslate) {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << "QPaintBufferEngine: transformChanged (translate only) " << state()->matrix;
+#endif
+        QPaintBufferCommand *cmd =
+            buffer->addCommand(QPaintBufferPrivate::Cmd_Translate);
+
+        qreal data[] = { delta.dx(), delta.dy() };
+        cmd->extra = buffer->addData((qreal *) data, 2);
+        return;
+    }
+
+    // ### accumulate, like in QBrush case...
+    if (!buffer->commands.isEmpty()
+        && buffer->commands.last().id == QPaintBufferPrivate::Cmd_SetTransform) {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << "QPaintBufferEngine: transformChanged (compressing) " << state()->matrix;
+#endif
+        buffer->variants[buffer->commands.last().offset] = state()->matrix;
+        return;
+    }
+
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << "QPaintBufferEngine: transformChanged:" << state()->matrix;
+#endif
+    buffer->addCommand(QPaintBufferPrivate::Cmd_SetTransform, state()->matrix);
+}
+
+void QPaintBufferEngine::backgroundModeChanged()
+{
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+    qDebug() << "QPaintEngineBuffer: background mode changed" << state()->bgMode;
+#endif
+    QPaintBufferCommand *cmd = buffer->addCommand(QPaintBufferPrivate::Cmd_SetBackgroundMode);
+    cmd->extra = state()->bgMode;
+}
+
+void QPaintBufferEngine::draw(const QVectorPath &path)
+{
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+    qDebug() << "QPaintBufferEngine: draw vpath:" << path.elementCount();
+#endif
+
+    bool hasBrush = qbrush_style(state()->brush) != Qt::NoBrush;
+    bool hasPen = qpen_style(state()->pen) != Qt::NoPen
+                  && qbrush_style(qpen_brush(state()->pen)) != Qt::NoBrush;
+
+    if (hasPen || hasBrush)
+        buffer->addCommand(QPaintBufferPrivate::Cmd_DrawVectorPath, path);
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+    else
+        qDebug() << " - no pen or brush active, discarded...\n";
+#endif
+
+//     if (buffer->calculateBoundingRect) {
+//         QRealRect r = path.controlPointRect();
+//         buffer->updateBoundingRect(QRectF(r.x1, r.y1, r.x2 - r.x1, r.y2 - r.y1));
+//     }
+}
+
+void QPaintBufferEngine::fill(const QVectorPath &path, const QBrush &brush)
+{
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+    qDebug() << "QPaintBufferEngine: fill vpath:" << path.elementCount() << brush;
+#endif
+    QPaintBufferCommand *cmd =
+        buffer->addCommand(QPaintBufferPrivate::Cmd_FillVectorPath, path);
+    cmd->extra = buffer->addData(QVariant(brush));
+//     if (buffer->calculateBoundingRect) {
+//         QRealRect r = path.controlPointRect();
+//         buffer->updateBoundingRect(QRectF(r.x1, r.y1, r.x2 - r.x1, r.y2 - r.y1));
+//     }
+}
+
+void QPaintBufferEngine::stroke(const QVectorPath &path, const QPen &pen)
+{
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+    qDebug() << "QPaintBufferEngine: stroke vpath:" << path.elementCount() << pen;
+#endif
+    QPaintBufferCommand *cmd =
+        buffer->addCommand(QPaintBufferPrivate::Cmd_StrokeVectorPath, path);
+    cmd->extra = buffer->addData(QVariant(pen));
+//     if (buffer->calculateBoundingRect) {
+//         QRealRect r = path.controlPointRect();
+//         buffer->updateBoundingRect(QRectF(r.x1, r.y1, r.x2 - r.x1, r.y2 - r.y1));
+//     }
+}
+
+void QPaintBufferEngine::fillRect(const QRectF &rect, const QBrush &brush)
+{
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+    qDebug() << "QPaintBufferEngine: fillRect brush:" << rect << brush;
+#endif
+    QPaintBufferCommand *cmd =
+        buffer->addCommand(QPaintBufferPrivate::Cmd_FillRectBrush, (qreal *) &rect, 4, 1);
+    cmd->extra = buffer->addData(brush);
+    if (buffer->calculateBoundingRect)
+        buffer->updateBoundingRect(rect);
+}
+
+void QPaintBufferEngine::fillRect(const QRectF &rect, const QColor &color)
+{
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+    qDebug() << "QPaintBufferEngine: fillRect color:" << rect << color;
+#endif
+    QPaintBufferCommand *cmd =
+        buffer->addCommand(QPaintBufferPrivate::Cmd_FillRectColor, (qreal *) &rect, 4, 1);
+    cmd->extra = buffer->addData(color);
+    if (buffer->calculateBoundingRect)
+        buffer->updateBoundingRect(rect);
+}
+
+void QPaintBufferEngine::drawRects(const QRect *rects, int rectCount)
+{
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+    qDebug() << "QPaintBufferEngine: drawRectsI:" << rectCount;
+#endif
+    QPaintBufferCommand *cmd =
+        buffer->addCommand(QPaintBufferPrivate::Cmd_DrawRectI, (int *) rects, 4 * rectCount, rectCount);
+    cmd->extra = rectCount;
+
+    if (buffer->calculateBoundingRect) {
+        if (rectCount == 1) {
+            buffer->updateBoundingRect(rects[0]);
+        } else {
+            int min_x = rects[0].left();
+            int min_y = rects[0].top();
+            int max_x = rects[0].left() + rects[0].width();
+            int max_y = rects[0].top() + rects[0].height();
+            for (int i=1; i< rectCount; ++i) {
+                if (rects[i].left() < min_x)
+                    min_x = rects[i].left();
+                if (rects[i].top() < min_y)
+                    min_y = rects[i].top();
+                if (rects[i].right() > max_x)
+                    max_x = rects[i].left() + rects[i].width();
+                if (rects[i].bottom() > max_y)
+                    max_y = rects[i].top() + rects[i].height();
+
+            }
+            buffer->updateBoundingRect(QRectF(min_x, min_y, max_x - min_x, max_y - min_y));
+        }
+    }
+}
+
+void QPaintBufferEngine::drawRects(const QRectF *rects, int rectCount)
+{
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+    qDebug() << "QPaintBufferEngine: drawRectsF:" << rectCount;
+#endif
+    QPaintBufferCommand *cmd =
+        buffer->addCommand(QPaintBufferPrivate::Cmd_DrawRectF, (qreal *) rects, 4 * rectCount, rectCount);
+    cmd->extra = rectCount;
+
+    if (buffer->calculateBoundingRect) {
+        if (rectCount == 1) {
+            buffer->updateBoundingRect(rects[0]);
+        } else {
+            qreal min_x = rects[0].left();
+            qreal min_y = rects[0].top();
+            qreal max_x = rects[0].right();
+            qreal max_y = rects[0].bottom();
+            for (int i=1; i< rectCount; ++i) {
+                if (rects[i].left() < min_x)
+                    min_x = rects[i].left();
+                if (rects[i].top() < min_y)
+                    min_y = rects[i].top();
+                if (rects[i].right() > max_x)
+                    max_x = rects[i].right();
+                if (rects[i].bottom() > max_y)
+                    max_y = rects[i].bottom();
+
+            }
+            buffer->updateBoundingRect(QRectF(min_x, min_y, max_x - min_x, max_y - min_y));
+        }
+    }
+}
+
+void QPaintBufferEngine::drawLines(const QLine *lines, int lineCount)
+{
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+    qDebug() << "QPaintBufferEngine: drawLinesI:" << lineCount;
+#endif
+    QPaintBufferCommand *cmd =
+        buffer->addCommand(QPaintBufferPrivate::Cmd_DrawLineI, (int *) lines, 4 * lineCount, lineCount);
+    cmd->extra = lineCount;
+
+    if (buffer->calculateBoundingRect) {
+        int min_x = lines[0].p1().x();
+        int min_y = lines[0].p1().y();
+        int max_x = lines[0].p2().x();
+        int max_y = lines[0].p2().y();
+        if (min_x > max_x)
+            qSwap(min_x, max_x);
+        if (min_y > max_y)
+            qSwap(min_y, max_y);
+        for (int i=1; i < lineCount; ++i) {
+            int p1_x = lines[i].p1().x();
+            int p1_y = lines[i].p1().y();
+            int p2_x = lines[i].p2().x();
+            int p2_y = lines[i].p2().y();
+            if (p1_x > p2_x) {
+                min_x = qMin(p2_x, min_x);
+                max_x = qMax(p1_x, max_x);
+            } else {
+                min_x = qMin(p1_x, min_x);
+                max_x = qMax(p2_x, max_x);
+            }
+            if (p1_y > p2_y) {
+                min_y = qMin(p2_y, min_y);
+                max_y = qMax(p1_y, max_y);
+            } else {
+                min_y = qMin(p1_y, min_y);
+                max_y = qMax(p2_y, max_y);
+            }
+        }
+        buffer->updateBoundingRect(QRectF(min_x, min_y, max_x - min_x, max_y - min_y));
+    }
+}
+
+void QPaintBufferEngine::drawLines(const QLineF *lines, int lineCount)
+{
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+    qDebug() << "QPaintBufferEngine: drawLinesF:" << lineCount;
+#endif
+    QPaintBufferCommand *cmd =
+        buffer->addCommand(QPaintBufferPrivate::Cmd_DrawLineF, (qreal *) lines, 4 * lineCount, lineCount);
+    cmd->extra = lineCount;
+
+    if (buffer->calculateBoundingRect) {
+        qreal min_x = lines[0].p1().x();
+        qreal min_y = lines[0].p1().y();
+        qreal max_x = lines[0].p2().x();
+        qreal max_y = lines[0].p2().y();
+        if (min_x > max_x)
+            qSwap(min_x, max_x);
+        if (min_y > max_y)
+            qSwap(min_y, max_y);
+        for (int i=1; i < lineCount; ++i) {
+            qreal p1_x = lines[i].p1().x();
+            qreal p1_y = lines[i].p1().y();
+            qreal p2_x = lines[i].p2().x();
+            qreal p2_y = lines[i].p2().y();
+            if (p1_x > p2_x) {
+                min_x = qMin(p2_x, min_x);
+                max_x = qMax(p1_x, max_x);
+            } else {
+                min_x = qMin(p1_x, min_x);
+                max_x = qMax(p2_x, max_x);
+            }
+            if (p1_y > p2_y) {
+                min_y = qMin(p2_y, min_y);
+                max_y = qMax(p1_y, max_y);
+            } else {
+                min_y = qMin(p1_y, min_y);
+                max_y = qMax(p2_y, max_y);
+            }
+        }
+        buffer->updateBoundingRect(QRectF(min_x, min_y, max_x - min_x, max_y - min_y));
+    }
+}
+
+void QPaintBufferEngine::drawEllipse(const QRectF &r)
+{
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+    qDebug() << "QPaintBufferEngine: drawEllipseF:" << r;
+#endif
+    buffer->addCommand(QPaintBufferPrivate::Cmd_DrawEllipseF, (qreal *) &r, 4, 1);
+    if (buffer->calculateBoundingRect)
+        buffer->updateBoundingRect(r);
+}
+
+void QPaintBufferEngine::drawEllipse(const QRect &r)
+{
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+    qDebug() << "QPaintBufferEngine: drawEllipseI:" << r;
+#endif
+    buffer->addCommand(QPaintBufferPrivate::Cmd_DrawEllipseI, (int *) &r, 4, 1);
+    if (buffer->calculateBoundingRect)
+        buffer->updateBoundingRect(r);
+}
+
+void QPaintBufferEngine::drawPath(const QPainterPath &path)
+{
+// #ifdef QPAINTBUFFER_DEBUG_DRAW
+//     qDebug() << "QPaintBufferEngine: drawPath: element count:" << path.elementCount();
+// #endif
+//     // ### Path -> QVariant
+//     // buffer->addCommand(QPaintBufferPrivate::Cmd_DrawPath, QVariant(path));
+    QPaintEngineEx::drawPath(path);
+
+//     if (buffer->calculateBoundingRect)
+//         buffer->updateBoundingRect(path.boundingRect());
+}
+
+void QPaintBufferEngine::drawPoints(const QPoint *points, int pointCount)
+{
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+    qDebug() << "QPaintBufferEngine: drawPointsI: " << pointCount;
+#endif
+    buffer->addCommand(QPaintBufferPrivate::Cmd_DrawPointsI, (int *) points, 2 * pointCount, pointCount);
+
+    if (buffer->calculateBoundingRect) {
+        int min_x = points[0].x();
+        int min_y = points[0].y();
+        int max_x = points[0].x()+1;
+        int max_y = points[0].y()+1;
+        for (int i=1; i<pointCount; ++i) {
+            int x = points[i].x();
+            int y = points[i].y();
+            min_x = qMin(min_x, x);
+            min_y = qMin(min_y, y);
+            max_x = qMax(max_x, x+1);
+            max_y = qMax(max_y, y+1);
+        }
+        buffer->updateBoundingRect(QRectF(min_x, min_y, max_x - min_x, max_y - min_y));
+    }
+}
+
+void QPaintBufferEngine::drawPoints(const QPointF *points, int pointCount)
+{
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+    qDebug() << "QPaintBufferEngine: drawPointsF: " << pointCount;
+#endif
+    buffer->addCommand(QPaintBufferPrivate::Cmd_DrawPointsF, (qreal *) points, 2 * pointCount, pointCount);
+
+    if (buffer->calculateBoundingRect) {
+        qreal min_x = points[0].x();
+        qreal min_y = points[0].y();
+        qreal max_x = points[0].x()+1;
+        qreal max_y = points[0].y()+1;
+        for (int i=1; i<pointCount; ++i) {
+            qreal x = points[i].x();
+            qreal y = points[i].y();
+            min_x = qMin(min_x, x);
+            min_y = qMin(min_y, y);
+            max_x = qMax(max_x, x+1);
+            max_y = qMax(max_y, y+1);
+        }
+        buffer->updateBoundingRect(QRectF(min_x, min_y, max_x - min_x, max_y - min_y));
+    }
+}
+
+void QPaintBufferEngine::drawPolygon(const QPoint *pts, int count, PolygonDrawMode mode)
+{
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+    qDebug() << "QPaintBufferEngine: drawPolygonI: size:" << count << ", mode:" << mode;
+#endif
+    if (mode == QPaintEngine::OddEvenMode || mode == QPaintEngine::WindingMode) {
+        QPaintBufferCommand *cmd = buffer->addCommand(QPaintBufferPrivate::Cmd_DrawPolygonI,
+                                                      (int *) pts, 2 * count, count);
+        cmd->extra = mode;
+    } else if (mode == QPaintEngine::PolylineMode) {
+        buffer->addCommand(QPaintBufferPrivate::Cmd_DrawPolylineI, (int *) pts, 2 * count, count);
+    } else {
+        buffer->addCommand(QPaintBufferPrivate::Cmd_DrawConvexPolygonI, (int *) pts, 2 * count, count);
+    }
+
+    if (buffer->calculateBoundingRect) {
+        int min_x = pts[0].x();
+        int min_y = pts[0].y();
+        int max_x = pts[0].x();
+        int max_y = pts[0].y();
+        for (int i=1; i<count; ++i) {
+            int x = pts[i].x();
+            int y = pts[i].y();
+            min_x = qMin(min_x, x);
+            min_y = qMin(min_y, y);
+            max_x = qMax(max_x, x);
+            max_y = qMax(max_y, y);
+        }
+        buffer->updateBoundingRect(QRectF(min_x, min_y, max_x - min_x, max_y - min_y));
+    }
+}
+
+void QPaintBufferEngine::drawPolygon(const QPointF *pts, int count, PolygonDrawMode mode)
+{
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+    qDebug() << "QPaintBufferEngine: drawPolygonF: size:" << count << ", mode:" << mode;
+#endif
+    if (mode == QPaintEngine::OddEvenMode || mode == QPaintEngine::WindingMode) {
+        QPaintBufferCommand *cmd = buffer->addCommand(QPaintBufferPrivate::Cmd_DrawPolygonF,
+                                                      (qreal *) pts, 2 * count, count);
+        cmd->extra = mode;
+    } else if (mode == QPaintEngine::PolylineMode) {
+        buffer->addCommand(QPaintBufferPrivate::Cmd_DrawPolylineF, (qreal *) pts, 2 * count, count);
+    } else {
+        buffer->addCommand(QPaintBufferPrivate::Cmd_DrawConvexPolygonF, (qreal *) pts, 2 * count, count);
+    }
+
+    if (buffer->calculateBoundingRect) {
+        qreal min_x = pts[0].x();
+        qreal min_y = pts[0].y();
+        qreal max_x = pts[0].x();
+        qreal max_y = pts[0].y();
+        for (int i=1; i<count; ++i) {
+            qreal x = pts[i].x();
+            qreal y = pts[i].y();
+            min_x = qMin(min_x, x);
+            min_y = qMin(min_y, y);
+            max_x = qMax(max_x, x);
+            max_y = qMax(max_y, y);
+        }
+        buffer->updateBoundingRect(QRectF(min_x, min_y, max_x - min_x, max_y - min_y));
+    }
+}
+
+void QPaintBufferEngine::drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr)
+{
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+    qDebug() << "QPaintBufferEngine: drawPixmap: src/dest rects " << r << sr;
+#endif
+    QPaintBufferCommand *cmd =
+        buffer->addCommand(QPaintBufferPrivate::Cmd_DrawPixmapRect, QVariant(pm));
+    cmd->extra = buffer->addData((qreal *) &r, 4);
+    buffer->addData((qreal *) &sr, 4);
+    if (buffer->calculateBoundingRect)
+        buffer->updateBoundingRect(r);
+}
+
+void QPaintBufferEngine::drawPixmap(const QPointF &pos, const QPixmap &pm)
+{
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+    qDebug() << "QPaintBufferEngine: drawPixmap: pos:" << pos;
+#endif
+    QPaintBufferCommand *cmd =
+        buffer->addCommand(QPaintBufferPrivate::Cmd_DrawPixmapPos, QVariant(pm));
+    cmd->extra = buffer->addData((qreal *) &pos, 2);
+    if (buffer->calculateBoundingRect)
+        buffer->updateBoundingRect(QRectF(pos, pm.size()));
+}
+
+static inline QImage qpaintbuffer_storable_image(const QImage &src)
+{
+    QImageData *d = const_cast<QImage &>(src).data_ptr();
+    return d->own_data ? src : src.copy();
+}
+
+void QPaintBufferEngine::drawImage(const QRectF &r, const QImage &image, const QRectF &sr,
+                                   Qt::ImageConversionFlags /*flags */)
+{
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+    qDebug() << "QPaintBufferEngine: drawImage: src/dest rects " << r << sr;
+#endif
+    QPaintBufferCommand *cmd =
+        buffer->addCommand(QPaintBufferPrivate::Cmd_DrawImageRect,
+                           QVariant(qpaintbuffer_storable_image(image)));
+    cmd->extra = buffer->addData((qreal *) &r, 4);
+    buffer->addData((qreal *) &sr, 4);
+    // ### flags...
+    if (buffer->calculateBoundingRect)
+        buffer->updateBoundingRect(r);
+}
+
+void QPaintBufferEngine::drawImage(const QPointF &pos, const QImage &image)
+{
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+    qDebug() << "QPaintBufferEngine: drawImage: pos:" << pos;
+#endif
+    QPaintBufferCommand *cmd =
+        buffer->addCommand(QPaintBufferPrivate::Cmd_DrawImagePos,
+                           QVariant(qpaintbuffer_storable_image(image)));
+    cmd->extra = buffer->addData((qreal *) &pos, 2);
+    if (buffer->calculateBoundingRect)
+        buffer->updateBoundingRect(QRectF(pos, image.size()));
+}
+
+void QPaintBufferEngine::drawTiledPixmap(const QRectF &r, const QPixmap &pm, const QPointF &s)
+{
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+    qDebug() << "QPaintBufferEngine: drawTiledPixmap: src rect/offset:" << r << s;
+#endif
+    QPaintBufferCommand *cmd =
+        buffer->addCommand(QPaintBufferPrivate::Cmd_DrawTiledPixmap, QVariant(pm));
+    cmd->extra = buffer->addData((qreal *) &r, 4);
+    buffer->addData((qreal *) &s, 2);
+    if (buffer->calculateBoundingRect)
+        buffer->updateBoundingRect(r);
+}
+
+void QPaintBufferEngine::drawStaticTextItem(QStaticTextItem *staticTextItem)
+{
+    QVariantList variants;
+
+    variants << QVariant(staticTextItem->font);
+    for (int i=0; i<staticTextItem->numGlyphs; ++i) {
+        variants.append(staticTextItem->glyphs[i]);
+        variants.append(staticTextItem->glyphPositions[i].toPointF());
+    }
+
+    buffer->addCommand(QPaintBufferPrivate::Cmd_DrawStaticText, QVariant(variants));
+}
+
+void QPaintBufferEngine::drawTextItem(const QPointF &pos, const QTextItem &ti)
+{
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+    qDebug() << "QPaintBufferEngine: drawTextItem: pos:" << pos << ti.text();
+#endif
+    if (m_stream_raw_text_items) {
+        QPaintBufferCommand *cmd = buffer->addCommand(QPaintBufferPrivate::Cmd_DrawTextItem, QVariant::fromValue<void *>(new QTextItemIntCopy(ti)));
+
+        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();
+        int renderFlags = ti.renderFlags();
+        qreal scaleFactor = font.d->dpi/qreal(qt_defaultDpiY());
+
+        buffer->addData(QVariant(font));
+        cmd->extra = buffer->addData((qreal *) &pos, 2);
+        buffer->addData((qreal *) &justificationWidth, 1);
+        buffer->addData((qreal *) &scaleFactor, 1);
+        cmd->offset2 = buffer->addData((int *) &renderFlags, 1);
+    } else {
+        QList<QVariant> variants;
+        variants << QVariant(ti.font()) << QVariant(ti.text());
+        QPaintBufferCommand *cmd = buffer->addCommand(QPaintBufferPrivate::Cmd_DrawText, QVariant(variants));
+        cmd->extra = buffer->addData((qreal *) &pos, 2);
+    }
+
+    if (buffer->calculateBoundingRect)
+        buffer->updateBoundingRect(QRectF(pos, QSize(ti.width(), ti.ascent() + ti.descent() + 1)));
+}
+
+
+void QPaintBufferEngine::setState(QPainterState *s)
+{
+    Q_D(QPaintBufferEngine);
+    if (m_begin_detected) {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+            qDebug() << "QPaintBufferEngine: setState: begin, ignoring.";
+#endif
+        m_begin_detected = false;
+    } else if (m_save_detected) {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << "QPaintBufferEngine: setState: save.";
+#endif
+        m_save_detected = false;
+        buffer->addCommand(QPaintBufferPrivate::Cmd_Save);
+    } else {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << "QPaintBufferEngine: setState: restore.";
+#endif
+        buffer->addCommand(QPaintBufferPrivate::Cmd_Restore);
+    }
+
+    d->last = s->matrix;
+
+    QPaintEngineEx::setState(s);
+}
+
+
+/***********************************************************************
+ *
+ * class QPaintBufferPlayback_Painter
+ *
+ */
+
+// QFakeDevice is used to create fonts with a custom DPI
+//
+class QFakeDevice : public QPaintDevice
+{
+public:
+    QFakeDevice() { dpi_x = qt_defaultDpiX(); dpi_y = qt_defaultDpiY(); }
+    void setDpiX(int dpi) { dpi_x = dpi; }
+    void setDpiY(int dpi) { dpi_y = dpi; }
+    QPaintEngine *paintEngine() const { return 0; }
+    int metric(PaintDeviceMetric m) const
+    {
+        switch(m) {
+            case PdmPhysicalDpiX:
+            case PdmDpiX:
+                return dpi_x;
+            case PdmPhysicalDpiY:
+            case PdmDpiY:
+                return dpi_y;
+            default:
+                return QPaintDevice::metric(m);
+        }
+    }
+
+private:
+    int dpi_x;
+    int dpi_y;
+};
+
+
+void QPainterReplayer::setupTransform(QPainter *_painter)
+{
+    painter = _painter;
+    m_world_matrix = painter->transform();
+    m_world_matrix.scale(qreal(painter->device()->logicalDpiX()) / qreal(qt_defaultDpiX()),
+                         qreal(painter->device()->logicalDpiY()) / qreal(qt_defaultDpiY()));
+    painter->setTransform(m_world_matrix);
+}
+
+void QPainterReplayer::processCommands(const QPaintBuffer &buffer, QPainter *p, int begin, int end)
+{
+    d = buffer.d_ptr;
+    painter = p;
+
+    for (int cmdIndex = begin; cmdIndex < end; ++cmdIndex) {
+        const QPaintBufferCommand &cmd = d->commands.at(cmdIndex);
+        process(cmd);
+    }
+}
+
+void QPaintBuffer::beginNewFrame()
+{
+    if (!d_ptr->commands.isEmpty())
+        d_ptr->frames << d_ptr->commands.size();
+}
+
+int QPaintBuffer::numFrames() const
+{
+    return d_ptr->frames.size() + 1;
+}
+
+void QPainterReplayer::process(const QPaintBufferCommand &cmd)
+{
+    switch (cmd.id) {
+    case QPaintBufferPrivate::Cmd_Save: {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> Cmd_Save";
+#endif
+        painter->save();
+        break; }
+
+    case QPaintBufferPrivate::Cmd_Restore: {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> Cmd_Restore";
+#endif
+        painter->restore();
+        break; }
+
+    case QPaintBufferPrivate::Cmd_SetPen: {
+        QPen pen = qvariant_cast<QPen>(d->variants.at(cmd.offset));
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> Cmd_SetPen: " << pen;
+#endif
+        painter->setPen(pen);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_SetBrush: {
+        QBrush brush = qvariant_cast<QBrush>(d->variants.at(cmd.offset));
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> Cmd_SetBrush: " << brush;
+#endif
+        painter->setBrush(brush);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_SetBrushOrigin: {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> Cmd_SetBrushOrigin: " << d->variants.at(cmd.offset).toPointF();
+#endif
+        painter->setBrushOrigin(d->variants.at(cmd.offset).toPointF());
+        break; }
+
+    case QPaintBufferPrivate::Cmd_SetTransform: {
+        QTransform xform = qvariant_cast<QTransform>(d->variants.at(cmd.offset));
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> Cmd_SetTransform, offset: " << cmd.offset << xform;
+#endif
+        painter->setTransform(xform * m_world_matrix);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_Translate: {
+        QPointF delta(d->floats.at(cmd.extra), d->floats.at(cmd.extra+1));
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> Cmd_Translate, offset: " << cmd.offset << delta;
+#endif
+        painter->translate(delta.x(), delta.y());
+        return;
+    }
+
+    case QPaintBufferPrivate::Cmd_SetCompositionMode: {
+        QPainter::CompositionMode mode = (QPainter::CompositionMode) cmd.extra;
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> Cmd_SetCompositionMode, mode: " << mode;
+#endif
+        painter->setCompositionMode(mode);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_SetRenderHints: {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> Cmd_SetRenderHints, hints: " << cmd.extra;
+#endif
+        QPainter::RenderHints ph = painter->renderHints();
+        QPainter::RenderHints nh = (QPainter::RenderHints) cmd.extra;
+        QPainter::RenderHints xored = ph ^ nh;
+        if (xored & QPainter::Antialiasing)
+            painter->setRenderHint(QPainter::Antialiasing, nh & QPainter::Antialiasing);
+        if (xored & QPainter::HighQualityAntialiasing)
+            painter->setRenderHint(QPainter::HighQualityAntialiasing, nh & QPainter::HighQualityAntialiasing);
+        if (xored & QPainter::TextAntialiasing)
+            painter->setRenderHint(QPainter::TextAntialiasing, nh & QPainter::TextAntialiasing);
+        if (xored & QPainter::SmoothPixmapTransform)
+            painter->setRenderHint(QPainter::SmoothPixmapTransform, nh & QPainter::SmoothPixmapTransform);
+        if (xored & QPainter::NonCosmeticDefaultPen)
+            painter->setRenderHint(QPainter::NonCosmeticDefaultPen, nh & QPainter::NonCosmeticDefaultPen);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_SetOpacity: {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> Cmd_SetOpacity: " << d->variants.at(cmd.offset).toDouble();
+#endif
+        painter->setOpacity(d->variants.at(cmd.offset).toDouble());
+        break; }
+
+    case QPaintBufferPrivate::Cmd_SetBackgroundMode: {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> Cmd_SetBackgroundMode: " << cmd.extra;
+#endif
+        painter->setBackgroundMode((Qt::BGMode)cmd.extra);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawVectorPath: {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> Cmd_DrawVectorPath: size: " << cmd.size
+//                 << ", hints:" << d->ints[cmd.offset2+cmd.size]
+                 << "pts/elms:" << cmd.offset << cmd.offset2;
+#endif
+        QVectorPathCmd path(d, cmd);
+        painter->drawPath(path().convertToPainterPath());
+        break; }
+
+    case QPaintBufferPrivate::Cmd_StrokeVectorPath: {
+        QPen pen = qvariant_cast<QPen>(d->variants.at(cmd.extra));
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> Cmd_StrokeVectorPath: size: " << cmd.size
+//                 << ", hints:" << d->ints[cmd.offset2+cmd.size]
+                 << "pts/elms:" << cmd.offset << cmd.offset2;
+#endif
+        QVectorPathCmd path(d, cmd);
+        painter->strokePath(path().convertToPainterPath(), pen);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_FillVectorPath: {
+        QBrush brush = qvariant_cast<QBrush>(d->variants.at(cmd.extra));
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> Cmd_FillVectorPath: size: " << cmd.size
+//                 << ", hints:" << d->ints[cmd.offset2+cmd.size]
+                 << "pts/elms:" << cmd.offset << cmd.offset2 << brush;
+#endif
+        QVectorPathCmd path(d, cmd);
+        painter->fillPath(path().convertToPainterPath(), brush);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawPolygonF: {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> Cmd_DrawPolygonF, offset: " << cmd.offset << " size: " << cmd.size
+                 << " mode: " << cmd.extra
+                 << d->floats.at(cmd.offset)
+                 << d->floats.at(cmd.offset+1);
+#endif
+        Qt::FillRule fill = (QPaintEngine::PolygonDrawMode) cmd.extra == QPaintEngine::OddEvenMode
+                            ? Qt::OddEvenFill : Qt::WindingFill;
+        painter->drawPolygon((QPointF *) (d->floats.constData() + cmd.offset), cmd.size, fill);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawPolygonI: {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> Cmd_DrawPolygonI, offset: " << cmd.offset << " size: " << cmd.size
+                 << " mode: " << cmd.extra
+                 << d->ints.at(cmd.offset)
+                 << d->ints.at(cmd.offset+1);
+#endif
+        Qt::FillRule fill = (QPaintEngine::PolygonDrawMode) cmd.extra == QPaintEngine::OddEvenMode
+                            ? Qt::OddEvenFill : Qt::WindingFill;
+        painter->drawPolygon((QPoint *) (d->ints.constData() + cmd.offset), cmd.size, fill);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawPolylineF: {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> Cmd_DrawPolylineF, offset: " << cmd.offset << " size: " << cmd.size;
+#endif
+        painter->drawPolyline((QPointF *) (d->floats.constData() + cmd.offset), cmd.size);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawPolylineI: {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> Cmd_DrawPolylineI, offset: " << cmd.offset << " size: " << cmd.size;
+#endif
+        painter->drawPolyline((QPoint *) (d->ints.constData() + cmd.offset), cmd.size);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawConvexPolygonF: {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> Cmd_DrawConvexPolygonF, offset: " << cmd.offset << " size: " << cmd.size;
+#endif
+        painter->drawConvexPolygon((QPointF *) (d->floats.constData() + cmd.offset), cmd.size);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawConvexPolygonI: {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> Cmd_DrawConvexPolygonI, offset: " << cmd.offset << " size: " << cmd.size;
+#endif
+        painter->drawConvexPolygon((QPoint *) (d->ints.constData() + cmd.offset), cmd.size);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawEllipseF: {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> Cmd_DrawEllipseF, offset: " << cmd.offset;
+#endif
+        painter->drawEllipse(*(QRectF *)(d->floats.constData() + cmd.offset));
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawEllipseI: {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> Cmd_DrawEllipseI, offset: " << cmd.offset;
+#endif
+        painter->drawEllipse(*(QRect *)(d->ints.constData() + cmd.offset));
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawLineF: {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> Cmd_DrawLineF, offset: " << cmd.offset << " size: " << cmd.size;
+#endif
+        painter->drawLines((QLineF *)(d->floats.constData() + cmd.offset), cmd.size);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawLineI: {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> Cmd_DrawLineI, offset: " << cmd.offset << " size: " << cmd.size;
+#endif
+        painter->drawLines((QLine *)(d->ints.constData() + cmd.offset), cmd.size);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawPointsF: {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> Cmd_DrawPointsF, offset: " << cmd.offset << " size: " << cmd.size;
+#endif
+        painter->drawPoints((QPointF *)(d->floats.constData() + cmd.offset), cmd.size);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawPointsI: {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> Cmd_DrawPointsI, offset: " << cmd.offset << " size: " << cmd.size;
+#endif
+        painter->drawPoints((QPoint *)(d->ints.constData() + cmd.offset), cmd.size);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawPixmapRect: {
+        QPixmap pm(d->variants.at(cmd.offset).value<QPixmap>());
+        QRectF r(d->floats.at(cmd.extra), d->floats.at(cmd.extra+1),
+                 d->floats.at(cmd.extra+2), d->floats.at(cmd.extra+3));
+
+        QRectF sr(d->floats.at(cmd.extra+4), d->floats.at(cmd.extra+5),
+                  d->floats.at(cmd.extra+6), d->floats.at(cmd.extra+7));
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> Cmd_DrawPixmapRect:" << r << sr;
+#endif
+        painter->drawPixmap(r, pm, sr);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawPixmapPos: {
+        QPixmap pm(d->variants.at(cmd.offset).value<QPixmap>());
+        QPointF pos(d->floats.at(cmd.extra), d->floats.at(cmd.extra+1));
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> Cmd_DrawPixmapPos:" << pos;
+#endif
+        painter->drawPixmap(pos, pm);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawTiledPixmap: {
+        QPixmap pm(d->variants.at(cmd.offset).value<QPixmap>());
+        QRectF r(d->floats.at(cmd.extra), d->floats.at(cmd.extra+1),
+                 d->floats.at(cmd.extra+2), d->floats.at(cmd.extra+3));
+
+        QPointF offset(d->floats.at(cmd.extra+4), d->floats.at(cmd.extra+5));
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> Cmd_DrawTiledPixmap:" << r << offset;
+#endif
+        painter->drawTiledPixmap(r, pm, offset);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawImageRect: {
+        QImage image(d->variants.at(cmd.offset).value<QImage>());
+        QRectF r(d->floats.at(cmd.extra), d->floats.at(cmd.extra+1),
+                 d->floats.at(cmd.extra+2), d->floats.at(cmd.extra+3));
+        QRectF sr(d->floats.at(cmd.extra+4), d->floats.at(cmd.extra+5),
+                  d->floats.at(cmd.extra+6), d->floats.at(cmd.extra+7));
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> Cmd_DrawImageRect:" << r << sr;
+#endif
+        painter->drawImage(r, image, sr);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawImagePos: {
+        QImage image(d->variants.at(cmd.offset).value<QImage>());
+        QPointF pos(d->floats.at(cmd.extra), d->floats.at(cmd.extra+1));
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> Cmd_DrawImagePos:" << pos;
+#endif
+        painter->drawImage(pos, image);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawRectF: {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> Cmd_DrawRectF, offset: " << cmd.offset;
+#endif
+        painter->drawRects((QRectF *)(d->floats.constData() + cmd.offset), cmd.size);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawRectI: {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> Cmd_DrawRectI, offset: " << cmd.offset;
+#endif
+        painter->drawRects((QRect *)(d->ints.constData() + cmd.offset), cmd.size);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_FillRectBrush: {
+        QBrush brush = qvariant_cast<QBrush>(d->variants.at(cmd.extra));
+        QRectF *rect = (QRectF *)(d->floats.constData() + cmd.offset);
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> Cmd_FillRectBrush, offset: " << cmd.offset << " rect: " << *rect << " brush: " << brush;
+#endif
+        painter->fillRect(*rect, brush);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_FillRectColor: {
+        QColor color = qvariant_cast<QColor>(d->variants.at(cmd.extra));
+        QRectF *rect = (QRectF *)(d->floats.constData() + cmd.offset);
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> Cmd_FillRectBrush, offset: " << cmd.offset << " rect: " << *rect << " color: " << color;
+#endif
+        painter->fillRect(*rect, color);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_SetClipEnabled: {
+        bool clipEnabled = d->variants.at(cmd.offset).toBool();
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> Cmd_SetClipEnabled:" << clipEnabled;
+#endif
+        painter->setClipping(clipEnabled);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_ClipVectorPath: {
+        QVectorPathCmd path(d, cmd);
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> Cmd_ClipVectorPath:" << path().elementCount();
+#endif
+        painter->setClipPath(path().convertToPainterPath(), Qt::ClipOperation(cmd.extra));
+        break; }
+
+
+    case QPaintBufferPrivate::Cmd_ClipRect: {
+        QRect rect(QPoint(d->ints.at(cmd.offset), d->ints.at(cmd.offset + 1)),
+                   QPoint(d->ints.at(cmd.offset + 2), d->ints.at(cmd.offset + 3)));
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> Cmd_ClipRect:" << rect << cmd.extra;
+#endif
+        painter->setClipRect(rect, Qt::ClipOperation(cmd.extra));
+        break; }
+
+    case QPaintBufferPrivate::Cmd_ClipRegion: {
+        QRegion region(d->variants.at(cmd.offset).value<QRegion>());
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> Cmd_ClipRegion:" << region.boundingRect() << cmd.extra;
+#endif
+        painter->setClipRegion(region, Qt::ClipOperation(cmd.extra));
+        break; }
+        
+#if !defined(QT_NO_RAWFONT)
+    case QPaintBufferPrivate::Cmd_DrawStaticText: {
+            
+            QVariantList variants(d->variants.at(cmd.offset).value<QVariantList>());
+            
+            QFont font = variants.at(0).value<QFont>();
+
+            QVector<quint32> glyphIndexes;
+            QVector<QPointF> positions;
+
+            for (int i=0; i<(variants.size() - 1) / 2; ++i) {
+                glyphIndexes.append(variants.at(i*2 + 1).toUInt());
+                positions.append(variants.at(i*2 + 2).toPointF());
+            }
+
+            painter->setFont(font);
+
+            QRawFont rawFont;
+            QRawFontPrivate *rawFontD = QRawFontPrivate::get(rawFont);
+            QFontPrivate *fontD = QFontPrivate::get(font);
+            rawFontD->fontEngine = fontD->engineForScript(QUnicodeTables::Common);
+            rawFontD->fontEngine->ref.ref();
+
+            QGlyphs glyphs;
+            glyphs.setFont(rawFont);
+            glyphs.setGlyphIndexes(glyphIndexes);
+            glyphs.setPositions(positions);
+
+            painter->drawGlyphs(QPointF(), glyphs);
+            break;
+    }
+#endif
+
+    case QPaintBufferPrivate::Cmd_DrawText: {
+        QPointF pos(d->floats.at(cmd.extra), d->floats.at(cmd.extra+1));
+        QList<QVariant> variants(d->variants.at(cmd.offset).value<QList<QVariant> >());
+
+        QFont font(variants.at(0).value<QFont>());
+        QString text(variants.at(1).value<QString>());
+
+        painter->setFont(font);
+        painter->drawText(pos, text);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawTextItem: {
+        QPointF pos(d->floats.at(cmd.extra), d->floats.at(cmd.extra+1));
+        QTextItemIntCopy *tiCopy = reinterpret_cast<QTextItemIntCopy *>(qvariant_cast<void *>(d->variants.at(cmd.offset)));
+        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();
+        qreal scaleFactor = font.d->dpi/qreal(qt_defaultDpiY());
+
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> Cmd_DrawTextItem:" << pos << " " << text << " " << scaleFactor;
+#endif
+
+        if (scaleFactor != 1.0) {
+            QFont fnt(font);
+            QFakeDevice fake;
+            fake.setDpiX(qRound(scaleFactor*qt_defaultDpiX()));
+            fake.setDpiY(qRound(scaleFactor*qt_defaultDpiY()));
+            font = QFont(fnt, &fake);
+        }
+
+        int flags = Qt::TextSingleLine | Qt::TextDontClip | Qt::TextForceLeftToRight;
+        QSizeF size(1, 1);
+        if (justificationWidth > 0) {
+            size.setWidth(justificationWidth);
+            flags |= Qt::TextJustificationForced;
+            flags |= Qt::AlignJustify;
+        }
+
+        QFontMetrics fm(font);
+        QPointF pt(pos.x(), pos.y() - fm.ascent());
+        qt_format_text(font, QRectF(pt, size), flags, /*opt*/0,
+                       text, /*brect=*/0, /*tabstops=*/0, /*...*/0, /*tabarraylen=*/0, painter);
+        break; }
+    case QPaintBufferPrivate::Cmd_SystemStateChanged: {
+        QRegion systemClip(d->variants.at(cmd.offset).value<QRegion>());
+
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> Cmd_SystemStateChanged:" << systemClip;
+#endif
+
+        painter->paintEngine()->setSystemClip(systemClip);
+        painter->paintEngine()->d_ptr->systemStateChanged();
+        break; }
+    }
+}
+
+void QPaintEngineExReplayer::process(const QPaintBufferCommand &cmd)
+{
+    Q_ASSERT(painter->paintEngine()->isExtended());
+    QPaintEngineEx *xengine = static_cast<QPaintEngineEx *>(painter->paintEngine());
+
+    switch (cmd.id) {
+    case QPaintBufferPrivate::Cmd_SetBrushOrigin: {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> ExCmd_SetBrushOrigin: " << d->variants.at(cmd.offset).toPointF();
+#endif
+        xengine->state()->brushOrigin = d->variants.at(cmd.offset).toPointF();
+        xengine->brushOriginChanged();
+        break; }
+
+    case QPaintBufferPrivate::Cmd_SetCompositionMode: {
+        QPainter::CompositionMode mode = (QPainter::CompositionMode) cmd.extra;
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> ExCmd_SetCompositionMode, mode: " << mode;
+#endif
+        xengine->state()->composition_mode = mode;
+        xengine->compositionModeChanged();
+        break; }
+
+    case QPaintBufferPrivate::Cmd_SetOpacity: {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> ExCmd_SetOpacity: " << d->variants.at(cmd.offset).toDouble();
+#endif
+        xengine->state()->opacity = d->variants.at(cmd.offset).toDouble();
+        xengine->opacityChanged();
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawVectorPath: {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> ExCmd_DrawVectorPath: size: " << cmd.size
+//                 << ", hints:" << d->ints[cmd.offset2+cmd.size]
+                 << "pts/elms:" << cmd.offset << cmd.offset2;
+#endif
+        QVectorPathCmd path(d, cmd);
+        xengine->draw(path());
+        break; }
+
+    case QPaintBufferPrivate::Cmd_StrokeVectorPath: {
+        QPen pen = qvariant_cast<QPen>(d->variants.at(cmd.extra));
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> ExCmd_StrokeVectorPath: size: " << cmd.size
+//                 << ", hints:" << d->ints[cmd.offset2+cmd.size]
+                 << "pts/elms:" << cmd.offset << cmd.offset2;
+#endif
+        QVectorPathCmd path(d, cmd);
+        xengine->stroke(path(), pen);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_FillVectorPath: {
+        QBrush brush = qvariant_cast<QBrush>(d->variants.at(cmd.extra));
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> ExCmd_FillVectorPath: size: " << cmd.size
+//                 << ", hints:" << d->ints[cmd.offset2+cmd.size]
+                 << "pts/elms:" << cmd.offset << cmd.offset2 << brush;
+#endif
+        QVectorPathCmd path(d, cmd);
+        xengine->fill(path(), brush);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_FillRectBrush: {
+        QBrush brush = qvariant_cast<QBrush>(d->variants.at(cmd.extra));
+        QRectF *rect = (QRectF *)(d->floats.constData() + cmd.offset);
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> ExCmd_FillRectBrush, offset: " << cmd.offset << " rect: " << *rect << " brush: " << brush;
+#endif
+        xengine->fillRect(*rect, brush);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_FillRectColor: {
+        QColor color = qvariant_cast<QColor>(d->variants.at(cmd.extra));
+        QRectF *rect = (QRectF *)(d->floats.constData() + cmd.offset);
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> ExCmd_FillRectBrush, offset: " << cmd.offset << " rect: " << *rect << " color: " << color;
+#endif
+        xengine->fillRect(*rect, color);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawPolygonF: {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> ExCmd_DrawPolygonF, offset: " << cmd.offset << " size: " << cmd.size
+                 << " mode: " << cmd.extra
+                 << d->floats.at(cmd.offset)
+                 << d->floats.at(cmd.offset+1);
+#endif
+        xengine->drawPolygon((QPointF *) (d->floats.constData() + cmd.offset), cmd.size,
+                             (QPaintEngine::PolygonDrawMode) cmd.extra);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawPolygonI: {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> ExCmd_DrawPolygonI, offset: " << cmd.offset << " size: " << cmd.size
+                 << " mode: " << cmd.extra
+                 << d->ints.at(cmd.offset)
+                 << d->ints.at(cmd.offset+1);
+#endif
+        xengine->drawPolygon((QPoint *) (d->ints.constData() + cmd.offset), cmd.size,
+                             (QPaintEngine::PolygonDrawMode) cmd.extra);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawEllipseF: {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> ExCmd_DrawEllipseF, offset: " << cmd.offset;
+#endif
+        xengine->drawEllipse(*(QRectF *)(d->floats.constData() + cmd.offset));
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawEllipseI: {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> ExCmd_DrawEllipseI, offset: " << cmd.offset;
+#endif
+        xengine->drawEllipse(*(QRect *)(d->ints.constData() + cmd.offset));
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawLineF: {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> ExCmd_DrawLineF, offset: " << cmd.offset << " size: " << cmd.size;
+#endif
+        xengine->drawLines((QLineF *)(d->floats.constData() + cmd.offset), cmd.size);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawLineI: {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> ExCmd_DrawLineI, offset: " << cmd.offset << " size: " << cmd.size;
+#endif
+        xengine->drawLines((QLine *)(d->ints.constData() + cmd.offset), cmd.size);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawPointsF: {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> ExCmd_DrawPointsF, offset: " << cmd.offset << " size: " << cmd.size;
+#endif
+        xengine->drawPoints((QPointF *)(d->floats.constData() + cmd.offset), cmd.size);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawPointsI: {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> ExCmd_DrawPointsI, offset: " << cmd.offset << " size: " << cmd.size;
+#endif
+        xengine->drawPoints((QPoint *)(d->ints.constData() + cmd.offset), cmd.size);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawPolylineF: {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> ExCmd_DrawPolylineF, offset: " << cmd.offset << " size: " << cmd.size;
+#endif
+        xengine->drawPolygon((QPointF *) (d->floats.constData() + cmd.offset), cmd.size, QPaintEngine::PolylineMode);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawPolylineI: {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> ExCmd_DrawPolylineI, offset: " << cmd.offset << " size: " << cmd.size;
+#endif
+        xengine->drawPolygon((QPoint *) (d->ints.constData() + cmd.offset), cmd.size, QPaintEngine::PolylineMode);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawRectF: {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> ExCmd_DrawRectF, offset: " << cmd.offset << " size: " << cmd.size;
+#endif
+        xengine->drawRects((QRectF *) (d->floats.constData() + cmd.offset), cmd.size);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_DrawRectI: {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> ExCmd_DrawRectI, offset: " << cmd.offset << " size: " << cmd.size;
+#endif
+        xengine->drawRects((QRect *) (d->ints.constData() + cmd.offset), cmd.size);
+        break; }
+
+    case QPaintBufferPrivate::Cmd_SetClipEnabled: {
+        bool clipEnabled = d->variants.at(cmd.offset).toBool();
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> ExCmd_SetClipEnabled:" << clipEnabled;
+#endif
+        xengine->state()->clipEnabled = clipEnabled;
+        xengine->clipEnabledChanged();
+        break; }
+
+    case QPaintBufferPrivate::Cmd_ClipVectorPath: {
+        QVectorPathCmd path(d, cmd);
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> ExCmd_ClipVectorPath:" << path().elementCount();
+#endif
+        xengine->clip(path(), Qt::ClipOperation(cmd.extra));
+        break; }
+
+
+    case QPaintBufferPrivate::Cmd_ClipRect: {
+        QRect rect(QPoint(d->ints.at(cmd.offset), d->ints.at(cmd.offset + 1)),
+                   QPoint(d->ints.at(cmd.offset + 2), d->ints.at(cmd.offset + 3)));
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> ExCmd_ClipRect:" << rect << cmd.extra;
+#endif
+        xengine->clip(rect, Qt::ClipOperation(cmd.extra));
+        break; }
+
+    case QPaintBufferPrivate::Cmd_ClipRegion: {
+        QRegion region(d->variants.at(cmd.offset).value<QRegion>());
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> ExCmd_ClipRegion:" << region.boundingRect() << cmd.extra;
+#endif
+        xengine->clip(region, Qt::ClipOperation(cmd.extra));
+        break; }
+
+    default:
+        QPainterReplayer::process(cmd);
+        break;
+    }
+}
+
+QPaintBufferResource::QPaintBufferResource(FreeFunc f, QObject *parent) : QObject(parent), free(f)
+{
+    connect(QPaintBufferSignalProxy::instance(), SIGNAL(aboutToDestroy(const QPaintBufferPrivate*)), this, SLOT(remove(const QPaintBufferPrivate*)));
+}
+
+QPaintBufferResource::~QPaintBufferResource()
+{
+    for (Cache::iterator it = m_cache.begin(); it != m_cache.end(); ++it)
+        free(it.value());
+}
+
+void QPaintBufferResource::insert(const QPaintBufferPrivate *key, void *value)
+{
+    Cache::iterator it = m_cache.find(key);
+    if (it != m_cache.end()) {
+        free(it.value());
+        it.value() = value;
+    } else {
+        m_cache.insert(key, value);
+    }
+}
+
+void *QPaintBufferResource::value(const QPaintBufferPrivate *key)
+{
+    Cache::iterator it = m_cache.find(key);
+    if (it != m_cache.end())
+        return it.value();
+    return 0;
+}
+
+void QPaintBufferResource::remove(const QPaintBufferPrivate *key)
+{
+    Cache::iterator it = m_cache.find(key);
+    if (it != m_cache.end()) {
+        free(it.value());
+        m_cache.erase(it);
+    }
+}
+
+QDataStream &operator<<(QDataStream &stream, const QPaintBufferCommand &command)
+{
+    quint32 id = command.id;
+    quint32 size = command.size;
+    stream << id << size;
+    stream << command.offset << command.offset2 << command.extra;
+    return stream;
+}
+
+QDataStream &operator>>(QDataStream &stream, QPaintBufferCommand &command)
+{
+    quint32 id;
+    quint32 size;
+    stream >> id >> size;
+    stream >> command.offset >> command.offset2 >> command.extra;
+    command.id = id;
+    command.size = size;
+    return stream;
+}
+
+struct QPaintBufferCacheEntry
+{
+    QVariant::Type type;
+    quint64 cacheKey;
+};
+
+struct QPaintBufferCacheEntryV2
+{
+    enum Type {
+        ImageKey,
+        PixmapKey
+    };
+
+    struct Flags {
+        uint type : 8;
+        uint key : 24;
+    };
+
+    union {
+        Flags flags;
+        uint bits;
+    };
+};
+
+QT_END_NAMESPACE
+Q_DECLARE_METATYPE(QPaintBufferCacheEntry)
+Q_DECLARE_METATYPE(QPaintBufferCacheEntryV2)
+QT_BEGIN_NAMESPACE
+
+QDataStream &operator<<(QDataStream &stream, const QPaintBufferCacheEntry &entry)
+{
+    return stream << entry.type << entry.cacheKey;
+}
+
+QDataStream &operator>>(QDataStream &stream, QPaintBufferCacheEntry &entry)
+{
+    return stream >> entry.type >> entry.cacheKey;
+}
+
+QDataStream &operator<<(QDataStream &stream, const QPaintBufferCacheEntryV2 &entry)
+{
+    return stream << entry.bits;
+}
+
+QDataStream &operator>>(QDataStream &stream, QPaintBufferCacheEntryV2 &entry)
+{
+    return stream >> entry.bits;
+}
+
+static int qRegisterPaintBufferMetaTypes()
+{
+    qRegisterMetaType<QPaintBufferCacheEntry>();
+    qRegisterMetaTypeStreamOperators<QPaintBufferCacheEntry>("QPaintBufferCacheEntry");
+    qRegisterMetaType<QPaintBufferCacheEntryV2>();
+    qRegisterMetaTypeStreamOperators<QPaintBufferCacheEntryV2>("QPaintBufferCacheEntryV2");
+
+    return 0; // something
+}
+
+Q_CONSTRUCTOR_FUNCTION(qRegisterPaintBufferMetaTypes)
+
+QDataStream &operator<<(QDataStream &stream, const QPaintBuffer &buffer)
+{
+    QHash<qint64, uint> pixmapKeys;
+    QHash<qint64, uint> imageKeys;
+
+    QHash<qint64, QPixmap> pixmaps;
+    QHash<qint64, QImage> images;
+
+    QVector<QVariant> variants = buffer.d_ptr->variants;
+    for (int i = 0; i < variants.size(); ++i) {
+        const QVariant &v = variants.at(i);
+        if (v.type() == QVariant::Image) {
+            const QImage image(v.value<QImage>());
+
+            QPaintBufferCacheEntryV2 entry;
+            entry.flags.type = QPaintBufferCacheEntryV2::ImageKey;
+
+            QHash<qint64, uint>::iterator it = imageKeys.find(image.cacheKey());
+            if (it != imageKeys.end()) {
+                entry.flags.key = *it;
+            } else {
+                imageKeys[image.cacheKey()] = entry.flags.key = images.size();
+                images[images.size()] = image;
+            }
+
+            variants[i] = QVariant::fromValue(entry);
+        } else if (v.type() == QVariant::Pixmap) {
+            const QPixmap pixmap(v.value<QPixmap>());
+
+            QPaintBufferCacheEntryV2 entry;
+            entry.flags.type = QPaintBufferCacheEntryV2::PixmapKey;
+
+            QHash<qint64, uint>::iterator it = pixmapKeys.find(pixmap.cacheKey());
+            if (it != pixmapKeys.end()) {
+                entry.flags.key = *it;
+            } else {
+                pixmapKeys[pixmap.cacheKey()] = entry.flags.key = pixmaps.size();
+                pixmaps[pixmaps.size()] = pixmap;
+            }
+
+            variants[i] = QVariant::fromValue(entry);
+        }
+    }
+
+    stream << pixmaps;
+    stream << images;
+
+    stream << buffer.d_ptr->ints;
+    stream << buffer.d_ptr->floats;
+    stream << variants;
+    stream << buffer.d_ptr->commands;
+    stream << buffer.d_ptr->boundingRect;
+    stream << buffer.d_ptr->frames;
+
+    return stream;
+}
+
+QDataStream &operator>>(QDataStream &stream, QPaintBuffer &buffer)
+{
+    QHash<qint64, QPixmap> pixmaps;
+    QHash<qint64, QImage> images;
+
+    stream >> pixmaps;
+    stream >> images;
+
+    stream >> buffer.d_ptr->ints;
+    stream >> buffer.d_ptr->floats;
+    stream >> buffer.d_ptr->variants;
+    stream >> buffer.d_ptr->commands;
+    stream >> buffer.d_ptr->boundingRect;
+    stream >> buffer.d_ptr->frames;
+
+    QVector<QVariant> &variants = buffer.d_ptr->variants;
+    for (int i = 0; i < variants.size(); ++i) {
+        const QVariant &v = variants.at(i);
+        if (v.canConvert<QPaintBufferCacheEntry>()) {
+            QPaintBufferCacheEntry entry = v.value<QPaintBufferCacheEntry>();
+            if (entry.type == QVariant::Image)
+                variants[i] = QVariant(images.value(entry.cacheKey));
+            else
+                variants[i] = QVariant(pixmaps.value(entry.cacheKey));
+        } else if (v.canConvert<QPaintBufferCacheEntryV2>()) {
+            QPaintBufferCacheEntryV2 entry = v.value<QPaintBufferCacheEntryV2>();
+
+            if (entry.flags.type == QPaintBufferCacheEntryV2::ImageKey)
+                variants[i] = QVariant(images.value(entry.flags.key));
+            else if (entry.flags.type == QPaintBufferCacheEntryV2::PixmapKey)
+                variants[i] = QVariant(pixmaps.value(entry.flags.key));
+            else
+                qWarning() << "operator<<(QDataStream &stream, QPaintBuffer &buffer): unrecognized cache entry type:" << entry.flags.type;
+        }
+    }
+
+    return stream;
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qpaintbuffer_p.h b/src/gui/painting/qpaintbuffer_p.h
new file mode 100644
index 0000000000..6272dd912d
--- /dev/null
+++ b/src/gui/painting/qpaintbuffer_p.h
@@ -0,0 +1,461 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPAINTBUFFER_P_H
+#define QPAINTBUFFER_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <qpaintdevice.h>
+
+#include <private/qpaintengineex_p.h>
+#include <private/qtextengine_p.h>
+#include <QDebug>
+
+QT_BEGIN_NAMESPACE
+
+class QPaintBufferPrivate;
+class QPaintBufferPlayback;
+
+class Q_GUI_EXPORT QPaintBuffer : public QPaintDevice
+{
+    Q_DECLARE_PRIVATE(QPaintBuffer)
+public:
+    QPaintBuffer();
+    QPaintBuffer(const QPaintBuffer &other);
+    ~QPaintBuffer();
+
+    bool isEmpty() const;
+
+    void beginNewFrame();
+    int numFrames() const;
+
+    void draw(QPainter *painter, int frame = 0) const;
+
+    int frameStartIndex(int frame) const;
+    int frameEndIndex(int frame) const;
+    int processCommands(QPainter *painter, int begin, int end) const;
+#ifndef QT_NO_DEBUG_STREAM
+    QString commandDescription(int command) const;
+#endif
+
+    void setBoundingRect(const QRectF &rect);
+    QRectF boundingRect() const;
+
+    virtual QPaintEngine *paintEngine() const;
+    virtual int metric(PaintDeviceMetric m) const;
+    virtual int devType() const;
+
+    QPaintBuffer &operator=(const QPaintBuffer &other);
+
+private:
+    friend class QPainterReplayer;
+    friend class QOpenGLReplayer;
+
+    friend Q_GUI_EXPORT QDataStream &operator<<(QDataStream &stream, const QPaintBuffer &buffer);
+    friend Q_GUI_EXPORT QDataStream &operator>>(QDataStream &stream, QPaintBuffer &buffer);
+
+    QPaintBufferPrivate *d_ptr;
+};
+
+Q_GUI_EXPORT QDataStream &operator<<(QDataStream &stream, const QPaintBuffer &buffer);
+Q_GUI_EXPORT QDataStream &operator>>(QDataStream &stream, QPaintBuffer &buffer);
+
+class QPaintBufferEngine;
+
+class QTextItemIntCopy
+{
+public:
+    QTextItemIntCopy(const QTextItem &item);
+    ~QTextItemIntCopy();
+    QTextItemInt &operator () () {return m_item;}
+private:
+    QTextItemInt m_item;
+    QFont m_font;
+};
+
+struct QPaintBufferCommand
+{
+    uint id : 8;
+    uint size : 24;
+
+    int offset;
+    int offset2;
+    int extra;
+};
+
+QDataStream &operator<<(QDataStream &stream, const QPaintBufferCommand &command);
+QDataStream &operator>>(QDataStream &stream, QPaintBufferCommand &command);
+
+Q_DECLARE_TYPEINFO(QPaintBufferCommand, Q_MOVABLE_TYPE);
+
+class QPaintBufferPrivate
+{
+public:
+    enum Command {
+        Cmd_Save,
+        Cmd_Restore,
+
+        Cmd_SetBrush,
+        Cmd_SetBrushOrigin,
+        Cmd_SetClipEnabled,
+        Cmd_SetCompositionMode,
+        Cmd_SetOpacity,
+        Cmd_SetPen,
+        Cmd_SetRenderHints,
+        Cmd_SetTransform,
+        Cmd_SetBackgroundMode,
+
+        Cmd_ClipPath,
+        Cmd_ClipRect,
+        Cmd_ClipRegion,
+        Cmd_ClipVectorPath,
+
+        Cmd_DrawVectorPath,
+        Cmd_FillVectorPath,
+        Cmd_StrokeVectorPath,
+
+        Cmd_DrawConvexPolygonF,
+        Cmd_DrawConvexPolygonI,
+        Cmd_DrawEllipseF,
+        Cmd_DrawEllipseI,
+        Cmd_DrawLineF,
+        Cmd_DrawLineI,
+        Cmd_DrawPath,
+        Cmd_DrawPointsF,
+        Cmd_DrawPointsI,
+        Cmd_DrawPolygonF,
+        Cmd_DrawPolygonI,
+        Cmd_DrawPolylineF,
+        Cmd_DrawPolylineI,
+        Cmd_DrawRectF,
+        Cmd_DrawRectI,
+
+        Cmd_FillRectBrush,
+        Cmd_FillRectColor,
+
+        Cmd_DrawText,
+        Cmd_DrawTextItem,
+
+        Cmd_DrawImagePos,
+        Cmd_DrawImageRect,
+        Cmd_DrawPixmapPos,
+        Cmd_DrawPixmapRect,
+        Cmd_DrawTiledPixmap,
+
+        Cmd_SystemStateChanged,
+        Cmd_Translate,
+        Cmd_DrawStaticText,
+
+        // new commands must be added above this line
+
+        Cmd_LastCommand
+    };
+
+    QPaintBufferPrivate();
+    ~QPaintBufferPrivate();
+
+    int addData(const int *data, int count) {
+        if (count <= 0)
+            return 0;
+        int pos = ints.size();
+        ints.resize(pos + count);
+        memcpy(ints.data() + pos, data, count * sizeof(int));
+        return pos;
+    }
+
+    int addData(const qreal *data, int count) {
+        if (count <= 0)
+            return 0;
+        int pos = floats.size();
+        floats.resize(pos + count);
+        memcpy(floats.data() + pos, data, count * sizeof(qreal));
+        return pos;
+    }
+
+    int addData(const QVariant &var) {
+        variants << var;
+        return variants.size() - 1;
+    }
+
+    QPaintBufferCommand *addCommand(Command command) {
+        QPaintBufferCommand cmd;
+        cmd.id = command;
+        cmd.size = cmd.offset = cmd.offset2 = cmd.extra = 0;
+        commands << cmd;
+        return &commands.last();
+    }
+
+    QPaintBufferCommand *addCommand(Command command, const QVariant &var) {
+        QPaintBufferCommand cmd;
+        cmd.id = command;
+        cmd.offset = addData(var);
+        cmd.size = cmd.offset2 = cmd.extra = 0;
+        commands << cmd;
+        return &commands.last();
+    }
+
+    QPaintBufferCommand *addCommand(Command command, const QVectorPath &path) {
+        QPaintBufferCommand cmd;
+        cmd.id = command;
+        cmd.offset = addData(path.points(), path.elementCount() * 2);
+        cmd.offset2 = ints.size();
+        ints << path.hints();
+        // The absence of path elements is indicated by setting the highest bit in 'cmd.offset2'.
+        if (path.elements())
+            addData((const int *) path.elements(), path.elementCount());
+        else
+            cmd.offset2 |= 0x80000000;
+        cmd.size = path.elementCount();
+        cmd.extra = 0;
+        commands << cmd;
+        return &commands.last();
+    }
+
+    QPaintBufferCommand *addCommand(Command command , const qreal *pts, int arrayLength, int elementCount) {
+        QPaintBufferCommand cmd;
+        cmd.id = command;
+        cmd.offset = addData(pts, arrayLength);
+        cmd.size = elementCount;
+        cmd.offset2 = cmd.extra = 0;
+        commands << cmd;
+        return &commands.last();
+    }
+
+    QPaintBufferCommand *addCommand(Command command , const int *pts, int arrayLength, int elementCount) {
+        QPaintBufferCommand cmd;
+        cmd.id = command;
+        cmd.offset = addData(pts, arrayLength);
+        cmd.size = elementCount;
+        cmd.offset2 = cmd.extra = 0;
+        commands << cmd;
+        return &commands.last();
+    }
+
+    inline void updateBoundingRect(const QRectF &rect);
+
+    QAtomicInt ref;
+
+    QVector<int> ints;
+    QVector<qreal> floats;
+    QVector<QVariant> variants;
+
+    QVector<QPaintBufferCommand> commands;
+    QList<int> frames;
+
+    QPaintBufferEngine *engine;
+    QRectF boundingRect;
+    qreal penWidthAdjustment;
+    uint calculateBoundingRect : 1;
+
+    void *cache;
+};
+
+
+struct QVectorPathCmd
+{
+    // The absence of path elements is indicated by setting the highest bit in 'cmd.offset2'.
+    QVectorPathCmd(QPaintBufferPrivate *d, const QPaintBufferCommand &cmd)
+        : vectorPath(d->floats.constData() + cmd.offset,
+                     cmd.size,
+                     cmd.offset2 & 0x80000000
+                     ? 0
+                     : (const QPainterPath::ElementType *) (d->ints.constData() + cmd.offset2 + 1),
+                     *(d->ints.constData() + (cmd.offset2 & 0x7fffffff))) {}
+
+    inline const QVectorPath &operator()() const { return vectorPath; }
+
+    QVectorPath vectorPath;
+};
+
+
+class Q_GUI_EXPORT QPainterReplayer
+{
+public:
+    QPainterReplayer() { }
+
+    virtual ~QPainterReplayer() { }
+
+    void setupTransform(QPainter *painter);
+    virtual void process(const QPaintBufferCommand &cmd);
+    void processCommands(const QPaintBuffer &buffer, QPainter *painter, int begin, int end);
+
+protected:
+    QPaintBufferPrivate *d;
+    QTransform m_world_matrix;
+
+    QPainter *painter;
+};
+
+class Q_GUI_EXPORT QPaintEngineExReplayer : public QPainterReplayer
+{
+public:
+    QPaintEngineExReplayer() { }
+
+    virtual void process(const QPaintBufferCommand &cmd);
+};
+
+class QPaintBufferEnginePrivate;
+
+class QPaintBufferEngine : public QPaintEngineEx
+{
+    Q_DECLARE_PRIVATE(QPaintBufferEngine)
+public:
+    QPaintBufferEngine(QPaintBufferPrivate *buffer);
+
+    virtual bool begin(QPaintDevice *device);
+    virtual bool end();
+
+    virtual Type type() const { return QPaintEngine::PaintBuffer; }
+
+    virtual QPainterState *createState(QPainterState *orig) const;
+
+    virtual void draw(const QVectorPath &path);
+    virtual void fill(const QVectorPath &path, const QBrush &brush);
+    virtual void stroke(const QVectorPath &path, const QPen &pen);
+
+    virtual void clip(const QVectorPath &path, Qt::ClipOperation op);
+    virtual void clip(const QRect &rect, Qt::ClipOperation op);
+    virtual void clip(const QRegion &region, Qt::ClipOperation op);
+    virtual void clip(const QPainterPath &path, Qt::ClipOperation op);
+
+    virtual void clipEnabledChanged();
+    virtual void penChanged();
+    virtual void brushChanged();
+    virtual void brushOriginChanged();
+    virtual void opacityChanged();
+    virtual void compositionModeChanged();
+    virtual void renderHintsChanged();
+    virtual void transformChanged();
+    virtual void backgroundModeChanged();
+
+    virtual void fillRect(const QRectF &rect, const QBrush &brush);
+    virtual void fillRect(const QRectF &rect, const QColor &color);
+
+    virtual void drawRects(const QRect *rects, int rectCount);
+    virtual void drawRects(const QRectF *rects, int rectCount);
+
+    virtual void drawLines(const QLine *lines, int lineCount);
+    virtual void drawLines(const QLineF *lines, int lineCount);
+
+    virtual void drawEllipse(const QRectF &r);
+    virtual void drawEllipse(const QRect &r);
+
+    virtual void drawPath(const QPainterPath &path);
+
+    virtual void drawPoints(const QPointF *points, int pointCount);
+    virtual void drawPoints(const QPoint *points, int pointCount);
+
+    virtual void drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode);
+    virtual void drawPolygon(const QPoint *points, int pointCount, PolygonDrawMode mode);
+
+    virtual void drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr);
+    virtual void drawPixmap(const QPointF &pos, const QPixmap &pm);
+
+    virtual void drawImage(const QRectF &r, const QImage &pm, const QRectF &sr,
+                           Qt::ImageConversionFlags flags = Qt::AutoColor);
+    virtual void drawImage(const QPointF &pos, const QImage &image);
+
+    virtual void drawTiledPixmap(const QRectF &r, const QPixmap &pixmap, const QPointF &s);
+
+    virtual void drawTextItem(const QPointF &pos, const QTextItem &ti);
+    virtual void drawStaticTextItem(QStaticTextItem *staticTextItem);
+
+    virtual void setState(QPainterState *s);
+    virtual uint flags() const {return QPaintEngineEx::DoNotEmulate;}
+
+    QPaintBufferPrivate *buffer;
+
+    mutable int m_begin_detected : 1;
+    mutable int m_save_detected : 1;
+    mutable int m_stream_raw_text_items : 1;
+    mutable int m_unused : 29;
+
+    mutable QPainterState *m_created_state;
+};
+
+class Q_GUI_EXPORT QPaintBufferSignalProxy : public QObject
+{
+    Q_OBJECT
+public:
+    QPaintBufferSignalProxy() : QObject() {}
+    void emitAboutToDestroy(const QPaintBufferPrivate *buffer) {
+        emit aboutToDestroy(buffer);
+    }
+    static QPaintBufferSignalProxy *instance();
+Q_SIGNALS:
+    void aboutToDestroy(const QPaintBufferPrivate *buffer);
+};
+
+// One resource per paint buffer and vice versa.
+class Q_GUI_EXPORT QPaintBufferResource : public QObject
+{
+    Q_OBJECT
+public:
+    typedef void (*FreeFunc)(void *);
+
+    QPaintBufferResource(FreeFunc f, QObject *parent = 0);
+    ~QPaintBufferResource();
+    // Set resource 'value' for 'key'.
+    void insert(const QPaintBufferPrivate *key, void *value);
+    // Return resource for 'key'.
+    void *value(const QPaintBufferPrivate *key);
+public slots:
+    // Remove entry 'key' from cache and delete resource.
+    void remove(const QPaintBufferPrivate *key);
+private:
+    typedef QHash<const QPaintBufferPrivate *, void *> Cache;
+    Cache m_cache;
+    FreeFunc free;
+};
+
+QT_END_NAMESPACE
+
+#endif // QPAINTBUFFER_P_H
diff --git a/src/gui/painting/qpaintdevice.cpp b/src/gui/painting/qpaintdevice.cpp
new file mode 100644
index 0000000000..f2ba7f0744
--- /dev/null
+++ b/src/gui/painting/qpaintdevice.cpp
@@ -0,0 +1,75 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qpaintdevice.h"
+
+QT_BEGIN_NAMESPACE
+
+extern void qt_painter_removePaintDevice(QPaintDevice *); //qpainter.cpp
+
+QPaintDevice::QPaintDevice()
+{
+    painters = 0;
+}
+
+QPaintDevice::~QPaintDevice()
+{
+    if (paintingActive())
+        qWarning("QPaintDevice: Cannot destroy paint device that is being "
+                  "painted");
+    qt_painter_removePaintDevice(this);
+}
+
+
+#ifndef Q_WS_QPA
+int QPaintDevice::metric(PaintDeviceMetric) const
+{
+    qWarning("QPaintDevice::metrics: Device has no metric information");
+    return 0;
+}
+#endif
+
+Q_GUI_EXPORT int qt_paint_device_metric(const QPaintDevice *device, QPaintDevice::PaintDeviceMetric metric)
+{
+    return device->metric(metric);
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qpaintdevice.h b/src/gui/painting/qpaintdevice.h
new file mode 100644
index 0000000000..67db3f653f
--- /dev/null
+++ b/src/gui/painting/qpaintdevice.h
@@ -0,0 +1,177 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPAINTDEVICE_H
+#define QPAINTDEVICE_H
+
+#include <QtGui/qwindowdefs.h>
+#include <QtCore/qrect.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+#if defined(Q_WS_QWS)
+class QWSDisplay;
+#endif
+
+class QPaintEngine;
+
+class Q_GUI_EXPORT QPaintDevice                                // device for QPainter
+{
+public:
+    enum PaintDeviceMetric {
+        PdmWidth = 1,
+        PdmHeight,
+        PdmWidthMM,
+        PdmHeightMM,
+        PdmNumColors,
+        PdmDepth,
+        PdmDpiX,
+        PdmDpiY,
+        PdmPhysicalDpiX,
+        PdmPhysicalDpiY
+    };
+
+    virtual ~QPaintDevice();
+
+    virtual int devType() const;
+    bool paintingActive() const;
+    virtual QPaintEngine *paintEngine() const = 0;
+
+#if defined(Q_WS_QWS)
+    static QWSDisplay *qwsDisplay();
+#endif
+
+#ifdef Q_WS_WIN
+    virtual HDC getDC() const;
+    virtual void releaseDC(HDC hdc) const;
+#endif
+
+    int width() const { return metric(PdmWidth); }
+    int height() const { return metric(PdmHeight); }
+    int widthMM() const { return metric(PdmWidthMM); }
+    int heightMM() const { return metric(PdmHeightMM); }
+    int logicalDpiX() const { return metric(PdmDpiX); }
+    int logicalDpiY() const { return metric(PdmDpiY); }
+    int physicalDpiX() const { return metric(PdmPhysicalDpiX); }
+    int physicalDpiY() const { return metric(PdmPhysicalDpiY); }
+#ifdef QT_DEPRECATED
+    QT_DEPRECATED int numColors() const { return metric(PdmNumColors); }
+#endif
+    int colorCount() const { return metric(PdmNumColors); }
+    int depth() const { return metric(PdmDepth); }
+
+protected:
+    QPaintDevice();
+    virtual int metric(PaintDeviceMetric metric) const;
+
+    ushort        painters;                        // refcount
+
+private:
+    Q_DISABLE_COPY(QPaintDevice)
+
+#if defined(Q_WS_X11) && defined(QT3_SUPPORT)
+public:
+    QT3_SUPPORT Display *x11Display() const;
+    QT3_SUPPORT int x11Screen() const;
+    QT3_SUPPORT int x11Depth() const;
+    QT3_SUPPORT int x11Cells() const;
+    QT3_SUPPORT Qt::HANDLE x11Colormap() const;
+    QT3_SUPPORT bool x11DefaultColormap() const;
+    QT3_SUPPORT void *x11Visual() const;
+    QT3_SUPPORT bool x11DefaultVisual() const;
+
+    static QT3_SUPPORT Display *x11AppDisplay();
+    static QT3_SUPPORT int x11AppScreen();
+    static QT3_SUPPORT int x11AppDepth(int screen = -1);
+    static QT3_SUPPORT int x11AppCells(int screen = -1);
+    static QT3_SUPPORT Qt::HANDLE x11AppRootWindow(int screen = -1);
+    static QT3_SUPPORT Qt::HANDLE x11AppColormap(int screen = -1);
+    static QT3_SUPPORT void *x11AppVisual(int screen = -1);
+    static QT3_SUPPORT bool x11AppDefaultColormap(int screen =-1);
+    static QT3_SUPPORT bool x11AppDefaultVisual(int screen =-1);
+    static QT3_SUPPORT int x11AppDpiX(int screen = -1);
+    static QT3_SUPPORT int x11AppDpiY(int screen = -1);
+    static QT3_SUPPORT void x11SetAppDpiX(int, int);
+    static QT3_SUPPORT void x11SetAppDpiY(int, int);
+#endif
+
+    friend class QPainter;
+    friend class QFontEngineMac;
+    friend class QX11PaintEngine;
+    friend Q_GUI_EXPORT int qt_paint_device_metric(const QPaintDevice *device, PaintDeviceMetric metric);
+};
+
+#ifdef QT3_SUPPORT
+QT3_SUPPORT Q_GUI_EXPORT
+void bitBlt(QPaintDevice *dst, int dx, int dy,
+             const QPaintDevice *src, int sx=0, int sy=0, int sw=-1, int sh=-1,
+             bool ignoreMask=false);
+
+QT3_SUPPORT Q_GUI_EXPORT
+void bitBlt(QPaintDevice *dst, int dx, int dy,
+             const QImage *src, int sx=0, int sy=0, int sw=-1, int sh=-1,
+             int conversion_flags=0);
+
+QT3_SUPPORT Q_GUI_EXPORT
+void bitBlt(QPaintDevice *dst, const QPoint &dp,
+            const QPaintDevice *src, const QRect &sr=QRect(0,0,-1,-1),
+            bool ignoreMask=false);
+#endif
+
+/*****************************************************************************
+  Inline functions
+ *****************************************************************************/
+
+inline int QPaintDevice::devType() const
+{ return QInternal::UnknownDevice; }
+
+inline bool QPaintDevice::paintingActive() const
+{ return painters != 0; }
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QPAINTDEVICE_H
diff --git a/src/gui/painting/qpaintdevice.qdoc b/src/gui/painting/qpaintdevice.qdoc
new file mode 100644
index 0000000000..dc5c3583e7
--- /dev/null
+++ b/src/gui/painting/qpaintdevice.qdoc
@@ -0,0 +1,286 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Free Documentation License
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of this
+** file.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \class QPaintDevice
+    \brief The QPaintDevice class is the base class of objects that
+    can be painted.
+
+    \ingroup painting
+
+    A paint device is an abstraction of a two-dimensional space that
+    can be drawn using a QPainter.  Its default coordinate system has
+    its origin located at the top-left position. X increases to the
+    right and Y increases downwards. The unit is one pixel.
+
+    The drawing capabilities of QPaintDevice are currently implemented
+    by the QWidget, QImage, QPixmap, QGLPixelBuffer, QPicture, and
+    QPrinter subclasses.
+
+    To implement support for a new backend, you must derive from
+    QPaintDevice and reimplement the virtual paintEngine() function to
+    tell QPainter which paint engine should be used to draw on this
+    particular device. Note that you also must create a corresponding
+    paint engine to be able to draw on the device, i.e derive from
+    QPaintEngine and reimplement its virtual functions.
+
+    \warning Qt requires that a QApplication object exists before
+    any paint devices can be created. Paint devices access window
+    system resources, and these resources are not initialized before
+    an application object is created.
+
+    The QPaintDevice class provides several functions returning the
+    various device metrics: The depth() function returns its bit depth
+    (number of bit planes). The height() function returns its height
+    in default coordinate system units (e.g. pixels for QPixmap and
+    QWidget) while heightMM() returns the height of the device in
+    millimeters. Similiarily, the width() and widthMM() functions
+    return the width of the device in default coordinate system units
+    and in millimeters, respectively. Alternatively, the protected
+    metric() function can be used to retrieve the metric information
+    by specifying the desired PaintDeviceMetric as argument.
+
+    The logicalDpiX() and logicalDpiY() functions return the
+    horizontal and vertical resolution of the device in dots per
+    inch. The physicalDpiX() and physicalDpiY() functions also return
+    the resolution of the device in dots per inch, but note that if
+    the logical and physical resolution differ, the corresponding
+    QPaintEngine must handle the mapping. Finally, the colorCount()
+    function returns the number of different colors available for the
+    paint device.
+
+    \sa QPaintEngine, QPainter, {Coordinate System}, {Paint System}
+*/
+
+/*!
+    \enum QPaintDevice::PaintDeviceMetric
+
+    Describes the various metrics of a paint device.
+
+    \value PdmWidth The width of the paint device in default
+    coordinate system units (e.g. pixels for QPixmap and QWidget). See
+    also width().
+
+    \value PdmHeight The height of the paint device in default
+    coordinate system units (e.g. pixels for QPixmap and QWidget). See
+    also height().
+
+    \value PdmWidthMM The width of the paint device in millimeters. See
+    also widthMM().
+
+    \value PdmHeightMM  The height of the paint device in millimeters. See
+    also heightMM().
+
+    \value PdmNumColors The number of different colors available for
+    the paint device. See also colorCount().
+
+    \value PdmDepth The bit depth (number of bit planes) of the paint
+    device. See also depth().
+
+    \value PdmDpiX The horizontal resolution of the device in dots per
+    inch. See also logicalDpiX().
+
+    \value PdmDpiY  The vertical resolution of the device in dots per inch. See
+    also logicalDpiY().
+
+    \value PdmPhysicalDpiX The horizontal resolution of the device in
+    dots per inch. See also physicalDpiX().
+
+    \value PdmPhysicalDpiY The vertical resolution of the device in
+    dots per inch. See also physicalDpiY().
+
+    \sa metric()
+*/
+
+/*!
+    \fn QPaintDevice::QPaintDevice()
+
+    Constructs a paint device. This constructor can be invoked only from
+    subclasses of QPaintDevice.
+*/
+
+/*!
+    \fn QPaintDevice::~QPaintDevice()
+
+    Destroys the paint device and frees window system resources.
+*/
+
+/*!
+    \fn int QPaintDevice::devType() const
+
+    \internal
+
+    Returns the device type identifier, which is QInternal::Widget
+    if the device is a QWidget, QInternal::Pixmap if it's a
+    QPixmap, QInternal::Printer if it's a QPrinter,
+    QInternal::Picture if it's a QPicture, or
+    QInternal::UnknownDevice in other cases.
+*/
+
+/*!
+    \fn bool QPaintDevice::paintingActive() const
+
+    Returns true if the device is currently being painted on, i.e. someone has
+    called QPainter::begin() but not yet called QPainter::end() for
+    this device; otherwise returns false.
+
+    \sa QPainter::isActive()
+*/
+
+/*!
+    \fn QPaintEngine *QPaintDevice::paintEngine() const
+
+    Returns a pointer to the paint engine used for drawing on the
+    device.
+*/
+
+/*!
+    \fn int QPaintDevice::metric(PaintDeviceMetric metric) const
+
+    Returns the metric information for  the given paint device \a metric.
+
+    \sa PaintDeviceMetric
+*/
+
+/*!
+    \fn int QPaintDevice::width() const
+
+    Returns the width of the paint device in default coordinate system
+    units (e.g. pixels for QPixmap and QWidget).
+
+    \sa widthMM()
+*/
+
+/*!
+    \fn int QPaintDevice::height() const
+
+    Returns the height of the paint device in default coordinate
+    system units (e.g. pixels for QPixmap and QWidget).
+
+    \sa heightMM()
+*/
+
+/*!
+    \fn int QPaintDevice::widthMM() const
+
+    Returns the width of the paint device in millimeters. Due to platform
+    limitations it may not be possible to use this function to determine
+    the actual physical size of a widget on the screen.
+
+    \sa width()
+*/
+
+/*!
+    \fn int QPaintDevice::heightMM() const
+
+    Returns the height of the paint device in millimeters. Due to platform
+    limitations it may not be possible to use this function to determine
+    the actual physical size of a widget on the screen.
+
+    \sa height()
+*/
+
+/*!
+    \fn int QPaintDevice::numColors() const
+    \deprecated
+
+    Use colorCount() instead.
+
+    Returns the number of different colors available for the paint
+    device. Since this value is an int, it will not be sufficient to
+    represent the number of colors on 32 bit displays, in this case
+    INT_MAX is returned instead.
+ */
+
+/*!
+    \fn int QPaintDevice::colorCount() const
+
+    Returns the number of different colors available for the paint
+    device. Since this value is an int, it will not be sufficient to
+    represent the number of colors on 32 bit displays, in this case
+    INT_MAX is returned instead.
+*/
+
+/*!
+    \fn int QPaintDevice::depth() const
+
+    Returns the bit depth (number of bit planes) of the paint device.
+*/
+
+/*!
+    \fn int QPaintDevice::logicalDpiX() const
+
+    Returns the horizontal resolution of the device in dots per inch,
+    which is used when computing font sizes. For X11, this is usually
+    the same as could be computed from widthMM().
+
+    Note that if the logicalDpiX() doesn't equal the physicalDpiX(),
+    the corresponding QPaintEngine must handle the resolution mapping.
+
+    \sa logicalDpiY(), physicalDpiX()
+*/
+
+/*!
+    \fn int QPaintDevice::logicalDpiY() const
+
+    Returns the vertical resolution of the device in dots per inch,
+    which is used when computing font sizes. For X11, this is usually
+    the same as could be computed from heightMM().
+
+    Note that if the logicalDpiY() doesn't equal the physicalDpiY(),
+    the corresponding QPaintEngine must handle the resolution mapping.
+
+    \sa  logicalDpiX(), physicalDpiY()
+*/
+
+/*!
+    \fn int QPaintDevice::physicalDpiX() const
+
+    Returns the horizontal resolution of the device in dots per inch.
+    For example, when printing, this resolution refers to the physical
+    printer's resolution. The logical DPI on the other hand, refers to
+    the resolution used by the actual paint engine.
+
+    Note that if the physicalDpiX() doesn't equal the logicalDpiX(),
+    the corresponding QPaintEngine must handle the resolution mapping.
+
+    \sa  physicalDpiY(),  logicalDpiX()
+*/
+
+/*!
+    \fn int QPaintDevice::physicalDpiY() const
+
+    Returns the horizontal resolution of the device in dots per inch.
+    For example, when printing, this resolution refers to the physical
+    printer's resolution. The logical DPI on the other hand, refers to
+    the resolution used by the actual paint engine.
+
+    Note that if the physicalDpiY() doesn't equal the logicalDpiY(),
+    the corresponding QPaintEngine must handle the resolution mapping.
+
+    \sa  physicalDpiX(),  logicalDpiY()
+*/
diff --git a/src/gui/painting/qpaintdevice_mac.cpp b/src/gui/painting/qpaintdevice_mac.cpp
new file mode 100644
index 0000000000..245408a0b0
--- /dev/null
+++ b/src/gui/painting/qpaintdevice_mac.cpp
@@ -0,0 +1,152 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qpaintdevice.h"
+#include "qpainter.h"
+#include "qwidget.h"
+#include "qbitmap.h"
+#include "qapplication.h"
+#include "qprinter.h"
+#include <qdebug.h>
+#include <private/qt_mac_p.h>
+#include <private/qprintengine_mac_p.h>
+#include <private/qpixmap_mac_p.h>
+#include <private/qpixmap_raster_p.h>
+
+QT_BEGIN_NAMESPACE
+
+/*****************************************************************************
+  Internal variables and functions
+ *****************************************************************************/
+
+/*! \internal */
+float qt_mac_defaultDpi_x()
+{
+    // Mac OS X currently assumes things to be 72 dpi.
+    // (see http://developer.apple.com/releasenotes/GraphicsImaging/RN-ResolutionIndependentUI/)
+    // This may need to be re-worked as we go further in the resolution-independence stuff.
+    return 72;
+}
+
+/*! \internal */
+float qt_mac_defaultDpi_y()
+{
+    // Mac OS X currently assumes things to be 72 dpi.
+    // (see http://developer.apple.com/releasenotes/GraphicsImaging/RN-ResolutionIndependentUI/)
+    // This may need to be re-worked as we go further in the resolution-independence stuff.
+    return 72;
+}
+
+
+/*! \internal
+
+    Returns the QuickDraw CGrafPtr of the paint device. 0 is returned
+    if it can't be obtained. Do not hold the pointer around for long
+    as it can be relocated.
+
+    \warning This function is only available on Mac OS X.
+*/
+
+Q_GUI_EXPORT GrafPtr qt_mac_qd_context(const QPaintDevice *device)
+{
+    if (device->devType() == QInternal::Pixmap) {
+        return static_cast<GrafPtr>(static_cast<const QPixmap *>(device)->macQDHandle());
+    } else if(device->devType() == QInternal::Widget) {
+        return static_cast<GrafPtr>(static_cast<const QWidget *>(device)->macQDHandle());
+    } else if(device->devType() == QInternal::Printer) {
+        QPaintEngine *engine = static_cast<const QPrinter *>(device)->paintEngine();
+        return static_cast<GrafPtr>(static_cast<const QMacPrintEngine *>(engine)->handle());
+    }
+    return 0;
+}
+
+extern CGColorSpaceRef qt_mac_colorSpaceForDeviceType(const QPaintDevice *pdev);
+
+/*! \internal
+
+    Returns the CoreGraphics CGContextRef of the paint device. 0 is
+    returned if it can't be obtained. It is the caller's responsiblity to
+    CGContextRelease the context when finished using it.
+
+    \warning This function is only available on Mac OS X.
+*/
+
+Q_GUI_EXPORT CGContextRef qt_mac_cg_context(const QPaintDevice *pdev)
+{
+    if (pdev->devType() == QInternal::Pixmap) {
+        const QPixmap *pm = static_cast<const QPixmap*>(pdev);
+        CGColorSpaceRef colorspace = qt_mac_colorSpaceForDeviceType(pdev);
+        uint flags = kCGImageAlphaPremultipliedFirst;
+#ifdef kCGBitmapByteOrder32Host //only needed because CGImage.h added symbols in the minor version
+        flags |= kCGBitmapByteOrder32Host;
+#endif
+        CGContextRef ret = 0;
+
+        // It would make sense to put this into a mac #ifdef'ed
+        // virtual function in the QPixmapData at some point
+        if (pm->data->classId() == QPixmapData::MacClass) {
+            const QMacPixmapData *pmData = static_cast<const QMacPixmapData*>(pm->data.data());
+            ret = CGBitmapContextCreate(pmData->pixels, pmData->w, pmData->h,
+                                                     8, pmData->bytesPerRow, colorspace,
+                                                     flags);
+            if(!ret)
+                qWarning("QPaintDevice: Unable to create context for pixmap (%d/%d/%d)",
+                         pmData->w, pmData->h, (pmData->bytesPerRow * pmData->h));
+        } else if (pm->data->classId() == QPixmapData::RasterClass) {
+            QImage *image = pm->data->buffer();
+            ret = CGBitmapContextCreate(image->bits(), image->width(), image->height(),
+                                        8, image->bytesPerLine(), colorspace, flags);
+        }
+
+        CGContextTranslateCTM(ret, 0, pm->height());
+        CGContextScaleCTM(ret, 1, -1);
+        return ret;
+    } else if (pdev->devType() == QInternal::Widget) {
+        CGContextRef ret = static_cast<CGContextRef>(static_cast<const QWidget *>(pdev)->macCGHandle());
+        CGContextRetain(ret);
+        return ret;
+    } else if (pdev->devType() == QInternal::MacQuartz) {
+        return static_cast<const QMacQuartzPaintDevice *>(pdev)->cgContext();
+    }
+    return 0;
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qpaintdevice_qpa.cpp b/src/gui/painting/qpaintdevice_qpa.cpp
new file mode 100644
index 0000000000..0d1ca92d45
--- /dev/null
+++ b/src/gui/painting/qpaintdevice_qpa.cpp
@@ -0,0 +1,68 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qpaintdevice.h"
+#include "qpainter.h"
+#include "qwidget.h"
+#include "qbitmap.h"
+#include "qapplication.h"
+
+QT_BEGIN_NAMESPACE
+
+extern void qt_painter_removePaintDevice(QPaintDevice *); //qpainter.cpp
+
+int QPaintDevice::metric(PaintDeviceMetric m) const
+{
+    qWarning("QPaintDevice::metrics: Device has no metric information");
+    if (m == PdmDpiX) {
+        return 72;
+    } else if (m == PdmDpiY) {
+        return 72;
+    } else if (m == PdmNumColors) {
+        // FIXME: does this need to be a real value?
+        return 256;
+    } else {
+        qDebug("Unrecognised metric %d!",m);
+        return 0;
+    }
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qpaintdevice_qws.cpp b/src/gui/painting/qpaintdevice_qws.cpp
new file mode 100644
index 0000000000..6f9433ab62
--- /dev/null
+++ b/src/gui/painting/qpaintdevice_qws.cpp
@@ -0,0 +1,56 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qpaintdevice.h"
+#include "qpainter.h"
+#include "qwidget.h"
+#include "qbitmap.h"
+#include "qapplication.h"
+#include "qwsdisplay_qws.h"
+
+QT_BEGIN_NAMESPACE
+
+QWSDisplay *QPaintDevice::qwsDisplay()
+{
+    return qt_fbdpy;
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qpaintdevice_win.cpp b/src/gui/painting/qpaintdevice_win.cpp
new file mode 100644
index 0000000000..3dbe97492a
--- /dev/null
+++ b/src/gui/painting/qpaintdevice_win.cpp
@@ -0,0 +1,62 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qpaintdevice.h"
+#include "qpainter.h"
+#include "qwidget.h"
+#include "qbitmap.h"
+#include "qapplication.h"
+#include <private/qapplication_p.h>
+#include "qt_windows.h"
+#include "qprinter.h"
+
+QT_BEGIN_NAMESPACE
+
+HDC QPaintDevice::getDC() const
+{
+    return 0;
+}
+
+void QPaintDevice::releaseDC(HDC) const
+{
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qpaintdevice_x11.cpp b/src/gui/painting/qpaintdevice_x11.cpp
new file mode 100644
index 0000000000..b6be0761c5
--- /dev/null
+++ b/src/gui/painting/qpaintdevice_x11.cpp
@@ -0,0 +1,198 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qpaintdevice.h"
+#include "qpainter.h"
+#include "qwidget.h"
+#include "qbitmap.h"
+#include "qapplication.h"
+#include <private/qt_x11_p.h>
+#include "qx11info_x11.h"
+
+QT_BEGIN_NAMESPACE
+
+/*! \internal
+
+    Returns the X11 Drawable of the paint device. 0 is returned if it
+    can't be obtained.
+*/
+
+Drawable Q_GUI_EXPORT qt_x11Handle(const QPaintDevice *pd)
+{
+    if (!pd) return 0;
+    if (pd->devType() == QInternal::Widget)
+        return static_cast<const QWidget *>(pd)->handle();
+    else if (pd->devType() == QInternal::Pixmap)
+        return static_cast<const QPixmap *>(pd)->handle();
+    return 0;
+}
+
+/*!
+    \relates QPaintDevice
+
+    Returns the QX11Info structure for the \a pd paint device. 0 is
+    returned if it can't be obtained.
+*/
+const Q_GUI_EXPORT QX11Info *qt_x11Info(const QPaintDevice *pd)
+{
+    if (!pd) return 0;
+    if (pd->devType() == QInternal::Widget)
+        return &static_cast<const QWidget *>(pd)->x11Info();
+    else if (pd->devType() == QInternal::Pixmap)
+        return &static_cast<const QPixmap *>(pd)->x11Info();
+    return 0;
+}
+
+
+
+#ifdef QT3_SUPPORT
+
+Display *QPaintDevice::x11Display() const
+{
+    return X11->display;
+}
+
+int QPaintDevice::x11Screen() const
+{
+    const QX11Info *info = qt_x11Info(this);
+    if (info)
+	return info->screen();
+    return QX11Info::appScreen();
+}
+
+void *QPaintDevice::x11Visual() const
+{
+    const QX11Info *info = qt_x11Info(this);
+    if (info)
+	return info->visual();
+    return QX11Info::appVisual();
+}
+
+int QPaintDevice::x11Depth() const
+{
+    const QX11Info *info = qt_x11Info(this);
+    if (info)
+        return info->depth();
+    return QX11Info::appDepth();
+}
+
+int QPaintDevice::x11Cells() const
+{
+    const QX11Info *info = qt_x11Info(this);
+    if (info)
+	return info->cells();
+    return QX11Info::appCells();
+}
+
+Qt::HANDLE QPaintDevice::x11Colormap() const
+{
+    const QX11Info *info = qt_x11Info(this);
+    if (info)
+	return info->colormap();
+    return QX11Info::appColormap();
+}
+
+bool QPaintDevice::x11DefaultColormap() const
+{
+    const QX11Info *info = qt_x11Info(this);
+    if (info)
+	return info->defaultColormap();
+    return QX11Info::appDefaultColormap();
+}
+
+bool QPaintDevice::x11DefaultVisual() const
+{
+    const QX11Info *info = qt_x11Info(this);
+    if (info)
+	return info->defaultVisual();
+    return QX11Info::appDefaultVisual();
+}
+
+void *QPaintDevice::x11AppVisual(int screen)
+{ return QX11Info::appVisual(screen); }
+
+Qt::HANDLE QPaintDevice::x11AppColormap(int screen)
+{ return QX11Info::appColormap(screen); }
+
+Display *QPaintDevice::x11AppDisplay()
+{ return QX11Info::display(); }
+
+int QPaintDevice::x11AppScreen()
+{ return QX11Info::appScreen(); }
+
+int QPaintDevice::x11AppDepth(int screen)
+{ return QX11Info::appDepth(screen); }
+
+int QPaintDevice::x11AppCells(int screen)
+{ return QX11Info::appCells(screen); }
+
+Qt::HANDLE QPaintDevice::x11AppRootWindow(int screen)
+{ return QX11Info::appRootWindow(screen); }
+
+bool QPaintDevice::x11AppDefaultColormap(int screen)
+{ return QX11Info::appDefaultColormap(screen); }
+
+bool QPaintDevice::x11AppDefaultVisual(int screen)
+{ return QX11Info::appDefaultVisual(screen); }
+
+void QPaintDevice::x11SetAppDpiX(int dpi, int screen)
+{
+    QX11Info::setAppDpiX(dpi, screen);
+}
+
+void QPaintDevice::x11SetAppDpiY(int dpi, int screen)
+{
+    QX11Info::setAppDpiY(dpi, screen);
+}
+
+int QPaintDevice::x11AppDpiX(int screen)
+{
+    return QX11Info::appDpiX(screen);
+}
+
+int QPaintDevice::x11AppDpiY(int screen)
+{
+    return QX11Info::appDpiY(screen);
+}
+#endif
+
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qpaintengine.cpp b/src/gui/painting/qpaintengine.cpp
new file mode 100644
index 0000000000..6eb09e5966
--- /dev/null
+++ b/src/gui/painting/qpaintengine.cpp
@@ -0,0 +1,1030 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include "qpaintengine.h"
+#include "qpaintengine_p.h"
+#include "qpainter_p.h"
+#include "qpolygon.h"
+#include "qbitmap.h"
+#include "qapplication.h"
+#include <qdebug.h>
+#include <qmath.h>
+#include <private/qtextengine_p.h>
+#include <qvarlengtharray.h>
+#include <private/qfontengine_p.h>
+#include <private/qpaintengineex_p.h>
+
+
+QT_BEGIN_NAMESPACE
+
+/*!
+    \class QTextItem
+
+    \brief The QTextItem class provides all the information required to draw
+    text in a custom paint engine.
+
+    When you reimplement your own paint engine, you must reimplement
+    QPaintEngine::drawTextItem(), a function that takes a QTextItem as
+    one of its arguments.
+*/
+
+/*!
+  \enum QTextItem::RenderFlag
+
+  \value  RightToLeft Render the text from right to left.
+  \value  Overline    Paint a line above the text.
+  \value  Underline   Paint a line under the text.
+  \value  StrikeOut   Paint a line through the text.
+  \omitvalue Dummy
+*/
+
+
+/*!
+    \fn qreal QTextItem::descent() const
+
+    Corresponds to the \l{QFontMetrics::descent()}{descent} of the piece of text that is drawn.
+*/
+qreal QTextItem::descent() const
+{
+    const QTextItemInt *ti = static_cast<const QTextItemInt *>(this);
+    return ti->descent.toReal();
+}
+
+/*!
+    \fn qreal QTextItem::ascent() const
+
+    Corresponds to the \l{QFontMetrics::ascent()}{ascent} of the piece of text that is drawn.
+*/
+qreal QTextItem::ascent() const
+{
+    const QTextItemInt *ti = static_cast<const QTextItemInt *>(this);
+    return ti->ascent.toReal();
+}
+
+/*!
+    \fn qreal QTextItem::width() const
+
+    Specifies the total width of the text to be drawn.
+*/
+qreal QTextItem::width() const
+{
+    const QTextItemInt *ti = static_cast<const QTextItemInt *>(this);
+    return ti->width.toReal();
+}
+
+/*!
+    \fn QTextItem::RenderFlags QTextItem::renderFlags() const
+
+    Returns the render flags used.
+*/
+QTextItem::RenderFlags QTextItem::renderFlags() const
+{
+    const QTextItemInt *ti = static_cast<const QTextItemInt *>(this);
+    return ti->flags;
+}
+
+/*!
+    \fn QString QTextItem::text() const
+
+    Returns the text that should be drawn.
+*/
+QString QTextItem::text() const
+{
+    const QTextItemInt *ti = static_cast<const QTextItemInt *>(this);
+    return QString(ti->chars, ti->num_chars);
+}
+
+/*!
+    \fn QFont QTextItem::font() const
+
+    Returns the font that should be used to draw the text.
+*/
+QFont QTextItem::font() const
+{
+    const QTextItemInt *ti = static_cast<const QTextItemInt *>(this);
+    return ti->f ? *ti->f : QApplication::font();
+}
+
+
+/*!
+  \class QPaintEngine
+  \ingroup painting
+
+  \brief The QPaintEngine class provides an abstract definition of how
+  QPainter draws to a given device on a given platform.
+
+  Qt 4.0 provides several premade implementations of QPaintEngine for the
+  different painter backends we support. We provide one paint engine for each
+  window system and painting framework we support. This includes X11 on
+  Unix/Linux and CoreGraphics on Mac OS X. In addition we provide QPaintEngine
+  implementations for OpenGL (accessible through QGLWidget) and PostScript
+  (accessible through QPSPrinter on X11). Additionally there is a raster-based
+  paint engine that is a fallback for when an engine does not support a certain
+  capability.
+
+  If one wants to use QPainter to draw to a different backend,
+  one must subclass QPaintEngine and reimplement all its virtual
+  functions. The QPaintEngine implementation is then made available by
+  subclassing QPaintDevice and reimplementing the virtual function
+  QPaintDevice::paintEngine().
+
+  QPaintEngine is created and owned by the QPaintDevice that created it.
+
+  The big advantage of the QPaintEngine approach opposed to
+  Qt 3's QPainter/QPaintDevice::cmd() approach is that it is now
+  possible to adapt to multiple technologies on each platform and take
+  advantage of each to the fullest.
+
+  \sa QPainter, QPaintDevice::paintEngine(), {Paint System}
+*/
+
+/*!
+  \enum QPaintEngine::PaintEngineFeature
+
+  This enum is used to describe the features or capabilities that the
+  paint engine has. If a feature is not supported by the engine,
+  QPainter will do a best effort to emulate that feature through other
+  means and pass on an alpha blended QImage to the engine with the
+  emulated results. Some features cannot be emulated: AlphaBlend and PorterDuff.
+
+  \value AlphaBlend         The engine can alpha blend primitives.
+  \value Antialiasing       The engine can use antialising to improve the appearance
+                            of rendered primitives.
+  \value BlendModes         The engine supports blending modes.
+  \value BrushStroke        The engine supports drawing strokes that
+                            contain brushes as fills, not just solid
+                            colors (e.g. a dashed gradient line of
+                            width 2).
+  \value ConicalGradientFill The engine supports conical gradient fills.
+  \value ConstantOpacity    The engine supports the feature provided by
+                            QPainter::setOpacity().
+  \value LinearGradientFill The engine supports linear gradient fills.
+  \value MaskedBrush        The engine is capable of rendering brushes that has a
+                            texture with an alpha channel or a mask.
+  \value ObjectBoundingModeGradients The engine has native support for gradients
+                            with coordinate mode QGradient::ObjectBoundingMode.
+                            Otherwise, if QPaintEngine::PatternTransform is
+                            supported, object bounding mode gradients are
+                            converted to gradients with coordinate mode
+                            QGradient::LogicalMode and a brush transform for
+                            the coordinate mapping.
+  \value PainterPaths       The engine has path support.
+  \value PaintOutsidePaintEvent The engine is capable of painting outside of
+                                paint events.
+  \value PatternBrush       The engine is capable of rendering brushes with
+                            the brush patterns specified in Qt::BrushStyle.
+  \value PatternTransform   The engine has support for transforming brush
+                            patterns.
+  \value PerspectiveTransform The engine has support for performing perspective
+                            transformations on primitives.
+  \value PixmapTransform    The engine can transform pixmaps, including
+                            rotation and shearing.
+  \value PorterDuff         The engine supports Porter-Duff operations
+  \value PrimitiveTransform The engine has support for transforming
+                            drawing primitives.
+  \value RadialGradientFill The engine supports radial gradient fills.
+  \value RasterOpModes      The engine supports bitwise raster operations.
+  \value AllFeatures        All of the above features. This enum value is usually
+                            used as a bit mask.
+*/
+
+/*!
+    \enum QPaintEngine::PolygonDrawMode
+
+    \value OddEvenMode The polygon should be drawn using OddEven fill
+    rule.
+
+    \value WindingMode The polygon should be drawn using Winding fill rule.
+
+    \value ConvexMode The polygon is a convex polygon and can be drawn
+    using specialized algorithms where available.
+
+    \value PolylineMode Only the outline of the polygon should be
+    drawn.
+
+*/
+
+/*!
+    \enum QPaintEngine::DirtyFlag
+
+    \value DirtyPen The pen is dirty and needs to be updated.
+
+    \value DirtyBrush The brush is dirty and needs to be updated.
+
+    \value DirtyBrushOrigin The brush origin is dirty and needs to
+    updated.
+
+    \value DirtyFont The font is dirty and needs to be updated.
+
+    \value DirtyBackground The background is dirty and needs to be
+    updated.
+
+    \value DirtyBackgroundMode The background mode is dirty and needs
+    to be updated.
+
+    \value DirtyTransform The transform is dirty and needs to be
+    updated.
+
+    \value DirtyClipRegion The clip region is dirty and needs to be
+    updated.
+
+    \value DirtyClipPath The clip path is dirty and needs to be
+    updated.
+
+    \value DirtyHints The render hints is dirty and needs to be
+    updated.
+
+    \value DirtyCompositionMode The composition mode is dirty and
+    needs to be updated.
+
+    \value DirtyClipEnabled Whether clipping is enabled or not is
+    dirty and needs to be updated.
+
+    \value DirtyOpacity The constant opacity has changed and needs to
+                        be updated as part of the state change in
+                        QPaintEngine::updateState().
+
+    \value AllDirty Convenience enum used internally.
+
+    These types are used by QPainter to trigger lazy updates of the
+    various states in the QPaintEngine using
+    QPaintEngine::updateState().
+
+    A paint engine must update every dirty state.
+*/
+
+/*!
+    \fn void QPaintEngine::syncState()
+
+    \internal
+
+    Updates all dirty states in this engine. This function should ONLY
+    be used when drawing with native handles directly and immediate sync
+    from QPainters state to the native state is required.
+*/
+void QPaintEngine::syncState()
+{
+    Q_ASSERT(state);
+    updateState(*state);
+
+    if (isExtended())
+        static_cast<QPaintEngineEx *>(this)->sync();
+}
+
+static QPaintEngine *qt_polygon_recursion = 0;
+struct QT_Point {
+    int x;
+    int y;
+};
+
+/*!
+    \fn void QPaintEngine::drawPolygon(const QPointF *points, int pointCount,
+    PolygonDrawMode mode)
+
+    Reimplement this virtual function to draw the polygon defined
+    by the \a pointCount first points in \a points, using mode \a
+    mode.
+
+    \note At least one of the drawPolygon() functions must be reimplemented.
+*/
+void QPaintEngine::drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode)
+{
+    Q_ASSERT_X(qt_polygon_recursion != this, "QPaintEngine::drawPolygon",
+               "At least one drawPolygon function must be implemented");
+    qt_polygon_recursion = this;
+    Q_ASSERT(sizeof(QT_Point) == sizeof(QPoint));
+    QVarLengthArray<QT_Point> p(pointCount);
+    for (int i = 0; i < pointCount; ++i) {
+        p[i].x = qRound(points[i].x());
+        p[i].y = qRound(points[i].y());
+    }
+    drawPolygon((QPoint *)p.data(), pointCount, mode);
+    qt_polygon_recursion = 0;
+}
+
+struct QT_PointF {
+    qreal x;
+    qreal y;
+};
+/*!
+    \overload
+
+    Reimplement this virtual function to draw the polygon defined by the
+    \a pointCount first points in \a points, using mode \a mode.
+
+    \note At least one of the drawPolygon() functions must be reimplemented.
+*/
+void QPaintEngine::drawPolygon(const QPoint *points, int pointCount, PolygonDrawMode mode)
+{
+    Q_ASSERT_X(qt_polygon_recursion != this, "QPaintEngine::drawPolygon",
+               "At least one drawPolygon function must be implemented");
+    qt_polygon_recursion = this;
+    Q_ASSERT(sizeof(QT_PointF) == sizeof(QPointF));
+    QVarLengthArray<QT_PointF> p(pointCount);
+    for (int i=0; i<pointCount; ++i) {
+        p[i].x = points[i].x();
+        p[i].y = points[i].y();
+    }
+    drawPolygon((QPointF *)p.data(), pointCount, mode);
+    qt_polygon_recursion = 0;
+}
+
+/*!
+    \enum QPaintEngine::Type
+
+    \value X11
+    \value Windows
+    \value MacPrinter
+    \value CoreGraphics Mac OS X's Quartz2D (CoreGraphics)
+    \value QuickDraw Mac OS X's QuickDraw
+    \value QWindowSystem Qt for Embedded Linux
+    \value PostScript
+    \value OpenGL
+    \value Picture QPicture format
+    \value SVG Scalable Vector Graphics XML format
+    \value Raster
+    \value Direct3D Windows only, Direct3D based engine
+    \value Pdf Portable Document Format
+    \value OpenVG
+    \value User First user type ID
+    \value MaxUser Last user type ID
+    \value OpenGL2
+    \value PaintBuffer
+*/
+
+/*!
+    \fn bool QPaintEngine::isActive() const
+
+    Returns true if the paint engine is actively drawing; otherwise
+    returns false.
+
+    \sa setActive()
+*/
+
+/*!
+    \fn void QPaintEngine::setActive(bool state)
+
+    Sets the active state of the paint engine to \a state.
+
+    \sa isActive()
+*/
+
+/*!
+    \fn bool QPaintEngine::begin(QPaintDevice *pdev)
+
+    Reimplement this function to initialise your paint engine when
+    painting is to start on the paint device \a pdev. Return true if
+    the initialization was successful; otherwise return false.
+
+    \sa end() isActive()
+*/
+
+/*!
+    \fn bool QPaintEngine::end()
+
+    Reimplement this function to finish painting on the current paint
+    device. Return true if painting was finished successfully;
+    otherwise return false.
+
+    \sa begin() isActive()
+*/
+
+
+/*!
+    Draws the first \a pointCount points in the buffer \a points
+*/
+void QPaintEngine::drawPoints(const QPointF *points, int pointCount)
+{
+    QPainter *p = painter();
+    if (!p)
+        return;
+
+    qreal penWidth = p->pen().widthF();
+    if (penWidth == 0)
+        penWidth = 1;
+
+    bool ellipses = p->pen().capStyle() == Qt::RoundCap;
+
+    p->save();
+
+    QTransform transform;
+    if (p->pen().isCosmetic()) {
+        transform = p->transform();
+        p->setTransform(QTransform());
+    }
+
+    p->setBrush(p->pen().brush());
+    p->setPen(Qt::NoPen);
+
+    for (int i=0; i<pointCount; ++i) {
+        QPointF pos = transform.map(points[i]);
+        QRectF rect(pos.x() - penWidth / 2, pos.y() - penWidth / 2, penWidth, penWidth);
+
+        if (ellipses)
+            p->drawEllipse(rect);
+        else
+            p->drawRect(rect);
+    }
+
+    p->restore();
+}
+
+
+/*!
+    Draws the first \a pointCount points in the buffer \a points
+
+    The default implementation converts the first \a pointCount QPoints in \a points
+    to QPointFs and calls the floating point version of drawPoints.
+
+*/
+void QPaintEngine::drawPoints(const QPoint *points, int pointCount)
+{
+    Q_ASSERT(sizeof(QT_PointF) == sizeof(QPointF));
+    QT_PointF fp[256];
+    while (pointCount) {
+        int i = 0;
+        while (i < pointCount && i < 256) {
+            fp[i].x = points[i].x();
+            fp[i].y = points[i].y();
+            ++i;
+        }
+        drawPoints((QPointF *)(void *)fp, i);
+        points += i;
+        pointCount -= i;
+    }
+}
+
+/*!
+    \fn void QPaintEngine::drawEllipse(const QRectF &rect)
+
+    Reimplement this function to draw the largest ellipse that can be
+    contained within rectangle \a rect.
+
+    The default implementation calls drawPolygon().
+*/
+void QPaintEngine::drawEllipse(const QRectF &rect)
+{
+    QPainterPath path;
+    path.addEllipse(rect);
+    if (hasFeature(PainterPaths)) {
+        drawPath(path);
+    } else {
+        QPolygonF polygon = path.toFillPolygon();
+        drawPolygon(polygon.data(), polygon.size(), ConvexMode);
+    }
+}
+
+/*!
+    The default implementation of this function calls the floating
+    point version of this function
+*/
+void QPaintEngine::drawEllipse(const QRect &rect)
+{
+    drawEllipse(QRectF(rect));
+}
+
+/*!
+    \fn void QPaintEngine::drawPixmap(const QRectF &r, const QPixmap
+    &pm, const QRectF &sr)
+
+    Reimplement this function to draw the part of the \a pm
+    specified by the \a sr rectangle in the given \a r.
+*/
+
+
+void qt_fill_tile(QPixmap *tile, const QPixmap &pixmap)
+{
+    QPainter p(tile);
+    p.drawPixmap(0, 0, pixmap);
+    int x = pixmap.width();
+    while (x < tile->width()) {
+        p.drawPixmap(x, 0, *tile, 0, 0, x, pixmap.height());
+        x *= 2;
+    }
+    int y = pixmap.height();
+    while (y < tile->height()) {
+        p.drawPixmap(0, y, *tile, 0, 0, tile->width(), y);
+        y *= 2;
+    }
+}
+
+void qt_draw_tile(QPaintEngine *gc, qreal x, qreal y, qreal w, qreal h,
+                  const QPixmap &pixmap, qreal xOffset, qreal yOffset)
+{
+    qreal yPos, xPos, drawH, drawW, yOff, xOff;
+    yPos = y;
+    yOff = yOffset;
+    while(yPos < y + h) {
+        drawH = pixmap.height() - yOff;    // Cropping first row
+        if (yPos + drawH > y + h)           // Cropping last row
+            drawH = y + h - yPos;
+        xPos = x;
+        xOff = xOffset;
+        while(xPos < x + w) {
+            drawW = pixmap.width() - xOff; // Cropping first column
+            if (xPos + drawW > x + w)           // Cropping last column
+                drawW = x + w - xPos;
+            if (drawW > 0 && drawH > 0)
+                gc->drawPixmap(QRectF(xPos, yPos, drawW, drawH), pixmap, QRectF(xOff, yOff, drawW, drawH));
+            xPos += drawW;
+            xOff = 0;
+        }
+        yPos += drawH;
+        yOff = 0;
+    }
+}
+
+
+/*!
+    Reimplement this function to draw the \a pixmap in the given \a
+    rect, starting at the given \a p. The pixmap will be
+    drawn repeatedly until the \a rect is filled.
+*/
+void QPaintEngine::drawTiledPixmap(const QRectF &rect, const QPixmap &pixmap, const QPointF &p)
+{
+    int sw = pixmap.width();
+    int sh = pixmap.height();
+
+    if (sw*sh < 8192 && sw*sh < 16*rect.width()*rect.height()) {
+        int tw = sw, th = sh;
+        while (tw*th < 32678 && tw < rect.width()/2)
+            tw *= 2;
+        while (tw*th < 32678 && th < rect.height()/2)
+            th *= 2;
+        QPixmap tile;
+        if (pixmap.depth() == 1) {
+            tile = QBitmap(tw, th);
+        } else {
+            tile = QPixmap(tw, th);
+            if (pixmap.hasAlphaChannel())
+                tile.fill(Qt::transparent);
+        }
+        qt_fill_tile(&tile, pixmap);
+        qt_draw_tile(this, rect.x(), rect.y(), rect.width(), rect.height(), tile, p.x(), p.y());
+    } else {
+        qt_draw_tile(this, rect.x(), rect.y(), rect.width(), rect.height(), pixmap, p.x(), p.y());
+    }
+}
+
+/*!
+    \fn void QPaintEngine::drawImage(const QRectF &rectangle, const QImage
+    &image, const QRectF &sr, Qt::ImageConversionFlags flags)
+
+    Reimplement this function to draw the part of the \a image
+    specified by the \a sr rectangle in the given \a rectangle using
+    the given conversion flags \a flags, to convert it to a pixmap.
+*/
+
+void QPaintEngine::drawImage(const QRectF &r, const QImage &image, const QRectF &sr,
+                             Qt::ImageConversionFlags flags)
+{
+    QRectF baseSize(0, 0, image.width(), image.height());
+    QImage im = image;
+    if (baseSize != sr)
+        im = im.copy(qFloor(sr.x()), qFloor(sr.y()),
+                     qCeil(sr.width()), qCeil(sr.height()));
+    QPixmap pm = QPixmap::fromImage(im, flags);
+    drawPixmap(r, pm, QRectF(QPointF(0, 0), pm.size()));
+}
+
+/*!
+    \fn Type QPaintEngine::type() const
+
+    Reimplement this function to return the paint engine \l{Type}.
+*/
+
+/*!
+    \fn void QPaintEngine::fix_neg_rect(int *x, int *y, int *w, int *h);
+
+    \internal
+*/
+
+/*!
+    \fn bool QPaintEngine::testDirty(DirtyFlags df)
+
+    \internal
+*/
+
+/*!
+    \fn void QPaintEngine::clearDirty(DirtyFlags df)
+
+    \internal
+*/
+
+/*!
+    \fn void QPaintEngine::setDirty(DirtyFlags df)
+
+    \internal
+*/
+
+/*!
+    \fn bool QPaintEngine::hasFeature(PaintEngineFeatures feature) const
+
+    Returns true if the paint engine supports the specified \a
+    feature; otherwise returns false.
+*/
+
+/*!
+    \fn bool QPaintEngine::isExtended() const
+
+    \internal
+
+    Returns true if the paint engine is a QPaintEngineEx derivative.
+*/
+
+/*!
+    \fn void QPaintEngine::updateState(const QPaintEngineState &state)
+
+    Reimplement this function to update the state of a paint engine.
+
+    When implemented, this function is responsible for checking the
+    paint engine's current \a state and update the properties that are
+    changed. Use the QPaintEngineState::state() function to find out
+    which properties that must be updated, then use the corresponding
+    \l {GetFunction}{get function} to retrieve the current values for
+    the given properties.
+
+    \sa QPaintEngineState
+*/
+
+/*!
+    Creates a paint engine with the featureset specified by \a caps.
+*/
+
+QPaintEngine::QPaintEngine(PaintEngineFeatures caps)
+    : state(0),
+      gccaps(caps),
+      active(0),
+      selfDestruct(false),
+      extended(false),
+      d_ptr(new QPaintEnginePrivate)
+{
+    d_ptr->q_ptr = this;
+}
+
+/*!
+  \internal
+*/
+
+QPaintEngine::QPaintEngine(QPaintEnginePrivate &dptr, PaintEngineFeatures caps)
+    : state(0),
+      gccaps(caps),
+      active(0),
+      selfDestruct(false),
+      extended(false),
+      d_ptr(&dptr)
+{
+    d_ptr->q_ptr = this;
+}
+
+/*!
+    Destroys the paint engine.
+*/
+QPaintEngine::~QPaintEngine()
+{
+}
+
+/*!
+    Returns the paint engine's painter.
+*/
+QPainter *QPaintEngine::painter() const
+{
+    return state ? state->painter() : 0;
+}
+
+/*!
+    The default implementation ignores the \a path and does nothing.
+*/
+
+void QPaintEngine::drawPath(const QPainterPath &)
+{
+    if (hasFeature(PainterPaths)) {
+        qWarning("QPaintEngine::drawPath: Must be implemented when feature PainterPaths is set");
+    }
+}
+
+/*!
+    This function draws the text item \a textItem at position \a p. The
+    default implementation of this function converts the text to a
+    QPainterPath and paints the resulting path.
+*/
+
+void QPaintEngine::drawTextItem(const QPointF &p, const QTextItem &textItem)
+{
+    const QTextItemInt &ti = static_cast<const QTextItemInt &>(textItem);
+
+    QPainterPath path;
+#ifndef Q_WS_MAC
+    path.setFillRule(Qt::WindingFill);
+#endif
+    if (ti.glyphs.numGlyphs)
+        ti.fontEngine->addOutlineToPath(p.x(), p.y(), ti.glyphs, &path, ti.flags);
+    if (!path.isEmpty()) {
+        bool oldAA = painter()->renderHints() & QPainter::Antialiasing;
+        painter()->setRenderHint(QPainter::Antialiasing,
+                                 bool((painter()->renderHints() & QPainter::TextAntialiasing)
+                                      && !(painter()->font().styleStrategy() & QFont::NoAntialias)));
+        painter()->fillPath(path, state->pen().brush());
+        painter()->setRenderHint(QPainter::Antialiasing, oldAA);
+    }
+}
+
+/*!
+    The default implementation splits the list of lines in \a lines
+    into \a lineCount separate calls to drawPath() or drawPolygon()
+    depending on the feature set of the paint engine.
+*/
+void QPaintEngine::drawLines(const QLineF *lines, int lineCount)
+{
+    for (int i=0; i<lineCount; ++i) {
+        QPointF pts[2] = { lines[i].p1(), lines[i].p2() };
+
+        if (pts[0] == pts[1]) {
+            if (state->pen().capStyle() != Qt::FlatCap)
+                drawPoints(pts, 1);
+            continue;
+        }
+
+        drawPolygon(pts, 2, PolylineMode);
+    }
+}
+
+/*!
+    \overload
+
+    The default implementation converts the first \a lineCount lines
+    in \a lines to a QLineF and calls the floating point version of
+    this function.
+*/
+void QPaintEngine::drawLines(const QLine *lines, int lineCount)
+{
+    struct PointF {
+        qreal x;
+        qreal y;
+    };
+    struct LineF {
+        PointF p1;
+        PointF p2;
+    };
+    Q_ASSERT(sizeof(PointF) == sizeof(QPointF));
+    Q_ASSERT(sizeof(LineF) == sizeof(QLineF));
+    LineF fl[256];
+    while (lineCount) {
+        int i = 0;
+        while (i < lineCount && i < 256) {
+            fl[i].p1.x = lines[i].x1();
+            fl[i].p1.y = lines[i].y1();
+            fl[i].p2.x = lines[i].x2();
+            fl[i].p2.y = lines[i].y2();
+            ++i;
+        }
+        drawLines((QLineF *)(void *)fl, i);
+        lines += i;
+        lineCount -= i;
+    }
+}
+
+
+/*!
+    \overload
+
+    The default implementation converts the first \a rectCount
+    rectangles in the buffer \a rects to a QRectF and calls the
+    floating point version of this function.
+*/
+void QPaintEngine::drawRects(const QRect *rects, int rectCount)
+{
+    struct RectF {
+        qreal x;
+        qreal y;
+        qreal w;
+        qreal h;
+    };
+    Q_ASSERT(sizeof(RectF) == sizeof(QRectF));
+    RectF fr[256];
+    while (rectCount) {
+        int i = 0;
+        while (i < rectCount && i < 256) {
+            fr[i].x = rects[i].x();
+            fr[i].y = rects[i].y();
+            fr[i].w = rects[i].width();
+            fr[i].h = rects[i].height();
+            ++i;
+        }
+        drawRects((QRectF *)(void *)fr, i);
+        rects += i;
+        rectCount -= i;
+    }
+}
+
+/*!
+    Draws the first \a rectCount rectangles in the buffer \a
+    rects. The default implementation of this function calls drawPath()
+    or drawPolygon() depending on the feature set of the paint engine.
+*/
+void QPaintEngine::drawRects(const QRectF *rects, int rectCount)
+{
+    if (hasFeature(PainterPaths) &&
+        !state->penNeedsResolving() &&
+        !state->brushNeedsResolving()) {
+        for (int i=0; i<rectCount; ++i) {
+            QPainterPath path;
+            path.addRect(rects[i]);
+            if (path.isEmpty())
+                continue;
+            drawPath(path);
+        }
+    } else {
+        for (int i=0; i<rectCount; ++i) {
+            QRectF rf = rects[i];
+            QPointF pts[4] = { QPointF(rf.x(), rf.y()),
+                               QPointF(rf.x() + rf.width(), rf.y()),
+                               QPointF(rf.x() + rf.width(), rf.y() + rf.height()),
+                               QPointF(rf.x(), rf.y() + rf.height()) };
+            drawPolygon(pts, 4, ConvexMode);
+        }
+    }
+}
+
+/*!
+    \internal
+    Sets the paintdevice that this engine operates on to \a device
+*/
+void QPaintEngine::setPaintDevice(QPaintDevice *device)
+{
+    d_func()->pdev = device;
+}
+
+/*!
+    Returns the device that this engine is painting on, if painting is
+    active; otherwise returns 0.
+*/
+QPaintDevice *QPaintEngine::paintDevice() const
+{
+    return d_func()->pdev;
+}
+
+#ifdef Q_WS_WIN
+/*!
+    \internal
+
+    Empty default implementation.
+*/
+
+HDC QPaintEngine::getDC() const
+{
+    return 0;
+}
+
+
+/*!
+    \internal
+
+    Empty default implementation.
+*/
+
+void QPaintEngine::releaseDC(HDC) const
+{
+}
+
+#endif
+
+/*!
+    \internal
+
+    Returns the offset from the painters origo to the engines
+    origo. This value is used by QPainter for engines who have
+    internal double buffering.
+
+    This function only makes sense when the engine is active.
+*/
+QPoint QPaintEngine::coordinateOffset() const
+{
+    return QPoint();
+}
+
+/*!
+    \internal
+
+    Sets the system clip for this engine. The system clip defines the
+    basis area that the engine has to draw in. All clips that are
+    set will be be an intersection with the system clip.
+
+    Reset the systemclip to no clip by setting an empty region.
+*/
+void QPaintEngine::setSystemClip(const QRegion &region)
+{
+    Q_D(QPaintEngine);
+    d->systemClip = region;
+    // Be backward compatible and only call d->systemStateChanged()
+    // if we currently have a system transform/viewport set.
+    if (d->hasSystemTransform || d->hasSystemViewport) {
+        d->transformSystemClip();
+        d->systemStateChanged();
+    }
+}
+
+/*!
+    \internal
+
+    Returns the system clip. The system clip is read only while the
+    painter is active. An empty region indicates that system clip
+    is not in use.
+*/
+
+QRegion QPaintEngine::systemClip() const
+{
+    return d_func()->systemClip;
+}
+
+/*!
+    \internal
+
+    Sets the target rect for drawing within the backing store. This
+    function should ONLY be used by the backing store.
+*/
+void QPaintEngine::setSystemRect(const QRect &rect)
+{
+    if (isActive()) {
+        qWarning("QPaintEngine::setSystemRect: Should not be changed while engine is active");
+        return;
+    }
+    d_func()->systemRect = rect;
+}
+
+/*!
+    \internal
+
+    Retrieves the rect for drawing within the backing store. This
+    function should ONLY be used by the backing store.
+ */
+QRect QPaintEngine::systemRect() const
+{
+    return d_func()->systemRect;
+}
+
+void QPaintEnginePrivate::drawBoxTextItem(const QPointF &p, const QTextItemInt &ti)
+{
+    if (!ti.glyphs.numGlyphs)
+        return;
+
+    // any fixes here should probably also be done in QFontEngineBox::draw
+    const int size = qRound(ti.fontEngine->ascent());
+    QVarLengthArray<QFixedPoint> positions;
+    QVarLengthArray<glyph_t> glyphs;
+    QTransform matrix = QTransform::fromTranslate(p.x(), p.y() - size);
+    ti.fontEngine->getGlyphPositions(ti.glyphs, matrix, ti.flags, glyphs, positions);
+    if (glyphs.size() == 0)
+        return;
+
+    QSize s(size - 3, size - 3);
+
+    QPainter *painter = q_func()->state->painter();
+    painter->save();
+    painter->setBrush(Qt::NoBrush);
+    QPen pen = painter->pen();
+    pen.setWidthF(ti.fontEngine->lineThickness().toReal());
+    painter->setPen(pen);
+    for (int k = 0; k < positions.size(); k++)
+        painter->drawRect(QRectF(positions[k].toPointF(), s));
+    painter->restore();
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qpaintengine.h b/src/gui/painting/qpaintengine.h
new file mode 100644
index 0000000000..93aa63bea9
--- /dev/null
+++ b/src/gui/painting/qpaintengine.h
@@ -0,0 +1,368 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPAINTENGINE_H
+#define QPAINTENGINE_H
+
+#include <QtCore/qnamespace.h>
+#include <QtCore/qobjectdefs.h>
+#include <QtCore/qscopedpointer.h>
+#include <QtGui/qpainter.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+class QFontEngine;
+class QLineF;
+class QPaintDevice;
+class QPaintEnginePrivate;
+class QPainterPath;
+class QPointF;
+class QPolygonF;
+class QRectF;
+struct QGlyphLayout;
+class QTextItemInt;
+class QPaintEngineState;
+
+class Q_GUI_EXPORT QTextItem {
+public:
+    enum RenderFlag {
+        RightToLeft = 0x1,
+        Overline = 0x10,
+        Underline = 0x20,
+        StrikeOut = 0x40,
+
+        Dummy = 0xffffffff
+    };
+    Q_DECLARE_FLAGS(RenderFlags, RenderFlag)
+    qreal descent() const;
+    qreal ascent() const;
+    qreal width() const;
+
+    RenderFlags renderFlags() const;
+    QString text() const;
+    QFont font() const;
+};
+Q_DECLARE_TYPEINFO(QTextItem, Q_PRIMITIVE_TYPE);
+
+
+class Q_GUI_EXPORT QPaintEngine
+{
+    Q_DECLARE_PRIVATE(QPaintEngine)
+public:
+    enum PaintEngineFeature {
+        PrimitiveTransform          = 0x00000001, // Can transform primitives brushes
+        PatternTransform            = 0x00000002, // Can transform pattern brushes
+        PixmapTransform             = 0x00000004, // Can transform pixmaps
+        PatternBrush                = 0x00000008, // Can fill with pixmaps and standard patterns
+        LinearGradientFill          = 0x00000010, // Can fill gradient areas
+        RadialGradientFill          = 0x00000020, // Can render radial gradients
+        ConicalGradientFill         = 0x00000040, // Can render conical gradients
+        AlphaBlend                  = 0x00000080, // Can do source over alpha blend
+        PorterDuff                  = 0x00000100, // Can do general porter duff compositions
+        PainterPaths                = 0x00000200, // Can fill, outline and clip paths
+        Antialiasing                = 0x00000400, // Can antialias lines
+        BrushStroke                 = 0x00000800, // Can render brush based pens
+        ConstantOpacity             = 0x00001000, // Can render at constant opacity
+        MaskedBrush                 = 0x00002000, // Can fill with textures that has an alpha channel or mask
+        PerspectiveTransform        = 0x00004000, // Can do perspective transformations
+        BlendModes                  = 0x00008000, // Can do extended Porter&Duff composition
+        ObjectBoundingModeGradients = 0x00010000, // Can do object bounding mode gradients
+        RasterOpModes               = 0x00020000, // Can do logical raster operations
+        PaintOutsidePaintEvent      = 0x20000000, // Engine is capable of painting outside paint events
+        /*                          0x10000000, // Used for emulating
+                                    QGradient::StretchToDevice,
+                                    defined in qpainter.cpp
+
+                                    0x40000000, // Used internally for emulating opaque backgrounds
+        */
+
+        AllFeatures               = 0xffffffff  // For convenience
+    };
+    Q_DECLARE_FLAGS(PaintEngineFeatures, PaintEngineFeature)
+
+    enum DirtyFlag {
+        DirtyPen                = 0x0001,
+        DirtyBrush              = 0x0002,
+        DirtyBrushOrigin        = 0x0004,
+        DirtyFont               = 0x0008,
+        DirtyBackground         = 0x0010,
+        DirtyBackgroundMode     = 0x0020,
+        DirtyTransform          = 0x0040,
+        DirtyClipRegion         = 0x0080,
+        DirtyClipPath           = 0x0100,
+        DirtyHints              = 0x0200,
+        DirtyCompositionMode    = 0x0400,
+        DirtyClipEnabled        = 0x0800,
+        DirtyOpacity            = 0x1000,
+
+        AllDirty                = 0xffff
+    };
+    Q_DECLARE_FLAGS(DirtyFlags, DirtyFlag)
+
+    enum PolygonDrawMode {
+        OddEvenMode,
+        WindingMode,
+        ConvexMode,
+        PolylineMode
+    };
+
+    explicit QPaintEngine(PaintEngineFeatures features=0);
+    virtual ~QPaintEngine();
+
+    bool isActive() const { return active; }
+    void setActive(bool newState) { active = newState; }
+
+    virtual bool begin(QPaintDevice *pdev) = 0;
+    virtual bool end() = 0;
+
+    virtual void updateState(const QPaintEngineState &state) = 0;
+
+    virtual void drawRects(const QRect *rects, int rectCount);
+    virtual void drawRects(const QRectF *rects, int rectCount);
+
+    virtual void drawLines(const QLine *lines, int lineCount);
+    virtual void drawLines(const QLineF *lines, int lineCount);
+
+    virtual void drawEllipse(const QRectF &r);
+    virtual void drawEllipse(const QRect &r);
+
+    virtual void drawPath(const QPainterPath &path);
+
+    virtual void drawPoints(const QPointF *points, int pointCount);
+    virtual void drawPoints(const QPoint *points, int pointCount);
+
+    virtual void drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode);
+    virtual void drawPolygon(const QPoint *points, int pointCount, PolygonDrawMode mode);
+
+    virtual void drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr) = 0;
+    virtual void drawTextItem(const QPointF &p, const QTextItem &textItem);
+    virtual void drawTiledPixmap(const QRectF &r, const QPixmap &pixmap, const QPointF &s);
+    virtual void drawImage(const QRectF &r, const QImage &pm, const QRectF &sr,
+                           Qt::ImageConversionFlags flags = Qt::AutoColor);
+
+    void setPaintDevice(QPaintDevice *device);
+    QPaintDevice *paintDevice() const;
+
+    void setSystemClip(const QRegion &baseClip);
+    QRegion systemClip() const;
+
+    void setSystemRect(const QRect &rect);
+    QRect systemRect() const;
+
+#ifdef Q_WS_WIN
+    virtual HDC getDC() const;
+    virtual void releaseDC(HDC hdc) const;
+#endif
+
+    virtual QPoint coordinateOffset() const;
+
+    enum Type {
+        X11,
+        Windows,
+        QuickDraw, CoreGraphics, MacPrinter,
+        QWindowSystem,
+        PostScript,
+        OpenGL,
+        Picture,
+        SVG,
+        Raster,
+        Direct3D,
+        Pdf,
+        OpenVG,
+        OpenGL2,
+        PaintBuffer,
+        Blitter,
+
+        User = 50,    // first user type id
+        MaxUser = 100 // last user type id
+    };
+    virtual Type type() const = 0;
+
+    inline void fix_neg_rect(int *x, int *y, int *w, int *h);
+
+    inline bool testDirty(DirtyFlags df);
+    inline void setDirty(DirtyFlags df);
+    inline void clearDirty(DirtyFlags df);
+
+    bool hasFeature(PaintEngineFeatures feature) const { return (gccaps & feature) != 0; }
+
+    QPainter *painter() const;
+
+    void syncState();
+    inline bool isExtended() const { return extended; }
+
+protected:
+    QPaintEngine(QPaintEnginePrivate &data, PaintEngineFeatures devcaps=0);
+
+    QPaintEngineState *state;
+    PaintEngineFeatures gccaps;
+
+    uint active : 1;
+    uint selfDestruct : 1;
+    uint extended : 1;
+
+    QScopedPointer<QPaintEnginePrivate> d_ptr;
+
+private:
+    void setAutoDestruct(bool autoDestr) { selfDestruct = autoDestr; }
+    bool autoDestruct() const { return selfDestruct; }
+    Q_DISABLE_COPY(QPaintEngine)
+
+    friend class QPainterReplayer;
+    friend class QFontEngineBox;
+    friend class QFontEngineMac;
+    friend class QFontEngineWin;
+#ifndef QT_NO_FREETYPE
+    friend class QFontEngineFT;
+#endif
+#ifndef QT_NO_QWS_QPF
+    friend class QFontEngineQPF1;
+#endif
+#ifndef QT_NO_QWS_QPF2
+    friend class QFontEngineQPF;
+#endif
+    friend class QPSPrintEngine;
+    friend class QMacPrintEngine;
+    friend class QMacPrintEnginePrivate;
+#ifdef Q_WS_QWS
+    friend class QtopiaPrintEngine;
+    friend class QtopiaPrintEnginePrivate;
+    friend class QProxyFontEngine;
+#endif
+#ifdef Q_WS_QPA
+    friend class QFontEngineQPA;
+#endif
+    friend class QPainter;
+    friend class QPainterPrivate;
+    friend class QWidget;
+    friend class QWidgetPrivate;
+    friend class QWin32PaintEngine;
+    friend class QWin32PaintEnginePrivate;
+    friend class QMacCGContext;
+    friend class QPreviewPaintEngine;
+    friend class QX11GLPixmapData;
+};
+
+
+class Q_GUI_EXPORT QPaintEngineState
+{
+public:
+    QPaintEngine::DirtyFlags state() const { return dirtyFlags; }
+
+    QPen pen() const;
+    QBrush brush() const;
+    QPointF brushOrigin() const;
+    QBrush backgroundBrush() const;
+    Qt::BGMode backgroundMode() const;
+    QFont font() const;
+    QMatrix matrix() const;
+    QTransform transform() const;
+
+    Qt::ClipOperation clipOperation() const;
+    QRegion clipRegion() const;
+    QPainterPath clipPath() const;
+    bool isClipEnabled() const;
+
+    QPainter::RenderHints renderHints() const;
+    QPainter::CompositionMode compositionMode() const;
+    qreal opacity() const;
+
+    QPainter *painter() const;
+
+    bool brushNeedsResolving() const;
+    bool penNeedsResolving() const;
+
+protected:
+    friend class QPaintEngine;
+    friend class QRasterPaintEngine;
+    friend class QWidget;
+    friend class QPainter;
+    friend class QPainterPrivate;
+    friend class QMacPrintEnginePrivate;
+
+    QPaintEngine::DirtyFlags dirtyFlags;
+};
+
+//
+// inline functions
+//
+
+inline void QPaintEngine::fix_neg_rect(int *x, int *y, int *w, int *h)
+{
+    if (*w < 0) {
+        *w = -*w;
+        *x -= *w - 1;
+    }
+    if (*h < 0) {
+        *h = -*h;
+        *y -= *h - 1;
+    }
+}
+
+inline bool QPaintEngine::testDirty(DirtyFlags df) {
+    Q_ASSERT(state);
+    return ((state->dirtyFlags & df) != 0);
+}
+
+inline void QPaintEngine::setDirty(DirtyFlags df) {
+    Q_ASSERT(state);
+    state->dirtyFlags |= df;
+}
+
+inline void QPaintEngine::clearDirty(DirtyFlags df)
+{
+    Q_ASSERT(state);
+    state->dirtyFlags &= ~static_cast<uint>(df);
+}
+
+Q_DECLARE_OPERATORS_FOR_FLAGS(QTextItem::RenderFlags)
+Q_DECLARE_OPERATORS_FOR_FLAGS(QPaintEngine::PaintEngineFeatures)
+Q_DECLARE_OPERATORS_FOR_FLAGS(QPaintEngine::DirtyFlags)
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QPAINTENGINE_H
diff --git a/src/gui/painting/qpaintengine_alpha.cpp b/src/gui/painting/qpaintengine_alpha.cpp
new file mode 100644
index 0000000000..171850ded6
--- /dev/null
+++ b/src/gui/painting/qpaintengine_alpha.cpp
@@ -0,0 +1,516 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <qglobal.h>
+
+#ifndef QT_NO_PRINTER
+#include <qdebug.h>
+#include "private/qpaintengine_alpha_p.h"
+
+#include "private/qpicture_p.h"
+#include "private/qfont_p.h"
+#include "QtGui/qpicture.h"
+
+QT_BEGIN_NAMESPACE
+
+QAlphaPaintEngine::QAlphaPaintEngine(QAlphaPaintEnginePrivate &data, PaintEngineFeatures devcaps)
+    : QPaintEngine(data, devcaps)
+{
+
+}
+
+QAlphaPaintEngine::~QAlphaPaintEngine()
+{
+
+}
+
+bool QAlphaPaintEngine::begin(QPaintDevice *pdev)
+{
+    Q_D(QAlphaPaintEngine);
+
+    d->m_continueCall = true;
+    if (d->m_pass != 0) {
+        return true;
+    }
+
+    d->m_savedcaps = gccaps;
+    d->m_pdev = pdev;
+
+    d->m_alphaPen = false;
+    d->m_alphaBrush = false;
+    d->m_alphaOpacity = false;
+    d->m_hasalpha = false;
+    d->m_advancedPen = false;
+    d->m_advancedBrush = false;
+    d->m_complexTransform = false;
+    d->m_emulateProjectiveTransforms = false;
+
+    // clear alpha region
+    d->m_alphargn = QRegion();
+    d->m_cliprgn = QRegion();
+    d->m_pen = QPen();
+    d->m_transform = QTransform();
+
+    flushAndInit();
+
+    return true;
+}
+
+bool QAlphaPaintEngine::end()
+{
+    Q_D(QAlphaPaintEngine);
+
+    d->m_continueCall = true;
+    if (d->m_pass != 0) {
+        return true;
+    }
+
+    flushAndInit(false);
+    return true;
+}
+
+void QAlphaPaintEngine::updateState(const QPaintEngineState &state)
+{
+    Q_D(QAlphaPaintEngine);
+
+    DirtyFlags flags = state.state();
+    if (flags & QPaintEngine::DirtyTransform) {
+        d->m_transform = state.transform();
+        d->m_complexTransform = (d->m_transform.type() > QTransform::TxScale);
+        d->m_emulateProjectiveTransforms = !(d->m_savedcaps & QPaintEngine::PerspectiveTransform)
+                                           && !(d->m_savedcaps & QPaintEngine::AlphaBlend)
+                                           && (d->m_transform.type() >= QTransform::TxProject);
+    }
+    if (flags & QPaintEngine::DirtyPen) {
+        d->m_pen = state.pen();
+        if (d->m_pen.style() == Qt::NoPen) {
+            d->m_advancedPen = false;
+            d->m_alphaPen = false;
+        } else {
+            d->m_advancedPen = (d->m_pen.brush().style() != Qt::SolidPattern);
+            d->m_alphaPen = !d->m_pen.brush().isOpaque();
+        }
+    }
+
+    if (d->m_pass != 0) {
+        d->m_continueCall = true;
+        return;
+    }
+    d->m_continueCall = false;
+
+    if (flags & QPaintEngine::DirtyOpacity) {
+        d->m_alphaOpacity = (state.opacity() != 1.0f);
+    }
+
+    if (flags & QPaintEngine::DirtyBrush) {
+        if (state.brush().style() == Qt::NoBrush) {
+            d->m_advancedBrush = false;
+            d->m_alphaBrush = false;
+        } else {
+            d->m_advancedBrush = (state.brush().style() != Qt::SolidPattern);
+            d->m_alphaBrush = !state.brush().isOpaque();
+        }
+    }
+
+
+    d->m_hasalpha = d->m_alphaOpacity || d->m_alphaBrush || d->m_alphaPen;
+
+    if (d->m_picengine)
+        d->m_picengine->updateState(state);
+}
+
+void QAlphaPaintEngine::drawPath(const QPainterPath &path)
+{
+    Q_D(QAlphaPaintEngine);
+
+    QRectF tr = d->addPenWidth(path);
+
+    if (d->m_pass == 0) {
+        d->m_continueCall = false;
+        if (d->m_hasalpha || d->m_advancedPen || d->m_advancedBrush
+            || d->m_emulateProjectiveTransforms)
+        {
+            d->addAlphaRect(tr);
+        }
+        if (d->m_picengine)
+            d->m_picengine->drawPath(path);
+    } else {
+        d->m_continueCall = !d->fullyContained(tr);
+    }
+}
+
+void QAlphaPaintEngine::drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode)
+{
+    Q_D(QAlphaPaintEngine);
+
+    QPolygonF poly;
+    for (int i=0; i<pointCount; ++i)
+        poly.append(points[i]);
+
+    QPainterPath path;
+    path.addPolygon(poly);
+    QRectF tr = d->addPenWidth(path);
+
+    if (d->m_pass == 0) {
+        d->m_continueCall = false;
+        if (d->m_hasalpha || d->m_advancedPen || d->m_advancedBrush
+            || d->m_emulateProjectiveTransforms)
+        {
+            d->addAlphaRect(tr);
+        }
+
+        if (d->m_picengine)
+            d->m_picengine->drawPolygon(points, pointCount, mode);
+    } else {
+        d->m_continueCall = !d->fullyContained(tr);
+    }
+}
+
+void QAlphaPaintEngine::drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr)
+{
+    Q_D(QAlphaPaintEngine);
+
+    QRectF tr = d->m_transform.mapRect(r);
+    if (d->m_pass == 0) {
+        d->m_continueCall = false;
+        if (pm.hasAlpha() || d->m_alphaOpacity || d->m_complexTransform || pm.isQBitmap()) {
+            d->addAlphaRect(tr);
+        }
+
+        if (d->m_picengine)
+            d->m_picengine->drawPixmap(r, pm, sr);
+
+    } else {
+        d->m_continueCall = !d->fullyContained(tr);
+    }
+}
+
+void QAlphaPaintEngine::drawImage(const QRectF &r, const QImage &image, const QRectF &sr)
+{
+    Q_D(QAlphaPaintEngine);
+
+    QRectF tr = d->m_transform.mapRect(r);
+    if (d->m_pass == 0) {
+        d->m_continueCall = false;
+        if (image.hasAlphaChannel() || d->m_alphaOpacity || d->m_complexTransform) {
+            d->addAlphaRect(tr);
+        }
+
+        if (d->m_picengine)
+            d->m_picengine->drawImage(r, image, sr);
+
+    } else {
+        d->m_continueCall = !d->fullyContained(tr);
+    }
+}
+
+void QAlphaPaintEngine::drawTextItem(const QPointF &p, const QTextItem &textItem)
+{
+    Q_D(QAlphaPaintEngine);
+
+    QRectF tr(p.x(), p.y() - textItem.ascent(), textItem.width() + 5, textItem.ascent() + textItem.descent() + 5);
+    tr = d->m_transform.mapRect(tr);
+
+    if (d->m_pass == 0) {
+        d->m_continueCall = false;
+        if (d->m_alphaPen || d->m_alphaOpacity || d->m_advancedPen) {
+            d->addAlphaRect(tr);
+        }
+        if (d->m_picengine) {
+            d->m_picengine->drawTextItem(p, textItem);
+        }
+    } else {
+        d->m_continueCall = !d->fullyContained(tr);
+    }
+}
+
+void QAlphaPaintEngine::drawTiledPixmap(const QRectF &r, const QPixmap &pixmap, const QPointF &s)
+{
+    Q_D(QAlphaPaintEngine);
+
+    QRectF brect = d->m_transform.mapRect(r);
+
+    if (d->m_pass == 0) {
+        d->m_continueCall = false;
+        if (pixmap.hasAlpha() || d->m_alphaOpacity || d->m_complexTransform || pixmap.isQBitmap()) {
+            d->addAlphaRect(brect);
+        }
+        if (d->m_picengine)
+            d->m_picengine->drawTiledPixmap(r, pixmap, s);
+    } else {
+        d->m_continueCall = !d->fullyContained(brect);
+    }
+}
+
+QRegion QAlphaPaintEngine::alphaClipping() const
+{
+    Q_D(const QAlphaPaintEngine);
+    return d->m_cliprgn;
+}
+
+bool QAlphaPaintEngine::continueCall() const
+{
+    Q_D(const QAlphaPaintEngine);
+    return d->m_continueCall;
+}
+
+void QAlphaPaintEngine::flushAndInit(bool init)
+{
+    Q_D(QAlphaPaintEngine);
+    Q_ASSERT(d->m_pass == 0);
+
+    if (d->m_pic) {
+        d->m_picpainter->end();
+
+        // set clip region
+        d->m_alphargn = d->m_alphargn.intersected(QRect(0, 0, d->m_pdev->width(), d->m_pdev->height()));
+
+        // just use the bounding rect if it's a complex region..
+        QVector<QRect> rects = d->m_alphargn.rects();
+        if (rects.size() > 10) {
+            QRect br = d->m_alphargn.boundingRect();
+            d->m_alphargn = QRegion(br);
+            rects.clear();
+            rects.append(br);
+        }
+
+        d->m_cliprgn = d->m_alphargn;
+
+        // now replay the QPicture
+        ++d->m_pass; // we are now doing pass #2
+
+        // reset states
+        gccaps = d->m_savedcaps;
+
+        painter()->save();
+        d->resetState(painter());
+
+        // make sure the output from QPicture is unscaled
+        QTransform mtx;
+        mtx.scale(1.0f / (qreal(d->m_pdev->logicalDpiX()) / qreal(qt_defaultDpiX())),
+                  1.0f / (qreal(d->m_pdev->logicalDpiY()) / qreal(qt_defaultDpiY())));
+        painter()->setTransform(mtx);
+        painter()->drawPicture(0, 0, *d->m_pic);
+
+        d->m_cliprgn = QRegion();
+        d->resetState(painter());
+
+        // fill in the alpha images
+        for (int i=0; i<rects.size(); ++i)
+            d->drawAlphaImage(rects.at(i));
+
+        d->m_alphargn = QRegion();
+
+        painter()->restore();
+
+        --d->m_pass; // pass #2 finished
+
+        cleanUp();
+    }
+
+    if (init) {
+        gccaps = PaintEngineFeatures(AllFeatures & ~QPaintEngine::ObjectBoundingModeGradients);
+
+        d->m_pic = new QPicture();
+        d->m_pic->d_ptr->in_memory_only = true;
+        d->m_picpainter = new QPainter(d->m_pic);
+        d->m_picengine = d->m_picpainter->paintEngine();
+
+        // When newPage() is called and the m_picpainter is recreated
+        // we have to copy the current state of the original printer
+        // painter back to the m_picpainter
+        d->m_picpainter->setPen(painter()->pen());
+        d->m_picpainter->setBrush(painter()->brush());
+        d->m_picpainter->setBrushOrigin(painter()->brushOrigin());
+        d->m_picpainter->setFont(painter()->font());
+        d->m_picpainter->setOpacity(painter()->opacity());
+        d->m_picpainter->setTransform(painter()->combinedTransform());
+        d->m_picengine->syncState();
+    }
+}
+
+void QAlphaPaintEngine::cleanUp()
+{
+    Q_D(QAlphaPaintEngine);
+
+    delete d->m_picpainter;
+    delete d->m_pic;
+
+    d->m_picpainter = 0;
+    d->m_pic = 0;
+    d->m_picengine = 0;
+}
+
+QAlphaPaintEnginePrivate::QAlphaPaintEnginePrivate()
+    :   m_pass(0),
+        m_pic(0),
+        m_picengine(0),
+        m_picpainter(0),
+        m_hasalpha(false),
+        m_alphaPen(false),
+        m_alphaBrush(false),
+        m_alphaOpacity(false),
+        m_advancedPen(false),
+        m_advancedBrush(false),
+        m_complexTransform(false)
+{
+
+}
+
+QAlphaPaintEnginePrivate::~QAlphaPaintEnginePrivate()
+{
+    delete m_picpainter;
+    delete m_pic;
+}
+
+QRectF QAlphaPaintEnginePrivate::addPenWidth(const QPainterPath &path)
+{
+    QPainterPath tmp = path;
+
+    if (m_pen.style() == Qt::NoPen)
+        return (path.controlPointRect() * m_transform).boundingRect();
+    if (m_pen.isCosmetic())
+        tmp = path * m_transform;
+
+    QPainterPathStroker stroker;
+    if (m_pen.widthF() == 0.0f)
+        stroker.setWidth(1.0);
+    else
+        stroker.setWidth(m_pen.widthF());
+    stroker.setJoinStyle(m_pen.joinStyle());
+    stroker.setCapStyle(m_pen.capStyle());
+    tmp = stroker.createStroke(tmp);
+    if (m_pen.isCosmetic())
+        return tmp.controlPointRect();
+
+    return (tmp.controlPointRect() * m_transform).boundingRect();
+}
+
+QRect QAlphaPaintEnginePrivate::toRect(const QRectF &rect) const
+{
+    QRect r;
+    r.setLeft(int(rect.left()));
+    r.setTop(int(rect.top()));
+    r.setRight(int(rect.right() + 1));
+    r.setBottom(int(rect.bottom() + 1));
+    return r;
+}
+
+void QAlphaPaintEnginePrivate::addAlphaRect(const QRectF &rect)
+{
+    m_alphargn |= toRect(rect);
+}
+
+void QAlphaPaintEnginePrivate::drawAlphaImage(const QRectF &rect)
+{
+    Q_Q(QAlphaPaintEngine);
+
+    qreal dpiX = qMax(m_pdev->logicalDpiX(), 300);
+    qreal dpiY = qMax(m_pdev->logicalDpiY(), 300);
+    qreal xscale = (dpiX / m_pdev->logicalDpiX());
+    qreal yscale = (dpiY / m_pdev->logicalDpiY());
+
+    QTransform picscale;
+    picscale.scale(xscale, yscale);
+
+    const int tileSize = 2048;
+    QSize size((int(rect.width() * xscale)), int(rect.height() * yscale));
+    int divw = (size.width() / tileSize);
+    int divh = (size.height() / tileSize);
+    divw += 1;
+    divh += 1;
+
+    int incx = int(rect.width() / divw);
+    int incy = int(rect.height() / divh);
+
+    for (int y=0; y<divh; ++y) {
+        int ypos = int((incy * y) + rect.y());
+        int height = int((y == (divh - 1)) ? (rect.height() - (incy * y)) : incy) + 1;
+
+        for (int x=0; x<divw; ++x) {
+            int xpos = int((incx * x) + rect.x());
+            int width = int((x == (divw - 1)) ? (rect.width() - (incx * x)) : incx) + 1;
+
+            QSize imgsize((int)(width * xscale), (int)(height * yscale));
+            QImage img(imgsize, QImage::Format_RGB32);
+            img.fill(0xffffffff);
+
+            QPainter imgpainter(&img);
+            imgpainter.setTransform(picscale);
+            QPointF picpos(qreal(-xpos), qreal(-ypos));
+            imgpainter.drawPicture(picpos, *m_pic);
+            imgpainter.end();
+
+            q->painter()->setTransform(QTransform());
+            QRect r(xpos, ypos, width, height);
+            q->painter()->drawImage(r, img);
+        }
+    }
+}
+
+bool QAlphaPaintEnginePrivate::fullyContained(const QRectF &rect) const
+{
+    QRegion r(toRect(rect));
+    return (m_cliprgn.intersected(r) == r);
+}
+
+void QAlphaPaintEnginePrivate::resetState(QPainter *p)
+{
+    p->setPen(QPen());
+    p->setBrush(QBrush());
+    p->setBrushOrigin(0,0);
+    p->setBackground(QBrush());
+    p->setFont(QFont());
+    p->setTransform(QTransform());
+    // The view transform is already recorded and included in the
+    // picture we're about to replay. If we don't turn if off,
+    // the view matrix will be applied twice.
+    p->setViewTransformEnabled(false);
+    p->setClipRegion(QRegion(), Qt::NoClip);
+    p->setClipPath(QPainterPath(), Qt::NoClip);
+    p->setClipping(false);
+    p->setOpacity(1.0f);
+}
+
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_PRINTER
diff --git a/src/gui/painting/qpaintengine_alpha_p.h b/src/gui/painting/qpaintengine_alpha_p.h
new file mode 100644
index 0000000000..2b8b4dda07
--- /dev/null
+++ b/src/gui/painting/qpaintengine_alpha_p.h
@@ -0,0 +1,135 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPAINTENGINE_ALPHA_P_H
+#define QPAINTENGINE_ALPHA_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of other Qt classes.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#ifndef QT_NO_PRINTER
+#include "private/qpaintengine_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QAlphaPaintEnginePrivate;
+
+class QAlphaPaintEngine : public QPaintEngine
+{
+    Q_DECLARE_PRIVATE(QAlphaPaintEngine)
+public:
+    ~QAlphaPaintEngine();
+
+    virtual bool begin(QPaintDevice *pdev);
+    virtual bool end();
+
+    virtual void updateState(const QPaintEngineState &state);
+
+    virtual void drawPath(const QPainterPath &path);
+
+    virtual void drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode);
+
+    virtual void drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr);
+    virtual void drawImage(const QRectF &r, const QImage &image, const QRectF &sr);
+    virtual void drawTextItem(const QPointF &p, const QTextItem &textItem);
+    virtual void drawTiledPixmap(const QRectF &r, const QPixmap &pixmap, const QPointF &s);
+
+protected:
+    QAlphaPaintEngine(QAlphaPaintEnginePrivate &data, PaintEngineFeatures devcaps = 0);
+    QRegion alphaClipping() const;
+    bool continueCall() const;
+    void flushAndInit(bool init = true);
+    void cleanUp();
+};
+
+class QAlphaPaintEnginePrivate : public QPaintEnginePrivate
+{
+    Q_DECLARE_PUBLIC(QAlphaPaintEngine)
+public:
+    QAlphaPaintEnginePrivate();
+    ~QAlphaPaintEnginePrivate();
+
+    int m_pass;
+    QPicture *m_pic;
+    QPaintEngine *m_picengine;
+    QPainter *m_picpainter;
+
+    QPaintEngine::PaintEngineFeatures m_savedcaps;
+    QPaintDevice *m_pdev;
+
+    QRegion m_alphargn;
+    QRegion m_cliprgn;
+
+    bool m_hasalpha;
+    bool m_alphaPen;
+    bool m_alphaBrush;
+    bool m_alphaOpacity;
+    bool m_advancedPen;
+    bool m_advancedBrush;
+    bool m_complexTransform;
+    bool m_emulateProjectiveTransforms;
+    bool m_continueCall;
+
+    QTransform m_transform;
+    QPen m_pen;
+
+    void addAlphaRect(const QRectF &rect);
+    QRectF addPenWidth(const QPainterPath &path);
+    void drawAlphaImage(const QRectF &rect);
+    QRect toRect(const QRectF &rect) const;
+    bool fullyContained(const QRectF &rect) const;
+
+    void resetState(QPainter *p);
+};
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_PRINTER
+
+#endif // QPAINTENGINE_ALPHA_P_H
diff --git a/src/gui/painting/qpaintengine_blitter.cpp b/src/gui/painting/qpaintengine_blitter.cpp
new file mode 100644
index 0000000000..500748e159
--- /dev/null
+++ b/src/gui/painting/qpaintengine_blitter.cpp
@@ -0,0 +1,663 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "private/qpaintengine_blitter_p.h"
+
+#include "private/qblittable_p.h"
+#include "private/qpaintengine_raster_p.h"
+#include "private/qpainter_p.h"
+#include "private/qapplication_p.h"
+#include "private/qpixmap_blitter_p.h"
+
+#ifndef QT_NO_BLITTABLE
+QT_BEGIN_NAMESPACE
+
+#define STATE_XFORM_SCALE       0x00000001
+#define STATE_XFORM_COMPLEX     0x00000002
+
+#define STATE_BRUSH_PATTERN     0x00000010
+#define STATE_BRUSH_ALPHA       0x00000020
+
+#define STATE_PEN_ENABLED       0x00000100
+
+#define STATE_ANTIALIASING      0x00001000
+#define STATE_ALPHA             0x00002000
+#define STATE_BLENDING_COMPLEX  0x00004000
+
+#define STATE_CLIPSYS_COMPLEX   0x00010000
+#define STATE_CLIP_COMPLEX      0x00020000
+
+
+static inline void updateStateBits(uint *state, uint mask, bool on)
+{
+    *state = on ? (*state | mask) : (*state & ~mask);
+}
+
+static inline bool checkStateAgainstMask(uint state, uint mask)
+{
+    return !state || (state & mask && !(state & ~mask));
+}
+
+class CapabilitiesToStateMask
+{
+public:
+    CapabilitiesToStateMask(QBlittable::Capabilities capabilities)
+            : m_capabilities(capabilities),
+              fillRectMask(0),
+              drawRectMask(0),
+              drawPixmapMask(0),
+              capabillitiesState(0)
+    {
+        if (capabilities & QBlittable::SolidRectCapability) {
+            setFillRectMask();
+        }
+        if (capabilities & QBlittable::SourcePixmapCapability) {
+           setSourcePixmapMask();
+        }
+        if (capabilities & QBlittable::SourceOverPixmapCapability) {
+           setSourceOverPixmapMask();
+        }
+        if (capabilities & QBlittable::SourceOverScaledPixmapCapability) {
+            setSourceOverScaledPixmapMask();
+        }
+    }
+
+    inline bool canBlitterFillRect() const
+    {
+        return checkStateAgainstMask(capabillitiesState,fillRectMask);
+    }
+
+    inline bool canBlitterDrawRectMask() const
+    {
+        return checkStateAgainstMask(capabillitiesState,drawRectMask);
+    }
+
+    bool canBlitterDrawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr) const
+    {
+        if (pm.pixmapData()->classId() != QPixmapData::BlitterClass)
+            return false;
+        if (checkStateAgainstMask(capabillitiesState,drawPixmapMask)) {
+            if (m_capabilities & (QBlittable::SourceOverPixmapCapability
+                                  | QBlittable::SourceOverScaledPixmapCapability)) {
+                if (r.size() != sr.size()) {
+                    return m_capabilities & QBlittable::SourceOverScaledPixmapCapability;
+                } else {
+                    return m_capabilities & QBlittable::SourceOverPixmapCapability;
+                }
+            }
+            if ((m_capabilities & QBlittable::SourcePixmapCapability) && r.size() == sr.size() && !pm.hasAlphaChannel()) {
+                return m_capabilities & QBlittable::SourcePixmapCapability;
+            }
+        }
+        return false;
+    }
+
+    inline void updateState(uint mask, bool on) {
+        updateStateBits(&capabillitiesState,mask,on);
+    }
+
+public:
+
+    void setFillRectMask() {
+        updateStateBits(&fillRectMask, STATE_XFORM_SCALE, false);
+        updateStateBits(&fillRectMask, STATE_XFORM_COMPLEX, false);
+
+        updateStateBits(&fillRectMask, STATE_BRUSH_PATTERN, false);
+        updateStateBits(&fillRectMask, STATE_BRUSH_ALPHA, false);
+
+        updateStateBits(&fillRectMask, STATE_PEN_ENABLED, true);
+
+        //Sub-pixel aliasing should not be sent to the blitter
+        updateStateBits(&fillRectMask, STATE_ANTIALIASING, true);
+        updateStateBits(&fillRectMask, STATE_ALPHA, false);
+        updateStateBits(&fillRectMask, STATE_BLENDING_COMPLEX, false);
+
+        updateStateBits(&fillRectMask, STATE_CLIPSYS_COMPLEX, false);
+        updateStateBits(&fillRectMask, STATE_CLIP_COMPLEX, false);
+    }
+
+    void setSourcePixmapMask() {
+        updateStateBits(&drawPixmapMask, STATE_XFORM_SCALE, true);
+        updateStateBits(&drawPixmapMask, STATE_XFORM_COMPLEX, false);
+
+        updateStateBits(&drawPixmapMask, STATE_BRUSH_PATTERN, true);
+        updateStateBits(&drawPixmapMask, STATE_BRUSH_ALPHA, false);
+
+        updateStateBits(&drawPixmapMask, STATE_PEN_ENABLED, true);
+
+        updateStateBits(&drawPixmapMask, STATE_ANTIALIASING, true);
+        updateStateBits(&drawPixmapMask, STATE_ALPHA, false);
+        updateStateBits(&drawPixmapMask, STATE_BLENDING_COMPLEX, false);
+
+        updateStateBits(&drawPixmapMask, STATE_CLIPSYS_COMPLEX, false);
+        updateStateBits(&drawPixmapMask, STATE_CLIP_COMPLEX, false);
+    }
+
+    void setSourceOverPixmapMask() {
+        setSourcePixmapMask();
+    }
+
+    void setSourceOverScaledPixmapMask() {
+        setSourceOverPixmapMask();
+        updateStateBits(&drawRectMask, STATE_XFORM_SCALE, true);
+    }
+
+    QBlittable::Capabilities m_capabilities;
+    uint fillRectMask;
+    uint drawRectMask;
+    uint drawPixmapMask;
+    uint capabillitiesState;
+};
+
+class QBlitterPaintEnginePrivate : public QPaintEngineExPrivate
+{
+    Q_DECLARE_PUBLIC(QBlitterPaintEngine);
+public:
+    QBlitterPaintEnginePrivate(QBlittablePixmapData *p)
+            : QPaintEngineExPrivate(),
+              pmData(p),
+              isBlitterLocked(false),
+              hasXForm(false)
+
+    {
+        raster = new QRasterPaintEngine(p->buffer());
+        capabillities = new CapabilitiesToStateMask(pmData->blittable()->capabilities());
+    }
+
+    inline void lock() {
+        if (!isBlitterLocked) {
+            raster->d_func()->rasterBuffer->prepare(pmData->blittable()->lock());
+            isBlitterLocked = true;
+        }
+    }
+
+    inline void unlock() {
+        if (isBlitterLocked) {
+            pmData->blittable()->unlock();
+            isBlitterLocked = false;
+        }
+    }
+
+    void fillRect(const QRectF &rect, const QColor &color) {
+        Q_Q(QBlitterPaintEngine);
+        pmData->unmarkRasterOverlay(rect);
+        QRectF targetRect = rect;
+        if (hasXForm) {
+            targetRect = q->state()->matrix.mapRect(rect);
+        }
+        const QClipData *clipData = q->clip();
+        if (clipData) {
+            if (clipData->hasRectClip) {
+                unlock();
+                pmData->blittable()->fillRect(targetRect & clipData->clipRect, color);
+            } else if (clipData->hasRegionClip) {
+                QVector<QRect> rects = clipData->clipRegion.rects();
+                for ( int i = 0; i < rects.size(); i++ ) {
+                    QRect intersectRect = rects.at(i).intersected(targetRect.toRect());
+                    if (!intersectRect.isEmpty()) {
+                        unlock();
+                        pmData->blittable()->fillRect(intersectRect,color);
+                    }
+                }
+            }
+        } else {
+            if (targetRect.x() >= 0 && targetRect.y() >= 0
+                && targetRect.width() <= raster->paintDevice()->width()
+                && targetRect.height() <= raster->paintDevice()->height()) {
+                unlock();
+                pmData->blittable()->fillRect(targetRect,color);
+            } else {
+                QRectF deviceRect(0,0,raster->paintDevice()->width(), raster->paintDevice()->height());
+                unlock();
+                pmData->blittable()->fillRect(deviceRect&targetRect,color);
+            }
+        }
+    }
+
+    void clipAndDrawPixmap(const QRectF &clip, const QRectF &target, const QPixmap &pm, const QRectF &sr) {
+        QRectF intersectedRect = clip.intersected(target);
+        if (intersectedRect.isEmpty())
+            return;
+        QRectF source = sr;
+        if(intersectedRect.size() != target.size()) {
+            qreal deltaTop = target.top() - intersectedRect.top();
+            qreal deltaLeft = target.left() - intersectedRect.left();
+            qreal deltaBottom = target.bottom() - intersectedRect.bottom();
+            qreal deltaRight = target.right() - intersectedRect.right();
+            source.adjust(-deltaLeft,-deltaTop,-deltaRight,-deltaBottom);
+        }
+        pmData->unmarkRasterOverlay(intersectedRect);
+        pmData->blittable()->drawPixmap(intersectedRect, pm, source);
+    }
+
+    void updateClip() {
+        Q_Q(QBlitterPaintEngine);
+        const QClipData *clip = q->clip();
+        bool complex = clip && !(clip->hasRectClip || clip->hasRegionClip);
+        capabillities->updateState(STATE_CLIP_COMPLEX, complex);
+    }
+
+    void systemStateChanged() {
+        raster->d_func()->systemStateChanged();
+    }
+
+    QRasterPaintEngine *raster;
+
+    QBlittablePixmapData *pmData;
+    bool isBlitterLocked;
+
+    CapabilitiesToStateMask *capabillities;
+
+    uint hasXForm;
+};
+
+QBlitterPaintEngine::QBlitterPaintEngine(QBlittablePixmapData *p)
+    : QPaintEngineEx(*(new QBlitterPaintEnginePrivate(p)))
+{
+}
+
+QBlitterPaintEngine::~QBlitterPaintEngine()
+{
+}
+
+QPainterState *QBlitterPaintEngine::createState(QPainterState *orig) const
+{
+    Q_D(const QBlitterPaintEngine);
+    return d->raster->createState(orig);
+}
+
+bool QBlitterPaintEngine::begin(QPaintDevice *pdev)
+{
+    Q_D(QBlitterPaintEngine);
+
+    setActive(true);
+    bool ok = d->raster->begin(pdev);
+#ifdef QT_BLITTER_RASTEROVERLAY
+    d->pmData->unmergeOverlay();
+#endif
+    return ok;
+}
+
+
+bool QBlitterPaintEngine::end()
+{
+    Q_D(QBlitterPaintEngine);
+
+    setActive(false);
+#ifdef QT_BLITTER_RASTEROVERLAY
+    d->pmData->mergeOverlay();
+#endif
+    return d->raster->end();
+}
+
+
+void QBlitterPaintEngine::fill(const QVectorPath &path, const QBrush &brush)
+{
+    Q_D(QBlitterPaintEngine);
+    if (path.shape() == QVectorPath::RectangleHint) {
+        QRectF rect(((QPointF *) path.points())[0], ((QPointF *) path.points())[2]);
+        fillRect(rect, brush);
+    } else {
+        d->lock();
+        d->pmData->markRasterOverlay(path);
+        d->raster->fill(path, brush);
+    }
+}
+
+void QBlitterPaintEngine::fillRect(const QRectF &rect, const QColor &color)
+{
+    Q_D(QBlitterPaintEngine);
+    if (d->capabillities->canBlitterFillRect() && color.alpha() == 0xff) {
+        d->fillRect(rect, color);
+    } else {
+        d->lock();
+        d->pmData->markRasterOverlay(rect);
+        d->raster->fillRect(rect, color);
+    }
+}
+
+void QBlitterPaintEngine::fillRect(const QRectF &rect, const QBrush &brush)
+{
+    if(rect.size().isEmpty())
+        return;
+
+    Q_D(QBlitterPaintEngine);
+
+    if (qbrush_style(brush) == Qt::SolidPattern
+        && qbrush_color(brush).alpha() == 0xff
+        && d->capabillities->canBlitterFillRect())
+    {
+        d->fillRect(rect, qbrush_color(brush));
+    }else if (brush.style() == Qt::TexturePattern
+              && d->capabillities->canBlitterDrawPixmap(rect,brush.texture(),rect))
+    {
+        bool rectIsFilled = false;
+        QRectF transformedRect = state()->matrix.mapRect(rect);
+        qreal x = transformedRect.x();
+        qreal y = transformedRect.y();
+        QPixmap pm = brush.texture();
+        d->unlock();
+        int srcX = int(rect.x() - state()->brushOrigin.x()) % pm.width();
+        if (srcX < 0)
+            srcX = pm.width() + srcX;
+        const int startX = srcX;
+        int srcY = int(rect.y() - state()->brushOrigin.y()) % pm.height();
+        if (srcY < 0)
+            srcY = pm.height() + srcY;
+        while (!rectIsFilled) {
+            qreal blitWidth = (pm.width() ) - srcX;
+            qreal blitHeight = (pm.height() ) - srcY;
+            if (x + blitWidth > transformedRect.right())
+                blitWidth = transformedRect.right() -x;
+            if (y + blitHeight > transformedRect.bottom())
+                blitHeight = transformedRect.bottom() - y;
+            const QClipData *clipData = clip();
+            if (clipData->hasRectClip) {
+                QRect targetRect = QRect(x,y,blitWidth,blitHeight).intersected(clipData->clipRect);
+                if (targetRect.isValid()) {
+                    int tmpSrcX  = srcX + (targetRect.x() - x);
+                    int tmpSrcY = srcY + (targetRect.y() - y);
+                    QRect srcRect(tmpSrcX,tmpSrcY,targetRect.width(),targetRect.height());
+                    d->pmData->blittable()->drawPixmap(targetRect,pm,srcRect);
+                }
+            } else if (clipData->hasRegionClip) {
+                QVector<QRect> clipRects = clipData->clipRegion.rects();
+                QRect unclippedTargetRect(x,y,blitWidth,blitHeight);
+                QRegion intersectedRects = clipData->clipRegion.intersected(unclippedTargetRect);
+
+                for ( int i = 0; i < intersectedRects.rects().size(); i++ ) {
+                    QRect targetRect = intersectedRects.rects().at(i);
+                    if (!targetRect.isValid() || targetRect.isEmpty())
+                        continue;
+                    int tmpSrcX = srcX + (targetRect.x() - x);
+                    int tmpSrcY = srcY + (targetRect.y() - y);
+                    QRect srcRect(tmpSrcX,tmpSrcY,targetRect.width(),targetRect.height());
+                    d->pmData->blittable()->drawPixmap(targetRect,pm,srcRect);
+                }
+            }
+            x+=blitWidth;
+            if (x>=transformedRect.right()) {
+                x = transformedRect.x();
+                srcX = startX;
+                srcY = 0;
+                y+=blitHeight;
+                if (y>=transformedRect.bottom())
+                    rectIsFilled = true;
+            } else
+                srcX = 0;
+        }
+    } else {
+        d->lock();
+        d->pmData->markRasterOverlay(rect);
+        d->raster->fillRect(rect, brush);
+    }
+
+}
+
+void QBlitterPaintEngine::stroke(const QVectorPath &path, const QPen &pen)
+{
+    Q_D(QBlitterPaintEngine);
+    d->lock();
+    d->pmData->markRasterOverlay(path);
+    d->raster->stroke(path, pen);
+}
+
+void QBlitterPaintEngine::clip(const QVectorPath &path, Qt::ClipOperation op)
+{
+    Q_D(QBlitterPaintEngine);
+    d->lock();
+    d->raster->clip(path, op);
+    d->updateClip();
+}
+void QBlitterPaintEngine::clip(const QRect &rect, Qt::ClipOperation op){
+    Q_D(QBlitterPaintEngine);
+    d->lock();
+    d->raster->clip(rect,op);
+    d->updateClip();
+}
+void QBlitterPaintEngine::clip(const QRegion &region, Qt::ClipOperation op)
+{
+    Q_D(QBlitterPaintEngine);
+    d->lock();
+    d->raster->clip(region,op);
+    d->updateClip();
+}
+
+void QBlitterPaintEngine::clipEnabledChanged()
+{
+    Q_D(QBlitterPaintEngine);
+    d->lock();
+    d->raster->clipEnabledChanged();
+}
+
+void QBlitterPaintEngine::penChanged()
+{
+    Q_D(QBlitterPaintEngine);
+    d->lock();
+    d->raster->penChanged();
+    d->capabillities->updateState(STATE_PEN_ENABLED,qpen_style(state()->pen) != Qt::NoPen);
+}
+
+void QBlitterPaintEngine::brushChanged()
+{
+    Q_D(QBlitterPaintEngine);
+    d->raster->brushChanged();
+
+    bool solid = qbrush_style(state()->brush) == Qt::SolidPattern;
+
+    d->capabillities->updateState(STATE_BRUSH_PATTERN, !solid);
+    d->capabillities->updateState(STATE_BRUSH_ALPHA,
+                                        qbrush_color(state()->brush).alpha() < 255);
+}
+
+void QBlitterPaintEngine::brushOriginChanged()
+{
+    Q_D(QBlitterPaintEngine);
+    d->raster->brushOriginChanged();
+}
+
+void QBlitterPaintEngine::opacityChanged()
+{
+    Q_D(QBlitterPaintEngine);
+    d->raster->opacityChanged();
+
+    bool translucent = state()->opacity < 1;
+    d->capabillities->updateState(STATE_ALPHA,translucent);
+}
+
+void QBlitterPaintEngine::compositionModeChanged()
+{
+    Q_D(QBlitterPaintEngine);
+    d->raster->compositionModeChanged();
+
+    bool nonTrivial = state()->composition_mode != QPainter::CompositionMode_SourceOver
+                      && state()->composition_mode != QPainter::CompositionMode_Source;
+
+    d->capabillities->updateState(STATE_BLENDING_COMPLEX,nonTrivial);
+}
+
+void QBlitterPaintEngine::renderHintsChanged()
+{
+    Q_D(QBlitterPaintEngine);
+    d->raster->renderHintsChanged();
+
+    bool aa = state()->renderHints & QPainter::Antialiasing;
+    d->capabillities->updateState(STATE_ANTIALIASING, aa);
+
+}
+
+void QBlitterPaintEngine::transformChanged()
+{
+    Q_D(QBlitterPaintEngine);
+    d->raster->transformChanged();
+
+    QTransform::TransformationType type = state()->matrix.type();
+
+    d->capabillities->updateState(STATE_XFORM_COMPLEX, type > QTransform::TxScale);
+    d->capabillities->updateState(STATE_XFORM_SCALE, type > QTransform::TxTranslate);
+
+    d->hasXForm = type >= QTransform::TxTranslate;
+
+}
+
+void QBlitterPaintEngine::drawRects(const QRect *rects, int rectCount)
+{
+    Q_D(QBlitterPaintEngine);
+    if (d->capabillities->canBlitterDrawRectMask()) {
+        for (int i=0; i<rectCount; ++i) {
+            d->fillRect(rects[i], qbrush_color(state()->brush));
+        }
+    } else {
+        d->pmData->markRasterOverlay(rects,rectCount);
+        QPaintEngineEx::drawRects(rects, rectCount);
+    }
+}
+
+void QBlitterPaintEngine::drawRects(const QRectF *rects, int rectCount)
+{
+    Q_D(QBlitterPaintEngine);
+    if (d->capabillities->canBlitterDrawRectMask()) {
+        for (int i=0; i<rectCount; ++i) {
+            d->fillRect(rects[i], qbrush_color(state()->brush));
+        }
+    } else {
+        d->pmData->markRasterOverlay(rects,rectCount);
+        QPaintEngineEx::drawRects(rects, rectCount);
+    }
+}
+
+void QBlitterPaintEngine::drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr)
+{
+    Q_D(QBlitterPaintEngine);
+    if (d->capabillities->canBlitterDrawPixmap(r,pm,sr)) {
+
+        d->unlock();
+        QRectF targetRect = r;
+        if (d->hasXForm) {
+            targetRect = state()->matrix.mapRect(r);
+        }
+        const QClipData *clipData = clip();
+        if (clipData) {
+            if (clipData->hasRectClip) {
+                d->clipAndDrawPixmap(clipData->clipRect,targetRect,pm,sr);
+            }else if (clipData->hasRegionClip) {
+                QVector<QRect>rects = clipData->clipRegion.rects();
+                for (int i = 0; i<rects.size(); i++) {
+                    d->clipAndDrawPixmap(rects.at(i),targetRect,pm,sr);
+                }
+            }
+        } else {
+            QRectF deviceRect(0,0,d->raster->paintDevice()->width(), d->raster->paintDevice()->height());
+            d->clipAndDrawPixmap(deviceRect,targetRect,pm,sr);
+        }
+    }else {
+        d->lock();
+        d->pmData->markRasterOverlay(r);
+        d->raster->drawPixmap(r, pm, sr);
+    }
+}
+
+void QBlitterPaintEngine::drawImage(const QRectF &r, const QImage &pm, const QRectF &sr,
+                                    Qt::ImageConversionFlags flags)
+{
+    Q_D(QBlitterPaintEngine);
+    d->lock();
+    d->pmData->markRasterOverlay(r);
+    d->raster->drawImage(r, pm, sr, flags);
+}
+
+
+void QBlitterPaintEngine::drawTextItem(const QPointF &pos, const QTextItem &ti)
+{
+    Q_D(QBlitterPaintEngine);
+    d->lock();
+    d->raster->drawTextItem(pos, ti);
+    d->pmData->markRasterOverlay(pos,ti);
+}
+
+void QBlitterPaintEngine::drawStaticTextItem(QStaticTextItem *sti)
+{
+    Q_D(QBlitterPaintEngine);
+    d->lock();
+    d->raster->drawStaticTextItem(sti);
+
+//#### d->pmData->markRasterOverlay(sti);
+    qWarning("not implemented: markRasterOverlay for QStaticTextItem");
+
+}
+
+
+void QBlitterPaintEngine::drawEllipse(const QRectF &r)
+{
+    Q_D(QBlitterPaintEngine);
+    d->lock();
+    d->pmData->markRasterOverlay(r);
+    d->raster->drawEllipse(r);
+}
+
+void QBlitterPaintEngine::setState(QPainterState *s)
+{
+    Q_D(QBlitterPaintEngine);
+    d->lock();
+    QPaintEngineEx::setState(s);
+    d->raster->setState(s);
+
+    clipEnabledChanged();
+    penChanged();
+    brushChanged();
+    brushOriginChanged();
+    opacityChanged();
+    compositionModeChanged();
+    renderHintsChanged();
+    transformChanged();
+
+    d->updateClip();
+}
+
+inline QRasterPaintEngine *QBlitterPaintEngine::raster() const
+{
+    Q_D(const QBlitterPaintEngine);
+    return d->raster;
+}
+
+QT_END_NAMESPACE
+#endif //QT_NO_BLITTABLE
+
diff --git a/src/gui/painting/qpaintengine_blitter_p.h b/src/gui/painting/qpaintengine_blitter_p.h
new file mode 100644
index 0000000000..be8b2bc5ea
--- /dev/null
+++ b/src/gui/painting/qpaintengine_blitter_p.h
@@ -0,0 +1,113 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPAINTENGINE_BLITTER_P_H
+#define QPAINTENGINE_BLITTER_P_H
+
+#include "private/qpaintengineex_p.h"
+#include "private/qpaintengine_raster_p.h"
+
+#ifndef QT_NO_BLITTABLE
+QT_BEGIN_NAMESPACE
+
+class QBlitterPaintEnginePrivate;
+class QBlittablePixmapData;
+class QBlittable;
+
+class Q_GUI_EXPORT QBlitterPaintEngine : public QPaintEngineEx
+{
+    Q_DECLARE_PRIVATE(QBlitterPaintEngine);
+public:
+    QBlitterPaintEngine(QBlittablePixmapData *p);
+    ~QBlitterPaintEngine();
+
+    virtual QPainterState *createState(QPainterState *orig) const;
+
+    virtual QPaintEngine::Type type() const { return Blitter; }
+
+    virtual bool begin(QPaintDevice *pdev);
+    virtual bool end();
+
+    virtual void fill(const QVectorPath &path, const QBrush &brush);
+    virtual void stroke(const QVectorPath &path, const QPen &pen);
+
+    virtual void clip(const QVectorPath &path, Qt::ClipOperation op);
+    virtual void clip(const QRect &rect, Qt::ClipOperation op);
+    virtual void clip(const QRegion &region, Qt::ClipOperation op);
+
+    virtual void clipEnabledChanged();
+    virtual void penChanged();
+    virtual void brushChanged();
+    virtual void brushOriginChanged();
+    virtual void opacityChanged();
+    virtual void compositionModeChanged();
+    virtual void renderHintsChanged();
+    virtual void transformChanged();
+
+    virtual void fillRect(const QRectF &rect, const QBrush &brush);
+    virtual void fillRect(const QRectF &rect, const QColor &color);
+
+    virtual void drawRects(const QRect *rects, int rectCount);
+    virtual void drawRects(const QRectF *rects, int rectCount);
+
+    virtual void drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr);
+
+    virtual void drawImage(const QRectF &r, const QImage &pm, const QRectF &sr, Qt::ImageConversionFlags flags);
+
+    virtual void drawTextItem(const QPointF &pos, const QTextItem &ti);
+    virtual void drawStaticTextItem(QStaticTextItem *);
+
+    virtual void drawEllipse(const QRectF &r);
+
+    virtual void setState(QPainterState *s);
+
+    inline QPainterState *state() { return raster()->state(); }
+    inline const QPainterState *state() const { const QPainterState *state = raster()->state(); return state;}
+    inline const QClipData *clip(){return raster()->d_func()->clip();}
+
+private:
+    QRasterPaintEngine *raster() const;
+};
+
+QT_END_NAMESPACE
+#endif //QT_NO_BLITTABLE
+#endif // QPAINTENGINE_BLITTER_P_H
+
diff --git a/src/gui/painting/qpaintengine_mac.cpp b/src/gui/painting/qpaintengine_mac.cpp
new file mode 100644
index 0000000000..8aab7c7a4b
--- /dev/null
+++ b/src/gui/painting/qpaintengine_mac.cpp
@@ -0,0 +1,1749 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <qbitmap.h>
+#include <qpaintdevice.h>
+#include <private/qpaintengine_mac_p.h>
+#include <qpainterpath.h>
+#include <qpixmapcache.h>
+#include <private/qpaintengine_raster_p.h>
+#include <private/qprintengine_mac_p.h>
+#include <qprinter.h>
+#include <qstack.h>
+#include <qtextcodec.h>
+#include <qwidget.h>
+#include <qvarlengtharray.h>
+#include <qdebug.h>
+#include <qcoreapplication.h>
+#include <qmath.h>
+
+#include <private/qfont_p.h>
+#include <private/qfontengine_p.h>
+#include <private/qfontengine_coretext_p.h>
+#include <private/qfontengine_mac_p.h>
+#include <private/qnumeric_p.h>
+#include <private/qpainter_p.h>
+#include <private/qpainterpath_p.h>
+#include <private/qpixmap_mac_p.h>
+#include <private/qt_mac_p.h>
+#include <private/qtextengine_p.h>
+#include <private/qwidget_p.h>
+#include <private/qt_cocoa_helpers_mac_p.h>
+
+#include <string.h>
+
+QT_BEGIN_NAMESPACE
+
+extern int qt_antialiasing_threshold; // QApplication.cpp
+
+/*****************************************************************************
+  External functions
+ *****************************************************************************/
+extern CGImageRef qt_mac_create_imagemask(const QPixmap &px, const QRectF &sr); //qpixmap_mac.cpp
+extern QPoint qt_mac_posInWindow(const QWidget *w); //qwidget_mac.cpp
+extern OSWindowRef qt_mac_window_for(const QWidget *); //qwidget_mac.cpp
+extern CGContextRef qt_mac_cg_context(const QPaintDevice *); //qpaintdevice_mac.cpp
+extern void qt_mac_dispose_rgn(RgnHandle r); //qregion_mac.cpp
+extern QPixmap qt_pixmapForBrush(int, bool); //qbrush.cpp
+
+void qt_mac_clip_cg(CGContextRef hd, const QRegion &rgn, CGAffineTransform *orig_xform);
+
+
+//Implemented for qt_mac_p.h
+QMacCGContext::QMacCGContext(QPainter *p)
+{
+    QPaintEngine *pe = p->paintEngine();
+    if (pe->type() == QPaintEngine::MacPrinter)
+        pe = static_cast<QMacPrintEngine*>(pe)->paintEngine();
+    pe->syncState();
+    context = 0;
+    if(pe->type() == QPaintEngine::CoreGraphics)
+        context = static_cast<QCoreGraphicsPaintEngine*>(pe)->handle();
+
+    int devType = p->device()->devType();
+    if (pe->type() == QPaintEngine::Raster
+            && (devType == QInternal::Widget || devType == QInternal::Pixmap)) {
+
+        extern CGColorSpaceRef qt_mac_colorSpaceForDeviceType(const QPaintDevice *paintDevice);
+        CGColorSpaceRef colorspace = qt_mac_colorSpaceForDeviceType(pe->paintDevice());
+        uint flags = kCGImageAlphaPremultipliedFirst;
+#ifdef kCGBitmapByteOrder32Host //only needed because CGImage.h added symbols in the minor version
+        flags |= kCGBitmapByteOrder32Host;
+#endif
+        const QImage *image = (const QImage *) pe->paintDevice();
+
+        context = CGBitmapContextCreate((void *) image->bits(), image->width(), image->height(),
+                                        8, image->bytesPerLine(), colorspace, flags);
+
+        CGContextTranslateCTM(context, 0, image->height());
+        CGContextScaleCTM(context, 1, -1);
+
+        if (devType == QInternal::Widget) {
+            QRegion clip = p->paintEngine()->systemClip();
+            QTransform native = p->deviceTransform();
+            QTransform logical = p->combinedTransform();
+
+            if (p->hasClipping()) {
+                QRegion r = p->clipRegion();
+                r.translate(native.dx(), native.dy());
+                if (clip.isEmpty())
+                    clip = r;
+                else
+                    clip &= r;
+            }
+            qt_mac_clip_cg(context, clip, 0);
+
+            CGContextTranslateCTM(context, native.dx(), native.dy());
+        }
+    } else {
+        CGContextRetain(context);
+    }
+}
+
+
+/*****************************************************************************
+  QCoreGraphicsPaintEngine utility functions
+ *****************************************************************************/
+
+//conversion
+inline static float qt_mac_convert_color_to_cg(int c) { return ((float)c * 1000 / 255) / 1000; }
+inline static int qt_mac_convert_color_from_cg(float c) { return qRound(c * 255); }
+CGAffineTransform qt_mac_convert_transform_to_cg(const QTransform &t) {
+    return CGAffineTransformMake(t.m11(), t.m12(), t.m21(), t.m22(), t.dx(),  t.dy());
+}
+
+CGColorSpaceRef qt_mac_colorSpaceForDeviceType(const QPaintDevice *paintDevice)
+{
+    bool isWidget = (paintDevice->devType() == QInternal::Widget);
+    return QCoreGraphicsPaintEngine::macDisplayColorSpace(isWidget ? static_cast<const QWidget *>(paintDevice)
+                                                                   : 0);
+}
+
+inline static QCFType<CGColorRef> cgColorForQColor(const QColor &col, QPaintDevice *pdev)
+{
+    CGFloat components[] = {
+        qt_mac_convert_color_to_cg(col.red()),
+        qt_mac_convert_color_to_cg(col.green()),
+        qt_mac_convert_color_to_cg(col.blue()),
+        qt_mac_convert_color_to_cg(col.alpha())
+    };
+    return CGColorCreate(qt_mac_colorSpaceForDeviceType(pdev), components);
+}
+
+// There's architectural problems with using native gradients
+// on the Mac at the moment, so disable them.
+// #define QT_MAC_USE_NATIVE_GRADIENTS
+
+#ifdef QT_MAC_USE_NATIVE_GRADIENTS
+static bool drawGradientNatively(const QGradient *gradient)
+{
+    return gradient->spread() == QGradient::PadSpread;
+}
+
+// gradiant callback
+static void qt_mac_color_gradient_function(void *info, const CGFloat *in, CGFloat *out)
+{
+    QBrush *brush = static_cast<QBrush *>(info);
+    Q_ASSERT(brush && brush->gradient());
+
+    const QGradientStops stops = brush->gradient()->stops();
+    const int n = stops.count();
+    Q_ASSERT(n >= 1);
+    const QGradientStop *begin = stops.constBegin();
+    const QGradientStop *end = begin + n;
+
+    qreal p = in[0];
+    const QGradientStop *i = begin;
+    while (i != end && i->first < p)
+        ++i;
+
+    QRgb c;
+    if (i == begin) {
+        c = begin->second.rgba();
+    } else if (i == end) {
+        c = (end - 1)->second.rgba();
+    } else {
+        const QGradientStop &s1 = *(i - 1);
+        const QGradientStop &s2 = *i;
+        qreal p1 = s1.first;
+        qreal p2 = s2.first;
+        QRgb c1 = s1.second.rgba();
+        QRgb c2 = s2.second.rgba();
+        int idist = 256 * (p - p1) / (p2 - p1);
+        int dist = 256 - idist;
+        c = qRgba(INTERPOLATE_PIXEL_256(qRed(c1), dist, qRed(c2), idist),
+                  INTERPOLATE_PIXEL_256(qGreen(c1), dist, qGreen(c2), idist),
+                  INTERPOLATE_PIXEL_256(qBlue(c1), dist, qBlue(c2), idist),
+                  INTERPOLATE_PIXEL_256(qAlpha(c1), dist, qAlpha(c2), idist));
+    }
+
+    out[0] = qt_mac_convert_color_to_cg(qRed(c));
+    out[1] = qt_mac_convert_color_to_cg(qGreen(c));
+    out[2] = qt_mac_convert_color_to_cg(qBlue(c));
+    out[3] = qt_mac_convert_color_to_cg(qAlpha(c));
+}
+#endif
+
+//clipping handling
+void QCoreGraphicsPaintEnginePrivate::resetClip()
+{
+    static bool inReset = false;
+    if (inReset)
+        return;
+    inReset = true;
+
+    CGAffineTransform old_xform = CGContextGetCTM(hd);
+
+    //setup xforms
+    CGContextConcatCTM(hd, CGAffineTransformInvert(old_xform));
+    while (stackCount > 0) {
+        restoreGraphicsState();
+    }
+    saveGraphicsState();
+    inReset = false;
+    //reset xforms
+    CGContextConcatCTM(hd, CGAffineTransformInvert(CGContextGetCTM(hd)));
+    CGContextConcatCTM(hd, old_xform);
+}
+
+static CGRect qt_mac_compose_rect(const QRectF &r, float off=0)
+{
+    return CGRectMake(r.x()+off, r.y()+off, r.width(), r.height());
+}
+
+static CGMutablePathRef qt_mac_compose_path(const QPainterPath &p, float off=0)
+{
+    CGMutablePathRef ret = CGPathCreateMutable();
+    QPointF startPt;
+    for (int i=0; i<p.elementCount(); ++i) {
+        const QPainterPath::Element &elm = p.elementAt(i);
+        switch (elm.type) {
+            case QPainterPath::MoveToElement:
+                if(i > 0
+                        && p.elementAt(i - 1).x == startPt.x()
+                        && p.elementAt(i - 1).y == startPt.y())
+                    CGPathCloseSubpath(ret);
+                startPt = QPointF(elm.x, elm.y);
+                CGPathMoveToPoint(ret, 0, elm.x+off, elm.y+off);
+                break;
+            case QPainterPath::LineToElement:
+                CGPathAddLineToPoint(ret, 0, elm.x+off, elm.y+off);
+                break;
+            case QPainterPath::CurveToElement:
+                Q_ASSERT(p.elementAt(i+1).type == QPainterPath::CurveToDataElement);
+                Q_ASSERT(p.elementAt(i+2).type == QPainterPath::CurveToDataElement);
+                CGPathAddCurveToPoint(ret, 0,
+                        elm.x+off, elm.y+off,
+                        p.elementAt(i+1).x+off, p.elementAt(i+1).y+off,
+                        p.elementAt(i+2).x+off, p.elementAt(i+2).y+off);
+                i+=2;
+                break;
+            default:
+                qFatal("QCoreGraphicsPaintEngine::drawPath(), unhandled type: %d", elm.type);
+                break;
+        }
+    }
+    if(!p.isEmpty()
+            && p.elementAt(p.elementCount() - 1).x == startPt.x()
+            && p.elementAt(p.elementCount() - 1).y == startPt.y())
+        CGPathCloseSubpath(ret);
+    return ret;
+}
+
+CGColorSpaceRef QCoreGraphicsPaintEngine::m_genericColorSpace = 0;
+QHash<CGDirectDisplayID, CGColorSpaceRef> QCoreGraphicsPaintEngine::m_displayColorSpaceHash;
+bool QCoreGraphicsPaintEngine::m_postRoutineRegistered = false;
+
+CGColorSpaceRef QCoreGraphicsPaintEngine::macGenericColorSpace()
+{
+#if 0
+    if (!m_genericColorSpace) {
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4
+        if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_4) {
+            m_genericColorSpace = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB);
+        } else
+#endif
+        {
+            m_genericColorSpace = CGColorSpaceCreateDeviceRGB();
+        }
+        if (!m_postRoutineRegistered) {
+            m_postRoutineRegistered = true;
+            qAddPostRoutine(QCoreGraphicsPaintEngine::cleanUpMacColorSpaces);
+        }
+    }
+    return m_genericColorSpace;
+#else
+    // Just return the main display colorspace for the moment.
+    return macDisplayColorSpace();
+#endif
+}
+
+/*
+    Ideally, we should pass the widget in here, and use CGGetDisplaysWithRect() etc.
+    to support multiple displays correctly.
+*/
+CGColorSpaceRef QCoreGraphicsPaintEngine::macDisplayColorSpace(const QWidget *widget)
+{
+    CGColorSpaceRef colorSpace;
+
+    CGDirectDisplayID displayID;
+    CMProfileRef displayProfile = 0;
+    if (widget == 0) {
+        displayID = CGMainDisplayID();
+    } else {
+        const QRect &qrect = widget->window()->geometry();
+        CGRect rect = CGRectMake(qrect.x(), qrect.y(), qrect.width(), qrect.height());
+        CGDisplayCount throwAway;
+        CGDisplayErr dErr = CGGetDisplaysWithRect(rect, 1, &displayID, &throwAway);
+        if (dErr != kCGErrorSuccess)
+            return macDisplayColorSpace(0); // fall back on main display
+    }
+    if ((colorSpace = m_displayColorSpaceHash.value(displayID)))
+        return colorSpace;
+
+    CMError err = CMGetProfileByAVID((CMDisplayIDType)displayID, &displayProfile);
+    if (err == noErr) {
+        colorSpace = CGColorSpaceCreateWithPlatformColorSpace(displayProfile);
+    } else if (widget) {
+        return macDisplayColorSpace(0); // fall back on main display
+    }
+
+    if (colorSpace == 0)
+        colorSpace = CGColorSpaceCreateDeviceRGB();
+
+    m_displayColorSpaceHash.insert(displayID, colorSpace);
+    CMCloseProfile(displayProfile);
+    if (!m_postRoutineRegistered) {
+        m_postRoutineRegistered = true;
+        qAddPostRoutine(QCoreGraphicsPaintEngine::cleanUpMacColorSpaces);
+    }
+    return colorSpace;
+}
+
+void QCoreGraphicsPaintEngine::cleanUpMacColorSpaces()
+{
+    if (m_genericColorSpace) {
+        CFRelease(m_genericColorSpace);
+        m_genericColorSpace = 0;
+    }
+    QHash<CGDirectDisplayID, CGColorSpaceRef>::const_iterator it = m_displayColorSpaceHash.constBegin();
+    while (it != m_displayColorSpaceHash.constEnd()) {
+        if (it.value())
+            CFRelease(it.value());
+        ++it;
+    }
+    m_displayColorSpaceHash.clear();
+}
+
+void qt_mac_clip_cg(CGContextRef hd, const QRegion &rgn, CGAffineTransform *orig_xform)
+{
+    CGAffineTransform old_xform = CGAffineTransformIdentity;
+    if(orig_xform) { //setup xforms
+        old_xform = CGContextGetCTM(hd);
+        CGContextConcatCTM(hd, CGAffineTransformInvert(old_xform));
+        CGContextConcatCTM(hd, *orig_xform);
+    }
+
+    //do the clipping
+    CGContextBeginPath(hd);
+    if(rgn.isEmpty()) {
+        CGContextAddRect(hd, CGRectMake(0, 0, 0, 0));
+    } else {
+#if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5)
+        if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_5) {
+            QCFType<HIMutableShapeRef> shape = rgn.toHIMutableShape();
+            Q_ASSERT(!HIShapeIsEmpty(shape));
+            HIShapeReplacePathInCGContext(shape, hd);
+        } else
+#endif
+        {
+            QVector<QRect> rects = rgn.rects();
+            const int count = rects.size();
+            for(int i = 0; i < count; i++) {
+                const QRect &r = rects[i];
+                CGRect mac_r = CGRectMake(r.x(), r.y(), r.width(), r.height());
+                CGContextAddRect(hd, mac_r);
+            }
+        }
+
+    }
+    CGContextClip(hd);
+
+    if(orig_xform) {//reset xforms
+        CGContextConcatCTM(hd, CGAffineTransformInvert(CGContextGetCTM(hd)));
+        CGContextConcatCTM(hd, old_xform);
+    }
+}
+
+
+//pattern handling (tiling)
+#if 1
+#  define QMACPATTERN_MASK_MULTIPLIER 32
+#else
+#  define QMACPATTERN_MASK_MULTIPLIER 1
+#endif
+class QMacPattern
+{
+public:
+    QMacPattern() : as_mask(false), pdev(0), image(0) { data.bytes = 0; }
+    ~QMacPattern() { CGImageRelease(image); }
+    int width() {
+        if(image)
+            return CGImageGetWidth(image);
+        if(data.bytes)
+            return 8*QMACPATTERN_MASK_MULTIPLIER;
+        return data.pixmap.width();
+    }
+    int height() {
+        if(image)
+            return CGImageGetHeight(image);
+        if(data.bytes)
+            return 8*QMACPATTERN_MASK_MULTIPLIER;
+        return data.pixmap.height();
+    }
+
+    //input
+    QColor foreground;
+    bool as_mask;
+    struct {
+        QPixmap pixmap;
+        const uchar *bytes;
+    } data;
+    QPaintDevice *pdev;
+    //output
+    CGImageRef image;
+};
+static void qt_mac_draw_pattern(void *info, CGContextRef c)
+{
+    QMacPattern *pat = (QMacPattern*)info;
+    int w = 0, h = 0;
+    bool isBitmap = (pat->data.pixmap.depth() == 1);
+    if(!pat->image) { //lazy cache
+        if(pat->as_mask) {
+            Q_ASSERT(pat->data.bytes);
+            w = h = 8;
+#if (QMACPATTERN_MASK_MULTIPLIER == 1)
+            CGDataProviderRef provider = CGDataProviderCreateWithData(0, pat->data.bytes, w*h, 0);
+            pat->image = CGImageMaskCreate(w, h, 1, 1, 1, provider, 0, false);
+            CGDataProviderRelease(provider);
+#else
+            const int numBytes = (w*h)/sizeof(uchar);
+            uchar xor_bytes[numBytes];
+            for(int i = 0; i < numBytes; ++i)
+                xor_bytes[i] = pat->data.bytes[i] ^ 0xFF;
+            CGDataProviderRef provider = CGDataProviderCreateWithData(0, xor_bytes, w*h, 0);
+            CGImageRef swatch = CGImageMaskCreate(w, h, 1, 1, 1, provider, 0, false);
+            CGDataProviderRelease(provider);
+
+            const QColor c0(0, 0, 0, 0), c1(255, 255, 255, 255);
+            QPixmap pm(w*QMACPATTERN_MASK_MULTIPLIER, h*QMACPATTERN_MASK_MULTIPLIER);
+            pm.fill(c0);
+            CGContextRef pm_ctx = qt_mac_cg_context(&pm);
+            CGContextSetFillColorWithColor(c, cgColorForQColor(c1, pat->pdev));
+            CGRect rect = CGRectMake(0, 0, w, h);
+            for(int x = 0; x < QMACPATTERN_MASK_MULTIPLIER; ++x) {
+                rect.origin.x = x * w;
+                for(int y = 0; y < QMACPATTERN_MASK_MULTIPLIER; ++y) {
+                    rect.origin.y = y * h;
+                    qt_mac_drawCGImage(pm_ctx, &rect, swatch);
+                }
+            }
+            pat->image = qt_mac_create_imagemask(pm, pm.rect());
+            CGImageRelease(swatch);
+            CGContextRelease(pm_ctx);
+            w *= QMACPATTERN_MASK_MULTIPLIER;
+            h *= QMACPATTERN_MASK_MULTIPLIER;
+#endif
+        } else {
+            w = pat->data.pixmap.width();
+            h = pat->data.pixmap.height();
+            if (isBitmap)
+                pat->image = qt_mac_create_imagemask(pat->data.pixmap, pat->data.pixmap.rect());
+            else
+                pat->image = (CGImageRef)pat->data.pixmap.macCGHandle();
+        }
+    } else {
+        w = CGImageGetWidth(pat->image);
+        h = CGImageGetHeight(pat->image);
+    }
+
+    //draw
+    bool needRestore = false;
+    if (CGImageIsMask(pat->image)) {
+        CGContextSaveGState(c);
+        CGContextSetFillColorWithColor(c, cgColorForQColor(pat->foreground, pat->pdev));
+    }
+    CGRect rect = CGRectMake(0, 0, w, h);
+    qt_mac_drawCGImage(c, &rect, pat->image);
+    if(needRestore)
+        CGContextRestoreGState(c);
+}
+static void qt_mac_dispose_pattern(void *info)
+{
+    QMacPattern *pat = (QMacPattern*)info;
+    delete pat;
+}
+
+/*****************************************************************************
+  QCoreGraphicsPaintEngine member functions
+ *****************************************************************************/
+
+inline static QPaintEngine::PaintEngineFeatures qt_mac_cg_features()
+{
+    return QPaintEngine::PaintEngineFeatures(QPaintEngine::AllFeatures & ~QPaintEngine::PaintOutsidePaintEvent
+                                              & ~QPaintEngine::PerspectiveTransform
+                                              & ~QPaintEngine::ConicalGradientFill
+                                              & ~QPaintEngine::LinearGradientFill
+                                              & ~QPaintEngine::RadialGradientFill
+                                              & ~QPaintEngine::BrushStroke);
+}
+
+QCoreGraphicsPaintEngine::QCoreGraphicsPaintEngine()
+: QPaintEngine(*(new QCoreGraphicsPaintEnginePrivate), qt_mac_cg_features())
+{
+}
+
+QCoreGraphicsPaintEngine::QCoreGraphicsPaintEngine(QPaintEnginePrivate &dptr)
+: QPaintEngine(dptr, qt_mac_cg_features())
+{
+}
+
+QCoreGraphicsPaintEngine::~QCoreGraphicsPaintEngine()
+{
+}
+
+bool
+QCoreGraphicsPaintEngine::begin(QPaintDevice *pdev)
+{
+    Q_D(QCoreGraphicsPaintEngine);
+    if(isActive()) {                         // already active painting
+        qWarning("QCoreGraphicsPaintEngine::begin: Painter already active");
+        return false;
+    }
+
+    //initialization
+    d->pdev = pdev;
+    d->complexXForm = false;
+    d->cosmeticPen = QCoreGraphicsPaintEnginePrivate::CosmeticSetPenWidth;
+    d->cosmeticPenSize = 1;
+    d->current.clipEnabled = false;
+    d->pixelSize = QPoint(1,1);
+    d->hd = qt_mac_cg_context(pdev);
+    if(d->hd) {
+        d->saveGraphicsState();
+        d->orig_xform = CGContextGetCTM(d->hd);
+        if (d->shading) {
+            CGShadingRelease(d->shading);
+            d->shading = 0;
+        }
+        d->setClip(0);  //clear the context's clipping
+    }
+
+    setActive(true);
+
+    if(d->pdev->devType() == QInternal::Widget) {                    // device is a widget
+        QWidget *w = (QWidget*)d->pdev;
+        bool unclipped = w->testAttribute(Qt::WA_PaintUnclipped);
+
+        if((w->windowType() == Qt::Desktop)) {
+            if(!unclipped)
+                qWarning("QCoreGraphicsPaintEngine::begin: Does not support clipped desktop on Mac OS X");
+            // ## need to do [qt_mac_window_for(w) makeKeyAndOrderFront]; (need to rename the file)
+        } else if(unclipped) {
+            qWarning("QCoreGraphicsPaintEngine::begin: Does not support unclipped painting");
+        }
+    } else if(d->pdev->devType() == QInternal::Pixmap) {             // device is a pixmap
+        QPixmap *pm = (QPixmap*)d->pdev;
+        if(pm->isNull()) {
+            qWarning("QCoreGraphicsPaintEngine::begin: Cannot paint null pixmap");
+            end();
+            return false;
+        }
+    }
+
+    setDirty(QPaintEngine::DirtyPen);
+    setDirty(QPaintEngine::DirtyBrush);
+    setDirty(QPaintEngine::DirtyBackground);
+    setDirty(QPaintEngine::DirtyHints);
+    return true;
+}
+
+bool
+QCoreGraphicsPaintEngine::end()
+{
+    Q_D(QCoreGraphicsPaintEngine);
+    setActive(false);
+    if(d->pdev->devType() == QInternal::Widget && static_cast<QWidget*>(d->pdev)->windowType() == Qt::Desktop) {
+#ifndef QT_MAC_USE_COCOA
+        HideWindow(qt_mac_window_for(static_cast<QWidget*>(d->pdev)));
+#else
+//        // ### need to do [qt_mac_window_for(static_cast<QWidget *>(d->pdev)) orderOut]; (need to rename)
+#endif
+
+	}
+    if(d->shading) {
+        CGShadingRelease(d->shading);
+        d->shading = 0;
+    }
+    d->pdev = 0;
+    if(d->hd) {
+        d->restoreGraphicsState();
+        CGContextSynchronize(d->hd);
+        CGContextRelease(d->hd);
+        d->hd = 0;
+    }
+    return true;
+}
+
+void
+QCoreGraphicsPaintEngine::updateState(const QPaintEngineState &state)
+{
+    Q_D(QCoreGraphicsPaintEngine);
+    QPaintEngine::DirtyFlags flags = state.state();
+
+    if (flags & DirtyTransform)
+        updateMatrix(state.transform());
+
+    if (flags & DirtyClipEnabled) {
+        if (state.isClipEnabled())
+            updateClipPath(painter()->clipPath(), Qt::ReplaceClip);
+        else
+            updateClipPath(QPainterPath(), Qt::NoClip);
+    }
+
+    if (flags & DirtyClipPath) {
+        updateClipPath(state.clipPath(), state.clipOperation());
+    } else if (flags & DirtyClipRegion) {
+        updateClipRegion(state.clipRegion(), state.clipOperation());
+    }
+
+    // If the clip has changed we need to update all other states
+    // too, since they are included in the system context on OSX,
+    // and changing the clip resets that context back to scratch.
+    if (flags & (DirtyClipPath | DirtyClipRegion | DirtyClipEnabled))
+        flags |= AllDirty;
+
+    if (flags & DirtyPen)
+        updatePen(state.pen());
+    if (flags & (DirtyBrush|DirtyBrushOrigin))
+        updateBrush(state.brush(), state.brushOrigin());
+    if (flags & DirtyFont)
+        updateFont(state.font());
+    if (flags & DirtyOpacity)
+        updateOpacity(state.opacity());
+    if (flags & DirtyHints)
+        updateRenderHints(state.renderHints());
+    if (flags & DirtyCompositionMode)
+        updateCompositionMode(state.compositionMode());
+
+    if (flags & (DirtyPen | DirtyTransform)) {
+        if (!d->current.pen.isCosmetic()) {
+            d->cosmeticPen = QCoreGraphicsPaintEnginePrivate::CosmeticNone;
+        } else if (d->current.transform.m11() < d->current.transform.m22()-1.0 ||
+                  d->current.transform.m11() > d->current.transform.m22()+1.0) {
+            d->cosmeticPen = QCoreGraphicsPaintEnginePrivate::CosmeticTransformPath;
+            d->cosmeticPenSize = d->adjustPenWidth(d->current.pen.widthF());
+            if (!d->cosmeticPenSize)
+                d->cosmeticPenSize = 1.0;
+        } else {
+            d->cosmeticPen = QCoreGraphicsPaintEnginePrivate::CosmeticSetPenWidth;
+            static const float sqrt2 = sqrt(2);
+            qreal width = d->current.pen.widthF();
+            if (!width)
+                width = 1;
+            d->cosmeticPenSize = sqrt(pow(d->pixelSize.y(), 2) + pow(d->pixelSize.x(), 2)) / sqrt2 * width;
+        }
+    }
+}
+
+void
+QCoreGraphicsPaintEngine::updatePen(const QPen &pen)
+{
+    Q_D(QCoreGraphicsPaintEngine);
+    Q_ASSERT(isActive());
+    d->current.pen = pen;
+    d->setStrokePen(pen);
+}
+
+void
+QCoreGraphicsPaintEngine::updateBrush(const QBrush &brush, const QPointF &brushOrigin)
+{
+    Q_D(QCoreGraphicsPaintEngine);
+    Q_ASSERT(isActive());
+    d->current.brush = brush;
+
+#ifdef QT_MAC_USE_NATIVE_GRADIENTS
+    // Quartz supports only pad spread
+    if (const QGradient *gradient = brush.gradient()) {
+        if (drawGradientNatively(gradient)) {
+            gccaps |= QPaintEngine::LinearGradientFill | QPaintEngine::RadialGradientFill;
+        } else {
+            gccaps &= ~(QPaintEngine::LinearGradientFill | QPaintEngine::RadialGradientFill);
+        }
+    }
+#endif
+
+    if (d->shading) {
+        CGShadingRelease(d->shading);
+        d->shading = 0;
+    }
+    d->setFillBrush(brushOrigin);
+}
+
+void
+QCoreGraphicsPaintEngine::updateOpacity(qreal opacity)
+{
+    Q_D(QCoreGraphicsPaintEngine);
+    CGContextSetAlpha(d->hd, opacity);
+}
+
+void
+QCoreGraphicsPaintEngine::updateFont(const QFont &)
+{
+    Q_D(QCoreGraphicsPaintEngine);
+    Q_ASSERT(isActive());
+    updatePen(d->current.pen);
+}
+
+void
+QCoreGraphicsPaintEngine::updateMatrix(const QTransform &transform)
+{
+    Q_D(QCoreGraphicsPaintEngine);
+    Q_ASSERT(isActive());
+
+    if (qt_is_nan(transform.m11()) || qt_is_nan(transform.m12()) || qt_is_nan(transform.m13())
+	|| qt_is_nan(transform.m21()) || qt_is_nan(transform.m22()) || qt_is_nan(transform.m23())
+	|| qt_is_nan(transform.m31()) || qt_is_nan(transform.m32()) || qt_is_nan(transform.m33()))
+	return;
+
+    d->current.transform = transform;
+    d->setTransform(transform.isIdentity() ? 0 : &transform);
+    d->complexXForm = (transform.m11() != 1 || transform.m22() != 1
+            || transform.m12() != 0 || transform.m21() != 0);
+    d->pixelSize = d->devicePixelSize(d->hd);
+}
+
+void
+QCoreGraphicsPaintEngine::updateClipPath(const QPainterPath &p, Qt::ClipOperation op)
+{
+    Q_D(QCoreGraphicsPaintEngine);
+    Q_ASSERT(isActive());
+    if(op == Qt::NoClip) {
+        if(d->current.clipEnabled) {
+            d->current.clipEnabled = false;
+            d->current.clip = QRegion();
+            d->setClip(0);
+        }
+    } else {
+        if(!d->current.clipEnabled)
+            op = Qt::ReplaceClip;
+        d->current.clipEnabled = true;
+        QRegion clipRegion(p.toFillPolygon().toPolygon(), p.fillRule());
+        if(op == Qt::ReplaceClip) {
+            d->current.clip = clipRegion;
+            d->setClip(0);
+            if(p.isEmpty()) {
+                CGRect rect = CGRectMake(0, 0, 0, 0);
+                CGContextClipToRect(d->hd, rect);
+            } else {
+                CGMutablePathRef path = qt_mac_compose_path(p);
+                CGContextBeginPath(d->hd);
+                CGContextAddPath(d->hd, path);
+                if(p.fillRule() == Qt::WindingFill)
+                    CGContextClip(d->hd);
+                else
+                    CGContextEOClip(d->hd);
+                CGPathRelease(path);
+            }
+        } else if(op == Qt::IntersectClip) {
+            d->current.clip = d->current.clip.intersected(clipRegion);
+            d->setClip(&d->current.clip);
+        } else if(op == Qt::UniteClip) {
+            d->current.clip = d->current.clip.united(clipRegion);
+            d->setClip(&d->current.clip);
+        }
+    }
+}
+
+void
+QCoreGraphicsPaintEngine::updateClipRegion(const QRegion &clipRegion, Qt::ClipOperation op)
+{
+    Q_D(QCoreGraphicsPaintEngine);
+    Q_ASSERT(isActive());
+    if(op == Qt::NoClip) {
+        d->current.clipEnabled = false;
+        d->current.clip = QRegion();
+        d->setClip(0);
+    } else {
+        if(!d->current.clipEnabled)
+            op = Qt::ReplaceClip;
+        d->current.clipEnabled = true;
+        if(op == Qt::IntersectClip)
+            d->current.clip = d->current.clip.intersected(clipRegion);
+        else if(op == Qt::ReplaceClip)
+            d->current.clip = clipRegion;
+        else if(op == Qt::UniteClip)
+            d->current.clip = d->current.clip.united(clipRegion);
+        d->setClip(&d->current.clip);
+    }
+}
+
+void
+QCoreGraphicsPaintEngine::drawPath(const QPainterPath &p)
+{
+    Q_D(QCoreGraphicsPaintEngine);
+    Q_ASSERT(isActive());
+
+    if (state->compositionMode() == QPainter::CompositionMode_Destination)
+        return;
+
+    CGMutablePathRef path = qt_mac_compose_path(p);
+    uchar ops = QCoreGraphicsPaintEnginePrivate::CGStroke;
+    if(p.fillRule() == Qt::WindingFill)
+        ops |= QCoreGraphicsPaintEnginePrivate::CGFill;
+    else
+        ops |= QCoreGraphicsPaintEnginePrivate::CGEOFill;
+    CGContextBeginPath(d->hd);
+    d->drawPath(ops, path);
+    CGPathRelease(path);
+}
+
+void
+QCoreGraphicsPaintEngine::drawRects(const QRectF *rects, int rectCount)
+{
+    Q_D(QCoreGraphicsPaintEngine);
+    Q_ASSERT(isActive());
+
+    if (state->compositionMode() == QPainter::CompositionMode_Destination)
+        return;
+
+    for (int i=0; i<rectCount; ++i) {
+        QRectF r = rects[i];
+
+        CGMutablePathRef path = CGPathCreateMutable();
+        CGPathAddRect(path, 0, qt_mac_compose_rect(r));
+        d->drawPath(QCoreGraphicsPaintEnginePrivate::CGFill|QCoreGraphicsPaintEnginePrivate::CGStroke,
+                path);
+        CGPathRelease(path);
+    }
+}
+
+void
+QCoreGraphicsPaintEngine::drawPoints(const QPointF *points, int pointCount)
+{
+    Q_D(QCoreGraphicsPaintEngine);
+    Q_ASSERT(isActive());
+
+    if (state->compositionMode() == QPainter::CompositionMode_Destination)
+        return;
+
+    if (d->current.pen.capStyle() == Qt::FlatCap)
+        CGContextSetLineCap(d->hd, kCGLineCapSquare);
+
+    CGMutablePathRef path = CGPathCreateMutable();
+    for(int i=0; i < pointCount; i++) {
+        float x = points[i].x(), y = points[i].y();
+        CGPathMoveToPoint(path, 0, x, y);
+        CGPathAddLineToPoint(path, 0, x+0.001, y);
+    }
+
+    bool doRestore = false;
+    if(d->cosmeticPen == QCoreGraphicsPaintEnginePrivate::CosmeticNone && !(state->renderHints() & QPainter::Antialiasing)) {
+        //we don't want adjusted pens for point rendering
+        doRestore = true;
+        d->saveGraphicsState();
+        CGContextSetLineWidth(d->hd, d->current.pen.widthF());
+    }
+    d->drawPath(QCoreGraphicsPaintEnginePrivate::CGStroke, path);
+    if (doRestore)
+        d->restoreGraphicsState();
+    CGPathRelease(path);
+    if (d->current.pen.capStyle() == Qt::FlatCap)
+        CGContextSetLineCap(d->hd, kCGLineCapButt);
+}
+
+void
+QCoreGraphicsPaintEngine::drawEllipse(const QRectF &r)
+{
+    Q_D(QCoreGraphicsPaintEngine);
+    Q_ASSERT(isActive());
+
+    if (state->compositionMode() == QPainter::CompositionMode_Destination)
+        return;
+
+    CGMutablePathRef path = CGPathCreateMutable();
+    CGAffineTransform transform = CGAffineTransformMakeScale(r.width() / r.height(), 1);
+    CGPathAddArc(path, &transform,(r.x() + (r.width() / 2)) / (r.width() / r.height()),
+            r.y() + (r.height() / 2), r.height() / 2, 0, (2 * M_PI), false);
+    d->drawPath(QCoreGraphicsPaintEnginePrivate::CGFill | QCoreGraphicsPaintEnginePrivate::CGStroke,
+            path);
+    CGPathRelease(path);
+}
+
+void
+QCoreGraphicsPaintEngine::drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode)
+{
+    Q_D(QCoreGraphicsPaintEngine);
+    Q_ASSERT(isActive());
+
+    if (state->compositionMode() == QPainter::CompositionMode_Destination)
+        return;
+
+    CGMutablePathRef path = CGPathCreateMutable();
+    CGPathMoveToPoint(path, 0, points[0].x(), points[0].y());
+    for(int x = 1; x < pointCount; ++x)
+        CGPathAddLineToPoint(path, 0, points[x].x(), points[x].y());
+    if(mode != PolylineMode && points[0] != points[pointCount-1])
+        CGPathAddLineToPoint(path, 0, points[0].x(), points[0].y());
+    uint op = QCoreGraphicsPaintEnginePrivate::CGStroke;
+    if (mode != PolylineMode)
+        op |= mode == OddEvenMode ? QCoreGraphicsPaintEnginePrivate::CGEOFill
+            : QCoreGraphicsPaintEnginePrivate::CGFill;
+    d->drawPath(op, path);
+    CGPathRelease(path);
+}
+
+void
+QCoreGraphicsPaintEngine::drawLines(const QLineF *lines, int lineCount)
+{
+    Q_D(QCoreGraphicsPaintEngine);
+    Q_ASSERT(isActive());
+
+    if (state->compositionMode() == QPainter::CompositionMode_Destination)
+        return;
+
+    CGMutablePathRef path = CGPathCreateMutable();
+    for(int i = 0; i < lineCount; i++) {
+        const QPointF start = lines[i].p1(), end = lines[i].p2();
+        CGPathMoveToPoint(path, 0, start.x(), start.y());
+        CGPathAddLineToPoint(path, 0, end.x(), end.y());
+    }
+    d->drawPath(QCoreGraphicsPaintEnginePrivate::CGStroke, path);
+    CGPathRelease(path);
+}
+
+void QCoreGraphicsPaintEngine::drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr)
+{
+    Q_D(QCoreGraphicsPaintEngine);
+    Q_ASSERT(isActive());
+
+    if (state->compositionMode() == QPainter::CompositionMode_Destination)
+        return;
+
+    if(pm.isNull())
+        return;
+
+    bool differentSize = (QRectF(0, 0, pm.width(), pm.height()) != sr), doRestore = false;
+    CGRect rect = CGRectMake(r.x(), r.y(), r.width(), r.height());
+    QCFType<CGImageRef> image;
+    bool isBitmap = (pm.depth() == 1);
+    if (isBitmap) {
+        doRestore = true;
+        d->saveGraphicsState();
+
+        const QColor &col = d->current.pen.color();
+        CGContextSetFillColorWithColor(d->hd, cgColorForQColor(col, d->pdev));
+        image = qt_mac_create_imagemask(pm, sr);
+    } else if (differentSize) {
+        QCFType<CGImageRef> img = pm.toMacCGImageRef();
+        image = CGImageCreateWithImageInRect(img, CGRectMake(qRound(sr.x()), qRound(sr.y()), qRound(sr.width()), qRound(sr.height())));
+    } else {
+        image = (CGImageRef)pm.macCGHandle();
+    }
+    qt_mac_drawCGImage(d->hd, &rect, image);
+    if (doRestore)
+        d->restoreGraphicsState();
+}
+
+static void drawImageReleaseData (void *info, const void *, size_t)
+{
+    delete static_cast<QImage *>(info);
+}
+
+CGImageRef qt_mac_createCGImageFromQImage(const QImage &img, const QImage **imagePtr = 0)
+{
+    QImage *image;
+    if (img.depth() != 32)
+        image = new QImage(img.convertToFormat(QImage::Format_ARGB32_Premultiplied));
+    else
+        image = new QImage(img);
+
+    uint cgflags = kCGImageAlphaNone;
+    switch (image->format()) {
+    case QImage::Format_ARGB32_Premultiplied:
+        cgflags = kCGImageAlphaPremultipliedFirst;
+        break;
+    case QImage::Format_ARGB32:
+        cgflags = kCGImageAlphaFirst;
+        break;
+    case QImage::Format_RGB32:
+        cgflags = kCGImageAlphaNoneSkipFirst;
+    default:
+        break;
+    }
+#if defined(kCGBitmapByteOrder32Host) //only needed because CGImage.h added symbols in the minor version
+    cgflags |= kCGBitmapByteOrder32Host;
+#endif
+    QCFType<CGDataProviderRef> dataProvider = CGDataProviderCreateWithData(image,
+                                                          static_cast<const QImage *>(image)->bits(),
+                                                          image->byteCount(),
+                                                          drawImageReleaseData);
+    if (imagePtr)
+        *imagePtr = image;
+    return CGImageCreate(image->width(), image->height(), 8, 32,
+                                        image->bytesPerLine(),
+                                        QCoreGraphicsPaintEngine::macGenericColorSpace(),
+                                        cgflags, dataProvider, 0, false, kCGRenderingIntentDefault);
+
+}
+
+void QCoreGraphicsPaintEngine::drawImage(const QRectF &r, const QImage &img, const QRectF &sr,
+                                         Qt::ImageConversionFlags flags)
+{
+    Q_D(QCoreGraphicsPaintEngine);
+    Q_UNUSED(flags);
+    Q_ASSERT(isActive());
+
+    if (img.isNull() || state->compositionMode() == QPainter::CompositionMode_Destination)
+        return;
+
+    const QImage *image;
+    QCFType<CGImageRef> cgimage = qt_mac_createCGImageFromQImage(img, &image);
+    CGRect rect = CGRectMake(r.x(), r.y(), r.width(), r.height());
+    if (QRectF(0, 0, img.width(), img.height()) != sr)
+        cgimage = CGImageCreateWithImageInRect(cgimage, CGRectMake(sr.x(), sr.y(),
+                                               sr.width(), sr.height()));
+    qt_mac_drawCGImage(d->hd, &rect, cgimage);
+}
+
+void QCoreGraphicsPaintEngine::initialize()
+{
+}
+
+void QCoreGraphicsPaintEngine::cleanup()
+{
+}
+
+CGContextRef
+QCoreGraphicsPaintEngine::handle() const
+{
+    return d_func()->hd;
+}
+
+void
+QCoreGraphicsPaintEngine::drawTiledPixmap(const QRectF &r, const QPixmap &pixmap,
+        const QPointF &p)
+{
+    Q_D(QCoreGraphicsPaintEngine);
+    Q_ASSERT(isActive());
+
+    if (state->compositionMode() == QPainter::CompositionMode_Destination)
+        return;
+
+    //save the old state
+    d->saveGraphicsState();
+
+    //setup the pattern
+    QMacPattern *qpattern = new QMacPattern;
+    qpattern->data.pixmap = pixmap;
+    qpattern->foreground = d->current.pen.color();
+    qpattern->pdev = d->pdev;
+    CGPatternCallbacks callbks;
+    callbks.version = 0;
+    callbks.drawPattern = qt_mac_draw_pattern;
+    callbks.releaseInfo = qt_mac_dispose_pattern;
+    const int width = qpattern->width(), height = qpattern->height();
+    CGAffineTransform trans = CGContextGetCTM(d->hd);
+    CGPatternRef pat = CGPatternCreate(qpattern, CGRectMake(0, 0, width, height),
+            trans, width, height,
+            kCGPatternTilingNoDistortion, true, &callbks);
+    CGColorSpaceRef cs = CGColorSpaceCreatePattern(0);
+    CGContextSetFillColorSpace(d->hd, cs);
+    CGFloat component = 1.0; //just one
+    CGContextSetFillPattern(d->hd, pat, &component);
+    CGSize phase = CGSizeApplyAffineTransform(CGSizeMake(-(p.x()-r.x()), -(p.y()-r.y())), trans);
+    CGContextSetPatternPhase(d->hd, phase);
+
+    //fill the rectangle
+    CGRect mac_rect = CGRectMake(r.x(), r.y(), r.width(), r.height());
+    CGContextFillRect(d->hd, mac_rect);
+
+    //restore the state
+    d->restoreGraphicsState();
+    //cleanup
+    CGColorSpaceRelease(cs);
+    CGPatternRelease(pat);
+}
+
+void QCoreGraphicsPaintEngine::drawTextItem(const QPointF &pos, const QTextItem &item)
+{
+    Q_D(QCoreGraphicsPaintEngine);
+    if (d->current.transform.type() == QTransform::TxProject
+#ifndef QMAC_NATIVE_GRADIENTS
+        || painter()->pen().brush().gradient()  //Just let the base engine "emulate" the gradient
+#endif
+        ) {
+        QPaintEngine::drawTextItem(pos, item);
+        return;
+    }
+
+    if (state->compositionMode() == QPainter::CompositionMode_Destination)
+        return;
+
+    const QTextItemInt &ti = static_cast<const QTextItemInt &>(item);
+
+    QPen oldPen = painter()->pen();
+    QBrush oldBrush = painter()->brush();
+    QPointF oldBrushOrigin = painter()->brushOrigin();
+    updatePen(Qt::NoPen);
+    updateBrush(oldPen.brush(), QPointF(0, 0));
+
+    Q_ASSERT(type() == QPaintEngine::CoreGraphics);
+
+    QFontEngine *fe = ti.fontEngine;
+
+    const bool textAA = state->renderHints() & QPainter::TextAntialiasing && fe->fontDef.pointSize > qt_antialiasing_threshold && !(fe->fontDef.styleStrategy & QFont::NoAntialias);
+    const bool lineAA = state->renderHints() & QPainter::Antialiasing;
+    if(textAA != lineAA)
+        CGContextSetShouldAntialias(d->hd, textAA);
+
+    if (ti.glyphs.numGlyphs) {
+        switch (fe->type()) {
+        case QFontEngine::Mac:
+#ifdef QT_MAC_USE_COCOA
+            static_cast<QCoreTextFontEngine *>(fe)->draw(d->hd, pos.x(), pos.y(), ti, paintDevice()->height());
+#else
+            static_cast<QFontEngineMac *>(fe)->draw(d->hd, pos.x(), pos.y(), ti, paintDevice()->height());
+#endif
+            break;
+        case QFontEngine::Box:
+            d->drawBoxTextItem(pos, ti);
+            break;
+        default:
+            break;
+        }
+    }
+
+    if(textAA != lineAA)
+        CGContextSetShouldAntialias(d->hd, !textAA);
+
+    updatePen(oldPen);
+    updateBrush(oldBrush, oldBrushOrigin);
+}
+
+QPainter::RenderHints
+QCoreGraphicsPaintEngine::supportedRenderHints() const
+{
+    return QPainter::RenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing | QPainter::SmoothPixmapTransform);
+}
+enum CGCompositeMode {
+        kCGCompositeModeClear            = 0,
+        kCGCompositeModeCopy             = 1,
+        kCGCompositeModeSourceOver       = 2,
+        kCGCompositeModeSourceIn         = 3,
+        kCGCompositeModeSourceOut        = 4,
+        kCGCompositeModeSourceAtop       = 5,
+        kCGCompositeModeDestinationOver  = 6,
+        kCGCompositeModeDestinationIn    = 7,
+        kCGCompositeModeDestinationOut   = 8,
+        kCGCompositeModeDestinationAtop  = 9,
+        kCGCompositeModeXOR              = 10,
+        kCGCompositeModePlusDarker       = 11, // (max (0, (1-d) + (1-s)))
+        kCGCompositeModePlusLighter      = 12, // (min (1, s + d))
+    };
+extern "C" {
+    extern void CGContextSetCompositeOperation(CGContextRef, int);
+} // private function, but is in all versions of OS X.
+void
+QCoreGraphicsPaintEngine::updateCompositionMode(QPainter::CompositionMode mode)
+{
+#if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5)
+    if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_5) {
+        int cg_mode = kCGBlendModeNormal;
+        switch(mode) {
+        case QPainter::CompositionMode_Multiply:
+            cg_mode = kCGBlendModeMultiply;
+            break;
+        case QPainter::CompositionMode_Screen:
+            cg_mode = kCGBlendModeScreen;
+            break;
+        case QPainter::CompositionMode_Overlay:
+            cg_mode = kCGBlendModeOverlay;
+            break;
+        case QPainter::CompositionMode_Darken:
+            cg_mode = kCGBlendModeDarken;
+            break;
+        case QPainter::CompositionMode_Lighten:
+            cg_mode = kCGBlendModeLighten;
+            break;
+        case QPainter::CompositionMode_ColorDodge:
+            cg_mode = kCGBlendModeColorDodge;
+            break;
+        case QPainter::CompositionMode_ColorBurn:
+            cg_mode = kCGBlendModeColorBurn;
+            break;
+        case QPainter::CompositionMode_HardLight:
+            cg_mode = kCGBlendModeHardLight;
+            break;
+        case QPainter::CompositionMode_SoftLight:
+            cg_mode = kCGBlendModeSoftLight;
+            break;
+        case QPainter::CompositionMode_Difference:
+            cg_mode = kCGBlendModeDifference;
+            break;
+        case QPainter::CompositionMode_Exclusion:
+            cg_mode = kCGBlendModeExclusion;
+            break;
+        case QPainter::CompositionMode_Plus:
+            cg_mode = kCGBlendModePlusLighter;
+            break;
+        case QPainter::CompositionMode_SourceOver:
+            cg_mode = kCGBlendModeNormal;
+            break;
+        case QPainter::CompositionMode_DestinationOver:
+            cg_mode = kCGBlendModeDestinationOver;
+            break;
+        case QPainter::CompositionMode_Clear:
+            cg_mode = kCGBlendModeClear;
+            break;
+        case QPainter::CompositionMode_Source:
+            cg_mode = kCGBlendModeCopy;
+            break;
+        case QPainter::CompositionMode_Destination:
+            cg_mode = -1;
+            break;
+        case QPainter::CompositionMode_SourceIn:
+            cg_mode = kCGBlendModeSourceIn;
+            break;
+        case QPainter::CompositionMode_DestinationIn:
+            cg_mode = kCGCompositeModeDestinationIn;
+            break;
+        case QPainter::CompositionMode_SourceOut:
+            cg_mode = kCGBlendModeSourceOut;
+            break;
+        case QPainter::CompositionMode_DestinationOut:
+            cg_mode = kCGBlendModeDestinationOver;
+            break;
+        case QPainter::CompositionMode_SourceAtop:
+            cg_mode = kCGBlendModeSourceAtop;
+            break;
+        case QPainter::CompositionMode_DestinationAtop:
+            cg_mode = kCGBlendModeDestinationAtop;
+            break;
+        case QPainter::CompositionMode_Xor:
+            cg_mode = kCGBlendModeXOR;
+            break;
+        default:
+            break;
+        }
+        if (cg_mode > -1) {
+            CGContextSetBlendMode(d_func()->hd, CGBlendMode(cg_mode));
+        }
+    } else
+#endif
+    // The standard porter duff ops.
+    if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_3
+            && mode <= QPainter::CompositionMode_Xor) {
+        int cg_mode = kCGCompositeModeCopy;
+        switch (mode) {
+        case QPainter::CompositionMode_SourceOver:
+            cg_mode = kCGCompositeModeSourceOver;
+            break;
+        case QPainter::CompositionMode_DestinationOver:
+            cg_mode = kCGCompositeModeDestinationOver;
+            break;
+        case QPainter::CompositionMode_Clear:
+            cg_mode = kCGCompositeModeClear;
+            break;
+        default:
+            qWarning("QCoreGraphicsPaintEngine: Unhandled composition mode %d", (int)mode);
+            break;
+        case QPainter::CompositionMode_Source:
+            cg_mode = kCGCompositeModeCopy;
+            break;
+        case QPainter::CompositionMode_Destination:
+            cg_mode = CGCompositeMode(-1);
+            break;
+        case QPainter::CompositionMode_SourceIn:
+            cg_mode = kCGCompositeModeSourceIn;
+            break;
+        case QPainter::CompositionMode_DestinationIn:
+            cg_mode = kCGCompositeModeDestinationIn;
+            break;
+        case QPainter::CompositionMode_SourceOut:
+            cg_mode = kCGCompositeModeSourceOut;
+            break;
+        case QPainter::CompositionMode_DestinationOut:
+            cg_mode = kCGCompositeModeDestinationOut;
+            break;
+        case QPainter::CompositionMode_SourceAtop:
+            cg_mode = kCGCompositeModeSourceAtop;
+            break;
+        case QPainter::CompositionMode_DestinationAtop:
+            cg_mode = kCGCompositeModeDestinationAtop;
+            break;
+        case QPainter::CompositionMode_Xor:
+            cg_mode = kCGCompositeModeXOR;
+            break;
+        }
+        if (cg_mode > -1)
+            CGContextSetCompositeOperation(d_func()->hd, CGCompositeMode(cg_mode));
+    } else {
+#if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4)
+        bool needPrivateAPI = false;
+        if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_4) {
+            int cg_mode = kCGBlendModeNormal;
+            switch (mode) {
+            case QPainter::CompositionMode_Multiply:
+                cg_mode = kCGBlendModeMultiply;
+                break;
+            case QPainter::CompositionMode_Screen:
+                cg_mode = kCGBlendModeScreen;
+                break;
+            case QPainter::CompositionMode_Overlay:
+                cg_mode = kCGBlendModeOverlay;
+                break;
+            case QPainter::CompositionMode_Darken:
+                cg_mode = kCGBlendModeDarken;
+                break;
+            case QPainter::CompositionMode_Lighten:
+                cg_mode = kCGBlendModeLighten;
+                break;
+            case QPainter::CompositionMode_ColorDodge:
+                cg_mode = kCGBlendModeColorDodge;
+                break;
+            case QPainter::CompositionMode_ColorBurn:
+                cg_mode = kCGBlendModeColorBurn;
+                break;
+            case QPainter::CompositionMode_HardLight:
+                cg_mode = kCGBlendModeHardLight;
+                break;
+            case QPainter::CompositionMode_SoftLight:
+                cg_mode = kCGBlendModeSoftLight;
+                break;
+            case QPainter::CompositionMode_Difference:
+                cg_mode = kCGBlendModeDifference;
+                break;
+            case QPainter::CompositionMode_Exclusion:
+                cg_mode = kCGBlendModeExclusion;
+                break;
+            case QPainter::CompositionMode_Plus:
+                needPrivateAPI = true;
+                cg_mode = kCGCompositeModePlusLighter;
+                break;
+            default:
+                break;
+            }
+            if (!needPrivateAPI)
+                CGContextSetBlendMode(d_func()->hd, CGBlendMode(cg_mode));
+            else
+                CGContextSetCompositeOperation(d_func()->hd, CGCompositeMode(cg_mode));
+        }
+#endif
+    }
+}
+
+void
+QCoreGraphicsPaintEngine::updateRenderHints(QPainter::RenderHints hints)
+{
+    Q_D(QCoreGraphicsPaintEngine);
+    CGContextSetShouldAntialias(d->hd, hints & QPainter::Antialiasing);
+    static const CGFloat ScaleFactor = qt_mac_get_scalefactor();
+    if (ScaleFactor > 1.) {
+        CGContextSetInterpolationQuality(d->hd, kCGInterpolationHigh);
+    } else {
+        CGContextSetInterpolationQuality(d->hd, (hints & QPainter::SmoothPixmapTransform) ?
+                                         kCGInterpolationHigh : kCGInterpolationNone);
+    }
+    bool textAntialiasing = (hints & QPainter::TextAntialiasing) == QPainter::TextAntialiasing;
+    if (!textAntialiasing || d->disabledSmoothFonts) {
+        d->disabledSmoothFonts = !textAntialiasing;
+        CGContextSetShouldSmoothFonts(d->hd, textAntialiasing);
+    }
+}
+
+/*
+    Returns the size of one device pixel in user-space coordinates.
+*/
+QPointF QCoreGraphicsPaintEnginePrivate::devicePixelSize(CGContextRef)
+{
+    QPointF p1 = current.transform.inverted().map(QPointF(0, 0));
+    QPointF p2 = current.transform.inverted().map(QPointF(1, 1));
+    return QPointF(qAbs(p2.x() - p1.x()), qAbs(p2.y() - p1.y()));
+}
+
+/*
+    Adjusts the pen width so we get correct line widths in the
+    non-transformed, aliased case.
+*/
+float QCoreGraphicsPaintEnginePrivate::adjustPenWidth(float penWidth)
+{
+    Q_Q(QCoreGraphicsPaintEngine);
+    float ret = penWidth;
+    if (!complexXForm && !(q->state->renderHints() & QPainter::Antialiasing)) {
+        if (penWidth < 2)
+            ret = 1;
+        else if (penWidth < 3)
+            ret = 1.5;
+        else
+            ret = penWidth -1;
+    }
+    return ret;
+}
+
+void
+QCoreGraphicsPaintEnginePrivate::setStrokePen(const QPen &pen)
+{
+    //pencap
+    CGLineCap cglinecap = kCGLineCapButt;
+    if(pen.capStyle() == Qt::SquareCap)
+        cglinecap = kCGLineCapSquare;
+    else if(pen.capStyle() == Qt::RoundCap)
+        cglinecap = kCGLineCapRound;
+    CGContextSetLineCap(hd, cglinecap);
+    CGContextSetLineWidth(hd, adjustPenWidth(pen.widthF()));
+
+    //join
+    CGLineJoin cglinejoin = kCGLineJoinMiter;
+    if(pen.joinStyle() == Qt::BevelJoin)
+        cglinejoin = kCGLineJoinBevel;
+    else if(pen.joinStyle() == Qt::RoundJoin)
+        cglinejoin = kCGLineJoinRound;
+    CGContextSetLineJoin(hd, cglinejoin);
+//    CGContextSetMiterLimit(hd, pen.miterLimit());
+
+    //pen style
+    QVector<CGFloat> linedashes;
+    if(pen.style() == Qt::CustomDashLine) {
+        QVector<qreal> customs = pen.dashPattern();
+        for(int i = 0; i < customs.size(); ++i)
+            linedashes.append(customs.at(i));
+    } else if(pen.style() == Qt::DashLine) {
+        linedashes.append(4);
+        linedashes.append(2);
+    } else if(pen.style() == Qt::DotLine) {
+        linedashes.append(1);
+        linedashes.append(2);
+    } else if(pen.style() == Qt::DashDotLine) {
+        linedashes.append(4);
+        linedashes.append(2);
+        linedashes.append(1);
+        linedashes.append(2);
+    } else if(pen.style() == Qt::DashDotDotLine) {
+        linedashes.append(4);
+        linedashes.append(2);
+        linedashes.append(1);
+        linedashes.append(2);
+        linedashes.append(1);
+        linedashes.append(2);
+    }
+    const CGFloat cglinewidth = pen.widthF() <= 0.0f ? 1.0f : float(pen.widthF());
+    for(int i = 0; i < linedashes.size(); ++i) {
+        linedashes[i] *= cglinewidth;
+        if(cglinewidth < 3 && (cglinecap == kCGLineCapSquare || cglinecap == kCGLineCapRound)) {
+            if((i%2))
+                linedashes[i] += cglinewidth/2;
+            else
+                linedashes[i] -= cglinewidth/2;
+        }
+    }
+    CGContextSetLineDash(hd, pen.dashOffset() * cglinewidth, linedashes.data(), linedashes.size());
+
+    // color
+    CGContextSetStrokeColorWithColor(hd, cgColorForQColor(pen.color(), pdev));
+}
+
+// Add our own patterns here to deal with the fact that the coordinate system
+// is flipped vertically with Quartz2D.
+static const uchar *qt_mac_patternForBrush(int brushStyle)
+{
+    Q_ASSERT(brushStyle > Qt::SolidPattern && brushStyle < Qt::LinearGradientPattern);
+    static const uchar dense1_pat[] = { 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x44, 0x00 };
+    static const uchar dense2_pat[] = { 0x00, 0x22, 0x00, 0x88, 0x00, 0x22, 0x00, 0x88 };
+    static const uchar dense3_pat[] = { 0x11, 0xaa, 0x44, 0xaa, 0x11, 0xaa, 0x44, 0xaa };
+    static const uchar dense4_pat[] = { 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55 };
+    static const uchar dense5_pat[] = { 0xee, 0x55, 0xbb, 0x55, 0xee, 0x55, 0xbb, 0x55 };
+    static const uchar dense6_pat[] = { 0xff, 0xdd, 0xff, 0x77, 0xff, 0xdd, 0xff, 0x77 };
+    static const uchar dense7_pat[] = { 0xff, 0xff, 0xbb, 0xff, 0xff, 0xff, 0xbb, 0xff };
+    static const uchar hor_pat[]    = { 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff };
+    static const uchar ver_pat[]    = { 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef };
+    static const uchar cross_pat[]  = { 0xef, 0xef, 0xef, 0xef, 0x00, 0xef, 0xef, 0xef };
+    static const uchar fdiag_pat[]  = { 0x7f, 0xbf, 0xdf, 0xef, 0xf7, 0xfb, 0xfd, 0xfe };
+    static const uchar bdiag_pat[]  = { 0xfe, 0xfd, 0xfb, 0xf7, 0xef, 0xdf, 0xbf, 0x7f };
+    static const uchar dcross_pat[] = { 0x7e, 0xbd, 0xdb, 0xe7, 0xe7, 0xdb, 0xbd, 0x7e };
+    static const uchar *const pat_tbl[] = {
+        dense1_pat, dense2_pat, dense3_pat, dense4_pat, dense5_pat,
+        dense6_pat, dense7_pat,
+        hor_pat, ver_pat, cross_pat, bdiag_pat, fdiag_pat, dcross_pat };
+    return pat_tbl[brushStyle - Qt::Dense1Pattern];
+}
+
+void QCoreGraphicsPaintEnginePrivate::setFillBrush(const QPointF &offset)
+{
+    // pattern
+    Qt::BrushStyle bs = current.brush.style();
+#ifdef QT_MAC_USE_NATIVE_GRADIENTS
+    if (bs == Qt::LinearGradientPattern || bs == Qt::RadialGradientPattern) {
+        const QGradient *grad = static_cast<const QGradient*>(current.brush.gradient());
+        if (drawGradientNatively(grad)) {
+            Q_ASSERT(grad->spread() == QGradient::PadSpread);
+
+            static const CGFloat domain[] = { 0.0f, +1.0f };
+            static const CGFunctionCallbacks callbacks = { 0, qt_mac_color_gradient_function, 0 };
+            CGFunctionRef fill_func = CGFunctionCreate(reinterpret_cast<void *>(&current.brush),
+                    1, domain, 4, 0, &callbacks);
+
+            CGColorSpaceRef colorspace = qt_mac_colorSpaceForDeviceType(pdev);
+            if (bs == Qt::LinearGradientPattern) {
+                const QLinearGradient *linearGrad = static_cast<const QLinearGradient *>(grad);
+                const QPointF start(linearGrad->start());
+                const QPointF stop(linearGrad->finalStop());
+                shading = CGShadingCreateAxial(colorspace, CGPointMake(start.x(), start.y()),
+                                               CGPointMake(stop.x(), stop.y()), fill_func, true, true);
+            } else {
+                Q_ASSERT(bs == Qt::RadialGradientPattern);
+                const QRadialGradient *radialGrad = static_cast<const QRadialGradient *>(grad);
+                QPointF center(radialGrad->center());
+                QPointF focal(radialGrad->focalPoint());
+                qreal radius = radialGrad->radius();
+                shading = CGShadingCreateRadial(colorspace, CGPointMake(focal.x(), focal.y()),
+                                                0.0, CGPointMake(center.x(), center.y()), radius, fill_func, false, true);
+            }
+
+            CGFunctionRelease(fill_func);
+        }
+    } else
+#endif
+    if(bs != Qt::SolidPattern && bs != Qt::NoBrush
+#ifndef QT_MAC_USE_NATIVE_GRADIENTS
+       && (bs < Qt::LinearGradientPattern || bs > Qt::ConicalGradientPattern)
+#endif
+        )
+    {
+        QMacPattern *qpattern = new QMacPattern;
+        qpattern->pdev = pdev;
+        CGFloat components[4] = { 1.0, 1.0, 1.0, 1.0 };
+        CGColorSpaceRef base_colorspace = 0;
+        if(bs == Qt::TexturePattern) {
+            qpattern->data.pixmap = current.brush.texture();
+            if(qpattern->data.pixmap.isQBitmap()) {
+                const QColor &col = current.brush.color();
+                components[0] = qt_mac_convert_color_to_cg(col.red());
+                components[1] = qt_mac_convert_color_to_cg(col.green());
+                components[2] = qt_mac_convert_color_to_cg(col.blue());
+                base_colorspace = QCoreGraphicsPaintEngine::macGenericColorSpace();
+            }
+        } else {
+            qpattern->as_mask = true;
+
+            qpattern->data.bytes = qt_mac_patternForBrush(bs);
+            const QColor &col = current.brush.color();
+            components[0] = qt_mac_convert_color_to_cg(col.red());
+            components[1] = qt_mac_convert_color_to_cg(col.green());
+            components[2] = qt_mac_convert_color_to_cg(col.blue());
+            base_colorspace = QCoreGraphicsPaintEngine::macGenericColorSpace();
+        }
+        int width = qpattern->width(), height = qpattern->height();
+        qpattern->foreground = current.brush.color();
+
+        CGColorSpaceRef fill_colorspace = CGColorSpaceCreatePattern(base_colorspace);
+        CGContextSetFillColorSpace(hd, fill_colorspace);
+
+        CGAffineTransform xform = CGContextGetCTM(hd);
+        xform = CGAffineTransformConcat(qt_mac_convert_transform_to_cg(current.brush.transform()), xform);
+        xform = CGAffineTransformTranslate(xform, offset.x(), offset.y());
+
+        CGPatternCallbacks callbks;
+        callbks.version = 0;
+        callbks.drawPattern = qt_mac_draw_pattern;
+        callbks.releaseInfo = qt_mac_dispose_pattern;
+        CGPatternRef fill_pattern = CGPatternCreate(qpattern, CGRectMake(0, 0, width, height),
+                xform, width, height, kCGPatternTilingNoDistortion,
+                !base_colorspace, &callbks);
+        CGContextSetFillPattern(hd, fill_pattern, components);
+
+        CGPatternRelease(fill_pattern);
+        CGColorSpaceRelease(fill_colorspace);
+    } else if(bs != Qt::NoBrush) {
+        CGContextSetFillColorWithColor(hd, cgColorForQColor(current.brush.color(), pdev));
+    }
+}
+
+void
+QCoreGraphicsPaintEnginePrivate::setClip(const QRegion *rgn)
+{
+    Q_Q(QCoreGraphicsPaintEngine);
+    if(hd) {
+        resetClip();
+        QRegion sysClip = q->systemClip();
+        if(!sysClip.isEmpty())
+            qt_mac_clip_cg(hd, sysClip, &orig_xform);
+        if(rgn)
+            qt_mac_clip_cg(hd, *rgn, 0);
+    }
+}
+
+struct qt_mac_cg_transform_path {
+    CGMutablePathRef path;
+    CGAffineTransform transform;
+};
+
+void qt_mac_cg_transform_path_apply(void *info, const CGPathElement *element)
+{
+    Q_ASSERT(info && element);
+    qt_mac_cg_transform_path *t = (qt_mac_cg_transform_path*)info;
+    switch(element->type) {
+    case kCGPathElementMoveToPoint:
+        CGPathMoveToPoint(t->path, &t->transform, element->points[0].x, element->points[0].y);
+        break;
+    case kCGPathElementAddLineToPoint:
+        CGPathAddLineToPoint(t->path, &t->transform, element->points[0].x, element->points[0].y);
+        break;
+    case kCGPathElementAddQuadCurveToPoint:
+        CGPathAddQuadCurveToPoint(t->path, &t->transform, element->points[0].x, element->points[0].y,
+                                  element->points[1].x, element->points[1].y);
+        break;
+    case kCGPathElementAddCurveToPoint:
+        CGPathAddCurveToPoint(t->path, &t->transform, element->points[0].x, element->points[0].y,
+                              element->points[1].x, element->points[1].y,
+                              element->points[2].x, element->points[2].y);
+        break;
+    case kCGPathElementCloseSubpath:
+        CGPathCloseSubpath(t->path);
+        break;
+    default:
+        qDebug() << "Unhandled path transform type: " << element->type;
+    }
+}
+
+void QCoreGraphicsPaintEnginePrivate::drawPath(uchar ops, CGMutablePathRef path)
+{
+    Q_Q(QCoreGraphicsPaintEngine);
+    Q_ASSERT((ops & (CGFill | CGEOFill)) != (CGFill | CGEOFill)); //can't really happen
+    if((ops & (CGFill | CGEOFill))) {
+        if (shading) {
+            Q_ASSERT(path);
+            CGContextBeginPath(hd);
+            CGContextAddPath(hd, path);
+            saveGraphicsState();
+            if (ops & CGFill)
+                CGContextClip(hd);
+            else if (ops & CGEOFill)
+                CGContextEOClip(hd);
+            if (current.brush.gradient()->coordinateMode() == QGradient::ObjectBoundingMode) {
+                CGRect boundingBox = CGPathGetBoundingBox(path);
+                CGContextConcatCTM(hd,
+                    CGAffineTransformMake(boundingBox.size.width, 0,
+                                          0, boundingBox.size.height,
+                                          boundingBox.origin.x, boundingBox.origin.y));
+            }
+            CGContextDrawShading(hd, shading);
+            restoreGraphicsState();
+            ops &= ~CGFill;
+            ops &= ~CGEOFill;
+        } else if (current.brush.style() == Qt::NoBrush) {
+            ops &= ~CGFill;
+            ops &= ~CGEOFill;
+        }
+    }
+    if((ops & CGStroke) && current.pen.style() == Qt::NoPen)
+        ops &= ~CGStroke;
+
+    if(ops & (CGEOFill | CGFill)) {
+        CGContextBeginPath(hd);
+        CGContextAddPath(hd, path);
+        if (ops & CGEOFill) {
+            CGContextEOFillPath(hd);
+        } else {
+            CGContextFillPath(hd);
+        }
+    }
+
+    // Avoid saving and restoring the context if we can.
+    const bool needContextSave = (cosmeticPen != QCoreGraphicsPaintEnginePrivate::CosmeticNone ||
+                                  !(q->state->renderHints() & QPainter::Antialiasing));
+    if(ops & CGStroke) {
+        if (needContextSave)
+            saveGraphicsState();
+        CGContextBeginPath(hd);
+
+        // Translate a fraction of a pixel size in the y direction
+        // to make sure that primitives painted at pixel borders
+        // fills the right pixel. This is needed since the y xais
+        // in the Quartz coordinate system is inverted compared to Qt.
+        if (!(q->state->renderHints() & QPainter::Antialiasing)) {
+            if (current.pen.style() == Qt::SolidLine || current.pen.width() >= 3)
+                CGContextTranslateCTM(hd, double(pixelSize.x()) * 0.25, double(pixelSize.y()) * 0.25);
+            else if (current.pen.style() == Qt::DotLine && QSysInfo::MacintoshVersion == QSysInfo::MV_10_3)
+                ; // Do nothing.
+            else
+                CGContextTranslateCTM(hd, 0, double(pixelSize.y()) * 0.1);
+        }
+
+        if (cosmeticPen != QCoreGraphicsPaintEnginePrivate::CosmeticNone) {
+            // If antialiazing is enabled, use the cosmetic pen size directly.
+            if (q->state->renderHints() & QPainter::Antialiasing)
+                CGContextSetLineWidth(hd,  cosmeticPenSize);
+            else if (current.pen.widthF() <= 1)
+                CGContextSetLineWidth(hd, cosmeticPenSize * 0.9f);
+            else
+                CGContextSetLineWidth(hd, cosmeticPenSize);
+        }
+        if(cosmeticPen == QCoreGraphicsPaintEnginePrivate::CosmeticTransformPath) {
+            qt_mac_cg_transform_path t;
+            t.transform = qt_mac_convert_transform_to_cg(current.transform);
+            t.path = CGPathCreateMutable();
+            CGPathApply(path, &t, qt_mac_cg_transform_path_apply); //transform the path
+            setTransform(0); //unset the context transform
+            CGContextSetLineWidth(hd,  cosmeticPenSize);
+            CGContextAddPath(hd, t.path);
+            CGPathRelease(t.path);
+        } else {
+            CGContextAddPath(hd, path);
+        }
+
+        CGContextStrokePath(hd);
+        if (needContextSave)
+            restoreGraphicsState();
+    }
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qpaintengine_mac_p.h b/src/gui/painting/qpaintengine_mac_p.h
new file mode 100644
index 0000000000..3e71d6ca6b
--- /dev/null
+++ b/src/gui/painting/qpaintengine_mac_p.h
@@ -0,0 +1,254 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPAINTENGINE_MAC_P_H
+#define QPAINTENGINE_MAC_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "QtGui/qpaintengine.h"
+#include "private/qt_mac_p.h"
+#include "private/qpaintengine_p.h"
+#include "private/qpolygonclipper_p.h"
+#include "private/qfont_p.h"
+#include "QtCore/qhash.h"
+
+typedef struct CGColorSpace *CGColorSpaceRef;
+QT_BEGIN_NAMESPACE
+
+class QCoreGraphicsPaintEnginePrivate;
+class QCoreGraphicsPaintEngine : public QPaintEngine
+{
+    Q_DECLARE_PRIVATE(QCoreGraphicsPaintEngine)
+
+public:
+    QCoreGraphicsPaintEngine();
+    ~QCoreGraphicsPaintEngine();
+
+    bool begin(QPaintDevice *pdev);
+    bool end();
+    static CGColorSpaceRef macGenericColorSpace();
+    static CGColorSpaceRef macDisplayColorSpace(const QWidget *widget = 0);
+
+    void updateState(const QPaintEngineState &state);
+
+    void updatePen(const QPen &pen);
+    void updateBrush(const QBrush &brush, const QPointF &pt);
+    void updateFont(const QFont &font);
+    void updateOpacity(qreal opacity);
+    void updateMatrix(const QTransform &matrix);
+    void updateTransform(const QTransform &matrix);
+    void updateClipRegion(const QRegion &region, Qt::ClipOperation op);
+    void updateClipPath(const QPainterPath &path, Qt::ClipOperation op);
+    void updateCompositionMode(QPainter::CompositionMode mode);
+    void updateRenderHints(QPainter::RenderHints hints);
+
+    void drawLines(const QLineF *lines, int lineCount);
+    void drawRects(const QRectF *rects, int rectCount);
+    void drawPoints(const QPointF *p, int pointCount);
+    void drawEllipse(const QRectF &r);
+    void drawPath(const QPainterPath &path);
+
+    void drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode);
+    void drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr);
+    void drawTiledPixmap(const QRectF &r, const QPixmap &pixmap, const QPointF &s);
+
+    void drawTextItem(const QPointF &pos, const QTextItem &item);
+    void drawImage(const QRectF &r, const QImage &pm, const QRectF &sr,
+                   Qt::ImageConversionFlags flags = Qt::AutoColor);
+
+    Type type() const { return QPaintEngine::CoreGraphics; }
+
+    CGContextRef handle() const;
+
+    static void initialize();
+    static void cleanup();
+
+    QPainter::RenderHints supportedRenderHints() const;
+
+    //avoid partial shadowed overload warnings...
+    void drawLines(const QLine *lines, int lineCount) { QPaintEngine::drawLines(lines, lineCount); }
+    void drawRects(const QRect *rects, int rectCount) { QPaintEngine::drawRects(rects, rectCount); }
+    void drawPoints(const QPoint *p, int pointCount) { QPaintEngine::drawPoints(p, pointCount); }
+    void drawEllipse(const QRect &r) { QPaintEngine::drawEllipse(r); }
+    void drawPolygon(const QPoint *points, int pointCount, PolygonDrawMode mode)
+    { QPaintEngine::drawPolygon(points, pointCount, mode); }
+
+protected:
+    friend class QMacPrintEngine;
+    friend class QMacPrintEnginePrivate;
+    friend void qt_mac_display_change_callbk(CGDirectDisplayID, CGDisplayChangeSummaryFlags, void *);
+    friend void qt_color_profile_changed(CFNotificationCenterRef center, void *,
+                                         CFStringRef , const void *, CFDictionaryRef);
+    QCoreGraphicsPaintEngine(QPaintEnginePrivate &dptr);
+
+private:
+    static bool m_postRoutineRegistered;
+    static CGColorSpaceRef m_genericColorSpace;
+    static QHash<CGDirectDisplayID, CGColorSpaceRef> m_displayColorSpaceHash;
+    static void cleanUpMacColorSpaces();
+    Q_DISABLE_COPY(QCoreGraphicsPaintEngine)
+};
+
+/*****************************************************************************
+  Private data
+ *****************************************************************************/
+class QCoreGraphicsPaintEnginePrivate : public QPaintEnginePrivate
+{
+    Q_DECLARE_PUBLIC(QCoreGraphicsPaintEngine)
+public:
+    QCoreGraphicsPaintEnginePrivate()
+        : hd(0), shading(0), stackCount(0), complexXForm(false), disabledSmoothFonts(false)
+    {
+    }
+
+    struct {
+        QPen pen;
+        QBrush brush;
+        uint clipEnabled : 1;
+        QRegion clip;
+        QTransform transform;
+   } current;
+
+    //state info (shared with QD)
+    CGAffineTransform orig_xform;
+
+    //cg structures
+    CGContextRef hd;
+    CGShadingRef shading;
+    int stackCount;
+    bool complexXForm;
+    bool disabledSmoothFonts;
+    enum { CosmeticNone, CosmeticTransformPath, CosmeticSetPenWidth } cosmeticPen;
+
+    // pixel and cosmetic pen size in user coordinates.
+    QPointF pixelSize;
+    float cosmeticPenSize;
+
+    //internal functions
+    enum { CGStroke=0x01, CGEOFill=0x02, CGFill=0x04 };
+    void drawPath(uchar ops, CGMutablePathRef path = 0);
+    void setClip(const QRegion *rgn=0);
+    void resetClip();
+    void setFillBrush(const QPointF &origin=QPoint());
+    void setStrokePen(const QPen &pen);
+    inline void saveGraphicsState();
+    inline void restoreGraphicsState();
+    float penOffset();
+    QPointF devicePixelSize(CGContextRef context);
+    float adjustPenWidth(float penWidth);
+    inline void setTransform(const QTransform *matrix=0)
+    {
+        CGContextConcatCTM(hd, CGAffineTransformInvert(CGContextGetCTM(hd)));
+        CGAffineTransform xform = orig_xform;
+        if(matrix) {
+            extern CGAffineTransform qt_mac_convert_transform_to_cg(const QTransform &);
+            xform = CGAffineTransformConcat(qt_mac_convert_transform_to_cg(*matrix), xform);
+        }
+        CGContextConcatCTM(hd, xform);
+        CGContextSetTextMatrix(hd, xform);
+    }
+};
+
+inline void QCoreGraphicsPaintEnginePrivate::saveGraphicsState()
+{
+    ++stackCount;
+    CGContextSaveGState(hd);
+}
+
+inline void QCoreGraphicsPaintEnginePrivate::restoreGraphicsState()
+{
+    --stackCount;
+    Q_ASSERT(stackCount >= 0);
+    CGContextRestoreGState(hd);
+}
+
+class QMacQuartzPaintDevice : public QPaintDevice
+{
+public:
+    QMacQuartzPaintDevice(CGContextRef cg, int width, int height, int bytesPerLine)
+        : mCG(cg), mWidth(width), mHeight(height), mBytesPerLine(bytesPerLine)
+    { }
+    int devType() const { return QInternal::MacQuartz; }
+    CGContextRef cgContext() const { return mCG; }
+    int metric(PaintDeviceMetric metric) const {
+        switch (metric) {
+        case PdmWidth:
+            return mWidth;
+        case PdmHeight:
+            return mHeight;
+        case PdmWidthMM:
+            return (qt_defaultDpiX() * mWidth) / 2.54;
+        case PdmHeightMM:
+            return (qt_defaultDpiY() * mHeight) / 2.54;
+        case PdmNumColors:
+            return 0;
+        case PdmDepth:
+            return 32;
+        case PdmDpiX:
+        case PdmPhysicalDpiX:
+            return qt_defaultDpiX();
+        case PdmDpiY:
+        case PdmPhysicalDpiY:
+            return qt_defaultDpiY();
+        }
+        return 0;
+    }
+    QPaintEngine *paintEngine() const { qWarning("This function should never be called."); return 0; }
+private:
+    CGContextRef mCG;
+    int mWidth;
+    int mHeight;
+    int mBytesPerLine;
+};
+
+QT_END_NAMESPACE
+
+#endif // QPAINTENGINE_MAC_P_H
diff --git a/src/gui/painting/qpaintengine_p.h b/src/gui/painting/qpaintengine_p.h
new file mode 100644
index 0000000000..d6aaffc254
--- /dev/null
+++ b/src/gui/painting/qpaintengine_p.h
@@ -0,0 +1,125 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPAINTENGINE_P_H
+#define QPAINTENGINE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of other Qt classes.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "QtGui/qpainter.h"
+#include "QtGui/qpaintengine.h"
+#include "QtGui/qregion.h"
+#include "private/qobject_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QPaintDevice;
+
+class QPaintEnginePrivate
+{
+    Q_DECLARE_PUBLIC(QPaintEngine)
+public:
+    QPaintEnginePrivate() : pdev(0), q_ptr(0), currentClipWidget(0), hasSystemTransform(0),
+                            hasSystemViewport(0) {}
+    virtual ~QPaintEnginePrivate() { }
+    QPaintDevice *pdev;
+    QPaintEngine *q_ptr;
+    QRegion systemClip;
+    QRect systemRect;
+    QRegion systemViewport;
+    QTransform systemTransform;
+    QWidget *currentClipWidget;
+    uint hasSystemTransform : 1;
+    uint hasSystemViewport : 1;
+
+    inline void transformSystemClip()
+    {
+        if (systemClip.isEmpty())
+            return;
+
+        if (hasSystemTransform) {
+            if (systemTransform.type() <= QTransform::TxTranslate)
+                systemClip.translate(qRound(systemTransform.dx()), qRound(systemTransform.dy()));
+            else
+                systemClip = systemTransform.map(systemClip);
+        }
+
+        // Make sure we're inside the viewport.
+        if (hasSystemViewport) {
+            systemClip &= systemViewport;
+            if (systemClip.isEmpty()) {
+                // We don't want to paint without system clip, so set it to 1 pixel :)
+                systemClip = QRect(systemViewport.boundingRect().topLeft(), QSize(1, 1));
+            }
+        }
+    }
+
+    inline void setSystemTransform(const QTransform &xform)
+    {
+        systemTransform = xform;
+        if ((hasSystemTransform = !xform.isIdentity()) || hasSystemViewport)
+            transformSystemClip();
+        systemStateChanged();
+    }
+
+    inline void setSystemViewport(const QRegion &region)
+    {
+        systemViewport = region;
+        hasSystemViewport = !systemViewport.isEmpty();
+    }
+
+    virtual void systemStateChanged() { }
+
+    void drawBoxTextItem(const QPointF &p, const QTextItemInt &ti);
+};
+
+QT_END_NAMESPACE
+
+#endif // QPAINTENGINE_P_H
diff --git a/src/gui/painting/qpaintengine_preview.cpp b/src/gui/painting/qpaintengine_preview.cpp
new file mode 100644
index 0000000000..99fe4f7fcc
--- /dev/null
+++ b/src/gui/painting/qpaintengine_preview.cpp
@@ -0,0 +1,223 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <private/qpaintengine_preview_p.h>
+#include <private/qpainter_p.h>
+#include <private/qpaintengine_p.h>
+#include <private/qpicture_p.h>
+
+#include <QtGui/qprintengine.h>
+#include <QtGui/qpainter.h>
+#include <QtGui/qpicture.h>
+
+#ifndef QT_NO_PRINTPREVIEWWIDGET
+QT_BEGIN_NAMESPACE
+
+class QPreviewPaintEnginePrivate : public QPaintEnginePrivate
+{
+    Q_DECLARE_PUBLIC(QPreviewPaintEngine)
+public:
+    QPreviewPaintEnginePrivate() : state(QPrinter::Idle) {}
+    ~QPreviewPaintEnginePrivate() {}
+
+    QList<const QPicture *> pages;
+    QPaintEngine *engine;
+    QPainter *painter;
+    QPrinter::PrinterState state;
+
+    QPaintEngine *proxy_paint_engine;
+    QPrintEngine *proxy_print_engine;
+};
+
+
+QPreviewPaintEngine::QPreviewPaintEngine()
+    : QPaintEngine(*(new QPreviewPaintEnginePrivate), PaintEngineFeatures(AllFeatures & ~ObjectBoundingModeGradients))
+{
+    Q_D(QPreviewPaintEngine);
+    d->proxy_print_engine = 0;
+    d->proxy_paint_engine = 0;
+}
+
+QPreviewPaintEngine::~QPreviewPaintEngine()
+{
+    Q_D(QPreviewPaintEngine);
+
+    qDeleteAll(d->pages);
+}
+
+bool QPreviewPaintEngine::begin(QPaintDevice *)
+{
+    Q_D(QPreviewPaintEngine);
+
+    qDeleteAll(d->pages);
+    d->pages.clear();
+
+    QPicture *page = new QPicture;
+    page->d_func()->in_memory_only = true;
+    d->painter = new QPainter(page);
+    d->engine = d->painter->paintEngine();
+    d->pages.append(page);
+    d->state = QPrinter::Active;
+    return true;
+}
+
+bool QPreviewPaintEngine::end()
+{
+    Q_D(QPreviewPaintEngine);
+
+    delete d->painter;
+    d->painter = 0;
+    d->engine = 0;
+    d->state = QPrinter::Idle;
+    return true;
+}
+
+void QPreviewPaintEngine::updateState(const QPaintEngineState &state)
+{
+    Q_D(QPreviewPaintEngine);
+    d->engine->updateState(state);
+}
+
+void QPreviewPaintEngine::drawPath(const QPainterPath &path)
+{
+    Q_D(QPreviewPaintEngine);
+    d->engine->drawPath(path);
+}
+
+void QPreviewPaintEngine::drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode)
+{
+    Q_D(QPreviewPaintEngine);
+    d->engine->drawPolygon(points, pointCount, mode);
+}
+
+void QPreviewPaintEngine::drawTextItem(const QPointF &p, const QTextItem &textItem)
+{
+    Q_D(QPreviewPaintEngine);
+    d->engine->drawTextItem(p, textItem);
+}
+
+void QPreviewPaintEngine::drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr)
+{
+    Q_D(QPreviewPaintEngine);
+    d->engine->drawPixmap(r, pm, sr);
+}
+
+void QPreviewPaintEngine::drawTiledPixmap(const QRectF &r, const QPixmap &pm, const QPointF &p)
+{
+    Q_D(QPreviewPaintEngine);
+    d->engine->drawTiledPixmap(r, pm, p);
+}
+
+bool QPreviewPaintEngine::newPage()
+{
+    Q_D(QPreviewPaintEngine);
+
+    QPicture *page = new QPicture;
+    page->d_func()->in_memory_only = true;
+    QPainter *tmp_painter = new QPainter(page);
+    QPaintEngine *tmp_engine = tmp_painter->paintEngine();
+
+    // copy the painter state from the original painter
+    Q_ASSERT(painter()->d_func()->state && tmp_painter->d_func()->state);
+    *tmp_painter->d_func()->state = *painter()->d_func()->state;
+
+    // composition modes aren't supported on a QPrinter and yields a
+    // warning, so ignore it for now
+    tmp_engine->setDirty(DirtyFlags(AllDirty & ~DirtyCompositionMode));
+    tmp_engine->syncState();
+
+    delete d->painter;
+    d->painter = tmp_painter;
+    d->pages.append(page);
+    d->engine = tmp_engine;
+    return true;
+}
+
+bool QPreviewPaintEngine::abort()
+{
+    Q_D(QPreviewPaintEngine);
+    end();
+    qDeleteAll(d->pages);
+    d->state = QPrinter::Aborted;
+
+    return true;
+}
+
+QList<const QPicture *> QPreviewPaintEngine::pages()
+{
+    Q_D(QPreviewPaintEngine);
+    return d->pages;
+}
+
+void QPreviewPaintEngine::setProxyEngines(QPrintEngine *printEngine, QPaintEngine *paintEngine)
+{
+    Q_D(QPreviewPaintEngine);
+    d->proxy_print_engine = printEngine;
+    d->proxy_paint_engine = paintEngine;
+}
+
+void QPreviewPaintEngine::setProperty(PrintEnginePropertyKey key, const QVariant &value)
+{
+    Q_D(QPreviewPaintEngine);
+    d->proxy_print_engine->setProperty(key, value);
+}
+
+QVariant QPreviewPaintEngine::property(PrintEnginePropertyKey key) const
+{
+    Q_D(const QPreviewPaintEngine);
+    return d->proxy_print_engine->property(key);
+}
+
+int QPreviewPaintEngine::metric(QPaintDevice::PaintDeviceMetric id) const
+{
+    Q_D(const QPreviewPaintEngine);
+    return d->proxy_print_engine->metric(id);
+}
+
+QPrinter::PrinterState QPreviewPaintEngine::printerState() const
+{
+    Q_D(const QPreviewPaintEngine);
+    return d->state;
+}
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/gui/painting/qpaintengine_preview_p.h b/src/gui/painting/qpaintengine_preview_p.h
new file mode 100644
index 0000000000..0101aa0073
--- /dev/null
+++ b/src/gui/painting/qpaintengine_preview_p.h
@@ -0,0 +1,106 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPREVIEWPAINTENGINE_P_H
+#define QPREVIEWPAINTENGINE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of QPreviewPrinter and friends.  This header file may change from
+// version to version without notice, or even be removed.
+//
+// We mean it.
+//
+//
+
+#include <QtGui/qpaintengine.h>
+#include <QtGui/qprintengine.h>
+
+#ifndef QT_NO_PRINTPREVIEWWIDGET
+
+QT_BEGIN_NAMESPACE
+
+class QPreviewPaintEnginePrivate;
+
+class QPreviewPaintEngine : public QPaintEngine, public QPrintEngine
+{
+    Q_DECLARE_PRIVATE(QPreviewPaintEngine)
+public:
+    QPreviewPaintEngine();
+    ~QPreviewPaintEngine();
+
+    bool begin(QPaintDevice *dev);
+    bool end();
+
+    void updateState(const QPaintEngineState &state);
+
+    void drawPath(const QPainterPath &path);
+    void drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode);
+    void drawTextItem(const QPointF &p, const QTextItem &textItem);
+
+    void drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr);
+    void drawTiledPixmap(const QRectF &r, const QPixmap &pm, const QPointF &p);
+
+    QList<const QPicture *> pages();
+
+    QPaintEngine::Type type() const { return Picture; }
+
+    void setProxyEngines(QPrintEngine *printEngine, QPaintEngine *paintEngine);
+
+    void setProperty(PrintEnginePropertyKey key, const QVariant &value);
+    QVariant property(PrintEnginePropertyKey key) const;
+
+    bool newPage();
+    bool abort();
+
+    int metric(QPaintDevice::PaintDeviceMetric) const;
+
+    QPrinter::PrinterState printerState() const;
+};
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_PRINTPREVIEWWIDGET
+
+#endif
diff --git a/src/gui/painting/qpaintengine_raster.cpp b/src/gui/painting/qpaintengine_raster.cpp
new file mode 100644
index 0000000000..69025436c2
--- /dev/null
+++ b/src/gui/painting/qpaintengine_raster.cpp
@@ -0,0 +1,6325 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtCore/qglobal.h>
+#include <QtCore/qmutex.h>
+
+#define QT_FT_BEGIN_HEADER
+#define QT_FT_END_HEADER
+
+#include <private/qrasterdefs_p.h>
+#include <private/qgrayraster_p.h>
+
+#include <qpainterpath.h>
+#include <qdebug.h>
+#include <qhash.h>
+#include <qlabel.h>
+#include <qbitmap.h>
+#include <qmath.h>
+
+#if defined (Q_WS_X11)
+#  include <private/qfontengine_ft_p.h>
+#endif
+
+//   #include <private/qdatabuffer_p.h>
+//   #include <private/qpainter_p.h>
+#include <private/qmath_p.h>
+#include <private/qtextengine_p.h>
+#include <private/qfontengine_p.h>
+#include <private/qpixmap_raster_p.h>
+//   #include <private/qpolygonclipper_p.h>
+//   #include <private/qrasterizer_p.h>
+#include <private/qimage_p.h>
+#include <private/qstatictext_p.h>
+#include "qmemrotate_p.h"
+
+#include "qpaintengine_raster_p.h"
+//   #include "qbezier_p.h"
+#include "qoutlinemapper_p.h"
+
+#if defined(Q_WS_WIN)
+#  include <qt_windows.h>
+#  include <qvarlengtharray.h>
+#  include <private/qfontengine_p.h>
+#  if defined(Q_OS_WINCE)
+#    include "qguifunctions_wince.h"
+#  endif
+#elif defined(Q_WS_MAC)
+#  include <private/qt_mac_p.h>
+#  include <private/qpixmap_mac_p.h>
+#  include <private/qpaintengine_mac_p.h>
+#elif defined(Q_WS_QWS)
+#  if !defined(QT_NO_FREETYPE)
+#    include <private/qfontengine_ft_p.h>
+#  endif
+#  if !defined(QT_NO_QWS_QPF2)
+#    include <private/qfontengine_qpf_p.h>
+#  endif
+#  include <private/qabstractfontengine_p.h>
+#elif defined(Q_OS_SYMBIAN) && defined(QT_NO_FREETYPE)
+#  include <private/qfontengine_s60_p.h>
+#elif defined(Q_WS_QPA)
+#  include <private/qfontengine_ft_p.h>
+#endif
+
+#if defined(Q_WS_WIN64)
+#  include <malloc.h>
+#endif
+#include <limits.h>
+
+QT_BEGIN_NAMESPACE
+
+Q_GUI_EXPORT extern bool qt_scaleForTransform(const QTransform &transform, qreal *scale); // qtransform.cpp
+
+#define qreal_to_fixed_26_6(f) (int(f * 64))
+#define qt_swap_int(x, y) { int tmp = (x); (x) = (y); (y) = tmp; }
+#define qt_swap_qreal(x, y) { qreal tmp = (x); (x) = (y); (y) = tmp; }
+
+// #define QT_DEBUG_DRAW
+#ifdef QT_DEBUG_DRAW
+void dumpClip(int width, int height, const QClipData *clip);
+#endif
+
+#define QT_FAST_SPANS
+
+
+// A little helper macro to get a better approximation of dimensions.
+// If we have a rect that starting at 0.5 of width 3.5 it should span
+// 4 pixels.
+#define int_dim(pos, dim) (int(pos+dim) - int(pos))
+
+#ifdef Q_WS_WIN
+extern bool qt_cleartype_enabled;
+#endif
+
+#ifdef Q_WS_MAC
+extern bool qt_applefontsmoothing_enabled;
+#endif
+
+
+/********************************************************************************
+ * Span functions
+ */
+static void qt_span_fill_clipRect(int count, const QSpan *spans, void *userData);
+static void qt_span_fill_clipped(int count, const QSpan *spans, void *userData);
+static void qt_span_clip(int count, const QSpan *spans, void *userData);
+static void qt_merge_clip(const QClipData *c1, const QClipData *c2, QClipData *result);
+
+struct ClipData
+{
+    QClipData *oldClip;
+    QClipData *newClip;
+    Qt::ClipOperation operation;
+};
+
+enum LineDrawMode {
+    LineDrawClipped,
+    LineDrawNormal,
+    LineDrawIncludeLastPixel
+};
+
+static void drawLine_midpoint_i(int x1, int y1, int x2, int y2, ProcessSpans span_func, QSpanData *data,
+                                LineDrawMode style, const QIntRect &rect);
+static void drawLine_midpoint_dashed_i(int x1, int y1, int x2, int y2,
+                                       QPen *pen, ProcessSpans span_func, QSpanData *data,
+                                       LineDrawMode style, const QIntRect &devRect,
+                                       int *patternOffset);
+// static void drawLine_midpoint_f(qreal x1, qreal y1, qreal x2, qreal y2,
+//                                 ProcessSpans span_func, QSpanData *data,
+//                                 LineDrawMode style, const QRect &devRect);
+
+static void drawEllipse_midpoint_i(const QRect &rect, const QRect &clip,
+                                   ProcessSpans pen_func, ProcessSpans brush_func,
+                                   QSpanData *pen_data, QSpanData *brush_data);
+
+struct QRasterFloatPoint {
+    qreal x;
+    qreal y;
+};
+
+#ifdef QT_DEBUG_DRAW
+static const QRectF boundingRect(const QPointF *points, int pointCount)
+{
+    const QPointF *e = points;
+    const QPointF *last = points + pointCount;
+    qreal minx, maxx, miny, maxy;
+    minx = maxx = e->x();
+    miny = maxy = e->y();
+    while (++e < last) {
+        if (e->x() < minx)
+            minx = e->x();
+        else if (e->x() > maxx)
+            maxx = e->x();
+        if (e->y() < miny)
+            miny = e->y();
+        else if (e->y() > maxy)
+            maxy = e->y();
+    }
+    return QRectF(QPointF(minx, miny), QPointF(maxx, maxy));
+}
+#endif
+
+template <typename T> static inline bool isRect(const T *pts, int elementCount) {
+    return (elementCount == 5 // 5-point polygon, check for closed rect
+            && pts[0] == pts[8] && pts[1] == pts[9] // last point == first point
+            && pts[0] == pts[6] && pts[2] == pts[4] // x values equal
+            && pts[1] == pts[3] && pts[5] == pts[7] // y values equal...
+            && pts[0] < pts[4] && pts[1] < pts[5]
+            ) ||
+           (elementCount == 4 // 4-point polygon, check for unclosed rect
+            && pts[0] == pts[6] && pts[2] == pts[4] // x values equal
+            && pts[1] == pts[3] && pts[5] == pts[7] // y values equal...
+            && pts[0] < pts[4] && pts[1] < pts[5]
+            );
+}
+
+
+static void qt_ft_outline_move_to(qfixed x, qfixed y, void *data)
+{
+    ((QOutlineMapper *) data)->moveTo(QPointF(qt_fixed_to_real(x), qt_fixed_to_real(y)));
+}
+
+static void qt_ft_outline_line_to(qfixed x, qfixed y, void *data)
+{
+    ((QOutlineMapper *) data)->lineTo(QPointF(qt_fixed_to_real(x), qt_fixed_to_real(y)));
+}
+
+static void qt_ft_outline_cubic_to(qfixed c1x, qfixed c1y,
+                             qfixed c2x, qfixed c2y,
+                             qfixed ex, qfixed ey,
+                             void *data)
+{
+    ((QOutlineMapper *) data)->curveTo(QPointF(qt_fixed_to_real(c1x), qt_fixed_to_real(c1y)),
+                                       QPointF(qt_fixed_to_real(c2x), qt_fixed_to_real(c2y)),
+                                       QPointF(qt_fixed_to_real(ex), qt_fixed_to_real(ey)));
+}
+
+
+#if !defined(QT_NO_DEBUG) && 0
+static void qt_debug_path(const QPainterPath &path)
+{
+    const char *names[] = {
+        "MoveTo     ",
+        "LineTo     ",
+        "CurveTo    ",
+        "CurveToData"
+    };
+
+    fprintf(stderr,"\nQPainterPath: elementCount=%d\n", path.elementCount());
+    for (int i=0; i<path.elementCount(); ++i) {
+        const QPainterPath::Element &e = path.elementAt(i);
+        Q_ASSERT(e.type >= 0 && e.type <= QPainterPath::CurveToDataElement);
+        fprintf(stderr," - %3d:: %s, (%.2f, %.2f)\n", i, names[e.type], e.x, e.y);
+    }
+}
+#endif
+
+QRasterPaintEnginePrivate::QRasterPaintEnginePrivate() :
+    QPaintEngineExPrivate(),
+    cachedLines(0)
+{
+}
+
+
+/*!
+    \class QRasterPaintEngine
+    \preliminary
+    \ingroup qws
+    \since 4.2
+
+    \brief The QRasterPaintEngine class enables hardware acceleration
+    of painting operations in Qt for Embedded Linux.
+
+    Note that this functionality is only available in
+    \l{Qt for Embedded Linux}.
+
+    In \l{Qt for Embedded Linux}, painting is a pure software
+    implementation. But starting with Qt 4.2, it is
+    possible to add an accelerated graphics driver to take advantage
+    of available hardware resources.
+
+    Hardware acceleration is accomplished by creating a custom screen
+    driver, accelerating the copying from memory to the screen, and
+    implementing a custom paint engine accelerating the various
+    painting operations. Then a custom paint device (derived from the
+    QCustomRasterPaintDevice class) and a custom window surface
+    (derived from QWSWindowSurface) must be implemented to make
+    \l{Qt for Embedded Linux} aware of the accelerated driver.
+
+    \note The QRasterPaintEngine class does not support 8-bit images.
+    Instead, they need to be converted to a supported format, such as
+    QImage::Format_ARGB32_Premultiplied.
+
+    See the \l {Adding an Accelerated Graphics Driver to Qt for Embedded Linux}
+    documentation for details.
+
+    \sa QCustomRasterPaintDevice, QPaintEngine
+*/
+
+/*!
+    \fn Type QRasterPaintEngine::type() const
+    \reimp
+*/
+
+/*!
+    \typedef QSpan
+    \relates QRasterPaintEngine
+
+    A struct equivalent to QT_FT_Span, containing a position (x,
+    y), the span's length in pixels and its color/coverage (a value
+    ranging from 0 to 255).
+*/
+
+/*!
+    \since 4.5
+
+    Creates a raster based paint engine for operating on the given
+    \a device, with the complete set of \l
+    {QPaintEngine::PaintEngineFeature}{paint engine features and
+    capabilities}.
+*/
+QRasterPaintEngine::QRasterPaintEngine(QPaintDevice *device)
+    : QPaintEngineEx(*(new QRasterPaintEnginePrivate))
+{
+    d_func()->device = device;
+    init();
+}
+
+/*!
+    \internal
+*/
+QRasterPaintEngine::QRasterPaintEngine(QRasterPaintEnginePrivate &dd, QPaintDevice *device)
+    : QPaintEngineEx(dd)
+{
+    d_func()->device = device;
+    init();
+}
+
+void QRasterPaintEngine::init()
+{
+    Q_D(QRasterPaintEngine);
+
+
+#ifdef Q_WS_WIN
+    d->hdc = 0;
+#endif
+
+    // The antialiasing raster.
+    d->grayRaster.reset(new QT_FT_Raster);
+    Q_CHECK_PTR(d->grayRaster.data());
+    if (qt_ft_grays_raster.raster_new(d->grayRaster.data()))
+        QT_THROW(std::bad_alloc()); // an error creating the raster is caused by a bad malloc
+
+
+    d->rasterizer.reset(new QRasterizer);
+    d->rasterBuffer.reset(new QRasterBuffer());
+    d->outlineMapper.reset(new QOutlineMapper);
+    d->outlinemapper_xform_dirty = true;
+
+    d->basicStroker.setMoveToHook(qt_ft_outline_move_to);
+    d->basicStroker.setLineToHook(qt_ft_outline_line_to);
+    d->basicStroker.setCubicToHook(qt_ft_outline_cubic_to);
+
+    d->baseClip.reset(new QClipData(d->device->height()));
+    d->baseClip->setClipRect(QRect(0, 0, d->device->width(), d->device->height()));
+
+    d->image_filler.init(d->rasterBuffer.data(), this);
+    d->image_filler.type = QSpanData::Texture;
+
+    d->image_filler_xform.init(d->rasterBuffer.data(), this);
+    d->image_filler_xform.type = QSpanData::Texture;
+
+    d->solid_color_filler.init(d->rasterBuffer.data(), this);
+    d->solid_color_filler.type = QSpanData::Solid;
+
+    d->deviceDepth = d->device->depth();
+
+    d->mono_surface = false;
+    gccaps &= ~PorterDuff;
+
+    QImage::Format format = QImage::Format_Invalid;
+
+    switch (d->device->devType()) {
+    case QInternal::Pixmap:
+        qWarning("QRasterPaintEngine: unsupported for pixmaps...");
+        break;
+    case QInternal::Image:
+        format = d->rasterBuffer->prepare(static_cast<QImage *>(d->device));
+        break;
+#ifdef Q_WS_QWS
+    case QInternal::CustomRaster:
+        d->rasterBuffer->prepare(static_cast<QCustomRasterPaintDevice*>(d->device));
+        break;
+#endif
+    default:
+        qWarning("QRasterPaintEngine: unsupported target device %d\n", d->device->devType());
+        d->device = 0;
+        return;
+    }
+
+    switch (format) {
+    case QImage::Format_MonoLSB:
+    case QImage::Format_Mono:
+        d->mono_surface = true;
+        break;
+    case QImage::Format_ARGB8565_Premultiplied:
+    case QImage::Format_ARGB8555_Premultiplied:
+    case QImage::Format_ARGB6666_Premultiplied:
+    case QImage::Format_ARGB4444_Premultiplied:
+    case QImage::Format_ARGB32_Premultiplied:
+    case QImage::Format_ARGB32:
+        gccaps |= PorterDuff;
+        break;
+    case QImage::Format_RGB32:
+    case QImage::Format_RGB444:
+    case QImage::Format_RGB555:
+    case QImage::Format_RGB666:
+    case QImage::Format_RGB888:
+    case QImage::Format_RGB16:
+        break;
+    default:
+        break;
+    }
+}
+
+
+
+
+/*!
+    Destroys this paint engine.
+*/
+QRasterPaintEngine::~QRasterPaintEngine()
+{
+    Q_D(QRasterPaintEngine);
+
+    qt_ft_grays_raster.raster_done(*d->grayRaster.data());
+}
+
+/*!
+    \reimp
+*/
+bool QRasterPaintEngine::begin(QPaintDevice *device)
+{
+    Q_D(QRasterPaintEngine);
+
+    if (device->devType() == QInternal::Pixmap) {
+        QPixmap *pixmap = static_cast<QPixmap *>(device);
+        QPixmapData *pd = pixmap->pixmapData();
+        if (pd->classId() == QPixmapData::RasterClass || pd->classId() == QPixmapData::BlitterClass)
+            d->device = pd->buffer();
+    } else {
+        d->device = device;
+    }
+
+    // Make sure QPaintEngine::paintDevice() returns the proper device.
+    d->pdev = d->device;
+
+    Q_ASSERT(d->device->devType() == QInternal::Image
+             || d->device->devType() == QInternal::CustomRaster);
+
+    d->systemStateChanged();
+
+    QRasterPaintEngineState *s = state();
+    ensureOutlineMapper();
+    d->outlineMapper->m_clip_rect = d->deviceRect;
+
+    if (d->outlineMapper->m_clip_rect.width() > QT_RASTER_COORD_LIMIT)
+        d->outlineMapper->m_clip_rect.setWidth(QT_RASTER_COORD_LIMIT);
+    if (d->outlineMapper->m_clip_rect.height() > QT_RASTER_COORD_LIMIT)
+        d->outlineMapper->m_clip_rect.setHeight(QT_RASTER_COORD_LIMIT);
+
+    d->rasterizer->setClipRect(d->deviceRect);
+
+    s->penData.init(d->rasterBuffer.data(), this);
+    s->penData.setup(s->pen.brush(), s->intOpacity, s->composition_mode);
+    s->stroker = &d->basicStroker;
+    d->basicStroker.setClipRect(d->deviceRect);
+
+    s->brushData.init(d->rasterBuffer.data(), this);
+    s->brushData.setup(s->brush, s->intOpacity, s->composition_mode);
+
+    d->rasterBuffer->compositionMode = QPainter::CompositionMode_SourceOver;
+
+    setDirty(DirtyBrushOrigin);
+
+#ifdef QT_DEBUG_DRAW
+    qDebug() << "QRasterPaintEngine::begin(" << (void *) device
+             << ") devType:" << device->devType()
+             << "devRect:" << d->deviceRect;
+    if (d->baseClip) {
+        dumpClip(d->rasterBuffer->width(), d->rasterBuffer->height(), &*d->baseClip);
+    }
+#endif
+
+#if defined(Q_WS_WIN)
+    d->isPlain45DegreeRotation = true;
+#endif
+
+    if (d->mono_surface)
+        d->glyphCacheType = QFontEngineGlyphCache::Raster_Mono;
+#if defined(Q_WS_WIN)
+    else if (qt_cleartype_enabled)
+#elif defined (Q_WS_MAC)
+    else if (qt_applefontsmoothing_enabled)
+#else
+    else if (false)
+#endif
+    {
+        QImage::Format format = static_cast<QImage *>(d->device)->format();
+        if (format == QImage::Format_ARGB32_Premultiplied || format == QImage::Format_RGB32)
+            d->glyphCacheType = QFontEngineGlyphCache::Raster_RGBMask;
+        else
+            d->glyphCacheType = QFontEngineGlyphCache::Raster_A8;
+    } else
+        d->glyphCacheType = QFontEngineGlyphCache::Raster_A8;
+
+    setActive(true);
+    return true;
+}
+
+/*!
+    \reimp
+*/
+bool QRasterPaintEngine::end()
+{
+#ifdef QT_DEBUG_DRAW
+    Q_D(QRasterPaintEngine);
+    qDebug() << "QRasterPaintEngine::end devRect:" << d->deviceRect;
+    if (d->baseClip) {
+        dumpClip(d->rasterBuffer->width(), d->rasterBuffer->height(), &*d->baseClip);
+    }
+#endif
+
+    return true;
+}
+
+/*!
+    \internal
+*/
+void QRasterPaintEngine::releaseBuffer()
+{
+    Q_D(QRasterPaintEngine);
+    d->rasterBuffer.reset(new QRasterBuffer);
+}
+
+/*!
+    \internal
+*/
+QSize QRasterPaintEngine::size() const
+{
+    Q_D(const QRasterPaintEngine);
+    return QSize(d->rasterBuffer->width(), d->rasterBuffer->height());
+}
+
+/*!
+    \internal
+*/
+#ifndef QT_NO_DEBUG
+void QRasterPaintEngine::saveBuffer(const QString &s) const
+{
+    Q_D(const QRasterPaintEngine);
+    d->rasterBuffer->bufferImage().save(s, "PNG");
+}
+#endif
+
+/*!
+    \internal
+*/
+void QRasterPaintEngine::updateMatrix(const QTransform &matrix)
+{
+    QRasterPaintEngineState *s = state();
+    // FALCON: get rid of this line, see drawImage call below.
+    s->matrix = matrix;
+    QTransform::TransformationType txop = s->matrix.type();
+
+    switch (txop) {
+
+    case QTransform::TxNone:
+        s->flags.int_xform = true;
+        break;
+
+    case QTransform::TxTranslate:
+        s->flags.int_xform = qreal(int(s->matrix.dx())) == s->matrix.dx()
+                            && qreal(int(s->matrix.dy())) == s->matrix.dy();
+        break;
+
+    case QTransform::TxScale:
+        s->flags.int_xform = qreal(int(s->matrix.dx())) == s->matrix.dx()
+                            && qreal(int(s->matrix.dy())) == s->matrix.dy()
+                            && qreal(int(s->matrix.m11())) == s->matrix.m11()
+                            && qreal(int(s->matrix.m22())) == s->matrix.m22();
+        break;
+
+    default: // shear / perspective...
+        s->flags.int_xform = false;
+        break;
+    }
+
+    s->flags.tx_noshear = qt_scaleForTransform(s->matrix, &s->txscale);
+
+    ensureOutlineMapper();
+
+#ifdef Q_WS_WIN
+    Q_D(QRasterPaintEngine);
+    d->isPlain45DegreeRotation = false;
+    if (txop >= QTransform::TxRotate) {
+        d->isPlain45DegreeRotation =
+            (qFuzzyIsNull(matrix.m11())
+             && qFuzzyIsNull(matrix.m12() - qreal(1))
+             && qFuzzyIsNull(matrix.m21() + qreal(1))
+             && qFuzzyIsNull(matrix.m22())
+                )
+            ||
+            (qFuzzyIsNull(matrix.m11() + qreal(1))
+             && qFuzzyIsNull(matrix.m12())
+             && qFuzzyIsNull(matrix.m21())
+             && qFuzzyIsNull(matrix.m22() + qreal(1))
+                )
+            ||
+            (qFuzzyIsNull(matrix.m11())
+             && qFuzzyIsNull(matrix.m12() + qreal(1))
+             && qFuzzyIsNull(matrix.m21() - qreal(1))
+             && qFuzzyIsNull(matrix.m22())
+                )
+            ;
+    }
+#endif
+
+}
+
+
+
+QRasterPaintEngineState::~QRasterPaintEngineState()
+{
+    if (flags.has_clip_ownership)
+        delete clip;
+}
+
+
+QRasterPaintEngineState::QRasterPaintEngineState()
+{
+    stroker = 0;
+
+    fillFlags = 0;
+    strokeFlags = 0;
+    pixmapFlags = 0;
+
+    intOpacity = 256;
+
+    txscale = 1.;
+
+    flags.fast_pen = true;
+    flags.antialiased = false;
+    flags.bilinear = false;
+    flags.fast_text = true;
+    flags.int_xform = true;
+    flags.tx_noshear = true;
+    flags.fast_images = true;
+
+    clip = 0;
+    flags.has_clip_ownership = false;
+
+    dirty = 0;
+}
+
+QRasterPaintEngineState::QRasterPaintEngineState(QRasterPaintEngineState &s)
+    : QPainterState(s)
+    , lastPen(s.lastPen)
+    , penData(s.penData)
+    , stroker(s.stroker)
+    , strokeFlags(s.strokeFlags)
+    , lastBrush(s.lastBrush)
+    , brushData(s.brushData)
+    , fillFlags(s.fillFlags)
+    , pixmapFlags(s.pixmapFlags)
+    , intOpacity(s.intOpacity)
+    , txscale(s.txscale)
+    , clip(s.clip)
+    , dirty(s.dirty)
+    , flag_bits(s.flag_bits)
+{
+    brushData.tempImage = 0;
+    penData.tempImage = 0;
+    flags.has_clip_ownership = false;
+}
+
+/*!
+    \internal
+*/
+QPainterState *QRasterPaintEngine::createState(QPainterState *orig) const
+{
+    QRasterPaintEngineState *s;
+    if (!orig)
+        s = new QRasterPaintEngineState();
+    else
+        s = new QRasterPaintEngineState(*static_cast<QRasterPaintEngineState *>(orig));
+
+    return s;
+}
+
+/*!
+    \internal
+*/
+void QRasterPaintEngine::setState(QPainterState *s)
+{
+    Q_D(QRasterPaintEngine);
+    QPaintEngineEx::setState(s);
+    d->rasterBuffer->compositionMode = s->composition_mode;
+}
+
+/*!
+    \fn QRasterPaintEngineState *QRasterPaintEngine::state()
+    \internal
+*/
+
+/*!
+    \fn const QRasterPaintEngineState *QRasterPaintEngine::state() const
+    \internal
+*/
+
+/*!
+    \internal
+*/
+void QRasterPaintEngine::penChanged()
+{
+#ifdef QT_DEBUG_DRAW
+    qDebug() << "QRasterPaintEngine::penChanged():" << state()->pen;
+#endif
+    QRasterPaintEngineState *s = state();
+    s->strokeFlags |= DirtyPen;
+    s->dirty |= DirtyPen;
+}
+
+/*!
+    \internal
+*/
+void QRasterPaintEngine::updatePen(const QPen &pen)
+{
+    Q_D(QRasterPaintEngine);
+    QRasterPaintEngineState *s = state();
+#ifdef QT_DEBUG_DRAW
+    qDebug() << "QRasterPaintEngine::updatePen():" << s->pen;
+#endif
+
+    Qt::PenStyle pen_style = qpen_style(pen);
+
+    s->lastPen = pen;
+    s->strokeFlags = 0;
+
+    s->penData.clip = d->clip();
+    s->penData.setup(pen_style == Qt::NoPen ? QBrush() : pen.brush(), s->intOpacity, s->composition_mode);
+
+    if (s->strokeFlags & QRasterPaintEngine::DirtyTransform
+        || pen.brush().transform().type() >= QTransform::TxNone) {
+        d->updateMatrixData(&s->penData, pen.brush(), s->matrix);
+    }
+
+    // Slightly ugly handling of an uncommon case... We need to change
+    // the pen because it is reused in draw_midpoint to decide dashed
+    // or non-dashed.
+    if (pen_style == Qt::CustomDashLine && pen.dashPattern().size() == 0) {
+        pen_style = Qt::SolidLine;
+        s->lastPen.setStyle(Qt::SolidLine);
+    }
+
+    d->basicStroker.setJoinStyle(qpen_joinStyle(pen));
+    d->basicStroker.setCapStyle(qpen_capStyle(pen));
+    d->basicStroker.setMiterLimit(pen.miterLimit());
+
+    qreal penWidth = qpen_widthf(pen);
+    if (penWidth == 0)
+        d->basicStroker.setStrokeWidth(1);
+    else
+        d->basicStroker.setStrokeWidth(penWidth);
+
+    if(pen_style == Qt::SolidLine) {
+        s->stroker = &d->basicStroker;
+    } else if (pen_style != Qt::NoPen) {
+        if (!d->dashStroker)
+            d->dashStroker.reset(new QDashStroker(&d->basicStroker));
+        if (pen.isCosmetic()) {
+            d->dashStroker->setClipRect(d->deviceRect);
+        } else {
+            // ### I've seen this inverted devrect multiple places now...
+            QRectF clipRect = s->matrix.inverted().mapRect(QRectF(d->deviceRect));
+            d->dashStroker->setClipRect(clipRect);
+        }
+        d->dashStroker->setDashPattern(pen.dashPattern());
+        d->dashStroker->setDashOffset(pen.dashOffset());
+        s->stroker = d->dashStroker.data();
+    } else {
+        s->stroker = 0;
+    }
+
+    s->flags.fast_pen = pen_style > Qt::NoPen
+                  && s->penData.blend
+                  && !s->flags.antialiased
+                  && (penWidth == 0 || (penWidth <= 1
+                                        && (s->matrix.type() <= QTransform::TxTranslate
+                                            || pen.isCosmetic())));
+
+    ensureState(); // needed because of tx_noshear...
+    s->flags.non_complex_pen = qpen_capStyle(s->lastPen) <= Qt::SquareCap && s->flags.tx_noshear;
+
+    s->strokeFlags = 0;
+}
+
+
+
+/*!
+    \internal
+*/
+void QRasterPaintEngine::brushOriginChanged()
+{
+    QRasterPaintEngineState *s = state();
+#ifdef QT_DEBUG_DRAW
+    qDebug() << "QRasterPaintEngine::brushOriginChanged()" << s->brushOrigin;
+#endif
+
+    s->fillFlags |= DirtyBrushOrigin;
+}
+
+
+/*!
+    \internal
+*/
+void QRasterPaintEngine::brushChanged()
+{
+    QRasterPaintEngineState *s = state();
+#ifdef QT_DEBUG_DRAW
+    qDebug() << "QRasterPaintEngine::brushChanged():" << s->brush;
+#endif
+    s->fillFlags |= DirtyBrush;
+}
+
+
+
+
+/*!
+    \internal
+*/
+void QRasterPaintEngine::updateBrush(const QBrush &brush)
+{
+#ifdef QT_DEBUG_DRAW
+    qDebug() << "QRasterPaintEngine::updateBrush()" << brush;
+#endif
+    Q_D(QRasterPaintEngine);
+    QRasterPaintEngineState *s = state();
+    // must set clip prior to setup, as setup uses it...
+    s->brushData.clip = d->clip();
+    s->brushData.setup(brush, s->intOpacity, s->composition_mode);
+    if (s->fillFlags & DirtyTransform
+        || brush.transform().type() >= QTransform::TxNone)
+        d_func()->updateMatrixData(&s->brushData, brush, d->brushMatrix());
+    s->lastBrush = brush;
+    s->fillFlags = 0;
+}
+
+void QRasterPaintEngine::updateOutlineMapper()
+{
+    Q_D(QRasterPaintEngine);
+    d->outlineMapper->setMatrix(state()->matrix);
+}
+
+void QRasterPaintEngine::updateState()
+{
+    QRasterPaintEngineState *s = state();
+
+    if (s->dirty & DirtyTransform)
+        updateMatrix(s->matrix);
+
+    if (s->dirty & (DirtyPen|DirtyCompositionMode|DirtyOpacity)) {
+        const QPainter::CompositionMode mode = s->composition_mode;
+        s->flags.fast_text = (s->penData.type == QSpanData::Solid)
+                       && s->intOpacity == 256
+                       && (mode == QPainter::CompositionMode_Source
+                           || (mode == QPainter::CompositionMode_SourceOver
+                               && qAlpha(s->penData.solid.color) == 255));
+    }
+
+    s->dirty = 0;
+}
+
+
+/*!
+    \internal
+*/
+void QRasterPaintEngine::opacityChanged()
+{
+    QRasterPaintEngineState *s = state();
+
+#ifdef QT_DEBUG_DRAW
+    qDebug() << "QRasterPaintEngine::opacityChanged()" << s->opacity;
+#endif
+
+    s->fillFlags |= DirtyOpacity;
+    s->strokeFlags |= DirtyOpacity;
+    s->pixmapFlags |= DirtyOpacity;
+    s->dirty |= DirtyOpacity;
+    s->intOpacity = (int) (s->opacity * 256);
+}
+
+/*!
+    \internal
+*/
+void QRasterPaintEngine::compositionModeChanged()
+{
+    Q_D(QRasterPaintEngine);
+    QRasterPaintEngineState *s = state();
+
+#ifdef QT_DEBUG_DRAW
+    qDebug() << "QRasterPaintEngine::compositionModeChanged()" << s->composition_mode;
+#endif
+
+    s->fillFlags |= DirtyCompositionMode;
+    s->dirty |= DirtyCompositionMode;
+
+    s->strokeFlags |= DirtyCompositionMode;
+    d->rasterBuffer->compositionMode = s->composition_mode;
+
+    d->recalculateFastImages();
+}
+
+/*!
+    \internal
+*/
+void QRasterPaintEngine::renderHintsChanged()
+{
+    QRasterPaintEngineState *s = state();
+
+#ifdef QT_DEBUG_DRAW
+    qDebug() << "QRasterPaintEngine::renderHintsChanged()" << hex << s->renderHints;
+#endif
+
+    bool was_aa = s->flags.antialiased;
+    bool was_bilinear = s->flags.bilinear;
+
+    s->flags.antialiased = bool(s->renderHints & QPainter::Antialiasing);
+    s->flags.bilinear = bool(s->renderHints & QPainter::SmoothPixmapTransform);
+
+    if (was_aa != s->flags.antialiased)
+        s->strokeFlags |= DirtyHints;
+
+    if (was_bilinear != s->flags.bilinear) {
+        s->strokeFlags |= DirtyPen;
+        s->fillFlags |= DirtyBrush;
+    }
+
+    Q_D(QRasterPaintEngine);
+    d->recalculateFastImages();
+}
+
+/*!
+    \internal
+*/
+void QRasterPaintEngine::transformChanged()
+{
+    QRasterPaintEngineState *s = state();
+
+#ifdef QT_DEBUG_DRAW
+    qDebug() << "QRasterPaintEngine::transformChanged()" << s->matrix;
+#endif
+
+    s->fillFlags |= DirtyTransform;
+    s->strokeFlags |= DirtyTransform;
+
+    s->dirty |= DirtyTransform;
+
+    Q_D(QRasterPaintEngine);
+    d->recalculateFastImages();
+}
+
+/*!
+    \internal
+*/
+void QRasterPaintEngine::clipEnabledChanged()
+{
+    QRasterPaintEngineState *s = state();
+
+#ifdef QT_DEBUG_DRAW
+    qDebug() << "QRasterPaintEngine::clipEnabledChanged()" << s->clipEnabled;
+#endif
+
+    if (s->clip) {
+        s->clip->enabled = s->clipEnabled;
+        s->fillFlags |= DirtyClipEnabled;
+        s->strokeFlags |= DirtyClipEnabled;
+        s->pixmapFlags |= DirtyClipEnabled;
+    }
+}
+
+#ifdef Q_WS_QWS
+void QRasterPaintEnginePrivate::prepare(QCustomRasterPaintDevice *device)
+{
+    rasterBuffer->prepare(device);
+}
+#endif
+
+void QRasterPaintEnginePrivate::drawImage(const QPointF &pt,
+                                          const QImage &img,
+                                          SrcOverBlendFunc func,
+                                          const QRect &clip,
+                                          int alpha,
+                                          const QRect &sr)
+{
+    if (alpha == 0 || !clip.isValid())
+        return;
+
+    Q_ASSERT(img.depth() >= 8);
+
+    int srcBPL = img.bytesPerLine();
+    const uchar *srcBits = img.bits();
+    int srcSize = img.depth() >> 3; // This is the part that is incompatible with lower than 8-bit..
+    int iw = img.width();
+    int ih = img.height();
+
+    if (!sr.isEmpty()) {
+        iw = sr.width();
+        ih = sr.height();
+        // Adjust the image according to the source offset...
+        srcBits += ((sr.y() * srcBPL) + sr.x() * srcSize);
+    }
+
+    // adapt the x parameters
+    int x = qRound(pt.x());
+    int cx1 = clip.x();
+    int cx2 = clip.x() + clip.width();
+    if (x < cx1) {
+        int d = cx1 - x;
+        srcBits += srcSize * d;
+        iw -= d;
+        x = cx1;
+    }
+    if (x + iw > cx2) {
+        int d = x + iw - cx2;
+        iw -= d;
+    }
+    if (iw <= 0)
+        return;
+
+    // adapt the y paremeters...
+    int cy1 = clip.y();
+    int cy2 = clip.y() + clip.height();
+    int y = qRound(pt.y());
+    if (y < cy1) {
+        int d = cy1 - y;
+        srcBits += srcBPL * d;
+        ih -= d;
+        y = cy1;
+    }
+    if (y + ih > cy2) {
+        int d = y + ih - cy2;
+        ih -= d;
+    }
+    if (ih <= 0)
+        return;
+
+    // call the blend function...
+    int dstSize = rasterBuffer->bytesPerPixel();
+    int dstBPL = rasterBuffer->bytesPerLine();
+    func(rasterBuffer->buffer() + x * dstSize + y * dstBPL, dstBPL,
+         srcBits, srcBPL,
+         iw, ih,
+         alpha);
+}
+
+
+void QRasterPaintEnginePrivate::systemStateChanged()
+{
+    QRect clipRect(0, 0,
+            qMin(QT_RASTER_COORD_LIMIT, device->width()),
+            qMin(QT_RASTER_COORD_LIMIT, device->height()));
+
+    if (!systemClip.isEmpty()) {
+        QRegion clippedDeviceRgn = systemClip & clipRect;
+        deviceRect = clippedDeviceRgn.boundingRect();
+        baseClip->setClipRegion(clippedDeviceRgn);
+    } else {
+        deviceRect = clipRect;
+        baseClip->setClipRect(deviceRect);
+    }
+#ifdef QT_DEBUG_DRAW
+    qDebug() << "systemStateChanged" << this << "deviceRect" << deviceRect << clipRect << systemClip;
+#endif
+
+    exDeviceRect = deviceRect;
+
+    Q_Q(QRasterPaintEngine);
+    q->state()->strokeFlags |= QPaintEngine::DirtyClipRegion;
+    q->state()->fillFlags |= QPaintEngine::DirtyClipRegion;
+    q->state()->pixmapFlags |= QPaintEngine::DirtyClipRegion;
+}
+
+void QRasterPaintEnginePrivate::updateMatrixData(QSpanData *spanData, const QBrush &b, const QTransform &m)
+{
+    if (b.d->style == Qt::NoBrush || b.d->style == Qt::SolidPattern)
+        return;
+
+    Q_Q(QRasterPaintEngine);
+    bool bilinear = q->state()->flags.bilinear;
+
+    if (b.d->transform.type() > QTransform::TxNone) { // FALCON: optimize
+        spanData->setupMatrix(b.transform() * m, bilinear);
+    } else {
+        if (m.type() <= QTransform::TxTranslate) {
+            // specialize setupMatrix for translation matrices
+            // to avoid needless matrix inversion
+            spanData->m11 = 1;
+            spanData->m12 = 0;
+            spanData->m13 = 0;
+            spanData->m21 = 0;
+            spanData->m22 = 1;
+            spanData->m23 = 0;
+            spanData->m33 = 1;
+            spanData->dx = -m.dx();
+            spanData->dy = -m.dy();
+            spanData->txop = m.type();
+            spanData->bilinear = bilinear;
+            spanData->fast_matrix = qAbs(m.dx()) < 1e4 && qAbs(m.dy()) < 1e4;
+            spanData->adjustSpanMethods();
+        } else {
+            spanData->setupMatrix(m, bilinear);
+        }
+    }
+}
+
+// #define QT_CLIPPING_RATIOS
+
+#ifdef QT_CLIPPING_RATIOS
+int rectClips;
+int regionClips;
+int totalClips;
+
+static void checkClipRatios(QRasterPaintEnginePrivate *d)
+{
+    if (d->clip()->hasRectClip)
+        rectClips++;
+    if (d->clip()->hasRegionClip)
+        regionClips++;
+    totalClips++;
+
+    if ((totalClips % 5000) == 0) {
+        printf("Clipping ratio: rectangular=%f%%, region=%f%%, complex=%f%%\n",
+               rectClips * 100.0 / (qreal) totalClips,
+               regionClips * 100.0 / (qreal) totalClips,
+               (totalClips - rectClips - regionClips) * 100.0 / (qreal) totalClips);
+        totalClips = 0;
+        rectClips = 0;
+        regionClips = 0;
+    }
+
+}
+#endif
+
+static void qrasterpaintengine_state_setNoClip(QRasterPaintEngineState *s)
+{
+    if (s->flags.has_clip_ownership)
+        delete s->clip;
+    s->clip = 0;
+    s->flags.has_clip_ownership = false;
+}
+
+static void qrasterpaintengine_dirty_clip(QRasterPaintEnginePrivate *d, QRasterPaintEngineState *s)
+{
+    s->fillFlags |= QPaintEngine::DirtyClipPath;
+    s->strokeFlags |= QPaintEngine::DirtyClipPath;
+    s->pixmapFlags |= QPaintEngine::DirtyClipPath;
+
+    d->solid_color_filler.clip = d->clip();
+    d->solid_color_filler.adjustSpanMethods();
+
+#ifdef QT_DEBUG_DRAW
+    dumpClip(d->rasterBuffer->width(), d->rasterBuffer->height(), &*d->clip());
+#endif
+
+}
+
+
+/*!
+    \internal
+*/
+void QRasterPaintEngine::clip(const QVectorPath &path, Qt::ClipOperation op)
+{
+#ifdef QT_DEBUG_DRAW
+    qDebug() << "QRasterPaintEngine::clip(): " << path << op;
+
+    if (path.elements()) {
+        for (int i=0; i<path.elementCount(); ++i) {
+            qDebug() << " - " << path.elements()[i]
+                     << '(' << path.points()[i*2] << ", " << path.points()[i*2+1] << ')';
+        }
+    } else {
+        for (int i=0; i<path.elementCount(); ++i) {
+            qDebug() << " ---- "
+                     << '(' << path.points()[i*2] << ", " << path.points()[i*2+1] << ')';
+        }
+    }
+#endif
+
+    Q_D(QRasterPaintEngine);
+    QRasterPaintEngineState *s = state();
+
+    const qreal *points = path.points();
+    const QPainterPath::ElementType *types = path.elements();
+
+    // There are some cases that are not supported by clip(QRect)
+    if (op != Qt::UniteClip && (op != Qt::IntersectClip || !s->clip
+                                || s->clip->hasRectClip || s->clip->hasRegionClip)) {
+        if (s->matrix.type() <= QTransform::TxScale
+            && ((path.shape() == QVectorPath::RectangleHint)
+                || (isRect(points, path.elementCount())
+                    && (!types || (types[0] == QPainterPath::MoveToElement
+                                   && types[1] == QPainterPath::LineToElement
+                                   && types[2] == QPainterPath::LineToElement
+                                   && types[3] == QPainterPath::LineToElement))))) {
+#ifdef QT_DEBUG_DRAW
+            qDebug() << " --- optimizing vector clip to rect clip...";
+#endif
+
+            QRectF r(points[0], points[1], points[4]-points[0], points[5]-points[1]);
+            if (setClipRectInDeviceCoords(s->matrix.mapRect(r).toRect(), op))
+                return;
+        }
+    }
+
+    if (op == Qt::NoClip) {
+        qrasterpaintengine_state_setNoClip(s);
+
+    } else {
+        QClipData *base = d->baseClip.data();
+
+        // Intersect with current clip when available...
+        if (op == Qt::IntersectClip && s->clip)
+            base = s->clip;
+
+        // We always intersect, except when there is nothing to
+        // intersect with, in which case we simplify the operation to
+        // a replace...
+        Qt::ClipOperation isectOp = Qt::IntersectClip;
+        if (base == 0)
+            isectOp = Qt::ReplaceClip;
+
+        QClipData *newClip = new QClipData(d->rasterBuffer->height());
+        newClip->initialize();
+        ClipData clipData = { base, newClip, isectOp };
+        ensureOutlineMapper();
+        d->rasterize(d->outlineMapper->convertPath(path), qt_span_clip, &clipData, 0);
+
+        newClip->fixup();
+
+        if (op == Qt::UniteClip) {
+            // merge clips
+            QClipData *result = new QClipData(d->rasterBuffer->height());
+            QClipData *current = s->clip ? s->clip : new QClipData(d->rasterBuffer->height());
+            qt_merge_clip(current, newClip, result);
+            result->fixup();
+            delete newClip;
+            if (!s->clip)
+                delete current;
+            newClip = result;
+        }
+
+        if (s->flags.has_clip_ownership)
+            delete s->clip;
+
+        s->clip = newClip;
+        s->flags.has_clip_ownership = true;
+    }
+    qrasterpaintengine_dirty_clip(d, s);
+}
+
+
+
+/*!
+    \internal
+*/
+void QRasterPaintEngine::clip(const QRect &rect, Qt::ClipOperation op)
+{
+#ifdef QT_DEBUG_DRAW
+    qDebug() << "QRasterPaintEngine::clip(): " << rect << op;
+#endif
+
+    QRasterPaintEngineState *s = state();
+
+    if (op == Qt::NoClip) {
+        qrasterpaintengine_state_setNoClip(s);
+
+    } else if (op == Qt::UniteClip || s->matrix.type() > QTransform::TxScale) {
+        QPaintEngineEx::clip(rect, op);
+        return;
+
+    } else if (!setClipRectInDeviceCoords(s->matrix.mapRect(rect), op)) {
+        QPaintEngineEx::clip(rect, op);
+        return;
+    }
+}
+
+
+bool QRasterPaintEngine::setClipRectInDeviceCoords(const QRect &r, Qt::ClipOperation op)
+{
+    Q_D(QRasterPaintEngine);
+    QRect clipRect = r & d->deviceRect;
+    QRasterPaintEngineState *s = state();
+
+    if (op == Qt::ReplaceClip || s->clip == 0) {
+
+        // No current clip, hence we intersect with sysclip and be
+        // done with it...
+        QRegion clipRegion = systemClip();
+        QClipData *clip = new QClipData(d->rasterBuffer->height());
+
+        if (clipRegion.isEmpty())
+            clip->setClipRect(clipRect);
+        else
+            clip->setClipRegion(clipRegion & clipRect);
+
+        if (s->flags.has_clip_ownership)
+            delete s->clip;
+
+        s->clip = clip;
+        s->clip->enabled = true;
+        s->flags.has_clip_ownership = true;
+
+    } else if (op == Qt::IntersectClip){ // intersect clip with current clip
+        QClipData *base = s->clip;
+
+        Q_ASSERT(base);
+        if (base->hasRectClip || base->hasRegionClip) {
+            if (!s->flags.has_clip_ownership) {
+                s->clip = new QClipData(d->rasterBuffer->height());
+                s->flags.has_clip_ownership = true;
+            }
+            if (base->hasRectClip)
+                s->clip->setClipRect(base->clipRect & clipRect);
+            else
+                s->clip->setClipRegion(base->clipRegion & clipRect);
+            s->clip->enabled = true;
+        } else {
+            return false;
+        }
+    } else {
+        return false;
+    }
+
+    qrasterpaintengine_dirty_clip(d, s);
+    return true;
+}
+
+
+/*!
+    \internal
+*/
+void QRasterPaintEngine::clip(const QRegion &region, Qt::ClipOperation op)
+{
+#ifdef QT_DEBUG_DRAW
+    qDebug() << "QRasterPaintEngine::clip(): " << region << op;
+#endif
+
+    Q_D(QRasterPaintEngine);
+
+    if (region.rectCount() == 1) {
+        clip(region.boundingRect(), op);
+        return;
+    }
+
+    QRasterPaintEngineState *s = state();
+    const QClipData *clip = d->clip();
+    const QClipData *baseClip = d->baseClip.data();
+
+    if (op == Qt::NoClip) {
+        qrasterpaintengine_state_setNoClip(s);
+    } else if (s->matrix.type() > QTransform::TxScale
+               || op == Qt::UniteClip
+               || (op == Qt::IntersectClip && !clip->hasRectClip && !clip->hasRegionClip)
+               || (op == Qt::ReplaceClip && !baseClip->hasRectClip && !baseClip->hasRegionClip)) {
+        QPaintEngineEx::clip(region, op);
+    } else {
+        const QClipData *curClip;
+        QClipData *newClip;
+
+        if (op == Qt::IntersectClip)
+            curClip = clip;
+        else
+            curClip = baseClip;
+
+        if (s->flags.has_clip_ownership) {
+            newClip = s->clip;
+            Q_ASSERT(newClip);
+        } else {
+            newClip = new QClipData(d->rasterBuffer->height());
+            s->clip = newClip;
+            s->flags.has_clip_ownership = true;
+        }
+
+        QRegion r = s->matrix.map(region);
+        if (curClip->hasRectClip)
+            newClip->setClipRegion(r & curClip->clipRect);
+        else if (curClip->hasRegionClip)
+            newClip->setClipRegion(r & curClip->clipRegion);
+
+        qrasterpaintengine_dirty_clip(d, s);
+    }
+}
+
+/*!
+    \internal
+*/
+void QRasterPaintEngine::fillPath(const QPainterPath &path, QSpanData *fillData)
+{
+#ifdef QT_DEBUG_DRAW
+    qDebug() << " --- fillPath, bounds=" << path.boundingRect();
+#endif
+
+    if (!fillData->blend)
+        return;
+
+    Q_D(QRasterPaintEngine);
+
+    const QRectF controlPointRect = path.controlPointRect();
+
+    QRasterPaintEngineState *s = state();
+    const QRect deviceRect = s->matrix.mapRect(controlPointRect).toRect();
+    ProcessSpans blend = d->getBrushFunc(deviceRect, fillData);
+    const bool do_clip = (deviceRect.left() < -QT_RASTER_COORD_LIMIT
+                          || deviceRect.right() > QT_RASTER_COORD_LIMIT
+                          || deviceRect.top() < -QT_RASTER_COORD_LIMIT
+                          || deviceRect.bottom() > QT_RASTER_COORD_LIMIT);
+
+    if (!s->flags.antialiased && !do_clip) {
+        d->initializeRasterizer(fillData);
+        d->rasterizer->rasterize(path * s->matrix, path.fillRule());
+        return;
+    }
+
+    ensureOutlineMapper();
+    d->rasterize(d->outlineMapper->convertPath(path), blend, fillData, d->rasterBuffer.data());
+}
+
+static void fillRect_normalized(const QRect &r, QSpanData *data,
+                                QRasterPaintEnginePrivate *pe)
+{
+    int x1, x2, y1, y2;
+
+    bool rectClipped = true;
+
+    if (data->clip) {
+        x1 = qMax(r.x(), data->clip->xmin);
+        x2 = qMin(r.x() + r.width(), data->clip->xmax);
+        y1 = qMax(r.y(), data->clip->ymin);
+        y2 = qMin(r.y() + r.height(), data->clip->ymax);
+        rectClipped = data->clip->hasRectClip;
+
+    } else if (pe) {
+        x1 = qMax(r.x(), pe->deviceRect.x());
+        x2 = qMin(r.x() + r.width(), pe->deviceRect.x() + pe->deviceRect.width());
+        y1 = qMax(r.y(), pe->deviceRect.y());
+        y2 = qMin(r.y() + r.height(), pe->deviceRect.y() + pe->deviceRect.height());
+    } else {
+        x1 = qMax(r.x(), 0);
+        x2 = qMin(r.x() + r.width(), data->rasterBuffer->width());
+        y1 = qMax(r.y(), 0);
+        y2 = qMin(r.y() + r.height(), data->rasterBuffer->height());
+    }
+
+    if (x2 <= x1 || y2 <= y1)
+        return;
+
+    const int width = x2 - x1;
+    const int height = y2 - y1;
+
+    bool isUnclipped = rectClipped
+                       || (pe && pe->isUnclipped_normalized(QRect(x1, y1, width, height)));
+
+    if (pe && isUnclipped) {
+        const QPainter::CompositionMode mode = pe->rasterBuffer->compositionMode;
+
+        if (data->fillRect && (mode == QPainter::CompositionMode_Source
+                               || (mode == QPainter::CompositionMode_SourceOver
+                                   && qAlpha(data->solid.color) == 255)))
+        {
+            data->fillRect(data->rasterBuffer, x1, y1, width, height,
+                           data->solid.color);
+            return;
+        }
+    }
+
+    ProcessSpans blend = isUnclipped ? data->unclipped_blend : data->blend;
+
+    const int nspans = 256;
+    QT_FT_Span spans[nspans];
+
+    Q_ASSERT(data->blend);
+    int y = y1;
+    while (y < y2) {
+        int n = qMin(nspans, y2 - y);
+        int i = 0;
+        while (i < n) {
+            spans[i].x = x1;
+            spans[i].len = width;
+            spans[i].y = y + i;
+            spans[i].coverage = 255;
+            ++i;
+        }
+
+        blend(n, spans, data);
+        y += n;
+    }
+}
+
+/*!
+    \reimp
+*/
+void QRasterPaintEngine::drawRects(const QRect *rects, int rectCount)
+{
+#ifdef QT_DEBUG_DRAW
+    qDebug(" - QRasterPaintEngine::drawRect(), rectCount=%d", rectCount);
+#endif
+    Q_D(QRasterPaintEngine);
+    QRasterPaintEngineState *s = state();
+
+    // Fill
+    ensureBrush();
+    if (s->brushData.blend) {
+        if (!s->flags.antialiased && s->matrix.type() <= QTransform::TxTranslate) {
+            const QRect *r = rects;
+            const QRect *lastRect = rects + rectCount;
+
+            int offset_x = int(s->matrix.dx());
+            int offset_y = int(s->matrix.dy());
+            while (r < lastRect) {
+                QRect rect = r->normalized();
+                QRect rr = rect.translated(offset_x, offset_y);
+                fillRect_normalized(rr, &s->brushData, d);
+                ++r;
+            }
+        } else {
+            QRectVectorPath path;
+            for (int i=0; i<rectCount; ++i) {
+                path.set(rects[i]);
+                fill(path, s->brush);
+            }
+        }
+    }
+
+    ensurePen();
+    if (s->penData.blend) {
+        if (s->flags.fast_pen && s->lastPen.brush().isOpaque()) {
+            const QRect *r = rects;
+            const QRect *lastRect = rects + rectCount;
+            while (r < lastRect) {
+                int left = r->x();
+                int right = r->x() + r->width();
+                int top = r->y();
+                int bottom = r->y() + r->height();
+
+#ifdef Q_WS_MAC
+                int pts[] = { top, left,
+                              top, right,
+                              bottom, right,
+                              bottom, left };
+#else
+                int pts[] = { left, top,
+                              right, top,
+                              right, bottom,
+                              left, bottom };
+#endif
+
+                strokePolygonCosmetic((QPoint *) pts, 4, WindingMode);
+                ++r;
+            }
+        } else {
+            QRectVectorPath path;
+            for (int i = 0; i < rectCount; ++i) {
+                path.set(rects[i]);
+                stroke(path, s->pen);
+            }
+        }
+    }
+}
+
+/*!
+    \reimp
+*/
+void QRasterPaintEngine::drawRects(const QRectF *rects, int rectCount)
+{
+#ifdef QT_DEBUG_DRAW
+    qDebug(" - QRasterPaintEngine::drawRect(), rectCount=%d", rectCount);
+#endif
+#ifdef QT_FAST_SPANS
+    Q_D(QRasterPaintEngine);
+    QRasterPaintEngineState *s = state();
+
+    ensureState();
+
+    if (s->flags.tx_noshear) {
+        ensureBrush();
+        if (s->brushData.blend) {
+            d->initializeRasterizer(&s->brushData);
+            for (int i = 0; i < rectCount; ++i) {
+                const QRectF &rect = rects[i].normalized();
+                if (rect.isEmpty())
+                    continue;
+                const QPointF a = s->matrix.map((rect.topLeft() + rect.bottomLeft()) * 0.5f);
+                const QPointF b = s->matrix.map((rect.topRight() + rect.bottomRight()) * 0.5f);
+                d->rasterizer->rasterizeLine(a, b, rect.height() / rect.width());
+            }
+        }
+
+        ensurePen();
+        if (s->penData.blend) {
+            qreal width = s->pen.isCosmetic()
+                          ? (s->lastPen.widthF() == 0 ? 1 : s->lastPen.widthF())
+                          : s->lastPen.widthF() * s->txscale;
+
+            if (s->flags.fast_pen && s->lastPen.brush().isOpaque()) {
+                for (int i = 0; i < rectCount; ++i) {
+                    const QRectF &r = rects[i];
+                    qreal left = r.x();
+                    qreal right = r.x() + r.width();
+                    qreal top = r.y();
+                    qreal bottom = r.y() + r.height();
+                    qreal pts[] = { left, top,
+                                    right, top,
+                                    right, bottom,
+                                    left, bottom };
+                    strokePolygonCosmetic((QPointF *) pts, 4, WindingMode);
+                }
+            } else if (width <= 1 && qpen_style(s->lastPen) == Qt::SolidLine) {
+                d->initializeRasterizer(&s->penData);
+
+                for (int i = 0; i < rectCount; ++i) {
+                    const QRectF &rect = rects[i].normalized();
+                    if (rect.isEmpty()) {
+                        qreal pts[] = { rect.left(), rect.top(), rect.right(), rect.bottom() };
+                        QVectorPath vp(pts, 2, 0, QVectorPath::LinesHint);
+                        QPaintEngineEx::stroke(vp, s->lastPen);
+                    } else {
+                        const QPointF tl = s->matrix.map(rect.topLeft());
+                        const QPointF tr = s->matrix.map(rect.topRight());
+                        const QPointF bl = s->matrix.map(rect.bottomLeft());
+                        const QPointF br = s->matrix.map(rect.bottomRight());
+                        const qreal w = width / (rect.width() * s->txscale);
+                        const qreal h = width / (rect.height() * s->txscale);
+                        d->rasterizer->rasterizeLine(tl, tr, w); // top
+                        d->rasterizer->rasterizeLine(bl, br, w); // bottom
+                        d->rasterizer->rasterizeLine(bl, tl, h); // left
+                        d->rasterizer->rasterizeLine(br, tr, h); // right
+                    }
+                }
+            } else {
+                for (int i = 0; i < rectCount; ++i) {
+                    const QRectF &r = rects[i];
+                    qreal left = r.x();
+                    qreal right = r.x() + r.width();
+                    qreal top = r.y();
+                    qreal bottom = r.y() + r.height();
+                    qreal pts[] = { left, top,
+                                    right, top,
+                                    right, bottom,
+                                    left, bottom,
+                                    left, top };
+                    QVectorPath vp(pts, 5, 0, QVectorPath::RectangleHint);
+                    QPaintEngineEx::stroke(vp, s->lastPen);
+                }
+            }
+        }
+
+        return;
+    }
+#endif // QT_FAST_SPANS
+    QPaintEngineEx::drawRects(rects, rectCount);
+}
+
+
+/*!
+    \internal
+*/
+void QRasterPaintEngine::stroke(const QVectorPath &path, const QPen &pen)
+{
+    QRasterPaintEngineState *s = state();
+    ensurePen(pen);
+    if (!s->penData.blend)
+        return;
+
+    if (s->flags.fast_pen && !path.isCurved()
+        && s->lastPen.brush().isOpaque()) {
+        int count = path.elementCount();
+        QPointF *points = (QPointF *) path.points();
+        const QPainterPath::ElementType *types = path.elements();
+        if (types) {
+            int first = 0;
+            int last;
+            while (first < count) {
+                while (first < count && types[first] != QPainterPath::MoveToElement) ++first;
+                last = first + 1;
+                while (last < count && types[last] == QPainterPath::LineToElement) ++last;
+                strokePolygonCosmetic(points + first, last - first,
+                                      path.hasImplicitClose() && last == count // only close last one..
+                                      ? WindingMode
+                                      : PolylineMode);
+                first = last;
+            }
+        } else {
+            strokePolygonCosmetic(points, count,
+                                  path.hasImplicitClose()
+                                  ? WindingMode
+                                  : PolylineMode);
+        }
+
+    } else if (s->flags.non_complex_pen && path.shape() == QVectorPath::LinesHint) {
+        qreal width = s->lastPen.isCosmetic()
+                      ? (qpen_widthf(s->lastPen) == 0 ? 1 : qpen_widthf(s->lastPen))
+                      : qpen_widthf(s->lastPen) * s->txscale;
+        int dashIndex = 0;
+        qreal dashOffset = s->lastPen.dashOffset();
+        bool inDash = true;
+        qreal patternLength = 0;
+        const QVector<qreal> pattern = s->lastPen.dashPattern();
+        for (int i = 0; i < pattern.size(); ++i)
+            patternLength += pattern.at(i);
+
+        if (patternLength > 0) {
+            int n = qFloor(dashOffset / patternLength);
+            dashOffset -= n * patternLength;
+            while (dashOffset >= pattern.at(dashIndex)) {
+                dashOffset -= pattern.at(dashIndex);
+                if (++dashIndex >= pattern.size())
+                    dashIndex = 0;
+                inDash = !inDash;
+            }
+        }
+
+        Q_D(QRasterPaintEngine);
+        d->initializeRasterizer(&s->penData);
+        int lineCount = path.elementCount() / 2;
+        const QLineF *lines = reinterpret_cast<const QLineF *>(path.points());
+
+        for (int i = 0; i < lineCount; ++i) {
+            if (lines[i].p1() == lines[i].p2()) {
+                if (s->lastPen.capStyle() != Qt::FlatCap) {
+                    QPointF p = lines[i].p1();
+                    QLineF line = s->matrix.map(QLineF(QPointF(p.x() - width*0.5, p.y()),
+                                                       QPointF(p.x() + width*0.5, p.y())));
+                    d->rasterizer->rasterizeLine(line.p1(), line.p2(), 1);
+                }
+                continue;
+            }
+
+            const QLineF line = s->matrix.map(lines[i]);
+            if (qpen_style(s->lastPen) == Qt::SolidLine) {
+                d->rasterizer->rasterizeLine(line.p1(), line.p2(),
+                                            width / line.length(),
+                                            s->lastPen.capStyle() == Qt::SquareCap);
+            } else {
+                d->rasterizeLine_dashed(line, width,
+                                        &dashIndex, &dashOffset, &inDash);
+            }
+        }
+    }
+    else
+        QPaintEngineEx::stroke(path, pen);
+}
+
+static inline QRect toNormalizedFillRect(const QRectF &rect)
+{
+    int x1 = qRound(rect.x());
+    int y1 = qRound(rect.y());
+    int x2 = qRound(rect.right());
+    int y2 = qRound(rect.bottom());
+
+    if (x2 < x1)
+        qSwap(x1, x2);
+    if (y2 < y1)
+        qSwap(y1, y2);
+
+    return QRect(x1, y1, x2 - x1, y2 - y1);
+}
+
+/*!
+    \internal
+*/
+void QRasterPaintEngine::fill(const QVectorPath &path, const QBrush &brush)
+{
+    if (path.isEmpty())
+        return;
+#ifdef QT_DEBUG_DRAW
+    QRectF rf = path.controlPointRect();
+    qDebug() << "QRasterPaintEngine::fill(): "
+             << "size=" << path.elementCount()
+             << ", hints=" << hex << path.hints()
+             << rf << brush;
+#endif
+
+    Q_D(QRasterPaintEngine);
+    QRasterPaintEngineState *s = state();
+
+    ensureBrush(brush);
+    if (!s->brushData.blend)
+        return;
+
+    if (path.shape() == QVectorPath::RectangleHint) {
+        if (!s->flags.antialiased && s->matrix.type() <= QTransform::TxScale) {
+            const qreal *p = path.points();
+            QPointF tl = QPointF(p[0], p[1]) * s->matrix;
+            QPointF br = QPointF(p[4], p[5]) * s->matrix;
+            fillRect_normalized(toNormalizedFillRect(QRectF(tl, br)), &s->brushData, d);
+            return;
+        }
+        ensureState();
+        if (s->flags.tx_noshear) {
+            d->initializeRasterizer(&s->brushData);
+            // ### Is normalizing really necessary here?
+            const qreal *p = path.points();
+            QRectF r = QRectF(p[0], p[1], p[2] - p[0], p[7] - p[1]).normalized();
+            if (!r.isEmpty()) {
+                const QPointF a = s->matrix.map((r.topLeft() + r.bottomLeft()) * 0.5f);
+                const QPointF b = s->matrix.map((r.topRight() + r.bottomRight()) * 0.5f);
+                d->rasterizer->rasterizeLine(a, b, r.height() / r.width());
+            }
+            return;
+        }
+    }
+
+    if (path.shape() == QVectorPath::EllipseHint) {
+        if (!s->flags.antialiased && s->matrix.type() <= QTransform::TxScale) {
+            const qreal *p = path.points();
+            QPointF tl = QPointF(p[0], p[1]) * s->matrix;
+            QPointF br = QPointF(p[4], p[5]) * s->matrix;
+            QRectF r = s->matrix.mapRect(QRectF(tl, br));
+
+            ProcessSpans penBlend = d->getPenFunc(r, &s->penData);
+            ProcessSpans brushBlend = d->getBrushFunc(r, &s->brushData);
+            const QRect brect = QRect(int(r.x()), int(r.y()),
+                                      int_dim(r.x(), r.width()),
+                                      int_dim(r.y(), r.height()));
+            if (brect == r) {
+                drawEllipse_midpoint_i(brect, d->deviceRect, penBlend, brushBlend,
+                                       &s->penData, &s->brushData);
+                return;
+            }
+        }
+    }
+
+    // ### Optimize for non transformed ellipses and rectangles...
+    QRectF cpRect = path.controlPointRect();
+    const QRect deviceRect = s->matrix.mapRect(cpRect).toRect();
+    ProcessSpans blend = d->getBrushFunc(deviceRect, &s->brushData);
+
+        // ### Falcon
+//         const bool do_clip = (deviceRect.left() < -QT_RASTER_COORD_LIMIT
+//                               || deviceRect.right() > QT_RASTER_COORD_LIMIT
+//                               || deviceRect.top() < -QT_RASTER_COORD_LIMIT
+//                               || deviceRect.bottom() > QT_RASTER_COORD_LIMIT);
+
+        // ### Falonc: implement....
+//         if (!s->flags.antialiased && !do_clip) {
+//             d->initializeRasterizer(&s->brushData);
+//             d->rasterizer->rasterize(path * d->matrix, path.fillRule());
+//             return;
+//         }
+
+    ensureOutlineMapper();
+    d->rasterize(d->outlineMapper->convertPath(path), blend, &s->brushData, d->rasterBuffer.data());
+}
+
+void QRasterPaintEngine::fillRect(const QRectF &r, QSpanData *data)
+{
+    Q_D(QRasterPaintEngine);
+    QRasterPaintEngineState *s = state();
+
+    if (!s->flags.antialiased) {
+        uint txop = s->matrix.type();
+        if (txop == QTransform::TxNone) {
+            fillRect_normalized(toNormalizedFillRect(r), data, d);
+            return;
+        } else if (txop == QTransform::TxTranslate) {
+            const QRect rr = toNormalizedFillRect(r.translated(s->matrix.dx(), s->matrix.dy()));
+            fillRect_normalized(rr, data, d);
+            return;
+        } else if (txop == QTransform::TxScale) {
+            const QRect rr = toNormalizedFillRect(s->matrix.mapRect(r));
+            fillRect_normalized(rr, data, d);
+            return;
+        }
+    }
+    ensureState();
+    if (s->flags.tx_noshear) {
+        d->initializeRasterizer(data);
+        QRectF nr = r.normalized();
+        if (!nr.isEmpty()) {
+            const QPointF a = s->matrix.map((nr.topLeft() + nr.bottomLeft()) * 0.5f);
+            const QPointF b = s->matrix.map((nr.topRight() + nr.bottomRight()) * 0.5f);
+            d->rasterizer->rasterizeLine(a, b, nr.height() / nr.width());
+        }
+        return;
+    }
+
+    QPainterPath path;
+    path.addRect(r);
+    ensureOutlineMapper();
+    fillPath(path, data);
+}
+
+/*!
+    \reimp
+*/
+void QRasterPaintEngine::fillRect(const QRectF &r, const QBrush &brush)
+{
+#ifdef QT_DEBUG_DRAW
+    qDebug() << "QRasterPaintEngine::fillRecct(): " << r << brush;
+#endif
+    QRasterPaintEngineState *s = state();
+
+    ensureBrush(brush);
+    if (!s->brushData.blend)
+        return;
+
+    fillRect(r, &s->brushData);
+}
+
+/*!
+    \reimp
+*/
+void QRasterPaintEngine::fillRect(const QRectF &r, const QColor &color)
+{
+#ifdef QT_DEBUG_DRAW
+    qDebug() << "QRasterPaintEngine::fillRect(): " << r << color;
+#endif
+    Q_D(QRasterPaintEngine);
+    QRasterPaintEngineState *s = state();
+
+    d->solid_color_filler.solid.color = PREMUL(ARGB_COMBINE_ALPHA(color.rgba(), s->intOpacity));
+    if ((d->solid_color_filler.solid.color & 0xff000000) == 0
+        && s->composition_mode == QPainter::CompositionMode_SourceOver) {
+        return;
+    }
+    d->solid_color_filler.clip = d->clip();
+    d->solid_color_filler.adjustSpanMethods();
+    fillRect(r, &d->solid_color_filler);
+}
+
+static inline bool isAbove(const QPointF *a, const QPointF *b)
+{
+    return a->y() < b->y();
+}
+
+static bool splitPolygon(const QPointF *points, int pointCount, QVector<QPointF> *upper, QVector<QPointF> *lower)
+{
+    Q_ASSERT(upper);
+    Q_ASSERT(lower);
+
+    Q_ASSERT(pointCount >= 2);
+
+    QVector<const QPointF *> sorted;
+    sorted.reserve(pointCount);
+
+    upper->reserve(pointCount * 3 / 4);
+    lower->reserve(pointCount * 3 / 4);
+
+    for (int i = 0; i < pointCount; ++i)
+        sorted << points + i;
+
+    qSort(sorted.begin(), sorted.end(), isAbove);
+
+    qreal splitY = sorted.at(sorted.size() / 2)->y();
+
+    const QPointF *end = points + pointCount;
+    const QPointF *last = end - 1;
+
+    QVector<QPointF> *bin[2] = { upper, lower };
+
+    for (const QPointF *p = points; p < end; ++p) {
+        int side = p->y() < splitY;
+        int lastSide = last->y() < splitY;
+
+        if (side != lastSide) {
+            if (qFuzzyCompare(p->y(), splitY)) {
+                bin[!side]->append(*p);
+            } else if (qFuzzyCompare(last->y(), splitY)) {
+                bin[side]->append(*last);
+            } else {
+                QPointF delta = *p - *last;
+                QPointF intersection(p->x() + delta.x() * (splitY - p->y()) / delta.y(), splitY);
+
+                bin[0]->append(intersection);
+                bin[1]->append(intersection);
+            }
+        }
+
+        bin[side]->append(*p);
+
+        last = p;
+    }
+
+    // give up if we couldn't reduce the point count
+    return upper->size() < pointCount && lower->size() < pointCount;
+}
+
+/*!
+  \internal
+ */
+void QRasterPaintEngine::fillPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode)
+{
+    Q_D(QRasterPaintEngine);
+    QRasterPaintEngineState *s = state();
+
+    const int maxPoints = 0xffff;
+
+    // max amount of points that raster engine can reliably handle
+    if (pointCount > maxPoints) {
+        QVector<QPointF> upper, lower;
+
+        if (splitPolygon(points, pointCount, &upper, &lower)) {
+            fillPolygon(upper.constData(), upper.size(), mode);
+            fillPolygon(lower.constData(), lower.size(), mode);
+        } else
+            qWarning("Polygon too complex for filling.");
+
+        return;
+    }
+
+    // Compose polygon fill..,
+    QVectorPath vp((qreal *) points, pointCount, 0, QVectorPath::polygonFlags(mode));
+    ensureOutlineMapper();
+    QT_FT_Outline *outline = d->outlineMapper->convertPath(vp);
+
+    // scanconvert.
+    ProcessSpans brushBlend = d->getBrushFunc(d->outlineMapper->controlPointRect,
+                                              &s->brushData);
+    d->rasterize(outline, brushBlend, &s->brushData, d->rasterBuffer.data());
+}
+
+/*!
+    \reimp
+*/
+void QRasterPaintEngine::drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode)
+{
+    QRasterPaintEngineState *s = state();
+
+#ifdef QT_DEBUG_DRAW
+    qDebug(" - QRasterPaintEngine::drawPolygon(F), pointCount=%d", pointCount);
+    for (int i=0; i<pointCount; ++i)
+        qDebug() << "   - " << points[i];
+#endif
+    Q_ASSERT(pointCount >= 2);
+
+    if (mode != PolylineMode && isRect((qreal *) points, pointCount)) {
+        QRectF r(points[0], points[2]);
+        drawRects(&r, 1);
+        return;
+    }
+
+    ensurePen();
+    ensureBrush();
+    if (mode != PolylineMode) {
+        // Do the fill...
+        if (s->brushData.blend) {
+            fillPolygon(points, pointCount, mode);
+        }
+    }
+
+    // Do the outline...
+    if (s->penData.blend) {
+        if (s->flags.fast_pen && s->lastPen.brush().isOpaque())
+            strokePolygonCosmetic(points, pointCount, mode);
+        else {
+            QVectorPath vp((qreal *) points, pointCount, 0, QVectorPath::polygonFlags(mode));
+            QPaintEngineEx::stroke(vp, s->lastPen);
+        }
+    }
+}
+
+/*!
+    \reimp
+*/
+void QRasterPaintEngine::drawPolygon(const QPoint *points, int pointCount, PolygonDrawMode mode)
+{
+    Q_D(QRasterPaintEngine);
+    QRasterPaintEngineState *s = state();
+
+#ifdef QT_DEBUG_DRAW
+    qDebug(" - QRasterPaintEngine::drawPolygon(I), pointCount=%d", pointCount);
+    for (int i=0; i<pointCount; ++i)
+        qDebug() << "   - " << points[i];
+#endif
+    Q_ASSERT(pointCount >= 2);
+    if (mode != PolylineMode && isRect((int *) points, pointCount)) {
+        QRect r(points[0].x(),
+                points[0].y(),
+                points[2].x() - points[0].x(),
+                points[2].y() - points[0].y());
+        drawRects(&r, 1);
+        return;
+    }
+
+    ensureState();
+    ensurePen();
+    if (!(s->flags.int_xform && s->flags.fast_pen && (!s->penData.blend || s->pen.brush().isOpaque()))) {
+        // this calls the float version
+        QPaintEngineEx::drawPolygon(points, pointCount, mode);
+        return;
+    }
+
+    // Do the fill
+    if (mode != PolylineMode) {
+        ensureBrush();
+        if (s->brushData.blend) {
+            // Compose polygon fill..,
+            ensureOutlineMapper();
+            d->outlineMapper->beginOutline(mode == WindingMode ? Qt::WindingFill : Qt::OddEvenFill);
+            d->outlineMapper->moveTo(*points);
+            const QPoint *p = points;
+            const QPoint *ep = points + pointCount - 1;
+            do {
+                d->outlineMapper->lineTo(*(++p));
+            } while (p < ep);
+            d->outlineMapper->endOutline();
+
+            // scanconvert.
+            ProcessSpans brushBlend = d->getBrushFunc(d->outlineMapper->controlPointRect,
+                                                      &s->brushData);
+            d->rasterize(d->outlineMapper->outline(), brushBlend, &s->brushData, d->rasterBuffer.data());
+        }
+    }
+
+    // Do the outline...
+    if (s->penData.blend) {
+        if (s->flags.fast_pen && s->lastPen.brush().isOpaque())
+            strokePolygonCosmetic(points, pointCount, mode);
+        else {
+            int count = pointCount * 2;
+            QVarLengthArray<qreal> fpoints(count);
+#ifdef Q_WS_MAC
+            for (int i=0; i<count; i+=2) {
+                fpoints[i] = ((int *) points)[i+1];
+                fpoints[i+1] = ((int *) points)[i];
+            }
+#else
+            for (int i=0; i<count; ++i)
+                fpoints[i] = ((int *) points)[i];
+#endif
+            QVectorPath vp((qreal *) fpoints.data(), pointCount, 0, QVectorPath::polygonFlags(mode));
+            QPaintEngineEx::stroke(vp, s->lastPen);
+        }
+    }
+}
+
+/*!
+    \internal
+*/
+void QRasterPaintEngine::strokePolygonCosmetic(const QPointF *points, int pointCount, PolygonDrawMode mode)
+{
+    Q_D(QRasterPaintEngine);
+    QRasterPaintEngineState *s = state();
+
+    Q_ASSERT(s->penData.blend);
+    Q_ASSERT(s->flags.fast_pen);
+
+    bool needs_closing = mode != PolylineMode && points[0] != points[pointCount-1];
+
+    // Use fast path for 0 width /  trivial pens.
+    QIntRect devRect;
+    devRect.set(d->deviceRect);
+
+    LineDrawMode mode_for_last = (s->lastPen.capStyle() != Qt::FlatCap
+                                  ? LineDrawIncludeLastPixel
+                                  : LineDrawNormal);
+    int dashOffset = int(s->lastPen.dashOffset());
+
+    // Draw all the line segments.
+    for (int i=1; i<pointCount; ++i) {
+
+        QPointF lp1 = points[i-1] * s->matrix;
+        QPointF lp2 = points[i] * s->matrix;
+
+        const QRectF brect(lp1, lp2);
+        ProcessSpans penBlend = d->getPenFunc(brect, &s->penData);
+        if (qpen_style(s->lastPen) == Qt::SolidLine) {
+            drawLine_midpoint_i(qFloor(lp1.x()), qFloor(lp1.y()),
+                                qFloor(lp2.x()), qFloor(lp2.y()),
+                                penBlend, &s->penData,
+                                i == pointCount - 1 ? mode_for_last : LineDrawIncludeLastPixel,
+                                devRect);
+        } else {
+            drawLine_midpoint_dashed_i(qFloor(lp1.x()), qFloor(lp1.y()),
+                                       qFloor(lp2.x()), qFloor(lp2.y()),
+                                       &s->lastPen,
+                                       penBlend, &s->penData,
+                                       i == pointCount - 1 ? mode_for_last : LineDrawIncludeLastPixel,
+                                       devRect, &dashOffset);
+        }
+    }
+
+    // Polygons are implicitly closed.
+    if (needs_closing) {
+        QPointF lp1 = points[pointCount-1] * s->matrix;
+        QPointF lp2 = points[0] * s->matrix;
+
+        const QRectF brect(lp1, lp2);
+        ProcessSpans penBlend = d->getPenFunc(brect, &s->penData);
+        if (qpen_style(s->lastPen) == Qt::SolidLine) {
+            drawLine_midpoint_i(qFloor(lp1.x()), qFloor(lp1.y()),
+                                qFloor(lp2.x()), qFloor(lp2.y()),
+                                penBlend, &s->penData,
+                                LineDrawIncludeLastPixel,
+                                devRect);
+        } else {
+            drawLine_midpoint_dashed_i(qFloor(lp1.x()), qFloor(lp1.y()),
+                                       qFloor(lp2.x()), qFloor(lp2.y()),
+                                       &s->lastPen,
+                                       penBlend, &s->penData,
+                                       LineDrawIncludeLastPixel,
+                                       devRect, &dashOffset);
+        }
+    }
+
+}
+
+/*!
+    \internal
+*/
+void QRasterPaintEngine::strokePolygonCosmetic(const QPoint *points, int pointCount, PolygonDrawMode mode)
+{
+    Q_D(QRasterPaintEngine);
+    QRasterPaintEngineState *s = state();
+
+    // We assert here because this function is called from drawRects
+    // and drawPolygon and they already do ensurePen(), so we skip that
+    // here to avoid duplicate checks..
+    Q_ASSERT(s->penData.blend);
+
+    bool needs_closing = mode != PolylineMode && points[0] != points[pointCount-1];
+
+    QIntRect devRect;
+    devRect.set(d->deviceRect);
+
+    LineDrawMode mode_for_last = (s->lastPen.capStyle() != Qt::FlatCap
+                                  ? LineDrawIncludeLastPixel
+                                  : LineDrawNormal);
+
+    int m11 = int(s->matrix.m11());
+    int m22 = int(s->matrix.m22());
+    int dx = int(s->matrix.dx());
+    int dy = int(s->matrix.dy());
+    int m13 = int(s->matrix.m13());
+    int m23 = int(s->matrix.m23());
+    bool affine = !m13 && !m23;
+
+    int dashOffset = int(s->lastPen.dashOffset());
+
+    if (affine) {
+        // Draw all the line segments.
+        for (int i=1; i<pointCount; ++i) {
+            const QPoint lp1 = points[i-1] * s->matrix;
+            const QPoint lp2 = points[i] * s->matrix;
+            const QRect brect(lp1, lp2);
+            ProcessSpans penBlend = d->getPenFunc(brect, &s->penData);
+
+            if (qpen_style(s->lastPen) == Qt::SolidLine)
+                drawLine_midpoint_i(lp1.x(), lp1.y(),
+                                    lp2.x(), lp2.y(),
+                                    penBlend, &s->penData,
+                                    i == pointCount - 1 ? mode_for_last : LineDrawIncludeLastPixel,
+                                    devRect);
+            else
+                drawLine_midpoint_dashed_i(lp1.x(), lp1.y(),
+                                           lp2.x(), lp2.y(),
+                                           &s->lastPen,
+                                           penBlend, &s->penData,
+                                           i == pointCount - 1 ? mode_for_last : LineDrawIncludeLastPixel,
+                                           devRect, &dashOffset);
+
+        }
+
+        // Polygons are implicitly closed.
+        if (needs_closing) {
+            const QPoint lp1 = points[pointCount - 1] * s->matrix;
+            const QPoint lp2 = points[0] * s->matrix;
+            const QRect brect(lp1, lp2);
+            ProcessSpans penBlend = d->getPenFunc(brect, &s->penData);
+
+            if (qpen_style(s->lastPen) == Qt::SolidLine)
+                drawLine_midpoint_i(lp1.x(), lp1.y(),
+                                    lp2.x(), lp2.y(),
+                                    penBlend, &s->penData, LineDrawIncludeLastPixel,
+                                    devRect);
+            else
+                drawLine_midpoint_dashed_i(lp1.x(), lp1.y(),
+                                           lp2.x(), lp2.y(),
+                                           &s->lastPen,
+                                           penBlend, &s->penData, LineDrawIncludeLastPixel,
+                                           devRect, &dashOffset);
+        }
+    } else {
+        // Draw all the line segments.
+        for (int i=1; i<pointCount; ++i) {
+            int x1 = points[i-1].x() * m11 + dx;
+            int y1 = points[i-1].y() * m22 + dy;
+            qreal w = m13*points[i-1].x() + m23*points[i-1].y() + 1.;
+            w = 1/w;
+            x1 = int(x1*w);
+            y1 = int(y1*w);
+            int x2 = points[i].x() * m11 + dx;
+            int y2 = points[i].y() * m22 + dy;
+            w = m13*points[i].x() + m23*points[i].y() + 1.;
+            w = 1/w;
+            x2 = int(x2*w);
+            y2 = int(y2*w);
+
+            const QRect brect(x1, y1, x2 - x1 + 1, y2 - y1 + 1);
+            ProcessSpans penBlend = d->getPenFunc(brect, &s->penData);
+            if (qpen_style(s->lastPen) == Qt::SolidLine)
+                drawLine_midpoint_i(x1, y1, x2, y2,
+                                    penBlend, &s->penData,
+                                    i == pointCount - 1 ? mode_for_last : LineDrawIncludeLastPixel,
+                                    devRect);
+            else
+                drawLine_midpoint_dashed_i(x1, y1, x2, y2,
+                                           &s->lastPen,
+                                           penBlend, &s->penData,
+                                           i == pointCount - 1 ? mode_for_last : LineDrawIncludeLastPixel,
+                                           devRect, &dashOffset);
+
+        }
+
+        int x1 = points[pointCount-1].x() * m11 + dx;
+        int y1 = points[pointCount-1].y() * m22 + dy;
+        qreal w = m13*points[pointCount-1].x() + m23*points[pointCount-1].y() + 1.;
+        w = 1/w;
+        x1 = int(x1*w);
+        y1 = int(y1*w);
+        int x2 = points[0].x() * m11 + dx;
+        int y2 = points[0].y() * m22 + dy;
+        w = m13*points[0].x() + m23*points[0].y() + 1.;
+        w = 1/w;
+        x2 = int(x2 * w);
+        y2 = int(y2 * w);
+        // Polygons are implicitly closed.
+
+        if (needs_closing) {
+            const QRect brect(x1, y1, x2 - x1 + 1, y2 - y1 + 1);
+            ProcessSpans penBlend = d->getPenFunc(brect, &s->penData);
+            if (qpen_style(s->lastPen) == Qt::SolidLine)
+                drawLine_midpoint_i(x1, y1, x2, y2,
+                                    penBlend, &s->penData, LineDrawIncludeLastPixel,
+                                    devRect);
+            else
+                drawLine_midpoint_dashed_i(x1, y1, x2, y2,
+                                           &s->lastPen,
+                                           penBlend, &s->penData, LineDrawIncludeLastPixel,
+                                           devRect, &dashOffset);
+        }
+    }
+}
+
+/*!
+    \internal
+*/
+void QRasterPaintEngine::drawPixmap(const QPointF &pos, const QPixmap &pixmap)
+{
+#ifdef QT_DEBUG_DRAW
+    qDebug() << " - QRasterPaintEngine::drawPixmap(), pos=" << pos << " pixmap=" << pixmap.size() << "depth=" << pixmap.depth();
+#endif
+
+    QPixmapData *pd = pixmap.pixmapData();
+    if (pd->classId() == QPixmapData::RasterClass) {
+        const QImage &image = static_cast<QRasterPixmapData *>(pd)->image;
+        if (image.depth() == 1) {
+            Q_D(QRasterPaintEngine);
+            QRasterPaintEngineState *s = state();
+            if (s->matrix.type() <= QTransform::TxTranslate) {
+                ensurePen();
+                drawBitmap(pos + QPointF(s->matrix.dx(), s->matrix.dy()), image, &s->penData);
+            } else {
+                drawImage(pos, d->rasterBuffer->colorizeBitmap(image, s->pen.color()));
+            }
+        } else {
+            QRasterPaintEngine::drawImage(pos, image);
+        }
+    } else {
+        const QImage image = pixmap.toImage();
+        if (pixmap.depth() == 1) {
+            Q_D(QRasterPaintEngine);
+            QRasterPaintEngineState *s = state();
+            if (s->matrix.type() <= QTransform::TxTranslate) {
+                ensurePen();
+                drawBitmap(pos + QPointF(s->matrix.dx(), s->matrix.dy()), image, &s->penData);
+            } else {
+                drawImage(pos, d->rasterBuffer->colorizeBitmap(image, s->pen.color()));
+            }
+        } else {
+            QRasterPaintEngine::drawImage(pos, image);
+        }
+    }
+}
+
+/*!
+    \reimp
+*/
+void QRasterPaintEngine::drawPixmap(const QRectF &r, const QPixmap &pixmap, const QRectF &sr)
+{
+#ifdef QT_DEBUG_DRAW
+    qDebug() << " - QRasterPaintEngine::drawPixmap(), r=" << r << " sr=" << sr << " pixmap=" << pixmap.size() << "depth=" << pixmap.depth();
+#endif
+
+    QPixmapData* pd = pixmap.pixmapData();
+    if (pd->classId() == QPixmapData::RasterClass) {
+        const QImage &image = static_cast<QRasterPixmapData *>(pd)->image;
+        if (image.depth() == 1) {
+            Q_D(QRasterPaintEngine);
+            QRasterPaintEngineState *s = state();
+            if (s->matrix.type() <= QTransform::TxTranslate
+                && r.size() == sr.size()
+                && r.size() == pixmap.size()) {
+                ensurePen();
+                drawBitmap(r.topLeft() + QPointF(s->matrix.dx(), s->matrix.dy()), image, &s->penData);
+                return;
+            } else {
+                drawImage(r, d->rasterBuffer->colorizeBitmap(image, s->pen.color()), sr);
+            }
+        } else {
+            drawImage(r, image, sr);
+        }
+    } else {
+        QRect clippedSource = sr.toAlignedRect().intersected(pixmap.rect());
+        const QImage image = pd->toImage(clippedSource);
+        QRectF translatedSource = sr.translated(-clippedSource.topLeft());
+        if (image.depth() == 1) {
+            Q_D(QRasterPaintEngine);
+            QRasterPaintEngineState *s = state();
+            if (s->matrix.type() <= QTransform::TxTranslate
+                && r.size() == sr.size()
+                && r.size() == pixmap.size()) {
+                ensurePen();
+                drawBitmap(r.topLeft() + QPointF(s->matrix.dx(), s->matrix.dy()), image, &s->penData);
+                return;
+            } else {
+                drawImage(r, d->rasterBuffer->colorizeBitmap(image, s->pen.color()), translatedSource);
+            }
+        } else {
+            drawImage(r, image, translatedSource);
+        }
+    }
+}
+
+// assumes that rect has positive width and height
+static inline const QRect toRect_normalized(const QRectF &rect)
+{
+    const int x = qRound(rect.x());
+    const int y = qRound(rect.y());
+    const int w = int(rect.width() + qreal(0.5));
+    const int h = int(rect.height() + qreal(0.5));
+
+    return QRect(x, y, w, h);
+}
+
+static inline int fast_ceil_positive(const qreal &v)
+{
+    const int iv = int(v);
+    if (v - iv == 0)
+        return iv;
+    else
+        return iv + 1;
+}
+
+static inline const QRect toAlignedRect_positive(const QRectF &rect)
+{
+    const int xmin = int(rect.x());
+    const int xmax = int(fast_ceil_positive(rect.right()));
+    const int ymin = int(rect.y());
+    const int ymax = int(fast_ceil_positive(rect.bottom()));
+    return QRect(xmin, ymin, xmax - xmin, ymax - ymin);
+}
+
+/*!
+    \internal
+*/
+void QRasterPaintEngine::drawImage(const QPointF &p, const QImage &img)
+{
+#ifdef QT_DEBUG_DRAW
+    qDebug() << " - QRasterPaintEngine::drawImage(), p=" <<  p << " image=" << img.size() << "depth=" << img.depth();
+#endif
+
+    Q_D(QRasterPaintEngine);
+    QRasterPaintEngineState *s = state();
+
+    if (s->matrix.type() > QTransform::TxTranslate) {
+        drawImage(QRectF(p.x(), p.y(), img.width(), img.height()),
+                  img,
+                  QRectF(0, 0, img.width(), img.height()));
+    } else {
+
+        const QClipData *clip = d->clip();
+        QPointF pt(p.x() + s->matrix.dx(), p.y() + s->matrix.dy());
+
+        if (d->canUseFastImageBlending(d->rasterBuffer->compositionMode, img)) {
+            SrcOverBlendFunc func = qBlendFunctions[d->rasterBuffer->format][img.format()];
+            if (func) {
+                if (!clip) {
+                    d->drawImage(pt, img, func, d->deviceRect, s->intOpacity);
+                    return;
+                } else if (clip->hasRectClip) {
+                    d->drawImage(pt, img, func, clip->clipRect, s->intOpacity);
+                    return;
+                }
+            }
+        }
+
+
+
+        d->image_filler.clip = clip;
+        d->image_filler.initTexture(&img, s->intOpacity, QTextureData::Plain, img.rect());
+        if (!d->image_filler.blend)
+            return;
+        d->image_filler.dx = -pt.x();
+        d->image_filler.dy = -pt.y();
+        QRect rr = img.rect().translated(qRound(pt.x()), qRound(pt.y()));
+
+        fillRect_normalized(rr, &d->image_filler, d);
+    }
+
+}
+
+QRectF qt_mapRect_non_normalizing(const QRectF &r, const QTransform &t)
+{
+    return QRectF(r.topLeft() * t, r.bottomRight() * t);
+}
+
+namespace {
+    enum RotationType {
+        Rotation90,
+        Rotation180,
+        Rotation270,
+        NoRotation
+    };
+
+    inline RotationType qRotationType(const QTransform &transform)
+    {
+        QTransform::TransformationType type = transform.type();
+
+        if (type > QTransform::TxRotate)
+            return NoRotation;
+
+        if (type == QTransform::TxRotate && qFuzzyIsNull(transform.m11()) && qFuzzyCompare(transform.m12(), qreal(-1))
+            && qFuzzyCompare(transform.m21(), qreal(1)) && qFuzzyIsNull(transform.m22()))
+            return Rotation90;
+
+        if (type == QTransform::TxScale && qFuzzyCompare(transform.m11(), qreal(-1)) && qFuzzyIsNull(transform.m12())
+            && qFuzzyIsNull(transform.m21()) && qFuzzyCompare(transform.m22(), qreal(-1)))
+            return Rotation180;
+
+        if (type == QTransform::TxRotate && qFuzzyIsNull(transform.m11()) && qFuzzyCompare(transform.m12(), qreal(1))
+            && qFuzzyCompare(transform.m21(), qreal(-1)) && qFuzzyIsNull(transform.m22()))
+            return Rotation270;
+
+        return NoRotation;
+    }
+
+    inline bool isPixelAligned(const QRectF &rect) {
+        return QRectF(rect.toRect()) == rect;
+    }
+}
+
+/*!
+    \reimp
+*/
+void QRasterPaintEngine::drawImage(const QRectF &r, const QImage &img, const QRectF &sr,
+                                   Qt::ImageConversionFlags)
+{
+#ifdef QT_DEBUG_DRAW
+    qDebug() << " - QRasterPaintEngine::drawImage(), r=" << r << " sr=" << sr << " image=" << img.size() << "depth=" << img.depth();
+#endif
+
+    if (r.isEmpty())
+        return;
+
+    Q_D(QRasterPaintEngine);
+    QRasterPaintEngineState *s = state();
+    int sr_l = qFloor(sr.left());
+    int sr_r = qCeil(sr.right()) - 1;
+    int sr_t = qFloor(sr.top());
+    int sr_b = qCeil(sr.bottom()) - 1;
+
+    if (s->matrix.type() <= QTransform::TxScale && !s->flags.antialiased && sr_l == sr_r && sr_t == sr_b) {
+        QTransform old = s->matrix;
+
+        // Do whatever fillRect() does, but without premultiplying the color if it's already premultiplied.
+        QRgb color = img.pixel(sr_l, sr_t);
+        switch (img.format()) {
+        case QImage::Format_ARGB32_Premultiplied:
+        case QImage::Format_ARGB8565_Premultiplied:
+        case QImage::Format_ARGB6666_Premultiplied:
+        case QImage::Format_ARGB8555_Premultiplied:
+        case QImage::Format_ARGB4444_Premultiplied:
+            // Combine premultiplied color with the opacity set on the painter.
+            d->solid_color_filler.solid.color =
+                ((((color & 0x00ff00ff) * s->intOpacity) >> 8) & 0x00ff00ff)
+                | ((((color & 0xff00ff00) >> 8) * s->intOpacity) & 0xff00ff00);
+            break;
+        default:
+            d->solid_color_filler.solid.color = PREMUL(ARGB_COMBINE_ALPHA(color, s->intOpacity));
+            break;
+        }
+
+        if ((d->solid_color_filler.solid.color & 0xff000000) == 0
+            && s->composition_mode == QPainter::CompositionMode_SourceOver) {
+            return;
+        }
+
+        d->solid_color_filler.clip = d->clip();
+        d->solid_color_filler.adjustSpanMethods();
+        fillRect(r, &d->solid_color_filler);
+
+        s->matrix = old;
+        return;
+    }
+
+    bool stretch_sr = r.width() != sr.width() || r.height() != sr.height();
+
+    const QClipData *clip = d->clip();
+
+    if (s->matrix.type() > QTransform::TxTranslate
+        && !stretch_sr
+        && (!clip || clip->hasRectClip)
+        && s->intOpacity == 256
+        && (d->rasterBuffer->compositionMode == QPainter::CompositionMode_SourceOver
+            || d->rasterBuffer->compositionMode == QPainter::CompositionMode_Source)
+        && d->rasterBuffer->format == img.format()
+        && (d->rasterBuffer->format == QImage::Format_RGB16
+            || d->rasterBuffer->format == QImage::Format_RGB32
+            || (d->rasterBuffer->format == QImage::Format_ARGB32_Premultiplied
+                && d->rasterBuffer->compositionMode == QPainter::CompositionMode_Source)))
+    {
+        RotationType rotationType = qRotationType(s->matrix);
+
+        if (rotationType != NoRotation && qMemRotateFunctions[d->rasterBuffer->format][rotationType] && img.rect().contains(sr.toAlignedRect())) {
+            QRectF transformedTargetRect = s->matrix.mapRect(r);
+
+            if ((!(s->renderHints & QPainter::SmoothPixmapTransform) && !(s->renderHints & QPainter::Antialiasing))
+                || (isPixelAligned(transformedTargetRect) && isPixelAligned(sr)))
+            {
+                QRect clippedTransformedTargetRect = transformedTargetRect.toRect().intersected(clip ? clip->clipRect : d->deviceRect);
+                if (clippedTransformedTargetRect.isNull())
+                    return;
+
+                QRectF clippedTargetRect = s->matrix.inverted().mapRect(QRectF(clippedTransformedTargetRect));
+
+                QRect clippedSourceRect
+                    = QRectF(sr.x() + clippedTargetRect.x() - r.x(), sr.y() + clippedTargetRect.y() - r.y(),
+                            clippedTargetRect.width(), clippedTargetRect.height()).toRect();
+
+                uint dbpl = d->rasterBuffer->bytesPerLine();
+                uint sbpl = img.bytesPerLine();
+
+                uchar *dst = d->rasterBuffer->buffer();
+                uint bpp = img.depth() >> 3;
+
+                const uchar *srcBase = img.bits() + clippedSourceRect.y() * sbpl + clippedSourceRect.x() * bpp;
+                uchar *dstBase = dst + clippedTransformedTargetRect.y() * dbpl + clippedTransformedTargetRect.x() * bpp;
+
+                uint cw = clippedSourceRect.width();
+                uint ch = clippedSourceRect.height();
+
+                qMemRotateFunctions[d->rasterBuffer->format][rotationType](srcBase, cw, ch, sbpl, dstBase, dbpl);
+
+                return;
+            }
+        }
+    }
+
+    if (s->matrix.type() > QTransform::TxTranslate || stretch_sr) {
+
+        QRectF targetBounds = s->matrix.mapRect(r);
+        bool exceedsPrecision = targetBounds.width() > 0xffff
+                                || targetBounds.height() > 0xffff;
+
+        if (!exceedsPrecision && d->canUseFastImageBlending(d->rasterBuffer->compositionMode, img)) {
+            if (s->matrix.type() > QTransform::TxScale) {
+                SrcOverTransformFunc func = qTransformFunctions[d->rasterBuffer->format][img.format()];
+                if (func && (!clip || clip->hasRectClip)) {
+                    func(d->rasterBuffer->buffer(), d->rasterBuffer->bytesPerLine(), img.bits(),
+                         img.bytesPerLine(), r, sr, !clip ? d->deviceRect : clip->clipRect,
+                         s->matrix, s->intOpacity);
+                    return;
+                }
+            } else {
+                SrcOverScaleFunc func = qScaleFunctions[d->rasterBuffer->format][img.format()];
+                if (func && (!clip || clip->hasRectClip)) {
+                    func(d->rasterBuffer->buffer(), d->rasterBuffer->bytesPerLine(),
+                         img.bits(), img.bytesPerLine(),
+                         qt_mapRect_non_normalizing(r, s->matrix), sr,
+                         !clip ? d->deviceRect : clip->clipRect,
+                         s->intOpacity);
+                    return;
+                }
+            }
+        }
+
+        QTransform copy = s->matrix;
+        copy.translate(r.x(), r.y());
+        if (stretch_sr)
+            copy.scale(r.width() / sr.width(), r.height() / sr.height());
+        copy.translate(-sr.x(), -sr.y());
+
+        d->image_filler_xform.clip = clip;
+        d->image_filler_xform.initTexture(&img, s->intOpacity, QTextureData::Plain, toAlignedRect_positive(sr));
+        if (!d->image_filler_xform.blend)
+            return;
+        d->image_filler_xform.setupMatrix(copy, s->flags.bilinear);
+
+        if (!s->flags.antialiased && s->matrix.type() == QTransform::TxScale) {
+            QRectF rr = s->matrix.mapRect(r);
+
+            const int x1 = qRound(rr.x());
+            const int y1 = qRound(rr.y());
+            const int x2 = qRound(rr.right());
+            const int y2 = qRound(rr.bottom());
+
+            fillRect_normalized(QRect(x1, y1, x2-x1, y2-y1), &d->image_filler_xform, d);
+            return;
+        }
+
+#ifdef QT_FAST_SPANS
+        ensureState();
+        if (s->flags.tx_noshear || s->matrix.type() == QTransform::TxScale) {
+            d->initializeRasterizer(&d->image_filler_xform);
+            d->rasterizer->setAntialiased(s->flags.antialiased);
+
+            const QRectF &rect = r.normalized();
+            const QPointF a = s->matrix.map((rect.topLeft() + rect.bottomLeft()) * 0.5f);
+            const QPointF b = s->matrix.map((rect.topRight() + rect.bottomRight()) * 0.5f);
+
+            if (s->flags.tx_noshear)
+                d->rasterizer->rasterizeLine(a, b, rect.height() / rect.width());
+            else
+                d->rasterizer->rasterizeLine(a, b, qAbs((s->matrix.m22() * rect.height()) / (s->matrix.m11() * rect.width())));
+            return;
+        }
+#endif
+        QPainterPath path;
+        path.addRect(r);
+        QTransform m = s->matrix;
+        s->matrix = QTransform(m.m11(), m.m12(), m.m13(),
+                               m.m21(), m.m22(), m.m23(),
+                               m.m31(), m.m32(), m.m33());
+        fillPath(path, &d->image_filler_xform);
+        s->matrix = m;
+    } else {
+        if (d->canUseFastImageBlending(d->rasterBuffer->compositionMode, img)) {
+            SrcOverBlendFunc func = qBlendFunctions[d->rasterBuffer->format][img.format()];
+            if (func) {
+                QPointF pt(r.x() + s->matrix.dx(), r.y() + s->matrix.dy());
+                if (!clip) {
+                    d->drawImage(pt, img, func, d->deviceRect, s->intOpacity, sr.toRect());
+                    return;
+                } else if (clip->hasRectClip) {
+                    d->drawImage(pt, img, func, clip->clipRect, s->intOpacity, sr.toRect());
+                    return;
+                }
+            }
+        }
+
+        d->image_filler.clip = clip;
+        d->image_filler.initTexture(&img, s->intOpacity, QTextureData::Plain, toAlignedRect_positive(sr));
+        if (!d->image_filler.blend)
+            return;
+        d->image_filler.dx = -(r.x() + s->matrix.dx()) + sr.x();
+        d->image_filler.dy = -(r.y() + s->matrix.dy()) + sr.y();
+
+        QRectF rr = r;
+        rr.translate(s->matrix.dx(), s->matrix.dy());
+
+        const int x1 = qRound(rr.x());
+        const int y1 = qRound(rr.y());
+        const int x2 = qRound(rr.right());
+        const int y2 = qRound(rr.bottom());
+
+        fillRect_normalized(QRect(x1, y1, x2-x1, y2-y1), &d->image_filler, d);
+    }
+}
+
+/*!
+    \reimp
+*/
+void QRasterPaintEngine::drawTiledPixmap(const QRectF &r, const QPixmap &pixmap, const QPointF &sr)
+{
+#ifdef QT_DEBUG_DRAW
+    qDebug() << " - QRasterPaintEngine::drawTiledPixmap(), r=" << r << "pixmap=" << pixmap.size();
+#endif
+    Q_D(QRasterPaintEngine);
+    QRasterPaintEngineState *s = state();
+
+    QImage image;
+
+    QPixmapData *pd = pixmap.pixmapData();
+    if (pd->classId() == QPixmapData::RasterClass) {
+        image = static_cast<QRasterPixmapData *>(pd)->image;
+    } else {
+        image = pixmap.toImage();
+    }
+
+    if (image.depth() == 1)
+        image = d->rasterBuffer->colorizeBitmap(image, s->pen.color());
+
+    if (s->matrix.type() > QTransform::TxTranslate) {
+        QTransform copy = s->matrix;
+        copy.translate(r.x(), r.y());
+        copy.translate(-sr.x(), -sr.y());
+        d->image_filler_xform.clip = d->clip();
+        d->image_filler_xform.initTexture(&image, s->intOpacity, QTextureData::Tiled);
+        if (!d->image_filler_xform.blend)
+            return;
+        d->image_filler_xform.setupMatrix(copy, s->flags.bilinear);
+
+#ifdef QT_FAST_SPANS
+        ensureState();
+        if (s->flags.tx_noshear || s->matrix.type() == QTransform::TxScale) {
+            d->initializeRasterizer(&d->image_filler_xform);
+            d->rasterizer->setAntialiased(s->flags.antialiased);
+
+            const QRectF &rect = r.normalized();
+            const QPointF a = s->matrix.map((rect.topLeft() + rect.bottomLeft()) * 0.5f);
+            const QPointF b = s->matrix.map((rect.topRight() + rect.bottomRight()) * 0.5f);
+            if (s->flags.tx_noshear)
+                d->rasterizer->rasterizeLine(a, b, rect.height() / rect.width());
+            else
+                d->rasterizer->rasterizeLine(a, b, qAbs((s->matrix.m22() * rect.height()) / (s->matrix.m11() * rect.width())));
+            return;
+        }
+#endif
+        QPainterPath path;
+        path.addRect(r);
+        fillPath(path, &d->image_filler_xform);
+    } else {
+        d->image_filler.clip = d->clip();
+
+        d->image_filler.initTexture(&image, s->intOpacity, QTextureData::Tiled);
+        if (!d->image_filler.blend)
+            return;
+        d->image_filler.dx = -(r.x() + s->matrix.dx()) + sr.x();
+        d->image_filler.dy = -(r.y() + s->matrix.dy()) + sr.y();
+
+        QRectF rr = r;
+        rr.translate(s->matrix.dx(), s->matrix.dy());
+        fillRect_normalized(rr.toRect().normalized(), &d->image_filler, d);
+    }
+}
+
+
+//QWS hack
+static inline bool monoVal(const uchar* s, int x)
+{
+    return  (s[x>>3] << (x&7)) & 0x80;
+}
+
+/*!
+    \internal
+*/
+void QRasterPaintEngine::alphaPenBlt(const void* src, int bpl, int depth, int rx,int ry,int w,int h)
+{
+    Q_D(QRasterPaintEngine);
+    QRasterPaintEngineState *s = state();
+
+    if (!s->penData.blend)
+        return;
+
+    QRasterBuffer *rb = d->rasterBuffer.data();
+
+    const QRect rect(rx, ry, w, h);
+    const QClipData *clip = d->clip();
+    bool unclipped = false;
+    if (clip) {
+        // inlined QRect::intersects
+        const bool intersects = qMax(clip->xmin, rect.left()) <= qMin(clip->xmax - 1, rect.right())
+                                && qMax(clip->ymin, rect.top()) <= qMin(clip->ymax - 1, rect.bottom());
+
+        if (clip->hasRectClip) {
+            unclipped = rx > clip->xmin
+                        && rx + w < clip->xmax
+                        && ry > clip->ymin
+                        && ry + h < clip->ymax;
+        }
+
+        if (!intersects)
+            return;
+    } else {
+        // inlined QRect::intersects
+        const bool intersects = qMax(0, rect.left()) <= qMin(rb->width() - 1, rect.right())
+                                && qMax(0, rect.top()) <= qMin(rb->height() - 1, rect.bottom());
+        if (!intersects)
+            return;
+
+        // inlined QRect::contains
+        const bool contains = rect.left() >= 0 && rect.right() < rb->width()
+                              && rect.top() >= 0 && rect.bottom() < rb->height();
+
+        unclipped = contains && d->isUnclipped_normalized(rect);
+    }
+
+    ProcessSpans blend = unclipped ? s->penData.unclipped_blend : s->penData.blend;
+    const uchar * scanline = static_cast<const uchar *>(src);
+
+    if (s->flags.fast_text) {
+        if (unclipped) {
+            if (depth == 1) {
+                if (s->penData.bitmapBlit) {
+                    s->penData.bitmapBlit(rb, rx, ry, s->penData.solid.color,
+                                          scanline, w, h, bpl);
+                    return;
+                }
+            } else if (depth == 8) {
+                if (s->penData.alphamapBlit) {
+                    s->penData.alphamapBlit(rb, rx, ry, s->penData.solid.color,
+                                            scanline, w, h, bpl, 0);
+                    return;
+                }
+            } else if (depth == 32) {
+                // (A)RGB Alpha mask where the alpha component is not used.
+                if (s->penData.alphaRGBBlit) {
+                    s->penData.alphaRGBBlit(rb, rx, ry, s->penData.solid.color,
+                                            (const uint *) scanline, w, h, bpl / 4, 0);
+                    return;
+                }
+            }
+        } else if (d->deviceDepth == 32 && (depth == 8 || depth == 32)) {
+            // (A)RGB Alpha mask where the alpha component is not used.
+            if (!clip) {
+                int nx = qMax(0, rx);
+                int ny = qMax(0, ry);
+
+                // Move scanline pointer to compensate for moved x and y
+                int xdiff = nx - rx;
+                int ydiff = ny - ry;
+                scanline += ydiff * bpl;
+                scanline += xdiff * (depth == 32 ? 4 : 1);
+
+                w -= xdiff;
+                h -= ydiff;
+
+                if (nx + w > d->rasterBuffer->width())
+                    w = d->rasterBuffer->width() - nx;
+                if (ny + h > d->rasterBuffer->height())
+                    h = d->rasterBuffer->height() - ny;
+
+                rx = nx;
+                ry = ny;
+            }
+            if (depth == 8 && s->penData.alphamapBlit) {
+                s->penData.alphamapBlit(rb, rx, ry, s->penData.solid.color,
+                                        scanline, w, h, bpl, clip);
+            } else if (depth == 32 && s->penData.alphaRGBBlit) {
+                s->penData.alphaRGBBlit(rb, rx, ry, s->penData.solid.color,
+                                        (const uint *) scanline, w, h, bpl / 4, clip);
+            }
+            return;
+        }
+    }
+
+    int x0 = 0;
+    if (rx < 0) {
+        x0 = -rx;
+        w -= x0;
+    }
+
+    int y0 = 0;
+    if (ry < 0) {
+        y0 = -ry;
+        scanline += bpl * y0;
+        h -= y0;
+    }
+
+    w = qMin(w, rb->width() - qMax(0, rx));
+    h = qMin(h, rb->height() - qMax(0, ry));
+
+    if (w <= 0 || h <= 0)
+        return;
+
+    const int NSPANS = 256;
+    QSpan spans[NSPANS];
+    int current = 0;
+
+    const int x1 = x0 + w;
+    const int y1 = y0 + h;
+
+    if (depth == 1) {
+        for (int y = y0; y < y1; ++y) {
+            for (int x = x0; x < x1; ) {
+                if (!monoVal(scanline, x)) {
+                    ++x;
+                    continue;
+                }
+
+                if (current == NSPANS) {
+                    blend(current, spans, &s->penData);
+                    current = 0;
+                }
+                spans[current].x = x + rx;
+                spans[current].y = y + ry;
+                spans[current].coverage = 255;
+                int len = 1;
+                ++x;
+                // extend span until we find a different one.
+                while (x < x1 && monoVal(scanline, x)) {
+                    ++x;
+                    ++len;
+                }
+                spans[current].len = len;
+                ++current;
+            }
+            scanline += bpl;
+        }
+    } else if (depth == 8) {
+        for (int y = y0; y < y1; ++y) {
+            for (int x = x0; x < x1; ) {
+                // Skip those with 0 coverage
+                if (scanline[x] == 0) {
+                    ++x;
+                    continue;
+                }
+
+                if (current == NSPANS) {
+                    blend(current, spans, &s->penData);
+                    current = 0;
+                }
+                int coverage = scanline[x];
+                spans[current].x = x + rx;
+                spans[current].y = y + ry;
+                spans[current].coverage = coverage;
+                int len = 1;
+                ++x;
+
+                // extend span until we find a different one.
+                while (x < x1 && scanline[x] == coverage) {
+                    ++x;
+                    ++len;
+                }
+                spans[current].len = len;
+                ++current;
+            }
+            scanline += bpl;
+        }
+    } else { // 32-bit alpha...
+        uint *sl = (uint *) src;
+        for (int y = y0; y < y1; ++y) {
+            for (int x = x0; x < x1; ) {
+                // Skip those with 0 coverage
+                if ((sl[x] & 0x00ffffff) == 0) {
+                    ++x;
+                    continue;
+                }
+
+                if (current == NSPANS) {
+                    blend(current, spans, &s->penData);
+                    current = 0;
+                }
+                uint rgbCoverage = sl[x];
+                int coverage = qGreen(rgbCoverage);
+                spans[current].x = x + rx;
+                spans[current].y = y + ry;
+                spans[current].coverage = coverage;
+                int len = 1;
+                ++x;
+
+                // extend span until we find a different one.
+                while (x < x1 && sl[x] == rgbCoverage) {
+                    ++x;
+                    ++len;
+                }
+                spans[current].len = len;
+                ++current;
+            }
+            sl += bpl / sizeof(uint);
+        }
+    }
+//     qDebug() << "alphaPenBlt: num spans=" << current
+//              << "span:" << spans->x << spans->y << spans->len << spans->coverage;
+        // Call span func for current set of spans.
+    if (current != 0)
+        blend(current, spans, &s->penData);
+}
+
+bool QRasterPaintEngine::drawCachedGlyphs(int numGlyphs, const glyph_t *glyphs,
+                                          const QFixedPoint *positions, QFontEngine *fontEngine)
+{
+    Q_D(QRasterPaintEngine);
+    QRasterPaintEngineState *s = state();
+
+#if !defined(QT_NO_FREETYPE)
+    if (fontEngine->type() == QFontEngine::Freetype) {
+        QFontEngineFT *fe = static_cast<QFontEngineFT *>(fontEngine);
+        QFontEngineFT::GlyphFormat neededFormat =
+            painter()->device()->devType() == QInternal::Widget
+            ? fe->defaultGlyphFormat()
+            : QFontEngineFT::Format_A8;
+
+        if (d_func()->mono_surface
+            || fe->isBitmapFont() // alphaPenBlt can handle mono, too
+            )
+            neededFormat = QFontEngineFT::Format_Mono;
+
+        if (neededFormat == QFontEngineFT::Format_None)
+            neededFormat = QFontEngineFT::Format_A8;
+
+        QFontEngineFT::QGlyphSet *gset = fe->defaultGlyphs();
+        if (s->matrix.type() >= QTransform::TxScale) {
+            if (s->matrix.isAffine())
+                gset = fe->loadTransformedGlyphSet(s->matrix);
+            else
+                gset = 0;
+        }
+
+        if (!gset || gset->outline_drawing
+            || !fe->loadGlyphs(gset, glyphs, numGlyphs, positions, neededFormat))
+            return false;
+
+        FT_Face lockedFace = 0;
+
+        int depth;
+        switch (neededFormat) {
+        case QFontEngineFT::Format_Mono:
+            depth = 1;
+            break;
+        case QFontEngineFT::Format_A8:
+            depth = 8;
+            break;
+        case QFontEngineFT::Format_A32:
+            depth = 32;
+            break;
+        default:
+            Q_ASSERT(false);
+            depth = 0;
+        };
+
+        for (int i = 0; i < numGlyphs; i++) {
+            QFixed spp = fe->subPixelPositionForX(positions[i].x);
+            QFontEngineFT::Glyph *glyph = gset->getGlyph(glyphs[i], spp);
+
+            if (!glyph || glyph->format != neededFormat) {
+                if (!lockedFace)
+                    lockedFace = fe->lockFace();
+                glyph = fe->loadGlyph(gset, glyphs[i], spp, neededFormat);
+            }
+
+            if (!glyph || !glyph->data)
+                continue;
+
+            int pitch;
+            switch (neededFormat) {
+            case QFontEngineFT::Format_Mono:
+                pitch = ((glyph->width + 31) & ~31) >> 3;
+                break;
+            case QFontEngineFT::Format_A8:
+                pitch = (glyph->width + 3) & ~3;
+                break;
+            case QFontEngineFT::Format_A32:
+                pitch = glyph->width * 4;
+                break;
+            default:
+                Q_ASSERT(false);
+                pitch = 0;
+            };
+
+            alphaPenBlt(glyph->data, pitch, depth,
+                        qFloor(positions[i].x) + glyph->x,
+                        qFloor(positions[i].y) - glyph->y,
+                        glyph->width, glyph->height);
+        }
+        if (lockedFace)
+            fe->unlockFace();
+    } else
+#endif
+    {
+        QFontEngineGlyphCache::Type glyphType = fontEngine->glyphFormat >= 0 ? QFontEngineGlyphCache::Type(fontEngine->glyphFormat) : d->glyphCacheType;
+
+        QImageTextureGlyphCache *cache =
+            static_cast<QImageTextureGlyphCache *>(fontEngine->glyphCache(0, glyphType, s->matrix));
+        if (!cache) {
+            cache = new QImageTextureGlyphCache(glyphType, s->matrix);
+            fontEngine->setGlyphCache(0, cache);
+        }
+
+        cache->populate(fontEngine, numGlyphs, glyphs, positions);
+        cache->fillInPendingGlyphs();
+
+        const QImage &image = cache->image();
+        int bpl = image.bytesPerLine();
+
+        int depth = image.depth();
+        int rightShift = 0;
+        int leftShift = 0;
+        if (depth == 32)
+            leftShift = 2; // multiply by 4
+        else if (depth == 1)
+            rightShift = 3; // divide by 8
+
+        int margin = cache->glyphMargin();
+        const uchar *bits = image.bits();
+        for (int i=0; i<numGlyphs; ++i) {
+
+            QFixed subPixelPosition = cache->subPixelPositionForX(positions[i].x);
+            QTextureGlyphCache::GlyphAndSubPixelPosition glyph(glyphs[i], subPixelPosition);
+            const QTextureGlyphCache::Coord &c = cache->coords[glyph];
+            if (c.isNull())
+                continue;
+
+            int x = qFloor(positions[i].x) + c.baseLineX - margin;
+            int y = qFloor(positions[i].y) - c.baseLineY - margin;
+
+            // printf("drawing [%d %d %d %d] baseline [%d %d], glyph: %d, to: %d %d, pos: %d %d\n",
+            //        c.x, c.y,
+            //        c.w, c.h,
+            //        c.baseLineX, c.baseLineY,
+            //        glyphs[i],
+            //        x, y,
+            //        positions[i].x.toInt(), positions[i].y.toInt());
+
+            alphaPenBlt(bits + ((c.x << leftShift) >> rightShift) + c.y * bpl, bpl, depth, x, y, c.w, c.h);
+        }
+    }
+    return true;
+}
+
+#if defined(Q_OS_SYMBIAN) && defined(QT_NO_FREETYPE)
+void QRasterPaintEngine::drawGlyphsS60(const QPointF &p, const QTextItemInt &ti)
+{
+    Q_D(QRasterPaintEngine);
+    QRasterPaintEngineState *s = state();
+
+    QFontEngine *fontEngine = ti.fontEngine;
+    if (fontEngine->type() != QFontEngine::S60FontEngine) {
+        QPaintEngineEx::drawTextItem(p, ti);
+        return;
+    }
+
+    QFontEngineS60 *fe = static_cast<QFontEngineS60 *>(fontEngine);
+
+    QVarLengthArray<QFixedPoint> positions;
+    QVarLengthArray<glyph_t> glyphs;
+    QTransform matrix = s->matrix;
+    matrix.translate(p.x(), p.y());
+    if (matrix.type() == QTransform::TxScale)
+        fe->setFontScale(matrix.m11());
+    ti.fontEngine->getGlyphPositions(ti.glyphs, matrix, ti.flags, glyphs, positions);
+
+    for (int i=0; i<glyphs.size(); ++i) {
+        TOpenFontCharMetrics tmetrics;
+        const TUint8 *glyphBitmapBytes;
+        TSize glyphBitmapSize;
+        fe->getCharacterData(glyphs[i], tmetrics, glyphBitmapBytes, glyphBitmapSize);
+        const int x = qFloor(positions[i].x + tmetrics.HorizBearingX());
+        const int y = qFloor(positions[i].y - tmetrics.HorizBearingY());
+        alphaPenBlt(glyphBitmapBytes, glyphBitmapSize.iWidth, 8, x, y, glyphBitmapSize.iWidth, glyphBitmapSize.iHeight);
+    }
+
+    if (matrix.type() == QTransform::TxScale)
+        fe->setFontScale(1.0);
+
+    return;
+}
+#endif // Q_OS_SYMBIAN && QT_NO_FREETYPE
+
+/*!
+ * Returns true if the rectangle is completely within the current clip
+ * state of the paint engine.
+ */
+bool QRasterPaintEnginePrivate::isUnclipped_normalized(const QRect &r) const
+{
+    const QClipData *cl = clip();
+    if (!cl) {
+        // inline contains() for performance (we know the rects are normalized)
+        const QRect &r1 = deviceRect;
+        return (r.left() >= r1.left() && r.right() <= r1.right()
+                && r.top() >= r1.top() && r.bottom() <= r1.bottom());
+    }
+
+
+    if (cl->hasRectClip) {
+        // currently all painting functions clips to deviceRect internally
+        if (cl->clipRect == deviceRect)
+            return true;
+
+        // inline contains() for performance (we know the rects are normalized)
+        const QRect &r1 = cl->clipRect;
+        return (r.left() >= r1.left() && r.right() <= r1.right()
+                && r.top() >= r1.top() && r.bottom() <= r1.bottom());
+    } else {
+        return qt_region_strictContains(cl->clipRegion, r);
+    }
+}
+
+bool QRasterPaintEnginePrivate::isUnclipped(const QRect &rect,
+                                            int penWidth) const
+{
+    Q_Q(const QRasterPaintEngine);
+    const QRasterPaintEngineState *s = q->state();
+    const QClipData *cl = clip();
+    if (!cl) {
+        QRect r = rect.normalized();
+        // inline contains() for performance (we know the rects are normalized)
+        const QRect &r1 = deviceRect;
+        return (r.left() >= r1.left() && r.right() <= r1.right()
+                && r.top() >= r1.top() && r.bottom() <= r1.bottom());
+    }
+
+
+    // currently all painting functions that call this function clip to deviceRect internally
+    if (cl->hasRectClip && cl->clipRect == deviceRect)
+        return true;
+
+    if (s->flags.antialiased)
+        ++penWidth;
+
+    QRect r = rect.normalized();
+    if (penWidth > 0) {
+        r.setX(r.x() - penWidth);
+        r.setY(r.y() - penWidth);
+        r.setWidth(r.width() + 2 * penWidth);
+        r.setHeight(r.height() + 2 * penWidth);
+    }
+
+    if (cl->hasRectClip) {
+        // inline contains() for performance (we know the rects are normalized)
+        const QRect &r1 = cl->clipRect;
+        return (r.left() >= r1.left() && r.right() <= r1.right()
+                && r.top() >= r1.top() && r.bottom() <= r1.bottom());
+    } else {
+        return qt_region_strictContains(cl->clipRegion, r);
+    }
+}
+
+inline bool QRasterPaintEnginePrivate::isUnclipped(const QRectF &rect,
+                                                   int penWidth) const
+{
+    return isUnclipped(rect.normalized().toAlignedRect(), penWidth);
+}
+
+inline ProcessSpans
+QRasterPaintEnginePrivate::getBrushFunc(const QRect &rect,
+                                        const QSpanData *data) const
+{
+    return isUnclipped(rect, 0) ? data->unclipped_blend : data->blend;
+}
+
+inline ProcessSpans
+QRasterPaintEnginePrivate::getBrushFunc(const QRectF &rect,
+                                        const QSpanData *data) const
+{
+    return isUnclipped(rect, 0) ? data->unclipped_blend : data->blend;
+}
+
+inline ProcessSpans
+QRasterPaintEnginePrivate::getPenFunc(const QRect &rect,
+                                      const QSpanData *data) const
+{
+    Q_Q(const QRasterPaintEngine);
+    const QRasterPaintEngineState *s = q->state();
+
+    if (!s->flags.fast_pen && s->matrix.type() > QTransform::TxTranslate)
+        return data->blend;
+    const int penWidth = s->flags.fast_pen ? 1 : qCeil(s->pen.widthF());
+    return isUnclipped(rect, penWidth) ? data->unclipped_blend : data->blend;
+}
+
+inline ProcessSpans
+QRasterPaintEnginePrivate::getPenFunc(const QRectF &rect,
+                                      const QSpanData *data) const
+{
+    Q_Q(const QRasterPaintEngine);
+    const QRasterPaintEngineState *s = q->state();
+
+    if (!s->flags.fast_pen && s->matrix.type() > QTransform::TxTranslate)
+        return data->blend;
+    const int penWidth = s->flags.fast_pen ? 1 : qCeil(s->lastPen.widthF());
+    return isUnclipped(rect, penWidth) ? data->unclipped_blend : data->blend;
+}
+
+/*!
+   \reimp
+*/
+void QRasterPaintEngine::drawStaticTextItem(QStaticTextItem *textItem)
+{
+    ensurePen();
+    ensureState();
+
+    drawCachedGlyphs(textItem->numGlyphs, textItem->glyphs, textItem->glyphPositions,
+                     textItem->fontEngine());
+}
+
+/*!
+    \reimp
+*/
+void QRasterPaintEngine::drawTextItem(const QPointF &p, const QTextItem &textItem)
+{
+    const QTextItemInt &ti = static_cast<const QTextItemInt &>(textItem);
+    QRasterPaintEngineState *s = state();
+
+#ifdef QT_DEBUG_DRAW
+    Q_D(QRasterPaintEngine);
+    fprintf(stderr," - QRasterPaintEngine::drawTextItem(), (%.2f,%.2f), string=%s ct=%d\n",
+           p.x(), p.y(), QString::fromRawData(ti.chars, ti.num_chars).toLatin1().data(),
+           d->glyphCacheType);
+#endif
+
+    ensurePen();
+    ensureState();
+
+#if defined (Q_WS_WIN) || defined(Q_WS_MAC)
+
+    bool drawCached = true;
+
+    if (s->matrix.type() >= QTransform::TxProject)
+        drawCached = false;
+
+    // don't try to cache huge fonts
+    const qreal pixelSize = ti.fontEngine->fontDef.pixelSize;
+    if (pixelSize * pixelSize * qAbs(s->matrix.determinant()) >= 64 * 64)
+        drawCached = false;
+
+    // ### Remove the TestFontEngine and Box engine crap, in these
+    // ### cases we should delegate painting to the font engine
+    // ### directly...
+
+#if defined(Q_WS_WIN) && !defined(Q_WS_WINCE)
+    QFontEngine::Type fontEngineType = ti.fontEngine->type();
+    // qDebug() << "type" << fontEngineType << s->matrix.type();
+    if ((fontEngineType == QFontEngine::Win && !((QFontEngineWin *) ti.fontEngine)->ttf && s->matrix.type() > QTransform::TxTranslate)
+        || (s->matrix.type() <= QTransform::TxTranslate
+            && (fontEngineType == QFontEngine::TestFontEngine
+                || fontEngineType == QFontEngine::Box))) {
+            drawCached = false;
+    }
+#else
+    if (s->matrix.type() > QTransform::TxTranslate)
+        drawCached = false;
+#endif
+    if (drawCached) {
+        QRasterPaintEngineState *s = state();
+
+        QVarLengthArray<QFixedPoint> positions;
+        QVarLengthArray<glyph_t> glyphs;
+
+        QTransform matrix = s->matrix;
+        matrix.translate(p.x(), p.y());
+
+        ti.fontEngine->getGlyphPositions(ti.glyphs, matrix, ti.flags, glyphs, positions);
+
+        drawCachedGlyphs(glyphs.size(), glyphs.constData(), positions.constData(), ti.fontEngine);
+        return;
+    }
+
+#elif defined (Q_OS_SYMBIAN) && defined(QT_NO_FREETYPE) // Q_WS_WIN || Q_WS_MAC
+    if (s->matrix.type() <= QTransform::TxTranslate
+        || (s->matrix.type() == QTransform::TxScale
+                && (qFuzzyCompare(s->matrix.m11(), s->matrix.m22())))) {
+        drawGlyphsS60(p, ti);
+        return;
+    }
+#else // Q_WS_WIN || Q_WS_MAC
+
+    QFontEngine *fontEngine = ti.fontEngine;
+
+#if defined(Q_WS_QWS)
+    if (fontEngine->type() == QFontEngine::Box) {
+        fontEngine->draw(this, qFloor(p.x()), qFloor(p.y()), ti);
+        return;
+    }
+
+    if (s->matrix.type() < QTransform::TxScale
+        && (fontEngine->type() == QFontEngine::QPF1 || fontEngine->type() == QFontEngine::QPF2
+            || (fontEngine->type() == QFontEngine::Proxy
+                && !(static_cast<QProxyFontEngine *>(fontEngine)->drawAsOutline()))
+            )) {
+        fontEngine->draw(this, qFloor(p.x()), qFloor(p.y()), ti);
+        return;
+    }
+#endif // Q_WS_QWS
+
+#ifdef Q_WS_QPA
+    if (s->matrix.type() < QTransform::TxScale) {
+
+        QVarLengthArray<QFixedPoint> positions;
+        QVarLengthArray<glyph_t> glyphs;
+        QTransform matrix = state()->transform();
+
+        qreal _x = qFloor(p.x());
+        qreal _y = qFloor(p.y());
+        matrix.translate(_x, _y);
+
+        fontEngine->getGlyphPositions(ti.glyphs, matrix, ti.flags, glyphs, positions);
+        if (glyphs.size() == 0)
+            return;
+
+        for(int i = 0; i < glyphs.size(); i++) {
+            QImage img = fontEngine->alphaMapForGlyph(glyphs[i]);
+            glyph_metrics_t metrics = fontEngine->boundingBox(glyphs[i]);
+            alphaPenBlt(img.bits(), img.bytesPerLine(), img.depth(),
+                                         qRound(positions[i].x + metrics.x),
+                                         qRound(positions[i].y + metrics.y),
+                                         img.width(), img.height());
+        }
+        return;
+    }
+#endif //Q_WS_QPA
+
+#if (defined(Q_WS_X11) || defined(Q_WS_QWS) || defined(Q_OS_SYMBIAN)) && !defined(QT_NO_FREETYPE)
+
+#if defined(Q_WS_QWS) && !defined(QT_NO_QWS_QPF2)
+    if (fontEngine->type() == QFontEngine::QPF2) {
+        QFontEngine *renderingEngine = static_cast<QFontEngineQPF *>(fontEngine)->renderingEngine();
+        if (renderingEngine)
+            fontEngine = renderingEngine;
+    }
+#endif
+
+    if (fontEngine->type() != QFontEngine::Freetype) {
+        QPaintEngineEx::drawTextItem(p, ti);
+        return;
+    }
+
+    QFontEngineFT *fe = static_cast<QFontEngineFT *>(fontEngine);
+
+    QTransform matrix = s->matrix;
+    matrix.translate(p.x(), p.y());
+
+    QVarLengthArray<QFixedPoint> positions;
+    QVarLengthArray<glyph_t> glyphs;
+    fe->getGlyphPositions(ti.glyphs, matrix, ti.flags, glyphs, positions);
+    if (glyphs.size() == 0)
+        return;
+
+    if (!drawCachedGlyphs(glyphs.size(), glyphs.constData(), positions.constData(), fontEngine))
+        QPaintEngine::drawTextItem(p, ti);
+
+    return;
+#endif
+#endif
+
+    QPaintEngineEx::drawTextItem(p, ti);
+}
+
+/*!
+    \reimp
+*/
+void QRasterPaintEngine::drawPoints(const QPointF *points, int pointCount)
+{
+    Q_D(QRasterPaintEngine);
+    QRasterPaintEngineState *s = state();
+
+    ensurePen();
+    qreal pw = s->lastPen.widthF();
+    if (!s->flags.fast_pen && (s->matrix.type() > QTransform::TxTranslate || pw > 1)) {
+        QPaintEngineEx::drawPoints(points, pointCount);
+
+    } else {
+        if (!s->penData.blend)
+            return;
+
+        QVarLengthArray<QT_FT_Span, 4096> array(pointCount);
+        QT_FT_Span span = { 0, 1, 0, 255 };
+        const QPointF *end = points + pointCount;
+        qreal trans_x, trans_y;
+        int x, y;
+        int left = d->deviceRect.x();
+        int right = left + d->deviceRect.width();
+        int top = d->deviceRect.y();
+        int bottom = top + d->deviceRect.height();
+        int count = 0;
+        while (points < end) {
+            s->matrix.map(points->x(), points->y(), &trans_x, &trans_y);
+            x = qFloor(trans_x);
+            y = qFloor(trans_y);
+            if (x >= left && x < right && y >= top && y < bottom) {
+                if (count > 0) {
+                    const QT_FT_Span &last = array[count - 1];
+                    // spans must be sorted on y (primary) and x (secondary)
+                    if (y < last.y || (y == last.y && x < last.x)) {
+                        s->penData.blend(count, array.constData(), &s->penData);
+                        count = 0;
+                    }
+                }
+
+                span.x = x;
+                span.y = y;
+                array[count++] = span;
+            }
+            ++points;
+        }
+
+        if (count > 0)
+            s->penData.blend(count, array.constData(), &s->penData);
+    }
+}
+
+
+void QRasterPaintEngine::drawPoints(const QPoint *points, int pointCount)
+{
+    Q_D(QRasterPaintEngine);
+    QRasterPaintEngineState *s = state();
+
+    ensurePen();
+    double pw = s->lastPen.widthF();
+    if (!s->flags.fast_pen && (s->matrix.type() > QTransform::TxTranslate || pw > 1)) {
+        QPaintEngineEx::drawPoints(points, pointCount);
+
+    } else {
+        if (!s->penData.blend)
+            return;
+
+        QVarLengthArray<QT_FT_Span, 4096> array(pointCount);
+        QT_FT_Span span = { 0, 1, 0, 255 };
+        const QPoint *end = points + pointCount;
+        qreal trans_x, trans_y;
+        int x, y;
+        int left = d->deviceRect.x();
+        int right = left + d->deviceRect.width();
+        int top = d->deviceRect.y();
+        int bottom = top + d->deviceRect.height();
+        int count = 0;
+        while (points < end) {
+            s->matrix.map(points->x(), points->y(), &trans_x, &trans_y);
+            x = qFloor(trans_x);
+            y = qFloor(trans_y);
+            if (x >= left && x < right && y >= top && y < bottom) {
+                if (count > 0) {
+                    const QT_FT_Span &last = array[count - 1];
+                    // spans must be sorted on y (primary) and x (secondary)
+                    if (y < last.y || (y == last.y && x < last.x)) {
+                        s->penData.blend(count, array.constData(), &s->penData);
+                        count = 0;
+                    }
+                }
+
+                span.x = x;
+                span.y = y;
+                array[count++] = span;
+            }
+            ++points;
+        }
+
+        if (count > 0)
+            s->penData.blend(count, array.constData(), &s->penData);
+    }
+}
+
+/*!
+    \reimp
+*/
+void QRasterPaintEngine::drawLines(const QLine *lines, int lineCount)
+{
+#ifdef QT_DEBUG_DRAW
+    qDebug() << " - QRasterPaintEngine::drawLine()";
+#endif
+    Q_D(QRasterPaintEngine);
+    QRasterPaintEngineState *s = state();
+
+    ensurePen();
+    if (s->flags.fast_pen) {
+        QIntRect bounds; bounds.set(d->deviceRect);
+        LineDrawMode mode = s->lastPen.capStyle() == Qt::FlatCap
+                            ? LineDrawNormal
+                            : LineDrawIncludeLastPixel;
+
+        int m11 = int(s->matrix.m11());
+        int m22 = int(s->matrix.m22());
+        int dx = qFloor(s->matrix.dx());
+        int dy = qFloor(s->matrix.dy());
+        for (int i=0; i<lineCount; ++i) {
+            int dashOffset = int(s->lastPen.dashOffset());
+            if (s->flags.int_xform) {
+                const QLine &l = lines[i];
+                int x1 = l.x1() * m11 + dx;
+                int y1 = l.y1() * m22 + dy;
+                int x2 = l.x2() * m11 + dx;
+                int y2 = l.y2() * m22 + dy;
+
+                const QRect brect(QPoint(x1, y1), QPoint(x2, y2));
+                ProcessSpans penBlend = d->getPenFunc(brect, &s->penData);
+                if (qpen_style(s->lastPen) == Qt::SolidLine)
+                    drawLine_midpoint_i(x1, y1, x2, y2,
+                                        penBlend, &s->penData, mode, bounds);
+                else
+                    drawLine_midpoint_dashed_i(x1, y1, x2, y2,
+                                               &s->lastPen, penBlend,
+                                               &s->penData, mode, bounds,
+                                               &dashOffset);
+            } else {
+                QLineF line = lines[i] * s->matrix;
+                const QRectF brect(QPointF(line.x1(), line.y1()),
+                                   QPointF(line.x2(), line.y2()));
+                ProcessSpans penBlend = d->getPenFunc(brect, &s->penData);
+                if (qpen_style(s->lastPen) == Qt::SolidLine)
+                    drawLine_midpoint_i(int(line.x1()), int(line.y1()),
+                                        int(line.x2()), int(line.y2()),
+                                        penBlend, &s->penData, mode, bounds);
+                else
+                    drawLine_midpoint_dashed_i(int(line.x1()), int(line.y1()),
+                                               int(line.x2()), int(line.y2()),
+                                               &s->lastPen, penBlend,
+                                               &s->penData, mode, bounds,
+                                               &dashOffset);
+            }
+        }
+    } else if (s->penData.blend) {
+        QPaintEngineEx::drawLines(lines, lineCount);
+    }
+}
+
+void QRasterPaintEnginePrivate::rasterizeLine_dashed(QLineF line,
+                                                     qreal width,
+                                                     int *dashIndex,
+                                                     qreal *dashOffset,
+                                                     bool *inDash)
+{
+    Q_Q(QRasterPaintEngine);
+    QRasterPaintEngineState *s = q->state();
+
+    const QPen &pen = s->lastPen;
+    const bool squareCap = (pen.capStyle() == Qt::SquareCap);
+    const QVector<qreal> pattern = pen.dashPattern();
+
+    qreal patternLength = 0;
+    for (int i = 0; i < pattern.size(); ++i)
+        patternLength += pattern.at(i);
+
+    if (patternLength <= 0)
+        return;
+
+    qreal length = line.length();
+    Q_ASSERT(length > 0);
+    while (length > 0) {
+        const bool rasterize = *inDash;
+        qreal dash = (pattern.at(*dashIndex) - *dashOffset) * width;
+        QLineF l = line;
+
+        if (dash >= length) {
+            dash = length;
+            *dashOffset += dash / width;
+            length = 0;
+        } else {
+            *dashOffset = 0;
+            *inDash = !(*inDash);
+            if (++*dashIndex >= pattern.size())
+                *dashIndex = 0;
+            length -= dash;
+            l.setLength(dash);
+            line.setP1(l.p2());
+        }
+
+        if (rasterize && dash > 0)
+            rasterizer->rasterizeLine(l.p1(), l.p2(), width / dash, squareCap);
+    }
+}
+
+/*!
+    \reimp
+*/
+void QRasterPaintEngine::drawLines(const QLineF *lines, int lineCount)
+{
+#ifdef QT_DEBUG_DRAW
+    qDebug() << " - QRasterPaintEngine::drawLine()";
+#endif
+    Q_D(QRasterPaintEngine);
+    QRasterPaintEngineState *s = state();
+
+    ensurePen();
+    if (!s->penData.blend)
+        return;
+    if (s->flags.fast_pen) {
+        QIntRect bounds;
+        bounds.set(d->deviceRect);
+        LineDrawMode mode = s->lastPen.capStyle() == Qt::FlatCap
+                            ? LineDrawNormal
+                            : LineDrawIncludeLastPixel;
+
+        for (int i=0; i<lineCount; ++i) {
+            int dashOffset = int(s->lastPen.dashOffset());
+            QLineF line = lines[i] * s->matrix;
+            const QRectF brect(QPointF(line.x1(), line.y1()),
+                               QPointF(line.x2(), line.y2()));
+            ProcessSpans penBlend = d->getPenFunc(brect, &s->penData);
+            if (qpen_style(s->lastPen) == Qt::SolidLine)
+                drawLine_midpoint_i(int(line.x1()), int(line.y1()),
+                                    int(line.x2()), int(line.y2()),
+                                    penBlend, &s->penData, mode, bounds);
+            else
+                drawLine_midpoint_dashed_i(int(line.x1()), int(line.y1()),
+                                           int(line.x2()), int(line.y2()),
+                                           &s->lastPen,
+                                           penBlend, &s->penData, mode,
+                                           bounds, &dashOffset);
+        }
+    } else {
+        QPaintEngineEx::drawLines(lines, lineCount);
+    }
+}
+
+
+/*!
+    \reimp
+*/
+void QRasterPaintEngine::drawEllipse(const QRectF &rect)
+{
+    Q_D(QRasterPaintEngine);
+    QRasterPaintEngineState *s = state();
+
+    ensurePen();
+    if (((qpen_style(s->lastPen) == Qt::SolidLine && s->flags.fast_pen)
+         || (qpen_style(s->lastPen) == Qt::NoPen && !s->flags.antialiased))
+        && qMax(rect.width(), rect.height()) < QT_RASTER_COORD_LIMIT
+        && !rect.isEmpty()
+        && s->matrix.type() <= QTransform::TxScale) // no shear
+    {
+        ensureBrush();
+        const QRectF r = s->matrix.mapRect(rect);
+        ProcessSpans penBlend = d->getPenFunc(r, &s->penData);
+        ProcessSpans brushBlend = d->getBrushFunc(r, &s->brushData);
+        const QRect brect = QRect(int(r.x()), int(r.y()),
+                                  int_dim(r.x(), r.width()),
+                                  int_dim(r.y(), r.height()));
+        if (brect == r) {
+            drawEllipse_midpoint_i(brect, d->deviceRect, penBlend, brushBlend,
+                                   &s->penData, &s->brushData);
+            return;
+        }
+    }
+    QPaintEngineEx::drawEllipse(rect);
+}
+
+/*!
+    \internal
+*/
+#ifdef Q_WS_MAC
+void QRasterPaintEngine::setCGContext(CGContextRef ctx)
+{
+    Q_D(QRasterPaintEngine);
+    d->cgContext = ctx;
+}
+
+/*!
+    \internal
+*/
+CGContextRef QRasterPaintEngine::getCGContext() const
+{
+    Q_D(const QRasterPaintEngine);
+    return d->cgContext;
+}
+#endif
+
+#ifdef Q_WS_WIN
+/*!
+    \internal
+*/
+void QRasterPaintEngine::setDC(HDC hdc) {
+    Q_D(QRasterPaintEngine);
+    d->hdc = hdc;
+}
+
+/*!
+    \internal
+*/
+HDC QRasterPaintEngine::getDC() const
+{
+    Q_D(const QRasterPaintEngine);
+    return d->hdc;
+}
+
+/*!
+    \internal
+*/
+void QRasterPaintEngine::releaseDC(HDC) const
+{
+}
+
+#endif
+
+/*!
+    \internal
+*/
+QPoint QRasterPaintEngine::coordinateOffset() const
+{
+    return QPoint(0, 0);
+}
+
+/*!
+    Draws the given color \a spans with the specified \a color. The \a
+    count parameter specifies the number of spans.
+
+    The default implementation does nothing; reimplement this function
+    to draw the given color \a spans with the specified \a color. Note
+    that this function \e must be reimplemented if the framebuffer is
+    not memory-mapped.
+
+    \sa drawBufferSpan()
+*/
+#if defined(Q_WS_QWS) && !defined(QT_NO_RASTERCALLBACKS)
+void QRasterPaintEngine::drawColorSpans(const QSpan *spans, int count, uint color)
+{
+    Q_UNUSED(spans);
+    Q_UNUSED(count);
+    Q_UNUSED(color);
+    qFatal("QRasterPaintEngine::drawColorSpans must be reimplemented on "
+           "a non memory-mapped device");
+}
+
+/*!
+    \fn void QRasterPaintEngine::drawBufferSpan(const uint *buffer, int size, int x, int y, int length, uint alpha)
+
+    Draws the given \a buffer.
+
+    The default implementation does nothing; reimplement this function
+    to draw a buffer that contains more than one color. Note that this
+    function \e must be reimplemented if the framebuffer is not
+    memory-mapped.
+
+    The \a size parameter specifies the total size of the given \a
+    buffer, while the \a length parameter specifies the number of
+    pixels to draw. The buffer's position is given by (\a x, \a
+    y). The provided \a alpha value is added to each pixel in the
+    buffer when drawing.
+
+    \sa drawColorSpans()
+*/
+void QRasterPaintEngine::drawBufferSpan(const uint *buffer, int bufsize,
+                                        int x, int y, int length, uint const_alpha)
+{
+    Q_UNUSED(buffer);
+    Q_UNUSED(bufsize);
+    Q_UNUSED(x);
+    Q_UNUSED(y);
+    Q_UNUSED(length);
+    Q_UNUSED(const_alpha);
+    qFatal("QRasterPaintEngine::drawBufferSpan must be reimplemented on "
+           "a non memory-mapped device");
+}
+#endif // Q_WS_QWS
+
+void QRasterPaintEngine::drawBitmap(const QPointF &pos, const QImage &image, QSpanData *fg)
+{
+    Q_ASSERT(fg);
+    if (!fg->blend)
+        return;
+    Q_D(QRasterPaintEngine);
+
+    Q_ASSERT(image.depth() == 1);
+
+    const int spanCount = 256;
+    QT_FT_Span spans[spanCount];
+    int n = 0;
+
+    // Boundaries
+    int w = image.width();
+    int h = image.height();
+    int ymax = qMin(qRound(pos.y() + h), d->rasterBuffer->height());
+    int ymin = qMax(qRound(pos.y()), 0);
+    int xmax = qMin(qRound(pos.x() + w), d->rasterBuffer->width());
+    int xmin = qMax(qRound(pos.x()), 0);
+
+    int x_offset = xmin - qRound(pos.x());
+
+    QImage::Format format = image.format();
+    for (int y = ymin; y < ymax; ++y) {
+        const uchar *src = image.scanLine(y - qRound(pos.y()));
+        if (format == QImage::Format_MonoLSB) {
+            for (int x = 0; x < xmax - xmin; ++x) {
+                int src_x = x + x_offset;
+                uchar pixel = src[src_x >> 3];
+                if (!pixel) {
+                    x += 7 - (src_x%8);
+                    continue;
+                }
+                if (pixel & (0x1 << (src_x & 7))) {
+                    spans[n].x = xmin + x;
+                    spans[n].y = y;
+                    spans[n].coverage = 255;
+                    int len = 1;
+                    while (src_x < w-1 && src[(src_x+1) >> 3] & (0x1 << ((src_x+1) & 7))) {
+                        ++src_x;
+                        ++len;
+                    }
+                    spans[n].len = ((len + spans[n].x) > xmax) ? (xmax - spans[n].x) : len;
+                    x += len;
+                    ++n;
+                    if (n == spanCount) {
+                        fg->blend(n, spans, fg);
+                        n = 0;
+                    }
+                }
+            }
+        } else {
+            for (int x = 0; x < xmax - xmin; ++x) {
+                int src_x = x + x_offset;
+                uchar pixel = src[src_x >> 3];
+                if (!pixel) {
+                    x += 7 - (src_x%8);
+                    continue;
+                }
+                if (pixel & (0x80 >> (x & 7))) {
+                    spans[n].x = xmin + x;
+                    spans[n].y = y;
+                    spans[n].coverage = 255;
+                    int len = 1;
+                    while (src_x < w-1 && src[(src_x+1) >> 3] & (0x80 >> ((src_x+1) & 7))) {
+                        ++src_x;
+                        ++len;
+                    }
+                    spans[n].len = ((len + spans[n].x) > xmax) ? (xmax - spans[n].x) : len;
+                    x += len;
+                    ++n;
+                    if (n == spanCount) {
+                        fg->blend(n, spans, fg);
+                        n = 0;
+                    }
+                }
+            }
+        }
+    }
+    if (n) {
+        fg->blend(n, spans, fg);
+        n = 0;
+    }
+}
+
+/*!
+    \enum QRasterPaintEngine::ClipType
+    \internal
+
+    \value RectClip Indicates that the currently set clip is a single rectangle.
+    \value ComplexClip Indicates that the currently set clip is a combination of several shapes.
+*/
+
+/*!
+    \internal
+    Returns the type of the clip currently set.
+*/
+QRasterPaintEngine::ClipType QRasterPaintEngine::clipType() const
+{
+    Q_D(const QRasterPaintEngine);
+
+    const QClipData *clip = d->clip();
+    if (!clip || clip->hasRectClip)
+        return RectClip;
+    else
+        return ComplexClip;
+}
+
+/*!
+    \internal
+    Returns the bounding rect of the currently set clip.
+*/
+QRect QRasterPaintEngine::clipBoundingRect() const
+{
+    Q_D(const QRasterPaintEngine);
+
+    const QClipData *clip = d->clip();
+
+    if (!clip)
+        return d->deviceRect;
+
+    if (clip->hasRectClip)
+        return clip->clipRect;
+
+    return QRect(clip->xmin, clip->ymin, clip->xmax - clip->xmin, clip->ymax - clip->ymin);
+}
+
+static void qt_merge_clip(const QClipData *c1, const QClipData *c2, QClipData *result)
+{
+    Q_ASSERT(c1->clipSpanHeight == c2->clipSpanHeight && c1->clipSpanHeight == result->clipSpanHeight);
+
+    QVarLengthArray<short, 4096> buffer;
+
+    QClipData::ClipLine *c1ClipLines = const_cast<QClipData *>(c1)->clipLines();
+    QClipData::ClipLine *c2ClipLines = const_cast<QClipData *>(c2)->clipLines();
+    result->initialize();
+
+    for (int y = 0; y < c1->clipSpanHeight; ++y) {
+        const QSpan *c1_spans = c1ClipLines[y].spans;
+        int c1_count = c1ClipLines[y].count;
+        const QSpan *c2_spans = c2ClipLines[y].spans;
+        int c2_count = c2ClipLines[y].count;
+
+        if (c1_count == 0 && c2_count == 0)
+            continue;
+        if (c1_count == 0) {
+            result->appendSpans(c2_spans, c2_count);
+            continue;
+        } else if (c2_count == 0) {
+            result->appendSpans(c1_spans, c1_count);
+            continue;
+        }
+
+        // we need to merge the two
+
+        // find required length
+        int max = qMax(c1_spans[c1_count - 1].x + c1_spans[c1_count - 1].len,
+                c2_spans[c2_count - 1].x + c2_spans[c2_count - 1].len);
+        buffer.resize(max);
+        memset(buffer.data(), 0, buffer.size() * sizeof(short));
+
+        // Fill with old spans.
+        for (int i = 0; i < c1_count; ++i) {
+            const QSpan *cs = c1_spans + i;
+            for (int j=cs->x; j<cs->x + cs->len; ++j)
+                buffer[j] = cs->coverage;
+        }
+
+        // Fill with new spans
+        for (int i = 0; i < c2_count; ++i) {
+            const QSpan *cs = c2_spans + i;
+            for (int j = cs->x; j < cs->x + cs->len; ++j) {
+                buffer[j] += cs->coverage;
+                if (buffer[j] > 255)
+                    buffer[j] = 255;
+            }
+        }
+
+        int x = 0;
+        while (x<max) {
+
+            // Skip to next span
+            while (x < max && buffer[x] == 0) ++x;
+            if (x >= max) break;
+
+            int sx = x;
+            int coverage = buffer[x];
+
+            // Find length of span
+            while (x < max && buffer[x] == coverage)
+                ++x;
+
+            result->appendSpan(sx, x - sx, y, coverage);
+        }
+    }
+}
+
+void QRasterPaintEnginePrivate::initializeRasterizer(QSpanData *data)
+{
+    Q_Q(QRasterPaintEngine);
+    QRasterPaintEngineState *s = q->state();
+
+    rasterizer->setAntialiased(s->flags.antialiased);
+
+    QRect clipRect(deviceRect);
+    ProcessSpans blend;
+    // ### get from optimized rectbased QClipData
+
+    const QClipData *c = clip();
+    if (c) {
+        const QRect r(QPoint(c->xmin, c->ymin),
+                      QSize(c->xmax - c->xmin, c->ymax - c->ymin));
+        clipRect = clipRect.intersected(r);
+        blend = data->blend;
+    } else {
+        blend = data->unclipped_blend;
+    }
+
+    rasterizer->setClipRect(clipRect);
+    rasterizer->initialize(blend, data);
+}
+
+void QRasterPaintEnginePrivate::rasterize(QT_FT_Outline *outline,
+                                          ProcessSpans callback,
+                                          QSpanData *spanData, QRasterBuffer *rasterBuffer)
+{
+    if (!callback || !outline)
+        return;
+
+    Q_Q(QRasterPaintEngine);
+    QRasterPaintEngineState *s = q->state();
+
+    if (!s->flags.antialiased) {
+        initializeRasterizer(spanData);
+
+        const Qt::FillRule fillRule = outline->flags == QT_FT_OUTLINE_NONE
+                                      ? Qt::WindingFill
+                                      : Qt::OddEvenFill;
+
+        rasterizer->rasterize(outline, fillRule);
+        return;
+    }
+
+    rasterize(outline, callback, (void *)spanData, rasterBuffer);
+}
+
+extern "C" {
+    int q_gray_rendered_spans(QT_FT_Raster raster);
+}
+
+void QRasterPaintEnginePrivate::rasterize(QT_FT_Outline *outline,
+                                          ProcessSpans callback,
+                                          void *userData, QRasterBuffer *)
+{
+    if (!callback || !outline)
+        return;
+
+    Q_Q(QRasterPaintEngine);
+    QRasterPaintEngineState *s = q->state();
+
+    if (!s->flags.antialiased) {
+        rasterizer->setAntialiased(s->flags.antialiased);
+        rasterizer->setClipRect(deviceRect);
+        rasterizer->initialize(callback, userData);
+
+        const Qt::FillRule fillRule = outline->flags == QT_FT_OUTLINE_NONE
+                                      ? Qt::WindingFill
+                                      : Qt::OddEvenFill;
+
+        rasterizer->rasterize(outline, fillRule);
+        return;
+    }
+
+    // Initial size for raster pool is MINIMUM_POOL_SIZE so as to
+    // minimize memory reallocations. However if initial size for
+    // raster pool is changed for lower value, reallocations will
+    // occur normally.
+    const int rasterPoolInitialSize = MINIMUM_POOL_SIZE;
+    int rasterPoolSize = rasterPoolInitialSize;
+    unsigned char *rasterPoolBase;
+#if defined(Q_WS_WIN64)
+    rasterPoolBase =
+        // We make use of setjmp and longjmp in qgrayraster.c which requires
+        // 16-byte alignment, hence we hardcode this requirement here..
+        (unsigned char *) _aligned_malloc(rasterPoolSize, sizeof(void*) * 2);
+#else
+    unsigned char rasterPoolOnStack[rasterPoolInitialSize];
+    rasterPoolBase = rasterPoolOnStack;
+#endif
+    Q_CHECK_PTR(rasterPoolBase);
+
+    qt_ft_grays_raster.raster_reset(*grayRaster.data(), rasterPoolBase, rasterPoolSize);
+
+    void *data = userData;
+
+    QT_FT_BBox clip_box = { deviceRect.x(),
+                            deviceRect.y(),
+                            deviceRect.x() + deviceRect.width(),
+                            deviceRect.y() + deviceRect.height() };
+
+    QT_FT_Raster_Params rasterParams;
+    rasterParams.target = 0;
+    rasterParams.source = outline;
+    rasterParams.flags = QT_FT_RASTER_FLAG_CLIP;
+    rasterParams.gray_spans = 0;
+    rasterParams.black_spans = 0;
+    rasterParams.bit_test = 0;
+    rasterParams.bit_set = 0;
+    rasterParams.user = data;
+    rasterParams.clip_box = clip_box;
+
+    bool done = false;
+    int error;
+
+    int rendered_spans = 0;
+
+    while (!done) {
+
+        rasterParams.flags |= (QT_FT_RASTER_FLAG_AA | QT_FT_RASTER_FLAG_DIRECT);
+        rasterParams.gray_spans = callback;
+        rasterParams.skip_spans = rendered_spans;
+        error = qt_ft_grays_raster.raster_render(*grayRaster.data(), &rasterParams);
+
+        // Out of memory, reallocate some more and try again...
+        if (error == -6) { // ErrRaster_OutOfMemory from qgrayraster.c
+            int new_size = rasterPoolSize * 2;
+            if (new_size > 1024 * 1024) {
+                qWarning("QPainter: Rasterization of primitive failed");
+                break;
+            }
+
+            rendered_spans += q_gray_rendered_spans(*grayRaster.data());
+
+#if defined(Q_WS_WIN64)
+            _aligned_free(rasterPoolBase);
+#else
+            if (rasterPoolBase != rasterPoolOnStack) // initially on the stack
+                free(rasterPoolBase);
+#endif
+
+            rasterPoolSize = new_size;
+            rasterPoolBase =
+#if defined(Q_WS_WIN64)
+                // We make use of setjmp and longjmp in qgrayraster.c which requires
+                // 16-byte alignment, hence we hardcode this requirement here..
+                (unsigned char *) _aligned_malloc(rasterPoolSize, sizeof(void*) * 2);
+#else
+                (unsigned char *) malloc(rasterPoolSize);
+#endif
+            Q_CHECK_PTR(rasterPoolBase); // note: we just freed the old rasterPoolBase. I hope it's not fatal.
+
+            qt_ft_grays_raster.raster_done(*grayRaster.data());
+            qt_ft_grays_raster.raster_new(grayRaster.data());
+            qt_ft_grays_raster.raster_reset(*grayRaster.data(), rasterPoolBase, rasterPoolSize);
+        } else {
+            done = true;
+        }
+    }
+
+#if defined(Q_WS_WIN64)
+    _aligned_free(rasterPoolBase);
+#else
+    if (rasterPoolBase != rasterPoolOnStack) // initially on the stack
+        free(rasterPoolBase);
+#endif
+}
+
+void QRasterPaintEnginePrivate::recalculateFastImages()
+{
+    Q_Q(QRasterPaintEngine);
+    QRasterPaintEngineState *s = q->state();
+
+    s->flags.fast_images = !(s->renderHints & QPainter::SmoothPixmapTransform)
+                           && s->matrix.type() <= QTransform::TxShear;
+}
+
+bool QRasterPaintEnginePrivate::canUseFastImageBlending(QPainter::CompositionMode mode, const QImage &image) const
+{
+    Q_Q(const QRasterPaintEngine);
+    const QRasterPaintEngineState *s = q->state();
+
+    return s->flags.fast_images
+           && (mode == QPainter::CompositionMode_SourceOver
+               || (mode == QPainter::CompositionMode_Source
+                   && !image.hasAlphaChannel()));
+}
+
+QImage QRasterBuffer::colorizeBitmap(const QImage &image, const QColor &color)
+{
+    Q_ASSERT(image.depth() == 1);
+
+    QImage sourceImage = image.convertToFormat(QImage::Format_MonoLSB);
+    QImage dest = QImage(sourceImage.size(), QImage::Format_ARGB32_Premultiplied);
+
+    QRgb fg = PREMUL(color.rgba());
+    QRgb bg = 0;
+
+    int height = sourceImage.height();
+    int width = sourceImage.width();
+    for (int y=0; y<height; ++y) {
+        uchar *source = sourceImage.scanLine(y);
+        QRgb *target = reinterpret_cast<QRgb *>(dest.scanLine(y));
+        if (!source || !target)
+            QT_THROW(std::bad_alloc()); // we must have run out of memory
+        for (int x=0; x < width; ++x)
+            target[x] = (source[x>>3] >> (x&7)) & 1 ? fg : bg;
+    }
+    return dest;
+}
+
+QRasterBuffer::~QRasterBuffer()
+{
+}
+
+void QRasterBuffer::init()
+{
+    compositionMode = QPainter::CompositionMode_SourceOver;
+    monoDestinationWithClut = false;
+    destColor0 = 0;
+    destColor1 = 0;
+}
+
+QImage::Format QRasterBuffer::prepare(QImage *image)
+{
+    m_buffer = (uchar *)image->bits();
+    m_width = qMin(QT_RASTER_COORD_LIMIT, image->width());
+    m_height = qMin(QT_RASTER_COORD_LIMIT, image->height());
+    bytes_per_pixel = image->depth()/8;
+    bytes_per_line = image->bytesPerLine();
+
+    format = image->format();
+    drawHelper = qDrawHelper + format;
+    if (image->depth() == 1 && image->colorTable().size() == 2) {
+        monoDestinationWithClut = true;
+        destColor0 = PREMUL(image->colorTable()[0]);
+        destColor1 = PREMUL(image->colorTable()[1]);
+    }
+
+    return format;
+}
+
+void QRasterBuffer::resetBuffer(int val)
+{
+    memset(m_buffer, val, m_height*bytes_per_line);
+}
+
+
+#if defined(Q_WS_QWS)
+void QRasterBuffer::prepare(QCustomRasterPaintDevice *device)
+{
+    m_buffer = reinterpret_cast<uchar*>(device->memory());
+    m_width = qMin(QT_RASTER_COORD_LIMIT, device->width());
+    m_height = qMin(QT_RASTER_COORD_LIMIT, device->height());
+    bytes_per_pixel = device->depth() / 8;
+    bytes_per_line = device->bytesPerLine();
+    format = device->format();
+#ifndef QT_NO_RASTERCALLBACKS
+    if (!m_buffer)
+        drawHelper = qDrawHelperCallback + format;
+    else
+#endif
+        drawHelper = qDrawHelper + format;
+}
+
+int QCustomRasterPaintDevice::metric(PaintDeviceMetric m) const
+{
+    switch (m) {
+    case PdmWidth:
+        return widget->frameGeometry().width();
+    case PdmHeight:
+        return widget->frameGeometry().height();
+    default:
+        break;
+    }
+
+    return qt_paint_device_metric(widget, m);
+}
+
+int QCustomRasterPaintDevice::bytesPerLine() const
+{
+    return (width() * depth() + 7) / 8;
+}
+
+#elif defined(Q_OS_SYMBIAN)
+
+void QRasterBuffer::prepareBuffer(int /* width */, int /* height */)
+{
+}
+
+#endif // Q_OS_SYMBIAN
+
+/*!
+    \class QCustomRasterPaintDevice
+    \preliminary
+    \ingroup qws
+    \since 4.2
+
+    \brief The QCustomRasterPaintDevice class is provided to activate
+    hardware accelerated paint engines in Qt for Embedded Linux.
+
+    Note that this class is only available in \l{Qt for Embedded Linux}.
+
+    In \l{Qt for Embedded Linux}, painting is a pure software
+    implementation. But starting with Qt 4.2, it is
+    possible to add an accelerated graphics driver to take advantage
+    of available hardware resources.
+
+    Hardware acceleration is accomplished by creating a custom screen
+    driver, accelerating the copying from memory to the screen, and
+    implementing a custom paint engine accelerating the various
+    painting operations. Then a custom paint device (derived from the
+    QCustomRasterPaintDevice class) and a custom window surface
+    (derived from QWSWindowSurface) must be implemented to make
+    \l{Qt for Embedded Linux} aware of the accelerated driver.
+
+    See the \l {Adding an Accelerated Graphics Driver to Qt for Embedded Linux}
+    documentation for details.
+
+    \sa QRasterPaintEngine, QPaintDevice
+*/
+
+/*!
+    \fn QCustomRasterPaintDevice::QCustomRasterPaintDevice(QWidget *widget)
+
+    Constructs a custom raster based paint device for the given
+    top-level \a widget.
+*/
+
+/*!
+    \fn int QCustomRasterPaintDevice::bytesPerLine() const
+
+    Returns the number of bytes per line in the framebuffer. Note that
+    this number might be larger than the framebuffer width.
+*/
+
+/*!
+    \fn int QCustomRasterPaintDevice::devType() const
+    \internal
+*/
+
+/*!
+    \fn QImage::Format QCustomRasterPaintDevice::format() const
+
+    Returns the format of the device's memory buffet.
+
+    The default format is QImage::Format_ARGB32_Premultiplied. The
+    only other valid format is QImage::Format_RGB16.
+*/
+
+/*!
+    \fn void * QCustomRasterPaintDevice::memory () const
+
+    Returns a pointer to the paint device's memory buffer, or 0 if no
+    such buffer exists.
+*/
+
+/*!
+    \fn int QCustomRasterPaintDevice::metric ( PaintDeviceMetric m ) const
+    \reimp
+*/
+
+/*!
+    \fn QSize QCustomRasterPaintDevice::size () const
+    \internal
+*/
+
+
+QClipData::QClipData(int height)
+{
+    clipSpanHeight = height;
+    m_clipLines = 0;
+
+    allocated = 0;
+    m_spans = 0;
+    xmin = xmax = ymin = ymax = 0;
+    count = 0;
+
+    enabled = true;
+    hasRectClip = hasRegionClip = false;
+}
+
+QClipData::~QClipData()
+{
+    if (m_clipLines)
+        free(m_clipLines);
+    if (m_spans)
+        free(m_spans);
+}
+
+void QClipData::initialize()
+{
+    if (m_spans)
+        return;
+
+    if (!m_clipLines)
+        m_clipLines = (ClipLine *)calloc(sizeof(ClipLine), clipSpanHeight);
+
+    Q_CHECK_PTR(m_clipLines);
+    QT_TRY {
+        m_spans = (QSpan *)malloc(clipSpanHeight*sizeof(QSpan));
+        allocated = clipSpanHeight;
+        Q_CHECK_PTR(m_spans);
+
+        QT_TRY {
+            if (hasRectClip) {
+                int y = 0;
+                while (y < ymin) {
+                    m_clipLines[y].spans = 0;
+                    m_clipLines[y].count = 0;
+                    ++y;
+                }
+
+                const int len = clipRect.width();
+                count = 0;
+                while (y < ymax) {
+                    QSpan *span = m_spans + count;
+                    span->x = xmin;
+                    span->len = len;
+                    span->y = y;
+                    span->coverage = 255;
+                    ++count;
+
+                    m_clipLines[y].spans = span;
+                    m_clipLines[y].count = 1;
+                    ++y;
+                }
+
+                while (y < clipSpanHeight) {
+                    m_clipLines[y].spans = 0;
+                    m_clipLines[y].count = 0;
+                    ++y;
+                }
+            } else if (hasRegionClip) {
+
+                const QVector<QRect> rects = clipRegion.rects();
+                const int numRects = rects.size();
+
+                { // resize
+                    const int maxSpans = (ymax - ymin) * numRects;
+                    if (maxSpans > allocated) {
+                        m_spans = q_check_ptr((QSpan *)realloc(m_spans, maxSpans * sizeof(QSpan)));
+                        allocated = maxSpans;
+                    }
+                }
+
+                int y = 0;
+                int firstInBand = 0;
+                count = 0;
+                while (firstInBand < numRects) {
+                    const int currMinY = rects.at(firstInBand).y();
+                    const int currMaxY = currMinY + rects.at(firstInBand).height();
+
+                    while (y < currMinY) {
+                        m_clipLines[y].spans = 0;
+                        m_clipLines[y].count = 0;
+                        ++y;
+                    }
+
+                    int lastInBand = firstInBand;
+                    while (lastInBand + 1 < numRects && rects.at(lastInBand+1).top() == y)
+                        ++lastInBand;
+
+                    while (y < currMaxY) {
+
+                        m_clipLines[y].spans = m_spans + count;
+                        m_clipLines[y].count = lastInBand - firstInBand + 1;
+
+                        for (int r = firstInBand; r <= lastInBand; ++r) {
+                            const QRect &currRect = rects.at(r);
+                            QSpan *span = m_spans + count;
+                            span->x = currRect.x();
+                            span->len = currRect.width();
+                            span->y = y;
+                            span->coverage = 255;
+                            ++count;
+                        }
+                        ++y;
+                    }
+
+                    firstInBand = lastInBand + 1;
+                }
+
+                Q_ASSERT(count <= allocated);
+
+                while (y < clipSpanHeight) {
+                    m_clipLines[y].spans = 0;
+                    m_clipLines[y].count = 0;
+                    ++y;
+                }
+
+            }
+        } QT_CATCH(...) {
+            free(m_spans); // have to free m_spans again or someone might think that we were successfully initialized.
+            m_spans = 0;
+            QT_RETHROW;
+        }
+    } QT_CATCH(...) {
+        free(m_clipLines); // same for clipLines
+        m_clipLines = 0;
+        QT_RETHROW;
+    }
+}
+
+void QClipData::fixup()
+{
+    Q_ASSERT(m_spans);
+
+    if (count == 0) {
+        ymin = ymax = xmin = xmax = 0;
+        return;
+    }
+
+    int y = -1;
+    ymin = m_spans[0].y;
+    ymax = m_spans[count-1].y + 1;
+    xmin = INT_MAX;
+    xmax = 0;
+
+    const int firstLeft = m_spans[0].x;
+    const int firstRight = m_spans[0].x + m_spans[0].len;
+    bool isRect = true;
+
+    for (int i = 0; i < count; ++i) {
+        QT_FT_Span_& span = m_spans[i];
+
+        if (span.y != y) {
+            if (span.y != y + 1 && y != -1)
+                isRect = false;
+            y = span.y;
+            m_clipLines[y].spans = &span;
+            m_clipLines[y].count = 1;
+        } else
+            ++m_clipLines[y].count;
+
+        const int spanLeft = span.x;
+        const int spanRight = spanLeft + span.len;
+
+        if (spanLeft < xmin)
+            xmin = spanLeft;
+
+        if (spanRight > xmax)
+            xmax = spanRight;
+
+        if (spanLeft != firstLeft || spanRight != firstRight)
+            isRect = false;
+    }
+
+    if (isRect) {
+        hasRectClip = true;
+        clipRect.setRect(xmin, ymin, xmax - xmin, ymax - ymin);
+    }
+}
+
+/*
+    Convert \a rect to clip spans.
+ */
+void QClipData::setClipRect(const QRect &rect)
+{
+    if (hasRectClip && rect == clipRect)
+        return;
+
+//    qDebug() << "setClipRect" << clipSpanHeight << count << allocated << rect;
+    hasRectClip = true;
+    hasRegionClip = false;
+    clipRect = rect;
+
+    xmin = rect.x();
+    xmax = rect.x() + rect.width();
+    ymin = qMin(rect.y(), clipSpanHeight);
+    ymax = qMin(rect.y() + rect.height(), clipSpanHeight);
+
+    if (m_spans) {
+        free(m_spans);
+        m_spans = 0;
+    }
+
+//    qDebug() << xmin << xmax << ymin << ymax;
+}
+
+/*
+    Convert \a region to clip spans.
+ */
+void QClipData::setClipRegion(const QRegion &region)
+{
+    if (region.rectCount() == 1) {
+        setClipRect(region.rects().at(0));
+        return;
+    }
+
+    hasRegionClip = true;
+    hasRectClip = false;
+    clipRegion = region;
+
+    { // set bounding rect
+        const QRect rect = region.boundingRect();
+        xmin = rect.x();
+        xmax = rect.x() + rect.width();
+        ymin = rect.y();
+        ymax = rect.y() + rect.height();
+    }
+
+    if (m_spans) {
+        free(m_spans);
+        m_spans = 0;
+    }
+
+}
+
+/*!
+    \internal
+    spans must be sorted on y
+*/
+static const QSpan *qt_intersect_spans(const QClipData *clip, int *currentClip,
+                                       const QSpan *spans, const QSpan *end,
+                                       QSpan **outSpans, int available)
+{
+    const_cast<QClipData *>(clip)->initialize();
+
+    QSpan *out = *outSpans;
+
+    const QSpan *clipSpans = clip->m_spans + *currentClip;
+    const QSpan *clipEnd = clip->m_spans + clip->count;
+
+    while (available && spans < end ) {
+        if (clipSpans >= clipEnd) {
+            spans = end;
+            break;
+        }
+        if (clipSpans->y > spans->y) {
+            ++spans;
+            continue;
+        }
+        if (spans->y != clipSpans->y) {
+            if (spans->y < clip->count && clip->m_clipLines[spans->y].spans)
+                clipSpans = clip->m_clipLines[spans->y].spans;
+            else
+                ++clipSpans;
+            continue;
+        }
+        Q_ASSERT(spans->y == clipSpans->y);
+
+        int sx1 = spans->x;
+        int sx2 = sx1 + spans->len;
+        int cx1 = clipSpans->x;
+        int cx2 = cx1 + clipSpans->len;
+
+        if (cx1 < sx1 && cx2 < sx1) {
+            ++clipSpans;
+            continue;
+        } else if (sx1 < cx1 && sx2 < cx1) {
+            ++spans;
+            continue;
+        }
+        int x = qMax(sx1, cx1);
+        int len = qMin(sx2, cx2) - x;
+        if (len) {
+            out->x = qMax(sx1, cx1);
+            out->len = qMin(sx2, cx2) - out->x;
+            out->y = spans->y;
+            out->coverage = qt_div_255(spans->coverage * clipSpans->coverage);
+            ++out;
+            --available;
+        }
+        if (sx2 < cx2) {
+            ++spans;
+        } else {
+            ++clipSpans;
+        }
+    }
+
+    *outSpans = out;
+    *currentClip = clipSpans - clip->m_spans;
+    return spans;
+}
+
+static void qt_span_fill_clipped(int spanCount, const QSpan *spans, void *userData)
+{
+//     qDebug() << "qt_span_fill_clipped" << spanCount;
+    QSpanData *fillData = reinterpret_cast<QSpanData *>(userData);
+
+    Q_ASSERT(fillData->blend && fillData->unclipped_blend);
+
+    const int NSPANS = 256;
+    QSpan cspans[NSPANS];
+    int currentClip = 0;
+    const QSpan *end = spans + spanCount;
+    while (spans < end) {
+        QSpan *clipped = cspans;
+        spans = qt_intersect_spans(fillData->clip, &currentClip, spans, end, &clipped, NSPANS);
+//         qDebug() << "processed " << processed << "clipped" << clipped-cspans
+//                  << "span:" << cspans->x << cspans->y << cspans->len << spans->coverage;
+
+        if (clipped - cspans)
+            fillData->unclipped_blend(clipped - cspans, cspans, fillData);
+    }
+}
+
+/*
+    \internal
+    Clip spans to \a{clip}-rectangle.
+    Returns number of unclipped spans
+*/
+static int qt_intersect_spans(QT_FT_Span *spans, int numSpans,
+                              const QRect &clip)
+{
+    const short minx = clip.left();
+    const short miny = clip.top();
+    const short maxx = clip.right();
+    const short maxy = clip.bottom();
+
+    int n = 0;
+    for (int i = 0; i < numSpans; ++i) {
+        if (spans[i].y > maxy)
+            break;
+        if (spans[i].y < miny
+            || spans[i].x > maxx
+            || spans[i].x + spans[i].len <= minx) {
+            continue;
+        }
+        if (spans[i].x < minx) {
+            spans[n].len = qMin(spans[i].len - (minx - spans[i].x), maxx - minx + 1);
+            spans[n].x = minx;
+        } else {
+            spans[n].x = spans[i].x;
+            spans[n].len = qMin(spans[i].len, ushort(maxx - spans[n].x + 1));
+        }
+        if (spans[n].len == 0)
+            continue;
+        spans[n].y = spans[i].y;
+        spans[n].coverage = spans[i].coverage;
+        ++n;
+    }
+    return n;
+}
+
+
+static void qt_span_fill_clipRect(int count, const QSpan *spans,
+                                  void *userData)
+{
+    QSpanData *fillData = reinterpret_cast<QSpanData *>(userData);
+    Q_ASSERT(fillData->blend && fillData->unclipped_blend);
+
+    Q_ASSERT(fillData->clip);
+    Q_ASSERT(!fillData->clip->clipRect.isEmpty());
+
+    // hw: check if this const_cast<> is safe!!!
+    count = qt_intersect_spans(const_cast<QSpan*>(spans), count,
+                               fillData->clip->clipRect);
+    if (count > 0)
+        fillData->unclipped_blend(count, spans, fillData);
+}
+
+static void qt_span_clip(int count, const QSpan *spans, void *userData)
+{
+    ClipData *clipData = reinterpret_cast<ClipData *>(userData);
+
+//     qDebug() << " qt_span_clip: " << count << clipData->operation;
+//     for (int i = 0; i < qMin(count, 10); ++i) {
+//         qDebug() << "    " << spans[i].x << spans[i].y << spans[i].len << spans[i].coverage;
+//     }
+
+    switch (clipData->operation) {
+
+    case Qt::IntersectClip:
+        {
+            QClipData *newClip = clipData->newClip;
+            newClip->initialize();
+
+            int currentClip = 0;
+            const QSpan *end = spans + count;
+            while (spans < end) {
+                QSpan *newspans = newClip->m_spans + newClip->count;
+                spans = qt_intersect_spans(clipData->oldClip, &currentClip, spans, end,
+                                           &newspans, newClip->allocated - newClip->count);
+                newClip->count = newspans - newClip->m_spans;
+                if (spans < end) {
+                    newClip->m_spans = q_check_ptr((QSpan *)realloc(newClip->m_spans, newClip->allocated*2*sizeof(QSpan)));
+                    newClip->allocated *= 2;
+                }
+            }
+        }
+        break;
+
+    case Qt::UniteClip:
+    case Qt::ReplaceClip:
+        clipData->newClip->appendSpans(spans, count);
+        break;
+    case Qt::NoClip:
+        break;
+    }
+}
+
+#ifndef QT_NO_DEBUG
+QImage QRasterBuffer::bufferImage() const
+{
+    QImage image(m_width, m_height, QImage::Format_ARGB32_Premultiplied);
+
+    for (int y = 0; y < m_height; ++y) {
+        uint *span = (uint *)const_cast<QRasterBuffer *>(this)->scanLine(y);
+
+        for (int x=0; x<m_width; ++x) {
+            uint argb = span[x];
+            image.setPixel(x, y, argb);
+        }
+    }
+    return image;
+}
+#endif
+
+
+void QRasterBuffer::flushToARGBImage(QImage *target) const
+{
+    int w = qMin(m_width, target->width());
+    int h = qMin(m_height, target->height());
+
+    for (int y=0; y<h; ++y) {
+        uint *sourceLine = (uint *)const_cast<QRasterBuffer *>(this)->scanLine(y);
+        QRgb *dest = (QRgb *) target->scanLine(y);
+        for (int x=0; x<w; ++x) {
+            QRgb pixel = sourceLine[x];
+            int alpha = qAlpha(pixel);
+            if (!alpha) {
+                dest[x] = 0;
+            } else {
+                dest[x] = (alpha << 24)
+                        | ((255*qRed(pixel)/alpha) << 16)
+                        | ((255*qGreen(pixel)/alpha) << 8)
+                        | ((255*qBlue(pixel)/alpha) << 0);
+            }
+        }
+    }
+}
+
+
+class QGradientCache
+{
+    struct CacheInfo
+    {
+        inline CacheInfo(QGradientStops s, int op, QGradient::InterpolationMode mode) :
+            stops(s), opacity(op), interpolationMode(mode) {}
+        uint buffer[GRADIENT_STOPTABLE_SIZE];
+        QGradientStops stops;
+        int opacity;
+        QGradient::InterpolationMode interpolationMode;
+    };
+
+    typedef QMultiHash<quint64, CacheInfo> QGradientColorTableHash;
+
+public:
+    inline const uint *getBuffer(const QGradient &gradient, int opacity) {
+        quint64 hash_val = 0;
+
+        QGradientStops stops = gradient.stops();
+        for (int i = 0; i < stops.size() && i <= 2; i++)
+            hash_val += stops[i].second.rgba();
+
+        QMutexLocker lock(&mutex);
+        QGradientColorTableHash::const_iterator it = cache.constFind(hash_val);
+
+        if (it == cache.constEnd())
+            return addCacheElement(hash_val, gradient, opacity);
+        else {
+            do {
+                const CacheInfo &cache_info = it.value();
+                if (cache_info.stops == stops && cache_info.opacity == opacity && cache_info.interpolationMode == gradient.interpolationMode())
+                    return cache_info.buffer;
+                ++it;
+            } while (it != cache.constEnd() && it.key() == hash_val);
+            // an exact match for these stops and opacity was not found, create new cache
+            return addCacheElement(hash_val, gradient, opacity);
+        }
+    }
+
+    inline int paletteSize() const { return GRADIENT_STOPTABLE_SIZE; }
+protected:
+    inline int maxCacheSize() const { return 60; }
+    inline void generateGradientColorTable(const QGradient& g,
+                                           uint *colorTable,
+                                           int size, int opacity) const;
+    uint *addCacheElement(quint64 hash_val, const QGradient &gradient, int opacity) {
+        if (cache.size() == maxCacheSize()) {
+            // may remove more than 1, but OK
+            cache.erase(cache.begin() + (qrand() % maxCacheSize()));
+        }
+        CacheInfo cache_entry(gradient.stops(), opacity, gradient.interpolationMode());
+        generateGradientColorTable(gradient, cache_entry.buffer, paletteSize(), opacity);
+        return cache.insert(hash_val, cache_entry).value().buffer;
+    }
+
+    QGradientColorTableHash cache;
+    QMutex mutex;
+};
+
+void QGradientCache::generateGradientColorTable(const QGradient& gradient, uint *colorTable, int size, int opacity) const
+{
+    QGradientStops stops = gradient.stops();
+    int stopCount = stops.count();
+    Q_ASSERT(stopCount > 0);
+
+    bool colorInterpolation = (gradient.interpolationMode() == QGradient::ColorInterpolation);
+
+    uint current_color = ARGB_COMBINE_ALPHA(stops[0].second.rgba(), opacity);
+    if (stopCount == 1) {
+        current_color = PREMUL(current_color);
+        for (int i = 0; i < size; ++i)
+            colorTable[i] = current_color;
+        return;
+    }
+
+    // The position where the gradient begins and ends
+    qreal begin_pos = stops[0].first;
+    qreal end_pos = stops[stopCount-1].first;
+
+    int pos = 0; // The position in the color table.
+    uint next_color;
+
+    qreal incr = 1 / qreal(size); // the double increment.
+    qreal dpos = 1.5 * incr; // current position in gradient stop list (0 to 1)
+
+     // Up to first point
+    colorTable[pos++] = PREMUL(current_color);
+    while (dpos <= begin_pos) {
+        colorTable[pos] = colorTable[pos - 1];
+        ++pos;
+        dpos += incr;
+    }
+
+    int current_stop = 0; // We always interpolate between current and current + 1.
+
+    qreal t; // position between current left and right stops
+    qreal t_delta; // the t increment per entry in the color table
+
+    if (dpos < end_pos) {
+        // Gradient area
+        while (dpos > stops[current_stop+1].first)
+            ++current_stop;
+
+        if (current_stop != 0)
+            current_color = ARGB_COMBINE_ALPHA(stops[current_stop].second.rgba(), opacity);
+        next_color = ARGB_COMBINE_ALPHA(stops[current_stop+1].second.rgba(), opacity);
+
+        if (colorInterpolation) {
+            current_color = PREMUL(current_color);
+            next_color = PREMUL(next_color);
+        }
+
+        qreal diff = stops[current_stop+1].first - stops[current_stop].first;
+        qreal c = (diff == 0) ? qreal(0) : 256 / diff;
+        t = (dpos - stops[current_stop].first) * c;
+        t_delta = incr * c;
+
+        while (true) {
+            Q_ASSERT(current_stop < stopCount);
+
+            int dist = qRound(t);
+            int idist = 256 - dist;
+
+            if (colorInterpolation)
+                colorTable[pos] = INTERPOLATE_PIXEL_256(current_color, idist, next_color, dist);
+            else
+                colorTable[pos] = PREMUL(INTERPOLATE_PIXEL_256(current_color, idist, next_color, dist));
+
+            ++pos;
+            dpos += incr;
+
+            if (dpos >= end_pos)
+                break;
+
+            t += t_delta;
+
+            int skip = 0;
+            while (dpos > stops[current_stop+skip+1].first)
+                ++skip;
+
+            if (skip != 0) {
+                current_stop += skip;
+                if (skip == 1)
+                    current_color = next_color;
+                else
+                    current_color = ARGB_COMBINE_ALPHA(stops[current_stop].second.rgba(), opacity);
+                next_color = ARGB_COMBINE_ALPHA(stops[current_stop+1].second.rgba(), opacity);
+
+                if (colorInterpolation) {
+                    if (skip != 1)
+                        current_color = PREMUL(current_color);
+                    next_color = PREMUL(next_color);
+                }
+
+                qreal diff = stops[current_stop+1].first - stops[current_stop].first;
+                qreal c = (diff == 0) ? qreal(0) : 256 / diff;
+                t = (dpos - stops[current_stop].first) * c;
+                t_delta = incr * c;
+            }
+        }
+    }
+
+    // After last point
+    current_color = PREMUL(ARGB_COMBINE_ALPHA(stops[stopCount - 1].second.rgba(), opacity));
+    while (pos < size - 1) {
+        colorTable[pos] = current_color;
+        ++pos;
+    }
+
+    // Make sure the last color stop is represented at the end of the table
+    colorTable[size - 1] = current_color;
+}
+
+Q_GLOBAL_STATIC(QGradientCache, qt_gradient_cache)
+
+
+void QSpanData::init(QRasterBuffer *rb, const QRasterPaintEngine *pe)
+{
+    rasterBuffer = rb;
+#ifdef Q_WS_QWS
+    rasterEngine = const_cast<QRasterPaintEngine *>(pe);
+#endif
+    type = None;
+    txop = 0;
+    bilinear = false;
+    m11 = m22 = m33 = 1.;
+    m12 = m13 = m21 = m23 = dx = dy = 0.0;
+    clip = pe ? pe->d_func()->clip() : 0;
+}
+
+Q_GUI_EXPORT extern QImage qt_imageForBrush(int brushStyle, bool invert);
+
+void QSpanData::setup(const QBrush &brush, int alpha, QPainter::CompositionMode compositionMode)
+{
+    Qt::BrushStyle brushStyle = qbrush_style(brush);
+    switch (brushStyle) {
+    case Qt::SolidPattern: {
+        type = Solid;
+        QColor c = qbrush_color(brush);
+        QRgb rgba = c.rgba();
+        solid.color = PREMUL(ARGB_COMBINE_ALPHA(rgba, alpha));
+        if ((solid.color & 0xff000000) == 0
+            && compositionMode == QPainter::CompositionMode_SourceOver) {
+            type = None;
+        }
+        break;
+    }
+
+    case Qt::LinearGradientPattern:
+        {
+            type = LinearGradient;
+            const QLinearGradient *g = static_cast<const QLinearGradient *>(brush.gradient());
+            gradient.alphaColor = !brush.isOpaque() || alpha != 256;
+            gradient.colorTable = const_cast<uint*>(qt_gradient_cache()->getBuffer(*g, alpha));
+            gradient.spread = g->spread();
+
+            QLinearGradientData &linearData = gradient.linear;
+
+            linearData.origin.x = g->start().x();
+            linearData.origin.y = g->start().y();
+            linearData.end.x = g->finalStop().x();
+            linearData.end.y = g->finalStop().y();
+            break;
+        }
+
+    case Qt::RadialGradientPattern:
+        {
+            type = RadialGradient;
+            const QRadialGradient *g = static_cast<const QRadialGradient *>(brush.gradient());
+            gradient.alphaColor = !brush.isOpaque() || alpha != 256;
+            gradient.colorTable = const_cast<uint*>(qt_gradient_cache()->getBuffer(*g, alpha));
+            gradient.spread = g->spread();
+
+            QRadialGradientData &radialData = gradient.radial;
+
+            QPointF center = g->center();
+            radialData.center.x = center.x();
+            radialData.center.y = center.y();
+            QPointF focal = g->focalPoint();
+            radialData.focal.x = focal.x();
+            radialData.focal.y = focal.y();
+            radialData.radius = g->radius();
+        }
+        break;
+
+    case Qt::ConicalGradientPattern:
+        {
+            type = ConicalGradient;
+            const QConicalGradient *g = static_cast<const QConicalGradient *>(brush.gradient());
+            gradient.alphaColor = !brush.isOpaque() || alpha != 256;
+            gradient.colorTable = const_cast<uint*>(qt_gradient_cache()->getBuffer(*g, alpha));
+            gradient.spread = QGradient::RepeatSpread;
+
+            QConicalGradientData &conicalData = gradient.conical;
+
+            QPointF center = g->center();
+            conicalData.center.x = center.x();
+            conicalData.center.y = center.y();
+            conicalData.angle = g->angle() * 2 * Q_PI / 360.0;
+        }
+        break;
+
+    case Qt::Dense1Pattern:
+    case Qt::Dense2Pattern:
+    case Qt::Dense3Pattern:
+    case Qt::Dense4Pattern:
+    case Qt::Dense5Pattern:
+    case Qt::Dense6Pattern:
+    case Qt::Dense7Pattern:
+    case Qt::HorPattern:
+    case Qt::VerPattern:
+    case Qt::CrossPattern:
+    case Qt::BDiagPattern:
+    case Qt::FDiagPattern:
+    case Qt::DiagCrossPattern:
+        type = Texture;
+        if (!tempImage)
+            tempImage = new QImage();
+        *tempImage = rasterBuffer->colorizeBitmap(qt_imageForBrush(brushStyle, true), brush.color());
+        initTexture(tempImage, alpha, QTextureData::Tiled);
+        break;
+    case Qt::TexturePattern:
+        type = Texture;
+        if (!tempImage)
+            tempImage = new QImage();
+
+        if (qHasPixmapTexture(brush) && brush.texture().isQBitmap())
+            *tempImage = rasterBuffer->colorizeBitmap(brush.textureImage(), brush.color());
+        else
+            *tempImage = brush.textureImage();
+        initTexture(tempImage, alpha, QTextureData::Tiled, tempImage->rect());
+        break;
+
+    case Qt::NoBrush:
+    default:
+        type = None;
+        break;
+    }
+    adjustSpanMethods();
+}
+
+void QSpanData::adjustSpanMethods()
+{
+    bitmapBlit = 0;
+    alphamapBlit = 0;
+    alphaRGBBlit = 0;
+
+    fillRect = 0;
+
+    switch(type) {
+    case None:
+        unclipped_blend = 0;
+        break;
+    case Solid:
+        unclipped_blend = rasterBuffer->drawHelper->blendColor;
+        bitmapBlit = rasterBuffer->drawHelper->bitmapBlit;
+        alphamapBlit = rasterBuffer->drawHelper->alphamapBlit;
+        alphaRGBBlit = rasterBuffer->drawHelper->alphaRGBBlit;
+        fillRect = rasterBuffer->drawHelper->fillRect;
+        break;
+    case LinearGradient:
+    case RadialGradient:
+    case ConicalGradient:
+        unclipped_blend = rasterBuffer->drawHelper->blendGradient;
+        break;
+    case Texture:
+#ifdef Q_WS_QWS
+#ifndef QT_NO_RASTERCALLBACKS
+        if (!rasterBuffer->buffer())
+            unclipped_blend = qBlendTextureCallback;
+        else
+#endif
+            unclipped_blend = qBlendTexture;
+#else
+        unclipped_blend = qBlendTexture;
+#endif
+        if (!texture.imageData)
+            unclipped_blend = 0;
+
+        break;
+    }
+    // setup clipping
+    if (!unclipped_blend) {
+        blend = 0;
+    } else if (!clip) {
+        blend = unclipped_blend;
+    } else if (clip->hasRectClip) {
+        blend = clip->clipRect.isEmpty() ? 0 : qt_span_fill_clipRect;
+    } else {
+        blend = qt_span_fill_clipped;
+    }
+}
+
+void QSpanData::setupMatrix(const QTransform &matrix, int bilin)
+{
+    QTransform delta;
+    // make sure we round off correctly in qdrawhelper.cpp
+    delta.translate(1.0 / 65536, 1.0 / 65536);
+
+    QTransform inv = (delta * matrix).inverted();
+    m11 = inv.m11();
+    m12 = inv.m12();
+    m13 = inv.m13();
+    m21 = inv.m21();
+    m22 = inv.m22();
+    m23 = inv.m23();
+    m33 = inv.m33();
+    dx = inv.dx();
+    dy = inv.dy();
+    txop = inv.type();
+    bilinear = bilin;
+
+    const bool affine = !m13 && !m23;
+    fast_matrix = affine
+        && m11 * m11 + m21 * m21 < 1e4
+        && m12 * m12 + m22 * m22 < 1e4
+        && qAbs(dx) < 1e4
+        && qAbs(dy) < 1e4;
+
+    adjustSpanMethods();
+}
+
+extern const QVector<QRgb> *qt_image_colortable(const QImage &image);
+
+void QSpanData::initTexture(const QImage *image, int alpha, QTextureData::Type _type, const QRect &sourceRect)
+{
+    const QImageData *d = const_cast<QImage *>(image)->data_ptr();
+    if (!d || d->height == 0) {
+        texture.imageData = 0;
+        texture.width = 0;
+        texture.height = 0;
+        texture.x1 = 0;
+        texture.y1 = 0;
+        texture.x2 = 0;
+        texture.y2 = 0;
+        texture.bytesPerLine = 0;
+        texture.format = QImage::Format_Invalid;
+        texture.colorTable = 0;
+        texture.hasAlpha = alpha != 256;
+    } else {
+        texture.imageData = d->data;
+        texture.width = d->width;
+        texture.height = d->height;
+
+        if (sourceRect.isNull()) {
+            texture.x1 = 0;
+            texture.y1 = 0;
+            texture.x2 = texture.width;
+            texture.y2 = texture.height;
+        } else {
+            texture.x1 = sourceRect.x();
+            texture.y1 = sourceRect.y();
+            texture.x2 = qMin(texture.x1 + sourceRect.width(), d->width);
+            texture.y2 = qMin(texture.y1 + sourceRect.height(), d->height);
+        }
+
+        texture.bytesPerLine = d->bytes_per_line;
+
+        texture.format = d->format;
+        texture.colorTable = (d->format <= QImage::Format_Indexed8 && !d->colortable.isEmpty()) ? &d->colortable : 0;
+        texture.hasAlpha = image->hasAlphaChannel() || alpha != 256;
+    }
+    texture.const_alpha = alpha;
+    texture.type = _type;
+
+    adjustSpanMethods();
+}
+
+#ifdef Q_WS_WIN
+
+
+#endif
+
+
+/*!
+    \internal
+
+    Draws a line using the floating point midpoint algorithm. The line
+    \a line is already in device coords at this point.
+*/
+
+static void drawLine_midpoint_i(int x1, int y1, int x2, int y2, ProcessSpans span_func, QSpanData *data,
+                                LineDrawMode style, const QIntRect &devRect)
+{
+#ifdef QT_DEBUG_DRAW
+    qDebug() << "   - drawLine_midpoint_i" << QLine(QPoint(x1, y1), QPoint(x2, y2));
+#endif
+
+    int x, y;
+    int dx, dy, d, incrE, incrNE;
+
+    dx = x2 - x1;
+    dy = y2 - y1;
+
+    const int NSPANS = 256;
+    QT_FT_Span spans[NSPANS];
+    int current = 0;
+    bool ordered = true;
+
+    if (dy == 0) {
+        // specialcase horizontal lines
+        if (y1 >= devRect.y1 && y1 < devRect.y2) {
+            int start = qMax(devRect.x1, qMin(x1, x2));
+            int stop = qMax(x1, x2) + 1;
+            int stop_clipped = qMin(devRect.x2, stop);
+            int len = stop_clipped - start;
+            if (style == LineDrawNormal && stop == stop_clipped)
+                len--;
+            if (len > 0) {
+                spans[0].x = ushort(start);
+                spans[0].len = ushort(len);
+                spans[0].y = y1;
+                spans[0].coverage = 255;
+                span_func(1, spans, data);
+            }
+        }
+        return;
+    } else if (dx == 0) {
+        // specialcase vertical lines
+        if (x1 >= devRect.x1 && x1 < devRect.x2) {
+            int start = qMax(devRect.y1, qMin(y1, y2));
+            int stop = qMax(y1, y2) + 1;
+            int stop_clipped = qMin(devRect.y2, stop);
+            int len = stop_clipped - start;
+            if (style == LineDrawNormal && stop == stop_clipped)
+                len--;
+            // hw: create spans directly instead to possibly avoid clipping
+            if (len > 0)
+                fillRect_normalized(QRect(x1, start, 1, len).normalized(), data, 0);
+        }
+        return;
+    }
+
+
+    if (qAbs(dx) >= qAbs(dy)) {       /* if x is the major axis: */
+
+        if (x2 < x1) {  /* if coordinates are out of order */
+            qt_swap_int(x1, x2);
+            dx = -dx;
+
+            qt_swap_int(y1, y2);
+            dy = -dy;
+        }
+
+        int x_lower_limit = - 128;
+        if (x1 < x_lower_limit) {
+            int cy = dy * (x_lower_limit - x1) / dx + y1;
+            drawLine_midpoint_i(x_lower_limit, cy, x2, y2, span_func, data, style, devRect);
+            return;
+        }
+
+        if (style == LineDrawNormal)
+            --x2;
+
+        // In the loops below we increment before call the span function so
+        // we need to stop one pixel before
+        x2 = qMin(x2, devRect.x2 - 1);
+
+        // completely clipped, so abort
+        if (x2 <= x1) {
+            return;
+        }
+
+        int x = x1;
+        int y = y1;
+
+        if (y2 <= y1)
+            ordered = false;
+
+        {
+            const int index = (ordered ? current : NSPANS - 1 - current);
+            spans[index].coverage = 255;
+            spans[index].x = x;
+            spans[index].y = y;
+
+            if (x >= devRect.x1 && y >= devRect.y1 && y < devRect.y2)
+                spans[index].len = 1;
+            else
+                spans[index].len = 0;
+        }
+
+        if (y2 > y1) { // 315 -> 360 and 135 -> 180 (unit circle degrees)
+            y2 = qMin(y2, devRect.y2 - 1);
+
+            incrE = dy * 2;
+            d = incrE - dx;
+            incrNE = (dy - dx) * 2;
+
+            if (y > y2)
+                goto flush_and_return;
+
+            while (x < x2) {
+                ++x;
+                if (d > 0) {
+                    if (spans[current].len > 0)
+                        ++current;
+                    if (current == NSPANS) {
+                        span_func(NSPANS, spans, data);
+                        current = 0;
+                    }
+
+                    ++y;
+                    d += incrNE;
+                    if (y > y2)
+                        goto flush_and_return;
+
+                    spans[current].len = 0;
+                    spans[current].coverage = 255;
+                    spans[current].x = x;
+                    spans[current].y = y;
+                } else {
+                    d += incrE;
+                    if (x == devRect.x1)
+                        spans[current].x = devRect.x1;
+                }
+
+                if (x < devRect.x1 || y < devRect.y1)
+                    continue;
+
+                Q_ASSERT(x<devRect.x2);
+                Q_ASSERT(y<devRect.y2);
+                Q_ASSERT(spans[current].y == y);
+                spans[current].len++;
+            }
+            if (spans[current].len > 0) {
+                ++current;
+            }
+        } else {  // 0-45 and 180->225 (unit circle degrees)
+
+            y1 = qMin(y1, devRect.y2 - 1);
+
+            incrE = dy * 2;
+            d = incrE + dx;
+            incrNE = (dy + dx) * 2;
+
+            if (y < devRect.y1)
+                goto flush_and_return;
+
+            while (x < x2) {
+                ++x;
+                if (d < 0) {
+                    if (spans[NSPANS - 1 - current].len > 0)
+                        ++current;
+                    if (current == NSPANS) {
+                        span_func(NSPANS, spans, data);
+                        current = 0;
+                    }
+
+                    --y;
+                    d += incrNE;
+                    if (y < devRect.y1)
+                        goto flush_and_return;
+
+                    const int index = NSPANS - 1 - current;
+                    spans[index].len = 0;
+                    spans[index].coverage = 255;
+                    spans[index].x = x;
+                    spans[index].y = y;
+                } else {
+                    d += incrE;
+                    if (x == devRect.x1)
+                        spans[NSPANS - 1 - current].x = devRect.x1;
+                }
+
+                if (x < devRect.x1 || y > y1)
+                    continue;
+
+                Q_ASSERT(x<devRect.x2 && y<devRect.y2);
+                Q_ASSERT(spans[NSPANS - 1 - current].y == y);
+                spans[NSPANS - 1 - current].len++;
+            }
+            if (spans[NSPANS - 1 - current].len > 0) {
+                ++current;
+            }
+        }
+
+    } else {
+
+        // if y is the major axis:
+
+        if (y2 < y1) {      /* if coordinates are out of order */
+            qt_swap_int(y1, y2);
+            dy = -dy;
+
+            qt_swap_int(x1, x2);
+            dx = -dx;
+        }
+
+        int y_lower_limit = - 128;
+        if (y1 < y_lower_limit) {
+            int cx = dx * (y_lower_limit - y1) / dy + x1;
+            drawLine_midpoint_i(cx, y_lower_limit, x2, y2, span_func, data, style, devRect);
+            return;
+        }
+
+        if (style == LineDrawNormal)
+            --y2;
+
+        // In the loops below we increment before call the span function so
+        // we need to stop one pixel before
+        y2 = qMin(y2, devRect.y2 - 1);
+
+        // completely clipped, so abort
+        if (y2 <= y1) {
+            return;
+        }
+
+        x = x1;
+        y = y1;
+
+        if (x>=devRect.x1 && y>=devRect.y1 && x < devRect.x2) {
+            Q_ASSERT(x >= devRect.x1 && y >= devRect.y1 && x < devRect.x2 && y < devRect.y2);
+            if (current == NSPANS) {
+                span_func(NSPANS, spans, data);
+                current = 0;
+            }
+            spans[current].len = 1;
+            spans[current].coverage = 255;
+            spans[current].x = x;
+            spans[current].y = y;
+            ++current;
+        }
+
+        if (x2 > x1) { // 90 -> 135 and 270 -> 315 (unit circle degrees)
+            x2 = qMin(x2, devRect.x2 - 1);
+            incrE = dx * 2;
+            d = incrE - dy;
+            incrNE = (dx - dy) * 2;
+
+            if (x > x2)
+                goto flush_and_return;
+
+            while (y < y2) {
+                if (d > 0) {
+                    ++x;
+                    d += incrNE;
+                    if (x > x2)
+                        goto flush_and_return;
+                } else {
+                    d += incrE;
+                }
+                ++y;
+                if (x < devRect.x1 || y < devRect.y1)
+                    continue;
+                Q_ASSERT(x<devRect.x2 && y<devRect.y2);
+                if (current == NSPANS) {
+                    span_func(NSPANS, spans, data);
+                    current = 0;
+                }
+                spans[current].len = 1;
+                spans[current].coverage = 255;
+                spans[current].x = x;
+                spans[current].y = y;
+                ++current;
+            }
+        } else { // 45 -> 90 and 225 -> 270 (unit circle degrees)
+            x1 = qMin(x1, devRect.x2 - 1);
+            incrE = dx * 2;
+            d = incrE + dy;
+            incrNE = (dx + dy) * 2;
+
+            if (x < devRect.x1)
+                goto flush_and_return;
+
+            while (y < y2) {
+                if (d < 0) {
+                    --x;
+                    d += incrNE;
+                    if (x < devRect.x1)
+                        goto flush_and_return;
+                } else {
+                    d += incrE;
+                }
+                ++y;
+                if (y < devRect.y1 || x > x1)
+                    continue;
+                Q_ASSERT(x>=devRect.x1 && x<devRect.x2 && y>=devRect.y1 && y<devRect.y2);
+                if (current == NSPANS) {
+                    span_func(NSPANS, spans, data);
+                    current = 0;
+                }
+                spans[current].len = 1;
+                spans[current].coverage = 255;
+                spans[current].x = x;
+                spans[current].y = y;
+                ++current;
+            }
+        }
+    }
+flush_and_return:
+    if (current > 0)
+        span_func(current, ordered ? spans : spans + (NSPANS - current), data);
+}
+
+static void offset_pattern(int offset, bool *inDash, int *dashIndex, int *currentOffset, const QVarLengthArray<qreal> &pattern)
+{
+    while (offset--) {
+        if (--*currentOffset == 0) {
+            *inDash = !*inDash;
+            *dashIndex = ((*dashIndex + 1) % pattern.size());
+            *currentOffset = int(pattern[*dashIndex]);
+        }
+    }
+}
+
+static void drawLine_midpoint_dashed_i(int x1, int y1, int x2, int y2,
+                                       QPen *pen,
+                                       ProcessSpans span_func, QSpanData *data,
+                                       LineDrawMode style, const QIntRect &devRect,
+                                       int *patternOffset)
+{
+#ifdef QT_DEBUG_DRAW
+    qDebug() << "   - drawLine_midpoint_dashed_i" << x1 << y1 << x2 << y2 << *patternOffset;
+#endif
+
+    int x, y;
+    int dx, dy, d, incrE, incrNE;
+
+    dx = x2 - x1;
+    dy = y2 - y1;
+
+    Q_ASSERT(*patternOffset >= 0);
+
+    const QVector<qreal> penPattern = pen->dashPattern();
+    QVarLengthArray<qreal> pattern(penPattern.size());
+
+    int patternLength = 0;
+    for (int i = 0; i < penPattern.size(); ++i)
+        patternLength += qMax<qreal>(1.0, (penPattern.at(i)));
+
+    // pattern must be reversed if coordinates are out of order
+    int reverseLength = -1;
+    if (dy == 0 && x1 > x2)
+        reverseLength = x1 - x2;
+    else if (dx == 0 && y1 > y2)
+        reverseLength = y1 - y2;
+    else if (qAbs(dx) >= qAbs(dy) && x2 < x1) // x major axis
+        reverseLength = qAbs(dx);
+    else if (qAbs(dy) >= qAbs(dx) && y2 < y1) // y major axis
+        reverseLength = qAbs(dy);
+
+    const bool reversed = (reverseLength > -1);
+    if (reversed) { // reverse pattern
+        for (int i = 0; i < penPattern.size(); ++i)
+            pattern[penPattern.size() - 1 - i] = qMax<qreal>(1.0, penPattern.at(i));
+
+        *patternOffset = (patternLength - 1 - *patternOffset);
+        *patternOffset += patternLength - (reverseLength % patternLength);
+        *patternOffset = *patternOffset % patternLength;
+    } else {
+        for (int i = 0; i < penPattern.size(); ++i)
+            pattern[i] = qMax<qreal>(1.0, penPattern.at(i));
+    }
+
+    int dashIndex = 0;
+    bool inDash = !reversed;
+    int currPattern = int(pattern[dashIndex]);
+
+    // adjust pattern for offset
+    offset_pattern(*patternOffset, &inDash, &dashIndex, &currPattern, pattern);
+
+    const int NSPANS = 256;
+    QT_FT_Span spans[NSPANS];
+    int current = 0;
+    bool ordered = true;
+
+    if (dy == 0) {
+        // specialcase horizontal lines
+        if (y1 >= devRect.y1 && y1 < devRect.y2) {
+            int start_unclipped = qMin(x1, x2);
+            int start = qMax(devRect.x1, start_unclipped);
+            int stop = qMax(x1, x2) + 1;
+            int stop_clipped = qMin(devRect.x2, stop);
+            int len = stop_clipped - start;
+            if (style == LineDrawNormal && stop == stop_clipped)
+                len--;
+
+            // adjust pattern for starting offset
+            offset_pattern(start - start_unclipped, &inDash, &dashIndex, &currPattern, pattern);
+
+            if (len > 0) {
+                int x = start;
+                while (x < stop_clipped) {
+                    if (current == NSPANS) {
+                        span_func(NSPANS, spans, data);
+                        current = 0;
+                    }
+                    const int dash = qMin(currPattern, stop_clipped - x);
+                    if (inDash) {
+                        spans[current].x = ushort(x);
+                        spans[current].len = ushort(dash);
+                        spans[current].y = y1;
+                        spans[current].coverage = 255;
+                        ++current;
+                    }
+                    if (dash < currPattern) {
+                        currPattern -= dash;
+                    } else {
+                        dashIndex = (dashIndex + 1) % pattern.size();
+                        currPattern = int(pattern[dashIndex]);
+                        inDash = !inDash;
+                    }
+                    x += dash;
+                }
+            }
+        }
+        goto flush_and_return;
+    } else if (dx == 0) {
+        if (x1 >= devRect.x1 && x1 < devRect.x2) {
+            int start_unclipped = qMin(y1, y2);
+            int start = qMax(devRect.y1, start_unclipped);
+            int stop = qMax(y1, y2) + 1;
+            int stop_clipped = qMin(devRect.y2, stop);
+            if (style == LineDrawNormal && stop == stop_clipped)
+                --stop;
+            else
+                stop = stop_clipped;
+
+            // adjust pattern for starting offset
+            offset_pattern(start - start_unclipped, &inDash, &dashIndex, &currPattern, pattern);
+
+            // loop over dashes
+            int y = start;
+            while (y < stop) {
+                const int dash = qMin(currPattern, stop - y);
+                if (inDash) {
+                    for (int i = 0; i < dash; ++i) {
+                        if (current == NSPANS) {
+                            span_func(NSPANS, spans, data);
+                            current = 0;
+                        }
+                        spans[current].x = x1;
+                        spans[current].len = 1;
+                        spans[current].coverage = 255;
+                        spans[current].y = ushort(y + i);
+                        ++current;
+                    }
+                }
+                if (dash < currPattern) {
+                    currPattern -= dash;
+                } else {
+                    dashIndex = (dashIndex + 1) % pattern.size();
+                    currPattern = int(pattern[dashIndex]);
+                    inDash = !inDash;
+                }
+                y += dash;
+            }
+        }
+        goto flush_and_return;
+    }
+
+    if (qAbs(dx) >= qAbs(dy)) {       /* if x is the major axis: */
+
+        if (x2 < x1) {  /* if coordinates are out of order */
+            qt_swap_int(x1, x2);
+            dx = -dx;
+
+            qt_swap_int(y1, y2);
+            dy = -dy;
+        }
+
+        if (style == LineDrawNormal)
+            --x2;
+
+        // In the loops below we increment before call the span function so
+        // we need to stop one pixel before
+        x2 = qMin(x2, devRect.x2 - 1);
+
+        // completely clipped, so abort
+        if (x2 <= x1)
+            goto flush_and_return;
+
+        int x = x1;
+        int y = y1;
+
+        if (x >= devRect.x1 && y >= devRect.y1 && y < devRect.y2) {
+            Q_ASSERT(x < devRect.x2);
+            if (inDash) {
+                if (current == NSPANS) {
+                    span_func(NSPANS, spans, data);
+                    current = 0;
+                }
+                spans[current].len = 1;
+                spans[current].coverage = 255;
+                spans[current].x = x;
+                spans[current].y = y;
+                ++current;
+            }
+            if (--currPattern <= 0) {
+                inDash = !inDash;
+                dashIndex = (dashIndex + 1) % pattern.size();
+                currPattern = int(pattern[dashIndex]);
+            }
+        }
+
+        if (y2 > y1) { // 315 -> 360 and 135 -> 180 (unit circle degrees)
+            y2 = qMin(y2, devRect.y2 - 1);
+
+            incrE = dy * 2;
+            d = incrE - dx;
+            incrNE = (dy - dx) * 2;
+
+            if (y > y2)
+                goto flush_and_return;
+
+            while (x < x2) {
+                if (d > 0) {
+                    ++y;
+                    d += incrNE;
+                    if (y > y2)
+                        goto flush_and_return;
+                } else {
+                    d += incrE;
+                }
+                ++x;
+
+                const bool skip = x < devRect.x1 || y < devRect.y1;
+                Q_ASSERT(skip || (x < devRect.x2 && y < devRect.y2));
+                if (inDash && !skip) {
+                    if (current == NSPANS) {
+                        span_func(NSPANS, spans, data);
+                        current = 0;
+                    }
+                    spans[current].len = 1;
+                    spans[current].coverage = 255;
+                    spans[current].x = x;
+                    spans[current].y = y;
+                    ++current;
+                }
+                if (--currPattern <= 0) {
+                    inDash = !inDash;
+                    dashIndex = (dashIndex + 1) % pattern.size();
+                    currPattern = int(pattern[dashIndex]);
+                }
+            }
+        } else {  // 0-45 and 180->225 (unit circle degrees)
+            y1 = qMin(y1, devRect.y2 - 1);
+
+            incrE = dy * 2;
+            d = incrE + dx;
+            incrNE = (dy + dx) * 2;
+
+            if (y < devRect.y1)
+                goto flush_and_return;
+
+            while (x < x2) {
+                if (d < 0) {
+                    if (current > 0) {
+                        span_func(current, spans, data);
+                        current = 0;
+                    }
+
+                    --y;
+                    d += incrNE;
+                    if (y < devRect.y1)
+                        goto flush_and_return;
+                } else {
+                    d += incrE;
+                }
+                ++x;
+
+                const bool skip = x < devRect.x1 || y > y1;
+                Q_ASSERT(skip || (x < devRect.x2 && y < devRect.y2));
+                if (inDash && !skip) {
+                    if (current == NSPANS) {
+                        span_func(NSPANS, spans, data);
+                        current = 0;
+                    }
+                    spans[current].len = 1;
+                    spans[current].coverage = 255;
+                    spans[current].x = x;
+                    spans[current].y = y;
+                    ++current;
+                }
+                if (--currPattern <= 0) {
+                    inDash = !inDash;
+                    dashIndex = (dashIndex + 1) % pattern.size();
+                    currPattern = int(pattern[dashIndex]);
+                }
+            }
+        }
+    } else {
+
+        // if y is the major axis:
+
+        if (y2 < y1) {      /* if coordinates are out of order */
+            qt_swap_int(y1, y2);
+            dy = -dy;
+
+            qt_swap_int(x1, x2);
+            dx = -dx;
+        }
+
+        if (style == LineDrawNormal)
+            --y2;
+
+        // In the loops below we increment before call the span function so
+        // we need to stop one pixel before
+        y2 = qMin(y2, devRect.y2 - 1);
+
+        // completely clipped, so abort
+        if (y2 <= y1)
+            goto flush_and_return;
+
+        x = x1;
+        y = y1;
+
+        if (x>=devRect.x1 && y>=devRect.y1 && x < devRect.x2) {
+            Q_ASSERT(x < devRect.x2);
+            if (inDash) {
+                if (current == NSPANS) {
+                    span_func(NSPANS, spans, data);
+                    current = 0;
+                }
+                spans[current].len = 1;
+                spans[current].coverage = 255;
+                spans[current].x = x;
+                spans[current].y = y;
+                ++current;
+            }
+            if (--currPattern <= 0) {
+                inDash = !inDash;
+                dashIndex = (dashIndex + 1) % pattern.size();
+                currPattern = int(pattern[dashIndex]);
+            }
+        }
+
+        if (x2 > x1) { // 90 -> 135 and 270 -> 315 (unit circle degrees)
+            x2 = qMin(x2, devRect.x2 - 1);
+            incrE = dx * 2;
+            d = incrE - dy;
+            incrNE = (dx - dy) * 2;
+
+            if (x > x2)
+                goto flush_and_return;
+
+            while (y < y2) {
+                if (d > 0) {
+                    ++x;
+                    d += incrNE;
+                    if (x > x2)
+                        goto flush_and_return;
+                } else {
+                    d += incrE;
+                }
+                ++y;
+                const bool skip = x < devRect.x1 || y < devRect.y1;
+                Q_ASSERT(skip || (x < devRect.x2 && y < devRect.y2));
+                if (inDash && !skip) {
+                    if (current == NSPANS) {
+                        span_func(NSPANS, spans, data);
+                        current = 0;
+                    }
+                    spans[current].len = 1;
+                    spans[current].coverage = 255;
+                    spans[current].x = x;
+                    spans[current].y = y;
+                    ++current;
+                }
+                if (--currPattern <= 0) {
+                    inDash = !inDash;
+                    dashIndex = (dashIndex + 1) % pattern.size();
+                    currPattern = int(pattern[dashIndex]);
+                }
+            }
+        } else { // 45 -> 90 and 225 -> 270 (unit circle degrees)
+            x1 = qMin(x1, devRect.x2 - 1);
+            incrE = dx * 2;
+            d = incrE + dy;
+            incrNE = (dx + dy) * 2;
+
+            if (x < devRect.x1)
+                goto flush_and_return;
+
+            while (y < y2) {
+                if (d < 0) {
+                    --x;
+                    d += incrNE;
+                    if (x < devRect.x1)
+                        goto flush_and_return;
+                } else {
+                    d += incrE;
+                }
+                ++y;
+                const bool skip = y < devRect.y1 || x > x1;
+                Q_ASSERT(skip || (x >= devRect.x1 && x < devRect.x2 && y < devRect.y2));
+                if (inDash && !skip) {
+                    if (current == NSPANS) {
+                        span_func(NSPANS, spans, data);
+                        current = 0;
+                    }
+                    spans[current].len = 1;
+                    spans[current].coverage = 255;
+                    spans[current].x = x;
+                    spans[current].y = y;
+                    ++current;
+                }
+                if (--currPattern <= 0) {
+                    inDash = !inDash;
+                    dashIndex = (dashIndex + 1) % pattern.size();
+                    currPattern = int(pattern[dashIndex]);
+                }
+            }
+        }
+    }
+flush_and_return:
+    if (current > 0)
+        span_func(current, ordered ? spans : spans + (NSPANS - current), data);
+
+    // adjust offset
+    if (reversed) {
+        *patternOffset = (patternLength - 1 - *patternOffset);
+    } else {
+        *patternOffset = 0;
+        for (int i = 0; i <= dashIndex; ++i)
+            *patternOffset += int(pattern[i]);
+        *patternOffset += patternLength - currPattern - 1;
+        *patternOffset = (*patternOffset % patternLength);
+    }
+}
+
+/*!
+    \internal
+    \a x and \a y is relative to the midpoint of \a rect.
+*/
+static inline void drawEllipsePoints(int x, int y, int length,
+                                     const QRect &rect,
+                                     const QRect &clip,
+                                     ProcessSpans pen_func, ProcessSpans brush_func,
+                                     QSpanData *pen_data, QSpanData *brush_data)
+{
+    if (length == 0)
+        return;
+
+    QT_FT_Span outline[4];
+    const int midx = rect.x() + (rect.width() + 1) / 2;
+    const int midy = rect.y() + (rect.height() + 1) / 2;
+
+    x = x + midx;
+    y = midy - y;
+
+    // topleft
+    outline[0].x = midx + (midx - x) - (length - 1) - (rect.width() & 0x1);
+    outline[0].len = qMin(length, x - outline[0].x);
+    outline[0].y = y;
+    outline[0].coverage = 255;
+
+    // topright
+    outline[1].x = x;
+    outline[1].len = length;
+    outline[1].y = y;
+    outline[1].coverage = 255;
+
+    // bottomleft
+    outline[2].x = outline[0].x;
+    outline[2].len = outline[0].len;
+    outline[2].y = midy + (midy - y) - (rect.height() & 0x1);
+    outline[2].coverage = 255;
+
+    // bottomright
+    outline[3].x = x;
+    outline[3].len = length;
+    outline[3].y = outline[2].y;
+    outline[3].coverage = 255;
+
+    if (brush_func && outline[0].x + outline[0].len < outline[1].x) {
+        QT_FT_Span fill[2];
+
+        // top fill
+        fill[0].x = outline[0].x + outline[0].len - 1;
+        fill[0].len = qMax(0, outline[1].x - fill[0].x);
+        fill[0].y = outline[1].y;
+        fill[0].coverage = 255;
+
+        // bottom fill
+        fill[1].x = outline[2].x + outline[2].len - 1;
+        fill[1].len = qMax(0, outline[3].x - fill[1].x);
+        fill[1].y = outline[3].y;
+        fill[1].coverage = 255;
+
+        int n = (fill[0].y >= fill[1].y ? 1 : 2);
+        n = qt_intersect_spans(fill, n, clip);
+        if (n > 0)
+            brush_func(n, fill, brush_data);
+    }
+    if (pen_func) {
+        int n = (outline[1].y >= outline[2].y ? 2 : 4);
+        n = qt_intersect_spans(outline, n, clip);
+        if (n > 0)
+            pen_func(n, outline, pen_data);
+    }
+}
+
+/*!
+    \internal
+    Draws an ellipse using the integer point midpoint algorithm.
+*/
+static void drawEllipse_midpoint_i(const QRect &rect, const QRect &clip,
+                                   ProcessSpans pen_func, ProcessSpans brush_func,
+                                   QSpanData *pen_data, QSpanData *brush_data)
+{
+    const qreal a = qreal(rect.width()) / 2;
+    const qreal b = qreal(rect.height()) / 2;
+    qreal d = b*b - (a*a*b) + 0.25*a*a;
+
+    int x = 0;
+    int y = (rect.height() + 1) / 2;
+    int startx = x;
+
+    // region 1
+    while (a*a*(2*y - 1) > 2*b*b*(x + 1)) {
+        if (d < 0) { // select E
+            d += b*b*(2*x + 3);
+            ++x;
+        } else {     // select SE
+            d += b*b*(2*x + 3) + a*a*(-2*y + 2);
+            drawEllipsePoints(startx, y, x - startx + 1, rect, clip,
+                              pen_func, brush_func, pen_data, brush_data);
+            startx = ++x;
+            --y;
+        }
+    }
+    drawEllipsePoints(startx, y, x - startx + 1, rect, clip,
+                      pen_func, brush_func, pen_data, brush_data);
+
+    // region 2
+    d = b*b*(x + 0.5)*(x + 0.5) + a*a*((y - 1)*(y - 1) - b*b);
+    const int miny = rect.height() & 0x1;
+    while (y > miny) {
+        if (d < 0) { // select SE
+            d += b*b*(2*x + 2) + a*a*(-2*y + 3);
+            ++x;
+        } else {     // select S
+            d += a*a*(-2*y + 3);
+        }
+        --y;
+        drawEllipsePoints(x, y, 1, rect, clip,
+                          pen_func, brush_func, pen_data, brush_data);
+    }
+}
+
+/*!
+    \fn void QRasterPaintEngine::drawPoints(const QPoint *points, int pointCount)
+    \overload
+
+    Draws the first \a pointCount points in the buffer \a points
+
+    The default implementation converts the first \a pointCount QPoints in \a points
+    to QPointFs and calls the floating point version of drawPoints.
+*/
+
+/*!
+    \fn void QRasterPaintEngine::drawEllipse(const QRect &rect)
+    \overload
+
+    Reimplement this function to draw the largest ellipse that can be
+    contained within rectangle \a rect.
+*/
+
+#ifdef QT_DEBUG_DRAW
+void dumpClip(int width, int height, const QClipData *clip)
+{
+    QImage clipImg(width, height, QImage::Format_ARGB32_Premultiplied);
+    clipImg.fill(0xffff0000);
+
+    int x0 = width;
+    int x1 = 0;
+    int y0 = height;
+    int y1 = 0;
+
+    ((QClipData *) clip)->spans(); // Force allocation of the spans structure...
+
+    for (int i = 0; i < clip->count; ++i) {
+        const QSpan *span = ((QClipData *) clip)->spans() + i;
+        for (int j = 0; j < span->len; ++j)
+            clipImg.setPixel(span->x + j, span->y, 0xffffff00);
+        x0 = qMin(x0, int(span->x));
+        x1 = qMax(x1, int(span->x + span->len - 1));
+
+        y0 = qMin(y0, int(span->y));
+        y1 = qMax(y1, int(span->y));
+    }
+
+    static int counter = 0;
+
+    Q_ASSERT(y0 >= 0);
+    Q_ASSERT(x0 >= 0);
+    Q_ASSERT(y1 >= 0);
+    Q_ASSERT(x1 >= 0);
+
+    fprintf(stderr,"clip %d: %d %d - %d %d\n", counter, x0, y0, x1, y1);
+    clipImg.save(QString::fromLatin1("clip-%0.png").arg(counter++));
+}
+#endif
+
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qpaintengine_raster_p.h b/src/gui/painting/qpaintengine_raster_p.h
new file mode 100644
index 0000000000..52f51fab16
--- /dev/null
+++ b/src/gui/painting/qpaintengine_raster_p.h
@@ -0,0 +1,567 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPAINTENGINE_RASTER_P_H
+#define QPAINTENGINE_RASTER_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of other Qt classes.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "private/qpaintengineex_p.h"
+#include "QtGui/qpainterpath.h"
+#include "private/qdatabuffer_p.h"
+#include "private/qdrawhelper_p.h"
+#include "private/qpaintengine_p.h"
+#include "private/qrasterizer_p.h"
+#include "private/qstroker_p.h"
+#include "private/qpainter_p.h"
+#include "private/qtextureglyphcache_p.h"
+#include "private/qoutlinemapper_p.h"
+
+#include <stdlib.h>
+
+QT_BEGIN_NAMESPACE
+
+class QOutlineMapper;
+class QRasterPaintEnginePrivate;
+class QRasterBuffer;
+class QClipData;
+class QCustomRasterPaintDevice;
+
+class QRasterPaintEngineState : public QPainterState
+{
+public:
+    QRasterPaintEngineState(QRasterPaintEngineState &other);
+    QRasterPaintEngineState();
+    ~QRasterPaintEngineState();
+
+
+    QPen lastPen;
+    QSpanData penData;
+    QStrokerOps *stroker;
+    uint strokeFlags;
+
+    QBrush lastBrush;
+    QSpanData brushData;
+    uint fillFlags;
+
+    uint pixmapFlags;
+    int intOpacity;
+
+    qreal txscale;
+
+    QClipData *clip;
+//     QRect clipRect;
+//     QRegion clipRegion;
+
+//     QPainter::RenderHints hints;
+//     QPainter::CompositionMode compositionMode;
+
+    uint dirty;
+
+    struct Flags {
+        uint has_clip_ownership : 1;        // should delete the clip member..
+        uint fast_pen : 1;                  // cosmetic 1-width pens, using midpoint drawlines
+        uint non_complex_pen : 1;           // can use rasterizer, rather than stroker
+        uint antialiased : 1;
+        uint bilinear : 1;
+        uint fast_text : 1;
+        uint int_xform : 1;
+        uint tx_noshear : 1;
+        uint fast_images : 1;
+    };
+
+    union {
+        Flags flags;
+        uint flag_bits;
+    };
+};
+
+
+
+
+/*******************************************************************************
+ * QRasterPaintEngine
+ */
+class
+#ifdef Q_WS_QWS
+Q_GUI_EXPORT
+#endif
+QRasterPaintEngine : public QPaintEngineEx
+{
+    Q_DECLARE_PRIVATE(QRasterPaintEngine)
+public:
+
+    QRasterPaintEngine(QPaintDevice *device);
+    ~QRasterPaintEngine();
+    bool begin(QPaintDevice *device);
+    bool end();
+
+    void penChanged();
+    void brushChanged();
+    void brushOriginChanged();
+    void opacityChanged();
+    void compositionModeChanged();
+    void renderHintsChanged();
+    void transformChanged();
+    void clipEnabledChanged();
+
+    void setState(QPainterState *s);
+    QPainterState *createState(QPainterState *orig) const;
+    inline QRasterPaintEngineState *state() {
+        return static_cast<QRasterPaintEngineState *>(QPaintEngineEx::state());
+    }
+    inline const QRasterPaintEngineState *state() const {
+        return static_cast<const QRasterPaintEngineState *>(QPaintEngineEx::state());
+    }
+
+    void updateBrush(const QBrush &brush);
+    void updatePen(const QPen &pen);
+
+    void updateMatrix(const QTransform &matrix);
+
+    void drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode);
+    void drawPolygon(const QPoint *points, int pointCount, PolygonDrawMode mode);
+    void fillPath(const QPainterPath &path, QSpanData *fillData);
+    void fillPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode);
+
+    void drawEllipse(const QRectF &rect);
+
+    void fillRect(const QRectF &rect, const QBrush &brush);
+    void fillRect(const QRectF &rect, const QColor &color);
+
+    void drawRects(const QRect  *rects, int rectCount);
+    void drawRects(const QRectF *rects, int rectCount);
+
+    void drawPixmap(const QPointF &p, const QPixmap &pm);
+    void drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr);
+    void drawImage(const QPointF &p, const QImage &img);
+    void drawImage(const QRectF &r, const QImage &pm, const QRectF &sr,
+                   Qt::ImageConversionFlags falgs = Qt::AutoColor);
+    void drawTiledPixmap(const QRectF &r, const QPixmap &pm, const QPointF &sr);
+    void drawTextItem(const QPointF &p, const QTextItem &textItem);
+
+    void drawLines(const QLine *line, int lineCount);
+    void drawLines(const QLineF *line, int lineCount);
+
+    void drawPoints(const QPointF *points, int pointCount);
+    void drawPoints(const QPoint *points, int pointCount);
+
+    void stroke(const QVectorPath &path, const QPen &pen);
+    void fill(const QVectorPath &path, const QBrush &brush);
+
+    void strokePolygonCosmetic(const QPoint *pts, int pointCount, PolygonDrawMode mode);
+    void strokePolygonCosmetic(const QPointF *pt, int pointCount, PolygonDrawMode mode);
+
+    void clip(const QVectorPath &path, Qt::ClipOperation op);
+    void clip(const QRect &rect, Qt::ClipOperation op);
+    void clip(const QRegion &region, Qt::ClipOperation op);
+
+    void drawStaticTextItem(QStaticTextItem *textItem);
+
+    enum ClipType {
+        RectClip,
+        ComplexClip
+    };
+    ClipType clipType() const;
+    QRect clipBoundingRect() const;
+
+#ifdef Q_NO_USING_KEYWORD
+    inline void drawEllipse(const QRect &rect) { QPaintEngineEx::drawEllipse(rect); }
+#else
+    using QPaintEngineEx::drawPolygon;
+    using QPaintEngineEx::drawEllipse;
+#endif
+
+    void releaseBuffer();
+
+    QSize size() const;
+
+#ifndef QT_NO_DEBUG
+    void saveBuffer(const QString &s) const;
+#endif
+
+#ifdef Q_WS_MAC
+    void setCGContext(CGContextRef ref);
+    CGContextRef getCGContext() const;
+#endif
+
+#ifdef Q_WS_WIN
+    void setDC(HDC hdc);
+    HDC getDC() const;
+    void releaseDC(HDC hdc) const;
+#endif
+
+    void alphaPenBlt(const void* src, int bpl, int depth, int rx,int ry,int w,int h);
+
+    Type type() const { return Raster; }
+
+    QPoint coordinateOffset() const;
+
+#if defined(Q_WS_QWS) && !defined(QT_NO_RASTERCALLBACKS)
+    virtual void drawColorSpans(const QSpan *spans, int count, uint color);
+    virtual void drawBufferSpan(const uint *buffer, int bufsize,
+                                int x, int y, int length, uint const_alpha);
+#endif
+
+protected:
+    QRasterPaintEngine(QRasterPaintEnginePrivate &d, QPaintDevice *);
+private:
+    friend struct QSpanData;
+    friend class QBlitterPaintEngine;
+    friend class QBlitterPaintEnginePrivate;
+    void init();
+
+    void fillRect(const QRectF &rect, QSpanData *data);
+    void drawBitmap(const QPointF &pos, const QImage &image, QSpanData *fill);
+
+    bool drawCachedGlyphs(int numGlyphs, const glyph_t *glyphs, const QFixedPoint *positions,
+                          QFontEngine *fontEngine);
+
+#if defined(Q_OS_SYMBIAN) && defined(QT_NO_FREETYPE)
+    void drawGlyphsS60(const QPointF &p, const QTextItemInt &ti);
+#endif // Q_OS_SYMBIAN && QT_NO_FREETYPE
+
+    bool setClipRectInDeviceCoords(const QRect &r, Qt::ClipOperation op);
+
+    inline void ensureBrush(const QBrush &brush) {
+        if (!qbrush_fast_equals(state()->lastBrush, brush) || (brush.style() != Qt::NoBrush && state()->fillFlags))
+            updateBrush(brush);
+    }
+    inline void ensureBrush() { ensureBrush(state()->brush); }
+
+    inline void ensurePen(const QPen &pen) {
+        if (!qpen_fast_equals(state()->lastPen, pen) || (pen.style() != Qt::NoPen && state()->strokeFlags))
+            updatePen(pen);
+    }
+    inline void ensurePen() { ensurePen(state()->pen); }
+
+    void updateOutlineMapper();
+    inline void ensureOutlineMapper();
+
+    void updateState();
+    inline void ensureState() {
+        if (state()->dirty)
+            updateState();
+    }
+};
+
+
+/*******************************************************************************
+ * QRasterPaintEnginePrivate
+ */
+class
+#ifdef Q_WS_QWS
+Q_GUI_EXPORT
+#endif
+QRasterPaintEnginePrivate : public QPaintEngineExPrivate
+{
+    Q_DECLARE_PUBLIC(QRasterPaintEngine)
+public:
+    QRasterPaintEnginePrivate();
+
+    void rasterizeLine_dashed(QLineF line, qreal width,
+                              int *dashIndex, qreal *dashOffset, bool *inDash);
+    void rasterize(QT_FT_Outline *outline, ProcessSpans callback, QSpanData *spanData, QRasterBuffer *rasterBuffer);
+    void rasterize(QT_FT_Outline *outline, ProcessSpans callback, void *userData, QRasterBuffer *rasterBuffer);
+    void updateMatrixData(QSpanData *spanData, const QBrush &brush, const QTransform &brushMatrix);
+
+    void systemStateChanged();
+
+    void drawImage(const QPointF &pt, const QImage &img, SrcOverBlendFunc func,
+                   const QRect &clip, int alpha, const QRect &sr = QRect());
+
+    QTransform brushMatrix() const {
+        Q_Q(const QRasterPaintEngine);
+        const QRasterPaintEngineState *s = q->state();
+        QTransform m(s->matrix);
+        m.translate(s->brushOrigin.x(), s->brushOrigin.y());
+        return m;
+    }
+
+    bool isUnclipped_normalized(const QRect &rect) const;
+    bool isUnclipped(const QRect &rect, int penWidth) const;
+    bool isUnclipped(const QRectF &rect, int penWidth) const;
+    ProcessSpans getPenFunc(const QRect &rect, const QSpanData *data) const;
+    ProcessSpans getPenFunc(const QRectF &rect, const QSpanData *data) const;
+    ProcessSpans getBrushFunc(const QRect &rect, const QSpanData *data) const;
+    ProcessSpans getBrushFunc(const QRectF &rect, const QSpanData *data) const;
+
+#ifdef Q_WS_QWS
+    void prepare(QCustomRasterPaintDevice *);
+#endif
+
+    inline const QClipData *clip() const;
+
+    void initializeRasterizer(QSpanData *data);
+
+    void recalculateFastImages();
+    bool canUseFastImageBlending(QPainter::CompositionMode mode, const QImage &image) const;
+
+    QPaintDevice *device;
+    QScopedPointer<QOutlineMapper> outlineMapper;
+    QScopedPointer<QRasterBuffer>  rasterBuffer;
+
+#if defined (Q_WS_WIN)
+    HDC hdc;
+#elif defined(Q_WS_MAC)
+    CGContextRef cgContext;
+#endif
+
+    QRect deviceRect;
+
+    QStroker basicStroker;
+    QScopedPointer<QDashStroker> dashStroker;
+
+    QScopedPointer<QT_FT_Raster> grayRaster;
+
+    QDataBuffer<QLineF> cachedLines;
+    QSpanData image_filler;
+    QSpanData image_filler_xform;
+    QSpanData solid_color_filler;
+
+
+    QFontEngineGlyphCache::Type glyphCacheType;
+
+    QScopedPointer<QClipData> baseClip;
+
+    int deviceDepth;
+
+    uint mono_surface : 1;
+    uint outlinemapper_xform_dirty : 1;
+
+#ifdef Q_WS_WIN
+    uint isPlain45DegreeRotation : 1;
+#endif
+
+    QScopedPointer<QRasterizer> rasterizer;
+};
+
+
+class
+#ifdef Q_WS_QWS
+Q_GUI_EXPORT
+#endif
+QClipData {
+public:
+    QClipData(int height);
+    ~QClipData();
+
+    int clipSpanHeight;
+    struct ClipLine {
+        int count;
+        QSpan *spans;
+    } *m_clipLines;
+
+    void initialize();
+
+    inline ClipLine *clipLines() {
+        if (!m_clipLines)
+            initialize();
+        return m_clipLines;
+    }
+
+    inline QSpan *spans() {
+        if (!m_spans)
+            initialize();
+        return m_spans;
+    }
+
+    int allocated;
+    int count;
+    QSpan *m_spans;
+    int xmin, xmax, ymin, ymax;
+
+    QRect clipRect;
+    QRegion clipRegion;
+
+    uint enabled : 1;
+    uint hasRectClip : 1;
+    uint hasRegionClip : 1;
+
+    void appendSpan(int x, int length, int y, int coverage);
+    void appendSpans(const QSpan *s, int num);
+
+    // ### Should optimize and actually kill the QSpans if the rect is
+    // ### a subset of The current region. Thus the "fast" clipspan
+    // ### callback can be used
+    void setClipRect(const QRect &rect);
+    void setClipRegion(const QRegion &region);
+    void fixup();
+};
+
+inline void QClipData::appendSpan(int x, int length, int y, int coverage)
+{
+    Q_ASSERT(m_spans); // initialize() has to be called prior to adding spans..
+
+    if (count == allocated) {
+        allocated *= 2;
+        m_spans = (QSpan *)realloc(m_spans, allocated*sizeof(QSpan));
+    }
+    m_spans[count].x = x;
+    m_spans[count].len = length;
+    m_spans[count].y = y;
+    m_spans[count].coverage = coverage;
+    ++count;
+}
+
+inline void QClipData::appendSpans(const QSpan *s, int num)
+{
+    Q_ASSERT(m_spans);
+
+    if (count + num > allocated) {
+        do {
+            allocated *= 2;
+        } while (count + num > allocated);
+        m_spans = (QSpan *)realloc(m_spans, allocated*sizeof(QSpan));
+    }
+    memcpy(m_spans+count, s, num*sizeof(QSpan));
+    count += num;
+}
+
+#ifdef Q_WS_QWS
+class Q_GUI_EXPORT QCustomRasterPaintDevice : public QPaintDevice
+{
+public:
+    QCustomRasterPaintDevice(QWidget *w) : widget(w) {}
+
+    int devType() const { return QInternal::CustomRaster; }
+
+    virtual int metric(PaintDeviceMetric m) const;
+
+    virtual void* memory() const { return 0; }
+
+    virtual QImage::Format format() const {
+        return QImage::Format_ARGB32_Premultiplied;
+    }
+
+    virtual int bytesPerLine() const;
+
+    virtual QSize size() const {
+        return static_cast<QRasterPaintEngine*>(paintEngine())->size();
+    }
+
+private:
+    QWidget *widget;
+};
+#endif // Q_WS_QWS
+
+/*******************************************************************************
+ * QRasterBuffer
+ */
+class
+#ifdef Q_WS_QWS
+Q_GUI_EXPORT
+#endif
+QRasterBuffer
+{
+public:
+    QRasterBuffer() : m_width(0), m_height(0), m_buffer(0) { init(); }
+
+    ~QRasterBuffer();
+
+    void init();
+
+    QImage::Format prepare(QImage *image);
+    QImage::Format prepare(QPixmap *pix);
+#ifdef Q_WS_QWS
+    void prepare(QCustomRasterPaintDevice *device);
+#endif
+    void prepare(int w, int h);
+    void prepareBuffer(int w, int h);
+
+    void resetBuffer(int val=0);
+
+    uchar *scanLine(int y) { Q_ASSERT(y>=0); Q_ASSERT(y<m_height); return m_buffer + y * bytes_per_line; }
+
+#ifndef QT_NO_DEBUG
+    QImage bufferImage() const;
+#endif
+
+    void flushToARGBImage(QImage *image) const;
+
+    int width() const { return m_width; }
+    int height() const { return m_height; }
+    int bytesPerLine() const { return bytes_per_line; }
+    int bytesPerPixel() const { return bytes_per_pixel; }
+
+    uchar *buffer() const { return m_buffer; }
+
+    bool monoDestinationWithClut;
+    QRgb destColor0;
+    QRgb destColor1;
+
+    QPainter::CompositionMode compositionMode;
+    QImage::Format format;
+    DrawHelper *drawHelper;
+    QImage colorizeBitmap(const QImage &image, const QColor &color);
+
+private:
+    int m_width;
+    int m_height;
+    int bytes_per_line;
+    int bytes_per_pixel;
+    uchar *m_buffer;
+};
+
+inline void QRasterPaintEngine::ensureOutlineMapper() {
+    if (d_func()->outlinemapper_xform_dirty)
+        updateOutlineMapper();
+}
+
+inline const QClipData *QRasterPaintEnginePrivate::clip() const {
+    Q_Q(const QRasterPaintEngine);
+    if (q->state() && q->state()->clip && q->state()->clip->enabled)
+        return q->state()->clip;
+    return baseClip.data();
+}
+
+
+QT_END_NAMESPACE
+#endif // QPAINTENGINE_RASTER_P_H
diff --git a/src/gui/painting/qpaintengine_s60.cpp b/src/gui/painting/qpaintengine_s60.cpp
new file mode 100644
index 0000000000..ca303be03d
--- /dev/null
+++ b/src/gui/painting/qpaintengine_s60.cpp
@@ -0,0 +1,145 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include <private/qpaintengine_s60_p.h>
+#include <private/qpixmap_s60_p.h>
+#include <private/qt_s60_p.h>
+#include <private/qvolatileimage_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QS60PaintEnginePrivate : public QRasterPaintEnginePrivate
+{
+public:
+    QS60PaintEnginePrivate() {}
+};
+
+QS60PaintEngine::QS60PaintEngine(QPaintDevice *device, QS60PixmapData *data)
+    : QRasterPaintEngine(*(new QS60PaintEnginePrivate), device), pixmapData(data)
+{
+}
+
+bool QS60PaintEngine::begin(QPaintDevice *device)
+{
+    Q_D(QS60PaintEngine);
+
+    if (pixmapData->classId() == QPixmapData::RasterClass) {
+        pixmapData->beginDataAccess();
+        bool ret = QRasterPaintEngine::begin(device);
+        // Make sure QPaintEngine::paintDevice() returns the proper device.
+        // QRasterPaintEngine changes pdev to QImage in case of RasterClass QPixmapData
+        // which is incorrect in Symbian.
+        d->pdev = device;
+        return ret;
+    }
+
+    return QRasterPaintEngine::begin(device);
+}
+
+bool QS60PaintEngine::end()
+{
+    if (pixmapData->classId() == QPixmapData::RasterClass) {
+        bool ret = QRasterPaintEngine::end();
+        pixmapData->endDataAccess();
+        return ret;
+    }
+    return QRasterPaintEngine::end();
+}
+
+void QS60PaintEngine::drawPixmap(const QPointF &p, const QPixmap &pm)
+{
+    if (pm.pixmapData()->classId() == QPixmapData::RasterClass) {
+        QS60PixmapData *srcData = static_cast<QS60PixmapData *>(pm.pixmapData());
+        srcData->beginDataAccess();
+        QRasterPaintEngine::drawPixmap(p, pm);
+        srcData->endDataAccess();
+    } else {
+        void *nativeData = pm.pixmapData()->toNativeType(QPixmapData::VolatileImage);
+        if (nativeData) {
+            QVolatileImage *img = static_cast<QVolatileImage *>(nativeData);
+            img->beginDataAccess();
+            QRasterPaintEngine::drawImage(p, img->imageRef());
+            img->endDataAccess(true);
+        } else {
+            QRasterPaintEngine::drawPixmap(p, pm);
+        }
+    }
+}
+
+void QS60PaintEngine::drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr)
+{
+    if (pm.pixmapData()->classId() == QPixmapData::RasterClass) {
+        QS60PixmapData *srcData = static_cast<QS60PixmapData *>(pm.pixmapData());
+        srcData->beginDataAccess();
+        QRasterPaintEngine::drawPixmap(r, pm, sr);
+        srcData->endDataAccess();
+    } else {
+        void *nativeData = pm.pixmapData()->toNativeType(QPixmapData::VolatileImage);
+        if (nativeData) {
+            QVolatileImage *img = static_cast<QVolatileImage *>(nativeData);
+            img->beginDataAccess();
+            QRasterPaintEngine::drawImage(r, img->imageRef(), sr);
+            img->endDataAccess(true);
+        } else {
+            QRasterPaintEngine::drawPixmap(r, pm, sr);
+        }
+    }
+}
+
+void QS60PaintEngine::drawTiledPixmap(const QRectF &r, const QPixmap &pm, const QPointF &sr)
+{
+    if (pm.pixmapData()->classId() == QPixmapData::RasterClass) {
+        QS60PixmapData *srcData = static_cast<QS60PixmapData *>(pm.pixmapData());
+        srcData->beginDataAccess();
+        QRasterPaintEngine::drawTiledPixmap(r, pm, sr);
+        srcData->endDataAccess();
+    } else {
+        QRasterPaintEngine::drawTiledPixmap(r, pm, sr);
+    }
+}
+
+void QS60PaintEngine::prepare(QImage *image)
+{
+    QRasterBuffer *buffer = d_func()->rasterBuffer.data();
+    if (buffer)
+        buffer->prepare(image);
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qpaintengine_s60_p.h b/src/gui/painting/qpaintengine_s60_p.h
new file mode 100644
index 0000000000..a62bdac97c
--- /dev/null
+++ b/src/gui/painting/qpaintengine_s60_p.h
@@ -0,0 +1,84 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPAINTENGINE_S60_P_H
+#define QPAINTENGINE_S60_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of other Qt classes.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "private/qpaintengine_raster_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QS60PaintEnginePrivate;
+class QS60PixmapData;
+
+class QS60PaintEngine : public QRasterPaintEngine
+{
+    Q_DECLARE_PRIVATE(QS60PaintEngine)
+
+public:
+    QS60PaintEngine(QPaintDevice *device, QS60PixmapData* data);
+    bool begin(QPaintDevice *device);
+    bool end();
+
+    void drawPixmap(const QPointF &p, const QPixmap &pm);
+    void drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr);
+    void drawTiledPixmap(const QRectF &r, const QPixmap &pm, const QPointF &sr);
+
+    void prepare(QImage* image);
+
+private:
+    QS60PixmapData *pixmapData;
+};
+
+QT_END_NAMESPACE
+
+#endif // QPAINTENGINE_S60_P_H
diff --git a/src/gui/painting/qpaintengine_x11.cpp b/src/gui/painting/qpaintengine_x11.cpp
new file mode 100644
index 0000000000..94828fba53
--- /dev/null
+++ b/src/gui/painting/qpaintengine_x11.cpp
@@ -0,0 +1,2507 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qplatformdefs.h"
+
+#include "private/qpixmap_x11_p.h"
+
+#include "qapplication.h"
+#include "qdebug.h"
+#include "qfont.h"
+#include "qwidget.h"
+#include "qbitmap.h"
+#include "qpixmapcache.h"
+#include "qtextcodec.h"
+#include "qcoreevent.h"
+#include "qiodevice.h"
+#include <qmath.h>
+
+#include "qpainter_p.h"
+#include <qtextlayout.h>
+#include <qvarlengtharray.h>
+#include <private/qfont_p.h>
+#include <private/qtextengine_p.h>
+#include <private/qpaintengine_x11_p.h>
+#include <private/qfontengine_x11_p.h>
+#include <private/qwidget_p.h>
+#include <private/qpainterpath_p.h>
+
+#include "qpen.h"
+#include "qcolor.h"
+#include "qcolormap.h"
+
+#include <private/qpaintengine_p.h>
+#include "qpaintengine_x11_p.h"
+
+#include <private/qt_x11_p.h>
+#include <private/qnumeric_p.h>
+#include <limits.h>
+
+#ifndef QT_NO_XRENDER
+#include <private/qtessellator_p.h>
+#endif
+
+#include <private/qstylehelper_p.h>
+
+QT_BEGIN_NAMESPACE
+
+extern Drawable qt_x11Handle(const QPaintDevice *pd);
+extern const QX11Info *qt_x11Info(const QPaintDevice *pd);
+extern QPixmap qt_pixmapForBrush(int brushStyle, bool invert); //in qbrush.cpp
+extern QPixmap qt_toX11Pixmap(const QPixmap &pixmap);
+
+// use the same rounding as in qrasterizer.cpp (6 bit fixed point)
+static const qreal aliasedCoordinateDelta = 0.5 - 0.015625;
+
+#undef X11 // defined in qt_x11_p.h
+/*!
+    Returns the X11 specific pen GC for the painter \a p. Note that
+    QPainter::begin() must be called before this function returns a
+    valid GC.
+*/
+Q_GUI_EXPORT GC qt_x11_get_pen_gc(QPainter *p)
+{
+    if (p && p->paintEngine()
+        && p->paintEngine()->isActive()
+        && p->paintEngine()->type() == QPaintEngine::X11) {
+        return static_cast<QX11PaintEngine *>(p->paintEngine())->d_func()->gc;
+    }
+    return 0;
+}
+
+/*!
+    Returns the X11 specific brush GC for the painter \a p. Note that
+    QPainter::begin() must be called before this function returns a
+    valid GC.
+*/
+Q_GUI_EXPORT GC qt_x11_get_brush_gc(QPainter *p)
+{
+    if (p && p->paintEngine()
+        && p->paintEngine()->isActive()
+        && p->paintEngine()->type() == QPaintEngine::X11) {
+        return static_cast<QX11PaintEngine *>(p->paintEngine())->d_func()->gc_brush;
+    }
+    return 0;
+}
+#define X11 qt_x11Data
+
+#ifndef QT_NO_XRENDER
+static const int compositionModeToRenderOp[QPainter::CompositionMode_Xor + 1] = {
+    PictOpOver, //CompositionMode_SourceOver,
+    PictOpOverReverse, //CompositionMode_DestinationOver,
+    PictOpClear, //CompositionMode_Clear,
+    PictOpSrc, //CompositionMode_Source,
+    PictOpDst, //CompositionMode_Destination,
+    PictOpIn, //CompositionMode_SourceIn,
+    PictOpInReverse, //CompositionMode_DestinationIn,
+    PictOpOut, //CompositionMode_SourceOut,
+    PictOpOutReverse, //CompositionMode_DestinationOut,
+    PictOpAtop, //CompositionMode_SourceAtop,
+    PictOpAtopReverse, //CompositionMode_DestinationAtop,
+    PictOpXor //CompositionMode_Xor
+};
+
+static inline int qpainterOpToXrender(QPainter::CompositionMode mode)
+{
+    Q_ASSERT(mode <= QPainter::CompositionMode_Xor);
+    return compositionModeToRenderOp[mode];
+}
+#endif
+
+// hack, so we don't have to make QRegion::clipRectangles() public or include
+// X11 headers in qregion.h
+Q_GUI_EXPORT void *qt_getClipRects(const QRegion &r, int &num)
+{
+    return r.clipRectangles(num);
+}
+
+static inline void x11SetClipRegion(Display *dpy, GC gc, GC gc2,
+#ifndef QT_NO_XRENDER
+                                    Picture picture,
+#else
+                                    Qt::HANDLE picture,
+#endif
+                                    const QRegion &r)
+{
+    int num;
+    XRectangle *rects = (XRectangle *)qt_getClipRects(r, num);
+
+    if (gc)
+        XSetClipRectangles( dpy, gc, 0, 0, rects, num, YXBanded );
+    if (gc2)
+        XSetClipRectangles( dpy, gc2, 0, 0, rects, num, YXBanded );
+
+#ifndef QT_NO_XRENDER
+    if (picture)
+        XRenderSetPictureClipRectangles(dpy, picture, 0, 0, rects, num);
+#else
+    Q_UNUSED(picture);
+#endif // QT_NO_XRENDER
+}
+
+
+static inline void x11ClearClipRegion(Display *dpy, GC gc, GC gc2,
+#ifndef QT_NO_XRENDER
+                                    Picture picture
+#else
+                                    Qt::HANDLE picture
+#endif
+                                      )
+{
+    if (gc)
+        XSetClipMask(dpy, gc, XNone);
+    if (gc2)
+        XSetClipMask(dpy, gc2, XNone);
+
+#ifndef QT_NO_XRENDER
+    if (picture) {
+        XRenderPictureAttributes attrs;
+        attrs.clip_mask = XNone;
+        XRenderChangePicture (dpy, picture, CPClipMask, &attrs);
+    }
+#else
+    Q_UNUSED(picture);
+#endif // QT_NO_XRENDER
+}
+
+
+#define DITHER_SIZE 16
+static const uchar base_dither_matrix[DITHER_SIZE][DITHER_SIZE] = {
+  {   0,192, 48,240, 12,204, 60,252,  3,195, 51,243, 15,207, 63,255 },
+  { 128, 64,176,112,140, 76,188,124,131, 67,179,115,143, 79,191,127 },
+  {  32,224, 16,208, 44,236, 28,220, 35,227, 19,211, 47,239, 31,223 },
+  { 160, 96,144, 80,172,108,156, 92,163, 99,147, 83,175,111,159, 95 },
+  {   8,200, 56,248,  4,196, 52,244, 11,203, 59,251,  7,199, 55,247 },
+  { 136, 72,184,120,132, 68,180,116,139, 75,187,123,135, 71,183,119 },
+  {  40,232, 24,216, 36,228, 20,212, 43,235, 27,219, 39,231, 23,215 },
+  { 168,104,152, 88,164,100,148, 84,171,107,155, 91,167,103,151, 87 },
+  {   2,194, 50,242, 14,206, 62,254,  1,193, 49,241, 13,205, 61,253 },
+  { 130, 66,178,114,142, 78,190,126,129, 65,177,113,141, 77,189,125 },
+  {  34,226, 18,210, 46,238, 30,222, 33,225, 17,209, 45,237, 29,221 },
+  { 162, 98,146, 82,174,110,158, 94,161, 97,145, 81,173,109,157, 93 },
+  {  10,202, 58,250,  6,198, 54,246,  9,201, 57,249,  5,197, 53,245 },
+  { 138, 74,186,122,134, 70,182,118,137, 73,185,121,133, 69,181,117 },
+  {  42,234, 26,218, 38,230, 22,214, 41,233, 25,217, 37,229, 21,213 },
+  { 170,106,154, 90,166,102,150, 86,169,105,153, 89,165,101,149, 85 }
+};
+
+static QPixmap qt_patternForAlpha(uchar alpha, int screen)
+{
+    QPixmap pm;
+    QString key = QLatin1Literal("$qt-alpha-brush$")
+                  % HexString<uchar>(alpha)
+                  % HexString<int>(screen);
+
+    if (!QPixmapCache::find(key, pm)) {
+        // #### why not use a mono image here????
+        QImage pattern(DITHER_SIZE, DITHER_SIZE, QImage::Format_ARGB32);
+        pattern.fill(0xffffffff);
+        for (int y = 0; y < DITHER_SIZE; ++y) {
+            for (int x = 0; x < DITHER_SIZE; ++x) {
+                if (base_dither_matrix[x][y] <= alpha)
+                    pattern.setPixel(x, y, 0x00000000);
+            }
+        }
+        pm = QBitmap::fromImage(pattern);
+        pm.x11SetScreen(screen);
+        QPixmapCache::insert(key, pm);
+    }
+    return pm;
+}
+
+#if !defined(QT_NO_XRENDER)
+
+class QXRenderTessellator : public QTessellator
+{
+public:
+    QXRenderTessellator() : traps(0), allocated(0), size(0) {}
+    ~QXRenderTessellator() { free(traps); }
+    XTrapezoid *traps;
+    int allocated;
+    int size;
+    void addTrap(const Trapezoid &trap);
+    QRect tessellate(const QPointF *points, int nPoints, bool winding) {
+        size = 0;
+        setWinding(winding);
+        return QTessellator::tessellate(points, nPoints).toRect();
+    }
+    void done() {
+        if (allocated > 64) {
+            free(traps);
+            traps = 0;
+            allocated = 0;
+        }
+    }
+};
+
+void QXRenderTessellator::addTrap(const Trapezoid &trap)
+{
+    if (size == allocated) {
+        allocated = qMax(2*allocated, 64);
+        traps = q_check_ptr((XTrapezoid *)realloc(traps, allocated * sizeof(XTrapezoid)));
+    }
+    traps[size].top = Q27Dot5ToXFixed(trap.top);
+    traps[size].bottom = Q27Dot5ToXFixed(trap.bottom);
+    traps[size].left.p1.x = Q27Dot5ToXFixed(trap.topLeft->x);
+    traps[size].left.p1.y = Q27Dot5ToXFixed(trap.topLeft->y);
+    traps[size].left.p2.x = Q27Dot5ToXFixed(trap.bottomLeft->x);
+    traps[size].left.p2.y = Q27Dot5ToXFixed(trap.bottomLeft->y);
+    traps[size].right.p1.x = Q27Dot5ToXFixed(trap.topRight->x);
+    traps[size].right.p1.y = Q27Dot5ToXFixed(trap.topRight->y);
+    traps[size].right.p2.x = Q27Dot5ToXFixed(trap.bottomRight->x);
+    traps[size].right.p2.y = Q27Dot5ToXFixed(trap.bottomRight->y);
+    ++size;
+}
+
+#endif // !defined(QT_NO_XRENDER)
+
+
+#ifndef QT_NO_XRENDER
+static Picture getPatternFill(int screen, const QBrush &b)
+{
+    if (!X11->use_xrender)
+        return XNone;
+
+    XRenderColor color = X11->preMultiply(b.color());
+    XRenderColor bg_color;
+
+    bg_color = X11->preMultiply(QColor(0, 0, 0, 0));
+
+    for (int i = 0; i < X11->pattern_fill_count; ++i) {
+        if (X11->pattern_fills[i].screen == screen
+            && X11->pattern_fills[i].opaque == false
+            && X11->pattern_fills[i].style == b.style()
+            && X11->pattern_fills[i].color.alpha == color.alpha
+            && X11->pattern_fills[i].color.red == color.red
+            && X11->pattern_fills[i].color.green == color.green
+            && X11->pattern_fills[i].color.blue == color.blue
+            && X11->pattern_fills[i].bg_color.alpha == bg_color.alpha
+            && X11->pattern_fills[i].bg_color.red == bg_color.red
+            && X11->pattern_fills[i].bg_color.green == bg_color.green
+            && X11->pattern_fills[i].bg_color.blue == bg_color.blue)
+            return X11->pattern_fills[i].picture;
+    }
+    // none found, replace one
+    int i = qrand() % 16;
+
+    if (X11->pattern_fills[i].screen != screen && X11->pattern_fills[i].picture) {
+	XRenderFreePicture (X11->display, X11->pattern_fills[i].picture);
+	X11->pattern_fills[i].picture = 0;
+    }
+
+    if (!X11->pattern_fills[i].picture) {
+        Pixmap pixmap = XCreatePixmap (X11->display, RootWindow (X11->display, screen), 8, 8, 32);
+        XRenderPictureAttributes attrs;
+        attrs.repeat = True;
+        X11->pattern_fills[i].picture = XRenderCreatePicture (X11->display, pixmap,
+                                                              XRenderFindStandardFormat(X11->display, PictStandardARGB32),
+                                                              CPRepeat, &attrs);
+        XFreePixmap (X11->display, pixmap);
+    }
+
+    X11->pattern_fills[i].screen = screen;
+    X11->pattern_fills[i].color = color;
+    X11->pattern_fills[i].bg_color = bg_color;
+    X11->pattern_fills[i].opaque = false;
+    X11->pattern_fills[i].style = b.style();
+
+    XRenderFillRectangle(X11->display, PictOpSrc, X11->pattern_fills[i].picture, &bg_color, 0, 0, 8, 8);
+
+    QPixmap pattern(qt_pixmapForBrush(b.style(), true));
+    XRenderPictureAttributes attrs;
+    attrs.repeat = true;
+    XRenderChangePicture(X11->display, pattern.x11PictureHandle(), CPRepeat, &attrs);
+
+    Picture fill_fg = X11->getSolidFill(screen, b.color());
+    XRenderComposite(X11->display, PictOpOver, fill_fg, pattern.x11PictureHandle(),
+                     X11->pattern_fills[i].picture,
+                     0, 0, 0, 0, 0, 0, 8, 8);
+
+    return X11->pattern_fills[i].picture;
+}
+
+static void qt_render_bitmap(Display *dpy, int scrn, Picture src, Picture dst,
+                      int sx, int sy, int x, int y, int sw, int sh,
+                      const QPen &pen)
+{
+    Picture fill_fg = X11->getSolidFill(scrn, pen.color());
+    XRenderComposite(dpy, PictOpOver,
+                     fill_fg, src, dst, sx, sy, sx, sy, x, y, sw, sh);
+}
+#endif
+
+void QX11PaintEnginePrivate::init()
+{
+    dpy = 0;
+    scrn = 0;
+    hd = 0;
+    picture = 0;
+    xinfo = 0;
+#ifndef QT_NO_XRENDER
+    current_brush = 0;
+    composition_mode = PictOpOver;
+    tessellator = new QXRenderTessellator;
+#endif
+}
+
+void QX11PaintEnginePrivate::setupAdaptedOrigin(const QPoint &p)
+{
+    if (adapted_pen_origin)
+        XSetTSOrigin(dpy, gc, p.x(), p.y());
+    if (adapted_brush_origin)
+        XSetTSOrigin(dpy, gc_brush, p.x(), p.y());
+}
+
+void QX11PaintEnginePrivate::resetAdaptedOrigin()
+{
+    if (adapted_pen_origin)
+        XSetTSOrigin(dpy, gc, 0, 0);
+    if (adapted_brush_origin)
+        XSetTSOrigin(dpy, gc_brush, 0, 0);
+}
+
+void QX11PaintEnginePrivate::clipPolygon_dev(const QPolygonF &poly, QPolygonF *clipped_poly)
+{
+    int clipped_count = 0;
+    qt_float_point *clipped_points = 0;
+    polygonClipper.clipPolygon((qt_float_point *) poly.data(), poly.size(),
+                               &clipped_points, &clipped_count);
+    clipped_poly->resize(clipped_count);
+    for (int i=0; i<clipped_count; ++i)
+        (*clipped_poly)[i] = *((QPointF *)(&clipped_points[i]));
+}
+
+void QX11PaintEnginePrivate::systemStateChanged()
+{
+    Q_Q(QX11PaintEngine);
+    QPainter *painter = q->state ? static_cast<QPainterState *>(q->state)->painter : 0;
+    if (painter && painter->hasClipping()) {
+        if (q->testDirty(QPaintEngine::DirtyTransform))
+            q->updateMatrix(q->state->transform());
+        QPolygonF clip_poly_dev(matrix.map(painter->clipPath().toFillPolygon()));
+        QPolygonF clipped_poly_dev;
+        clipPolygon_dev(clip_poly_dev, &clipped_poly_dev);
+        q->updateClipRegion_dev(QRegion(clipped_poly_dev.toPolygon()), Qt::ReplaceClip);
+    } else {
+        q->updateClipRegion_dev(QRegion(), Qt::NoClip);
+    }
+}
+
+static QPaintEngine::PaintEngineFeatures qt_decide_features()
+{
+    QPaintEngine::PaintEngineFeatures features =
+        QPaintEngine::PrimitiveTransform
+        | QPaintEngine::PatternBrush
+        | QPaintEngine::AlphaBlend
+        | QPaintEngine::PainterPaths
+        | QPaintEngine::RasterOpModes;
+
+    if (X11->use_xrender) {
+        features |= QPaintEngine::Antialiasing;
+        features |= QPaintEngine::PorterDuff;
+        features |= QPaintEngine::MaskedBrush;
+#if 0
+        if (X11->xrender_version > 10) {
+            features |= QPaintEngine::LinearGradientFill;
+            // ###
+        }
+#endif
+    }
+
+    return features;
+}
+
+/*
+ * QX11PaintEngine members
+ */
+
+QX11PaintEngine::QX11PaintEngine()
+    : QPaintEngine(*(new QX11PaintEnginePrivate), qt_decide_features())
+{
+    d_func()->init();
+}
+
+QX11PaintEngine::QX11PaintEngine(QX11PaintEnginePrivate &dptr)
+    : QPaintEngine(dptr, qt_decide_features())
+{
+    d_func()->init();
+}
+
+QX11PaintEngine::~QX11PaintEngine()
+{
+#ifndef QT_NO_XRENDER
+    Q_D(QX11PaintEngine);
+    delete d->tessellator;
+#endif
+}
+
+bool QX11PaintEngine::begin(QPaintDevice *pdev)
+{
+    Q_D(QX11PaintEngine);
+    d->xinfo = qt_x11Info(pdev);
+    QWidget *w = d->pdev->devType() == QInternal::Widget ? static_cast<QWidget *>(d->pdev) : 0;
+    const bool isAlienWidget = w && !w->internalWinId() && w->testAttribute(Qt::WA_WState_Created);
+#ifndef QT_NO_XRENDER
+    if (w) {
+        if (isAlienWidget)
+            d->picture = (::Picture)w->nativeParentWidget()->x11PictureHandle();
+        else
+            d->picture = (::Picture)w->x11PictureHandle();
+    } else if (pdev->devType() == QInternal::Pixmap) {
+        const QPixmap *pm = static_cast<const QPixmap *>(pdev);
+        QX11PixmapData *data = static_cast<QX11PixmapData*>(pm->data.data());
+        if (X11->use_xrender && data->depth() != 32 && data->x11_mask)
+            data->convertToARGB32();
+        d->picture = (::Picture)static_cast<const QPixmap *>(pdev)->x11PictureHandle();
+    }
+#else
+    d->picture = 0;
+#endif
+    d->hd = !isAlienWidget ? qt_x11Handle(pdev) : qt_x11Handle(w->nativeParentWidget());
+
+    Q_ASSERT(d->xinfo != 0);
+    d->dpy = d->xinfo->display(); // get display variable
+    d->scrn = d->xinfo->screen(); // get screen variable
+
+    d->crgn = QRegion();
+    d->gc = XCreateGC(d->dpy, d->hd, 0, 0);
+    d->gc_brush = XCreateGC(d->dpy, d->hd, 0, 0);
+    d->has_alpha_brush = false;
+    d->has_alpha_pen = false;
+    d->has_clipping = false;
+    d->has_complex_xform = false;
+    d->has_scaling_xform = false;
+    d->has_non_scaling_xform = true;
+    d->xform_scale = 1;
+    d->has_custom_pen = false;
+    d->matrix = QTransform();
+    d->pdev_depth = d->pdev->depth();
+    d->render_hints = 0;
+    d->txop = QTransform::TxNone;
+    d->use_path_fallback = false;
+#if !defined(QT_NO_XRENDER)
+    d->composition_mode = PictOpOver;
+#endif
+    d->xlibMaxLinePoints = 32762; // a safe number used to avoid, call to XMaxRequestSize(d->dpy) - 3;
+    d->opacity = 1;
+
+    // Set up the polygon clipper. Note: This will only work in
+    // polyline mode as long as we have a buffer zone, since a
+    // polyline may be clipped into several non-connected polylines.
+    const int BUFFERZONE = 1000;
+    QRect devClipRect(-BUFFERZONE, -BUFFERZONE,
+                      pdev->width() + 2*BUFFERZONE, pdev->height() + 2*BUFFERZONE);
+    d->polygonClipper.setBoundingRect(devClipRect);
+
+    if (isAlienWidget) {
+        // Set system clip for alien widgets painting outside the paint event.
+        // This is not a problem with native windows since the windowing system
+        // will handle the clip.
+        QWidgetPrivate *wd = w->d_func();
+        QRegion widgetClip(wd->clipRect());
+        wd->clipToEffectiveMask(widgetClip);
+        wd->subtractOpaqueSiblings(widgetClip);
+        widgetClip.translate(w->mapTo(w->nativeParentWidget(), QPoint()));
+        setSystemClip(widgetClip);
+    }
+
+    QPixmap::x11SetDefaultScreen(d->xinfo->screen());
+
+    if (w && w->testAttribute(Qt::WA_PaintUnclipped)) {  // paint direct on device
+ 	updatePen(QPen(Qt::black));
+ 	updateBrush(QBrush(Qt::white), QPoint());
+        XSetSubwindowMode(d->dpy, d->gc, IncludeInferiors);
+        XSetSubwindowMode(d->dpy, d->gc_brush, IncludeInferiors);
+#ifndef QT_NO_XRENDER
+        XRenderPictureAttributes attrs;
+        attrs.subwindow_mode = IncludeInferiors;
+        XRenderChangePicture(d->dpy, d->picture, CPSubwindowMode, &attrs);
+#endif
+    }
+
+    setDirty(QPaintEngine::DirtyClipRegion);
+    setDirty(QPaintEngine::DirtyPen);
+    setDirty(QPaintEngine::DirtyBrush);
+    setDirty(QPaintEngine::DirtyBackground);
+
+    return true;
+}
+
+bool QX11PaintEngine::end()
+{
+    Q_D(QX11PaintEngine);
+
+#if !defined(QT_NO_XRENDER)
+    if (d->picture) {
+        // reset clipping/subwindow mode on our render picture
+	XRenderPictureAttributes attrs;
+	attrs.subwindow_mode = ClipByChildren;
+        attrs.clip_mask = XNone;
+	XRenderChangePicture(d->dpy, d->picture, CPClipMask|CPSubwindowMode, &attrs);
+    }
+#endif
+
+    if (d->gc_brush && d->pdev->painters < 2) {
+        XFreeGC(d->dpy, d->gc_brush);
+        d->gc_brush = 0;
+    }
+
+    if (d->gc && d->pdev->painters < 2) {
+        XFreeGC(d->dpy, d->gc);
+        d->gc = 0;
+    }
+
+    // Restore system clip for alien widgets painting outside the paint event.
+    if (d->pdev->devType() == QInternal::Widget && !static_cast<QWidget *>(d->pdev)->internalWinId())
+        setSystemClip(QRegion());
+
+    return true;
+}
+
+static bool clipLine(QLineF *line, const QRect &rect)
+{
+    qreal x1 = line->x1();
+    qreal x2 = line->x2();
+    qreal y1 = line->y1();
+    qreal y2 = line->y2();
+
+    qreal left = rect.x();
+    qreal right = rect.x() + rect.width() - 1;
+    qreal top = rect.y();
+    qreal bottom = rect.y() + rect.height() - 1;
+
+    enum { Left, Right, Top, Bottom };
+    // clip the lines, after cohen-sutherland, see e.g. http://www.nondot.org/~sabre/graphpro/line6.html
+    int p1 = ((x1 < left) << Left)
+             | ((x1 > right) << Right)
+             | ((y1 < top) << Top)
+             | ((y1 > bottom) << Bottom);
+    int p2 = ((x2 < left) << Left)
+             | ((x2 > right) << Right)
+             | ((y2 < top) << Top)
+             | ((y2 > bottom) << Bottom);
+
+    if (p1 & p2)
+        // completely outside
+        return false;
+
+    if (p1 | p2) {
+        qreal dx = x2 - x1;
+        qreal dy = y2 - y1;
+
+        // clip x coordinates
+        if (x1 < left) {
+            y1 += dy/dx * (left - x1);
+            x1 = left;
+        } else if (x1 > right) {
+            y1 -= dy/dx * (x1 - right);
+            x1 = right;
+        }
+        if (x2 < left) {
+            y2 += dy/dx * (left - x2);
+            x2 = left;
+        } else if (x2 > right) {
+            y2 -= dy/dx * (x2 - right);
+            x2 = right;
+        }
+        p1 = ((y1 < top) << Top)
+             | ((y1 > bottom) << Bottom);
+        p2 = ((y2 < top) << Top)
+             | ((y2 > bottom) << Bottom);
+        if (p1 & p2)
+            return false;
+        // clip y coordinates
+        if (y1 < top) {
+            x1 += dx/dy * (top - y1);
+            y1 = top;
+        } else if (y1 > bottom) {
+            x1 -= dx/dy * (y1 - bottom);
+            y1 = bottom;
+        }
+        if (y2 < top) {
+            x2 += dx/dy * (top - y2);
+            y2 = top;
+        } else if (y2 > bottom) {
+            x2 -= dx/dy * (y2 - bottom);
+            y2 = bottom;
+        }
+        *line = QLineF(QPointF(x1, y1), QPointF(x2, y2));
+    }
+    return true;
+}
+
+void QX11PaintEngine::drawLines(const QLine *lines, int lineCount)
+{
+    Q_ASSERT(lines);
+    Q_ASSERT(lineCount);
+    Q_D(QX11PaintEngine);
+    if (d->has_alpha_brush
+        || d->has_alpha_pen
+        || d->has_custom_pen
+        || (d->cpen.widthF() > 0 && d->has_complex_xform
+            && !d->has_non_scaling_xform)
+        || (d->render_hints & QPainter::Antialiasing)) {
+        for (int i = 0; i < lineCount; ++i) {
+            QPainterPath path(lines[i].p1());
+            path.lineTo(lines[i].p2());
+            drawPath(path);
+        }
+        return;
+    }
+
+    if (d->has_pen) {
+        for (int i = 0; i < lineCount; ++i) {
+            QLineF linef;
+            if (d->txop == QTransform::TxNone) {
+                linef = lines[i];
+            } else {
+                linef = d->matrix.map(QLineF(lines[i]));
+            }
+            if (clipLine(&linef, d->polygonClipper.boundingRect())) {
+                int x1 = qRound(linef.x1() + aliasedCoordinateDelta);
+                int y1 = qRound(linef.y1() + aliasedCoordinateDelta);
+                int x2 = qRound(linef.x2() + aliasedCoordinateDelta);
+                int y2 = qRound(linef.y2() + aliasedCoordinateDelta);
+
+                XDrawLine(d->dpy, d->hd, d->gc, x1, y1, x2, y2);
+            }
+        }
+    }
+}
+
+void QX11PaintEngine::drawLines(const QLineF *lines, int lineCount)
+{
+    Q_ASSERT(lines);
+    Q_ASSERT(lineCount);
+    Q_D(QX11PaintEngine);
+    if (d->has_alpha_brush
+        || d->has_alpha_pen
+        || d->has_custom_pen
+        || (d->cpen.widthF() > 0 && d->has_complex_xform
+            && !d->has_non_scaling_xform)
+        || (d->render_hints & QPainter::Antialiasing)) {
+        for (int i = 0; i < lineCount; ++i) {
+            QPainterPath path(lines[i].p1());
+            path.lineTo(lines[i].p2());
+            drawPath(path);
+        }
+        return;
+    }
+
+    if (d->has_pen) {
+        for (int i = 0; i < lineCount; ++i) {
+            QLineF linef = d->matrix.map(lines[i]);
+            if (clipLine(&linef, d->polygonClipper.boundingRect())) {
+                int x1 = qRound(linef.x1() + aliasedCoordinateDelta);
+                int y1 = qRound(linef.y1() + aliasedCoordinateDelta);
+                int x2 = qRound(linef.x2() + aliasedCoordinateDelta);
+                int y2 = qRound(linef.y2() + aliasedCoordinateDelta);
+
+                XDrawLine(d->dpy, d->hd, d->gc, x1, y1, x2, y2);
+            }
+        }
+    }
+}
+
+static inline QLine clipStraightLine(const QRect &clip, const QLine &l)
+{
+    if (l.p1().x() == l.p2().x()) {
+        int x = qBound(clip.left(), l.p1().x(), clip.right());
+        int y1 = qBound(clip.top(), l.p1().y(), clip.bottom());
+        int y2 = qBound(clip.top(), l.p2().y(), clip.bottom());
+
+        return QLine(x, y1, x, y2);
+    } else {
+        Q_ASSERT(l.p1().y() == l.p2().y());
+
+        int x1 = qBound(clip.left(), l.p1().x(), clip.right());
+        int x2 = qBound(clip.left(), l.p2().x(), clip.right());
+        int y = qBound(clip.top(), l.p1().y(), clip.bottom());
+
+        return QLine(x1, y, x2, y);
+    }
+}
+
+void QX11PaintEngine::drawRects(const QRectF *rects, int rectCount)
+{
+    Q_D(QX11PaintEngine);
+    Q_ASSERT(rects);
+    Q_ASSERT(rectCount);
+
+    if (rectCount != 1
+        || d->has_pen
+        || d->has_alpha_brush
+        || d->has_complex_xform
+        || d->has_custom_pen
+        || d->cbrush.style() != Qt::SolidPattern)
+    {
+        QPaintEngine::drawRects(rects, rectCount);
+        return;
+    }
+
+    QPoint alignedOffset;
+    if (d->txop == QTransform::TxTranslate) {
+        QPointF offset(d->matrix.dx(), d->matrix.dy());
+        alignedOffset = offset.toPoint();
+        if (offset != QPointF(alignedOffset)) {
+            QPaintEngine::drawRects(rects, rectCount);
+            return;
+        }
+    }
+
+    const QRectF& r = rects[0];
+    QRect alignedRect = r.toAlignedRect();
+    if (r != QRectF(alignedRect)) {
+        QPaintEngine::drawRects(rects, rectCount);
+        return;
+    }
+    alignedRect.translate(alignedOffset);
+
+    QRect clip(d->polygonClipper.boundingRect());
+    alignedRect = alignedRect.intersected(clip);
+    if (alignedRect.isEmpty())
+        return;
+
+    // simple-case:
+    //   the rectangle is pixel-aligned
+    //   the fill brush is just a solid non-alpha color
+    //   the painter transform is only integer translation
+    // ignore: antialiasing and just XFillRectangles directly
+    XRectangle xrect;
+    xrect.x = short(alignedRect.x());
+    xrect.y = short(alignedRect.y());
+    xrect.width = ushort(alignedRect.width());
+    xrect.height = ushort(alignedRect.height());
+    XFillRectangles(d->dpy, d->hd, d->gc_brush, &xrect, 1);
+}
+
+void QX11PaintEngine::drawRects(const QRect *rects, int rectCount)
+{
+    Q_D(QX11PaintEngine);
+    Q_ASSERT(rects);
+    Q_ASSERT(rectCount);
+
+    if (d->has_alpha_pen
+        || d->has_complex_xform
+        || d->has_custom_pen
+        || (d->render_hints & QPainter::Antialiasing))
+    {
+        for (int i = 0; i < rectCount; ++i) {
+            QPainterPath path;
+            path.addRect(rects[i]);
+            drawPath(path);
+        }
+        return;
+    }
+
+    QRect clip(d->polygonClipper.boundingRect());
+    QPoint offset(qRound(d->matrix.dx()), qRound(d->matrix.dy()));
+#if !defined(QT_NO_XRENDER)
+    ::Picture pict = d->picture;
+
+    if (X11->use_xrender && pict && d->has_brush && d->pdev_depth != 1
+        && (d->has_texture || d->has_alpha_brush))
+    {
+        XRenderColor xc;
+        if (!d->has_texture && !d->has_pattern)
+            xc = X11->preMultiply(d->cbrush.color());
+
+        for (int i = 0; i < rectCount; ++i) {
+            QRect r(rects[i]);
+            if (d->txop == QTransform::TxTranslate)
+                r.translate(offset);
+
+            if (r.width() == 0 || r.height() == 0) {
+                if (d->has_pen) {
+                    const QLine l = clipStraightLine(clip, QLine(r.left(), r.top(), r.left() + r.width(), r.top() + r.height()));
+                    XDrawLine(d->dpy, d->hd, d->gc, l.p1().x(), l.p1().y(), l.p2().x(), l.p2().y());
+                }
+                continue;
+            }
+
+            r = r.intersected(clip);
+            if (r.isEmpty())
+                continue;
+            if (d->has_texture || d->has_pattern) {
+                XRenderComposite(d->dpy, d->composition_mode, d->current_brush, 0, pict,
+                                 qRound(r.x() - d->bg_origin.x()), qRound(r.y() - d->bg_origin.y()),
+                                 0, 0, r.x(), r.y(), r.width(), r.height());
+            } else {
+                XRenderFillRectangle(d->dpy, d->composition_mode, pict, &xc, r.x(), r.y(), r.width(), r.height());
+            }
+            if (d->has_pen)
+                XDrawRectangle(d->dpy, d->hd, d->gc, r.x(), r.y(), r.width(), r.height());
+        }
+    } else
+#endif // !QT_NO_XRENDER
+    {
+        if (d->has_brush && d->has_pen) {
+            for (int i = 0; i < rectCount; ++i) {
+                QRect r(rects[i]);
+                if (d->txop == QTransform::TxTranslate)
+                    r.translate(offset);
+
+                if (r.width() == 0 || r.height() == 0) {
+                    const QLine l = clipStraightLine(clip, QLine(r.left(), r.top(), r.left() + r.width(), r.top() + r.height()));
+                    XDrawLine(d->dpy, d->hd, d->gc, l.p1().x(), l.p1().y(), l.p2().x(), l.p2().y());
+                    continue;
+                }
+
+                r = r.intersected(clip);
+                if (r.isEmpty())
+                    continue;
+                d->setupAdaptedOrigin(r.topLeft());
+                XFillRectangle(d->dpy, d->hd, d->gc_brush, r.x(), r.y(), r.width(), r.height());
+                XDrawRectangle(d->dpy, d->hd, d->gc, r.x(), r.y(), r.width(), r.height());
+            }
+            d->resetAdaptedOrigin();
+        } else {
+            QVarLengthArray<XRectangle> xrects(rectCount);
+            int numClipped = rectCount;
+            for (int i = 0; i < rectCount; ++i) {
+                QRect r(rects[i]);
+                if (d->txop == QTransform::TxTranslate)
+                    r.translate(offset);
+
+                if (r.width() == 0 || r.height() == 0) {
+                    --numClipped;
+                    if (d->has_pen) {
+                        const QLine l = clipStraightLine(clip, QLine(r.left(), r.top(), r.left() + r.width(), r.top() + r.height()));
+                        XDrawLine(d->dpy, d->hd, d->gc, l.p1().x(), l.p1().y(), l.p2().x(), l.p2().y());
+                    }
+                    continue;
+                }
+
+                r = r.intersected(clip);
+                if (r.isEmpty()) {
+                    --numClipped;
+                    continue;
+                }
+                xrects[i].x = short(r.x());
+                xrects[i].y = short(r.y());
+                xrects[i].width = ushort(r.width());
+                xrects[i].height = ushort(r.height());
+            }
+            if (numClipped) {
+                d->setupAdaptedOrigin(rects[0].topLeft());
+                if (d->has_brush)
+                    XFillRectangles(d->dpy, d->hd, d->gc_brush, xrects.data(), numClipped);
+                else if (d->has_pen)
+                    XDrawRectangles(d->dpy, d->hd, d->gc, xrects.data(), numClipped);
+                d->resetAdaptedOrigin();
+            }
+        }
+    }
+}
+
+static inline void setCapStyle(int cap_style, GC gc)
+{
+    ulong mask = GCCapStyle;
+    XGCValues vals;
+    vals.cap_style = cap_style;
+    XChangeGC(X11->display, gc, mask, &vals);
+}
+
+void QX11PaintEngine::drawPoints(const QPoint *points, int pointCount)
+{
+    Q_ASSERT(points);
+    Q_ASSERT(pointCount);
+    Q_D(QX11PaintEngine);
+
+    if (!d->has_pen)
+        return;
+
+    // use the same test here as in drawPath to ensure that we don't use the path fallback
+    // and end up in XDrawLines for pens with width <= 1
+    if (d->cpen.widthF() > 1.0f
+        || (X11->use_xrender && (d->has_alpha_pen || (d->render_hints & QPainter::Antialiasing)))
+        || (!d->cpen.isCosmetic() && d->txop > QTransform::TxTranslate))
+    {
+        Qt::PenCapStyle capStyle = d->cpen.capStyle();
+        if (capStyle == Qt::FlatCap) {
+            setCapStyle(CapProjecting, d->gc);
+            d->cpen.setCapStyle(Qt::SquareCap);
+        }
+        const QPoint *end = points + pointCount;
+        while (points < end) {
+            QPainterPath path;
+            path.moveTo(*points);
+            path.lineTo(points->x()+.005, points->y());
+            drawPath(path);
+            ++points;
+        }
+
+        if (capStyle == Qt::FlatCap) {
+            setCapStyle(CapButt, d->gc);
+            d->cpen.setCapStyle(capStyle);
+        }
+        return;
+    }
+
+    static const int BUF_SIZE = 1024;
+    XPoint xPoints[BUF_SIZE];
+    int i = 0, j = 0;
+    while (i < pointCount) {
+        while (i < pointCount && j < BUF_SIZE) {
+            const QPoint &xformed = d->matrix.map(points[i]);
+            int x = xformed.x();
+            int y = xformed.y();
+            if (x >= SHRT_MIN && y >= SHRT_MIN && x < SHRT_MAX && y < SHRT_MAX) {
+                xPoints[j].x = x;
+                xPoints[j].y = y;
+                ++j;
+            }
+            ++i;
+        }
+        if (j)
+            XDrawPoints(d->dpy, d->hd, d->gc, xPoints, j, CoordModeOrigin);
+
+        j = 0;
+    }
+}
+
+void QX11PaintEngine::drawPoints(const QPointF *points, int pointCount)
+{
+    Q_ASSERT(points);
+    Q_ASSERT(pointCount);
+    Q_D(QX11PaintEngine);
+
+    if (!d->has_pen)
+        return;
+
+    // use the same test here as in drawPath to ensure that we don't use the path fallback
+    // and end up in XDrawLines for pens with width <= 1
+    if (d->cpen.widthF() > 1.0f
+        || (X11->use_xrender && (d->has_alpha_pen || (d->render_hints & QPainter::Antialiasing)))
+        || (!d->cpen.isCosmetic() && d->txop > QTransform::TxTranslate))
+    {
+        Qt::PenCapStyle capStyle = d->cpen.capStyle();
+        if (capStyle == Qt::FlatCap) {
+            setCapStyle(CapProjecting, d->gc);
+            d->cpen.setCapStyle(Qt::SquareCap);
+        }
+
+        const QPointF *end = points + pointCount;
+        while (points < end) {
+            QPainterPath path;
+            path.moveTo(*points);
+            path.lineTo(points->x() + 0.005, points->y());
+            drawPath(path);
+            ++points;
+        }
+        if (capStyle == Qt::FlatCap) {
+            setCapStyle(CapButt, d->gc);
+            d->cpen.setCapStyle(capStyle);
+        }
+        return;
+    }
+
+    static const int BUF_SIZE = 1024;
+    XPoint xPoints[BUF_SIZE];
+    int i = 0, j = 0;
+    while (i < pointCount) {
+        while (i < pointCount && j < BUF_SIZE) {
+            const QPointF &xformed = d->matrix.map(points[i]);
+            int x = qFloor(xformed.x());
+            int y = qFloor(xformed.y());
+
+            if (x >= SHRT_MIN && y >= SHRT_MIN && x < SHRT_MAX && y < SHRT_MAX) {
+                xPoints[j].x = x;
+                xPoints[j].y = y;
+                ++j;
+            }
+            ++i;
+        }
+        if (j)
+            XDrawPoints(d->dpy, d->hd, d->gc, xPoints, j, CoordModeOrigin);
+
+        j = 0;
+    }
+}
+
+QPainter::RenderHints QX11PaintEngine::supportedRenderHints() const
+{
+#if !defined(QT_NO_XRENDER)
+    if (X11->use_xrender)
+        return QPainter::Antialiasing;
+#endif
+    return QFlag(0);
+}
+
+void QX11PaintEngine::updateState(const QPaintEngineState &state)
+{
+    Q_D(QX11PaintEngine);
+    QPaintEngine::DirtyFlags flags = state.state();
+
+
+    if (flags & DirtyOpacity) {
+        d->opacity = state.opacity();
+        // Force update pen/brush as to get proper alpha colors propagated
+        flags |= DirtyPen;
+        flags |= DirtyBrush;
+    }
+
+    if (flags & DirtyTransform) updateMatrix(state.transform());
+    if (flags & DirtyPen) updatePen(state.pen());
+    if (flags & (DirtyBrush | DirtyBrushOrigin)) updateBrush(state.brush(), state.brushOrigin());
+    if (flags & DirtyFont) updateFont(state.font());
+
+    if (state.state() & DirtyClipEnabled) {
+        if (state.isClipEnabled()) {
+            QPolygonF clip_poly_dev(d->matrix.map(painter()->clipPath().toFillPolygon()));
+            QPolygonF clipped_poly_dev;
+            d->clipPolygon_dev(clip_poly_dev, &clipped_poly_dev);
+            updateClipRegion_dev(QRegion(clipped_poly_dev.toPolygon()), Qt::ReplaceClip);
+        } else {
+            updateClipRegion_dev(QRegion(), Qt::NoClip);
+        }
+    }
+
+    if (flags & DirtyClipPath) {
+        QPolygonF clip_poly_dev(d->matrix.map(state.clipPath().toFillPolygon()));
+        QPolygonF clipped_poly_dev;
+        d->clipPolygon_dev(clip_poly_dev, &clipped_poly_dev);
+        updateClipRegion_dev(QRegion(clipped_poly_dev.toPolygon(), state.clipPath().fillRule()),
+                             state.clipOperation());
+    } else if (flags & DirtyClipRegion) {
+        extern QPainterPath qt_regionToPath(const QRegion &region);
+        QPainterPath clip_path = qt_regionToPath(state.clipRegion());
+        QPolygonF clip_poly_dev(d->matrix.map(clip_path.toFillPolygon()));
+        QPolygonF clipped_poly_dev;
+        d->clipPolygon_dev(clip_poly_dev, &clipped_poly_dev);
+        updateClipRegion_dev(QRegion(clipped_poly_dev.toPolygon()), state.clipOperation());
+    }
+    if (flags & DirtyHints) updateRenderHints(state.renderHints());
+    if (flags & DirtyCompositionMode) {
+        int function = GXcopy;
+        if (state.compositionMode() >= QPainter::RasterOp_SourceOrDestination) {
+            switch (state.compositionMode()) {
+            case QPainter::RasterOp_SourceOrDestination:
+                function = GXor;
+                break;
+            case QPainter::RasterOp_SourceAndDestination:
+                function = GXand;
+                break;
+            case QPainter::RasterOp_SourceXorDestination:
+                function = GXxor;
+                break;
+            case QPainter::RasterOp_NotSourceAndNotDestination:
+                function = GXnor;
+                break;
+            case QPainter::RasterOp_NotSourceOrNotDestination:
+                function = GXnand;
+                break;
+            case QPainter::RasterOp_NotSourceXorDestination:
+                function = GXequiv;
+                break;
+            case QPainter::RasterOp_NotSource:
+                function = GXcopyInverted;
+                break;
+            case QPainter::RasterOp_SourceAndNotDestination:
+                function = GXandReverse;
+                break;
+            case QPainter::RasterOp_NotSourceAndDestination:
+                function = GXandInverted;
+                break;
+            default:
+                function = GXcopy;
+            }
+        }
+#if !defined(QT_NO_XRENDER)
+        else {
+            d->composition_mode =
+            qpainterOpToXrender(state.compositionMode());
+        }
+#endif
+        XSetFunction(X11->display, d->gc, function);
+        XSetFunction(X11->display, d->gc_brush, function);
+    }
+    d->decidePathFallback();
+    d->decideCoordAdjust();
+}
+
+void QX11PaintEngine::updateRenderHints(QPainter::RenderHints hints)
+{
+    Q_D(QX11PaintEngine);
+    d->render_hints = hints;
+
+#if !defined(QT_NO_XRENDER)
+    if (X11->use_xrender && d->picture) {
+        XRenderPictureAttributes attrs;
+        attrs.poly_edge = (hints & QPainter::Antialiasing) ? PolyEdgeSmooth : PolyEdgeSharp;
+        XRenderChangePicture(d->dpy, d->picture, CPPolyEdge, &attrs);
+    }
+#endif
+}
+
+void QX11PaintEngine::updatePen(const QPen &pen)
+{
+    Q_D(QX11PaintEngine);
+    d->cpen = pen;
+    int cp = CapButt;
+    int jn = JoinMiter;
+    int ps = pen.style();
+
+    if (d->opacity < 1.0) {
+        QColor c = d->cpen.color();
+        c.setAlpha(qRound(c.alpha()*d->opacity));
+        d->cpen.setColor(c);
+    }
+
+    d->has_pen = (ps != Qt::NoPen);
+    d->has_alpha_pen = (pen.color().alpha() != 255);
+
+    switch (pen.capStyle()) {
+    case Qt::SquareCap:
+        cp = CapProjecting;
+        break;
+    case Qt::RoundCap:
+        cp = CapRound;
+        break;
+    case Qt::FlatCap:
+    default:
+        cp = CapButt;
+        break;
+    }
+    switch (pen.joinStyle()) {
+    case Qt::BevelJoin:
+        jn = JoinBevel;
+        break;
+    case Qt::RoundJoin:
+        jn = JoinRound;
+        break;
+    case Qt::MiterJoin:
+    default:
+        jn = JoinMiter;
+        break;
+    }
+
+    d->adapted_pen_origin = false;
+
+    char dashes[10];                            // custom pen dashes
+    int dash_len = 0;                           // length of dash list
+    int xStyle = LineSolid;
+
+    /*
+      We are emulating Windows here.  Windows treats cpen.width() == 1
+      (or 0) as a very special case.  The fudge variable unifies this
+      case with the general case.
+    */
+    qreal pen_width = pen.widthF();
+    int scale =  qRound(pen_width < 1 ? 1 : pen_width);
+    int space = (pen_width < 1 && pen_width > 0 ? 1 : (2 * scale));
+    int dot = 1 * scale;
+    int dash = 4 * scale;
+
+    d->has_custom_pen = false;
+
+    switch (ps) {
+    case Qt::NoPen:
+    case Qt::SolidLine:
+        xStyle = LineSolid;
+	break;
+    case Qt::DashLine:
+	dashes[0] = dash;
+	dashes[1] = space;
+	dash_len = 2;
+        xStyle = LineOnOffDash;
+	break;
+    case Qt::DotLine:
+	dashes[0] = dot;
+	dashes[1] = space;
+	dash_len = 2;
+        xStyle = LineOnOffDash;
+	break;
+    case Qt::DashDotLine:
+	dashes[0] = dash;
+	dashes[1] = space;
+	dashes[2] = dot;
+	dashes[3] = space;
+	dash_len = 4;
+        xStyle = LineOnOffDash;
+	break;
+    case Qt::DashDotDotLine:
+	dashes[0] = dash;
+	dashes[1] = space;
+	dashes[2] = dot;
+	dashes[3] = space;
+	dashes[4] = dot;
+	dashes[5] = space;
+	dash_len = 6;
+        xStyle = LineOnOffDash;
+        break;
+    case Qt::CustomDashLine:
+        d->has_custom_pen = true;
+        break;
+    }
+
+    ulong mask = GCForeground | GCBackground | GCGraphicsExposures | GCLineWidth
+                 | GCCapStyle | GCJoinStyle | GCLineStyle;
+    XGCValues vals;
+    vals.graphics_exposures = false;
+    if (d->pdev_depth == 1) {
+        vals.foreground = qGray(pen.color().rgb()) > 127 ? 0 : 1;
+        vals.background = qGray(QColor(Qt::transparent).rgb()) > 127 ? 0 : 1;
+    } else if (d->pdev->devType() == QInternal::Pixmap && d->pdev_depth == 32
+        && X11->use_xrender) {
+        vals.foreground = pen.color().rgba();
+        vals.background = QColor(Qt::transparent).rgba();
+    } else {
+        QColormap cmap = QColormap::instance(d->scrn);
+        vals.foreground = cmap.pixel(pen.color());
+        vals.background = cmap.pixel(QColor(Qt::transparent));
+    }
+
+
+    vals.line_width = qRound(pen.widthF());
+    vals.cap_style = cp;
+    vals.join_style = jn;
+    vals.line_style = xStyle;
+
+    XChangeGC(d->dpy, d->gc, mask, &vals);
+
+    if (dash_len) { // make dash list
+        XSetDashes(d->dpy, d->gc, 0, dashes, dash_len);
+    }
+
+    if (!d->has_clipping) { // if clipping is set the paintevent clip region is merged with the clip region
+        QRegion sysClip = systemClip();
+        if (!sysClip.isEmpty())
+            x11SetClipRegion(d->dpy, d->gc, 0, d->picture, sysClip);
+        else
+            x11ClearClipRegion(d->dpy, d->gc, 0, d->picture);
+    }
+}
+
+void QX11PaintEngine::updateBrush(const QBrush &brush, const QPointF &origin)
+{
+    Q_D(QX11PaintEngine);
+    d->cbrush = brush;
+    d->bg_origin = origin;
+    d->adapted_brush_origin = false;
+#if !defined(QT_NO_XRENDER)
+    d->current_brush = 0;
+#endif
+    if (d->opacity < 1.0) {
+        QColor c = d->cbrush.color();
+        c.setAlpha(qRound(c.alpha()*d->opacity));
+        d->cbrush.setColor(c);
+    }
+
+    int s  = FillSolid;
+    int  bs = d->cbrush.style();
+    d->has_brush = (bs != Qt::NoBrush);
+    d->has_pattern = bs >= Qt::Dense1Pattern && bs <= Qt::DiagCrossPattern;
+    d->has_texture = bs == Qt::TexturePattern;
+    d->has_alpha_brush = brush.color().alpha() != 255;
+    d->has_alpha_texture = d->has_texture && d->cbrush.texture().hasAlphaChannel();
+
+    ulong mask = GCForeground | GCBackground | GCGraphicsExposures
+                 | GCLineStyle | GCCapStyle | GCJoinStyle | GCFillStyle;
+    XGCValues vals;
+    vals.graphics_exposures = false;
+    if (d->pdev_depth == 1) {
+        vals.foreground = qGray(d->cbrush.color().rgb()) > 127 ? 0 : 1;
+        vals.background = qGray(QColor(Qt::transparent).rgb()) > 127 ? 0 : 1;
+    } else if (X11->use_xrender && d->pdev->devType() == QInternal::Pixmap
+               && d->pdev_depth == 32) {
+        vals.foreground = d->cbrush.color().rgba();
+        vals.background = QColor(Qt::transparent).rgba();
+    } else {
+        QColormap cmap = QColormap::instance(d->scrn);
+        vals.foreground = cmap.pixel(d->cbrush.color());
+        vals.background = cmap.pixel(QColor(Qt::transparent));
+
+        if (!X11->use_xrender && d->has_brush && !d->has_pattern && !brush.isOpaque()) {
+            QPixmap pattern = qt_patternForAlpha(brush.color().alpha(), d->scrn);
+            mask |= GCStipple;
+            vals.stipple = pattern.handle();
+            s = FillStippled;
+            d->adapted_brush_origin = true;
+        }
+    }
+    vals.cap_style = CapButt;
+    vals.join_style = JoinMiter;
+    vals.line_style = LineSolid;
+
+    if (d->has_pattern || d->has_texture) {
+        if (bs == Qt::TexturePattern) {
+            d->brush_pm = qt_toX11Pixmap(d->cbrush.texture());
+#if !defined(QT_NO_XRENDER)
+            if (X11->use_xrender) {
+                XRenderPictureAttributes attrs;
+                attrs.repeat = true;
+                XRenderChangePicture(d->dpy, d->brush_pm.x11PictureHandle(), CPRepeat, &attrs);
+                QX11PixmapData *data = static_cast<QX11PixmapData*>(d->brush_pm.data.data());
+                if (data->mask_picture)
+                    XRenderChangePicture(d->dpy, data->mask_picture, CPRepeat, &attrs);
+            }
+#endif
+        } else {
+            d->brush_pm = qt_toX11Pixmap(qt_pixmapForBrush(bs, true));
+        }
+        d->brush_pm.x11SetScreen(d->scrn);
+        if (d->brush_pm.depth() == 1) {
+            mask |= GCStipple;
+            vals.stipple = d->brush_pm.handle();
+            s = FillStippled;
+#if !defined(QT_NO_XRENDER)
+            if (X11->use_xrender) {
+                d->bitmap_texture = QPixmap(d->brush_pm.size());
+                d->bitmap_texture.fill(Qt::transparent);
+                d->bitmap_texture = qt_toX11Pixmap(d->bitmap_texture);
+                d->bitmap_texture.x11SetScreen(d->scrn);
+
+                ::Picture src  = X11->getSolidFill(d->scrn, d->cbrush.color());
+                XRenderComposite(d->dpy, PictOpSrc, src, d->brush_pm.x11PictureHandle(),
+                                 d->bitmap_texture.x11PictureHandle(),
+                                 0, 0, d->brush_pm.width(), d->brush_pm.height(),
+                                 0, 0, d->brush_pm.width(), d->brush_pm.height());
+
+                XRenderPictureAttributes attrs;
+                attrs.repeat = true;
+                XRenderChangePicture(d->dpy, d->bitmap_texture.x11PictureHandle(), CPRepeat, &attrs);
+
+                d->current_brush = d->bitmap_texture.x11PictureHandle();
+            }
+#endif
+        } else {
+            mask |= GCTile;
+#ifndef QT_NO_XRENDER
+            if (d->pdev_depth == 32 && d->brush_pm.depth() != 32) {
+                d->brush_pm.detach();
+                QX11PixmapData *brushData = static_cast<QX11PixmapData*>(d->brush_pm.data.data());
+                brushData->convertToARGB32();
+            }
+#endif
+            vals.tile = (d->brush_pm.depth() == d->pdev_depth
+                         ? d->brush_pm.handle()
+                         : static_cast<QX11PixmapData*>(d->brush_pm.data.data())->x11ConvertToDefaultDepth());
+            s = FillTiled;
+#if !defined(QT_NO_XRENDER)
+            d->current_brush = d->cbrush.texture().x11PictureHandle();
+#endif
+        }
+
+        mask |= GCTileStipXOrigin | GCTileStipYOrigin;
+        vals.ts_x_origin = qRound(origin.x());
+        vals.ts_y_origin = qRound(origin.y());
+    }
+#if !defined(QT_NO_XRENDER)
+    else if (d->has_alpha_brush) {
+        d->current_brush = X11->getSolidFill(d->scrn, d->cbrush.color());
+    }
+#endif
+
+    vals.fill_style = s;
+    XChangeGC(d->dpy, d->gc_brush, mask, &vals);
+    if (!d->has_clipping) {
+        QRegion sysClip = systemClip();
+        if (!sysClip.isEmpty())
+            x11SetClipRegion(d->dpy, d->gc_brush, 0, d->picture, sysClip);
+        else
+            x11ClearClipRegion(d->dpy, d->gc_brush, 0, d->picture);
+    }
+}
+
+void QX11PaintEngine::drawEllipse(const QRectF &rect)
+{
+    QRect aligned = rect.toAlignedRect();
+    if (aligned == rect)
+        drawEllipse(aligned);
+    else
+        QPaintEngine::drawEllipse(rect);
+}
+
+void QX11PaintEngine::drawEllipse(const QRect &rect)
+{
+    if (rect.isEmpty()) {
+        drawRects(&rect, 1);
+        return;
+    }
+
+    Q_D(QX11PaintEngine);
+    QRect devclip(SHRT_MIN, SHRT_MIN, SHRT_MAX*2 - 1, SHRT_MAX*2 - 1);
+    QRect r(rect);
+    if (d->txop < QTransform::TxRotate) {
+        r = d->matrix.mapRect(rect);
+    } else if (d->txop == QTransform::TxRotate && rect.width() == rect.height()) {
+        QPainterPath path;
+        path.addEllipse(rect);
+        r = d->matrix.map(path).boundingRect().toRect();
+    }
+
+    if (d->has_alpha_brush || d->has_alpha_pen || d->has_custom_pen || (d->render_hints & QPainter::Antialiasing)
+        || d->has_alpha_texture || devclip.intersected(r) != r
+        || (d->has_complex_xform
+            && !(d->has_non_scaling_xform && rect.width() == rect.height())))
+    {
+        QPainterPath path;
+        path.addEllipse(rect);
+        drawPath(path);
+        return;
+    }
+
+    int x = r.x();
+    int y = r.y();
+    int w = r.width();
+    int h = r.height();
+    if (w < 1 || h < 1)
+        return;
+    if (w == 1 && h == 1) {
+        XDrawPoint(d->dpy, d->hd, d->has_pen ? d->gc : d->gc_brush, x, y);
+        return;
+    }
+    d->setupAdaptedOrigin(rect.topLeft());
+    if (d->has_brush) {             // draw filled ellipse
+        XFillArc(d->dpy, d->hd, d->gc_brush, x, y, w, h, 0, 360*64);
+        if (!d->has_pen)            // make smoother outline
+            XDrawArc(d->dpy, d->hd, d->gc_brush, x, y, w-1, h-1, 0, 360*64);
+    }
+    if (d->has_pen)                // draw outline
+        XDrawArc(d->dpy, d->hd, d->gc, x, y, w, h, 0, 360*64);
+    d->resetAdaptedOrigin();
+}
+
+
+
+void QX11PaintEnginePrivate::fillPolygon_translated(const QPointF *polygonPoints, int pointCount,
+                                                    QX11PaintEnginePrivate::GCMode gcMode,
+                                                    QPaintEngine::PolygonDrawMode mode)
+{
+
+    QVarLengthArray<QPointF> translated_points(pointCount);
+    QPointF offset(matrix.dx(), matrix.dy());
+
+    qreal offs = adjust_coords ? aliasedCoordinateDelta : 0.0;
+    if (!X11->use_xrender || !(render_hints & QPainter::Antialiasing))
+        offset += QPointF(aliasedCoordinateDelta, aliasedCoordinateDelta);
+
+    for (int i = 0; i < pointCount; ++i) {
+        translated_points[i] = polygonPoints[i] + offset;
+
+        translated_points[i].rx() = qRound(translated_points[i].x()) + offs;
+        translated_points[i].ry() = qRound(translated_points[i].y()) + offs;
+    }
+
+    fillPolygon_dev(translated_points.data(), pointCount, gcMode, mode);
+}
+
+#ifndef QT_NO_XRENDER
+static void qt_XRenderCompositeTrapezoids(Display *dpy,
+                                          int op,
+                                          Picture src,
+                                          Picture dst,
+                                          _Xconst XRenderPictFormat *maskFormat,
+                                          int xSrc,
+                                          int ySrc,
+                                          const XTrapezoid *traps, int size)
+{
+    const int MAX_TRAPS = 50000;
+    while (size) {
+        int to_draw = size;
+        if (to_draw > MAX_TRAPS)
+            to_draw = MAX_TRAPS;
+        XRenderCompositeTrapezoids(dpy, op, src, dst,
+                                   maskFormat,
+                                   xSrc, ySrc,
+                                   traps, to_draw);
+        size -= to_draw;
+        traps += to_draw;
+    }
+}
+#endif
+
+void QX11PaintEnginePrivate::fillPolygon_dev(const QPointF *polygonPoints, int pointCount,
+                                             QX11PaintEnginePrivate::GCMode gcMode,
+                                             QPaintEngine::PolygonDrawMode mode)
+{
+    Q_Q(QX11PaintEngine);
+
+    int clippedCount = 0;
+    qt_float_point *clippedPoints = 0;
+
+#ifndef QT_NO_XRENDER
+    //can change if we switch to pen if gcMode != BrushGC
+    bool has_fill_texture = has_texture;
+    bool has_fill_pattern = has_pattern;
+    ::Picture src;
+#endif
+    QBrush fill;
+    GC fill_gc;
+    if (gcMode == BrushGC) {
+        fill = cbrush;
+        fill_gc = gc_brush;
+#ifndef QT_NO_XRENDER
+        if (current_brush)
+            src = current_brush;
+        else
+            src = X11->getSolidFill(scrn, fill.color());
+#endif
+    } else {
+        fill = QBrush(cpen.brush());
+        fill_gc = gc;
+#ifndef QT_NO_XRENDER
+        //we use the pens brush
+        has_fill_texture = (fill.style() == Qt::TexturePattern);
+        has_fill_pattern = (fill.style() >= Qt::Dense1Pattern && fill.style() <= Qt::DiagCrossPattern);
+        if (has_fill_texture)
+            src = fill.texture().x11PictureHandle();
+        else if (has_fill_pattern)
+            src = getPatternFill(scrn, fill);
+        else
+            src = X11->getSolidFill(scrn, fill.color());
+#endif
+    }
+
+    polygonClipper.clipPolygon((qt_float_point *) polygonPoints, pointCount,
+                               &clippedPoints, &clippedCount);
+
+#ifndef QT_NO_XRENDER
+    bool solid_fill = fill.color().alpha() == 255;
+    if (has_fill_texture && fill.texture().depth() == 1 && solid_fill) {
+        has_fill_texture = false;
+        has_fill_pattern = true;
+    }
+
+    bool antialias = render_hints & QPainter::Antialiasing;
+
+    if (X11->use_xrender
+        && picture
+        && !has_fill_pattern
+        && (clippedCount > 0)
+        && (fill.style() != Qt::NoBrush)
+        && ((has_fill_texture && fill.texture().hasAlpha()) || antialias || !solid_fill || has_alpha_pen != has_alpha_brush))
+    {
+        QRect br = tessellator->tessellate((QPointF *)clippedPoints, clippedCount,
+                                              mode == QPaintEngine::WindingMode);
+        if (tessellator->size > 0) {
+            XRenderPictureAttributes attrs;
+            attrs.poly_edge = antialias ? PolyEdgeSmooth : PolyEdgeSharp;
+            XRenderChangePicture(dpy, picture, CPPolyEdge, &attrs);
+            int x_offset = int(XFixedToDouble(tessellator->traps[0].left.p1.x) - bg_origin.x());
+            int y_offset = int(XFixedToDouble(tessellator->traps[0].left.p1.y) - bg_origin.y());
+            qt_XRenderCompositeTrapezoids(dpy, composition_mode, src, picture,
+                                          antialias
+                                          ? XRenderFindStandardFormat(dpy, PictStandardA8)
+                                          : XRenderFindStandardFormat(dpy, PictStandardA1),
+                                          x_offset, y_offset,
+                                          tessellator->traps, tessellator->size);
+            tessellator->done();
+        }
+    } else
+#endif
+        if (fill.style() != Qt::NoBrush) {
+            if (clippedCount > 200000) {
+                QPolygon poly;
+                for (int i = 0; i < clippedCount; ++i)
+                    poly << QPoint(qFloor(clippedPoints[i].x), qFloor(clippedPoints[i].y));
+
+                const QRect bounds = poly.boundingRect();
+                const QRect aligned = bounds
+                    & QRect(QPoint(), QSize(pdev->width(), pdev->height()));
+
+                QImage img(aligned.size(), QImage::Format_ARGB32_Premultiplied);
+                img.fill(0);
+
+                QPainter painter(&img);
+                painter.translate(-aligned.x(), -aligned.y());
+                painter.setPen(Qt::NoPen);
+                painter.setBrush(fill);
+                if (gcMode == BrushGC)
+                    painter.setBrushOrigin(q->painter()->brushOrigin());
+                painter.drawPolygon(poly);
+                painter.end();
+
+                q->drawImage(aligned, img, img.rect(), Qt::AutoColor);
+            } else if (clippedCount > 0) {
+                QVarLengthArray<XPoint> xpoints(clippedCount);
+                for (int i = 0; i < clippedCount; ++i) {
+                    xpoints[i].x = qFloor(clippedPoints[i].x);
+                    xpoints[i].y = qFloor(clippedPoints[i].y);
+                }
+                if (mode == QPaintEngine::WindingMode)
+                    XSetFillRule(dpy, fill_gc, WindingRule);
+                setupAdaptedOrigin(QPoint(xpoints[0].x, xpoints[0].y));
+                XFillPolygon(dpy, hd, fill_gc,
+                             xpoints.data(), clippedCount,
+                             mode == QPaintEngine::ConvexMode ? Convex : Complex, CoordModeOrigin);
+                resetAdaptedOrigin();
+                if (mode == QPaintEngine::WindingMode)
+                    XSetFillRule(dpy, fill_gc, EvenOddRule);
+            }
+        }
+}
+
+void QX11PaintEnginePrivate::strokePolygon_translated(const QPointF *polygonPoints, int pointCount, bool close)
+{
+    QVarLengthArray<QPointF> translated_points(pointCount);
+    QPointF offset(matrix.dx(), matrix.dy());
+    for (int i = 0; i < pointCount; ++i)
+        translated_points[i] = polygonPoints[i] + offset;
+    strokePolygon_dev(translated_points.data(), pointCount, close);
+}
+
+void QX11PaintEnginePrivate::strokePolygon_dev(const QPointF *polygonPoints, int pointCount, bool close)
+{
+    int clippedCount = 0;
+    qt_float_point *clippedPoints = 0;
+    polygonClipper.clipPolygon((qt_float_point *) polygonPoints, pointCount,
+                               &clippedPoints, &clippedCount, close);
+
+    if (clippedCount > 0) {
+        QVarLengthArray<XPoint> xpoints(clippedCount);
+        for (int i = 0; i < clippedCount; ++i) {
+            xpoints[i].x = qRound(clippedPoints[i].x + aliasedCoordinateDelta);
+            xpoints[i].y = qRound(clippedPoints[i].y + aliasedCoordinateDelta);
+        }
+        uint numberPoints = qMin(clippedCount, xlibMaxLinePoints);
+        XPoint *pts = xpoints.data();
+        XDrawLines(dpy, hd, gc, pts, numberPoints, CoordModeOrigin);
+        pts += numberPoints;
+        clippedCount -= numberPoints;
+        numberPoints = qMin(clippedCount, xlibMaxLinePoints-1);
+        while (clippedCount) {
+            XDrawLines(dpy, hd, gc, pts-1, numberPoints+1, CoordModeOrigin);
+            pts += numberPoints;
+            clippedCount -= numberPoints;
+            numberPoints = qMin(clippedCount, xlibMaxLinePoints-1);
+        }
+    }
+}
+
+void QX11PaintEngine::drawPolygon(const QPointF *polygonPoints, int pointCount, PolygonDrawMode mode)
+{
+    Q_D(QX11PaintEngine);
+    if (d->use_path_fallback) {
+        QPainterPath path(polygonPoints[0]);
+        for (int i = 1; i < pointCount; ++i)
+            path.lineTo(polygonPoints[i]);
+        if (mode == PolylineMode) {
+            QBrush oldBrush = d->cbrush;
+            d->cbrush = QBrush(Qt::NoBrush);
+            path.setFillRule(Qt::WindingFill);
+            drawPath(path);
+            d->cbrush = oldBrush;
+        } else {
+            path.setFillRule(mode == OddEvenMode ? Qt::OddEvenFill : Qt::WindingFill);
+            path.closeSubpath();
+            drawPath(path);
+        }
+        return;
+    }
+    if (mode != PolylineMode && d->has_brush)
+        d->fillPolygon_translated(polygonPoints, pointCount, QX11PaintEnginePrivate::BrushGC, mode);
+
+    if (d->has_pen)
+        d->strokePolygon_translated(polygonPoints, pointCount, mode != PolylineMode);
+}
+
+
+void QX11PaintEnginePrivate::fillPath(const QPainterPath &path, QX11PaintEnginePrivate::GCMode gc_mode, bool transform)
+{
+    qreal offs = adjust_coords ? aliasedCoordinateDelta : 0.0;
+
+    QPainterPath clippedPath;
+    QPainterPath clipPath;
+    clipPath.addRect(polygonClipper.boundingRect());
+
+    if (transform)
+         clippedPath = (path*matrix).intersected(clipPath);
+    else
+        clippedPath = path.intersected(clipPath);
+
+    QList<QPolygonF> polys = clippedPath.toFillPolygons();
+    for (int i = 0; i < polys.size(); ++i) {
+        QVarLengthArray<QPointF> translated_points(polys.at(i).size());
+
+        for (int j = 0; j < polys.at(i).size(); ++j) {
+            translated_points[j] = polys.at(i).at(j);
+            if (!X11->use_xrender || !(render_hints & QPainter::Antialiasing)) {
+                translated_points[j].rx() = qRound(translated_points[j].rx() + aliasedCoordinateDelta) + offs;
+                translated_points[j].ry() = qRound(translated_points[j].ry() + aliasedCoordinateDelta) + offs;
+            }
+        }
+
+        fillPolygon_dev(translated_points.data(), polys.at(i).size(), gc_mode,
+                        path.fillRule() == Qt::OddEvenFill ? QPaintEngine::OddEvenMode : QPaintEngine::WindingMode);
+    }
+}
+
+void QX11PaintEngine::drawPath(const QPainterPath &path)
+{
+    Q_D(QX11PaintEngine);
+    if (path.isEmpty())
+        return;
+    QTransform old_matrix = d->matrix;
+
+    if (d->has_brush)
+        d->fillPath(path, QX11PaintEnginePrivate::BrushGC, true);
+    if (d->has_pen
+        && ((X11->use_xrender && (d->has_alpha_pen || (d->render_hints & QPainter::Antialiasing)))
+            || (!d->cpen.isCosmetic() && d->txop > QTransform::TxTranslate
+                && !d->has_non_scaling_xform)
+            || (d->cpen.style() == Qt::CustomDashLine))) {
+        QPainterPathStroker stroker;
+        if (d->cpen.style() == Qt::CustomDashLine) {
+            stroker.setDashPattern(d->cpen.dashPattern());
+            stroker.setDashOffset(d->cpen.dashOffset());
+        } else {
+            stroker.setDashPattern(d->cpen.style());
+        }
+        stroker.setCapStyle(d->cpen.capStyle());
+        stroker.setJoinStyle(d->cpen.joinStyle());
+        QPainterPath stroke;
+        qreal width = d->cpen.widthF();
+        QPolygonF poly;
+        QRectF deviceRect(0, 0, d->pdev->width(), d->pdev->height());
+        // necessary to get aliased alphablended primitives to be drawn correctly
+        if (d->cpen.isCosmetic() || d->has_scaling_xform) {
+            if (d->cpen.isCosmetic())
+                stroker.setWidth(width == 0 ? 1 : width);
+            else
+                stroker.setWidth(width * d->xform_scale);
+            stroker.d_ptr->stroker.setClipRect(deviceRect);
+            stroke = stroker.createStroke(path * d->matrix);
+            if (stroke.isEmpty())
+                return;
+            stroke.setFillRule(Qt::WindingFill);
+            d->fillPath(stroke, QX11PaintEnginePrivate::PenGC, false);
+        } else {
+            stroker.setWidth(width);
+            stroker.d_ptr->stroker.setClipRect(d->matrix.inverted().mapRect(deviceRect));
+            stroke = stroker.createStroke(path);
+            if (stroke.isEmpty())
+                return;
+            stroke.setFillRule(Qt::WindingFill);
+            d->fillPath(stroke, QX11PaintEnginePrivate::PenGC, true);
+        }
+    } else if (d->has_pen) {
+        // if we have a cosmetic pen - use XDrawLine() for speed
+        QList<QPolygonF> polys = path.toSubpathPolygons(d->matrix);
+        for (int i = 0; i < polys.size(); ++i)
+            d->strokePolygon_dev(polys.at(i).data(), polys.at(i).size(), false);
+    }
+}
+
+Q_GUI_EXPORT void qt_x11_drawImage(const QRect &rect, const QPoint &pos, const QImage &image,
+                                   Drawable hd, GC gc, Display *dpy, Visual *visual, int depth)
+{
+    Q_ASSERT(image.format() == QImage::Format_RGB32);
+    Q_ASSERT(image.depth() == 32);
+
+    XImage *xi;
+    // Note: this code assumes either RGB or BGR, 8 bpc server layouts
+    const uint red_mask = (uint) visual->red_mask;
+    bool bgr_layout = (red_mask == 0xff);
+
+    const int w = rect.width();
+    const int h = rect.height();
+
+    QImage im;
+    int image_byte_order = ImageByteOrder(X11->display);
+    if ((QSysInfo::ByteOrder == QSysInfo::BigEndian && ((image_byte_order == LSBFirst) || bgr_layout))
+        || (image_byte_order == MSBFirst && QSysInfo::ByteOrder == QSysInfo::LittleEndian)
+        || (image_byte_order == LSBFirst && bgr_layout))
+    {
+        im = image.copy(rect);
+        const int iw = im.bytesPerLine() / 4;
+        uint *data = (uint *)im.bits();
+        for (int i=0; i < h; i++) {
+            uint *p = data;
+            uint *end = p + w;
+            if (bgr_layout && image_byte_order == MSBFirst && QSysInfo::ByteOrder == QSysInfo::LittleEndian) {
+                while (p < end) {
+                    *p = ((*p << 8) & 0xffffff00) | ((*p >> 24) & 0x000000ff);
+                    p++;
+                }
+            } else if ((image_byte_order == LSBFirst && QSysInfo::ByteOrder == QSysInfo::BigEndian)
+                    || (image_byte_order == MSBFirst && QSysInfo::ByteOrder == QSysInfo::LittleEndian)) {
+                while (p < end) {
+                    *p = ((*p << 24) & 0xff000000) | ((*p << 8) & 0x00ff0000)
+                        | ((*p >> 8) & 0x0000ff00) | ((*p >> 24) & 0x000000ff);
+                    p++;
+                }
+            } else if ((image_byte_order == MSBFirst && QSysInfo::ByteOrder == QSysInfo::BigEndian)
+                       || (image_byte_order == LSBFirst && bgr_layout))
+            {
+                while (p < end) {
+                    *p = ((*p << 16) & 0x00ff0000) | ((*p >> 16) & 0x000000ff)
+                        | ((*p ) & 0xff00ff00);
+                    p++;
+                }
+            }
+            data += iw;
+        }
+        xi = XCreateImage(dpy, visual, depth, ZPixmap,
+                          0, (char *) im.bits(), w, h, 32, im.bytesPerLine());
+    } else {
+        xi = XCreateImage(dpy, visual, depth, ZPixmap,
+                          0, (char *) image.scanLine(rect.y())+rect.x()*sizeof(uint), w, h, 32, image.bytesPerLine());
+    }
+    XPutImage(dpy, hd, gc, xi, 0, 0, pos.x(), pos.y(), w, h);
+    xi->data = 0; // QImage owns these bits
+    XDestroyImage(xi);
+}
+
+void QX11PaintEngine::drawImage(const QRectF &r, const QImage &image, const QRectF &sr, Qt::ImageConversionFlags flags)
+{
+    Q_D(QX11PaintEngine);
+
+    if (image.format() == QImage::Format_RGB32
+        && d->pdev_depth >= 24 && image.depth() == 32
+        && r.size() == sr.size())
+    {
+        int sx = qRound(sr.x());
+        int sy = qRound(sr.y());
+        int x = qRound(r.x());
+        int y = qRound(r.y());
+        int w = qRound(r.width());
+        int h = qRound(r.height());
+
+        qt_x11_drawImage(QRect(sx, sy, w, h), QPoint(x, y), image, d->hd, d->gc, d->dpy,
+                         (Visual *)d->xinfo->visual(), d->pdev_depth);
+    } else {
+        QPaintEngine::drawImage(r, image, sr, flags);
+    }
+}
+
+void QX11PaintEngine::drawPixmap(const QRectF &r, const QPixmap &px, const QRectF &_sr)
+{
+    Q_D(QX11PaintEngine);
+    QRectF sr = _sr;
+    int x = qRound(r.x());
+    int y = qRound(r.y());
+    int sx = qRound(sr.x());
+    int sy = qRound(sr.y());
+    int sw = qRound(sr.width());
+    int sh = qRound(sr.height());
+
+    QPixmap pixmap = qt_toX11Pixmap(px);
+    if(pixmap.isNull())
+        return;
+
+    if ((d->xinfo && d->xinfo->screen() != pixmap.x11Info().screen())
+        || (pixmap.x11Info().screen() != DefaultScreen(X11->display))) {
+        QPixmap* p = const_cast<QPixmap *>(&pixmap);
+        p->x11SetScreen(d->xinfo ? d->xinfo->screen() : DefaultScreen(X11->display));
+    }
+
+    QPixmap::x11SetDefaultScreen(pixmap.x11Info().screen());
+
+#ifndef QT_NO_XRENDER
+    ::Picture src_pict = static_cast<QX11PixmapData*>(pixmap.data.data())->picture;
+    if (src_pict && d->picture) {
+        const int pDepth = pixmap.depth();
+        if (pDepth == 1 && (d->has_alpha_pen)) {
+            qt_render_bitmap(d->dpy, d->scrn, src_pict, d->picture,
+                             sx, sy, x, y, sw, sh, d->cpen);
+            return;
+        } else if (pDepth != 1 && (pDepth == 32 || pDepth != d->pdev_depth)) {
+            XRenderComposite(d->dpy, d->composition_mode,
+                             src_pict, 0, d->picture, sx, sy, 0, 0, x, y, sw, sh);
+            return;
+        }
+    }
+#endif
+
+    bool mono_src = pixmap.depth() == 1;
+    bool mono_dst = d->pdev_depth == 1;
+    bool restore_clip = false;
+
+    if (static_cast<QX11PixmapData*>(pixmap.data.data())->x11_mask) { // pixmap has a mask
+        QBitmap comb(sw, sh);
+        GC cgc = XCreateGC(d->dpy, comb.handle(), 0, 0);
+        XSetForeground(d->dpy, cgc, 0);
+        XFillRectangle(d->dpy, comb.handle(), cgc, 0, 0, sw, sh);
+        XSetBackground(d->dpy, cgc, 0);
+        XSetForeground(d->dpy, cgc, 1);
+        if (!d->crgn.isEmpty()) {
+            int num;
+            XRectangle *rects = (XRectangle *)qt_getClipRects(d->crgn, num);
+            XSetClipRectangles(d->dpy, cgc, -x, -y, rects, num, Unsorted);
+        } else if (d->has_clipping) {
+            XSetClipRectangles(d->dpy, cgc, 0, 0, 0, 0, Unsorted);
+        }
+        XSetFillStyle(d->dpy, cgc, FillOpaqueStippled);
+        XSetTSOrigin(d->dpy, cgc, -sx, -sy);
+        XSetStipple(d->dpy, cgc,
+                    static_cast<QX11PixmapData*>(pixmap.data.data())->x11_mask);
+        XFillRectangle(d->dpy, comb.handle(), cgc, 0, 0, sw, sh);
+        XFreeGC(d->dpy, cgc);
+
+        XSetClipOrigin(d->dpy, d->gc, x, y);
+        XSetClipMask(d->dpy, d->gc, comb.handle());
+        restore_clip = true;
+    }
+
+    if (mono_src) {
+        if (!d->crgn.isEmpty()) {
+            Pixmap comb = XCreatePixmap(d->dpy, d->hd, sw, sh, 1);
+            GC cgc = XCreateGC(d->dpy, comb, 0, 0);
+            XSetForeground(d->dpy, cgc, 0);
+            XFillRectangle(d->dpy, comb, cgc, 0, 0, sw, sh);
+            int num;
+            XRectangle *rects = (XRectangle *)qt_getClipRects(d->crgn, num);
+            XSetClipRectangles(d->dpy, cgc, -x, -y, rects, num, Unsorted);
+            XCopyArea(d->dpy, pixmap.handle(), comb, cgc, sx, sy, sw, sh, 0, 0);
+            XFreeGC(d->dpy, cgc);
+
+            XSetClipMask(d->dpy, d->gc, comb);
+            XSetClipOrigin(d->dpy, d->gc, x, y);
+            XFreePixmap(d->dpy, comb);
+        } else {
+            XSetClipMask(d->dpy, d->gc, pixmap.handle());
+            XSetClipOrigin(d->dpy, d->gc, x - sx, y - sy);
+        }
+
+        if (mono_dst) {
+            XSetForeground(d->dpy, d->gc, qGray(d->cpen.color().rgb()) > 127 ? 0 : 1);
+        } else {
+            QColormap cmap = QColormap::instance(d->scrn);
+            XSetForeground(d->dpy, d->gc, cmap.pixel(d->cpen.color()));
+        }
+        XFillRectangle(d->dpy, d->hd, d->gc, x, y, sw, sh);
+        restore_clip = true;
+    } else if (mono_dst && !mono_src) {
+        QBitmap bitmap(pixmap);
+        XCopyArea(d->dpy, bitmap.handle(), d->hd, d->gc, sx, sy, sw, sh, x, y);
+    } else {
+        XCopyArea(d->dpy, pixmap.handle(), d->hd, d->gc, sx, sy, sw, sh, x, y);
+    }
+
+    if (d->pdev->devType() == QInternal::Pixmap) {
+        const QPixmap *px = static_cast<const QPixmap*>(d->pdev);
+        Pixmap src_mask = static_cast<QX11PixmapData*>(pixmap.data.data())->x11_mask;
+        Pixmap dst_mask = static_cast<QX11PixmapData*>(px->data.data())->x11_mask;
+        if (dst_mask) {
+            GC cgc = XCreateGC(d->dpy, dst_mask, 0, 0);
+            if (src_mask) { // copy src mask into dst mask
+                XCopyArea(d->dpy, src_mask, dst_mask, cgc, sx, sy, sw, sh, x, y);
+            } else { // no src mask, but make sure the area copied is opaque in dest
+                XSetBackground(d->dpy, cgc, 0);
+                XSetForeground(d->dpy, cgc, 1);
+                XFillRectangle(d->dpy, dst_mask, cgc, x, y, sw, sh);
+            }
+            XFreeGC(d->dpy, cgc);
+        }
+    }
+
+    if (restore_clip) {
+        XSetClipOrigin(d->dpy, d->gc, 0, 0);
+        int num;
+        XRectangle *rects = (XRectangle *)qt_getClipRects(d->crgn, num);
+        if (num == 0)
+            XSetClipMask(d->dpy, d->gc, XNone);
+        else
+            XSetClipRectangles(d->dpy, d->gc, 0, 0, rects, num, Unsorted);
+    }
+}
+
+void QX11PaintEngine::updateMatrix(const QTransform &mtx)
+{
+    Q_D(QX11PaintEngine);
+    d->txop = mtx.type();
+    d->matrix = mtx;
+
+    d->has_complex_xform = (d->txop > QTransform::TxTranslate);
+
+    extern bool qt_scaleForTransform(const QTransform &transform, qreal *scale);
+    bool scaling = qt_scaleForTransform(d->matrix, &d->xform_scale);
+    d->has_scaling_xform = scaling && d->xform_scale != 1.0;
+    d->has_non_scaling_xform = scaling && d->xform_scale == 1.0;
+}
+
+/*
+   NB! the clip region is expected to be in dev coordinates
+*/
+void QX11PaintEngine::updateClipRegion_dev(const QRegion &clipRegion, Qt::ClipOperation op)
+{
+    Q_D(QX11PaintEngine);
+    QRegion sysClip = systemClip();
+    if (op == Qt::NoClip) {
+        d->has_clipping = false;
+        d->crgn = sysClip;
+        if (!sysClip.isEmpty()) {
+            x11SetClipRegion(d->dpy, d->gc, d->gc_brush, d->picture, sysClip);
+        } else {
+            x11ClearClipRegion(d->dpy, d->gc, d->gc_brush, d->picture);
+        }
+        return;
+    }
+
+    switch (op) {
+    case Qt::IntersectClip:
+        if (d->has_clipping) {
+            d->crgn &= clipRegion;
+            break;
+        }
+        // fall through
+    case Qt::ReplaceClip:
+        if (!sysClip.isEmpty())
+            d->crgn = clipRegion.intersected(sysClip);
+        else
+            d->crgn = clipRegion;
+        break;
+    case Qt::UniteClip:
+        d->crgn |= clipRegion;
+        if (!sysClip.isEmpty())
+            d->crgn = d->crgn.intersected(sysClip);
+        break;
+    default:
+        break;
+    }
+    d->has_clipping = true;
+    x11SetClipRegion(d->dpy, d->gc, d->gc_brush, d->picture, d->crgn);
+}
+
+void QX11PaintEngine::updateFont(const QFont &)
+{
+}
+
+Qt::HANDLE QX11PaintEngine::handle() const
+{
+    Q_D(const QX11PaintEngine);
+    Q_ASSERT(isActive());
+    Q_ASSERT(d->hd);
+    return d->hd;
+}
+
+extern void qt_draw_tile(QPaintEngine *, qreal, qreal, qreal, qreal, const QPixmap &,
+                         qreal, qreal);
+
+void QX11PaintEngine::drawTiledPixmap(const QRectF &r, const QPixmap &pixmap, const QPointF &p)
+{
+    int x = qRound(r.x());
+    int y = qRound(r.y());
+    int w = qRound(r.width());
+    int h = qRound(r.height());
+    int sx = qRound(p.x());
+    int sy = qRound(p.y());
+
+    bool mono_src = pixmap.depth() == 1;
+    Q_D(QX11PaintEngine);
+
+    if ((d->xinfo && d->xinfo->screen() != pixmap.x11Info().screen())
+        || (pixmap.x11Info().screen() != DefaultScreen(X11->display))) {
+        QPixmap* p = const_cast<QPixmap *>(&pixmap);
+        p->x11SetScreen(d->xinfo ? d->xinfo->screen() : DefaultScreen(X11->display));
+    }
+
+    QPixmap::x11SetDefaultScreen(pixmap.x11Info().screen());
+
+#ifndef QT_NO_XRENDER
+    if (X11->use_xrender && d->picture && pixmap.x11PictureHandle()) {
+#if 0
+        // ### Qt 5: enable this
+        XRenderPictureAttributes attrs;
+        attrs.repeat = true;
+        XRenderChangePicture(d->dpy, pixmap.x11PictureHandle(), CPRepeat, &attrs);
+
+        if (mono_src) {
+            qt_render_bitmap(d->dpy, d->scrn, pixmap.x11PictureHandle(), d->picture,
+                             sx, sy, x, y, w, h, d->cpen);
+        } else {
+            XRenderComposite(d->dpy, d->composition_mode,
+                             pixmap.x11PictureHandle(), XNone, d->picture,
+                             sx, sy, 0, 0, x, y, w, h);
+        }
+#else
+        const int numTiles = (w / pixmap.width()) * (h / pixmap.height());
+        if (numTiles < 100) {
+            // this is essentially qt_draw_tile(), inlined for
+            // the XRenderComposite call
+            int yPos, xPos, drawH, drawW, yOff, xOff;
+            yPos = y;
+            yOff = sy;
+            while(yPos < y + h) {
+                drawH = pixmap.height() - yOff;    // Cropping first row
+                if (yPos + drawH > y + h)        // Cropping last row
+                    drawH = y + h - yPos;
+                xPos = x;
+                xOff = sx;
+                while(xPos < x + w) {
+                    drawW = pixmap.width() - xOff; // Cropping first column
+                    if (xPos + drawW > x + w)    // Cropping last column
+                        drawW = x + w - xPos;
+                    if (mono_src) {
+                        qt_render_bitmap(d->dpy, d->scrn, pixmap.x11PictureHandle(), d->picture,
+                                         xOff, yOff, xPos, yPos, drawW, drawH, d->cpen);
+                    } else {
+                        XRenderComposite(d->dpy, d->composition_mode,
+                                         pixmap.x11PictureHandle(), XNone, d->picture,
+                                         xOff, yOff, 0, 0, xPos, yPos, drawW, drawH);
+                    }
+                    xPos += drawW;
+                    xOff = 0;
+                }
+                yPos += drawH;
+                yOff = 0;
+            }
+        } else {
+            w = qMin(w, d->pdev->width() - x);
+            h = qMin(h, d->pdev->height() - y);
+            if (w <= 0 || h <= 0)
+                return;
+
+            const int pw = w + sx;
+            const int ph = h + sy;
+            QPixmap pm(pw, ph);
+            if (pixmap.hasAlpha() || mono_src)
+                pm.fill(Qt::transparent);
+
+            const int mode = pixmap.hasAlpha() ? PictOpOver : PictOpSrc;
+            const ::Picture pmPicture = pm.x11PictureHandle();
+
+            // first tile
+            XRenderComposite(d->dpy, mode,
+                             pixmap.x11PictureHandle(), XNone, pmPicture,
+                             0, 0, 0, 0, 0, 0, qMin(pw, pixmap.width()), qMin(ph, pixmap.height()));
+
+            // first row of tiles
+            int xPos = pixmap.width();
+            const int sh = qMin(ph, pixmap.height());
+            while (xPos < pw) {
+                const int sw = qMin(xPos, pw - xPos);
+                XRenderComposite(d->dpy, mode,
+                                 pmPicture, XNone, pmPicture,
+                                 0, 0, 0, 0, xPos, 0, sw, sh);
+                xPos *= 2;
+            }
+
+            // remaining rows
+            int yPos = pixmap.height();
+            const int sw = pw;
+            while (yPos < ph) {
+                const int sh = qMin(yPos, ph - yPos);
+                XRenderComposite(d->dpy, mode,
+                                 pmPicture, XNone, pmPicture,
+                                 0, 0, 0, 0, 0, yPos, sw, sh);
+                yPos *= 2;
+            }
+
+            // composite
+            if (mono_src)
+                qt_render_bitmap(d->dpy, d->scrn, pmPicture, d->picture,
+                                 sx, sy, x, y, w, h, d->cpen);
+            else
+                XRenderComposite(d->dpy, d->composition_mode,
+                                 pmPicture, XNone, d->picture,
+                                 sx, sy, 0, 0, x, y, w, h);
+        }
+#endif
+    } else
+#endif // !QT_NO_XRENDER
+        if (pixmap.depth() > 1 && !static_cast<QX11PixmapData*>(pixmap.data.data())->x11_mask) {
+            XSetTile(d->dpy, d->gc, pixmap.handle());
+            XSetFillStyle(d->dpy, d->gc, FillTiled);
+            XSetTSOrigin(d->dpy, d->gc, x-sx, y-sy);
+            XFillRectangle(d->dpy, d->hd, d->gc, x, y, w, h);
+            XSetTSOrigin(d->dpy, d->gc, 0, 0);
+            XSetFillStyle(d->dpy, d->gc, FillSolid);
+        } else {
+            qt_draw_tile(this, x, y, w, h, pixmap, sx, sy);
+        }
+}
+
+void QX11PaintEngine::drawTextItem(const QPointF &p, const QTextItem &textItem)
+{
+    const QTextItemInt &ti = static_cast<const QTextItemInt &>(textItem);
+
+    switch(ti.fontEngine->type()) {
+    case QFontEngine::TestFontEngine:
+    case QFontEngine::Box:
+        d_func()->drawBoxTextItem(p, ti);
+        break;
+    case QFontEngine::XLFD:
+        drawXLFD(p, ti);
+        break;
+#ifndef QT_NO_FONTCONFIG
+    case QFontEngine::Freetype:
+        drawFreetype(p, ti);
+        break;
+#endif
+    default:
+        Q_ASSERT(false);
+    }
+}
+
+void QX11PaintEngine::drawXLFD(const QPointF &p, const QTextItemInt &ti)
+{
+    Q_D(QX11PaintEngine);
+
+    if (d->txop > QTransform::TxTranslate) {
+        // XServer or font don't support server side transformations, need to do it by hand
+        QPaintEngine::drawTextItem(p, ti);
+        return;
+    }
+
+    if (!ti.glyphs.numGlyphs)
+        return;
+
+    QVarLengthArray<QFixedPoint> positions;
+    QVarLengthArray<glyph_t> glyphs;
+    QTransform matrix = d->matrix;
+    matrix.translate(p.x(), p.y());
+    ti.fontEngine->getGlyphPositions(ti.glyphs, matrix, ti.flags, glyphs, positions);
+    if (glyphs.size() == 0)
+        return;
+
+    QFontEngineXLFD *xlfd = static_cast<QFontEngineXLFD *>(ti.fontEngine);
+    Qt::HANDLE font_id = xlfd->fontStruct()->fid;
+
+    XSetFont(d->dpy, d->gc, font_id);
+
+    const QFixed offs = QFixed::fromReal(aliasedCoordinateDelta);
+    for (int i = 0; i < glyphs.size(); i++) {
+        int xp = qRound(positions[i].x + offs);
+        int yp = qRound(positions[i].y + offs);
+        if (xp < SHRT_MAX && xp > SHRT_MIN &&  yp > SHRT_MIN && yp < SHRT_MAX) {
+            XChar2b ch;
+            ch.byte1 = glyphs[i] >> 8;
+            ch.byte2 = glyphs[i] & 0xff;
+            XDrawString16(d->dpy, d->hd, d->gc, xp, yp, &ch, 1);
+        }
+    }
+}
+
+#ifndef QT_NO_FONTCONFIG
+static QPainterPath path_for_glyphs(const QVarLengthArray<glyph_t> &glyphs,
+                                    const QVarLengthArray<QFixedPoint> &positions,
+                                    const QFontEngineFT *ft)
+{
+    QPainterPath path;
+    path.setFillRule(Qt::WindingFill);
+    ft->lockFace();
+    int i = 0;
+    while (i < glyphs.size()) {
+        QFontEngineFT::Glyph *glyph = ft->loadGlyph(glyphs[i], QFontEngineFT::Format_Mono);
+        // #### fix case where we don't get a glyph
+        if (!glyph)
+            break;
+
+        Q_ASSERT(glyph->format == QFontEngineFT::Format_Mono);
+        int n = 0;
+        int h = glyph->height;
+        int xp = qRound(positions[i].x);
+        int yp = qRound(positions[i].y);
+
+        xp += glyph->x;
+        yp += -glyph->y + glyph->height;
+        int pitch = ((glyph->width + 31) & ~31) >> 3;
+
+        uchar *src = glyph->data;
+        while (h--) {
+            for (int x = 0; x < glyph->width; ++x) {
+                bool set = src[x >> 3] & (0x80 >> (x & 7));
+                if (set) {
+                    QRect r(xp + x, yp - h, 1, 1);
+                    while (x < glyph->width-1 && src[(x+1) >> 3] & (0x80 >> ((x+1) & 7))) {
+                        ++x;
+                        r.setRight(r.right()+1);
+                    }
+
+                    path.addRect(r);
+                    ++n;
+                }
+            }
+            src += pitch;
+        }
+        ++i;
+    }
+    ft->unlockFace();
+    return path;
+}
+
+void QX11PaintEngine::drawFreetype(const QPointF &p, const QTextItemInt &ti)
+{
+    Q_D(QX11PaintEngine);
+    if (!ti.glyphs.numGlyphs)
+        return;
+
+    QFontEngineX11FT *ft = static_cast<QFontEngineX11FT *>(ti.fontEngine);
+
+    if (!d->cpen.isSolid()) {
+        QPaintEngine::drawTextItem(p, ti);
+        return;
+    }
+
+    const bool xrenderPath = (X11->use_xrender
+                              && !(d->pdev->devType() == QInternal::Pixmap
+                                   && static_cast<const QPixmap *>(d->pdev)->data->pixelType() == QPixmapData::BitmapType));
+
+    QVarLengthArray<QFixedPoint> positions;
+    QVarLengthArray<glyph_t> glyphs;
+    QTransform matrix;
+
+    if (xrenderPath)
+        matrix = d->matrix;
+    matrix.translate(p.x(), p.y());
+    ft->getGlyphPositions(ti.glyphs, matrix, ti.flags, glyphs, positions);
+    if (glyphs.count() == 0)
+        return;
+
+#ifndef QT_NO_XRENDER
+    QFontEngineFT::QGlyphSet *set = ft->defaultGlyphs();
+    if (d->txop >= QTransform::TxScale && xrenderPath)
+        set = ft->loadTransformedGlyphSet(d->matrix);
+
+    if (!set || set->outline_drawing
+        || !ft->loadGlyphs(set, glyphs.constData(), glyphs.size(), positions.constData(), QFontEngineFT::Format_Render))
+    {
+        QPaintEngine::drawTextItem(p, ti);
+        return;
+    }
+
+    if (xrenderPath) {
+        GlyphSet glyphSet = set->id;
+        const QColor &pen = d->cpen.color();
+        ::Picture src = X11->getSolidFill(d->scrn, pen);
+        XRenderPictFormat *maskFormat = 0;
+        if (ft->xglyph_format != PictStandardA1)
+            maskFormat = XRenderFindStandardFormat(X11->display, ft->xglyph_format);
+
+        enum { t_min = SHRT_MIN, t_max = SHRT_MAX };
+
+        int i = 0;
+        for (; i < glyphs.size()
+                 && (positions[i].x < t_min || positions[i].x > t_max
+                     || positions[i].y < t_min || positions[i].y > t_max);
+             ++i)
+            ;
+
+        if (i >= glyphs.size())
+            return;
+        ++i;
+
+        QFixed xp = positions[i - 1].x;
+        QFixed yp = positions[i - 1].y;
+        QFixed offs = QFixed::fromReal(aliasedCoordinateDelta);
+
+        XGlyphElt32 elt;
+        elt.glyphset = glyphSet;
+        elt.chars = &glyphs[i - 1];
+        elt.nchars = 1;
+        elt.xOff = qRound(xp + offs);
+        elt.yOff = qRound(yp + offs);
+        for (; i < glyphs.size(); ++i) {
+            if (positions[i].x < t_min || positions[i].x > t_max
+                || positions[i].y < t_min || positions[i].y > t_max) {
+                break;
+            }
+            QFontEngineFT::Glyph *g = ft->cachedGlyph(glyphs[i - 1]);
+            if (g
+                && positions[i].x == xp + g->advance
+                && positions[i].y == yp
+                && elt.nchars < 253 // don't draw more than 253 characters as some X servers
+                                    // hang with it
+                ) {
+                elt.nchars++;
+                xp += g->advance;
+            } else {
+                xp = positions[i].x;
+                yp = positions[i].y;
+
+                XRenderCompositeText32(X11->display, PictOpOver, src, d->picture,
+                                       maskFormat, 0, 0, 0, 0,
+                                       &elt, 1);
+                elt.chars = &glyphs[i];
+                elt.nchars = 1;
+                elt.xOff = qRound(xp + offs);
+                elt.yOff = qRound(yp + offs);
+            }
+        }
+        XRenderCompositeText32(X11->display, PictOpOver, src, d->picture,
+                               maskFormat, 0, 0, 0, 0,
+                               &elt, 1);
+
+        return;
+
+    }
+#endif
+
+    QPainterPath path = path_for_glyphs(glyphs, positions, ft);
+    if (path.elementCount() <= 1)
+        return;
+    Q_ASSERT((path.elementCount() % 5) == 0);
+    if (d->txop >= QTransform::TxScale) {
+        painter()->save();
+        painter()->setBrush(d->cpen.brush());
+        painter()->setPen(Qt::NoPen);
+        painter()->drawPath(path);
+        painter()->restore();
+        return;
+    }
+
+    const int rectcount = 256;
+    XRectangle rects[rectcount];
+    int num_rects = 0;
+
+    QPoint delta(qRound(d->matrix.dx()), qRound(d->matrix.dy()));
+    QRect clip(d->polygonClipper.boundingRect());
+    for (int i=0; i < path.elementCount(); i+=5) {
+        int x = qRound(path.elementAt(i).x);
+        int y = qRound(path.elementAt(i).y);
+        int w = qRound(path.elementAt(i+1).x) - x;
+        int h = qRound(path.elementAt(i+2).y) - y;
+
+        QRect rect = QRect(x + delta.x(), y + delta.y(), w, h);
+        rect = rect.intersected(clip);
+        if (rect.isEmpty())
+            continue;
+
+        rects[num_rects].x = short(rect.x());
+        rects[num_rects].y = short(rect.y());
+        rects[num_rects].width = ushort(rect.width());
+        rects[num_rects].height = ushort(rect.height());
+        ++num_rects;
+        if (num_rects == rectcount) {
+            XFillRectangles(d->dpy, d->hd, d->gc, rects, num_rects);
+            num_rects = 0;
+        }
+    }
+    if (num_rects > 0)
+        XFillRectangles(d->dpy, d->hd, d->gc, rects, num_rects);
+
+}
+#endif // !QT_NO_XRENDER
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qpaintengine_x11_p.h b/src/gui/painting/qpaintengine_x11_p.h
new file mode 100644
index 0000000000..897c69f122
--- /dev/null
+++ b/src/gui/painting/qpaintengine_x11_p.h
@@ -0,0 +1,246 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPAINTENGINE_X11_P_H
+#define QPAINTENGINE_X11_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "QtGui/qpaintengine.h"
+#include "QtGui/qregion.h"
+#include "QtGui/qpen.h"
+#include "QtCore/qpoint.h"
+#include "private/qpaintengine_p.h"
+#include "private/qpainter_p.h"
+#include "private/qpolygonclipper_p.h"
+
+typedef unsigned long Picture;
+
+QT_BEGIN_NAMESPACE
+
+class QX11PaintEnginePrivate;
+class QFontEngineFT;
+class QXRenderTessellator;
+
+struct qt_float_point
+{
+    qreal x, y;
+};
+
+class QX11PaintEngine : public QPaintEngine
+{
+    Q_DECLARE_PRIVATE(QX11PaintEngine)
+public:
+    QX11PaintEngine();
+    ~QX11PaintEngine();
+
+    bool begin(QPaintDevice *pdev);
+    bool end();
+
+    void updateState(const QPaintEngineState &state);
+
+    void updatePen(const QPen &pen);
+    void updateBrush(const QBrush &brush, const QPointF &pt);
+    void updateRenderHints(QPainter::RenderHints hints);
+    void updateFont(const QFont &font);
+    void updateMatrix(const QTransform &matrix);
+    void updateClipRegion_dev(const QRegion &region, Qt::ClipOperation op);
+
+    void drawLines(const QLine *lines, int lineCount);
+    void drawLines(const QLineF *lines, int lineCount);
+
+    void drawRects(const QRect *rects, int rectCount);
+    void drawRects(const QRectF *rects, int rectCount);
+
+    void drawPoints(const QPoint *points, int pointCount);
+    void drawPoints(const QPointF *points, int pointCount);
+
+    void drawEllipse(const QRect &r);
+    void drawEllipse(const QRectF &r);
+
+    virtual void drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode);
+    inline void drawPolygon(const QPoint *points, int pointCount, PolygonDrawMode mode)
+        { QPaintEngine::drawPolygon(points, pointCount, mode); }
+
+    void drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr);
+    void drawTiledPixmap(const QRectF &r, const QPixmap &pixmap, const QPointF &s);
+    void drawPath(const QPainterPath &path);
+    void drawTextItem(const QPointF &p, const QTextItem &textItem);
+    void drawImage(const QRectF &r, const QImage &img, const QRectF &sr,
+                   Qt::ImageConversionFlags flags = Qt::AutoColor);
+
+    virtual Qt::HANDLE handle() const;
+    inline Type type() const { return QPaintEngine::X11; }
+
+    QPainter::RenderHints supportedRenderHints() const;
+
+protected:
+    QX11PaintEngine(QX11PaintEnginePrivate &dptr);
+
+    void drawXLFD(const QPointF &p, const QTextItemInt &si);
+#ifndef QT_NO_FONTCONFIG
+    void drawFreetype(const QPointF &p, const QTextItemInt &si);
+#endif
+
+    friend class QPixmap;
+    friend class QFontEngineBox;
+    friend Q_GUI_EXPORT GC qt_x11_get_pen_gc(QPainter *);
+    friend Q_GUI_EXPORT GC qt_x11_get_brush_gc(QPainter *);
+
+private:
+    Q_DISABLE_COPY(QX11PaintEngine)
+};
+
+class QX11PaintEnginePrivate : public QPaintEnginePrivate
+{
+    Q_DECLARE_PUBLIC(QX11PaintEngine)
+public:
+    QX11PaintEnginePrivate()
+    {
+        scrn = -1;
+        hd = 0;
+        picture = 0;
+        gc = gc_brush = 0;
+        dpy  = 0;
+        xinfo = 0;
+        txop = QTransform::TxNone;
+        has_clipping = false;
+        render_hints = 0;
+        xform_scale = 1;
+#ifndef QT_NO_XRENDER
+        tessellator = 0;
+#endif
+    }
+    enum GCMode {
+        PenGC,
+        BrushGC
+    };
+
+    void init();
+    void fillPolygon_translated(const QPointF *points, int pointCount, GCMode gcMode,
+                                QPaintEngine::PolygonDrawMode mode);
+    void fillPolygon_dev(const QPointF *points, int pointCount, GCMode gcMode,
+                         QPaintEngine::PolygonDrawMode mode);
+    void fillPath(const QPainterPath &path, GCMode gcmode, bool transform);
+    void strokePolygon_dev(const QPointF *points, int pointCount, bool close);
+    void strokePolygon_translated(const QPointF *points, int pointCount, bool close);
+    void setupAdaptedOrigin(const QPoint &p);
+    void resetAdaptedOrigin();
+    void decidePathFallback() {
+        use_path_fallback = has_alpha_brush
+                            || has_alpha_pen
+                            || has_custom_pen
+                            || has_complex_xform
+                            || (render_hints & QPainter::Antialiasing);
+    }
+    void decideCoordAdjust() {
+        adjust_coords = !(render_hints & QPainter::Antialiasing)
+                        && (has_alpha_pen
+                            || (has_alpha_brush && has_pen && !has_alpha_pen)
+                            || (cpen.style() > Qt::SolidLine));
+    }
+    void clipPolygon_dev(const QPolygonF &poly, QPolygonF *clipped_poly);
+    void systemStateChanged();
+
+    Display *dpy;
+    int scrn;
+    int pdev_depth;
+    Qt::HANDLE hd;
+    QPixmap brush_pm;
+#if !defined (QT_NO_XRENDER)
+    Qt::HANDLE picture;
+    Qt::HANDLE current_brush;
+    QPixmap bitmap_texture;
+    int composition_mode;
+#else
+    Qt::HANDLE picture;
+#endif
+    GC gc;
+    GC gc_brush;
+
+    QPen cpen;
+    QBrush cbrush;
+    QRegion crgn;
+    QTransform matrix;
+    qreal opacity;
+
+    uint has_complex_xform : 1;
+    uint has_scaling_xform : 1;
+    uint has_non_scaling_xform : 1;
+    uint has_custom_pen : 1;
+    uint use_path_fallback : 1;
+    uint adjust_coords : 1;
+    uint has_clipping : 1;
+    uint adapted_brush_origin : 1;
+    uint adapted_pen_origin : 1;
+    uint has_pen : 1;
+    uint has_brush : 1;
+    uint has_texture : 1;
+    uint has_alpha_texture : 1;
+    uint has_pattern : 1;
+    uint has_alpha_pen : 1;
+    uint has_alpha_brush : 1;
+    uint render_hints;
+
+    const QX11Info *xinfo;
+    QPointF bg_origin;
+    QTransform::TransformationType txop;
+    qreal xform_scale;
+    QPolygonClipper<qt_float_point, qt_float_point, float> polygonClipper;
+
+    int xlibMaxLinePoints;
+#ifndef QT_NO_XRENDER
+    QXRenderTessellator *tessellator;
+#endif
+};
+
+QT_END_NAMESPACE
+
+#endif // QPAINTENGINE_X11_P_H
diff --git a/src/gui/painting/qpaintengineex.cpp b/src/gui/painting/qpaintengineex.cpp
new file mode 100644
index 0000000000..509fb77d25
--- /dev/null
+++ b/src/gui/painting/qpaintengineex.cpp
@@ -0,0 +1,1015 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qpaintengineex_p.h"
+#include "qpainter_p.h"
+#include "qstroker_p.h"
+#include "qbezier_p.h"
+#include <private/qpainterpath_p.h>
+
+#include <qvarlengtharray.h>
+#include <qdebug.h>
+
+
+QT_BEGIN_NAMESPACE
+
+/*******************************************************************************
+ *
+ * class QVectorPath
+ *
+ */
+QVectorPath::~QVectorPath()
+{
+    if (m_hints & ShouldUseCacheHint) {
+        CacheEntry *e = m_cache;
+        while (e) {
+            if (e->data)
+                e->cleanup(e->engine, e->data);
+            CacheEntry *n = e->next;
+            delete e;
+            e = n;
+        }
+    }
+}
+
+
+QRectF QVectorPath::controlPointRect() const
+{
+    if (m_hints & ControlPointRect)
+        return QRectF(QPointF(m_cp_rect.x1, m_cp_rect.y1), QPointF(m_cp_rect.x2, m_cp_rect.y2));
+
+    if (m_count == 0) {
+        m_cp_rect.x1 = m_cp_rect.x2 = m_cp_rect.y1 = m_cp_rect.y2 = 0;
+        m_hints |= ControlPointRect;
+        return QRectF(QPointF(m_cp_rect.x1, m_cp_rect.y1), QPointF(m_cp_rect.x2, m_cp_rect.y2));
+    }
+    Q_ASSERT(m_points && m_count > 0);
+
+    const qreal *pts = m_points;
+    m_cp_rect.x1 = m_cp_rect.x2 = *pts;
+    ++pts;
+    m_cp_rect.y1 = m_cp_rect.y2 = *pts;
+    ++pts;
+
+    const qreal *epts = m_points + (m_count << 1);
+    while (pts < epts) {
+        qreal x = *pts;
+        if (x < m_cp_rect.x1) m_cp_rect.x1 = x;
+        else if (x > m_cp_rect.x2) m_cp_rect.x2 = x;
+        ++pts;
+
+        qreal y = *pts;
+        if (y < m_cp_rect.y1) m_cp_rect.y1 = y;
+        else if (y > m_cp_rect.y2) m_cp_rect.y2 = y;
+        ++pts;
+    }
+
+    m_hints |= ControlPointRect;
+    return QRectF(QPointF(m_cp_rect.x1, m_cp_rect.y1), QPointF(m_cp_rect.x2, m_cp_rect.y2));
+}
+
+
+QVectorPath::CacheEntry *QVectorPath::addCacheData(QPaintEngineEx *engine, void *data,
+                                                   qvectorpath_cache_cleanup cleanup) const{
+    Q_ASSERT(!lookupCacheData(engine));
+    if ((m_hints & IsCachedHint) == 0) {
+        m_cache = 0;
+        m_hints |= IsCachedHint;
+    }
+    CacheEntry *e = new CacheEntry;
+    e->engine = engine;
+    e->data = data;
+    e->cleanup = cleanup;
+    e->next = m_cache;
+    m_cache = e;
+    return m_cache;
+}
+
+
+const QVectorPath &qtVectorPathForPath(const QPainterPath &path)
+{
+    Q_ASSERT(path.d_func());
+    return path.d_func()->vectorPath();
+}
+
+#ifndef QT_NO_DEBUG_STREAM
+QDebug Q_GUI_EXPORT &operator<<(QDebug &s, const QVectorPath &path)
+{
+    QRectF rf = path.controlPointRect();
+    s << "QVectorPath(size:" << path.elementCount()
+      << " hints:" << hex << path.hints()
+      << rf << ')';
+    return s;
+}
+#endif
+
+/*******************************************************************************
+ *
+ * class QPaintEngineExPrivate:
+ *
+ */
+
+
+struct StrokeHandler {
+    StrokeHandler(int reserve) : pts(reserve), types(reserve) {}
+    QDataBuffer<qreal> pts;
+    QDataBuffer<QPainterPath::ElementType> types;
+};
+
+
+QPaintEngineExPrivate::QPaintEngineExPrivate()
+    : dasher(&stroker),
+      strokeHandler(0),
+      activeStroker(0),
+      strokerPen(Qt::NoPen)
+{
+}
+
+
+QPaintEngineExPrivate::~QPaintEngineExPrivate()
+{
+    delete strokeHandler;
+}
+
+
+void QPaintEngineExPrivate::replayClipOperations()
+{
+    Q_Q(QPaintEngineEx);
+
+    QPainter *p = q->painter();
+    if (!p || !p->d_ptr)
+        return;
+
+    QList<QPainterClipInfo> clipInfo = p->d_ptr->state->clipInfo;
+
+    QTransform transform = q->state()->matrix;
+
+    for (int i = 0; i <  clipInfo.size(); ++i) {
+        const QPainterClipInfo &info = clipInfo.at(i);
+
+        if (info.matrix != q->state()->matrix) {
+            q->state()->matrix = info.matrix;
+            q->transformChanged();
+        }
+
+        switch (info.clipType) {
+        case QPainterClipInfo::RegionClip:
+            q->clip(info.region, info.operation);
+            break;
+        case QPainterClipInfo::PathClip:
+            q->clip(info.path, info.operation);
+            break;
+        case QPainterClipInfo::RectClip:
+            q->clip(info.rect, info.operation);
+            break;
+        case QPainterClipInfo::RectFClip: {
+            qreal right = info.rectf.x() + info.rectf.width();
+            qreal bottom = info.rectf.y() + info.rectf.height();
+            qreal pts[] = { info.rectf.x(), info.rectf.y(),
+                            right, info.rectf.y(),
+                            right, bottom,
+                            info.rectf.x(), bottom };
+            QVectorPath vp(pts, 4, 0, QVectorPath::RectangleHint);
+            q->clip(vp, info.operation);
+            break;
+            }
+        }
+    }
+
+    if (transform != q->state()->matrix) {
+        q->state()->matrix = transform;
+        q->transformChanged();
+    }
+}
+
+
+bool QPaintEngineExPrivate::hasClipOperations() const
+{
+    Q_Q(const QPaintEngineEx);
+
+    QPainter *p = q->painter();
+    if (!p || !p->d_ptr)
+        return false;
+
+    QList<QPainterClipInfo> clipInfo = p->d_ptr->state->clipInfo;
+
+    return !clipInfo.isEmpty();
+}
+
+/*******************************************************************************
+ *
+ * class QPaintEngineEx:
+ *
+ */
+
+static QPainterPath::ElementType qpaintengineex_ellipse_types[] = {
+    QPainterPath::MoveToElement,
+    QPainterPath::CurveToElement,
+    QPainterPath::CurveToDataElement,
+    QPainterPath::CurveToDataElement,
+
+    QPainterPath::CurveToElement,
+    QPainterPath::CurveToDataElement,
+    QPainterPath::CurveToDataElement,
+
+    QPainterPath::CurveToElement,
+    QPainterPath::CurveToDataElement,
+    QPainterPath::CurveToDataElement,
+
+    QPainterPath::CurveToElement,
+    QPainterPath::CurveToDataElement,
+    QPainterPath::CurveToDataElement
+};
+
+static QPainterPath::ElementType qpaintengineex_line_types_16[] = {
+    QPainterPath::MoveToElement, QPainterPath::LineToElement,
+    QPainterPath::MoveToElement, QPainterPath::LineToElement,
+    QPainterPath::MoveToElement, QPainterPath::LineToElement,
+    QPainterPath::MoveToElement, QPainterPath::LineToElement,
+    QPainterPath::MoveToElement, QPainterPath::LineToElement,
+    QPainterPath::MoveToElement, QPainterPath::LineToElement,
+    QPainterPath::MoveToElement, QPainterPath::LineToElement,
+    QPainterPath::MoveToElement, QPainterPath::LineToElement,
+    QPainterPath::MoveToElement, QPainterPath::LineToElement,
+    QPainterPath::MoveToElement, QPainterPath::LineToElement,
+    QPainterPath::MoveToElement, QPainterPath::LineToElement,
+    QPainterPath::MoveToElement, QPainterPath::LineToElement,
+    QPainterPath::MoveToElement, QPainterPath::LineToElement,
+    QPainterPath::MoveToElement, QPainterPath::LineToElement,
+    QPainterPath::MoveToElement, QPainterPath::LineToElement,
+    QPainterPath::MoveToElement, QPainterPath::LineToElement
+};
+
+static QPainterPath::ElementType qpaintengineex_rect4_types_32[] = {
+    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 1
+    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 2
+    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 3
+    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 4
+    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 5
+    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 6
+    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 7
+    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 8
+    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 9
+    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 10
+    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 11
+    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 12
+    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 13
+    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 14
+    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 15
+    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 16
+    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 17
+    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 18
+    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 19
+    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 20
+    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 21
+    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 22
+    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 23
+    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 24
+    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 25
+    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 26
+    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 27
+    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 28
+    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 29
+    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 30
+    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 31
+    QPainterPath::MoveToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, QPainterPath::LineToElement, // 32
+};
+
+
+static QPainterPath::ElementType qpaintengineex_roundedrect_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
+};
+
+
+
+static void qpaintengineex_moveTo(qreal x, qreal y, void *data) {
+    ((StrokeHandler *) data)->pts.add(x);
+    ((StrokeHandler *) data)->pts.add(y);
+    ((StrokeHandler *) data)->types.add(QPainterPath::MoveToElement);
+}
+
+static void qpaintengineex_lineTo(qreal x, qreal y, void *data) {
+    ((StrokeHandler *) data)->pts.add(x);
+    ((StrokeHandler *) data)->pts.add(y);
+    ((StrokeHandler *) data)->types.add(QPainterPath::LineToElement);
+}
+
+static void qpaintengineex_cubicTo(qreal c1x, qreal c1y, qreal c2x, qreal c2y, qreal ex, qreal ey, void *data) {
+    ((StrokeHandler *) data)->pts.add(c1x);
+    ((StrokeHandler *) data)->pts.add(c1y);
+    ((StrokeHandler *) data)->types.add(QPainterPath::CurveToElement);
+
+    ((StrokeHandler *) data)->pts.add(c2x);
+    ((StrokeHandler *) data)->pts.add(c2y);
+    ((StrokeHandler *) data)->types.add(QPainterPath::CurveToDataElement);
+
+    ((StrokeHandler *) data)->pts.add(ex);
+    ((StrokeHandler *) data)->pts.add(ey);
+    ((StrokeHandler *) data)->types.add(QPainterPath::CurveToDataElement);
+}
+
+QPaintEngineEx::QPaintEngineEx()
+    : QPaintEngine(*new QPaintEngineExPrivate, AllFeatures)
+{
+    extended = true;
+}
+
+QPaintEngineEx::QPaintEngineEx(QPaintEngineExPrivate &data)
+    : QPaintEngine(data, AllFeatures)
+{
+    extended = true;
+}
+
+QPainterState *QPaintEngineEx::createState(QPainterState *orig) const
+{
+    if (!orig)
+        return new QPainterState;
+    return new QPainterState(orig);
+}
+
+Q_GUI_EXPORT extern bool qt_scaleForTransform(const QTransform &transform, qreal *scale); // qtransform.cpp
+
+void QPaintEngineEx::stroke(const QVectorPath &path, const QPen &pen)
+{
+#ifdef QT_DEBUG_DRAW
+    qDebug() << "QPaintEngineEx::stroke()" << pen;
+#endif
+
+    Q_D(QPaintEngineEx);
+
+    if (path.isEmpty())
+        return;
+
+    if (!d->strokeHandler) {
+        d->strokeHandler = new StrokeHandler(path.elementCount()+4);
+        d->stroker.setMoveToHook(qpaintengineex_moveTo);
+        d->stroker.setLineToHook(qpaintengineex_lineTo);
+        d->stroker.setCubicToHook(qpaintengineex_cubicTo);
+    }
+
+    if (!qpen_fast_equals(pen, d->strokerPen)) {
+        d->strokerPen = pen;
+        d->stroker.setJoinStyle(pen.joinStyle());
+        d->stroker.setCapStyle(pen.capStyle());
+        d->stroker.setMiterLimit(pen.miterLimit());
+        qreal penWidth = pen.widthF();
+        if (penWidth == 0)
+            d->stroker.setStrokeWidth(1);
+        else
+            d->stroker.setStrokeWidth(penWidth);
+
+        Qt::PenStyle style = pen.style();
+        if (style == Qt::SolidLine) {
+            d->activeStroker = &d->stroker;
+        } else if (style == Qt::NoPen) {
+            d->activeStroker = 0;
+        } else {
+            d->dasher.setDashPattern(pen.dashPattern());
+            d->dasher.setDashOffset(pen.dashOffset());
+            d->activeStroker = &d->dasher;
+        }
+    }
+
+    if (!d->activeStroker) {
+        return;
+    }
+
+    if (pen.style() > Qt::SolidLine) {
+        if (pen.isCosmetic()) {
+            d->activeStroker->setClipRect(d->exDeviceRect);
+        } else {
+            QRectF clipRect = state()->matrix.inverted().mapRect(QRectF(d->exDeviceRect));
+            d->activeStroker->setClipRect(clipRect);
+        }
+    }
+
+    const QPainterPath::ElementType *types = path.elements();
+    const qreal *points = path.points();
+    int pointCount = path.elementCount();
+
+    const qreal *lastPoint = points + (pointCount<<1);
+
+    d->strokeHandler->types.reset();
+    d->strokeHandler->pts.reset();
+
+    // Some engines might decide to optimize for the non-shape hint later on...
+    uint flags = QVectorPath::WindingFill;
+
+    if (path.elementCount() > 2)
+        flags |= QVectorPath::NonConvexShapeMask;
+
+    if (d->stroker.capStyle() == Qt::RoundCap || d->stroker.joinStyle() == Qt::RoundJoin)
+        flags |= QVectorPath::CurvedShapeMask;
+
+    // ### Perspective Xforms are currently not supported...
+    if (!pen.isCosmetic()) {
+        // We include cosmetic pens in this case to avoid having to
+        // change the current transform. Normal transformed,
+        // non-cosmetic pens will be transformed as part of fill
+        // later, so they are also covered here..
+        d->activeStroker->setCurveThresholdFromTransform(state()->matrix);
+        d->activeStroker->begin(d->strokeHandler);
+        if (types) {
+            while (points < lastPoint) {
+                switch (*types) {
+                case QPainterPath::MoveToElement:
+                    d->activeStroker->moveTo(points[0], points[1]);
+                    points += 2;
+                    ++types;
+                    break;
+                case QPainterPath::LineToElement:
+                    d->activeStroker->lineTo(points[0], points[1]);
+                    points += 2;
+                    ++types;
+                    break;
+                case QPainterPath::CurveToElement:
+                    d->activeStroker->cubicTo(points[0], points[1],
+                                              points[2], points[3],
+                                              points[4], points[5]);
+                    points += 6;
+                    types += 3;
+                    flags |= QVectorPath::CurvedShapeMask;
+                    break;
+                default:
+                    break;
+                }
+            }
+            if (path.hasImplicitClose())
+                d->activeStroker->lineTo(path.points()[0], path.points()[1]);
+
+        } else {
+            d->activeStroker->moveTo(points[0], points[1]);
+            points += 2;
+            while (points < lastPoint) {
+                d->activeStroker->lineTo(points[0], points[1]);
+                points += 2;
+            }
+            if (path.hasImplicitClose())
+                d->activeStroker->lineTo(path.points()[0], path.points()[1]);
+        }
+        d->activeStroker->end();
+
+        if (!d->strokeHandler->types.size()) // an empty path...
+            return;
+
+        QVectorPath strokePath(d->strokeHandler->pts.data(),
+                               d->strokeHandler->types.size(),
+                               d->strokeHandler->types.data(),
+                               flags);
+        fill(strokePath, pen.brush());
+    } else {
+        // For cosmetic pens we need a bit of trickery... We to process xform the input points
+        if (state()->matrix.type() >= QTransform::TxProject) {
+            QPainterPath painterPath = state()->matrix.map(path.convertToPainterPath());
+            d->activeStroker->strokePath(painterPath, d->strokeHandler, QTransform());
+        } else {
+            d->activeStroker->setCurveThresholdFromTransform(QTransform());
+            d->activeStroker->begin(d->strokeHandler);
+            if (types) {
+                while (points < lastPoint) {
+                    switch (*types) {
+                    case QPainterPath::MoveToElement: {
+                        QPointF pt = (*(QPointF *) points) * state()->matrix;
+                        d->activeStroker->moveTo(pt.x(), pt.y());
+                        points += 2;
+                        ++types;
+                        break;
+                    }
+                    case QPainterPath::LineToElement: {
+                        QPointF pt = (*(QPointF *) points) * state()->matrix;
+                        d->activeStroker->lineTo(pt.x(), pt.y());
+                        points += 2;
+                        ++types;
+                        break;
+                    }
+                    case QPainterPath::CurveToElement: {
+                        QPointF c1 = ((QPointF *) points)[0] * state()->matrix;
+                        QPointF c2 = ((QPointF *) points)[1] * state()->matrix;
+                        QPointF e =  ((QPointF *) points)[2] * state()->matrix;
+                        d->activeStroker->cubicTo(c1.x(), c1.y(), c2.x(), c2.y(), e.x(), e.y());
+                        points += 6;
+                        types += 3;
+                        flags |= QVectorPath::CurvedShapeMask;
+                        break;
+                    }
+                    default:
+                        break;
+                    }
+                }
+                if (path.hasImplicitClose()) {
+                    QPointF pt = * ((QPointF *) path.points()) * state()->matrix;
+                    d->activeStroker->lineTo(pt.x(), pt.y());
+                }
+
+            } else {
+                QPointF p = ((QPointF *)points)[0] * state()->matrix;
+                d->activeStroker->moveTo(p.x(), p.y());
+                points += 2;
+                while (points < lastPoint) {
+                    QPointF p = ((QPointF *)points)[0] * state()->matrix;
+                    d->activeStroker->lineTo(p.x(), p.y());
+                    points += 2;
+                }
+                if (path.hasImplicitClose())
+                    d->activeStroker->lineTo(p.x(), p.y());
+            }
+            d->activeStroker->end();
+        }
+
+        QVectorPath strokePath(d->strokeHandler->pts.data(),
+                               d->strokeHandler->types.size(),
+                               d->strokeHandler->types.data(),
+                               flags);
+
+        QTransform xform = state()->matrix;
+        state()->matrix = QTransform();
+        transformChanged();
+
+        QBrush brush = pen.brush();
+        if (qbrush_style(brush) != Qt::SolidPattern)
+            brush.setTransform(brush.transform() * xform);
+
+        fill(strokePath, brush);
+
+        state()->matrix = xform;
+        transformChanged();
+    }
+}
+
+void QPaintEngineEx::draw(const QVectorPath &path)
+{
+    const QBrush &brush = state()->brush;
+    if (qbrush_style(brush) != Qt::NoBrush)
+        fill(path, brush);
+
+    const QPen &pen = state()->pen;
+    if (qpen_style(pen) != Qt::NoPen && qbrush_style(qpen_brush(pen)) != Qt::NoBrush)
+        stroke(path, pen);
+}
+
+
+void QPaintEngineEx::clip(const QRect &r, Qt::ClipOperation op)
+{
+    qreal right = r.x() + r.width();
+    qreal bottom = r.y() + r.height();
+    qreal pts[] = { qreal(r.x()), qreal(r.y()),
+                    right, qreal(r.y()),
+                    right, bottom,
+                    qreal(r.x()), bottom,
+                    qreal(r.x()), qreal(r.y()) };
+    QVectorPath vp(pts, 5, 0, QVectorPath::RectangleHint);
+    clip(vp, op);
+}
+
+void QPaintEngineEx::clip(const QRegion &region, Qt::ClipOperation op)
+{
+    if (region.rectCount() == 1)
+        clip(region.boundingRect(), op);
+
+    QVector<QRect> rects = region.rects();
+    if (rects.size() <= 32) {
+        qreal pts[2*32*4];
+        int pos = 0;
+        for (QVector<QRect>::const_iterator i = rects.constBegin(); i != rects.constEnd(); ++i) {
+            qreal x1 = i->x();
+            qreal y1 = i->y();
+            qreal x2 = i->x() + i->width();
+            qreal y2 = i->y() + i->height();
+
+            pts[pos++] = x1;
+            pts[pos++] = y1;
+
+            pts[pos++] = x2;
+            pts[pos++] = y1;
+
+            pts[pos++] = x2;
+            pts[pos++] = y2;
+
+            pts[pos++] = x1;
+            pts[pos++] = y2;
+        }
+        QVectorPath vp(pts, rects.size() * 4, qpaintengineex_rect4_types_32);
+        clip(vp, op);
+    } else {
+        QVarLengthArray<qreal> pts(rects.size() * 2 * 4);
+        QVarLengthArray<QPainterPath::ElementType> types(rects.size() * 4);
+        int ppos = 0;
+        int tpos = 0;
+
+        for (QVector<QRect>::const_iterator i = rects.constBegin(); i != rects.constEnd(); ++i) {
+            qreal x1 = i->x();
+            qreal y1 = i->y();
+            qreal x2 = i->x() + i->width();
+            qreal y2 = i->y() + i->height();
+
+            pts[ppos++] = x1;
+            pts[ppos++] = y1;
+
+            pts[ppos++] = x2;
+            pts[ppos++] = y1;
+
+            pts[ppos++] = x2;
+            pts[ppos++] = y2;
+
+            pts[ppos++] = x1;
+            pts[ppos++] = y2;
+
+            types[tpos++] = QPainterPath::MoveToElement;
+            types[tpos++] = QPainterPath::LineToElement;
+            types[tpos++] = QPainterPath::LineToElement;
+            types[tpos++] = QPainterPath::LineToElement;
+        }
+
+        QVectorPath vp(pts.data(), rects.size() * 4, types.data());
+        clip(vp, op);
+    }
+
+}
+
+void QPaintEngineEx::clip(const QPainterPath &path, Qt::ClipOperation op)
+{
+    if (path.isEmpty()) {
+        QVectorPath vp(0, 0);
+        clip(vp, op);
+    } else {
+        clip(qtVectorPathForPath(path), op);
+    }
+}
+
+void QPaintEngineEx::fillRect(const QRectF &r, const QBrush &brush)
+{
+    qreal pts[] = { r.x(), r.y(), r.x() + r.width(), r.y(),
+                    r.x() + r.width(), r.y() + r.height(), r.x(), r.y() + r.height() };
+    QVectorPath vp(pts, 4, 0, QVectorPath::RectangleHint);
+    fill(vp, brush);
+}
+
+void QPaintEngineEx::fillRect(const QRectF &r, const QColor &color)
+{
+    fillRect(r, QBrush(color));
+}
+
+void QPaintEngineEx::drawRects(const QRect *rects, int rectCount)
+{
+    for (int i=0; i<rectCount; ++i) {
+        const QRect &r = rects[i];
+        // ### Is there a one off here?
+        qreal right = r.x() + r.width();
+        qreal bottom = r.y() + r.height();
+        qreal pts[] = { qreal(r.x()), qreal(r.y()),
+                        right, qreal(r.y()),
+                        right, bottom,
+                        qreal(r.x()), bottom,
+                        qreal(r.x()), qreal(r.y()) };
+        QVectorPath vp(pts, 5, 0, QVectorPath::RectangleHint);
+        draw(vp);
+    }
+}
+
+void QPaintEngineEx::drawRects(const QRectF *rects, int rectCount)
+{
+    for (int i=0; i<rectCount; ++i) {
+        const QRectF &r = rects[i];
+        qreal right = r.x() + r.width();
+        qreal bottom = r.y() + r.height();
+        qreal pts[] = { r.x(), r.y(),
+                        right, r.y(),
+                        right, bottom,
+                        r.x(), bottom,
+                        r.x(), r.y() };
+        QVectorPath vp(pts, 5, 0, QVectorPath::RectangleHint);
+        draw(vp);
+    }
+}
+
+
+void QPaintEngineEx::drawRoundedRect(const QRectF &rect, qreal xRadius, qreal yRadius,
+                                     Qt::SizeMode mode)
+{
+    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 + (1 - KAPPA) * yRadius,           // CurveTo
+        x1 + (1 - KAPPA) * xRadius, y1,
+        x1 + xRadius, y1
+    };
+
+    QVectorPath path(pts, 17, qpaintengineex_roundedrect_types, QVectorPath::RoundedRectHint);
+    draw(path);
+}
+
+
+
+void QPaintEngineEx::drawLines(const QLine *lines, int lineCount)
+{
+    int elementCount = lineCount << 1;
+    while (elementCount > 0) {
+        int count = qMin(elementCount, 32);
+
+        qreal pts[64];
+        int count2 = count<<1;
+#ifdef Q_WS_MAC
+        for (int i=0; i<count2; i+=2) {
+            pts[i] = ((int *) lines)[i+1];
+            pts[i+1] = ((int *) lines)[i];
+        }
+#else
+        for (int i=0; i<count2; ++i)
+            pts[i] = ((int *) lines)[i];
+#endif
+
+        QVectorPath path(pts, count, qpaintengineex_line_types_16, QVectorPath::LinesHint);
+        stroke(path, state()->pen);
+
+        elementCount -= 32;
+        lines += 16;
+    }
+}
+
+void QPaintEngineEx::drawLines(const QLineF *lines, int lineCount)
+{
+    int elementCount = lineCount << 1;
+    while (elementCount > 0) {
+        int count = qMin(elementCount, 32);
+
+        QVectorPath path((qreal *) lines, count, qpaintengineex_line_types_16,
+                         QVectorPath::LinesHint);
+        stroke(path, state()->pen);
+
+        elementCount -= 32;
+        lines += 16;
+    }
+}
+
+void QPaintEngineEx::drawEllipse(const QRectF &r)
+{
+    qreal pts[26]; // QPointF[13] without constructors...
+    union {
+        qreal *ptr;
+        QPointF *points;
+    } x;
+    x.ptr = pts;
+
+    int point_count = 0;
+    x.points[0] = qt_curves_for_arc(r, 0, -360, x.points + 1, &point_count);
+    QVectorPath vp((qreal *) pts, point_count, qpaintengineex_ellipse_types, QVectorPath::EllipseHint);
+    draw(vp);
+}
+
+void QPaintEngineEx::drawEllipse(const QRect &r)
+{
+    drawEllipse(QRectF(r));
+}
+
+void QPaintEngineEx::drawPath(const QPainterPath &path)
+{
+    if (!path.isEmpty())
+        draw(qtVectorPathForPath(path));
+}
+
+
+void QPaintEngineEx::drawPoints(const QPointF *points, int pointCount)
+{
+    QPen pen = state()->pen;
+    if (pen.capStyle() == Qt::FlatCap)
+        pen.setCapStyle(Qt::SquareCap);
+
+    if (pen.brush().isOpaque()) {
+        while (pointCount > 0) {
+            int count = qMin(pointCount, 16);
+            qreal pts[64];
+            int oset = -1;
+            for (int i=0; i<count; ++i) {
+                pts[++oset] = points[i].x();
+                pts[++oset] = points[i].y();
+                pts[++oset] = points[i].x() + 1/63.;
+                pts[++oset] = points[i].y();
+            }
+            QVectorPath path(pts, count * 2, qpaintengineex_line_types_16, QVectorPath::LinesHint);
+            stroke(path, pen);
+            pointCount -= 16;
+            points += 16;
+        }
+    } else {
+        for (int i=0; i<pointCount; ++i) {
+            qreal pts[] = { points[i].x(), points[i].y(), points[i].x() + 1/63., points[i].y() };
+            QVectorPath path(pts, 2, 0);
+            stroke(path, pen);
+        }
+    }
+}
+
+void QPaintEngineEx::drawPoints(const QPoint *points, int pointCount)
+{
+    QPen pen = state()->pen;
+    if (pen.capStyle() == Qt::FlatCap)
+        pen.setCapStyle(Qt::SquareCap);
+
+    if (pen.brush().isOpaque()) {
+        while (pointCount > 0) {
+            int count = qMin(pointCount, 16);
+            qreal pts[64];
+            int oset = -1;
+            for (int i=0; i<count; ++i) {
+                pts[++oset] = points[i].x();
+                pts[++oset] = points[i].y();
+                pts[++oset] = points[i].x() + 1/63.;
+                pts[++oset] = points[i].y();
+            }
+            QVectorPath path(pts, count * 2, qpaintengineex_line_types_16, QVectorPath::LinesHint);
+            stroke(path, pen);
+            pointCount -= 16;
+            points += 16;
+        }
+    } else {
+        for (int i=0; i<pointCount; ++i) {
+            qreal pts[] = { qreal(points[i].x()), qreal(points[i].y()),
+                            qreal(points[i].x() +1/63.), qreal(points[i].y()) };
+            QVectorPath path(pts, 2, 0);
+            stroke(path, pen);
+        }
+    }
+}
+
+
+void QPaintEngineEx::drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode)
+{
+    QVectorPath path((qreal *) points, pointCount, 0, QVectorPath::polygonFlags(mode));
+
+    if (mode == PolylineMode)
+        stroke(path, state()->pen);
+    else
+        draw(path);
+}
+
+void QPaintEngineEx::drawPolygon(const QPoint *points, int pointCount, PolygonDrawMode mode)
+{
+    int count = pointCount<<1;
+    QVarLengthArray<qreal> pts(count);
+
+#ifdef Q_WS_MAC
+    for (int i=0; i<count; i+=2) {
+        pts[i] = ((int *) points)[i+1];
+        pts[i+1] = ((int *) points)[i];
+    }
+#else
+    for (int i=0; i<count; ++i)
+        pts[i] = ((int *) points)[i];
+#endif
+
+    QVectorPath path(pts.data(), pointCount, 0, QVectorPath::polygonFlags(mode));
+
+    if (mode == PolylineMode)
+        stroke(path, state()->pen);
+    else
+        draw(path);
+
+}
+
+void QPaintEngineEx::drawPixmap(const QPointF &pos, const QPixmap &pm)
+{
+    drawPixmap(QRectF(pos, pm.size()), pm, pm.rect());
+}
+
+void QPaintEngineEx::drawImage(const QPointF &pos, const QImage &image)
+{
+    drawImage(QRectF(pos, image.size()), image, image.rect());
+}
+
+void QPaintEngineEx::drawTiledPixmap(const QRectF &r, const QPixmap &pixmap, const QPointF &s)
+{
+    QBrush brush(state()->pen.color(), pixmap);
+    QTransform xform = QTransform::fromTranslate(r.x() - s.x(), r.y() - s.y());
+    brush.setTransform(xform);
+
+    qreal pts[] = { r.x(), r.y(),
+                    r.x() + r.width(), r.y(),
+                    r.x() + r.width(), r.y() + r.height(),
+                    r.x(), r.y() + r.height() };
+
+    QVectorPath path(pts, 4, 0, QVectorPath::RectangleHint);
+    fill(path, brush);
+}
+
+void QPaintEngineEx::drawPixmapFragments(const QPainter::PixmapFragment *fragments, int fragmentCount,
+                                         const QPixmap &pixmap, QPainter::PixmapFragmentHints /*hints*/)
+{
+    if (pixmap.isNull())
+        return;
+
+    qreal oldOpacity = state()->opacity;
+    QTransform oldTransform = state()->matrix;
+
+    for (int i = 0; i < fragmentCount; ++i) {
+        QTransform transform = oldTransform;
+        transform.translate(fragments[i].x, fragments[i].y);
+        transform.rotate(fragments[i].rotation);
+        state()->opacity = oldOpacity * fragments[i].opacity;
+        state()->matrix = transform;
+        opacityChanged();
+        transformChanged();
+
+        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, -0.5 * h, w, h), pixmap, sourceRect);
+    }
+
+    state()->opacity = oldOpacity;
+    state()->matrix = oldTransform;
+    opacityChanged();
+    transformChanged();
+}
+
+void QPaintEngineEx::setState(QPainterState *s)
+{
+    QPaintEngine::state = s;
+}
+
+
+void QPaintEngineEx::updateState(const QPaintEngineState &)
+{
+    // do nothing...
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qpaintengineex_p.h b/src/gui/painting/qpaintengineex_p.h
new file mode 100644
index 0000000000..d12c602372
--- /dev/null
+++ b/src/gui/painting/qpaintengineex_p.h
@@ -0,0 +1,268 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPAINTENGINEEX_P_H
+#define QPAINTENGINEEX_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtGui/qpaintengine.h>
+#include <QtGui/qdrawutil.h>
+
+#include <private/qpaintengine_p.h>
+#include <private/qstroker_p.h>
+#include <private/qpainter_p.h>
+#include <private/qvectorpath_p.h>
+
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+class QPainterState;
+class QPaintEngineExPrivate;
+class QStaticTextItem;
+struct StrokeHandler;
+
+struct QIntRect {
+    int x1, y1, x2, y2;
+    inline void set(const QRect &r) {
+        x1 = r.x();
+        y1 = r.y();
+        x2 = r.right() + 1;
+        y2 = r.bottom() + 1;
+        // We will assume normalized for later...
+        Q_ASSERT(x2 >= x1);
+        Q_ASSERT(y2 >= y1);
+    }
+};
+
+class QRectVectorPath : public QVectorPath {
+public:
+    inline void set(const QRect &r) {
+        qreal left = r.x();
+        qreal right = r.x() + r.width();
+        qreal top = r.y();
+        qreal bottom = r.y() + r.height();
+        pts[0] = left;
+        pts[1] = top;
+        pts[2] = right;
+        pts[3] = top;
+        pts[4] = right;
+        pts[5] = bottom;
+        pts[6] = left;
+        pts[7] = bottom;
+    }
+
+    inline void set(const QRectF &r) {
+        qreal left = r.x();
+        qreal right = r.x() + r.width();
+        qreal top = r.y();
+        qreal bottom = r.y() + r.height();
+        pts[0] = left;
+        pts[1] = top;
+        pts[2] = right;
+        pts[3] = top;
+        pts[4] = right;
+        pts[5] = bottom;
+        pts[6] = left;
+        pts[7] = bottom;
+    }
+    inline QRectVectorPath(const QRect &r)
+        : QVectorPath(pts, 4, 0, QVectorPath::RectangleHint | QVectorPath::ImplicitClose)
+    {
+        set(r);
+    }
+    inline QRectVectorPath(const QRectF &r)
+        : QVectorPath(pts, 4, 0, QVectorPath::RectangleHint | QVectorPath::ImplicitClose)
+    {
+        set(r);
+    }
+    inline QRectVectorPath()
+        : QVectorPath(pts, 4, 0, QVectorPath::RectangleHint | QVectorPath::ImplicitClose)
+    { }
+
+    qreal pts[8];
+};
+
+#ifndef QT_NO_DEBUG_STREAM
+QDebug Q_GUI_EXPORT &operator<<(QDebug &, const QVectorPath &path);
+#endif
+
+class QPixmapFilter;
+
+class Q_GUI_EXPORT QPaintEngineEx : public QPaintEngine
+{
+    Q_DECLARE_PRIVATE(QPaintEngineEx)
+public:
+    QPaintEngineEx();
+
+    virtual QPainterState *createState(QPainterState *orig) const;
+
+    virtual void draw(const QVectorPath &path);
+    virtual void fill(const QVectorPath &path, const QBrush &brush) = 0;
+    virtual void stroke(const QVectorPath &path, const QPen &pen);
+
+    virtual void clip(const QVectorPath &path, Qt::ClipOperation op) = 0;
+    virtual void clip(const QRect &rect, Qt::ClipOperation op);
+    virtual void clip(const QRegion &region, Qt::ClipOperation op);
+    virtual void clip(const QPainterPath &path, Qt::ClipOperation op);
+
+    virtual void clipEnabledChanged() = 0;
+    virtual void penChanged() = 0;
+    virtual void brushChanged() = 0;
+    virtual void brushOriginChanged() = 0;
+    virtual void opacityChanged() = 0;
+    virtual void compositionModeChanged() = 0;
+    virtual void renderHintsChanged() = 0;
+    virtual void transformChanged() = 0;
+
+    virtual void fillRect(const QRectF &rect, const QBrush &brush);
+    virtual void fillRect(const QRectF &rect, const QColor &color);
+
+    virtual void drawRoundedRect(const QRectF &rect, qreal xrad, qreal yrad, Qt::SizeMode mode);
+
+    virtual void drawRects(const QRect *rects, int rectCount);
+    virtual void drawRects(const QRectF *rects, int rectCount);
+
+    virtual void drawLines(const QLine *lines, int lineCount);
+    virtual void drawLines(const QLineF *lines, int lineCount);
+
+    virtual void drawEllipse(const QRectF &r);
+    virtual void drawEllipse(const QRect &r);
+
+    virtual void drawPath(const QPainterPath &path);
+
+    virtual void drawPoints(const QPointF *points, int pointCount);
+    virtual void drawPoints(const QPoint *points, int pointCount);
+
+    virtual void drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode);
+    virtual void drawPolygon(const QPoint *points, int pointCount, PolygonDrawMode mode);
+
+    virtual void drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr) = 0;
+    virtual void drawPixmap(const QPointF &pos, const QPixmap &pm);
+
+    virtual void drawImage(const QRectF &r, const QImage &pm, const QRectF &sr,
+                           Qt::ImageConversionFlags flags = Qt::AutoColor) = 0;
+    virtual void drawImage(const QPointF &pos, const QImage &image);
+
+    virtual void drawTiledPixmap(const QRectF &r, const QPixmap &pixmap, const QPointF &s);
+
+    virtual void drawPixmapFragments(const QPainter::PixmapFragment *fragments, int fragmentCount, const QPixmap &pixmap,
+                                     QFlags<QPainter::PixmapFragmentHint> hints);
+
+    virtual void updateState(const QPaintEngineState &state);
+
+    virtual void drawStaticTextItem(QStaticTextItem *) = 0;
+
+    virtual void setState(QPainterState *s);
+    inline QPainterState *state() { return static_cast<QPainterState *>(QPaintEngine::state); }
+    inline const QPainterState *state() const { return static_cast<const QPainterState *>(QPaintEngine::state); }
+
+    virtual void sync() {}
+
+    virtual void beginNativePainting() {}
+    virtual void endNativePainting() {}
+
+    // Return a pixmap filter of "type" that can render the parameters
+    // in "prototype".  The returned filter is owned by the engine and
+    // will be destroyed when the engine is destroyed.  The "prototype"
+    // allows the engine to pick different filters based on the parameters
+    // that will be requested, and not just the "type".
+    virtual QPixmapFilter *pixmapFilter(int /*type*/, const QPixmapFilter * /*prototype*/) { return 0; }
+
+    // These flags are needed in the implementation of paint buffers.
+    enum Flags
+    {
+        DoNotEmulate = 0x01,        // If set, QPainter will not wrap this engine in an emulation engine.
+        IsEmulationEngine = 0x02    // If set, this object is a QEmulationEngine.
+    };
+    virtual uint flags() const {return 0;}
+
+protected:
+    QPaintEngineEx(QPaintEngineExPrivate &data);
+};
+
+class Q_GUI_EXPORT QPaintEngineExPrivate : public QPaintEnginePrivate
+{
+    Q_DECLARE_PUBLIC(QPaintEngineEx)
+public:
+    QPaintEngineExPrivate();
+    ~QPaintEngineExPrivate();
+
+    void replayClipOperations();
+    bool hasClipOperations() const;
+
+    QStroker stroker;
+    QDashStroker dasher;
+    StrokeHandler *strokeHandler;
+    QStrokerOps *activeStroker;
+    QPen strokerPen;
+
+    QRect exDeviceRect;
+};
+
+inline uint QVectorPath::polygonFlags(QPaintEngine::PolygonDrawMode mode) {
+    switch (mode) {
+    case QPaintEngine::ConvexMode: return ConvexPolygonHint | ImplicitClose;
+    case QPaintEngine::OddEvenMode: return PolygonHint | OddEvenFill | ImplicitClose;
+    case QPaintEngine::WindingMode: return PolygonHint | WindingFill | ImplicitClose;
+    case QPaintEngine::PolylineMode: return PolygonHint;
+    default: return 0;
+    }
+}
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/gui/painting/qpainter.cpp b/src/gui/painting/qpainter.cpp
new file mode 100644
index 0000000000..9fafba5f4f
--- /dev/null
+++ b/src/gui/painting/qpainter.cpp
@@ -0,0 +1,9572 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+// QtCore
+#include <qdebug.h>
+#include <qmath.h>
+#include <qmutex.h>
+
+// QtGui
+#include "qbitmap.h"
+#include "qimage.h"
+#include "qpaintdevice.h"
+#include "qpaintengine.h"
+#include "qpainter.h"
+#include "qpainter_p.h"
+#include "qpainterpath.h"
+#include "qpicture.h"
+#include "qpixmapcache.h"
+#include "qpolygon.h"
+#include "qtextlayout.h"
+#include "qwidget.h"
+#include "qapplication.h"
+#include "qstyle.h"
+#include "qthread.h"
+#include "qvarlengtharray.h"
+#include "qstatictext.h"
+#include "qglyphs.h"
+
+#include <private/qfontengine_p.h>
+#include <private/qpaintengine_p.h>
+#include <private/qemulationpaintengine_p.h>
+#include <private/qpainterpath_p.h>
+#include <private/qtextengine_p.h>
+#include <private/qwidget_p.h>
+#include <private/qpaintengine_raster_p.h>
+#include <private/qmath_p.h>
+#include <private/qstatictext_p.h>
+#include <private/qglyphs_p.h>
+#include <private/qstylehelper_p.h>
+#include <private/qrawfont_p.h>
+
+QT_BEGIN_NAMESPACE
+
+#define QGradient_StretchToDevice 0x10000000
+#define QPaintEngine_OpaqueBackground 0x40000000
+
+// #define QT_DEBUG_DRAW
+#ifdef QT_DEBUG_DRAW
+bool qt_show_painter_debug_output = true;
+#endif
+
+extern QPixmap qt_pixmapForBrush(int style, bool invert);
+
+void qt_format_text(const QFont &font,
+                    const QRectF &_r, int tf, const QTextOption *option, const QString& str, QRectF *brect,
+                    int tabstops, int* tabarray, int tabarraylen,
+                    QPainter *painter);
+static void drawTextItemDecoration(QPainter *painter, const QPointF &pos, const QFontEngine *fe,
+                                   QTextCharFormat::UnderlineStyle underlineStyle,
+                                   QTextItem::RenderFlags flags, qreal width,
+                                   const QTextCharFormat &charFormat);
+// Helper function to calculate left most position, width and flags for decoration drawing
+Q_GUI_EXPORT void qt_draw_decoration_for_glyphs(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)
+{
+    switch (brush.style()) {
+    case Qt::LinearGradientPattern:
+    case Qt::RadialGradientPattern:
+    case Qt::ConicalGradientPattern:
+        return brush.gradient()->coordinateMode();
+    default:
+        ;
+    }
+    return QGradient::LogicalMode;
+}
+
+/* Returns true if the gradient requires stretch to device...*/
+static inline bool check_gradient(const QBrush &brush)
+{
+    return coordinateMode(brush) == QGradient::StretchToDeviceMode;
+}
+
+extern bool qHasPixmapTexture(const QBrush &);
+
+static inline bool is_brush_transparent(const QBrush &brush) {
+    Qt::BrushStyle s = brush.style();
+    bool brushBitmap = qHasPixmapTexture(brush)
+                       ? brush.texture().isQBitmap()
+                       : (brush.textureImage().depth() == 1);
+    return ((s >= Qt::Dense1Pattern && s <= Qt::DiagCrossPattern)
+            || (s == Qt::TexturePattern && brushBitmap));
+}
+
+static inline bool is_pen_transparent(const QPen &pen) {
+    return pen.style() > Qt::SolidLine || is_brush_transparent(pen.brush());
+}
+
+/* Discards the emulation flags that are not relevant for line drawing
+   and returns the result
+*/
+static inline uint line_emulation(uint emulation)
+{
+    return emulation & (QPaintEngine::PrimitiveTransform
+                        | QPaintEngine::AlphaBlend
+                        | QPaintEngine::Antialiasing
+                        | QPaintEngine::BrushStroke
+                        | QPaintEngine::ConstantOpacity
+                        | QGradient_StretchToDevice
+                        | QPaintEngine::ObjectBoundingModeGradients
+                        | QPaintEngine_OpaqueBackground);
+}
+
+static bool qt_paintengine_supports_transformations(QPaintEngine::Type type)
+{
+    return type == QPaintEngine::OpenGL2
+            || type == QPaintEngine::OpenVG
+            || type == QPaintEngine::OpenGL;
+}
+
+#ifndef QT_NO_DEBUG
+static bool qt_painter_thread_test(int devType, const char *what, bool extraCondition = false)
+{
+    switch (devType) {
+    case QInternal::Image:
+    case QInternal::Printer:
+    case QInternal::Picture:
+        // can be drawn onto these devices safely from any thread
+#ifndef Q_WS_WIN
+        if (extraCondition)
+#endif
+            break;
+    default:
+#ifdef Q_WS_X11
+        if (QApplication::testAttribute(Qt::AA_X11InitThreads))
+            return true;
+#endif
+        if (!extraCondition && QThread::currentThread() != qApp->thread()) {
+            qWarning("QPainter: It is not safe to use %s outside the GUI thread", what);
+            return false;
+        }
+        break;
+    }
+    return true;
+}
+#endif
+
+void QPainterPrivate::checkEmulation()
+{
+    Q_ASSERT(extended);
+    if (extended->flags() & QPaintEngineEx::DoNotEmulate)
+        return;
+
+    bool doEmulation = false;
+    if (state->bgMode == Qt::OpaqueMode)
+        doEmulation = true;
+
+    const QGradient *bg = state->brush.gradient();
+    if (bg && bg->coordinateMode() > QGradient::LogicalMode)
+        doEmulation = true;
+
+    const QGradient *pg = qpen_brush(state->pen).gradient();
+    if (pg && pg->coordinateMode() > QGradient::LogicalMode)
+        doEmulation = true;
+
+    if (doEmulation) {
+        if (extended != emulationEngine) {
+            if (!emulationEngine)
+                emulationEngine = new QEmulationPaintEngine(extended);
+            extended = emulationEngine;
+            extended->setState(state);
+        }
+    } else if (emulationEngine == extended) {
+        extended = emulationEngine->real_engine;
+    }
+}
+
+
+QPainterPrivate::~QPainterPrivate()
+{
+    delete emulationEngine;
+    for (int i=0; i<states.size(); ++i)
+        delete states.at(i);
+
+    if (dummyState)
+        delete dummyState;
+}
+
+
+QTransform QPainterPrivate::viewTransform() const
+{
+    if (state->VxF) {
+        qreal scaleW = qreal(state->vw)/qreal(state->ww);
+        qreal scaleH = qreal(state->vh)/qreal(state->wh);
+        return QTransform(scaleW, 0, 0, scaleH,
+                          state->vx - state->wx*scaleW, state->vy - state->wy*scaleH);
+    }
+    return QTransform();
+}
+
+
+/*
+   \internal
+   Returns true if using a shared painter; otherwise false.
+*/
+bool QPainterPrivate::attachPainterPrivate(QPainter *q, QPaintDevice *pdev)
+{
+    Q_ASSERT(q);
+    Q_ASSERT(pdev);
+
+    if (pdev->devType() != QInternal::Widget)
+        return false;
+
+    QWidget *widget = static_cast<QWidget *>(pdev);
+    Q_ASSERT(widget);
+
+    // Someone either called QPainter::setRedirected in the widget's paint event
+    // right before this painter was created (or begin was called) or
+    // sent a paint event directly to the widget.
+    if (!widget->d_func()->redirectDev)
+        return false;
+
+    QPainter *sp = widget->d_func()->sharedPainter();
+    if (!sp || !sp->isActive())
+        return false;
+
+    if (sp->paintEngine()->paintDevice() != widget->d_func()->redirectDev)
+        return false;
+
+    // Check if we're attempting to paint outside a paint event.
+    if (!sp->d_ptr->engine->hasFeature(QPaintEngine::PaintOutsidePaintEvent)
+        && !widget->testAttribute(Qt::WA_PaintOutsidePaintEvent)
+        && !widget->testAttribute(Qt::WA_WState_InPaintEvent)) {
+
+        qWarning("QPainter::begin: Widget painting can only begin as a result of a paintEvent");
+        return false;
+    }
+
+    // Save the current state of the shared painter and assign
+    // the current d_ptr to the shared painter's d_ptr.
+    sp->save();
+    if (!sp->d_ptr->d_ptrs) {
+        // Allocate space for 4 d-pointers (enough for up to 4 sub-sequent
+        // redirections within the same paintEvent(), which should be enough
+        // in 99% of all cases). E.g: A renders B which renders C which renders D.
+        sp->d_ptr->d_ptrs_size = 4;
+        sp->d_ptr->d_ptrs = (QPainterPrivate **)malloc(4 * sizeof(QPainterPrivate *));
+        Q_CHECK_PTR(sp->d_ptr->d_ptrs);
+    } 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 = 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);
+
+    // Now initialize the painter with correct widget properties.
+    q->initFrom(widget);
+    QPoint offset;
+    widget->d_func()->redirected(&offset);
+    offset += q->d_ptr->engine->coordinateOffset();
+
+    // Update system rect.
+    q->d_ptr->state->ww = q->d_ptr->state->vw = widget->width();
+    q->d_ptr->state->wh = q->d_ptr->state->vh = widget->height();
+
+    // Update matrix.
+    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();
+
+    QPaintEnginePrivate *enginePrivate = q->d_ptr->engine->d_func();
+    if (enginePrivate->currentClipWidget == widget) {
+        enginePrivate->systemStateChanged();
+        return true;
+    }
+
+    // Update system transform and clip.
+    enginePrivate->currentClipWidget = widget;
+    enginePrivate->setSystemTransform(q->d_ptr->state->matrix);
+    return true;
+}
+
+void QPainterPrivate::detachPainterPrivate(QPainter *q)
+{
+    Q_ASSERT(refcount > 1);
+    Q_ASSERT(q);
+
+    QPainterPrivate *original = d_ptrs[--refcount - 1];
+    if (inDestructor) {
+        inDestructor = false;
+        if (original)
+            original->inDestructor = true;
+    } else if (!original) {
+        original = new QPainterPrivate(q);
+    }
+
+    d_ptrs[refcount - 1] = 0;
+    q->restore();
+    q->d_ptr.take();
+    q->d_ptr.reset(original);
+
+    if (emulationEngine) {
+        extended = emulationEngine->real_engine;
+        delete emulationEngine;
+        emulationEngine = 0;
+    }
+}
+
+
+void QPainterPrivate::draw_helper(const QPainterPath &originalPath, DrawOperation op)
+{
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output) {
+        printf("QPainter::drawHelper\n");
+    }
+#endif
+
+    if (originalPath.isEmpty())
+        return;
+
+    QPaintEngine::PaintEngineFeatures gradientStretch =
+        QPaintEngine::PaintEngineFeatures(QGradient_StretchToDevice
+                                          | QPaintEngine::ObjectBoundingModeGradients);
+
+    const bool mustEmulateObjectBoundingModeGradients = extended
+                                                        || ((state->emulationSpecifier & QPaintEngine::ObjectBoundingModeGradients)
+                                                            && !engine->hasFeature(QPaintEngine::PatternTransform));
+
+    if (!(state->emulationSpecifier & ~gradientStretch)
+        && !mustEmulateObjectBoundingModeGradients) {
+        drawStretchedGradient(originalPath, op);
+        return;
+    } else if (state->emulationSpecifier & QPaintEngine_OpaqueBackground) {
+        drawOpaqueBackground(originalPath, op);
+        return;
+    }
+
+    Q_Q(QPainter);
+
+    qreal strokeOffsetX = 0, strokeOffsetY = 0;
+
+    QPainterPath path = originalPath * state->matrix;
+    QRectF pathBounds = path.boundingRect();
+    QRectF strokeBounds;
+    bool doStroke = (op & StrokeDraw) && (state->pen.style() != Qt::NoPen);
+    if (doStroke) {
+        qreal penWidth = state->pen.widthF();
+        if (penWidth == 0) {
+            strokeOffsetX = 1;
+            strokeOffsetY = 1;
+        } else {
+            // In case of complex xform
+            if (state->matrix.type() > QTransform::TxScale) {
+                QPainterPathStroker stroker;
+                stroker.setWidth(penWidth);
+                stroker.setJoinStyle(state->pen.joinStyle());
+                stroker.setCapStyle(state->pen.capStyle());
+                QPainterPath stroke = stroker.createStroke(originalPath);
+                strokeBounds = (stroke * state->matrix).boundingRect();
+            } else {
+                strokeOffsetX = qAbs(penWidth * state->matrix.m11() / 2.0);
+                strokeOffsetY = qAbs(penWidth * state->matrix.m22() / 2.0);
+            }
+        }
+    }
+
+    QRect absPathRect;
+    if (!strokeBounds.isEmpty()) {
+        absPathRect = strokeBounds.intersected(QRectF(0, 0, device->width(), device->height())).toAlignedRect();
+    } else {
+        absPathRect = pathBounds.adjusted(-strokeOffsetX, -strokeOffsetY, strokeOffsetX, strokeOffsetY)
+            .intersected(QRectF(0, 0, device->width(), device->height())).toAlignedRect();
+    }
+
+    if (q->hasClipping()) {
+        bool hasPerspectiveTransform = false;
+        for (int i = 0; i < state->clipInfo.size(); ++i) {
+            const QPainterClipInfo &info = state->clipInfo.at(i);
+            if (info.matrix.type() == QTransform::TxProject) {
+                hasPerspectiveTransform = true;
+                break;
+            }
+        }
+        // avoid mapping QRegions with perspective transforms
+        if (!hasPerspectiveTransform) {
+            // The trick with txinv and invMatrix is done in order to
+            // avoid transforming the clip to logical coordinates, and
+            // then back to device coordinates. This is a problem with
+            // QRegion/QRect based clips, since they use integer
+            // coordinates and converting to/from logical coordinates will
+            // lose precision.
+            bool old_txinv = txinv;
+            QTransform old_invMatrix = invMatrix;
+            txinv = true;
+            invMatrix = QTransform();
+            QPainterPath clipPath = q->clipPath();
+            QRectF r = clipPath.boundingRect().intersected(absPathRect);
+            absPathRect = r.toAlignedRect();
+            txinv = old_txinv;
+            invMatrix = old_invMatrix;
+        }
+    }
+
+//     qDebug("\nQPainterPrivate::draw_helper(), x=%d, y=%d, w=%d, h=%d",
+//            devMinX, devMinY, device->width(), device->height());
+//     qDebug() << " - matrix" << state->matrix;
+//     qDebug() << " - originalPath.bounds" << originalPath.boundingRect();
+//     qDebug() << " - path.bounds" << path.boundingRect();
+
+    if (absPathRect.width() <= 0 || absPathRect.height() <= 0)
+        return;
+
+    QImage image(absPathRect.width(), absPathRect.height(), QImage::Format_ARGB32_Premultiplied);
+    image.fill(0);
+
+    QPainter p(&image);
+
+    p.d_ptr->helper_device = helper_device;
+
+    p.setOpacity(state->opacity);
+    p.translate(-absPathRect.x(), -absPathRect.y());
+    p.setTransform(state->matrix, true);
+    p.setPen(doStroke ? state->pen : QPen(Qt::NoPen));
+    p.setBrush((op & FillDraw) ? state->brush : QBrush(Qt::NoBrush));
+    p.setBackground(state->bgBrush);
+    p.setBackgroundMode(state->bgMode);
+    p.setBrushOrigin(state->brushOrigin);
+
+    p.setRenderHint(QPainter::Antialiasing, state->renderHints & QPainter::Antialiasing);
+    p.setRenderHint(QPainter::SmoothPixmapTransform,
+                    state->renderHints & QPainter::SmoothPixmapTransform);
+
+    p.drawPath(originalPath);
+
+#ifndef QT_NO_DEBUG
+    static bool do_fallback_overlay = qgetenv("QT_PAINT_FALLBACK_OVERLAY").size() > 0;
+    if (do_fallback_overlay) {
+        QImage block(8, 8, QImage::Format_ARGB32_Premultiplied);
+        QPainter pt(&block);
+        pt.fillRect(0, 0, 8, 8, QColor(196, 0, 196));
+        pt.drawLine(0, 0, 8, 8);
+        pt.end();
+        p.resetTransform();
+        p.setCompositionMode(QPainter::CompositionMode_SourceAtop);
+        p.setOpacity(0.5);
+        p.fillRect(0, 0, image.width(), image.height(), QBrush(block));
+    }
+#endif
+
+    p.end();
+
+    q->save();
+    state->matrix = QTransform();
+    state->dirtyFlags |= QPaintEngine::DirtyTransform;
+    updateState(state);
+    engine->drawImage(absPathRect,
+                 image,
+                 QRectF(0, 0, absPathRect.width(), absPathRect.height()),
+                 Qt::OrderedDither | Qt::OrderedAlphaDither);
+    q->restore();
+}
+
+void QPainterPrivate::drawOpaqueBackground(const QPainterPath &path, DrawOperation op)
+{
+    Q_Q(QPainter);
+
+    q->setBackgroundMode(Qt::TransparentMode);
+
+    if (op & FillDraw && state->brush.style() != Qt::NoBrush) {
+        q->fillPath(path, state->bgBrush.color());
+        q->fillPath(path, state->brush);
+    }
+
+    if (op & StrokeDraw && state->pen.style() != Qt::NoPen) {
+        q->strokePath(path, QPen(state->bgBrush.color(), state->pen.width()));
+        q->strokePath(path, state->pen);
+    }
+
+    q->setBackgroundMode(Qt::OpaqueMode);
+}
+
+static inline QBrush stretchGradientToUserSpace(const QBrush &brush, const QRectF &boundingRect)
+{
+    Q_ASSERT(brush.style() >= Qt::LinearGradientPattern
+             && brush.style() <= Qt::ConicalGradientPattern);
+
+    QTransform gradientToUser(boundingRect.width(), 0, 0, boundingRect.height(),
+                              boundingRect.x(), boundingRect.y());
+
+    QGradient g = *brush.gradient();
+    g.setCoordinateMode(QGradient::LogicalMode);
+
+    QBrush b(g);
+    b.setTransform(gradientToUser * b.transform());
+    return b;
+}
+
+void QPainterPrivate::drawStretchedGradient(const QPainterPath &path, DrawOperation op)
+{
+    Q_Q(QPainter);
+
+    const qreal sw = helper_device->width();
+    const qreal sh = helper_device->height();
+
+    bool changedPen = false;
+    bool changedBrush = false;
+    bool needsFill = false;
+
+    const QPen pen = state->pen;
+    const QBrush brush = state->brush;
+
+    const QGradient::CoordinateMode penMode = coordinateMode(pen.brush());
+    const QGradient::CoordinateMode brushMode = coordinateMode(brush);
+
+    QRectF boundingRect;
+
+    // Draw the xformed fill if the brush is a stretch gradient.
+    if ((op & FillDraw) && brush.style() != Qt::NoBrush) {
+        if (brushMode == QGradient::StretchToDeviceMode) {
+            q->setPen(Qt::NoPen);
+            changedPen = pen.style() != Qt::NoPen;
+            q->scale(sw, sh);
+            updateState(state);
+
+            const qreal isw = 1.0 / sw;
+            const qreal ish = 1.0 / sh;
+            QTransform inv(isw, 0, 0, ish, 0, 0);
+            engine->drawPath(path * inv);
+            q->scale(isw, ish);
+        } else {
+            needsFill = true;
+
+            if (brushMode == QGradient::ObjectBoundingMode) {
+                Q_ASSERT(engine->hasFeature(QPaintEngine::PatternTransform));
+                boundingRect = path.boundingRect();
+                q->setBrush(stretchGradientToUserSpace(brush, boundingRect));
+                changedBrush = true;
+            }
+        }
+    }
+
+    if ((op & StrokeDraw) && pen.style() != Qt::NoPen) {
+        // Draw the xformed outline if the pen is a stretch gradient.
+        if (penMode == QGradient::StretchToDeviceMode) {
+            q->setPen(Qt::NoPen);
+            changedPen = true;
+
+            if (needsFill) {
+                updateState(state);
+                engine->drawPath(path);
+            }
+
+            q->scale(sw, sh);
+            q->setBrush(pen.brush());
+            changedBrush = true;
+            updateState(state);
+
+            QPainterPathStroker stroker;
+            stroker.setDashPattern(pen.style());
+            stroker.setWidth(pen.widthF());
+            stroker.setJoinStyle(pen.joinStyle());
+            stroker.setCapStyle(pen.capStyle());
+            stroker.setMiterLimit(pen.miterLimit());
+            QPainterPath stroke = stroker.createStroke(path);
+
+            const qreal isw = 1.0 / sw;
+            const qreal ish = 1.0 / sh;
+            QTransform inv(isw, 0, 0, ish, 0, 0);
+            engine->drawPath(stroke * inv);
+            q->scale(isw, ish);
+        } else {
+            if (!needsFill && brush.style() != Qt::NoBrush) {
+                q->setBrush(Qt::NoBrush);
+                changedBrush = true;
+            }
+
+            if (penMode == QGradient::ObjectBoundingMode) {
+                Q_ASSERT(engine->hasFeature(QPaintEngine::PatternTransform));
+
+                // avoid computing the bounding rect twice
+                if (!needsFill || brushMode != QGradient::ObjectBoundingMode)
+                    boundingRect = path.boundingRect();
+
+                QPen p = pen;
+                p.setBrush(stretchGradientToUserSpace(pen.brush(), boundingRect));
+                q->setPen(p);
+                changedPen = true;
+            } else if (changedPen) {
+                q->setPen(pen);
+                changedPen = false;
+            }
+
+            updateState(state);
+            engine->drawPath(path);
+        }
+    } else if (needsFill) {
+        if (pen.style() != Qt::NoPen) {
+            q->setPen(Qt::NoPen);
+            changedPen = true;
+        }
+
+        updateState(state);
+        engine->drawPath(path);
+    }
+
+    if (changedPen)
+        q->setPen(pen);
+    if (changedBrush)
+        q->setBrush(brush);
+}
+
+
+void QPainterPrivate::updateMatrix()
+{
+    state->matrix = state->WxF ? state->worldMatrix : QTransform();
+    if (state->VxF)
+        state->matrix *= viewTransform();
+
+    txinv = false;                                // no inverted matrix
+    state->matrix *= state->redirectionMatrix;
+    if (extended)
+        extended->transformChanged();
+    else
+        state->dirtyFlags |= QPaintEngine::DirtyTransform;
+
+//     printf("VxF=%d, WxF=%d\n", state->VxF, state->WxF);
+//     qDebug() << " --- using matrix" << state->matrix << redirection_offset;
+}
+
+/*! \internal */
+void QPainterPrivate::updateInvMatrix()
+{
+    Q_ASSERT(txinv == false);
+    txinv = true;                                // creating inverted matrix
+    invMatrix = state->matrix.inverted();
+}
+
+void QPainterPrivate::updateEmulationSpecifier(QPainterState *s)
+{
+    bool alpha = false;
+    bool linearGradient = false;
+    bool radialGradient = false;
+    bool conicalGradient = false;
+    bool patternBrush = false;
+    bool xform = false;
+    bool complexXform = false;
+
+    bool skip = true;
+
+    // Pen and brush properties (we have to check both if one changes because the
+    // one that's unchanged can still be in a state which requires emulation)
+    if (s->state() & (QPaintEngine::DirtyPen | QPaintEngine::DirtyBrush | QPaintEngine::DirtyHints)) {
+        // Check Brush stroke emulation
+        if (!s->pen.isSolid() && !engine->hasFeature(QPaintEngine::BrushStroke))
+            s->emulationSpecifier |= QPaintEngine::BrushStroke;
+        else
+            s->emulationSpecifier &= ~QPaintEngine::BrushStroke;
+
+        skip = false;
+
+        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)
+                 && !penBrush.isOpaque())
+                || (brushStyle != Qt::NoBrush
+                    && (brushStyle < Qt::LinearGradientPattern && s->brush.color().alpha() != 255)
+                    && !s->brush.isOpaque());
+        linearGradient = ((penBrushStyle == Qt::LinearGradientPattern) ||
+                           (brushStyle == Qt::LinearGradientPattern));
+        radialGradient = ((penBrushStyle == Qt::RadialGradientPattern) ||
+                           (brushStyle == Qt::RadialGradientPattern));
+        conicalGradient = ((penBrushStyle == Qt::ConicalGradientPattern) ||
+                            (brushStyle == Qt::ConicalGradientPattern));
+        patternBrush = (((penBrushStyle > Qt::SolidPattern
+                           && penBrushStyle < Qt::LinearGradientPattern)
+                          || penBrushStyle == Qt::TexturePattern) ||
+                         ((brushStyle > Qt::SolidPattern
+                           && brushStyle < Qt::LinearGradientPattern)
+                          || brushStyle == Qt::TexturePattern));
+
+        bool penTextureAlpha = false;
+        if (penBrush.style() == Qt::TexturePattern)
+            penTextureAlpha = qHasPixmapTexture(penBrush)
+                              ? (penBrush.texture().depth() > 1) && penBrush.texture().hasAlpha()
+                              : penBrush.textureImage().hasAlphaChannel();
+        bool brushTextureAlpha = false;
+        if (s->brush.style() == Qt::TexturePattern) {
+            brushTextureAlpha = qHasPixmapTexture(s->brush)
+                                ? (s->brush.texture().depth() > 1) && s->brush.texture().hasAlpha()
+                                : s->brush.textureImage().hasAlphaChannel();
+        }
+        if (((penBrush.style() == Qt::TexturePattern && penTextureAlpha)
+             || (s->brush.style() == Qt::TexturePattern && brushTextureAlpha))
+            && !engine->hasFeature(QPaintEngine::MaskedBrush))
+            s->emulationSpecifier |= QPaintEngine::MaskedBrush;
+        else
+            s->emulationSpecifier &= ~QPaintEngine::MaskedBrush;
+    }
+
+    if (s->state() & (QPaintEngine::DirtyHints
+                      | QPaintEngine::DirtyOpacity
+                      | QPaintEngine::DirtyBackgroundMode)) {
+        skip = false;
+    }
+
+    if (skip)
+        return;
+
+#if 0
+    qDebug("QPainterPrivate::updateEmulationSpecifier, state=%p\n"
+           " - alpha: %d\n"
+           " - linearGradient: %d\n"
+           " - radialGradient: %d\n"
+           " - conicalGradient: %d\n"
+           " - patternBrush: %d\n"
+           " - hints: %x\n"
+           " - xform: %d\n",
+           s,
+           alpha,
+           linearGradient,
+           radialGradient,
+           conicalGradient,
+           patternBrush,
+           uint(s->renderHints),
+           xform);
+#endif
+
+    // XForm properties
+    if (s->state() & QPaintEngine::DirtyTransform) {
+        xform = !s->matrix.isIdentity();
+        complexXform = !s->matrix.isAffine();
+    } else if (s->matrix.type() >= QTransform::TxTranslate) {
+        xform = true;
+        complexXform = !s->matrix.isAffine();
+    }
+
+    const bool brushXform = (!s->brush.transform().type() == QTransform::TxNone);
+    const bool penXform = (!s->pen.brush().transform().type() == QTransform::TxNone);
+
+    const bool patternXform = patternBrush && (xform || brushXform || penXform);
+
+    // Check alphablending
+    if (alpha && !engine->hasFeature(QPaintEngine::AlphaBlend))
+        s->emulationSpecifier |= QPaintEngine::AlphaBlend;
+    else
+        s->emulationSpecifier &= ~QPaintEngine::AlphaBlend;
+
+    // Linear gradient emulation
+    if (linearGradient && !engine->hasFeature(QPaintEngine::LinearGradientFill))
+        s->emulationSpecifier |= QPaintEngine::LinearGradientFill;
+    else
+        s->emulationSpecifier &= ~QPaintEngine::LinearGradientFill;
+
+    // Radial gradient emulation
+    if (radialGradient && !engine->hasFeature(QPaintEngine::RadialGradientFill))
+        s->emulationSpecifier |= QPaintEngine::RadialGradientFill;
+    else
+        s->emulationSpecifier &= ~QPaintEngine::RadialGradientFill;
+
+    // Conical gradient emulation
+    if (conicalGradient && !engine->hasFeature(QPaintEngine::ConicalGradientFill))
+        s->emulationSpecifier |= QPaintEngine::ConicalGradientFill;
+    else
+        s->emulationSpecifier &= ~QPaintEngine::ConicalGradientFill;
+
+    // Pattern brushes
+    if (patternBrush && !engine->hasFeature(QPaintEngine::PatternBrush))
+        s->emulationSpecifier |= QPaintEngine::PatternBrush;
+    else
+        s->emulationSpecifier &= ~QPaintEngine::PatternBrush;
+
+    // Pattern XForms
+    if (patternXform && !engine->hasFeature(QPaintEngine::PatternTransform))
+        s->emulationSpecifier |= QPaintEngine::PatternTransform;
+    else
+        s->emulationSpecifier &= ~QPaintEngine::PatternTransform;
+
+    // Primitive XForms
+    if (xform && !engine->hasFeature(QPaintEngine::PrimitiveTransform))
+        s->emulationSpecifier |= QPaintEngine::PrimitiveTransform;
+    else
+        s->emulationSpecifier &= ~QPaintEngine::PrimitiveTransform;
+
+    // Perspective XForms
+    if (complexXform && !engine->hasFeature(QPaintEngine::PerspectiveTransform))
+        s->emulationSpecifier |= QPaintEngine::PerspectiveTransform;
+    else
+        s->emulationSpecifier &= ~QPaintEngine::PerspectiveTransform;
+
+    // Constant opacity
+    if (state->opacity != 1 && !engine->hasFeature(QPaintEngine::ConstantOpacity))
+        s->emulationSpecifier |= QPaintEngine::ConstantOpacity;
+    else
+        s->emulationSpecifier &= ~QPaintEngine::ConstantOpacity;
+
+    bool gradientStretch = false;
+    bool objectBoundingMode = false;
+    if (linearGradient || conicalGradient || radialGradient) {
+        QGradient::CoordinateMode brushMode = coordinateMode(s->brush);
+        QGradient::CoordinateMode penMode = coordinateMode(s->pen.brush());
+
+        gradientStretch |= (brushMode == QGradient::StretchToDeviceMode);
+        gradientStretch |= (penMode == QGradient::StretchToDeviceMode);
+
+        objectBoundingMode |= (brushMode == QGradient::ObjectBoundingMode);
+        objectBoundingMode |= (penMode == QGradient::ObjectBoundingMode);
+    }
+    if (gradientStretch)
+        s->emulationSpecifier |= QGradient_StretchToDevice;
+    else
+        s->emulationSpecifier &= ~QGradient_StretchToDevice;
+
+    if (objectBoundingMode && !engine->hasFeature(QPaintEngine::ObjectBoundingModeGradients))
+        s->emulationSpecifier |= QPaintEngine::ObjectBoundingModeGradients;
+    else
+        s->emulationSpecifier &= ~QPaintEngine::ObjectBoundingModeGradients;
+
+    // Opaque backgrounds...
+    if (s->bgMode == Qt::OpaqueMode &&
+        (is_pen_transparent(s->pen) || is_brush_transparent(s->brush)))
+        s->emulationSpecifier |= QPaintEngine_OpaqueBackground;
+    else
+        s->emulationSpecifier &= ~QPaintEngine_OpaqueBackground;
+
+#if 0
+    //won't be correct either way because the device can already have
+    // something rendered to it in which case subsequent emulation
+    // on a fully transparent qimage and then blitting the results
+    // won't produce correct results
+    // Blend modes
+    if (state->composition_mode > QPainter::CompositionMode_Xor &&
+        !engine->hasFeature(QPaintEngine::BlendModes))
+        s->emulationSpecifier |= QPaintEngine::BlendModes;
+    else
+        s->emulationSpecifier &= ~QPaintEngine::BlendModes;
+#endif
+}
+
+void QPainterPrivate::updateStateImpl(QPainterState *newState)
+{
+    // ### we might have to call QPainter::begin() here...
+    if (!engine->state) {
+        engine->state = newState;
+        engine->setDirty(QPaintEngine::AllDirty);
+    }
+
+    if (engine->state->painter() != newState->painter)
+        // ### this could break with clip regions vs paths.
+        engine->setDirty(QPaintEngine::AllDirty);
+
+    // Upon restore, revert all changes since last save
+    else if (engine->state != newState)
+        newState->dirtyFlags |= QPaintEngine::DirtyFlags(static_cast<QPainterState *>(engine->state)->changeFlags);
+
+    // We need to store all changes made so that restore can deal with them
+    else
+        newState->changeFlags |= newState->dirtyFlags;
+
+    updateEmulationSpecifier(newState);
+
+    // Unset potential dirty background mode
+    newState->dirtyFlags &= ~(QPaintEngine::DirtyBackgroundMode
+            | QPaintEngine::DirtyBackground);
+
+    engine->state = newState;
+    engine->updateState(*newState);
+    engine->clearDirty(QPaintEngine::AllDirty);
+
+}
+
+void QPainterPrivate::updateState(QPainterState *newState)
+{
+
+    if (!newState) {
+        engine->state = newState;
+
+    } else if (newState->state() || engine->state!=newState) {
+        bool setNonCosmeticPen = (newState->renderHints & QPainter::NonCosmeticDefaultPen)
+                                 && newState->pen.widthF() == 0;
+        if (setNonCosmeticPen) {
+            // Override the default pen's cosmetic state if the
+            // NonCosmeticDefaultPen render hint is used.
+            QPen oldPen = newState->pen;
+            newState->pen.setWidth(1);
+            newState->pen.setCosmetic(false);
+            newState->dirtyFlags |= QPaintEngine::DirtyPen;
+
+            updateStateImpl(newState);
+
+            // Restore the state pen back to its default to preserve visible
+            // state.
+            newState->pen = oldPen;
+        } else {
+            updateStateImpl(newState);
+        }
+    }
+}
+
+
+/*!
+    \class QPainter
+    \brief The QPainter class performs low-level painting on widgets and
+    other paint devices.
+
+    \ingroup painting
+
+    \reentrant
+
+    QPainter provides highly optimized functions to do most of the
+    drawing GUI programs require. It can draw everything from simple
+    lines to complex shapes like pies and chords. It can also draw
+    aligned text and pixmaps. Normally, it draws in a "natural"
+    coordinate system, but it can also do view and world
+    transformation. QPainter can operate on any object that inherits
+    the QPaintDevice class.
+
+    The common use of QPainter is inside a widget's paint event:
+    Construct and customize (e.g. set the pen or the brush) the
+    painter. Then draw. Remember to destroy the QPainter object after
+    drawing. For example:
+
+    \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 0
+
+    The core functionality of QPainter is drawing, but the class also
+    provide several functions that allows you to customize QPainter's
+    settings and its rendering quality, and others that enable
+    clipping. In addition you can control how different shapes are
+    merged together by specifying the painter's composition mode.
+
+    The isActive() function indicates whether the painter is active. A
+    painter is activated by the begin() function and the constructor
+    that takes a QPaintDevice argument. The end() function, and the
+    destructor, deactivates it.
+
+    Together with the QPaintDevice and QPaintEngine classes, QPainter
+    form the basis for Qt's paint system. QPainter is the class used
+    to perform drawing operations. QPaintDevice represents a device
+    that can be painted on using a QPainter. QPaintEngine provides the
+    interface that the painter uses to draw onto different types of
+    devices. If the painter is active, device() returns the paint
+    device on which the painter paints, and paintEngine() returns the
+    paint engine that the painter is currently operating on. For more
+    information, see the \l {Paint System}.
+
+    Sometimes it is desirable to make someone else paint on an unusual
+    QPaintDevice. QPainter supports a static function to do this,
+    setRedirected().
+
+    \warning When the paintdevice is a widget, QPainter can only be
+    used inside a paintEvent() function or in a function called by
+    paintEvent(); that is unless the Qt::WA_PaintOutsidePaintEvent
+    widget attribute is set. On Mac OS X and Windows, you can only
+    paint in a paintEvent() function regardless of this attribute's
+    setting.
+
+    \tableofcontents
+
+    \section1 Settings
+
+    There are several settings that you can customize to make QPainter
+    draw according to your preferences:
+
+    \list
+
+    \o font() is the font used for drawing text. If the painter
+        isActive(), you can retrieve information about the currently set
+        font, and its metrics, using the fontInfo() and fontMetrics()
+        functions respectively.
+
+    \o brush() defines the color or pattern that is used for filling
+       shapes.
+
+    \o pen() defines the color or stipple that is used for drawing
+       lines or boundaries.
+
+    \o backgroundMode() defines whether there is a background() or
+       not, i.e it is either Qt::OpaqueMode or Qt::TransparentMode.
+
+    \o background() only applies when backgroundMode() is \l
+       Qt::OpaqueMode and pen() is a stipple. In that case, it
+       describes the color of the background pixels in the stipple.
+
+    \o brushOrigin() defines the origin of the tiled brushes, normally
+       the origin of widget's background.
+
+    \o viewport(), window(), worldTransform() make up the painter's coordinate
+        transformation system. For more information, see the \l
+        {Coordinate Transformations} section and the \l {Coordinate
+        System} documentation.
+
+    \o hasClipping() tells whether the painter clips at all. (The paint
+       device clips, too.) If the painter clips, it clips to clipRegion().
+
+    \o layoutDirection() defines the layout direction used by the
+       painter when drawing text.
+
+    \o worldMatrixEnabled() tells whether world transformation is enabled.
+
+    \o viewTransformEnabled() tells whether view transformation is
+        enabled.
+
+    \endlist
+
+    Note that some of these settings mirror settings in some paint
+    devices, e.g.  QWidget::font(). The QPainter::begin() function (or
+    equivalently the QPainter constructor) copies these attributes
+    from the paint device.
+
+    You can at any time save the QPainter's state by calling the
+    save() function which saves all the available settings on an
+    internal stack. The restore() function pops them back.
+
+    \section1 Drawing
+
+    QPainter provides functions to draw most primitives: drawPoint(),
+    drawPoints(), drawLine(), drawRect(), drawRoundedRect(),
+    drawEllipse(), drawArc(), drawPie(), drawChord(), drawPolyline(),
+    drawPolygon(), drawConvexPolygon() and drawCubicBezier().  The two
+    convenience functions, drawRects() and drawLines(), draw the given
+    number of rectangles or lines in the given array of \l
+    {QRect}{QRects} or \l {QLine}{QLines} using the current pen and
+    brush.
+
+    The QPainter class also provides the fillRect() function which
+    fills the given QRect, with the given QBrush, and the eraseRect()
+    function that erases the area inside the given rectangle.
+
+    All of these functions have both integer and floating point
+    versions.
+
+    \table 100%
+    \row
+    \o \inlineimage qpainter-basicdrawing.png
+    \o
+    \bold {Basic Drawing Example}
+
+    The \l {painting/basicdrawing}{Basic Drawing} example shows how to
+    display basic graphics primitives in a variety of styles using the
+    QPainter class.
+
+    \endtable
+
+    If you need to draw a complex shape, especially if you need to do
+    so repeatedly, consider creating a QPainterPath and drawing it
+    using drawPath().
+
+    \table 100%
+    \row
+    \o
+    \bold {Painter Paths example}
+
+    The QPainterPath class provides a container for painting
+    operations, enabling graphical shapes to be constructed and
+    reused.
+
+    The \l {painting/painterpaths}{Painter Paths} example shows how
+    painter paths can be used to build complex shapes for rendering.
+
+    \o \inlineimage qpainter-painterpaths.png
+    \endtable
+
+    QPainter also provides the fillPath() function which fills the
+    given QPainterPath with the given QBrush, and the strokePath()
+    function that draws the outline of the given path (i.e. strokes
+    the path).
+
+    See also the \l {demos/deform}{Vector Deformation} demo which
+    shows how to use advanced vector techniques to draw text using a
+    QPainterPath, the \l {demos/gradients}{Gradients} demo which shows
+    the different types of gradients that are available in Qt, and the \l
+    {demos/pathstroke}{Path Stroking} demo which shows Qt's built-in
+    dash patterns and shows how custom patterns can be used to extend
+    the range of available patterns.
+
+    \table
+    \header
+    \o \l {demos/deform}{Vector Deformation}
+    \o \l {demos/gradients}{Gradients}
+    \o \l {demos/pathstroke}{Path Stroking}
+    \row
+    \o \inlineimage qpainter-vectordeformation.png
+    \o \inlineimage qpainter-gradients.png
+    \o \inlineimage qpainter-pathstroking.png
+    \endtable
+
+
+    There are functions to draw pixmaps/images, namely drawPixmap(),
+    drawImage() and drawTiledPixmap(). Both drawPixmap() and drawImage()
+    produce the same result, except that drawPixmap() is faster
+    on-screen while drawImage() may be faster on a QPrinter or other
+    devices.
+
+    Text drawing is done using drawText(). When you need
+    fine-grained positioning, boundingRect() tells you where a given
+    drawText() command will draw.
+
+    There is a drawPicture() function that draws the contents of an
+    entire QPicture. The drawPicture() function is the only function
+    that disregards all the painter's settings as QPicture has its own
+    settings.
+
+    \section1 Rendering Quality
+
+    To get the optimal rendering result using QPainter, you should use
+    the platform independent QImage as paint device; i.e. using QImage
+    will ensure that the result has an identical pixel representation
+    on any platform.
+
+    The QPainter class also provides a means of controlling the
+    rendering quality through its RenderHint enum and the support for
+    floating point precision: All the functions for drawing primitives
+    has a floating point version. These are often used in combination
+    with the \l {RenderHint}{QPainter::Antialiasing} render hint.
+
+    \table 100%
+    \row
+    \o \inlineimage qpainter-concentriccircles.png
+    \o
+    \bold {Concentric Circles Example}
+
+    The \l {painting/concentriccircles}{Concentric Circles} example
+    shows the improved rendering quality that can be obtained using
+    floating point precision and anti-aliasing when drawing custom
+    widgets.
+
+    The application's main window displays several widgets which are
+    drawn using the various combinations of precision and
+    anti-aliasing.
+
+    \endtable
+
+    The RenderHint enum specifies flags to QPainter that may or may
+    not be respected by any given engine.  \l
+    {RenderHint}{QPainter::Antialiasing} indicates that the engine
+    should antialias edges of primitives if possible, \l
+    {RenderHint}{QPainter::TextAntialiasing} indicates that the engine
+    should antialias text if possible, and the \l
+    {RenderHint}{QPainter::SmoothPixmapTransform} indicates that the
+    engine should use a smooth pixmap transformation algorithm.
+    \l {RenderHint}{HighQualityAntialiasing} is an OpenGL-specific rendering hint
+    indicating that the engine should use fragment programs and offscreen
+    rendering for antialiasing.
+
+    The renderHints() function returns a flag that specifies the
+    rendering hints that are set for this painter.  Use the
+    setRenderHint() function to set or clear the currently set
+    RenderHints.
+
+    \section1 Coordinate Transformations
+
+    Normally, the QPainter operates on the device's own coordinate
+    system (usually pixels), but QPainter has good support for
+    coordinate transformations.
+
+    \table
+    \header
+    \o  nop \o rotate() \o scale() \o translate()
+    \row
+    \o \inlineimage qpainter-clock.png
+    \o \inlineimage qpainter-rotation.png
+    \o \inlineimage qpainter-scale.png
+    \o \inlineimage qpainter-translation.png
+    \endtable
+
+    The most commonly used transformations are scaling, rotation,
+    translation and shearing. Use the scale() function to scale the
+    coordinate system by a given offset, the rotate() function to
+    rotate it clockwise and translate() to translate it (i.e. adding a
+    given offset to the points). You can also twist the coordinate
+    system around the origin using the shear() function. See the \l
+    {demos/affine}{Affine Transformations} demo for a visualization of
+    a sheared coordinate system.
+
+    See also the \l {painting/transformations}{Transformations}
+    example which shows how transformations influence the way that
+    QPainter renders graphics primitives. In particular it shows how
+    the order of transformations affects the result.
+
+    \table 100%
+    \row
+    \o
+    \bold {Affine Transformations Demo}
+
+    The \l {demos/affine}{Affine Transformations} demo show Qt's
+    ability to perform affine transformations on painting
+    operations. The demo also allows the user to experiment with the
+    transformation operations and see the results immediately.
+
+    \o \inlineimage qpainter-affinetransformations.png
+    \endtable
+
+    All the tranformation operations operate on the transformation
+    worldTransform(). A matrix transforms a point in the plane to another
+    point. For more information about the transformation matrix, see
+    the \l {Coordinate System} and QTransform documentation.
+
+    The setWorldTransform() function can replace or add to the currently
+    set worldTransform(). The resetTransform() function resets any
+    transformations that were made using translate(), scale(),
+    shear(), rotate(), setWorldTransform(), setViewport() and setWindow()
+    functions. The deviceTransform() returns the matrix that transforms
+    from logical coordinates to device coordinates of the platform
+    dependent paint device. The latter function is only needed when
+    using platform painting commands on the platform dependent handle,
+    and the platform does not do transformations nativly.
+
+    When drawing with QPainter, we specify points using logical
+    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 combinedTransform(), a
+    combination of viewport() and window() and worldTransform(). The
+    viewport() represents the physical coordinates specifying an
+    arbitrary rectangle, the window() describes the same rectangle in
+    logical coordinates, and the worldTransform() is identical with the
+    transformation matrix.
+
+    See also \l {Coordinate System}
+
+    \section1 Clipping
+
+    QPainter can clip any drawing operation to a rectangle, a region,
+    or a vector path. The current clip is available using the
+    functions clipRegion() and clipPath(). Whether paths or regions are
+    preferred (faster) depends on the underlying paintEngine(). For
+    example, the QImage paint engine prefers paths while the X11 paint
+    engine prefers regions. Setting a clip is done in the painters
+    logical coordinates.
+
+    After QPainter's clipping, the paint device may also clip. For
+    example, most widgets clip away the pixels used by child widgets,
+    and most printers clip away an area near the edges of the paper.
+    This additional clipping is not reflected by the return value of
+    clipRegion() or hasClipping().
+
+    \section1 Composition Modes
+    \target Composition Modes
+
+    QPainter provides the CompositionMode enum which defines the
+    Porter-Duff rules for digital image compositing; it describes a
+    model for combining the pixels in one image, the source, with the
+    pixels in another image, the destination.
+
+    The two most common forms of composition are \l
+    {QPainter::CompositionMode}{Source} and \l
+    {QPainter::CompositionMode}{SourceOver}.  \l
+    {QPainter::CompositionMode}{Source} is used to draw opaque objects
+    onto a paint device. In this mode, each pixel in the source
+    replaces the corresponding pixel in the destination. In \l
+    {QPainter::CompositionMode}{SourceOver} composition mode, the
+    source object is transparent and is drawn on top of the
+    destination.
+
+    Note that composition transformation operates pixelwise. For that
+    reason, there is a difference between using the graphic primitive
+    itself and its bounding rectangle: The bounding rect contains
+    pixels with alpha == 0 (i.e the pixels surrounding the
+    primitive). These pixels will overwrite the other image's pixels,
+    affectively clearing those, while the primitive only overwrites
+    its own area.
+
+    \table 100%
+    \row
+    \o \inlineimage qpainter-compositiondemo.png
+
+    \o
+    \bold {Composition Modes Demo}
+
+    The \l {demos/composition}{Composition Modes} demo, available in
+    Qt's demo directory, allows you to experiment with the various
+    composition modes and see the results immediately.
+
+    \endtable
+
+    \section1 Limitations
+    \target Limitations
+
+    If you are using coordinates with Qt's raster-based paint engine, it is
+    important to note that, while coordinates greater than +/- 2\sup 15 can
+    be used, any painting performed with coordinates outside this range is not
+    guaranteed to be shown; the drawing may be clipped. This is due to the
+    use of \c{short int} in the implementation.
+
+    The outlines generated by Qt's stroker are only an approximation when dealing
+    with curved shapes. It is in most cases impossible to represent the outline of
+    a bezier curve segment using another bezier curve segment, and so Qt approximates
+    the curve outlines by using several smaller curves. For performance reasons there
+    is a limit to how many curves Qt uses for these outlines, and thus when using
+    large pen widths or scales the outline error increases. To generate outlines with
+    smaller errors it is possible to use the QPainterPathStroker class, which has the
+    setCurveThreshold member function which let's the user specify the error tolerance.
+    Another workaround is to convert the paths to polygons first and then draw the
+    polygons instead.
+
+    \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, where 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 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}
+*/
+
+/*!
+    \enum QPainter::RenderHint
+
+    Renderhints are used to specify flags to QPainter that may or
+    may not be respected by any given engine.
+
+    \value Antialiasing Indicates that the engine should antialias
+    edges of primitives if possible.
+
+    \value TextAntialiasing Indicates that the engine should antialias
+    text if possible. To forcibly disable antialiasing for text, do not
+    use this hint. Instead, set QFont::NoAntialias on your font's style
+    strategy.
+
+    \value SmoothPixmapTransform Indicates that the engine should use
+    a smooth pixmap transformation algorithm (such as bilinear) rather
+    than nearest neighbor.
+
+    \value HighQualityAntialiasing An OpenGL-specific rendering hint
+    indicating that the engine should use fragment programs and offscreen
+    rendering for antialiasing.
+
+    \value NonCosmeticDefaultPen The engine should interpret pens with a width
+    of 0 (which otherwise enables QPen::isCosmetic()) as being a non-cosmetic
+    pen with a width of 1.
+
+    \sa renderHints(), setRenderHint(), {QPainter#Rendering
+    Quality}{Rendering Quality}, {Concentric Circles Example}
+
+*/
+
+/*!
+    Constructs a painter.
+
+    \sa begin(), end()
+*/
+
+QPainter::QPainter()
+    : d_ptr(new QPainterPrivate(this))
+{
+}
+
+/*!
+    \fn QPainter::QPainter(QPaintDevice *device)
+
+    Constructs a painter that begins painting the paint \a device
+    immediately.
+
+    This constructor is convenient for short-lived painters, e.g. in a
+    QWidget::paintEvent() and should be used only once. The
+    constructor calls begin() for you and the QPainter destructor
+    automatically calls end().
+
+    Here's an example using begin() and end():
+    \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 1
+
+    The same example using this constructor:
+    \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 2
+
+    Since the constructor cannot provide feedback when the initialization
+    of the painter failed you should rather use begin() and end() to paint
+    on external devices, e.g. printers.
+
+    \sa begin(), end()
+*/
+
+QPainter::QPainter(QPaintDevice *pd)
+    : d_ptr(0)
+{
+    Q_ASSERT(pd != 0);
+    if (!QPainterPrivate::attachPainterPrivate(this, pd)) {
+        d_ptr.reset(new QPainterPrivate(this));
+        begin(pd);
+    }
+    Q_ASSERT(d_ptr);
+}
+
+/*!
+    Destroys the painter.
+*/
+QPainter::~QPainter()
+{
+    d_ptr->inDestructor = true;
+    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.
+        Q_ASSERT(d_ptr->inDestructor);
+        d_ptr->inDestructor = false;
+        Q_ASSERT(d_ptr->refcount == 1);
+        if (d_ptr->d_ptrs)
+            free(d_ptr->d_ptrs);
+    }
+}
+
+/*!
+    Returns the paint device on which this painter is currently
+    painting, or 0 if the painter is not active.
+
+    \sa isActive()
+*/
+
+QPaintDevice *QPainter::device() const
+{
+    Q_D(const QPainter);
+    if (isActive() && d->engine->d_func()->currentClipWidget)
+        return d->engine->d_func()->currentClipWidget;
+    return d->original_device;
+}
+
+/*!
+    Returns true if begin() has been called and end() has not yet been
+    called; otherwise returns false.
+
+    \sa begin(), QPaintDevice::paintingActive()
+*/
+
+bool QPainter::isActive() const
+{
+    Q_D(const QPainter);
+    return d->engine;
+}
+
+/*!
+    Initializes the painters pen, background and font to the same as
+    the given \a widget. This function is called automatically when the
+    painter is opened on a QWidget.
+
+    \sa begin(), {QPainter#Settings}{Settings}
+*/
+void QPainter::initFrom(const QWidget *widget)
+{
+    Q_ASSERT_X(widget, "QPainter::initFrom(const QWidget *widget)", "Widget cannot be 0");
+    Q_D(QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::initFrom: Painter not active, aborted");
+        return;
+    }
+
+    const QPalette &pal = widget->palette();
+    d->state->pen = QPen(pal.brush(widget->foregroundRole()), 0);
+    d->state->bgBrush = pal.brush(widget->backgroundRole());
+    d->state->deviceFont = QFont(widget->font(), const_cast<QWidget*> (widget));
+    d->state->font = d->state->deviceFont;
+    if (d->extended) {
+        d->extended->penChanged();
+    } else if (d->engine) {
+        d->engine->setDirty(QPaintEngine::DirtyPen);
+        d->engine->setDirty(QPaintEngine::DirtyBrush);
+        d->engine->setDirty(QPaintEngine::DirtyFont);
+    }
+}
+
+
+/*!
+    Saves the current painter state (pushes the state onto a stack). A
+    save() must be followed by a corresponding restore(); the end()
+    function unwinds the stack.
+
+    \sa restore()
+*/
+
+void QPainter::save()
+{
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::save()\n");
+#endif
+    Q_D(QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::save: Painter not active");
+        return;
+    }
+
+    if (d->extended) {
+        d->state = d->extended->createState(d->states.back());
+        d->extended->setState(d->state);
+    } else {
+        d->updateState(d->state);
+        d->state = new QPainterState(d->states.back());
+        d->engine->state = d->state;
+    }
+    d->states.push_back(d->state);
+}
+
+/*!
+    Restores the current painter state (pops a saved state off the
+    stack).
+
+    \sa save()
+*/
+
+void QPainter::restore()
+{
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::restore()\n");
+#endif
+    Q_D(QPainter);
+    if (d->states.size()<=1) {
+        qWarning("QPainter::restore: Unbalanced save/restore");
+        return;
+    } else if (!d->engine) {
+        qWarning("QPainter::restore: Painter not active");
+        return;
+    }
+
+    QPainterState *tmp = d->state;
+    d->states.pop_back();
+    d->state = d->states.back();
+    d->txinv = false;
+
+    if (d->extended) {
+        d->checkEmulation();
+        d->extended->setState(d->state);
+        delete tmp;
+        return;
+    }
+
+    // trigger clip update if the clip path/region has changed since
+    // last save
+    if (!d->state->clipInfo.isEmpty()
+        && (tmp->changeFlags & (QPaintEngine::DirtyClipRegion | QPaintEngine::DirtyClipPath))) {
+        // reuse the tmp state to avoid any extra allocs...
+        tmp->dirtyFlags = QPaintEngine::DirtyClipPath;
+        tmp->clipOperation = Qt::NoClip;
+        tmp->clipPath = QPainterPath();
+        d->engine->updateState(*tmp);
+        // replay the list of clip states,
+        for (int i=0; i<d->state->clipInfo.size(); ++i) {
+            const QPainterClipInfo &info = d->state->clipInfo.at(i);
+            tmp->matrix = info.matrix;
+            tmp->matrix *= d->state->redirectionMatrix;
+            tmp->clipOperation = info.operation;
+            if (info.clipType == QPainterClipInfo::RectClip) {
+                tmp->dirtyFlags = QPaintEngine::DirtyClipRegion | QPaintEngine::DirtyTransform;
+                tmp->clipRegion = info.rect;
+            } else if (info.clipType == QPainterClipInfo::RegionClip) {
+                tmp->dirtyFlags = QPaintEngine::DirtyClipRegion | QPaintEngine::DirtyTransform;
+                tmp->clipRegion = info.region;
+            } else { // clipType == QPainterClipInfo::PathClip
+                tmp->dirtyFlags = QPaintEngine::DirtyClipPath | QPaintEngine::DirtyTransform;
+                tmp->clipPath = info.path;
+            }
+            d->engine->updateState(*tmp);
+        }
+
+
+        //Since we've updated the clip region anyway, pretend that the clip path hasn't changed:
+        d->state->dirtyFlags &= ~(QPaintEngine::DirtyClipPath | QPaintEngine::DirtyClipRegion);
+        tmp->changeFlags &= ~(QPaintEngine::DirtyClipPath | QPaintEngine::DirtyClipRegion);
+        tmp->changeFlags |= QPaintEngine::DirtyTransform;
+    }
+
+    d->updateState(d->state);
+    delete tmp;
+}
+
+
+/*!
+
+    \fn bool QPainter::begin(QPaintDevice *device)
+
+    Begins painting the paint \a device and returns true if
+    successful; otherwise returns false.
+
+    Notice that all painter settings (setPen(), setBrush() etc.) are reset
+    to default values when begin() is called.
+
+    The errors that can occur are serious problems, such as these:
+
+    \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 3
+
+    Note that most of the time, you can use one of the constructors
+    instead of begin(), and that end() is automatically done at
+    destruction.
+
+    \warning A paint device can only be painted by one painter at a
+    time.
+
+    \warning Painting on a QImage with the format
+    QImage::Format_Indexed8 is not supported.
+
+    \sa end(), QPainter()
+*/
+
+static inline void qt_cleanup_painter_state(QPainterPrivate *d)
+{
+    d->states.clear();
+    delete d->state;
+    d->state = 0;
+    d->engine = 0;
+    d->device = 0;
+}
+
+bool QPainter::begin(QPaintDevice *pd)
+{
+    Q_ASSERT(pd);
+
+    if (pd->painters > 0) {
+        qWarning("QPainter::begin: A paint device can only be painted by one painter at a time.");
+        return false;
+    }
+
+    if (d_ptr->engine) {
+        qWarning("QPainter::begin: Painter already active");
+        return false;
+    }
+
+    if (QPainterPrivate::attachPainterPrivate(this, pd))
+        return true;
+
+    Q_D(QPainter);
+
+    d->helper_device = pd;
+    d->original_device = pd;
+    QPaintDevice *rpd = 0;
+
+    QPoint redirectionOffset;
+    // We know for sure that redirection is broken when the widget is inside
+    // its paint event, so it's safe to use our hard-coded redirection. However,
+    // there IS one particular case we still need to support, and that's
+    // when people call QPainter::setRedirected in the widget's paint event right
+    // before any painter is created (or QPainter::begin is called). In that
+    // particular case our hard-coded redirection is restored and the redirection
+    // is retrieved from QPainter::redirected (as before).
+    if (pd->devType() == QInternal::Widget)
+        rpd = static_cast<QWidget *>(pd)->d_func()->redirected(&redirectionOffset);
+
+    if (!rpd)
+        rpd = redirected(pd, &redirectionOffset);
+
+    if (rpd)
+        pd = rpd;
+
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::begin(), device=%p, type=%d\n", pd, pd->devType());
+#endif
+
+    if (pd->devType() == QInternal::Pixmap)
+        static_cast<QPixmap *>(pd)->detach();
+    else if (pd->devType() == QInternal::Image)
+        static_cast<QImage *>(pd)->detach();
+
+    d->engine = pd->paintEngine();
+
+    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;
+
+    // Setup new state...
+    Q_ASSERT(!d->state);
+    d->state = d->extended ? d->extended->createState(0) : new QPainterState;
+    d->state->painter = this;
+    d->states.push_back(d->state);
+
+    d->state->redirectionMatrix.translate(-redirectionOffset.x(), -redirectionOffset.y());
+    d->state->brushOrigin = QPointF();
+
+    // Slip a painter state into the engine before we do any other operations
+    if (d->extended)
+        d->extended->setState(d->state);
+    else
+        d->engine->state = d->state;
+
+    switch (pd->devType()) {
+        case QInternal::Widget:
+        {
+            const QWidget *widget = static_cast<const QWidget *>(pd);
+            Q_ASSERT(widget);
+
+            const bool paintOutsidePaintEvent = widget->testAttribute(Qt::WA_PaintOutsidePaintEvent);
+            const bool inPaintEvent = widget->testAttribute(Qt::WA_WState_InPaintEvent);
+            if(!d->engine->hasFeature(QPaintEngine::PaintOutsidePaintEvent)
+                && !paintOutsidePaintEvent && !inPaintEvent) {
+                qWarning("QPainter::begin: Widget painting can only begin as a "
+                         "result of a paintEvent");
+                qt_cleanup_painter_state(d);
+                return false;
+            }
+
+            // Adjust offset for alien widgets painting outside the paint event.
+            if (!inPaintEvent && paintOutsidePaintEvent && !widget->internalWinId()
+                && widget->testAttribute(Qt::WA_WState_Created)) {
+                const QPoint offset = widget->mapTo(widget->nativeParentWidget(), QPoint());
+                d->state->redirectionMatrix.translate(offset.x(), offset.y());
+            }
+            break;
+        }
+        case QInternal::Pixmap:
+        {
+            QPixmap *pm = static_cast<QPixmap *>(pd);
+            Q_ASSERT(pm);
+            if (pm->isNull()) {
+                qWarning("QPainter::begin: Cannot paint on a null pixmap");
+                qt_cleanup_painter_state(d);
+                return false;
+            }
+
+            if (pm->depth() == 1) {
+                d->state->pen = QPen(Qt::color1);
+                d->state->brush = QBrush(Qt::color0);
+            }
+            break;
+        }
+        case QInternal::Image:
+        {
+            QImage *img = static_cast<QImage *>(pd);
+            Q_ASSERT(img);
+            if (img->isNull()) {
+                qWarning("QPainter::begin: Cannot paint on a null image");
+                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;
+            }
+            if (img->depth() == 1) {
+                d->state->pen = QPen(Qt::color1);
+                d->state->brush = QBrush(Qt::color0);
+            }
+            break;
+        }
+        default:
+            break;
+    }
+    if (d->state->ww == 0) // For compat with 3.x painter defaults
+        d->state->ww = d->state->wh = d->state->vw = d->state->vh = 1024;
+
+    d->engine->setPaintDevice(pd);
+
+    bool begun = d->engine->begin(pd);
+    if (!begun) {
+        qWarning("QPainter::begin(): Returned false");
+        if (d->engine->isActive()) {
+            end();
+        } else {
+            qt_cleanup_painter_state(d);
+        }
+        return false;
+    } else {
+        d->engine->setActive(begun);
+    }
+
+    // Copy painter properties from original paint device,
+    // required for QPixmap::grabWidget()
+    if (d->original_device->devType() == QInternal::Widget) {
+        QWidget *widget = static_cast<QWidget *>(d->original_device);
+        initFrom(widget);
+    } else {
+        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());
+    }
+
+    QRect systemRect = d->engine->systemRect();
+    if (!systemRect.isEmpty()) {
+        d->state->ww = d->state->vw = systemRect.width();
+        d->state->wh = d->state->vh = systemRect.height();
+    } else {
+        d->state->ww = d->state->vw = pd->metric(QPaintDevice::PdmWidth);
+        d->state->wh = d->state->vh = pd->metric(QPaintDevice::PdmHeight);
+    }
+
+    const QPoint coordinateOffset = d->engine->coordinateOffset();
+    d->state->redirectionMatrix.translate(-coordinateOffset.x(), -coordinateOffset.y());
+
+    Q_ASSERT(d->engine->isActive());
+
+    if (!d->state->redirectionMatrix.isIdentity())
+        d->updateMatrix();
+
+    Q_ASSERT(d->engine->isActive());
+    d->state->renderHints = QPainter::TextAntialiasing;
+    ++d->device->painters;
+
+    d->state->emulationSpecifier = 0;
+
+    return true;
+}
+
+/*!
+    Ends painting. Any resources used while painting are released. You
+    don't normally need to call this since it is called by the
+    destructor.
+
+    Returns true if the painter is no longer active; otherwise returns false.
+
+    \sa begin(), isActive()
+*/
+
+bool QPainter::end()
+{
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::end()\n");
+#endif
+    Q_D(QPainter);
+
+    if (!d->engine) {
+        qWarning("QPainter::end: Painter not active, aborted");
+        qt_cleanup_painter_state(d);
+        return false;
+    }
+
+    if (d->refcount > 1) {
+        d->detachPainterPrivate(this);
+        return true;
+    }
+
+    bool ended = true;
+
+    if (d->engine->isActive()) {
+        ended = d->engine->end();
+        d->updateState(0);
+
+        --d->device->painters;
+        if (d->device->painters == 0) {
+            d->engine->setPaintDevice(0);
+            d->engine->setActive(false);
+        }
+    }
+
+    if (d->states.size() > 1) {
+        qWarning("QPainter::end: Painter ended with %d saved states",
+                 d->states.size());
+    }
+
+    if (d->engine->autoDestruct()) {
+        delete d->engine;
+    }
+
+    if (d->emulationEngine) {
+        delete d->emulationEngine;
+        d->emulationEngine = 0;
+    }
+
+    if (d->extended) {
+        d->extended = 0;
+    }
+
+    qt_cleanup_painter_state(d);
+
+    return ended;
+}
+
+
+/*!
+    Returns the paint engine that the painter is currently operating
+    on if the painter is active; otherwise 0.
+
+    \sa isActive()
+*/
+QPaintEngine *QPainter::paintEngine() const
+{
+    Q_D(const QPainter);
+    return d->engine;
+}
+
+/*!
+    \since 4.6
+
+    Flushes the painting pipeline and prepares for the user issuing commands
+    directly to the underlying graphics context. Must be followed by a call to
+    endNativePainting().
+
+    Note that only the states the underlying paint engine changes will be reset
+    to their respective default states. The states we reset may change from
+    release to release. The following states are currently reset in the OpenGL
+    2 engine:
+
+    \list
+    \i blending is disabled
+    \i the depth, stencil and scissor tests are disabled
+    \i the active texture unit is reset to 0
+    \i the depth mask, depth function and the clear depth are reset to their
+    default values
+    \i the stencil mask, stencil operation and stencil function are reset to
+    their default values
+     \i the current color is reset to solid white
+    \endlist
+
+    If, for example, the OpenGL polygon mode is changed by the user inside a
+    beginNativePaint()/endNativePainting() block, it will not be reset to the
+    default state by endNativePainting(). Here is an example that shows
+    intermixing of painter commands and raw OpenGL commands:
+
+    \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 21
+
+    \sa endNativePainting()
+*/
+void QPainter::beginNativePainting()
+{
+    Q_D(QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::beginNativePainting: Painter not active");
+        return;
+    }
+
+    if (d->extended)
+        d->extended->beginNativePainting();
+}
+
+/*!
+    \since 4.6
+
+    Restores the painter after manually issuing native painting commands. Lets
+    the painter restore any native state that it relies on before calling any
+    other painter commands.
+
+    \sa beginNativePainting()
+*/
+void QPainter::endNativePainting()
+{
+    Q_D(const QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::beginNativePainting: Painter not active");
+        return;
+    }
+
+    if (d->extended)
+        d->extended->endNativePainting();
+    else
+        d->engine->syncState();
+}
+
+/*!
+    Returns the font metrics for the painter if the painter is
+    active. Otherwise, the return value is undefined.
+
+    \sa font(), isActive(), {QPainter#Settings}{Settings}
+*/
+
+QFontMetrics QPainter::fontMetrics() const
+{
+    Q_D(const QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::fontMetrics: Painter not active");
+        return QFontMetrics(QFont());
+    }
+    return QFontMetrics(d->state->font);
+}
+
+
+/*!
+    Returns the font info for the painter if the painter is
+    active. Otherwise, the return value is undefined.
+
+    \sa font(), isActive(), {QPainter#Settings}{Settings}
+*/
+
+QFontInfo QPainter::fontInfo() const
+{
+    Q_D(const QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::fontInfo: Painter not active");
+        return QFontInfo(QFont());
+    }
+    return QFontInfo(d->state->font);
+}
+
+/*!
+    \since 4.2
+
+    Returns the opacity of the painter. The default value is
+    1.
+*/
+
+qreal QPainter::opacity() const
+{
+    Q_D(const QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::opacity: Painter not active");
+        return 1.0;
+    }
+    return d->state->opacity;
+}
+
+/*!
+    \since 4.2
+
+    Sets the opacity of the painter to \a opacity. The value should
+    be in the range 0.0 to 1.0, where 0.0 is fully transparent and
+    1.0 is fully opaque.
+
+    Opacity set on the painter will apply to all drawing operations
+    individually.
+*/
+
+void QPainter::setOpacity(qreal opacity)
+{
+    Q_D(QPainter);
+
+    if (!d->engine) {
+        qWarning("QPainter::setOpacity: Painter not active");
+        return;
+    }
+
+    opacity = qMin(qreal(1), qMax(qreal(0), opacity));
+
+    if (opacity == d->state->opacity)
+        return;
+
+    d->state->opacity = opacity;
+
+    if (d->extended)
+        d->extended->opacityChanged();
+    else
+        d->state->dirtyFlags |= QPaintEngine::DirtyOpacity;
+}
+
+
+/*!
+    Returns the currently set brush origin.
+
+    \sa setBrushOrigin(), {QPainter#Settings}{Settings}
+*/
+
+QPoint QPainter::brushOrigin() const
+{
+    Q_D(const QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::brushOrigin: Painter not active");
+        return QPoint();
+    }
+    return QPointF(d->state->brushOrigin).toPoint();
+}
+
+/*!
+    \fn void QPainter::setBrushOrigin(const QPointF &position)
+
+    Sets the brush origin to \a position.
+
+    The brush origin specifies the (0, 0) coordinate of the painter's
+    brush.
+
+    Note that while the brushOrigin() was necessary to adopt the
+    parent's background for a widget in Qt 3, this is no longer the
+    case since the Qt 4 painter doesn't paint the background unless
+    you explicitly tell it to do so by setting the widget's \l
+    {QWidget::autoFillBackground}{autoFillBackground} property to
+    true.
+
+    \sa brushOrigin(), {QPainter#Settings}{Settings}
+*/
+
+void QPainter::setBrushOrigin(const QPointF &p)
+{
+    Q_D(QPainter);
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::setBrushOrigin(), (%.2f,%.2f)\n", p.x(), p.y());
+#endif
+
+    if (!d->engine) {
+        qWarning("QPainter::setBrushOrigin: Painter not active");
+        return;
+    }
+
+    d->state->brushOrigin = p;
+
+    if (d->extended) {
+        d->extended->brushOriginChanged();
+        return;
+    }
+
+    d->state->dirtyFlags |= QPaintEngine::DirtyBrushOrigin;
+}
+
+/*!
+    \fn void QPainter::setBrushOrigin(const QPoint &position)
+    \overload
+
+    Sets the brush's origin to the given \a position.
+*/
+
+/*!
+    \fn void QPainter::setBrushOrigin(int x, int y)
+
+    \overload
+
+    Sets the brush's origin to point (\a x, \a y).
+*/
+
+/*!
+    \enum QPainter::CompositionMode
+
+    Defines the modes supported for digital image compositing.
+    Composition modes are used to specify how the pixels in one image,
+    the source, are merged with the pixel in another image, the
+    destination.
+
+    Please note that the bitwise raster operation modes, denoted with
+    a RasterOp prefix, are only natively supported in the X11 and
+    raster paint engines. This means that the only way to utilize
+    these modes on the Mac is via a QImage. The RasterOp denoted blend
+    modes are \e not supported for pens and brushes with alpha
+    components. Also, turning on the QPainter::Antialiasing render
+    hint will effectively disable the RasterOp modes.
+
+
+     \image qpainter-compositionmode1.png
+     \image qpainter-compositionmode2.png
+
+    The most common type is SourceOver (often referred to as just
+    alpha blending) where the source pixel is blended on top of the
+    destination pixel in such a way that the alpha component of the
+    source defines the translucency of the pixel.
+
+    When the paint device is a QImage, the image format must be set to
+    \l {QImage::Format}{Format_ARGB32Premultiplied} or
+    \l {QImage::Format}{Format_ARGB32} for the composition modes to have
+    any effect. For performance the premultiplied version is the preferred
+    format.
+
+    When a composition mode is set it applies to all painting
+    operator, pens, brushes, gradients and pixmap/image drawing.
+
+    \value CompositionMode_SourceOver This is the default mode. The
+    alpha of the source is used to blend the pixel on top of the
+    destination.
+
+    \value CompositionMode_DestinationOver The alpha of the
+    destination is used to blend it on top of the source pixels. This
+    mode is the inverse of CompositionMode_SourceOver.
+
+    \value CompositionMode_Clear The pixels in the destination are
+    cleared (set to fully transparent) independent of the source.
+
+    \value CompositionMode_Source The output is the source
+    pixel. (This means a basic copy operation and is identical to
+    SourceOver when the source pixel is opaque).
+
+    \value CompositionMode_Destination The output is the destination
+    pixel. This means that the blending has no effect. This mode is
+    the inverse of CompositionMode_Source.
+
+    \value CompositionMode_SourceIn The output is the source, where
+    the alpha is reduced by that of the destination.
+
+    \value CompositionMode_DestinationIn The output is the
+    destination, where the alpha is reduced by that of the
+    source. This mode is the inverse of CompositionMode_SourceIn.
+
+    \value CompositionMode_SourceOut The output is the source, where
+    the alpha is reduced by the inverse of destination.
+
+    \value CompositionMode_DestinationOut The output is the
+    destination, where the alpha is reduced by the inverse of the
+    source. This mode is the inverse of CompositionMode_SourceOut.
+
+    \value CompositionMode_SourceAtop The source pixel is blended on
+    top of the destination, with the alpha of the source pixel reduced
+    by the alpha of the destination pixel.
+
+    \value CompositionMode_DestinationAtop The destination pixel is
+    blended on top of the source, with the alpha of the destination
+    pixel is reduced by the alpha of the destination pixel. This mode
+    is the inverse of CompositionMode_SourceAtop.
+
+    \value CompositionMode_Xor The source, whose alpha is reduced with
+    the inverse of the destination alpha, is merged with the
+    destination, whose alpha is reduced by the inverse of the source
+    alpha. CompositionMode_Xor is not the same as the bitwise Xor.
+
+    \value CompositionMode_Plus Both the alpha and color of the source
+    and destination pixels are added together.
+
+    \value CompositionMode_Multiply The output is the source color
+    multiplied by the destination. Multiplying a color with white
+    leaves the color unchanged, while multiplying a color
+    with black produces black.
+
+    \value CompositionMode_Screen The source and destination colors
+    are inverted and then multiplied. Screening a color with white
+    produces white, whereas screening a color with black leaves the
+    color unchanged.
+
+    \value CompositionMode_Overlay Multiplies or screens the colors
+    depending on the destination color. The destination color is mixed
+    with the source color to reflect the lightness or darkness of the
+    destination.
+
+    \value CompositionMode_Darken The darker of the source and
+    destination colors is selected.
+
+    \value CompositionMode_Lighten The lighter of the source and
+    destination colors is selected.
+
+    \value CompositionMode_ColorDodge The destination color is
+    brightened to reflect the source color. A black source color
+    leaves the destination color unchanged.
+
+    \value CompositionMode_ColorBurn The destination color is darkened
+    to reflect the source color. A white source color leaves the
+    destination color unchanged.
+
+    \value CompositionMode_HardLight Multiplies or screens the colors
+    depending on the source color. A light source color will lighten
+    the destination color, whereas a dark source color will darken the
+    destination color.
+
+    \value CompositionMode_SoftLight Darkens or lightens the colors
+    depending on the source color. Similar to
+    CompositionMode_HardLight.
+
+    \value CompositionMode_Difference Subtracts the darker of the
+    colors from the lighter.  Painting with white inverts the
+    destination color, whereas painting with black leaves the
+    destination color unchanged.
+
+    \value CompositionMode_Exclusion Similar to
+    CompositionMode_Difference, but with a lower contrast. Painting
+    with white inverts the destination color, whereas painting with
+    black leaves the destination color unchanged.
+
+    \value RasterOp_SourceOrDestination Does a bitwise OR operation on
+    the source and destination pixels (src OR dst).
+
+    \value RasterOp_SourceAndDestination Does a bitwise AND operation
+    on the source and destination pixels (src AND dst).
+
+    \value RasterOp_SourceXorDestination Does a bitwise XOR operation
+    on the source and destination pixels (src XOR dst).
+
+    \value RasterOp_NotSourceAndNotDestination Does a bitwise NOR
+    operation on the source and destination pixels ((NOT src) AND (NOT
+    dst)).
+
+    \value RasterOp_NotSourceOrNotDestination Does a bitwise NAND
+    operation on the source and destination pixels ((NOT src) OR (NOT
+    dst)).
+
+    \value RasterOp_NotSourceXorDestination Does a bitwise operation
+    where the source pixels are inverted and then XOR'ed with the
+    destination ((NOT src) XOR dst).
+
+    \value RasterOp_NotSource Does a bitwise operation where the
+    source pixels are inverted (NOT src).
+
+    \value RasterOp_NotSourceAndDestination Does a bitwise operation
+    where the source is inverted and then AND'ed with the destination
+    ((NOT src) AND dst).
+
+    \value RasterOp_SourceAndNotDestination Does a bitwise operation
+    where the source is AND'ed with the inverted destination pixels
+    (src AND (NOT dst)).
+
+    \sa compositionMode(), setCompositionMode(), {QPainter#Composition
+    Modes}{Composition Modes}, {Image Composition Example}
+*/
+
+/*!
+    Sets the composition mode to the given \a mode.
+
+    \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()
+*/
+void QPainter::setCompositionMode(CompositionMode mode)
+{
+    Q_D(QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::setCompositionMode: Painter not active");
+        return;
+    }
+    if (d->state->composition_mode == mode)
+        return;
+    if (d->extended) {
+        d->state->composition_mode = mode;
+        d->extended->compositionModeChanged();
+        return;
+    }
+
+    if (mode >= QPainter::RasterOp_SourceOrDestination) {
+        if (!d->engine->hasFeature(QPaintEngine::RasterOpModes)) {
+            qWarning("QPainter::setCompositionMode: "
+                     "Raster operation modes not supported on device");
+            return;
+        }
+    } else if (mode >= QPainter::CompositionMode_Plus) {
+        if (!d->engine->hasFeature(QPaintEngine::BlendModes)) {
+            qWarning("QPainter::setCompositionMode: "
+                     "Blend modes not supported on device");
+            return;
+        }
+    } else if (!d->engine->hasFeature(QPaintEngine::PorterDuff)) {
+        if (mode != CompositionMode_Source && mode != CompositionMode_SourceOver) {
+            qWarning("QPainter::setCompositionMode: "
+                     "PorterDuff modes not supported on device");
+            return;
+        }
+    }
+
+    d->state->composition_mode = mode;
+    d->state->dirtyFlags |= QPaintEngine::DirtyCompositionMode;
+}
+
+/*!
+  Returns the current composition mode.
+
+  \sa CompositionMode, setCompositionMode()
+*/
+QPainter::CompositionMode QPainter::compositionMode() const
+{
+    Q_D(const QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::compositionMode: Painter not active");
+        return QPainter::CompositionMode_SourceOver;
+    }
+    return d->state->composition_mode;
+}
+
+/*!
+    Returns the current background brush.
+
+    \sa setBackground(), {QPainter#Settings}{Settings}
+*/
+
+const QBrush &QPainter::background() const
+{
+    Q_D(const QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::background: Painter not active");
+        return d->fakeState()->brush;
+    }
+    return d->state->bgBrush;
+}
+
+
+/*!
+    Returns true if clipping has been set; otherwise returns false.
+
+    \sa setClipping(), {QPainter#Clipping}{Clipping}
+*/
+
+bool QPainter::hasClipping() const
+{
+    Q_D(const QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::hasClipping: Painter not active");
+        return false;
+    }
+    return d->state->clipEnabled && d->state->clipOperation != Qt::NoClip;
+}
+
+
+/*!
+    Enables clipping if  \a enable is true, or disables clipping if  \a
+    enable is false.
+
+    \sa hasClipping(), {QPainter#Clipping}{Clipping}
+*/
+
+void QPainter::setClipping(bool enable)
+{
+    Q_D(QPainter);
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::setClipping(), enable=%s, was=%s\n",
+               enable ? "on" : "off",
+               hasClipping() ? "on" : "off");
+#endif
+    if (!d->engine) {
+        qWarning("QPainter::setClipping: Painter not active, state will be reset by begin");
+        return;
+    }
+
+    if (hasClipping() == enable)
+        return;
+
+    // we can't enable clipping if we don't have a clip
+    if (enable
+        && (d->state->clipInfo.isEmpty() || d->state->clipInfo.last().operation == Qt::NoClip))
+        return;
+    d->state->clipEnabled = enable;
+
+    if (d->extended) {
+        d->extended->clipEnabledChanged();
+        return;
+    }
+
+    d->state->dirtyFlags |= QPaintEngine::DirtyClipEnabled;
+    d->updateState(d->state);
+}
+
+
+/*!
+    Returns the currently set clip region. Note that the clip region
+    is given in logical coordinates.
+
+    \warning QPainter does not store the combined clip explicitly as
+    this is handled by the underlying QPaintEngine, so the path is
+    recreated on demand and transformed to the current logical
+    coordinate system. This is potentially an expensive operation.
+
+    \sa setClipRegion(), clipPath(), setClipping()
+*/
+
+QRegion QPainter::clipRegion() const
+{
+    Q_D(const QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::clipRegion: Painter not active");
+        return QRegion();
+    }
+
+    QRegion region;
+    bool lastWasNothing = true;
+
+    if (!d->txinv)
+        const_cast<QPainter *>(this)->d_ptr->updateInvMatrix();
+
+    // ### Falcon: Use QPainterPath
+    for (int i=0; i<d->state->clipInfo.size(); ++i) {
+        const QPainterClipInfo &info = d->state->clipInfo.at(i);
+        switch (info.clipType) {
+
+        case QPainterClipInfo::RegionClip: {
+            QTransform matrix = (info.matrix * d->invMatrix);
+            if (lastWasNothing) {
+                region = info.region * matrix;
+                lastWasNothing = false;
+                continue;
+            }
+            if (info.operation == Qt::IntersectClip)
+                region &= info.region * matrix;
+            else if (info.operation == Qt::UniteClip)
+                region |= info.region * matrix;
+            else if (info.operation == Qt::NoClip) {
+                lastWasNothing = true;
+                region = QRegion();
+            } else
+                region = info.region * matrix;
+            break;
+        }
+
+        case QPainterClipInfo::PathClip: {
+            QTransform matrix = (info.matrix * d->invMatrix);
+            if (lastWasNothing) {
+                region = QRegion((info.path * matrix).toFillPolygon().toPolygon(),
+                                 info.path.fillRule());
+                lastWasNothing = false;
+                continue;
+            }
+            if (info.operation == Qt::IntersectClip) {
+                region &= QRegion((info.path * matrix).toFillPolygon().toPolygon(),
+                                  info.path.fillRule());
+            } else if (info.operation == Qt::UniteClip) {
+                region |= QRegion((info.path * matrix).toFillPolygon().toPolygon(),
+                                  info.path.fillRule());
+            } else if (info.operation == Qt::NoClip) {
+                lastWasNothing = true;
+                region = QRegion();
+            } else {
+                region = QRegion((info.path * matrix).toFillPolygon().toPolygon(),
+                                 info.path.fillRule());
+            }
+            break;
+        }
+
+        case QPainterClipInfo::RectClip: {
+            QTransform matrix = (info.matrix * d->invMatrix);
+            if (lastWasNothing) {
+                region = QRegion(info.rect) * matrix;
+                lastWasNothing = false;
+                continue;
+            }
+            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) {
+                lastWasNothing = true;
+                region = QRegion();
+            } else {
+                region = QRegion(info.rect) * matrix;
+            }
+            break;
+        }
+
+        case QPainterClipInfo::RectFClip: {
+            QTransform matrix = (info.matrix * d->invMatrix);
+            if (lastWasNothing) {
+                region = QRegion(info.rectf.toRect()) * matrix;
+                lastWasNothing = false;
+                continue;
+            }
+            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) {
+                lastWasNothing = true;
+                region = QRegion();
+            } else {
+                region = QRegion(info.rectf.toRect()) * matrix;
+            }
+            break;
+        }
+        }
+    }
+
+    return region;
+}
+
+extern QPainterPath qt_regionToPath(const QRegion &region);
+
+/*!
+    Returns the currently clip as a path. Note that the clip path is
+    given in logical coordinates.
+
+    \warning QPainter does not store the combined clip explicitly as
+    this is handled by the underlying QPaintEngine, so the path is
+    recreated on demand and transformed to the current logical
+    coordinate system. This is potentially an expensive operation.
+
+    \sa setClipPath(), clipRegion(), setClipping()
+*/
+QPainterPath QPainter::clipPath() const
+{
+    Q_D(const QPainter);
+
+    // ### Since we do not support path intersections and path unions yet,
+    // we just use clipRegion() here...
+    if (!d->engine) {
+        qWarning("QPainter::clipPath: Painter not active");
+        return QPainterPath();
+    }
+
+    // No clip, return empty
+    if (d->state->clipInfo.size() == 0) {
+        return QPainterPath();
+    } else {
+
+        // Update inverse matrix, used below.
+        if (!d->txinv)
+            const_cast<QPainter *>(this)->d_ptr->updateInvMatrix();
+
+        // For the simple case avoid conversion.
+        if (d->state->clipInfo.size() == 1
+            && d->state->clipInfo.at(0).clipType == QPainterClipInfo::PathClip) {
+            QTransform matrix = (d->state->clipInfo.at(0).matrix * d->invMatrix);
+            return d->state->clipInfo.at(0).path * matrix;
+
+        } else if (d->state->clipInfo.size() == 1
+                   && d->state->clipInfo.at(0).clipType == QPainterClipInfo::RectClip) {
+            QTransform matrix = (d->state->clipInfo.at(0).matrix * d->invMatrix);
+            QPainterPath path;
+            path.addRect(d->state->clipInfo.at(0).rect);
+            return path * matrix;
+        } else {
+            // Fallback to clipRegion() for now, since we don't have isect/unite for paths
+            return qt_regionToPath(clipRegion());
+        }
+    }
+}
+
+/*!
+    Returns the bounding rectangle of the current clip if there is a clip;
+    otherwise returns an empty rectangle. Note that the clip region is
+    given in logical coordinates.
+
+    The bounding rectangle is not guaranteed to be tight.
+
+    \sa setClipRect(), setClipPath(), setClipRegion()
+
+    \since 4.8
+ */
+
+QRectF QPainter::clipBoundingRect() const
+{
+    Q_D(const QPainter);
+
+    if (!d->engine) {
+        qWarning("QPainter::clipBoundingRect: Painter not active");
+        return QRectF();
+    }
+
+    // Accumulate the bounding box in device space. This is not 100%
+    // precise, but it fits within the guarantee and it is resonably
+    // fast.
+    QRectF bounds;
+    for (int i=0; i<d->state->clipInfo.size(); ++i) {
+         QRectF r;
+         const QPainterClipInfo &info = d->state->clipInfo.at(i);
+
+         if (info.clipType == QPainterClipInfo::RectClip)
+             r = info.rect;
+         else if (info.clipType == QPainterClipInfo::RectFClip)
+             r = info.rectf;
+         else if (info.clipType == QPainterClipInfo::RegionClip)
+             r = info.region.boundingRect();
+         else
+             r = info.path.boundingRect();
+
+         r = info.matrix.mapRect(r);
+
+         if (i == 0)
+             bounds = r;
+         else if (info.operation == Qt::IntersectClip)
+             bounds &= r;
+         else if (info.operation == Qt::UniteClip)
+             bounds |= r;
+    }
+
+
+    // Map the rectangle back into logical space using the inverse
+    // matrix.
+    if (!d->txinv)
+        const_cast<QPainter *>(this)->d_ptr->updateInvMatrix();
+
+    return d->invMatrix.mapRect(bounds);
+}
+
+/*!
+    \fn void QPainter::setClipRect(const QRectF &rectangle, Qt::ClipOperation operation)
+
+    Enables clipping, and sets the clip region to the given \a
+    rectangle using the given clip \a operation. The default operation
+    is to replace the current clip rectangle.
+
+    Note that the clip rectangle is specified in logical (painter)
+    coordinates.
+
+    \sa clipRegion(), setClipping(), {QPainter#Clipping}{Clipping}
+*/
+void QPainter::setClipRect(const QRectF &rect, Qt::ClipOperation op)
+{
+    Q_D(QPainter);
+
+    if (d->extended) {
+        if ((!d->state->clipEnabled && op != Qt::NoClip) || (d->state->clipOperation == Qt::NoClip && op == Qt::UniteClip))
+            op = Qt::ReplaceClip;
+
+        if (!d->engine) {
+            qWarning("QPainter::setClipRect: Painter not active");
+            return;
+        }
+        qreal right = rect.x() + rect.width();
+        qreal bottom = rect.y() + rect.height();
+        qreal pts[] = { rect.x(), rect.y(),
+                        right, rect.y(),
+                        right, bottom,
+                        rect.x(), bottom };
+        QVectorPath vp(pts, 4, 0, QVectorPath::RectangleHint);
+        d->state->clipEnabled = true;
+        d->extended->clip(vp, op);
+        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 (qreal(int(rect.top())) == rect.top()
+        && qreal(int(rect.bottom())) == rect.bottom()
+        && qreal(int(rect.left())) == rect.left()
+        && qreal(int(rect.right())) == rect.right())
+    {
+        setClipRect(rect.toRect(), op);
+        return;
+    }
+
+    if (rect.isEmpty()) {
+        setClipRegion(QRegion(), op);
+        return;
+    }
+
+    QPainterPath path;
+    path.addRect(rect);
+    setClipPath(path, op);
+}
+
+/*!
+    \fn void QPainter::setClipRect(const QRect &rectangle, Qt::ClipOperation operation)
+    \overload
+
+    Enables clipping, and sets the clip region to the given \a rectangle using the given
+    clip \a operation.
+*/
+void QPainter::setClipRect(const QRect &rect, Qt::ClipOperation op)
+{
+    Q_D(QPainter);
+
+    if (!d->engine) {
+        qWarning("QPainter::setClipRect: Painter not active");
+        return;
+    }
+
+    if ((!d->state->clipEnabled && op != Qt::NoClip) || (d->state->clipOperation == Qt::NoClip && op == Qt::UniteClip))
+        op = Qt::ReplaceClip;
+
+    if (d->extended) {
+        d->state->clipEnabled = true;
+        d->extended->clip(rect, op);
+        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;
+    }
+
+    d->state->clipRegion = rect;
+    d->state->clipOperation = op;
+    if (op == Qt::NoClip || op == Qt::ReplaceClip)
+        d->state->clipInfo.clear();
+    d->state->clipInfo << QPainterClipInfo(rect, op, d->state->matrix);
+    d->state->clipEnabled = true;
+    d->state->dirtyFlags |= QPaintEngine::DirtyClipRegion | QPaintEngine::DirtyClipEnabled;
+    d->updateState(d->state);
+}
+
+/*!
+    \fn void QPainter::setClipRect(int x, int y, int width, int height, Qt::ClipOperation operation)
+
+    Enables clipping, and sets the clip region to the rectangle beginning at (\a x, \a y)
+    with the given \a width and \a height.
+*/
+
+/*!
+    \fn void QPainter::setClipRegion(const QRegion &region, Qt::ClipOperation operation)
+
+    Sets the clip region to the given \a region using the specified clip
+    \a operation. The default clip operation is to replace the current
+    clip region.
+
+    Note that the clip region is given in logical coordinates.
+
+    \sa clipRegion(), setClipRect(), {QPainter#Clipping}{Clipping}
+*/
+void QPainter::setClipRegion(const QRegion &r, Qt::ClipOperation op)
+{
+    Q_D(QPainter);
+#ifdef QT_DEBUG_DRAW
+    QRect rect = r.boundingRect();
+    if (qt_show_painter_debug_output)
+        printf("QPainter::setClipRegion(), size=%d, [%d,%d,%d,%d]\n",
+           r.rects().size(), rect.x(), rect.y(), rect.width(), rect.height());
+#endif
+    if (!d->engine) {
+        qWarning("QPainter::setClipRegion: Painter not active");
+        return;
+    }
+
+    if ((!d->state->clipEnabled && op != Qt::NoClip) || (d->state->clipOperation == Qt::NoClip && op == Qt::UniteClip))
+        op = Qt::ReplaceClip;
+
+    if (d->extended) {
+        d->state->clipEnabled = true;
+        d->extended->clip(r, op);
+        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;
+    }
+
+    d->state->clipRegion = r;
+    d->state->clipOperation = op;
+    if (op == Qt::NoClip || op == Qt::ReplaceClip)
+        d->state->clipInfo.clear();
+    d->state->clipInfo << QPainterClipInfo(r, op, d->state->matrix);
+    d->state->clipEnabled = true;
+    d->state->dirtyFlags |= QPaintEngine::DirtyClipRegion | QPaintEngine::DirtyClipEnabled;
+    d->updateState(d->state);
+}
+
+/*!
+    \since 4.2
+    \obsolete
+
+    Sets the transformation matrix to \a matrix and enables transformations.
+
+    \note It is advisable to use setWorldTransform() instead of this function to
+    preserve the properties of perspective transformations.
+
+    If \a combine is true, then \a matrix is combined with the current
+    transformation matrix; otherwise \a matrix replaces the current
+    transformation matrix.
+
+    If \a matrix is the identity matrix and \a combine is false, this
+    function calls setWorldMatrixEnabled(false). (The identity matrix is the
+    matrix where QMatrix::m11() and QMatrix::m22() are 1.0 and the
+    rest are 0.0.)
+
+    The following functions can transform the coordinate system without using
+    a QMatrix:
+    \list
+    \i translate()
+    \i scale()
+    \i shear()
+    \i rotate()
+    \endlist
+
+    They operate on the painter's worldMatrix() and are implemented like this:
+
+    \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 4
+
+    Note that when using setWorldMatrix() function you should always have
+    \a combine be true when you are drawing into a QPicture. Otherwise
+    it may not be possible to replay the picture with additional
+    transformations; using the translate(), scale(), etc. convenience
+    functions is safe.
+
+    For more information about the coordinate system, transformations
+    and window-viewport conversion, see \l {Coordinate System}.
+
+    \sa setWorldTransform(), QTransform
+*/
+
+void QPainter::setWorldMatrix(const QMatrix &matrix, bool combine)
+{
+    setWorldTransform(QTransform(matrix), combine);
+}
+
+/*!
+    \since 4.2
+    \obsolete
+
+    Returns the world transformation matrix.
+
+    It is advisable to use worldTransform() because worldMatrix() does not
+    preserve the properties of perspective transformations.
+
+    \sa {QPainter#Coordinate Transformations}{Coordinate Transformations},
+    {Coordinate System}
+*/
+
+const QMatrix &QPainter::worldMatrix() const
+{
+    Q_D(const QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::worldMatrix: Painter not active");
+        return d->fakeState()->transform.toAffine();
+    }
+    return d->state->worldMatrix.toAffine();
+}
+
+/*!
+    \obsolete
+
+    Use setWorldTransform() instead.
+
+    \sa setWorldTransform()
+*/
+
+void QPainter::setMatrix(const QMatrix &matrix, bool combine)
+{
+    setWorldTransform(QTransform(matrix), combine);
+}
+
+/*!
+    \obsolete
+
+    Use worldTransform() instead.
+
+    \sa worldTransform()
+*/
+
+const QMatrix &QPainter::matrix() const
+{
+    return worldMatrix();
+}
+
+
+/*!
+    \since 4.2
+    \obsolete
+
+    Returns the transformation matrix combining the current
+    window/viewport and world transformation.
+
+    It is advisable to use combinedTransform() instead of this
+    function to preserve the properties of perspective transformations.
+
+    \sa setWorldTransform(), setWindow(), setViewport()
+*/
+QMatrix QPainter::combinedMatrix() const
+{
+    return combinedTransform().toAffine();
+}
+
+
+/*!
+    \obsolete
+
+    Returns the matrix that transforms from logical coordinates to
+    device coordinates of the platform dependent paint device.
+
+    \note It is advisable to use deviceTransform() instead of this
+    function to preserve the properties of perspective transformations.
+
+    This function is \e only needed when using platform painting
+    commands on the platform dependent handle (Qt::HANDLE), and the
+    platform does not do transformations nativly.
+
+    The QPaintEngine::PaintEngineFeature enum can be queried to
+    determine whether the platform performs the transformations or
+    not.
+
+    \sa worldMatrix(), QPaintEngine::hasFeature(),
+*/
+const QMatrix &QPainter::deviceMatrix() const
+{
+    Q_D(const QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::deviceMatrix: Painter not active");
+        return d->fakeState()->transform.toAffine();
+    }
+    return d->state->matrix.toAffine();
+}
+
+/*!
+    \obsolete
+
+    Resets any transformations that were made using translate(), scale(),
+    shear(), rotate(), setWorldMatrix(), setViewport() and
+    setWindow().
+
+    It is advisable to use resetTransform() instead of this function
+    to preserve the properties of perspective transformations.
+
+    \sa {QPainter#Coordinate Transformations}{Coordinate
+    Transformations}
+*/
+
+void QPainter::resetMatrix()
+{
+    resetTransform();
+}
+
+
+/*!
+    \since 4.2
+
+    Enables transformations if \a enable is true, or disables
+    transformations if \a enable is false. The world transformation
+    matrix is not changed.
+
+    \sa worldMatrixEnabled(), worldTransform(), {QPainter#Coordinate
+    Transformations}{Coordinate Transformations}
+*/
+
+void QPainter::setWorldMatrixEnabled(bool enable)
+{
+    Q_D(QPainter);
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::setMatrixEnabled(), enable=%d\n", enable);
+#endif
+
+    if (!d->engine) {
+        qWarning("QPainter::setMatrixEnabled: Painter not active");
+        return;
+    }
+    if (enable == d->state->WxF)
+        return;
+
+    d->state->WxF = enable;
+    d->updateMatrix();
+}
+
+/*!
+    \since 4.2
+
+    Returns true if world transformation is enabled; otherwise returns
+    false.
+
+    \sa setWorldMatrixEnabled(), worldTransform(), {Coordinate System}
+*/
+
+bool QPainter::worldMatrixEnabled() const
+{
+    Q_D(const QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::worldMatrixEnabled: Painter not active");
+        return false;
+    }
+    return d->state->WxF;
+}
+
+/*!
+    \obsolete
+
+    Use setWorldMatrixEnabled() instead.
+
+    \sa setWorldMatrixEnabled()
+*/
+
+void QPainter::setMatrixEnabled(bool enable)
+{
+    setWorldMatrixEnabled(enable);
+}
+
+/*!
+    \obsolete
+
+    Use worldMatrixEnabled() instead
+
+    \sa worldMatrixEnabled()
+*/
+
+bool QPainter::matrixEnabled() const
+{
+    return worldMatrixEnabled();
+}
+
+/*!
+    Scales the coordinate system by (\a{sx}, \a{sy}).
+
+    \sa setWorldTransform() {QPainter#Coordinate Transformations}{Coordinate
+    Transformations}
+*/
+
+void QPainter::scale(qreal sx, qreal sy)
+{
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::scale(), sx=%f, sy=%f\n", sx, sy);
+#endif
+    Q_D(QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::scale: Painter not active");
+        return;
+    }
+
+    d->state->worldMatrix.scale(sx,sy);
+    d->state->WxF = true;
+    d->updateMatrix();
+}
+
+/*!
+    Shears the coordinate system by (\a{sh}, \a{sv}).
+
+    \sa setWorldTransform(), {QPainter#Coordinate Transformations}{Coordinate
+    Transformations}
+*/
+
+void QPainter::shear(qreal sh, qreal sv)
+{
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::shear(), sh=%f, sv=%f\n", sh, sv);
+#endif
+    Q_D(QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::shear: Painter not active");
+        return;
+    }
+
+    d->state->worldMatrix.shear(sh, sv);
+    d->state->WxF = true;
+    d->updateMatrix();
+}
+
+/*!
+    \fn void QPainter::rotate(qreal angle)
+
+    Rotates the coordinate system the given \a angle clockwise.
+
+    \sa setWorldTransform(), {QPainter#Coordinate Transformations}{Coordinate
+    Transformations}
+*/
+
+void QPainter::rotate(qreal a)
+{
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::rotate(), angle=%f\n", a);
+#endif
+    Q_D(QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::rotate: Painter not active");
+        return;
+    }
+
+    d->state->worldMatrix.rotate(a);
+    d->state->WxF = true;
+    d->updateMatrix();
+}
+
+/*!
+    Translates the coordinate system by the given \a offset; i.e. the
+    given \a offset is added to points.
+
+    \sa setWorldTransform(), {QPainter#Coordinate Transformations}{Coordinate
+    Transformations}
+*/
+void QPainter::translate(const QPointF &offset)
+{
+    qreal dx = offset.x();
+    qreal dy = offset.y();
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::translate(), dx=%f, dy=%f\n", dx, dy);
+#endif
+    Q_D(QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::translate: Painter not active");
+        return;
+    }
+
+    d->state->worldMatrix.translate(dx, dy);
+    d->state->WxF = true;
+    d->updateMatrix();
+}
+
+/*!
+    \fn void QPainter::translate(const QPoint &offset)
+    \overload
+
+    Translates the coordinate system by the given \a offset.
+*/
+
+/*!
+    \fn void QPainter::translate(qreal dx, qreal dy)
+    \overload
+
+    Translates the coordinate system by the vector (\a dx, \a dy).
+*/
+
+/*!
+    \fn void QPainter::setClipPath(const QPainterPath &path, Qt::ClipOperation operation)
+
+    Enables clipping, and sets the clip path for the painter to the
+    given \a path, with the clip \a operation.
+
+    Note that the clip path is specified in logical (painter)
+    coordinates.
+
+    \sa clipPath(), clipRegion(), {QPainter#Clipping}{Clipping}
+
+*/
+void QPainter::setClipPath(const QPainterPath &path, Qt::ClipOperation op)
+{
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output) {
+        QRectF b = path.boundingRect();
+        printf("QPainter::setClipPath(), size=%d, op=%d, bounds=[%.2f,%.2f,%.2f,%.2f]\n",
+               path.elementCount(), op, b.x(), b.y(), b.width(), b.height());
+    }
+#endif
+    Q_D(QPainter);
+
+    if (!d->engine) {
+        qWarning("QPainter::setClipPath: Painter not active");
+        return;
+    }
+
+    if ((!d->state->clipEnabled && op != Qt::NoClip) || (d->state->clipOperation == Qt::NoClip && op == Qt::UniteClip))
+        op = Qt::ReplaceClip;
+
+    if (d->extended) {
+        d->state->clipEnabled = true;
+        d->extended->clip(path, op);
+        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;
+    }
+
+    d->state->clipPath = path;
+    d->state->clipOperation = op;
+    if (op == Qt::NoClip || op == Qt::ReplaceClip)
+        d->state->clipInfo.clear();
+    d->state->clipInfo << QPainterClipInfo(path, op, d->state->matrix);
+    d->state->clipEnabled = true;
+    d->state->dirtyFlags |= QPaintEngine::DirtyClipPath | QPaintEngine::DirtyClipEnabled;
+    d->updateState(d->state);
+}
+
+/*!
+    Draws the outline (strokes) the path \a path with the pen specified
+    by \a pen
+
+    \sa fillPath(), {QPainter#Drawing}{Drawing}
+*/
+void QPainter::strokePath(const QPainterPath &path, const QPen &pen)
+{
+    Q_D(QPainter);
+
+    if (!d->engine) {
+        qWarning("QPainter::strokePath: Painter not active");
+        return;
+    }
+
+    if (path.isEmpty())
+        return;
+
+    if (d->extended) {
+        const QGradient *g = qpen_brush(pen).gradient();
+        if (!g || g->coordinateMode() == QGradient::LogicalMode) {
+            d->extended->stroke(qtVectorPathForPath(path), pen);
+            return;
+        }
+    }
+
+    QBrush oldBrush = d->state->brush;
+    QPen oldPen = d->state->pen;
+
+    setPen(pen);
+    setBrush(Qt::NoBrush);
+
+    drawPath(path);
+
+    // Reset old state
+    setPen(oldPen);
+    setBrush(oldBrush);
+}
+
+/*!
+    Fills the given \a path using the given \a brush. The outline is
+    not drawn.
+
+    Alternatively, you can specify a QColor instead of a QBrush; the
+    QBrush constructor (taking a QColor argument) will automatically
+    create a solid pattern brush.
+
+    \sa drawPath()
+*/
+void QPainter::fillPath(const QPainterPath &path, const QBrush &brush)
+{
+    Q_D(QPainter);
+
+    if (!d->engine) {
+        qWarning("QPainter::fillPath: Painter not active");
+        return;
+    }
+
+    if (path.isEmpty())
+        return;
+
+    if (d->extended) {
+        const QGradient *g = brush.gradient();
+        if (!g || g->coordinateMode() == QGradient::LogicalMode) {
+            d->extended->fill(qtVectorPathForPath(path), brush);
+            return;
+        }
+    }
+
+    QBrush oldBrush = d->state->brush;
+    QPen oldPen = d->state->pen;
+
+    setPen(Qt::NoPen);
+    setBrush(brush);
+
+    drawPath(path);
+
+    // Reset old state
+    setPen(oldPen);
+    setBrush(oldBrush);
+}
+
+/*!
+    Draws the given painter \a path using the current pen for outline
+    and the current brush for filling.
+
+    \table 100%
+    \row
+    \o \inlineimage qpainter-path.png
+    \o
+    \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 5
+    \endtable
+
+    \sa {painting/painterpaths}{the Painter Paths
+    example},{demos/deform}{the Vector Deformation demo}
+*/
+void QPainter::drawPath(const QPainterPath &path)
+{
+#ifdef QT_DEBUG_DRAW
+    QRectF pathBounds = path.boundingRect();
+    if (qt_show_painter_debug_output)
+        printf("QPainter::drawPath(), size=%d, [%.2f,%.2f,%.2f,%.2f]\n",
+               path.elementCount(),
+               pathBounds.x(), pathBounds.y(), pathBounds.width(), pathBounds.height());
+#endif
+
+    Q_D(QPainter);
+
+    if (!d->engine) {
+        qWarning("QPainter::drawPath: Painter not active");
+        return;
+    }
+
+    if (d->extended) {
+        d->extended->drawPath(path);
+        return;
+    }
+    d->updateState(d->state);
+
+    if (d->engine->hasFeature(QPaintEngine::PainterPaths) && d->state->emulationSpecifier == 0) {
+        d->engine->drawPath(path);
+    } else {
+        d->draw_helper(path);
+    }
+}
+
+/*!
+    \fn void QPainter::drawLine(const QLineF &line)
+
+    Draws a line defined by \a line.
+
+    \table 100%
+    \row
+    \o \inlineimage qpainter-line.png
+    \o
+    \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 6
+    \endtable
+
+    \sa drawLines(), drawPolyline(), {Coordinate System}
+*/
+
+/*!
+    \fn void QPainter::drawLine(const QLine &line)
+    \overload
+
+    Draws a line defined by \a line.
+*/
+
+/*!
+    \fn void QPainter::drawLine(const QPoint &p1, const QPoint &p2)
+    \overload
+
+    Draws a line from \a p1 to \a p2.
+*/
+
+/*!
+    \fn void QPainter::drawLine(const QPointF &p1, const QPointF &p2)
+    \overload
+
+    Draws a line from \a p1 to \a p2.
+*/
+
+/*!
+    \fn void QPainter::drawLine(int x1, int y1, int x2, int y2)
+    \overload
+
+    Draws a line from (\a x1, \a y1) to (\a x2, \a y2) and sets the
+    current pen position to (\a x2, \a y2).
+*/
+
+/*!
+    \fn void QPainter::drawRect(const QRectF &rectangle)
+
+    Draws the current \a rectangle with the current pen and brush.
+
+    A filled rectangle has a size of \a{rectangle}.size(). A stroked
+    rectangle has a size of \a{rectangle}.size() plus the pen width.
+
+    \table 100%
+    \row
+    \o \inlineimage qpainter-rectangle.png
+    \o
+    \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 7
+    \endtable
+
+    \sa drawRects(), drawPolygon(), {Coordinate System}
+*/
+
+/*!
+    \fn void QPainter::drawRect(const QRect &rectangle)
+
+    \overload
+
+    Draws the current \a rectangle with the current pen and brush.
+*/
+
+/*!
+    \fn void QPainter::drawRect(int x, int y, int width, int height)
+
+    \overload
+
+    Draws a rectangle with upper left corner at (\a{x}, \a{y}) and
+    with the given \a width and \a height.
+*/
+
+/*!
+    \fn void QPainter::drawRects(const QRectF *rectangles, int rectCount)
+
+    Draws the first \a rectCount of the given \a rectangles using the
+    current pen and brush.
+
+    \sa drawRect()
+*/
+void QPainter::drawRects(const QRectF *rects, int rectCount)
+{
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::drawRects(), count=%d\n", rectCount);
+#endif
+    Q_D(QPainter);
+
+    if (!d->engine) {
+        qWarning("QPainter::drawRects: Painter not active");
+        return;
+    }
+
+    if (rectCount <= 0)
+        return;
+
+    if (d->extended) {
+        d->extended->drawRects(rects, rectCount);
+        return;
+    }
+
+    d->updateState(d->state);
+
+    if (!d->state->emulationSpecifier) {
+        d->engine->drawRects(rects, rectCount);
+        return;
+    }
+
+    if (d->state->emulationSpecifier == QPaintEngine::PrimitiveTransform
+        && d->state->matrix.type() == QTransform::TxTranslate) {
+        for (int i=0; i<rectCount; ++i) {
+            QRectF r(rects[i].x() + d->state->matrix.dx(),
+                     rects[i].y() + d->state->matrix.dy(),
+                     rects[i].width(),
+                     rects[i].height());
+            d->engine->drawRects(&r, 1);
+        }
+    } else {
+        if (d->state->brushNeedsResolving() || d->state->penNeedsResolving()) {
+            for (int i=0; i<rectCount; ++i) {
+                QPainterPath rectPath;
+                rectPath.addRect(rects[i]);
+                d->draw_helper(rectPath, QPainterPrivate::StrokeAndFillDraw);
+            }
+        } else {
+            QPainterPath rectPath;
+            for (int i=0; i<rectCount; ++i)
+                rectPath.addRect(rects[i]);
+            d->draw_helper(rectPath, QPainterPrivate::StrokeAndFillDraw);
+        }
+    }
+}
+
+/*!
+    \fn void QPainter::drawRects(const QRect *rectangles, int rectCount)
+    \overload
+
+    Draws the first \a rectCount of the given \a rectangles using the
+    current pen and brush.
+*/
+void QPainter::drawRects(const QRect *rects, int rectCount)
+{
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::drawRects(), count=%d\n", rectCount);
+#endif
+    Q_D(QPainter);
+
+    if (!d->engine) {
+        qWarning("QPainter::drawRects: Painter not active");
+        return;
+    }
+
+    if (rectCount <= 0)
+        return;
+
+    if (d->extended) {
+        d->extended->drawRects(rects, rectCount);
+        return;
+    }
+
+    d->updateState(d->state);
+
+    if (!d->state->emulationSpecifier) {
+        d->engine->drawRects(rects, rectCount);
+        return;
+    }
+
+    if (d->state->emulationSpecifier == QPaintEngine::PrimitiveTransform
+        && d->state->matrix.type() == QTransform::TxTranslate) {
+        for (int i=0; i<rectCount; ++i) {
+            QRectF r(rects[i].x() + d->state->matrix.dx(),
+                     rects[i].y() + d->state->matrix.dy(),
+                     rects[i].width(),
+                     rects[i].height());
+
+            d->engine->drawRects(&r, 1);
+        }
+    } else {
+        if (d->state->brushNeedsResolving() || d->state->penNeedsResolving()) {
+            for (int i=0; i<rectCount; ++i) {
+                QPainterPath rectPath;
+                rectPath.addRect(rects[i]);
+                d->draw_helper(rectPath, QPainterPrivate::StrokeAndFillDraw);
+            }
+        } else {
+            QPainterPath rectPath;
+            for (int i=0; i<rectCount; ++i)
+                rectPath.addRect(rects[i]);
+
+            d->draw_helper(rectPath, QPainterPrivate::StrokeAndFillDraw);
+        }
+    }
+}
+
+/*!
+    \fn void QPainter::drawRects(const QVector<QRectF> &rectangles)
+    \overload
+
+    Draws the given \a rectangles using the current pen and brush.
+*/
+
+/*!
+    \fn void QPainter::drawRects(const QVector<QRect> &rectangles)
+
+    \overload
+
+    Draws the given \a rectangles using the current pen and brush.
+*/
+
+/*!
+  \fn void QPainter::drawPoint(const QPointF &position)
+
+    Draws a single point at the given \a position using the current
+    pen's color.
+
+    \sa {Coordinate System}
+*/
+
+/*!
+    \fn void QPainter::drawPoint(const QPoint &position)
+    \overload
+
+    Draws a single point at the given \a position using the current
+    pen's color.
+*/
+
+/*! \fn void QPainter::drawPoint(int x, int y)
+
+    \overload
+
+    Draws a single point at position (\a x, \a y).
+*/
+
+/*!
+    Draws the first \a pointCount points in the array \a points using
+    the current pen's color.
+
+    \sa {Coordinate System}
+*/
+void QPainter::drawPoints(const QPointF *points, int pointCount)
+{
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::drawPoints(), count=%d\n", pointCount);
+#endif
+    Q_D(QPainter);
+
+    if (!d->engine) {
+        qWarning("QPainter::drawPoints: Painter not active");
+        return;
+    }
+
+    if (pointCount <= 0)
+        return;
+
+    if (d->extended) {
+        d->extended->drawPoints(points, pointCount);
+        return;
+    }
+
+    d->updateState(d->state);
+
+    if (!d->state->emulationSpecifier) {
+        d->engine->drawPoints(points, pointCount);
+        return;
+    }
+
+    if (d->state->emulationSpecifier == QPaintEngine::PrimitiveTransform
+        && d->state->matrix.type() == QTransform::TxTranslate) {
+        // ### use drawPoints function
+        for (int i=0; i<pointCount; ++i) {
+            QPointF pt(points[i].x() + d->state->matrix.dx(),
+                       points[i].y() + d->state->matrix.dy());
+            d->engine->drawPoints(&pt, 1);
+        }
+    } else {
+        QPen pen = d->state->pen;
+        bool flat_pen = pen.capStyle() == Qt::FlatCap;
+        if (flat_pen) {
+            save();
+            pen.setCapStyle(Qt::SquareCap);
+            setPen(pen);
+        }
+        QPainterPath path;
+        for (int i=0; i<pointCount; ++i) {
+            path.moveTo(points[i].x(), points[i].y());
+            path.lineTo(points[i].x() + 0.0001, points[i].y());
+        }
+        d->draw_helper(path, QPainterPrivate::StrokeDraw);
+        if (flat_pen)
+            restore();
+    }
+}
+
+/*!
+    \overload
+
+    Draws the first \a pointCount points in the array \a points using
+    the current pen's color.
+*/
+
+void QPainter::drawPoints(const QPoint *points, int pointCount)
+{
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::drawPoints(), count=%d\n", pointCount);
+#endif
+    Q_D(QPainter);
+
+    if (!d->engine) {
+        qWarning("QPainter::drawPoints: Painter not active");
+        return;
+    }
+
+    if (pointCount <= 0)
+        return;
+
+    if (d->extended) {
+        d->extended->drawPoints(points, pointCount);
+        return;
+    }
+
+    d->updateState(d->state);
+
+    if (!d->state->emulationSpecifier) {
+        d->engine->drawPoints(points, pointCount);
+        return;
+    }
+
+    if (d->state->emulationSpecifier == QPaintEngine::PrimitiveTransform
+        && d->state->matrix.type() == QTransform::TxTranslate) {
+        // ### use drawPoints function
+        for (int i=0; i<pointCount; ++i) {
+            QPointF pt(points[i].x() + d->state->matrix.dx(),
+                       points[i].y() + d->state->matrix.dy());
+            d->engine->drawPoints(&pt, 1);
+        }
+    } else {
+        QPen pen = d->state->pen;
+        bool flat_pen = (pen.capStyle() == Qt::FlatCap);
+        if (flat_pen) {
+            save();
+            pen.setCapStyle(Qt::SquareCap);
+            setPen(pen);
+        }
+        QPainterPath path;
+        for (int i=0; i<pointCount; ++i) {
+            path.moveTo(points[i].x(), points[i].y());
+            path.lineTo(points[i].x() + 0.0001, points[i].y());
+        }
+        d->draw_helper(path, QPainterPrivate::StrokeDraw);
+        if (flat_pen)
+            restore();
+    }
+}
+
+/*!
+    \fn void QPainter::drawPoints(const QPolygonF &points)
+
+    \overload
+
+    Draws the points in the vector  \a points.
+*/
+
+/*!
+    \fn void QPainter::drawPoints(const QPolygon &points)
+
+    \overload
+
+    Draws the points in the vector  \a points.
+*/
+
+/*!
+    \fn void QPainter::drawPoints(const QPolygon &polygon, int index,
+    int count)
+
+    \overload
+    \compat
+
+    Draws \a count points in the vector \a polygon starting on \a index
+    using the current pen.
+
+    Use drawPoints() combined with QPolygon::constData() instead.
+
+    \oldcode
+        QPainter painter(this);
+        painter.drawPoints(polygon, index, count);
+    \newcode
+        int pointCount = (count == -1) ?  polygon.size() - index : count;
+
+        QPainter painter(this);
+        painter.drawPoints(polygon.constData() + index, pointCount);
+    \endcode
+*/
+
+/*!
+    Sets the background mode of the painter to the given \a mode
+
+    Qt::TransparentMode (the default) draws stippled lines and text
+    without setting the background pixels.  Qt::OpaqueMode fills these
+    space with the current background color.
+
+    Note that in order to draw a bitmap or pixmap transparently, you
+    must use QPixmap::setMask().
+
+    \sa backgroundMode(), setBackground(),
+    {QPainter#Settings}{Settings}
+*/
+
+void QPainter::setBackgroundMode(Qt::BGMode mode)
+{
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::setBackgroundMode(), mode=%d\n", mode);
+#endif
+
+    Q_D(QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::setBackgroundMode: Painter not active");
+        return;
+    }
+    if (d->state->bgMode == mode)
+        return;
+
+    d->state->bgMode = mode;
+    if (d->extended) {
+        d->checkEmulation();
+    } else {
+        d->state->dirtyFlags |= QPaintEngine::DirtyBackgroundMode;
+    }
+}
+
+/*!
+    Returns the current background mode.
+
+    \sa setBackgroundMode(), {QPainter#Settings}{Settings}
+*/
+Qt::BGMode QPainter::backgroundMode() const
+{
+    Q_D(const QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::backgroundMode: Painter not active");
+        return Qt::TransparentMode;
+    }
+    return d->state->bgMode;
+}
+
+
+/*!
+    \overload
+
+    Sets the painter's pen to have style Qt::SolidLine, width 0 and the
+    specified \a color.
+*/
+
+void QPainter::setPen(const QColor &color)
+{
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::setPen(), color=%04x\n", color.rgb());
+#endif
+    Q_D(QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::setPen: Painter not active");
+        return;
+    }
+
+    if (d->state->pen.style() == Qt::SolidLine
+        && d->state->pen.widthF() == 0
+        && d->state->pen.isSolid()
+        && d->state->pen.color() == color)
+        return;
+
+    QPen pen(color.isValid() ? color : QColor(Qt::black), 0, Qt::SolidLine);
+
+    d->state->pen = pen;
+    if (d->extended)
+        d->extended->penChanged();
+    else
+        d->state->dirtyFlags |= QPaintEngine::DirtyPen;
+}
+
+/*!
+    Sets the painter's pen to be the given \a pen.
+
+    The \a pen defines how to draw lines and outlines, and it also
+    defines the text color.
+
+    \sa pen(), {QPainter#Settings}{Settings}
+*/
+
+void QPainter::setPen(const QPen &pen)
+{
+
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::setPen(), color=%04x, (brushStyle=%d) style=%d, cap=%d, join=%d\n",
+           pen.color().rgb(), pen.brush().style(), pen.style(), pen.capStyle(), pen.joinStyle());
+#endif
+    Q_D(QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::setPen: Painter not active");
+        return;
+    }
+
+    if (d->state->pen == pen)
+        return;
+
+    d->state->pen = pen;
+
+    if (d->extended) {
+        d->checkEmulation();
+        d->extended->penChanged();
+        return;
+    }
+
+    d->state->dirtyFlags |= QPaintEngine::DirtyPen;
+}
+
+/*!
+    \overload
+
+    Sets the painter's pen to have the given \a style, width 0 and
+    black color.
+*/
+
+void QPainter::setPen(Qt::PenStyle style)
+{
+    Q_D(QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::setPen: Painter not active");
+        return;
+    }
+
+    if (d->state->pen.style() == style
+        && (style == Qt::NoPen || (d->state->pen.widthF() == 0
+                                   && d->state->pen.isSolid()
+                                   && d->state->pen.color() == QColor(Qt::black))))
+        return;
+
+    // QPen(Qt::NoPen) is to avoid creating QPenData, including its brush (from the color)
+    // Note that this works well as long as QPen(Qt::NoPen) returns a black, zero-width pen
+    d->state->pen = (style == Qt::NoPen) ? QPen(Qt::NoPen) : QPen(Qt::black, 0, style);
+
+    if (d->extended)
+        d->extended->penChanged();
+    else
+        d->state->dirtyFlags |= QPaintEngine::DirtyPen;
+
+}
+
+/*!
+    Returns the painter's current pen.
+
+    \sa setPen(), {QPainter#Settings}{Settings}
+*/
+
+const QPen &QPainter::pen() const
+{
+    Q_D(const QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::pen: Painter not active");
+        return d->fakeState()->pen;
+    }
+    return d->state->pen;
+}
+
+
+/*!
+    Sets the painter's brush to the given \a brush.
+
+    The painter's brush defines how shapes are filled.
+
+    \sa brush(), {QPainter#Settings}{Settings}
+*/
+
+void QPainter::setBrush(const QBrush &brush)
+{
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::setBrush(), color=%04x, style=%d\n", brush.color().rgb(), brush.style());
+#endif
+    Q_D(QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::setBrush: Painter not active");
+        return;
+    }
+
+    if (d->state->brush.d == brush.d)
+        return;
+
+    if (d->extended) {
+        d->state->brush = brush;
+        d->checkEmulation();
+        d->extended->brushChanged();
+        return;
+    }
+
+    d->state->brush = brush;
+    d->state->dirtyFlags |= QPaintEngine::DirtyBrush;
+}
+
+
+/*!
+    \overload
+
+    Sets the painter's brush to black color and the specified \a
+    style.
+*/
+
+void QPainter::setBrush(Qt::BrushStyle style)
+{
+    Q_D(QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::setBrush: Painter not active");
+        return;
+    }
+    if (d->state->brush.style() == style &&
+        (style == Qt::NoBrush
+         || (style == Qt::SolidPattern && d->state->brush.color() == QColor(0, 0, 0))))
+        return;
+    d->state->brush = QBrush(Qt::black, style);
+    if (d->extended)
+        d->extended->brushChanged();
+    else
+        d->state->dirtyFlags |= QPaintEngine::DirtyBrush;
+}
+
+/*!
+    Returns the painter's current brush.
+
+    \sa QPainter::setBrush(), {QPainter#Settings}{Settings}
+*/
+
+const QBrush &QPainter::brush() const
+{
+    Q_D(const QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::brush: Painter not active");
+        return d->fakeState()->brush;
+    }
+    return d->state->brush;
+}
+
+/*!
+    \fn void QPainter::setBackground(const QBrush &brush)
+
+    Sets the background brush of the painter to the given \a brush.
+
+    The background brush is the brush that is filled in when drawing
+    opaque text, stippled lines and bitmaps. The background brush has
+    no effect in transparent background mode (which is the default).
+
+    \sa background(), setBackgroundMode(),
+    {QPainter#Settings}{Settings}
+*/
+
+void QPainter::setBackground(const QBrush &bg)
+{
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::setBackground(), color=%04x, style=%d\n", bg.color().rgb(), bg.style());
+#endif
+
+    Q_D(QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::setBackground: Painter not active");
+        return;
+    }
+    d->state->bgBrush = bg;
+    if (!d->extended)
+        d->state->dirtyFlags |= QPaintEngine::DirtyBackground;
+}
+
+/*!
+    Sets the painter's font to the given \a font.
+
+    This font is used by subsequent drawText() functions. The text
+    color is the same as the pen color.
+
+    If you set a font that isn't available, Qt finds a close match.
+    font() will return what you set using setFont() and fontInfo() returns the
+    font actually being used (which may be the same).
+
+    \sa font(), drawText(), {QPainter#Settings}{Settings}
+*/
+
+void QPainter::setFont(const QFont &font)
+{
+    Q_D(QPainter);
+
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::setFont(), family=%s, pointSize=%d\n", font.family().toLatin1().constData(), font.pointSize());
+#endif
+
+    if (!d->engine) {
+        qWarning("QPainter::setFont: Painter not active");
+        return;
+    }
+
+    d->state->font = QFont(font.resolve(d->state->deviceFont), device());
+    if (!d->extended)
+        d->state->dirtyFlags |= QPaintEngine::DirtyFont;
+}
+
+/*!
+    Returns the currently set font used for drawing text.
+
+    \sa setFont(), drawText(), {QPainter#Settings}{Settings}
+*/
+const QFont &QPainter::font() const
+{
+    Q_D(const QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::font: Painter not active");
+        return d->fakeState()->font;
+    }
+    return d->state->font;
+}
+
+/*!
+    \since 4.4
+
+    Draws the given rectangle \a rect with rounded corners.
+
+    The \a xRadius and \a yRadius arguments specify the radii
+    of the ellipses defining the corners of the rounded rectangle.
+    When \a mode is Qt::RelativeSize, \a xRadius and
+    \a yRadius are specified in percentage of half the rectangle's
+    width and height respectively, and should be in the range
+    0.0 to 100.0.
+
+    A filled rectangle has a size of rect.size(). A stroked rectangle
+    has a size of rect.size() plus the pen width.
+
+    \table 100%
+    \row
+    \o \inlineimage qpainter-roundrect.png
+    \o
+    \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 8
+    \endtable
+
+    \sa drawRect(), QPen
+*/
+void QPainter::drawRoundedRect(const QRectF &rect, qreal xRadius, qreal yRadius, Qt::SizeMode mode)
+{
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::drawRoundedRect(), [%.2f,%.2f,%.2f,%.2f]\n", rect.x(), rect.y(), rect.width(), rect.height());
+#endif
+    Q_D(QPainter);
+
+    if (!d->engine)
+        return;
+
+    if (xRadius <= 0 || yRadius <= 0) {             // draw normal rectangle
+        drawRect(rect);
+        return;
+    }
+
+    if (d->extended) {
+        d->extended->drawRoundedRect(rect, xRadius, yRadius, mode);
+        return;
+    }
+
+    QPainterPath path;
+    path.addRoundedRect(rect, xRadius, yRadius, mode);
+    drawPath(path);
+}
+
+/*!
+    \fn void QPainter::drawRoundedRect(const QRect &rect, qreal xRadius, qreal yRadius,
+                                       Qt::SizeMode mode = Qt::AbsoluteSize);
+    \since 4.4
+    \overload
+
+    Draws the given rectangle \a rect with rounded corners.
+*/
+
+/*!
+    \fn void QPainter::drawRoundedRect(int x, int y, int w, int h, qreal xRadius, qreal yRadius,
+                                       Qt::SizeMode mode = Qt::AbsoluteSize);
+    \since 4.4
+    \overload
+
+    Draws the given rectangle \a x, \a y, \a w, \a h with rounded corners.
+*/
+
+/*!
+    \obsolete
+
+    Draws a rectangle \a r with rounded corners.
+
+    The \a xRnd and \a yRnd arguments specify how rounded the corners
+    should be. 0 is angled corners, 99 is maximum roundedness.
+
+    A filled rectangle has a size of r.size(). A stroked rectangle
+    has a size of r.size() plus the pen width.
+
+    \sa drawRoundedRect()
+*/
+void QPainter::drawRoundRect(const QRectF &r, int xRnd, int yRnd)
+{
+    drawRoundedRect(r, xRnd, yRnd, Qt::RelativeSize);
+}
+
+
+/*!
+    \fn void QPainter::drawRoundRect(const QRect &r, int xRnd = 25, int yRnd = 25)
+
+    \overload
+    \obsolete
+
+    Draws the rectangle \a r with rounded corners.
+*/
+
+/*!
+    \obsolete
+
+    \fn QPainter::drawRoundRect(int x, int y, int w, int h, int xRnd, int yRnd)
+
+    \overload
+
+    Draws the rectangle \a x, \a y, \a w, \a h with rounded corners.
+*/
+
+/*!
+    \fn void QPainter::drawEllipse(const QRectF &rectangle)
+
+    Draws the ellipse defined by the given \a rectangle.
+
+    A filled ellipse has a size of \a{rectangle}.\l
+    {QRect::size()}{size()}. A stroked ellipse has a size of
+    \a{rectangle}.\l {QRect::size()}{size()} plus the pen width.
+
+    \table 100%
+    \row
+    \o \inlineimage qpainter-ellipse.png
+    \o
+    \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 9
+    \endtable
+
+    \sa drawPie(), {Coordinate System}
+*/
+void QPainter::drawEllipse(const QRectF &r)
+{
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::drawEllipse(), [%.2f,%.2f,%.2f,%.2f]\n", r.x(), r.y(), r.width(), r.height());
+#endif
+    Q_D(QPainter);
+
+    if (!d->engine)
+        return;
+
+    QRectF rect(r.normalized());
+
+    if (d->extended) {
+        d->extended->drawEllipse(rect);
+        return;
+    }
+
+    d->updateState(d->state);
+    if (d->state->emulationSpecifier) {
+        if (d->state->emulationSpecifier == QPaintEngine::PrimitiveTransform
+            && d->state->matrix.type() == QTransform::TxTranslate) {
+            rect.translate(QPointF(d->state->matrix.dx(), d->state->matrix.dy()));
+        } else {
+            QPainterPath path;
+            path.addEllipse(rect);
+            d->draw_helper(path, QPainterPrivate::StrokeAndFillDraw);
+            return;
+        }
+    }
+
+    d->engine->drawEllipse(rect);
+}
+
+/*!
+    \fn QPainter::drawEllipse(const QRect &rectangle)
+
+    \overload
+
+    Draws the ellipse defined by the given \a rectangle.
+*/
+void QPainter::drawEllipse(const QRect &r)
+{
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::drawEllipse(), [%d,%d,%d,%d]\n", r.x(), r.y(), r.width(), r.height());
+#endif
+    Q_D(QPainter);
+
+    if (!d->engine)
+        return;
+
+    QRect rect(r.normalized());
+
+    if (d->extended) {
+        d->extended->drawEllipse(rect);
+        return;
+    }
+
+    d->updateState(d->state);
+
+    if (d->state->emulationSpecifier) {
+        if (d->state->emulationSpecifier == QPaintEngine::PrimitiveTransform
+            && d->state->matrix.type() == QTransform::TxTranslate) {
+            rect.translate(QPoint(qRound(d->state->matrix.dx()), qRound(d->state->matrix.dy())));
+        } else {
+            QPainterPath path;
+            path.addEllipse(rect);
+            d->draw_helper(path, QPainterPrivate::StrokeAndFillDraw);
+            return;
+        }
+    }
+
+    d->engine->drawEllipse(rect);
+}
+
+/*!
+    \fn QPainter::drawEllipse(int x, int y, int width, int height)
+
+    \overload
+
+    Draws the ellipse defined by the rectangle beginning at (\a{x},
+    \a{y}) with the given \a width and \a height.
+*/
+
+/*!
+    \since 4.4
+
+    \fn QPainter::drawEllipse(const QPointF &center, qreal rx, qreal ry)
+
+    \overload
+
+    Draws the ellipse positioned at \a{center} with radii \a{rx} and \a{ry}.
+*/
+
+/*!
+    \since 4.4
+
+    \fn QPainter::drawEllipse(const QPoint &center, int rx, int ry)
+
+    \overload
+
+    Draws the ellipse positioned at \a{center} with radii \a{rx} and \a{ry}.
+*/
+
+/*!
+    \fn void QPainter::drawArc(const QRectF &rectangle, int startAngle, int spanAngle)
+
+    Draws the arc defined by the given \a rectangle, \a startAngle and
+    \a spanAngle.
+
+    The \a startAngle and \a spanAngle must be specified in 1/16th of
+    a degree, i.e. a full circle equals 5760 (16 * 360). Positive
+    values for the angles mean counter-clockwise while negative values
+    mean the clockwise direction. Zero degrees is at the 3 o'clock
+    position.
+
+    \table 100%
+    \row
+    \o \inlineimage qpainter-arc.png
+    \o
+    \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 10
+    \endtable
+
+    \sa drawPie(), drawChord(), {Coordinate System}
+*/
+
+void QPainter::drawArc(const QRectF &r, int a, int alen)
+{
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::drawArc(), [%.2f,%.2f,%.2f,%.2f], angle=%d, sweep=%d\n",
+           r.x(), r.y(), r.width(), r.height(), a/16, alen/16);
+#endif
+    Q_D(QPainter);
+
+    if (!d->engine)
+        return;
+
+    QRectF rect = r.normalized();
+
+    QPainterPath path;
+    path.arcMoveTo(rect, a/16.0);
+    path.arcTo(rect, a/16.0, alen/16.0);
+    strokePath(path, d->state->pen);
+}
+
+/*! \fn void QPainter::drawArc(const QRect &rectangle, int startAngle,
+                               int spanAngle)
+
+    \overload
+
+    Draws the arc defined by the given \a rectangle, \a startAngle and
+    \a spanAngle.
+*/
+
+/*!
+    \fn void QPainter::drawArc(int x, int y, int width, int height,
+                               int startAngle, int spanAngle)
+
+    \overload
+
+    Draws the arc defined by the rectangle beginning at (\a x, \a y)
+    with the specified \a width and \a height, and the given \a
+    startAngle and \a spanAngle.
+*/
+
+/*!
+    \fn void QPainter::drawPie(const QRectF &rectangle, int startAngle, int spanAngle)
+
+    Draws a pie defined by the given \a rectangle, \a startAngle and
+    and \a spanAngle.
+
+    The pie is filled with the current brush().
+
+    The startAngle and spanAngle must be specified in 1/16th of a
+    degree, i.e. a full circle equals 5760 (16 * 360). Positive values
+    for the angles mean counter-clockwise while negative values mean
+    the clockwise direction. Zero degrees is at the 3 o'clock
+    position.
+
+    \table 100%
+    \row
+    \o \inlineimage qpainter-pie.png
+    \o
+    \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 11
+    \endtable
+
+    \sa drawEllipse(), drawChord(), {Coordinate System}
+*/
+void QPainter::drawPie(const QRectF &r, int a, int alen)
+{
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::drawPie(), [%.2f,%.2f,%.2f,%.2f], angle=%d, sweep=%d\n",
+           r.x(), r.y(), r.width(), r.height(), a/16, alen/16);
+#endif
+    Q_D(QPainter);
+
+    if (!d->engine)
+        return;
+
+    if (a > (360*16)) {
+        a = a % (360*16);
+    } else if (a < 0) {
+        a = a % (360*16);
+        if (a < 0) a += (360*16);
+    }
+
+    QRectF rect = r.normalized();
+
+    QPainterPath path;
+    path.moveTo(rect.center());
+    path.arcTo(rect.x(), rect.y(), rect.width(), rect.height(), a/16.0, alen/16.0);
+    path.closeSubpath();
+    drawPath(path);
+
+}
+
+/*!
+    \fn void QPainter::drawPie(const QRect &rectangle, int startAngle, int spanAngle)
+    \overload
+
+    Draws a pie defined by the given \a rectangle, \a startAngle and
+    and \a spanAngle.
+*/
+
+/*!
+    \fn void QPainter::drawPie(int x, int y, int width, int height, int
+    startAngle, int spanAngle)
+
+    \overload
+
+    Draws the pie defined by the rectangle beginning at (\a x, \a y) with
+    the specified \a width and \a height, and the given \a startAngle and
+    \a spanAngle.
+*/
+
+/*!
+    \fn void QPainter::drawChord(const QRectF &rectangle, int startAngle, int spanAngle)
+
+    Draws the chord defined by the given \a rectangle, \a startAngle and
+    \a spanAngle.  The chord is filled with the current brush().
+
+    The startAngle and spanAngle must be specified in 1/16th of a
+    degree, i.e. a full circle equals 5760 (16 * 360). Positive values
+    for the angles mean counter-clockwise while negative values mean
+    the clockwise direction. Zero degrees is at the 3 o'clock
+    position.
+
+    \table 100%
+    \row
+    \o \inlineimage qpainter-chord.png
+    \o
+    \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 12
+    \endtable
+
+    \sa drawArc(), drawPie(), {Coordinate System}
+*/
+void QPainter::drawChord(const QRectF &r, int a, int alen)
+{
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::drawChord(), [%.2f,%.2f,%.2f,%.2f], angle=%d, sweep=%d\n",
+           r.x(), r.y(), r.width(), r.height(), a/16, alen/16);
+#endif
+    Q_D(QPainter);
+
+    if (!d->engine)
+        return;
+
+    QRectF rect = r.normalized();
+
+    QPainterPath path;
+    path.arcMoveTo(rect, a/16.0);
+    path.arcTo(rect, a/16.0, alen/16.0);
+    path.closeSubpath();
+    drawPath(path);
+}
+/*!
+    \fn void QPainter::drawChord(const QRect &rectangle, int startAngle, int spanAngle)
+
+    \overload
+
+    Draws the chord defined by the given \a rectangle, \a startAngle and
+    \a spanAngle.
+*/
+
+/*!
+    \fn void QPainter::drawChord(int x, int y, int width, int height, int
+    startAngle, int spanAngle)
+
+    \overload
+
+   Draws the chord defined by the rectangle beginning at (\a x, \a y)
+   with the specified \a width and \a height, and the given \a
+   startAngle and \a spanAngle.
+*/
+
+#ifdef QT3_SUPPORT
+/*!
+    \fn void QPainter::drawLineSegments(const QPolygon &polygon, int
+    index, int count)
+
+    Draws \a count separate lines from points defined by the \a
+    polygon, starting at \a{polygon}\e{[index]} (\a index defaults to
+    0). If \a count is -1 (the default) all points until the end of
+    the array are used.
+
+    Use drawLines() combined with QPolygon::constData() instead.
+
+    \oldcode
+        QPainter painter(this);
+        painter.drawLineSegments(polygon, index, count);
+    \newcode
+        int lineCount = (count == -1) ?  (polygon.size() - index) / 2  : count;
+
+        QPainter painter(this);
+        painter.drawLines(polygon.constData() + index * 2, lineCount);
+    \endcode
+*/
+
+void QPainter::drawLineSegments(const QPolygon &a, int index, int nlines)
+{
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::drawLineSegments(), count=%d\n", a.size()/2);
+#endif
+    Q_D(QPainter);
+
+    if (!d->engine)
+        return;
+
+    if (nlines < 0)
+        nlines = a.size()/2 - index/2;
+    if (index + nlines*2 > (int)a.size())
+        nlines = (a.size() - index)/2;
+    if (nlines < 1 || index < 0)
+        return;
+
+    if (d->extended) {
+        // FALCON: Use QVectorPath
+        QVector<QLineF> lines;
+        for (int i=index; i<index + nlines*2; i+=2)
+            lines << QLineF(a.at(i), a.at(i+1));
+        d->extended->drawLines(lines.data(), lines.size());
+        return;
+    }
+
+    d->updateState(d->state);
+
+    QVector<QLineF> lines;
+    if (d->state->emulationSpecifier) {
+        if (d->state->emulationSpecifier == QPaintEngine::PrimitiveTransform
+            && d->state->matrix.type() == QTransform::TxTranslate) {
+            QPointF offset(d->state->matrix.dx(), d->state->matrix.dy());
+            for (int i=index; i<index + nlines*2; i+=2)
+                lines << QLineF(a.at(i) + offset, a.at(i+1) + offset);
+        } else {
+            QPainterPath linesPath;
+            for (int i=index; i<index + nlines*2; i+=2) {
+                linesPath.moveTo(a.at(i));
+                linesPath.lineTo(a.at(i+1));
+            }
+            d->draw_helper(linesPath, QPainterPrivate::StrokeDraw);
+            return;
+        }
+    } else {
+        for (int i=index; i<index + nlines*2; i+=2)
+            lines << QLineF(a.at(i), a.at(i+1));
+    }
+
+    d->engine->drawLines(lines.data(), lines.size());
+}
+#endif // QT3_SUPPORT
+
+/*!
+    Draws the first \a lineCount lines in the array \a lines
+    using the current pen.
+
+    \sa drawLine(), drawPolyline()
+*/
+void QPainter::drawLines(const QLineF *lines, int lineCount)
+{
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::drawLines(), line count=%d\n", lineCount);
+#endif
+
+    Q_D(QPainter);
+
+    if (!d->engine || lineCount < 1)
+        return;
+
+    if (d->extended) {
+        d->extended->drawLines(lines, lineCount);
+        return;
+    }
+
+    d->updateState(d->state);
+
+    uint lineEmulation = line_emulation(d->state->emulationSpecifier);
+
+    if (lineEmulation) {
+        if (lineEmulation == QPaintEngine::PrimitiveTransform
+            && d->state->matrix.type() == QTransform::TxTranslate) {
+            for (int i = 0; i < lineCount; ++i) {
+                QLineF line = lines[i];
+                line.translate(d->state->matrix.dx(), d->state->matrix.dy());
+                d->engine->drawLines(&line, 1);
+            }
+        } else {
+            QPainterPath linePath;
+            for (int i = 0; i < lineCount; ++i) {
+                linePath.moveTo(lines[i].p1());
+                linePath.lineTo(lines[i].p2());
+            }
+            d->draw_helper(linePath, QPainterPrivate::StrokeDraw);
+        }
+        return;
+    }
+    d->engine->drawLines(lines, lineCount);
+}
+
+/*!
+    \fn void QPainter::drawLines(const QLine *lines, int lineCount)
+    \overload
+
+    Draws the first \a lineCount lines in the array \a lines
+    using the current pen.
+*/
+void QPainter::drawLines(const QLine *lines, int lineCount)
+{
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::drawLine(), line count=%d\n", lineCount);
+#endif
+
+    Q_D(QPainter);
+
+    if (!d->engine || lineCount < 1)
+        return;
+
+    if (d->extended) {
+        d->extended->drawLines(lines, lineCount);
+        return;
+    }
+
+    d->updateState(d->state);
+
+    uint lineEmulation = line_emulation(d->state->emulationSpecifier);
+
+    if (lineEmulation) {
+        if (lineEmulation == QPaintEngine::PrimitiveTransform
+            && d->state->matrix.type() == QTransform::TxTranslate) {
+            for (int i = 0; i < lineCount; ++i) {
+                QLineF line = lines[i];
+                line.translate(d->state->matrix.dx(), d->state->matrix.dy());
+                d->engine->drawLines(&line, 1);
+            }
+        } else {
+            QPainterPath linePath;
+            for (int i = 0; i < lineCount; ++i) {
+                linePath.moveTo(lines[i].p1());
+                linePath.lineTo(lines[i].p2());
+            }
+            d->draw_helper(linePath, QPainterPrivate::StrokeDraw);
+        }
+        return;
+    }
+    d->engine->drawLines(lines, lineCount);
+}
+
+/*!
+    \overload
+
+    Draws the first \a lineCount lines in the array \a pointPairs
+    using the current pen.  The lines are specified as pairs of points
+    so the number of entries in \a pointPairs must be at least \a
+    lineCount * 2.
+*/
+void QPainter::drawLines(const QPointF *pointPairs, int lineCount)
+{
+    Q_ASSERT(sizeof(QLineF) == 2*sizeof(QPointF));
+
+    drawLines((QLineF*)pointPairs, lineCount);
+}
+
+/*!
+    \overload
+
+    Draws the first \a lineCount lines in the array \a pointPairs
+    using the current pen.
+*/
+void QPainter::drawLines(const QPoint *pointPairs, int lineCount)
+{
+    Q_ASSERT(sizeof(QLine) == 2*sizeof(QPoint));
+
+    drawLines((QLine*)pointPairs, lineCount);
+}
+
+
+/*!
+    \fn void QPainter::drawLines(const QVector<QPointF> &pointPairs)
+    \overload
+
+    Draws a line for each pair of points in the vector \a pointPairs
+    using the current pen. If there is an odd number of points in the
+    array, the last point will be ignored.
+*/
+
+/*!
+    \fn void QPainter::drawLines(const QVector<QPoint> &pointPairs)
+    \overload
+
+    Draws a line for each pair of points in the vector \a pointPairs
+    using the current pen.
+*/
+
+/*!
+    \fn void QPainter::drawLines(const QVector<QLineF> &lines)
+    \overload
+
+    Draws the set of lines defined by the list \a lines using the
+    current pen and brush.
+*/
+
+/*!
+    \fn void QPainter::drawLines(const QVector<QLine> &lines)
+    \overload
+
+    Draws the set of lines defined by the list \a lines using the
+    current pen and brush.
+*/
+
+/*!
+    Draws the polyline defined by the first \a pointCount points in \a
+    points using the current pen.
+
+    Note that unlike the drawPolygon() function the last point is \e
+    not connected to the first, neither is the polyline filled.
+
+    \table 100%
+    \row
+    \o
+    \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 13
+    \endtable
+
+    \sa drawLines(), drawPolygon(), {Coordinate System}
+*/
+void QPainter::drawPolyline(const QPointF *points, int pointCount)
+{
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::drawPolyline(), count=%d\n", pointCount);
+#endif
+    Q_D(QPainter);
+
+    if (!d->engine || pointCount < 2)
+        return;
+
+    if (d->extended) {
+        d->extended->drawPolygon(points, pointCount, QPaintEngine::PolylineMode);
+        return;
+    }
+
+    d->updateState(d->state);
+
+    uint lineEmulation = line_emulation(d->state->emulationSpecifier);
+
+    if (lineEmulation) {
+        // ###
+//         if (lineEmulation == QPaintEngine::PrimitiveTransform
+//             && d->state->matrix.type() == QTransform::TxTranslate) {
+//         } else {
+        QPainterPath polylinePath(points[0]);
+        for (int i=1; i<pointCount; ++i)
+            polylinePath.lineTo(points[i]);
+        d->draw_helper(polylinePath, QPainterPrivate::StrokeDraw);
+//         }
+    } else {
+        d->engine->drawPolygon(points, pointCount, QPaintEngine::PolylineMode);
+    }
+}
+
+/*!
+    \overload
+
+    Draws the polyline defined by the first \a pointCount points in \a
+    points using the current pen.
+ */
+void QPainter::drawPolyline(const QPoint *points, int pointCount)
+{
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::drawPolyline(), count=%d\n", pointCount);
+#endif
+    Q_D(QPainter);
+
+    if (!d->engine || pointCount < 2)
+        return;
+
+    if (d->extended) {
+        d->extended->drawPolygon(points, pointCount, QPaintEngine::PolylineMode);
+        return;
+    }
+
+    d->updateState(d->state);
+
+    uint lineEmulation = line_emulation(d->state->emulationSpecifier);
+
+    if (lineEmulation) {
+        // ###
+//         if (lineEmulation == QPaintEngine::PrimitiveTransform
+//             && d->state->matrix.type() == QTransform::TxTranslate) {
+//         } else {
+        QPainterPath polylinePath(points[0]);
+        for (int i=1; i<pointCount; ++i)
+            polylinePath.lineTo(points[i]);
+        d->draw_helper(polylinePath, QPainterPrivate::StrokeDraw);
+//         }
+    } else {
+        d->engine->drawPolygon(points, pointCount, QPaintEngine::PolylineMode);
+    }
+}
+
+/*!
+    \fn void QPainter::drawPolyline(const QPolygon &polygon, int index, int
+    count)
+
+    \overload
+    \compat
+
+    Draws the polyline defined by the \a count lines of the given \a
+    polygon starting at \a index (\a index defaults to 0).
+
+    Use drawPolyline() combined with QPolygon::constData() instead.
+
+    \oldcode
+        QPainter painter(this);
+        painter.drawPolyline(polygon, index, count);
+    \newcode
+        int pointCount = (count == -1) ?  polygon.size() - index : count;
+
+        QPainter painter(this);
+        painter.drawPolyline(polygon.constData() + index, pointCount);
+    \endcode
+*/
+
+/*!
+    \fn void QPainter::drawPolyline(const QPolygonF &points)
+
+    \overload
+
+    Draws the polyline defined by the given \a points using the
+    current pen.
+*/
+
+/*!
+    \fn void QPainter::drawPolyline(const QPolygon &points)
+
+    \overload
+
+    Draws the polyline defined by the given \a points using the
+    current pen.
+*/
+
+/*!
+    Draws the polygon defined by the first \a pointCount points in the
+    array \a points using the current pen and brush.
+
+    \table 100%
+    \row
+    \o \inlineimage qpainter-polygon.png
+    \o
+    \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 14
+    \endtable
+
+    The first point is implicitly connected to the last point, and the
+    polygon is filled with the current brush().
+
+    If \a fillRule is Qt::WindingFill, the polygon is filled using the
+    winding fill algorithm.  If \a fillRule is Qt::OddEvenFill, the
+    polygon is filled using the odd-even fill algorithm. See
+    \l{Qt::FillRule} for a more detailed description of these fill
+    rules.
+
+    \sa  drawConvexPolygon(), drawPolyline(), {Coordinate System}
+*/
+void QPainter::drawPolygon(const QPointF *points, int pointCount, Qt::FillRule fillRule)
+{
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::drawPolygon(), count=%d\n", pointCount);
+#endif
+
+    Q_D(QPainter);
+
+    if (!d->engine || pointCount < 2)
+        return;
+
+    if (d->extended) {
+        d->extended->drawPolygon(points, pointCount, QPaintEngine::PolygonDrawMode(fillRule));
+        return;
+    }
+
+    d->updateState(d->state);
+
+    uint emulationSpecifier = d->state->emulationSpecifier;
+
+    if (emulationSpecifier) {
+        QPainterPath polygonPath(points[0]);
+        for (int i=1; i<pointCount; ++i)
+            polygonPath.lineTo(points[i]);
+        polygonPath.closeSubpath();
+        polygonPath.setFillRule(fillRule);
+        d->draw_helper(polygonPath);
+        return;
+    }
+
+    d->engine->drawPolygon(points, pointCount, QPaintEngine::PolygonDrawMode(fillRule));
+}
+
+/*! \overload
+
+    Draws the polygon defined by the first \a pointCount points in the
+    array \a points.
+*/
+void QPainter::drawPolygon(const QPoint *points, int pointCount, Qt::FillRule fillRule)
+{
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::drawPolygon(), count=%d\n", pointCount);
+#endif
+
+    Q_D(QPainter);
+
+    if (!d->engine || pointCount < 2)
+        return;
+
+    if (d->extended) {
+        d->extended->drawPolygon(points, pointCount, QPaintEngine::PolygonDrawMode(fillRule));
+        return;
+    }
+
+    d->updateState(d->state);
+
+    uint emulationSpecifier = d->state->emulationSpecifier;
+
+    if (emulationSpecifier) {
+        QPainterPath polygonPath(points[0]);
+        for (int i=1; i<pointCount; ++i)
+            polygonPath.lineTo(points[i]);
+        polygonPath.closeSubpath();
+        polygonPath.setFillRule(fillRule);
+        d->draw_helper(polygonPath);
+        return;
+    }
+
+    d->engine->drawPolygon(points, pointCount, QPaintEngine::PolygonDrawMode(fillRule));
+}
+
+/*! \fn void QPainter::drawPolygon(const QPolygonF &polygon, bool winding, int index = 0,
+                                   int count = -1)
+    \compat
+    \overload
+
+    Use drawPolygon() combined with QPolygonF::constData() instead.
+
+    \oldcode
+        QPainter painter(this);
+        painter.drawPolygon(polygon, winding, index, count);
+    \newcode
+        int pointCount = (count == -1) ?  polygon.size() - index : count;
+        int fillRule = winding ? Qt::WindingFill : Qt::OddEvenFill;
+
+        QPainter painter(this);
+        painter.drawPolygon( polygon.constData() + index, pointCount, fillRule);
+    \endcode
+*/
+
+/*! \fn void QPainter::drawPolygon(const QPolygon &polygon, bool winding,
+                                   int index = 0, int count = -1)
+
+    \compat
+    \overload
+
+    Use drawPolygon() combined with QPolygon::constData() instead.
+
+    \oldcode
+        QPainter painter(this);
+        painter.drawPolygon(polygon, winding, index, count);
+    \newcode
+        int pointCount = (count == -1) ?  polygon.size() - index : count;
+        int fillRule = winding ? Qt::WindingFill : Qt::OddEvenFill;
+
+        QPainter painter(this);
+        painter.drawPolygon( polygon.constData() + index, pointCount, fillRule);
+    \endcode
+*/
+
+/*! \fn void QPainter::drawPolygon(const QPolygonF &points, Qt::FillRule fillRule)
+
+    \overload
+
+    Draws the polygon defined by the given \a points using the fill
+    rule \a fillRule.
+*/
+
+/*! \fn void QPainter::drawPolygon(const QPolygon &points, Qt::FillRule fillRule)
+
+    \overload
+
+    Draws the polygon defined by the given \a points using the fill
+    rule \a fillRule.
+*/
+
+/*!
+    \fn void QPainter::drawConvexPolygon(const QPointF *points, int pointCount)
+
+    Draws the convex polygon defined by the first \a pointCount points
+    in the array \a points using the current pen.
+
+    \table 100%
+    \row
+    \o \inlineimage qpainter-polygon.png
+    \o
+    \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 15
+    \endtable
+
+    The first point is implicitly connected to the last point, and the
+    polygon is filled with the current brush().  If the supplied
+    polygon is not convex, i.e. it contains at least one angle larger
+    than 180 degrees, the results are undefined.
+
+    On some platforms (e.g. X11), the drawConvexPolygon() function can
+    be faster than the drawPolygon() function.
+
+    \sa drawPolygon(), drawPolyline(), {Coordinate System}
+*/
+
+/*!
+    \fn void QPainter::drawConvexPolygon(const QPoint *points, int pointCount)
+    \overload
+
+    Draws the convex polygon defined by the first \a pointCount points
+    in the array \a points using the current pen.
+*/
+
+/*!
+    \fn void QPainter::drawConvexPolygon(const QPolygonF &polygon)
+
+    \overload
+
+    Draws the convex polygon defined by \a polygon using the current
+    pen and brush.
+*/
+
+/*!
+    \fn void QPainter::drawConvexPolygon(const QPolygon &polygon)
+    \overload
+
+    Draws the convex polygon defined by \a polygon using the current
+    pen and brush.
+*/
+
+/*!
+    \fn void QPainter::drawConvexPolygon(const QPolygonF &polygon, int
+    index, int count)
+
+    \compat
+    \overload
+
+    Use drawConvexPolygon() combined with QPolygonF::constData()
+    instead.
+
+    \oldcode
+        QPainter painter(this);
+        painter.drawConvexPolygon(polygon, index, count);
+    \newcode
+        int pointCount = (count == -1) ?  polygon.size() - index : count;
+
+        QPainter painter(this);
+        painter.drawConvexPolygon(polygon.constData() + index, pointCount);
+    \endcode
+*/
+
+/*!
+    \fn void QPainter::drawConvexPolygon(const QPolygon &polygon, int
+    index, int count)
+
+    \compat
+    \overload
+
+    Use drawConvexPolygon() combined with QPolygon::constData()
+    instead.
+
+    \oldcode
+        QPainter painter(this);
+        painter.drawConvexPolygon(polygon, index, count);
+    \newcode
+        int pointCount = (count == -1) ?  polygon.size() - index : count;
+
+        QPainter painter(this);
+        painter.drawConvexPolygon(polygon.constData() + index, pointCount);
+    \endcode
+*/
+
+void QPainter::drawConvexPolygon(const QPoint *points, int pointCount)
+{
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::drawConvexPolygon(), count=%d\n", pointCount);
+#endif
+
+    Q_D(QPainter);
+
+    if (!d->engine || pointCount < 2)
+        return;
+
+    if (d->extended) {
+        d->extended->drawPolygon(points, pointCount, QPaintEngine::ConvexMode);
+        return;
+    }
+
+    d->updateState(d->state);
+
+    uint emulationSpecifier = d->state->emulationSpecifier;
+
+    if (emulationSpecifier) {
+        QPainterPath polygonPath(points[0]);
+        for (int i=1; i<pointCount; ++i)
+            polygonPath.lineTo(points[i]);
+        polygonPath.closeSubpath();
+        polygonPath.setFillRule(Qt::WindingFill);
+        d->draw_helper(polygonPath);
+        return;
+    }
+
+    d->engine->drawPolygon(points, pointCount, QPaintEngine::ConvexMode);
+}
+
+void QPainter::drawConvexPolygon(const QPointF *points, int pointCount)
+{
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::drawConvexPolygon(), count=%d\n", pointCount);
+#endif
+
+    Q_D(QPainter);
+
+    if (!d->engine || pointCount < 2)
+        return;
+
+    if (d->extended) {
+        d->extended->drawPolygon(points, pointCount, QPaintEngine::ConvexMode);
+        return;
+    }
+
+    d->updateState(d->state);
+
+    uint emulationSpecifier = d->state->emulationSpecifier;
+
+    if (emulationSpecifier) {
+        QPainterPath polygonPath(points[0]);
+        for (int i=1; i<pointCount; ++i)
+            polygonPath.lineTo(points[i]);
+        polygonPath.closeSubpath();
+        polygonPath.setFillRule(Qt::WindingFill);
+        d->draw_helper(polygonPath);
+        return;
+    }
+
+    d->engine->drawPolygon(points, pointCount, QPaintEngine::ConvexMode);
+}
+
+static inline QPointF roundInDeviceCoordinates(const QPointF &p, const QTransform &m)
+{
+    return m.inverted().map(QPointF(m.map(p).toPoint()));
+}
+
+/*!
+    \fn void QPainter::drawPixmap(const QRectF &target, const QPixmap &pixmap, const QRectF &source)
+
+    Draws the rectangular portion \a source of the given \a pixmap
+    into the given \a target in the paint device.
+
+    \note The pixmap is scaled to fit the rectangle, if both the pixmap and rectangle size disagree.
+
+    \table 100%
+    \row
+    \o
+    \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 16
+    \endtable
+
+    If \a pixmap is a QBitmap it is drawn with the bits that are "set"
+    using the pens color. If backgroundMode is Qt::OpaqueMode, the
+    "unset" bits are drawn using the color of the background brush; if
+    backgroundMode is Qt::TransparentMode, the "unset" bits are
+    transparent. Drawing bitmaps with gradient or texture colors is
+    not supported.
+
+    \sa drawImage()
+*/
+void QPainter::drawPixmap(const QPointF &p, const QPixmap &pm)
+{
+#if defined QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::drawPixmap(), p=[%.2f,%.2f], pix=[%d,%d]\n",
+               p.x(), p.y(),
+               pm.width(), pm.height());
+#endif
+
+    Q_D(QPainter);
+
+    if (!d->engine || pm.isNull())
+        return;
+
+#ifndef QT_NO_DEBUG
+    qt_painter_thread_test(d->device->devType(), "drawPixmap()", true);
+#endif
+
+    if (d->extended) {
+        d->extended->drawPixmap(p, pm);
+        return;
+    }
+
+    qreal x = p.x();
+    qreal y = p.y();
+
+    int w = pm.width();
+    int h = pm.height();
+
+    if (w <= 0)
+        return;
+
+    // Emulate opaque background for bitmaps
+    if (d->state->bgMode == Qt::OpaqueMode && pm.isQBitmap()) {
+        fillRect(QRectF(x, y, w, h), d->state->bgBrush.color());
+    }
+
+    d->updateState(d->state);
+
+    if ((d->state->matrix.type() > QTransform::TxTranslate
+         && !d->engine->hasFeature(QPaintEngine::PixmapTransform))
+        || (!d->state->matrix.isAffine() && !d->engine->hasFeature(QPaintEngine::PerspectiveTransform))
+        || (d->state->opacity != 1.0 && !d->engine->hasFeature(QPaintEngine::ConstantOpacity)))
+    {
+        save();
+        // If there is no rotation 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::TxScale) {
+            const QPointF p = roundInDeviceCoordinates(QPointF(x, y), d->state->matrix);
+            x = p.x();
+            y = p.y();
+        }
+        translate(x, y);
+        setBackgroundMode(Qt::TransparentMode);
+        setRenderHint(Antialiasing, renderHints() & SmoothPixmapTransform);
+        QBrush brush(d->state->pen.color(), pm);
+        setBrush(brush);
+        setPen(Qt::NoPen);
+        setBrushOrigin(QPointF(0, 0));
+
+        drawRect(pm.rect());
+        restore();
+    } else {
+        if (!d->engine->hasFeature(QPaintEngine::PixmapTransform)) {
+            x += d->state->matrix.dx();
+            y += d->state->matrix.dy();
+        }
+        d->engine->drawPixmap(QRectF(x, y, w, h), pm, QRectF(0, 0, w, h));
+    }
+}
+
+void QPainter::drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr)
+{
+#if defined QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::drawPixmap(), target=[%.2f,%.2f,%.2f,%.2f], pix=[%d,%d], source=[%.2f,%.2f,%.2f,%.2f]\n",
+               r.x(), r.y(), r.width(), r.height(),
+               pm.width(), pm.height(),
+               sr.x(), sr.y(), sr.width(), sr.height());
+#endif
+
+    Q_D(QPainter);
+    if (!d->engine || pm.isNull())
+        return;
+#ifndef QT_NO_DEBUG
+    qt_painter_thread_test(d->device->devType(), "drawPixmap()", true);
+#endif
+
+    qreal x = r.x();
+    qreal y = r.y();
+    qreal w = r.width();
+    qreal h = r.height();
+    qreal sx = sr.x();
+    qreal sy = sr.y();
+    qreal sw = sr.width();
+    qreal sh = sr.height();
+
+    // Sanity-check clipping
+    if (sw <= 0)
+        sw = pm.width() - sx;
+
+    if (sh <= 0)
+        sh = pm.height() - sy;
+
+    if (w < 0)
+        w = sw;
+    if (h < 0)
+        h = sh;
+
+    if (sx < 0) {
+        qreal w_ratio = sx * w/sw;
+        x -= w_ratio;
+        w += w_ratio;
+        sw += sx;
+        sx = 0;
+    }
+
+    if (sy < 0) {
+        qreal h_ratio = sy * h/sh;
+        y -= h_ratio;
+        h += h_ratio;
+        sh += sy;
+        sy = 0;
+    }
+
+    if (sw + sx > pm.width()) {
+        qreal delta = sw - (pm.width() - sx);
+        qreal w_ratio = delta * w/sw;
+        sw -= delta;
+        w -= w_ratio;
+    }
+
+    if (sh + sy > pm.height()) {
+        qreal delta = sh - (pm.height() - sy);
+        qreal h_ratio = delta * h/sh;
+        sh -= delta;
+        h -= h_ratio;
+    }
+
+    if (w == 0 || h == 0 || sw <= 0 || sh <= 0)
+        return;
+
+    if (d->extended) {
+        d->extended->drawPixmap(QRectF(x, y, w, h), pm, QRectF(sx, sy, sw, sh));
+        return;
+    }
+
+    // Emulate opaque background for bitmaps
+    if (d->state->bgMode == Qt::OpaqueMode && pm.isQBitmap())
+        fillRect(QRectF(x, y, w, h), d->state->bgBrush.color());
+
+    d->updateState(d->state);
+
+    if ((d->state->matrix.type() > QTransform::TxTranslate
+         && !d->engine->hasFeature(QPaintEngine::PixmapTransform))
+        || (!d->state->matrix.isAffine() && !d->engine->hasFeature(QPaintEngine::PerspectiveTransform))
+        || (d->state->opacity != 1.0 && !d->engine->hasFeature(QPaintEngine::ConstantOpacity))
+        || ((sw != w || sh != h) && !d->engine->hasFeature(QPaintEngine::PixmapTransform)))
+    {
+        save();
+        // If there is no rotation 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::TxScale) {
+            const QPointF p = roundInDeviceCoordinates(QPointF(x, y), d->state->matrix);
+            x = p.x();
+            y = p.y();
+        }
+
+        if (d->state->matrix.type() <= QTransform::TxTranslate && sw == w && sh == h) {
+            sx = qRound(sx);
+            sy = qRound(sy);
+            sw = qRound(sw);
+            sh = qRound(sh);
+        }
+
+        translate(x, y);
+        scale(w / sw, h / sh);
+        setBackgroundMode(Qt::TransparentMode);
+        setRenderHint(Antialiasing, renderHints() & SmoothPixmapTransform);
+        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);
+
+        drawRect(QRectF(0, 0, sw, sh));
+        restore();
+    } else {
+        if (!d->engine->hasFeature(QPaintEngine::PixmapTransform)) {
+            x += d->state->matrix.dx();
+            y += d->state->matrix.dy();
+        }
+        d->engine->drawPixmap(QRectF(x, y, w, h), pm, QRectF(sx, sy, sw, sh));
+    }
+}
+
+
+/*!
+    \fn void QPainter::drawPixmap(const QRect &target, const QPixmap &pixmap,
+                                  const QRect &source)
+    \overload
+
+    Draws the rectangular portion \a source of the given \a pixmap
+    into the given \a target in the paint device.
+
+    \note The pixmap is scaled to fit the rectangle, if both the pixmap and rectangle size disagree.
+*/
+
+/*!
+    \fn void QPainter::drawPixmap(const QPointF &point, const QPixmap &pixmap,
+                                  const QRectF &source)
+    \overload
+
+    Draws the rectangular portion \a source of the given \a pixmap
+    with its origin at the given \a point.
+*/
+
+/*!
+    \fn void QPainter::drawPixmap(const QPoint &point, const QPixmap &pixmap,
+                                  const QRect &source)
+
+    \overload
+
+    Draws the rectangular portion \a source of the given \a pixmap
+    with its origin at the given \a point.
+*/
+
+/*!
+    \fn void QPainter::drawPixmap(const QPointF &point, const QPixmap &pixmap)
+    \overload
+
+    Draws the given \a pixmap with its origin at the given \a point.
+*/
+
+/*!
+    \fn void QPainter::drawPixmap(const QPoint &point, const QPixmap &pixmap)
+    \overload
+
+    Draws the given \a pixmap with its origin at the given \a point.
+*/
+
+/*!
+    \fn void QPainter::drawPixmap(int x, int y, const QPixmap &pixmap)
+
+    \overload
+
+    Draws the given \a pixmap at position (\a{x}, \a{y}).
+*/
+
+/*!
+    \fn void QPainter::drawPixmap(const QRect &rectangle, const QPixmap &pixmap)
+    \overload
+
+    Draws the given \a  pixmap into the given \a rectangle.
+
+    \note The pixmap is scaled to fit the rectangle, if both the pixmap and rectangle size disagree.
+*/
+
+/*!
+    \fn void QPainter::drawPixmap(int x, int y, int width, int height,
+    const QPixmap &pixmap)
+
+    \overload
+
+    Draws the \a pixmap into the rectangle at position (\a{x}, \a{y})
+    with  the given \a width and \a height.
+*/
+
+/*!
+    \fn void QPainter::drawPixmap(int x, int y, int w, int h, const QPixmap &pixmap,
+                                  int sx, int sy, int sw, int sh)
+
+    \overload
+
+    Draws the rectangular portion with the origin (\a{sx}, \a{sy}),
+    width \a sw and height \a sh, of the given \a pixmap , at the
+    point (\a{x}, \a{y}), with a width of \a w and a height of \a h.
+    If sw or sh are equal to zero the width/height of the pixmap
+    is used and adjusted by the offset sx/sy;
+*/
+
+/*!
+    \fn void QPainter::drawPixmap(int x, int y, const QPixmap &pixmap,
+                                  int sx, int sy, int sw, int sh)
+
+    \overload
+
+    Draws a pixmap at (\a{x}, \a{y}) by copying a part of the given \a
+    pixmap into the paint device.
+
+    (\a{x}, \a{y}) specifies the top-left point in the paint device that is
+    to be drawn onto. (\a{sx}, \a{sy}) specifies the top-left point in \a
+    pixmap that is to be drawn. The default is (0, 0).
+
+    (\a{sw}, \a{sh}) specifies the size of the pixmap that is to be drawn.
+    The default, (0, 0) (and negative) means all the way to the
+    bottom-right of the pixmap.
+*/
+
+void QPainter::drawImage(const QPointF &p, const QImage &image)
+{
+    Q_D(QPainter);
+
+    if (!d->engine || image.isNull())
+        return;
+
+    if (d->extended) {
+        d->extended->drawImage(p, image);
+        return;
+    }
+
+    qreal x = p.x();
+    qreal y = p.y();
+
+    int w = image.width();
+    int h = image.height();
+
+    d->updateState(d->state);
+
+    if (((d->state->matrix.type() > QTransform::TxTranslate)
+         && !d->engine->hasFeature(QPaintEngine::PixmapTransform))
+        || (!d->state->matrix.isAffine() && !d->engine->hasFeature(QPaintEngine::PerspectiveTransform))
+        || (d->state->opacity != 1.0 && !d->engine->hasFeature(QPaintEngine::ConstantOpacity)))
+    {
+        save();
+        // If there is no rotation 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::TxScale) {
+            const QPointF p = roundInDeviceCoordinates(QPointF(x, y), d->state->matrix);
+            x = p.x();
+            y = p.y();
+        }
+        translate(x, y);
+        setBackgroundMode(Qt::TransparentMode);
+        setRenderHint(Antialiasing, renderHints() & SmoothPixmapTransform);
+        QBrush brush(image);
+        setBrush(brush);
+        setPen(Qt::NoPen);
+        setBrushOrigin(QPointF(0, 0));
+
+        drawRect(image.rect());
+        restore();
+        return;
+    }
+
+    if (d->state->matrix.type() == QTransform::TxTranslate
+        && !d->engine->hasFeature(QPaintEngine::PixmapTransform)) {
+        x += d->state->matrix.dx();
+        y += d->state->matrix.dy();
+    }
+
+    d->engine->drawImage(QRectF(x, y, w, h), image, QRectF(0, 0, w, h), Qt::AutoColor);
+}
+
+void QPainter::drawImage(const QRectF &targetRect, const QImage &image, const QRectF &sourceRect,
+                         Qt::ImageConversionFlags flags)
+{
+    Q_D(QPainter);
+
+    if (!d->engine || image.isNull())
+        return;
+
+    qreal x = targetRect.x();
+    qreal y = targetRect.y();
+    qreal w = targetRect.width();
+    qreal h = targetRect.height();
+    qreal sx = sourceRect.x();
+    qreal sy = sourceRect.y();
+    qreal sw = sourceRect.width();
+    qreal sh = sourceRect.height();
+
+    // Sanity-check clipping
+    if (sw <= 0)
+        sw = image.width() - sx;
+
+    if (sh <= 0)
+        sh = image.height() - sy;
+
+    if (w < 0)
+        w = sw;
+    if (h < 0)
+        h = sh;
+
+    if (sx < 0) {
+        qreal w_ratio = sx * w/sw;
+        x -= w_ratio;
+        w += w_ratio;
+        sw += sx;
+        sx = 0;
+    }
+
+    if (sy < 0) {
+        qreal h_ratio = sy * h/sh;
+        y -= h_ratio;
+        h += h_ratio;
+        sh += sy;
+        sy = 0;
+    }
+
+    if (sw + sx > image.width()) {
+        qreal delta = sw - (image.width() - sx);
+        qreal w_ratio = delta * w/sw;
+        sw -= delta;
+        w -= w_ratio;
+    }
+
+    if (sh + sy > image.height()) {
+        qreal delta = sh - (image.height() - sy);
+        qreal h_ratio = delta * h/sh;
+        sh -= delta;
+        h -= h_ratio;
+    }
+
+    if (w == 0 || h == 0 || sw <= 0 || sh <= 0)
+        return;
+
+    if (d->extended) {
+        d->extended->drawImage(QRectF(x, y, w, h), image, QRectF(sx, sy, sw, sh), flags);
+        return;
+    }
+
+    d->updateState(d->state);
+
+    if (((d->state->matrix.type() > QTransform::TxTranslate || (sw != w || sh != h))
+         && !d->engine->hasFeature(QPaintEngine::PixmapTransform))
+        || (!d->state->matrix.isAffine() && !d->engine->hasFeature(QPaintEngine::PerspectiveTransform))
+        || (d->state->opacity != 1.0 && !d->engine->hasFeature(QPaintEngine::ConstantOpacity)))
+    {
+        save();
+        // If there is no rotation 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::TxScale) {
+            const QPointF p = roundInDeviceCoordinates(QPointF(x, y), d->state->matrix);
+            x = p.x();
+            y = p.y();
+        }
+
+        if (d->state->matrix.type() <= QTransform::TxTranslate && sw == w && sh == h) {
+            sx = qRound(sx);
+            sy = qRound(sy);
+            sw = qRound(sw);
+            sh = qRound(sh);
+        }
+        translate(x, y);
+        scale(w / sw, h / sh);
+        setBackgroundMode(Qt::TransparentMode);
+        setRenderHint(Antialiasing, renderHints() & SmoothPixmapTransform);
+        QBrush brush(image);
+        setBrush(brush);
+        setPen(Qt::NoPen);
+        setBrushOrigin(QPointF(-sx, -sy));
+
+        drawRect(QRectF(0, 0, sw, sh));
+        restore();
+        return;
+    }
+
+    if (d->state->matrix.type() == QTransform::TxTranslate
+        && !d->engine->hasFeature(QPaintEngine::PixmapTransform)) {
+        x += d->state->matrix.dx();
+        y += d->state->matrix.dy();
+    }
+
+    d->engine->drawImage(QRectF(x, y, w, h), image, QRectF(sx, sy, sw, sh), flags);
+}
+
+/*!
+    Draws the glyphs represented by \a glyphs at \a position. The \a position gives the
+    edge of the baseline for the string of glyphs. The glyphs will be retrieved from the font
+    selected on \a glyphs and at offsets given by the positions in \a glyphs.
+
+    \since 4.8
+
+    \sa QGlyphs::setFont(), QGlyphs::setPositions(), QGlyphs::setGlyphIndexes()
+*/
+#if !defined(QT_NO_RAWFONT)
+void QPainter::drawGlyphs(const QPointF &position, const QGlyphs &glyphs)
+{
+    Q_D(QPainter);
+
+    QRawFont font = glyphs.font();
+    if (!font.isValid())
+        return;
+
+    QVector<quint32> glyphIndexes = glyphs.glyphIndexes();
+    QVector<QPointF> glyphPositions = glyphs.positions();
+
+    int count = qMin(glyphIndexes.size(), glyphPositions.size());
+    QVarLengthArray<QFixedPoint, 128> fixedPointPositions(count);
+
+    bool paintEngineSupportsTransformations =
+            d->extended != 0
+            ? qt_paintengine_supports_transformations(d->extended->type())
+            : false;
+    for (int i=0; i<count; ++i) {
+        QPointF processedPosition = position + glyphPositions.at(i);
+        if (!paintEngineSupportsTransformations)
+            processedPosition = d->state->transform().map(processedPosition);
+        fixedPointPositions[i] = QFixedPoint::fromPointF(processedPosition);
+    }
+
+    d->drawGlyphs(glyphIndexes.data(), fixedPointPositions.data(), count, font, glyphs.overline(),
+                  glyphs.underline(), glyphs.strikeOut());
+}
+
+void QPainterPrivate::drawGlyphs(quint32 *glyphArray, QFixedPoint *positions, int glyphCount,
+                                 const QRawFont &font, bool overline, bool underline,
+                                 bool strikeOut)
+{
+    Q_Q(QPainter);
+
+    updateState(state);
+
+    QRawFontPrivate *fontD = QRawFontPrivate::get(font);
+    QFontEngine *fontEngine = fontD->fontEngine;
+
+    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;
+
+    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;
+
+        extended->drawStaticTextItem(&staticTextItem);
+    } else {
+        QTextItemInt textItem;
+        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;
+        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);
+    }
+
+    QTextItemInt::RenderFlags flags;
+    if (underline)
+        flags |= QTextItemInt::Underline;
+    if (overline)
+        flags |= QTextItemInt::Overline;
+    if (strikeOut)
+        flags |= QTextItemInt::StrikeOut;
+
+    drawTextItemDecoration(q, QPointF(leftMost.toReal(), baseLine.toReal()),
+                           fontEngine,
+                           (underline
+                              ? QTextCharFormat::SingleUnderline
+                              : QTextCharFormat::NoUnderline),
+                           flags, width.toReal(), QTextCharFormat());
+}
+#endif // QT_NO_RAWFONT
+
+/*!
+
+    \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)
+
+    Draws the given \a text with the currently defined text direction,
+    beginning at the given \a position.
+
+    This function does not handle the newline character (\n), as it cannot
+    break text into multiple lines, and it cannot display the newline character.
+    Use the QPainter::drawText() overload that takes a rectangle instead
+    if you want to draw multiple lines of text with the newline character, or
+    if you want the text to be wrapped.
+
+    By default, QPainter draws text anti-aliased.
+
+    \note The y-position is used as the baseline of the font.
+*/
+
+void QPainter::drawText(const QPointF &p, const QString &str)
+{
+    drawText(p, str, 0, 0);
+}
+
+/*!
+    \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 = qt_paintengine_supports_transformations(d->extended->type());
+    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);
+
+        qt_draw_decoration_for_glyphs(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
+*/
+void QPainter::drawText(const QPointF &p, const QString &str, int tf, int justificationPadding)
+{
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::drawText(), pos=[%.2f,%.2f], str='%s'\n", p.x(), p.y(), str.toLatin1().constData());
+#endif
+
+    Q_D(QPainter);
+
+    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);
+    engine.option.setTextDirection(d->state->layoutDirection);
+    if (tf & (Qt::TextForceLeftToRight|Qt::TextForceRightToLeft)) {
+        engine.ignoreBidi = true;
+        engine.option.setTextDirection((tf & Qt::TextForceLeftToRight) ? Qt::LeftToRight : Qt::RightToLeft);
+    }
+    engine.itemize();
+    QScriptLine line;
+    line.length = str.length();
+    engine.shapeLine(line);
+
+    int nItems = engine.layoutData->items.size();
+    QVarLengthArray<int> visualOrder(nItems);
+    QVarLengthArray<uchar> levels(nItems);
+    for (int i = 0; i < nItems; ++i)
+        levels[i] = engine.layoutData->items[i].analysis.bidiLevel;
+    QTextEngine::bidiReorder(nItems, levels.data(), visualOrder.data());
+
+    if (justificationPadding > 0) {
+        engine.option.setAlignment(Qt::AlignJustify);
+        engine.forceJustification = true;
+        // this works because justify() is only interested in the difference between width and textWidth
+        line.width = justificationPadding;
+        engine.justify(line);
+    }
+    QFixed x = QFixed::fromReal(p.x());
+
+    for (int i = 0; i < nItems; ++i) {
+        int item = visualOrder[i];
+        const QScriptItem &si = engine.layoutData->items.at(item);
+        if (si.analysis.flags >= QScriptAnalysis::TabOrObject) {
+            x += si.width;
+            continue;
+        }
+        QFont f = engine.font(si);
+        QTextItemInt gf(si, &f);
+        gf.glyphs = engine.shapedGlyphs(&si);
+        gf.chars = engine.layoutData->string.unicode() + si.position;
+        gf.num_chars = engine.length(item);
+        if (engine.forceJustification) {
+            for (int j=0; j<gf.glyphs.numGlyphs; ++j)
+                gf.width += gf.glyphs.effectiveAdvance(j);
+        } else {
+            gf.width = si.width;
+        }
+        gf.logClusters = engine.logClusters(&si);
+
+        drawTextItem(QPointF(x.toReal(), p.y()), gf);
+
+        x += gf.width;
+    }
+}
+
+void QPainter::drawText(const QRect &r, int flags, const QString &str, QRect *br)
+{
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::drawText(), r=[%d,%d,%d,%d], flags=%d, str='%s'\n",
+           r.x(), r.y(), r.width(), r.height(), flags, str.toLatin1().constData());
+#endif
+
+    Q_D(QPainter);
+
+    if (!d->engine || str.length() == 0 || pen().style() == Qt::NoPen)
+        return;
+
+    if (!d->extended)
+        d->updateState(d->state);
+
+    QRectF bounds;
+    qt_format_text(d->state->font, r, flags, 0, str, br ? &bounds : 0, 0, 0, 0, this);
+    if (br)
+        *br = bounds.toAlignedRect();
+}
+
+/*!
+    \fn void QPainter::drawText(const QPoint &position, const QString &text)
+
+    \overload
+
+    Draws the given \a text with the currently defined text direction,
+    beginning at the given \a position.
+
+    By default, QPainter draws text anti-aliased.
+
+    \note The y-position is used as the baseline of the font.
+
+*/
+
+/*!
+    \fn void QPainter::drawText(const QRectF &rectangle, int flags, const QString &text, QRectF *boundingRect)
+    \overload
+
+    Draws the given \a text within the provided \a rectangle.
+
+    \table 100%
+    \row
+    \o \inlineimage qpainter-text.png
+    \o
+    \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 17
+    \endtable
+
+    The \a boundingRect (if not null) is set to the what the bounding rectangle
+    should be in order to enclose the whole text. The \a flags argument is a bitwise
+    OR of the following flags:
+
+    \list
+    \o Qt::AlignLeft
+    \o Qt::AlignRight
+    \o Qt::AlignHCenter
+    \o Qt::AlignJustify
+    \o Qt::AlignTop
+    \o Qt::AlignBottom
+    \o Qt::AlignVCenter
+    \o Qt::AlignCenter
+    \o Qt::TextDontClip
+    \o Qt::TextSingleLine
+    \o Qt::TextExpandTabs
+    \o Qt::TextShowMnemonic
+    \o Qt::TextWordWrap
+    \o Qt::TextIncludeTrailingSpaces
+    \endlist
+
+    \sa Qt::AlignmentFlag, Qt::TextFlag, boundingRect(), layoutDirection()
+
+    By default, QPainter draws text anti-aliased.
+
+    \note The y-coordinate of \a rectangle is used as the top of the font.
+*/
+void QPainter::drawText(const QRectF &r, int flags, const QString &str, QRectF *br)
+{
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::drawText(), r=[%.2f,%.2f,%.2f,%.2f], flags=%d, str='%s'\n",
+           r.x(), r.y(), r.width(), r.height(), flags, str.toLatin1().constData());
+#endif
+
+    Q_D(QPainter);
+
+    if (!d->engine || str.length() == 0 || pen().style() == Qt::NoPen)
+        return;
+
+    if (!d->extended)
+        d->updateState(d->state);
+
+    qt_format_text(d->state->font, r, flags, 0, str, br, 0, 0, 0, this);
+}
+
+/*!
+    \fn void QPainter::drawText(const QRect &rectangle, int flags, const QString &text, QRect *boundingRect)
+    \overload
+
+    Draws the given \a text within the provided \a rectangle according
+    to the specified \a flags. The \a boundingRect (if not null) is set to
+    the what the bounding rectangle should be in order to enclose the whole text.
+
+    By default, QPainter draws text anti-aliased.
+
+    \note The y-coordinate of \a rectangle is used as the top of the font.
+*/
+
+/*!
+    \fn void QPainter::drawText(int x, int y, const QString &text)
+
+    \overload
+
+    Draws the given \a text at position (\a{x}, \a{y}), using the painter's
+    currently defined text direction.
+
+    By default, QPainter draws text anti-aliased.
+
+    \note The y-position is used as the baseline of the font.
+
+*/
+
+/*!
+    \fn void QPainter::drawText(int x, int y, int width, int height, int flags,
+                                const QString &text, QRect *boundingRect)
+
+    \overload
+
+    Draws the given \a text within the rectangle with origin (\a{x},
+    \a{y}), \a width and \a height.
+
+    The \a boundingRect (if not null) is set to the actual bounding
+    rectangle of the output.  The \a flags argument is a bitwise OR of
+    the following flags:
+
+    \list
+    \o Qt::AlignLeft
+    \o Qt::AlignRight
+    \o Qt::AlignHCenter
+    \o Qt::AlignJustify
+    \o Qt::AlignTop
+    \o Qt::AlignBottom
+    \o Qt::AlignVCenter
+    \o Qt::AlignCenter
+    \o Qt::TextSingleLine
+    \o Qt::TextExpandTabs
+    \o Qt::TextShowMnemonic
+    \o Qt::TextWordWrap
+    \endlist
+
+    By default, QPainter draws text anti-aliased.
+
+    \note The y-position is used as the top of the font.
+
+    \sa Qt::AlignmentFlag, Qt::TextFlag
+*/
+
+/*!
+    \fn void QPainter::drawText(const QRectF &rectangle, const QString &text,
+        const QTextOption &option)
+    \overload
+
+    Draws the given \a text in the \a rectangle specified using the \a option
+    to control its positioning and orientation.
+
+    By default, QPainter draws text anti-aliased.
+
+    \note The y-coordinate of \a rectangle is used as the top of the font.
+*/
+void QPainter::drawText(const QRectF &r, const QString &text, const QTextOption &o)
+{
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::drawText(), r=[%.2f,%.2f,%.2f,%.2f], str='%s'\n",
+           r.x(), r.y(), r.width(), r.height(), text.toLatin1().constData());
+#endif
+
+    Q_D(QPainter);
+
+    if (!d->engine || text.length() == 0 || pen().style() == Qt::NoPen)
+        return;
+
+    if (!d->extended)
+        d->updateState(d->state);
+
+    qt_format_text(d->state->font, r, 0, &o, text, 0, 0, 0, 0, this);
+}
+
+/*!
+    \fn void QPainter::drawTextItem(int x, int y, const QTextItem &ti)
+
+    \internal
+    \overload
+*/
+
+/*!
+    \fn void QPainter::drawTextItem(const QPoint &p, const QTextItem &ti)
+
+    \internal
+    \overload
+
+    Draws the text item \a ti at position \a p.
+*/
+
+/*!
+    \fn void QPainter::drawTextItem(const QPointF &p, const QTextItem &ti)
+
+    \internal
+    \since 4.1
+
+    Draws the text item \a ti at position \a p.
+
+    This method ignores the painters background mode and
+    color. drawText and qt_format_text have to do it themselves, as
+    only they know the extents of the complete string.
+
+    It ignores the font set on the painter as the text item has one of its own.
+
+    The underline and strikeout parameters of the text items font are
+    ignored aswell. You'll need to pass in the correct flags to get
+    underlining and strikeout.
+*/
+
+static QPixmap generateWavyPixmap(qreal maxRadius, const QPen &pen)
+{
+    const qreal radiusBase = qMax(qreal(1), maxRadius);
+
+    QString key = QLatin1Literal("WaveUnderline-")
+                  % pen.color().name()
+                  % HexString<qreal>(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;
+
+    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;
+}
+
+static void drawTextItemDecoration(QPainter *painter, const QPointF &pos, const QFontEngine *fe,
+                                   QTextCharFormat::UnderlineStyle underlineStyle,
+                                   QTextItem::RenderFlags flags, qreal width,
+                                   const QTextCharFormat &charFormat)
+{
+    if (underlineStyle == QTextCharFormat::NoUnderline
+        && !(flags & (QTextItem::StrikeOut | QTextItem::Overline)))
+        return;
+
+    const QPen oldPen = painter->pen();
+    const QBrush oldBrush = painter->brush();
+    painter->setBrush(Qt::NoBrush);
+    QPen pen = oldPen;
+    pen.setStyle(Qt::SolidLine);
+    pen.setWidthF(fe->lineThickness().toReal());
+    pen.setCapStyle(Qt::FlatCap);
+
+    QLineF line(pos.x(), pos.y(), pos.x() + qFloor(width), pos.y());
+
+    const qreal underlineOffset = fe->underlinePosition().toReal();
+    // deliberately ceil the offset to avoid the underline coming too close to
+    // the text above it.
+    const qreal aliasedCoordinateDelta = 0.5 - 0.015625;
+    const qreal underlinePos = pos.y() + qCeil(underlineOffset) - aliasedCoordinateDelta;
+
+    if (underlineStyle == QTextCharFormat::SpellCheckUnderline) {
+        underlineStyle = QTextCharFormat::UnderlineStyle(QApplication::style()->styleHint(QStyle::SH_SpellCheckUnderlineStyle));
+    }
+
+    if (underlineStyle == QTextCharFormat::WaveUnderline) {
+        painter->save();
+        painter->translate(0, pos.y() + 1);
+
+        QColor uc = charFormat.underlineColor();
+        if (uc.isValid())
+            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) fe->descent().toReal();
+
+        painter->setBrushOrigin(painter->brushOrigin().x(), 0);
+        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 = charFormat.underlineColor();
+        if (uc.isValid())
+            pen.setColor(uc);
+
+        pen.setStyle((Qt::PenStyle)(underlineStyle));
+        painter->setPen(pen);
+        painter->drawLine(underLine);
+    }
+
+    pen.setStyle(Qt::SolidLine);
+    pen.setColor(oldPen.color());
+
+    if (flags & QTextItem::StrikeOut) {
+        QLineF strikeOutLine = line;
+        strikeOutLine.translate(0., - fe->ascent().toReal() / 3.);
+        painter->setPen(pen);
+        painter->drawLine(strikeOutLine);
+    }
+
+    if (flags & QTextItem::Overline) {
+        QLineF overLine = line;
+        overLine.translate(0., - fe->ascent().toReal());
+        painter->setPen(pen);
+        painter->drawLine(overLine);
+    }
+
+    painter->setPen(oldPen);
+    painter->setBrush(oldBrush);
+}
+
+Q_GUI_EXPORT void qt_draw_decoration_for_glyphs(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);
+}
+
+void QPainter::drawTextItem(const QPointF &p, const QTextItem &_ti)
+{
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::drawTextItem(), pos=[%.f,%.f], str='%s'\n",
+               p.x(), p.y(), qPrintable(_ti.text()));
+#endif
+
+    Q_D(QPainter);
+
+    if (!d->engine)
+        return;
+
+#ifndef QT_NO_DEBUG
+    qt_painter_thread_test(d->device->devType(),
+                           "text and fonts",
+                           QFontDatabase::supportsThreadedFontRendering());
+#endif
+
+    QTextItemInt &ti = const_cast<QTextItemInt &>(static_cast<const QTextItemInt &>(_ti));
+
+    if (!d->extended && d->state->bgMode == Qt::OpaqueMode) {
+        QRectF rect(p.x(), p.y() - ti.ascent.toReal(), ti.width.toReal(), (ti.ascent + ti.descent + 1).toReal());
+        fillRect(rect, d->state->bgBrush);
+    }
+
+    if (pen().style() == Qt::NoPen)
+        return;
+
+    const RenderHints oldRenderHints = d->state->renderHints;
+    if (!d->state->renderHints & QPainter::Antialiasing && d->state->matrix.type() >= QTransform::TxScale) {
+        // draw antialias decoration (underline/overline/strikeout) with
+        // transformed text
+
+        bool aa = true;
+        const QTransform &m = d->state->matrix;
+        if (d->state->matrix.type() < QTransform::TxShear) {
+            bool isPlain90DegreeRotation =
+                (qFuzzyIsNull(m.m11())
+                 && qFuzzyIsNull(m.m12() - qreal(1))
+                 && qFuzzyIsNull(m.m21() + qreal(1))
+                 && qFuzzyIsNull(m.m22())
+                    )
+                ||
+                (qFuzzyIsNull(m.m11() + qreal(1))
+                 && qFuzzyIsNull(m.m12())
+                 && qFuzzyIsNull(m.m21())
+                 && qFuzzyIsNull(m.m22() + qreal(1))
+                    )
+                ||
+                (qFuzzyIsNull(m.m11())
+                 && qFuzzyIsNull(m.m12() + qreal(1))
+                 && qFuzzyIsNull(m.m21() - qreal(1))
+                 && qFuzzyIsNull(m.m22())
+                    )
+                ;
+            aa = !isPlain90DegreeRotation;
+        }
+        if (aa)
+            setRenderHint(QPainter::Antialiasing, true);
+    }
+
+    if (!d->extended)
+        d->updateState(d->state);
+
+    if (!ti.glyphs.numGlyphs) {
+        // nothing to do
+    } else if (ti.fontEngine->type() == QFontEngine::Multi) {
+        QFontEngineMulti *multi = static_cast<QFontEngineMulti *>(ti.fontEngine);
+
+        const QGlyphLayout &glyphs = ti.glyphs;
+        int which = glyphs.glyphs[0] >> 24;
+
+        qreal x = p.x();
+        qreal y = p.y();
+
+        int start = 0;
+        int end, i;
+        for (end = 0; end < ti.glyphs.numGlyphs; ++end) {
+            const int e = glyphs.glyphs[end] >> 24;
+            if (e == which)
+                continue;
+
+
+            QTextItemInt ti2 = ti.midItem(multi->engine(which), start, end - start);
+            ti2.width = 0;
+            // set the high byte to zero and calc the width
+            for (i = start; i < end; ++i) {
+                glyphs.glyphs[i] = glyphs.glyphs[i] & 0xffffff;
+                ti2.width += ti.glyphs.effectiveAdvance(i);
+            }
+
+            d->engine->drawTextItem(QPointF(x, y), ti2);
+
+            // reset the high byte for all glyphs and advance to the next sub-string
+            const int hi = which << 24;
+            for (i = start; i < end; ++i) {
+                glyphs.glyphs[i] = hi | glyphs.glyphs[i];
+            }
+            x += ti2.width.toReal();
+
+            // change engine
+            start = end;
+            which = e;
+        }
+
+        QTextItemInt ti2 = ti.midItem(multi->engine(which), start, end - start);
+        ti2.width = 0;
+        // set the high byte to zero and calc the width
+        for (i = start; i < end; ++i) {
+            glyphs.glyphs[i] = glyphs.glyphs[i] & 0xffffff;
+            ti2.width += ti.glyphs.effectiveAdvance(i);
+        }
+
+        if (d->extended)
+            d->extended->drawTextItem(QPointF(x, y), ti2);
+        else
+            d->engine->drawTextItem(QPointF(x,y), ti2);
+
+        // reset the high byte for all glyphs
+        const int hi = which << 24;
+        for (i = start; i < end; ++i)
+            glyphs.glyphs[i] = hi | glyphs.glyphs[i];
+
+    } else {
+        if (d->extended)
+            d->extended->drawTextItem(p, ti);
+        else
+            d->engine->drawTextItem(p, ti);
+    }
+    drawTextItemDecoration(this, p, ti.fontEngine, ti.underlineStyle, ti.flags, ti.width.toReal(),
+                           ti.charFormat);
+
+    if (d->state->renderHints != oldRenderHints) {
+        d->state->renderHints = oldRenderHints;
+        if (d->extended)
+            d->extended->renderHintsChanged();
+        else
+            d->state->dirtyFlags |= QPaintEngine::DirtyHints;
+    }
+}
+
+/*!
+    \fn QRectF QPainter::boundingRect(const QRectF &rectangle, int flags, const QString &text)
+
+    Returns the bounding rectangle of the \a text as it will appear
+    when drawn inside the given \a rectangle with the specified \a
+    flags using the currently set font(); i.e the function tells you
+    where the drawText() function will draw when given the same
+    arguments.
+
+    If the \a text does not fit within the given \a rectangle using
+    the specified \a flags, the function returns the required
+    rectangle.
+
+    The \a flags argument is a bitwise OR of the following flags:
+    \list
+         \o Qt::AlignLeft
+         \o Qt::AlignRight
+         \o Qt::AlignHCenter
+         \o Qt::AlignTop
+         \o Qt::AlignBottom
+         \o Qt::AlignVCenter
+         \o Qt::AlignCenter
+         \o Qt::TextSingleLine
+         \o Qt::TextExpandTabs
+         \o Qt::TextShowMnemonic
+         \o Qt::TextWordWrap
+         \o Qt::TextIncludeTrailingSpaces
+    \endlist
+    If several of the horizontal or several of the vertical alignment
+    flags are set, the resulting alignment is undefined.
+
+    \sa drawText(), Qt::Alignment, Qt::TextFlag
+*/
+
+/*!
+    \fn QRect QPainter::boundingRect(const QRect &rectangle, int flags,
+                                     const QString &text)
+
+    \overload
+
+    Returns the bounding rectangle of the \a text as it will appear
+    when drawn inside the given \a rectangle with the specified \a
+    flags using the currently set font().
+*/
+
+/*!
+    \fn QRect QPainter::boundingRect(int x, int y, int w, int h, int flags,
+                                     const QString &text);
+
+    \overload
+
+    Returns the bounding rectangle of the given \a text as it will
+    appear when drawn inside the rectangle beginning at the point
+    (\a{x}, \a{y}) with width \a w and height \a h.
+*/
+QRect QPainter::boundingRect(const QRect &rect, int flags, const QString &str)
+{
+    if (str.isEmpty())
+        return QRect(rect.x(),rect.y(), 0,0);
+    QRect brect;
+    drawText(rect, flags | Qt::TextDontPrint, str, &brect);
+    return brect;
+}
+
+
+
+QRectF QPainter::boundingRect(const QRectF &rect, int flags, const QString &str)
+{
+    if (str.isEmpty())
+        return QRectF(rect.x(),rect.y(), 0,0);
+    QRectF brect;
+    drawText(rect, flags | Qt::TextDontPrint, str, &brect);
+    return brect;
+}
+
+/*!
+    \fn QRectF QPainter::boundingRect(const QRectF &rectangle,
+        const QString &text, const QTextOption &option)
+
+    \overload
+
+    Instead of specifying flags as a bitwise OR of the
+    Qt::AlignmentFlag and Qt::TextFlag, this overloaded function takes
+    an \a option argument. The QTextOption class provides a
+    description of general rich text properties.
+
+    \sa QTextOption
+*/
+QRectF QPainter::boundingRect(const QRectF &r, const QString &text, const QTextOption &o)
+{
+    Q_D(QPainter);
+
+    if (!d->engine || text.length() == 0)
+        return QRectF(r.x(),r.y(), 0,0);
+
+    QRectF br;
+    qt_format_text(d->state->font, r, Qt::TextDontPrint, &o, text, &br, 0, 0, 0, this);
+    return br;
+}
+
+/*!
+    \fn void QPainter::drawTiledPixmap(const QRectF &rectangle, const QPixmap &pixmap, const QPointF &position)
+
+    Draws a tiled \a pixmap, inside the given \a rectangle with its
+    origin at the given \a position.
+
+    Calling drawTiledPixmap() is similar to calling drawPixmap()
+    several times to fill (tile) an area with a pixmap, but is
+    potentially much more efficient depending on the underlying window
+    system.
+
+    \sa drawPixmap()
+*/
+void QPainter::drawTiledPixmap(const QRectF &r, const QPixmap &pixmap, const QPointF &sp)
+{
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::drawTiledPixmap(), target=[%.2f,%.2f,%.2f,%.2f], pix=[%d,%d], offset=[%.2f,%.2f]\n",
+               r.x(), r.y(), r.width(), r.height(),
+               pixmap.width(), pixmap.height(),
+               sp.x(), sp.y());
+#endif
+
+    Q_D(QPainter);
+    if (!d->engine || pixmap.isNull() || r.isEmpty())
+        return;
+
+#ifndef QT_NO_DEBUG
+    qt_painter_thread_test(d->device->devType(), "drawTiledPixmap()", true);
+#endif
+
+    qreal sw = pixmap.width();
+    qreal sh = pixmap.height();
+    qreal sx = sp.x();
+    qreal sy = sp.y();
+    if (sx < 0)
+        sx = qRound(sw) - qRound(-sx) % qRound(sw);
+    else
+        sx = qRound(sx) % qRound(sw);
+    if (sy < 0)
+        sy = qRound(sh) - -qRound(sy) % qRound(sh);
+    else
+        sy = qRound(sy) % qRound(sh);
+
+
+    if (d->extended) {
+        d->extended->drawTiledPixmap(r, pixmap, QPointF(sx, sy));
+        return;
+    }
+
+    if (d->state->bgMode == Qt::OpaqueMode && pixmap.isQBitmap())
+        fillRect(r, d->state->bgBrush);
+
+    d->updateState(d->state);
+    if ((d->state->matrix.type() > QTransform::TxTranslate
+        && !d->engine->hasFeature(QPaintEngine::PixmapTransform))
+        || (d->state->opacity != 1.0 && !d->engine->hasFeature(QPaintEngine::ConstantOpacity)))
+    {
+        save();
+        setBackgroundMode(Qt::TransparentMode);
+        setRenderHint(Antialiasing, renderHints() & SmoothPixmapTransform);
+        setBrush(QBrush(d->state->pen.color(), pixmap));
+        setPen(Qt::NoPen);
+
+        // If there is no rotation 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::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(p, r.size()));
+        } else {
+            setBrushOrigin(QPointF(r.x()-sx, r.y()-sy));
+            drawRect(r);
+        }
+        restore();
+        return;
+    }
+
+    qreal x = r.x();
+    qreal y = r.y();
+    if (d->state->matrix.type() == QTransform::TxTranslate
+        && !d->engine->hasFeature(QPaintEngine::PixmapTransform)) {
+        x += d->state->matrix.dx();
+        y += d->state->matrix.dy();
+    }
+
+    d->engine->drawTiledPixmap(QRectF(x, y, r.width(), r.height()), pixmap, QPointF(sx, sy));
+}
+
+/*!
+    \fn QPainter::drawTiledPixmap(const QRect &rectangle, const QPixmap &pixmap,
+                                  const QPoint &position = QPoint())
+    \overload
+
+    Draws a tiled \a pixmap, inside the given \a rectangle with its
+    origin at the given \a position.
+*/
+
+/*!
+    \fn void QPainter::drawTiledPixmap(int x, int y, int width, int height, const
+         QPixmap &pixmap, int sx, int sy);
+    \overload
+
+    Draws a tiled \a pixmap in the specified rectangle.
+
+    (\a{x}, \a{y}) specifies the top-left point in the paint device
+    that is to be drawn onto; with the given \a width and \a
+    height. (\a{sx}, \a{sy}) specifies the top-left point in the \a
+    pixmap that is to be drawn; this defaults to (0, 0).
+*/
+
+#ifndef QT_NO_PICTURE
+
+/*!
+    \fn void QPainter::drawPicture(const QPointF &point, const QPicture &picture)
+
+    Replays the given \a picture at the given \a point.
+
+    The QPicture class is a paint device that records and replays
+    QPainter commands. A picture serializes the painter commands to an
+    IO device in a platform-independent format. Everything that can be
+    painted on a widget or pixmap can also be stored in a picture.
+
+    This function does exactly the same as QPicture::play() when
+    called with \a point = QPoint(0, 0).
+
+    \table 100%
+    \row
+    \o
+    \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 18
+    \endtable
+
+    \sa QPicture::play()
+*/
+
+void QPainter::drawPicture(const QPointF &p, const QPicture &picture)
+{
+    Q_D(QPainter);
+
+    if (!d->engine)
+        return;
+
+    if (!d->extended)
+        d->updateState(d->state);
+
+    save();
+    translate(p);
+    const_cast<QPicture *>(&picture)->play(this);
+    restore();
+}
+
+/*!
+    \fn void QPainter::drawPicture(const QPoint &point, const QPicture &picture)
+    \overload
+
+    Replays the given \a picture at the given \a point.
+*/
+
+/*!
+    \fn void QPainter::drawPicture(int x, int y, const QPicture &picture)
+    \overload
+
+    Draws the given \a picture at point (\a x, \a y).
+*/
+
+#endif // QT_NO_PICTURE
+
+/*!
+    \fn void QPainter::eraseRect(const QRectF &rectangle)
+
+    Erases the area inside the given \a rectangle. Equivalent to
+    calling
+    \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 19
+
+    \sa fillRect()
+*/
+void QPainter::eraseRect(const QRectF &r)
+{
+    Q_D(QPainter);
+
+    fillRect(r, d->state->bgBrush);
+}
+
+static inline bool needsResolving(const QBrush &brush)
+{
+    Qt::BrushStyle s = brush.style();
+    return ((s == Qt::LinearGradientPattern || s == Qt::RadialGradientPattern ||
+             s == Qt::ConicalGradientPattern) &&
+            brush.gradient()->coordinateMode() == QGradient::ObjectBoundingMode);
+}
+
+/*!
+    \fn void QPainter::eraseRect(const QRect &rectangle)
+    \overload
+
+    Erases the area inside the given  \a rectangle.
+*/
+
+/*!
+    \fn void QPainter::eraseRect(int x, int y, int width, int height)
+    \overload
+
+    Erases the area inside the rectangle beginning at (\a x, \a y)
+    with the given \a width and \a height.
+*/
+
+
+/*!
+    \fn void QPainter::fillRect(int x, int y, int width, int height, Qt::BrushStyle style)
+    \overload
+
+    Fills the rectangle beginning at (\a{x}, \a{y}) with the given \a
+    width and \a height, using the brush \a style specified.
+
+    \since 4.5
+*/
+
+/*!
+    \fn void QPainter::fillRect(const QRect &rectangle, Qt::BrushStyle style)
+    \overload
+
+    Fills the given \a rectangle  with the brush \a style specified.
+
+    \since 4.5
+*/
+
+/*!
+    \fn void QPainter::fillRect(const QRectF &rectangle, Qt::BrushStyle style)
+    \overload
+
+    Fills the given \a rectangle  with the brush \a style specified.
+
+    \since 4.5
+*/
+
+/*!
+    \fn void QPainter::fillRect(const QRectF &rectangle, const QBrush &brush)
+
+    Fills the given \a rectangle  with the \a brush specified.
+
+    Alternatively, you can specify a QColor instead of a QBrush; the
+    QBrush constructor (taking a QColor argument) will automatically
+    create a solid pattern brush.
+
+    \sa drawRect()
+*/
+void QPainter::fillRect(const QRectF &r, const QBrush &brush)
+{
+    Q_D(QPainter);
+
+    if (!d->engine)
+        return;
+
+    if (d->extended) {
+        const QGradient *g = brush.gradient();
+        if (!g || g->coordinateMode() == QGradient::LogicalMode) {
+            d->extended->fillRect(r, brush);
+            return;
+        }
+    }
+
+    QPen oldPen = pen();
+    QBrush oldBrush = this->brush();
+    setPen(Qt::NoPen);
+    if (brush.style() == Qt::SolidPattern) {
+        d->colorBrush.setStyle(Qt::SolidPattern);
+        d->colorBrush.setColor(brush.color());
+        setBrush(d->colorBrush);
+    } else {
+        setBrush(brush);
+    }
+
+    drawRect(r);
+    setBrush(oldBrush);
+    setPen(oldPen);
+}
+
+/*!
+    \fn void QPainter::fillRect(const QRect &rectangle, const QBrush &brush)
+    \overload
+
+    Fills the given \a rectangle with the specified \a brush.
+*/
+
+void QPainter::fillRect(const QRect &r, const QBrush &brush)
+{
+    Q_D(QPainter);
+
+    if (!d->engine)
+        return;
+
+    if (d->extended) {
+        const QGradient *g = brush.gradient();
+        if (!g || g->coordinateMode() == QGradient::LogicalMode) {
+            d->extended->fillRect(r, brush);
+            return;
+        }
+    }
+
+    QPen oldPen = pen();
+    QBrush oldBrush = this->brush();
+    setPen(Qt::NoPen);
+    if (brush.style() == Qt::SolidPattern) {
+        d->colorBrush.setStyle(Qt::SolidPattern);
+        d->colorBrush.setColor(brush.color());
+        setBrush(d->colorBrush);
+    } else {
+        setBrush(brush);
+    }
+
+    drawRect(r);
+    setBrush(oldBrush);
+    setPen(oldPen);
+}
+
+
+
+/*!
+    \fn void QPainter::fillRect(const QRect &rectangle, const QColor &color)
+    \overload
+
+    Fills the given \a rectangle with the \a color specified.
+
+    \since 4.5
+*/
+void QPainter::fillRect(const QRect &r, const QColor &color)
+{
+    Q_D(QPainter);
+
+    if (!d->engine)
+        return;
+
+    if (d->extended) {
+        d->extended->fillRect(r, color);
+        return;
+    }
+
+    fillRect(r, QBrush(color));
+}
+
+
+/*!
+    \fn void QPainter::fillRect(const QRectF &rectangle, const QColor &color)
+    \overload
+
+    Fills the given \a rectangle with the \a color specified.
+
+    \since 4.5
+*/
+void QPainter::fillRect(const QRectF &r, const QColor &color)
+{
+    Q_D(QPainter);
+
+    if (!d->engine)
+        return;
+
+    if (d->extended) {
+        d->extended->fillRect(r, color);
+        return;
+    }
+
+    fillRect(r, QBrush(color));
+}
+
+/*!
+    \fn void QPainter::fillRect(int x, int y, int width, int height, const QBrush &brush)
+
+    \overload
+
+    Fills the rectangle beginning at (\a{x}, \a{y}) with the given \a
+    width and \a height, using the given \a brush.
+*/
+
+/*!
+    \fn void QPainter::fillRect(int x, int y, int width, int height, const QColor &color)
+
+    \overload
+
+    Fills the rectangle beginning at (\a{x}, \a{y}) with the given \a
+    width and \a height, using the given \a color.
+
+    \since 4.5
+*/
+
+/*!
+    \fn void QPainter::fillRect(int x, int y, int width, int height, Qt::GlobalColor color)
+
+    \overload
+
+    Fills the rectangle beginning at (\a{x}, \a{y}) with the given \a
+    width and \a height, using the given \a color.
+
+    \since 4.5
+*/
+
+/*!
+    \fn void QPainter::fillRect(const QRect &rectangle, Qt::GlobalColor color);
+
+    \overload
+
+    Fills the given \a rectangle with the specified \a color.
+
+    \since 4.5
+*/
+
+/*!
+    \fn void QPainter::fillRect(const QRectF &rectangle, Qt::GlobalColor color);
+
+    \overload
+
+    Fills the given \a rectangle with the specified \a color.
+
+    \since 4.5
+*/
+
+/*!
+    Sets the given render \a hint on the painter if \a on is true;
+    otherwise clears the render hint.
+
+    \sa setRenderHints(), renderHints(), {QPainter#Rendering
+    Quality}{Rendering Quality}
+*/
+void QPainter::setRenderHint(RenderHint hint, bool on)
+{
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::setRenderHint: hint=%x, %s\n", hint, on ? "on" : "off");
+#endif
+
+#ifndef QT_NO_DEBUG
+    static const bool antialiasingDisabled = qgetenv("QT_NO_ANTIALIASING").toInt();
+    if (hint == QPainter::Antialiasing && antialiasingDisabled)
+        return;
+#endif
+
+    setRenderHints(hint, on);
+}
+
+/*!
+    \since 4.2
+
+    Sets the given render \a hints on the painter if \a on is true;
+    otherwise clears the render hints.
+
+    \sa setRenderHint(), renderHints(), {QPainter#Rendering
+    Quality}{Rendering Quality}
+*/
+
+void QPainter::setRenderHints(RenderHints hints, bool on)
+{
+    Q_D(QPainter);
+
+    if (!d->engine) {
+        qWarning("QPainter::setRenderHint: Painter must be active to set rendering hints");
+        return;
+    }
+
+    if (on)
+        d->state->renderHints |= hints;
+    else
+        d->state->renderHints &= ~hints;
+
+    if (d->extended)
+        d->extended->renderHintsChanged();
+    else
+        d->state->dirtyFlags |= QPaintEngine::DirtyHints;
+}
+
+/*!
+    Returns a flag that specifies the rendering hints that are set for
+    this painter.
+
+    \sa testRenderHint(), {QPainter#Rendering Quality}{Rendering Quality}
+*/
+QPainter::RenderHints QPainter::renderHints() const
+{
+    Q_D(const QPainter);
+
+    if (!d->engine)
+        return 0;
+
+    return d->state->renderHints;
+}
+
+/*!
+    \fn bool QPainter::testRenderHint(RenderHint hint) const
+    \since 4.3
+
+    Returns true if \a hint is set; otherwise returns false.
+
+    \sa renderHints(), setRenderHint()
+*/
+
+/*!
+    Returns true if view transformation is enabled; otherwise returns
+    false.
+
+    \sa setViewTransformEnabled(), worldTransform()
+*/
+
+bool QPainter::viewTransformEnabled() const
+{
+    Q_D(const QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::viewTransformEnabled: Painter not active");
+        return false;
+    }
+    return d->state->VxF;
+}
+
+/*!
+    \fn void QPainter::setWindow(const QRect &rectangle)
+
+    Sets the painter's window to the given \a rectangle, and enables
+    view transformations.
+
+    The window rectangle is part of the view transformation. The
+    window specifies the logical coordinate system. Its sister, the
+    viewport(), specifies the device coordinate system.
+
+    The default window rectangle is the same as the device's
+    rectangle.
+
+    \sa window(), viewTransformEnabled(), {Coordinate
+    System#Window-Viewport Conversion}{Window-Viewport Conversion}
+*/
+
+/*!
+    \fn void QPainter::setWindow(int x, int y, int width, int height)
+    \overload
+
+    Sets the painter's window to the rectangle beginning at (\a x, \a
+    y) and the given \a width and \a height.
+*/
+
+void QPainter::setWindow(const QRect &r)
+{
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::setWindow(), [%d,%d,%d,%d]\n", r.x(), r.y(), r.width(), r.height());
+#endif
+
+    Q_D(QPainter);
+
+    if (!d->engine) {
+        qWarning("QPainter::setWindow: Painter not active");
+        return;
+    }
+
+    d->state->wx = r.x();
+    d->state->wy = r.y();
+    d->state->ww = r.width();
+    d->state->wh = r.height();
+
+    d->state->VxF = true;
+    d->updateMatrix();
+}
+
+/*!
+    Returns the window rectangle.
+
+    \sa setWindow(), setViewTransformEnabled()
+*/
+
+QRect QPainter::window() const
+{
+    Q_D(const QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::window: Painter not active");
+        return QRect();
+    }
+    return QRect(d->state->wx, d->state->wy, d->state->ww, d->state->wh);
+}
+
+/*!
+    \fn void QPainter::setViewport(const QRect &rectangle)
+
+    Sets the painter's viewport rectangle to the given \a rectangle,
+    and enables view transformations.
+
+    The viewport rectangle is part of the view transformation. The
+    viewport specifies the device coordinate system. Its sister, the
+    window(), specifies the logical coordinate system.
+
+    The default viewport rectangle is the same as the device's
+    rectangle.
+
+    \sa viewport(), viewTransformEnabled() {Coordinate
+    System#Window-Viewport Conversion}{Window-Viewport Conversion}
+*/
+
+/*!
+    \fn void QPainter::setViewport(int x, int y, int width, int height)
+    \overload
+
+    Sets the painter's viewport rectangle to be the rectangle
+    beginning at (\a x, \a y) with the given \a width and \a height.
+*/
+
+void QPainter::setViewport(const QRect &r)
+{
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::setViewport(), [%d,%d,%d,%d]\n", r.x(), r.y(), r.width(), r.height());
+#endif
+
+    Q_D(QPainter);
+
+    if (!d->engine) {
+        qWarning("QPainter::setViewport: Painter not active");
+        return;
+    }
+
+    d->state->vx = r.x();
+    d->state->vy = r.y();
+    d->state->vw = r.width();
+    d->state->vh = r.height();
+
+    d->state->VxF = true;
+    d->updateMatrix();
+}
+
+/*!
+    Returns the viewport rectangle.
+
+    \sa setViewport(), setViewTransformEnabled()
+*/
+
+QRect QPainter::viewport() const
+{
+    Q_D(const QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::viewport: Painter not active");
+        return QRect();
+    }
+    return QRect(d->state->vx, d->state->vy, d->state->vw, d->state->vh);
+}
+
+/*! \fn bool QPainter::hasViewXForm() const
+    \compat
+
+    Use viewTransformEnabled() instead.
+*/
+
+/*! \fn bool QPainter::hasWorldXForm() const
+    \compat
+
+    Use worldMatrixEnabled() instead.
+*/
+
+/*! \fn void QPainter::resetXForm()
+    \compat
+
+    Use resetTransform() instead.
+*/
+
+/*! \fn void QPainter::setViewXForm(bool enabled)
+    \compat
+
+    Use setViewTransformEnabled() instead.
+*/
+
+/*! \fn void QPainter::setWorldXForm(bool enabled)
+    \compat
+
+    Use setWorldMatrixEnabled() instead.
+*/
+/*!
+    Enables view transformations if \a enable is true, or disables
+    view transformations if \a enable is false.
+
+    \sa viewTransformEnabled(), {Coordinate System#Window-Viewport
+    Conversion}{Window-Viewport Conversion}
+*/
+
+void QPainter::setViewTransformEnabled(bool enable)
+{
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::setViewTransformEnabled(), enable=%d\n", enable);
+#endif
+
+    Q_D(QPainter);
+
+    if (!d->engine) {
+        qWarning("QPainter::setViewTransformEnabled: Painter not active");
+        return;
+    }
+
+    if (enable == d->state->VxF)
+        return;
+
+    d->state->VxF = enable;
+    d->updateMatrix();
+}
+
+#ifdef QT3_SUPPORT
+
+/*!
+    \obsolete
+
+    Use the worldTransform() combined with QTransform::dx() instead.
+
+    \oldcode
+        QPainter painter(this);
+        qreal x = painter.translationX();
+    \newcode
+        QPainter painter(this);
+        qreal x = painter.worldTransform().dx();
+    \endcode
+*/
+qreal QPainter::translationX() const
+{
+    Q_D(const QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::translationX: Painter not active");
+        return 0.0;
+    }
+    return d->state->worldMatrix.dx();
+}
+
+/*!
+    \obsolete
+
+    Use the worldTransform() combined with QTransform::dy() instead.
+
+    \oldcode
+        QPainter painter(this);
+        qreal y = painter.translationY();
+    \newcode
+        QPainter painter(this);
+        qreal y = painter.worldTransform().dy();
+    \endcode
+*/
+qreal QPainter::translationY() const
+{
+    Q_D(const QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::translationY: Painter not active");
+        return 0.0;
+    }
+    return d->state->worldMatrix.dy();
+}
+
+/*!
+    \fn void QPainter::map(int x, int y, int *rx, int *ry) const
+
+    \internal
+
+    Sets (\a{rx}, \a{ry}) to the point that results from applying the
+    painter's current transformation on the point (\a{x}, \a{y}).
+*/
+void QPainter::map(int x, int y, int *rx, int *ry) const
+{
+    QPoint p(x, y);
+    p = p * combinedMatrix();
+    *rx = p.x();
+    *ry = p.y();
+}
+
+/*!
+    \fn QPoint QPainter::xForm(const QPoint &point) const
+
+    Use combinedTransform() instead.
+*/
+
+QPoint QPainter::xForm(const QPoint &p) const
+{
+    Q_D(const QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::xForm: Painter not active");
+        return QPoint();
+    }
+    if (d->state->matrix.type() == QTransform::TxNone)
+        return p;
+    return p * combinedMatrix();
+}
+
+
+/*!
+    \fn QRect QPainter::xForm(const QRect &rectangle) const
+    \overload
+
+    Use combinedTransform() instead of this function and call
+    mapRect() on the result to obtain a QRect.
+*/
+
+QRect QPainter::xForm(const QRect &r) const
+{
+    Q_D(const QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::xForm: Painter not active");
+        return QRect();
+    }
+    if (d->state->matrix.type() == QTransform::TxNone)
+        return r;
+    return combinedMatrix().mapRect(r);
+}
+
+/*!
+    \fn QPolygon QPainter::xForm(const QPolygon &polygon) const
+    \overload
+
+    Use combinedTransform() instead.
+*/
+
+QPolygon QPainter::xForm(const QPolygon &a) const
+{
+    Q_D(const QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::xForm: Painter not active");
+        return QPolygon();
+    }
+    if (d->state->matrix.type() == QTransform::TxNone)
+        return a;
+    return a * combinedMatrix();
+}
+
+/*!
+    \fn QPolygon QPainter::xForm(const QPolygon &polygon, int index, int count) const
+    \overload
+
+    Use combinedTransform() combined with QPolygon::mid() instead.
+
+    \oldcode
+        QPainter painter(this);
+        QPolygon transformed = painter.xForm(polygon, index, count)
+    \newcode
+        QPainter painter(this);
+        QPolygon transformed = polygon.mid(index, count) * painter.combinedTransform();
+    \endcode
+*/
+
+QPolygon QPainter::xForm(const QPolygon &av, int index, int npoints) const
+{
+    int lastPoint = npoints < 0 ? av.size() : index+npoints;
+    QPolygon a(lastPoint-index);
+    memcpy(a.data(), av.data()+index, (lastPoint-index)*sizeof(QPoint));
+    return a * combinedMatrix();
+}
+
+/*!
+    \fn QPoint QPainter::xFormDev(const QPoint &point) const
+    \overload
+    \obsolete
+
+    Use combinedTransform() combined with QTransform::inverted() instead.
+
+    \oldcode
+        QPainter painter(this);
+        QPoint transformed = painter.xFormDev(point);
+    \newcode
+        QPainter painter(this);
+        QPoint transformed = point * painter.combinedTransform().inverted();
+    \endcode
+*/
+
+QPoint QPainter::xFormDev(const QPoint &p) const
+{
+    Q_D(const QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::xFormDev: Painter not active");
+        return QPoint();
+    }
+    if(d->state->matrix.type() == QTransform::TxNone)
+        return p;
+    return p * combinedMatrix().inverted();
+}
+
+/*!
+    \fn QRect QPainter::xFormDev(const QRect &rectangle) const
+    \overload
+    \obsolete
+
+    Use combinedTransform() combined with QTransform::inverted() instead.
+
+    \oldcode
+        QPainter painter(this);
+        QRect transformed = painter.xFormDev(rectangle);
+    \newcode
+        QPainter painter(this);
+        QRegion region = QRegion(rectangle) * painter.combinedTransform().inverted();
+        QRect transformed = region.boundingRect();
+    \endcode
+*/
+
+QRect QPainter::xFormDev(const QRect &r)  const
+{
+    Q_D(const QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::xFormDev: Painter not active");
+        return QRect();
+    }
+    if (d->state->matrix.type() == QTransform::TxNone)
+        return r;
+    return combinedMatrix().inverted().mapRect(r);
+}
+
+/*!
+    \overload
+
+    \fn QPoint QPainter::xFormDev(const QPolygon &polygon) const
+    \obsolete
+
+    Use  combinedTransform() combined with QTransform::inverted() instead.
+
+    \oldcode
+        QPainter painter(this);
+        QPolygon transformed = painter.xFormDev(rectangle);
+    \newcode
+        QPainter painter(this);
+        QPolygon transformed = polygon * painter.combinedTransform().inverted();
+    \endcode
+*/
+
+QPolygon QPainter::xFormDev(const QPolygon &a) const
+{
+    Q_D(const QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::xFormDev: Painter not active");
+        return QPolygon();
+    }
+    if (d->state->matrix.type() == QTransform::TxNone)
+        return a;
+    return a * combinedMatrix().inverted();
+}
+
+/*!
+    \fn QPolygon QPainter::xFormDev(const QPolygon &polygon, int index, int count) const
+    \overload
+    \obsolete
+
+    Use combinedTransform() combined with QPolygon::mid() and QTransform::inverted() instead.
+
+    \oldcode
+        QPainter painter(this);
+        QPolygon transformed = painter.xFormDev(polygon, index, count);
+    \newcode
+        QPainter painter(this);
+        QPolygon transformed = polygon.mid(index, count) * painter.combinedTransform().inverted();
+    \endcode
+*/
+
+QPolygon QPainter::xFormDev(const QPolygon &ad, int index, int npoints) const
+{
+    Q_D(const QPainter);
+    int lastPoint = npoints < 0 ? ad.size() : index+npoints;
+    QPolygon a(lastPoint-index);
+    memcpy(a.data(), ad.data()+index, (lastPoint-index)*sizeof(QPoint));
+    if (d->state->matrix.type() == QTransform::TxNone)
+        return a;
+    return a * combinedMatrix().inverted();
+}
+
+/*!
+    \fn void QPainter::drawCubicBezier(const QPolygon &controlPoints, int index)
+
+    Draws a cubic Bezier curve defined by the \a controlPoints,
+    starting at \a{controlPoints}\e{[index]} (\a index defaults to 0).
+    Points after \a{controlPoints}\e{[index + 3]} are ignored. Nothing
+    happens if there aren't enough control points.
+
+    Use strokePath() instead.
+
+    \oldcode
+             QPainter painter(this);
+             painter.drawCubicBezier(controlPoints, index)
+    \newcode
+             QPainterPath path;
+             path.moveTo(controlPoints.at(index));
+             path.cubicTo(controlPoints.at(index+1),
+                                 controlPoints.at(index+2),
+                                 controlPoints.at(index+3));
+
+             QPainter painter(this);
+             painter.strokePath(path, painter.pen());
+    \endcode
+*/
+void QPainter::drawCubicBezier(const QPolygon &a, int index)
+{
+    Q_D(QPainter);
+
+    if (!d->engine)
+        return;
+
+    if ((int)a.size() - index < 4) {
+        qWarning("QPainter::drawCubicBezier: Cubic Bezier needs 4 control "
+                  "points");
+        return;
+    }
+
+    QPainterPath path;
+    path.moveTo(a.at(index));
+    path.cubicTo(a.at(index+1), a.at(index+2), a.at(index+3));
+    strokePath(path, d->state->pen);
+}
+#endif
+
+struct QPaintDeviceRedirection
+{
+    QPaintDeviceRedirection() : device(0), replacement(0), internalWidgetRedirectionIndex(-1) {}
+    QPaintDeviceRedirection(const QPaintDevice *device, QPaintDevice *replacement,
+                            const QPoint& offset, int internalWidgetRedirectionIndex)
+        : device(device), replacement(replacement), offset(offset),
+          internalWidgetRedirectionIndex(internalWidgetRedirectionIndex) { }
+    const QPaintDevice *device;
+    QPaintDevice *replacement;
+    QPoint offset;
+    int internalWidgetRedirectionIndex;
+    bool operator==(const QPaintDevice *pdev) const { return device == pdev; }
+    Q_DUMMY_COMPARISON_OPERATOR(QPaintDeviceRedirection)
+};
+
+typedef QList<QPaintDeviceRedirection> QPaintDeviceRedirectionList;
+Q_GLOBAL_STATIC(QPaintDeviceRedirectionList, globalRedirections)
+Q_GLOBAL_STATIC(QMutex, globalRedirectionsMutex)
+Q_GLOBAL_STATIC(QAtomicInt, globalRedirectionAtomic)
+
+/*!
+    \threadsafe
+
+    \obsolete
+
+    Please use QWidget::render() instead.
+
+    Redirects all paint commands for the given paint \a device, to the
+    \a replacement device. The optional point \a offset defines an
+    offset within the source device.
+
+    The redirection will not be effective until the begin() function
+    has been called; make sure to call end() for the given \a
+    device's painter (if any) before redirecting. Call
+    restoreRedirected() to restore the previous redirection.
+
+    \warning Making use of redirections in the QPainter API implies
+    that QPainter::begin() and QPaintDevice destructors need to hold
+    a mutex for a short period. This can impact performance. Use of
+    QWidget::render is strongly encouraged.
+
+    \sa redirected(), restoreRedirected()
+*/
+void QPainter::setRedirected(const QPaintDevice *device,
+                             QPaintDevice *replacement,
+                             const QPoint &offset)
+{
+    Q_ASSERT(device != 0);
+
+    bool hadInternalWidgetRedirection = false;
+    if (device->devType() == QInternal::Widget) {
+        const QWidgetPrivate *widgetPrivate = static_cast<const QWidget *>(device)->d_func();
+        // This is the case when the widget is in a paint event.
+        if (widgetPrivate->redirectDev) {
+            // Remove internal redirection and put it back into the global redirection list.
+            QPoint oldOffset;
+            QPaintDevice *oldReplacement = widgetPrivate->redirected(&oldOffset);
+            const_cast<QWidgetPrivate *>(widgetPrivate)->restoreRedirected();
+            setRedirected(device, oldReplacement, oldOffset);
+            hadInternalWidgetRedirection = true;
+        }
+    }
+
+    QPoint roffset;
+    QPaintDevice *rdev = redirected(replacement, &roffset);
+
+    QMutexLocker locker(globalRedirectionsMutex());
+    QPaintDeviceRedirectionList *redirections = globalRedirections();
+    Q_ASSERT(redirections != 0);
+    *redirections += QPaintDeviceRedirection(device, rdev ? rdev : replacement, offset + roffset,
+                                             hadInternalWidgetRedirection ? redirections->size() - 1 : -1);
+    globalRedirectionAtomic()->ref();
+}
+
+/*!
+    \threadsafe
+
+    \obsolete
+
+    Using QWidget::render() obsoletes the use of this function.
+
+    Restores the previous redirection for the given \a device after a
+    call to setRedirected().
+
+    \warning Making use of redirections in the QPainter API implies
+    that QPainter::begin() and QPaintDevice destructors need to hold
+    a mutex for a short period. This can impact performance. Use of
+    QWidget::render is strongly encouraged.
+
+    \sa redirected()
+ */
+void QPainter::restoreRedirected(const QPaintDevice *device)
+{
+    Q_ASSERT(device != 0);
+    QMutexLocker locker(globalRedirectionsMutex());
+    QPaintDeviceRedirectionList *redirections = globalRedirections();
+    Q_ASSERT(redirections != 0);
+    for (int i = redirections->size()-1; i >= 0; --i) {
+        if (redirections->at(i) == device) {
+            globalRedirectionAtomic()->deref();
+            const int internalWidgetRedirectionIndex = redirections->at(i).internalWidgetRedirectionIndex;
+            redirections->removeAt(i);
+            // Restore the internal widget redirection, i.e. remove it from the global
+            // redirection list and put it back into QWidgetPrivate. The index is only set when
+            // someone call QPainter::setRedirected in a widget's paint event and we internally
+            // have a redirection set (typically set in QWidgetPrivate::drawWidget).
+            if (internalWidgetRedirectionIndex >= 0) {
+                Q_ASSERT(internalWidgetRedirectionIndex < redirections->size());
+                const QPaintDeviceRedirection &redirectionDevice = redirections->at(internalWidgetRedirectionIndex);
+                QWidget *widget = static_cast<QWidget *>(const_cast<QPaintDevice *>(device));
+                widget->d_func()->setRedirected(redirectionDevice.replacement, redirectionDevice.offset);
+                redirections->removeAt(internalWidgetRedirectionIndex);
+            }
+            return;
+        }
+    }
+}
+
+/*!
+    \threadsafe
+
+    \obsolete
+
+    Using QWidget::render() obsoletes the use of this function.
+
+    Returns the replacement for given \a device. The optional out
+    parameter \a offset returns the offset within the replaced device.
+
+    \warning Making use of redirections in the QPainter API implies
+    that QPainter::begin() and QPaintDevice destructors need to hold
+    a mutex for a short period. This can impact performance. Use of
+    QWidget::render is strongly encouraged.
+
+    \sa setRedirected(), restoreRedirected()
+*/
+QPaintDevice *QPainter::redirected(const QPaintDevice *device, QPoint *offset)
+{
+    Q_ASSERT(device != 0);
+
+    if (device->devType() == QInternal::Widget) {
+        const QWidgetPrivate *widgetPrivate = static_cast<const QWidget *>(device)->d_func();
+        if (widgetPrivate->redirectDev)
+            return widgetPrivate->redirected(offset);
+    }
+
+    if (!globalRedirectionAtomic() || *globalRedirectionAtomic() == 0)
+        return 0;
+
+    QMutexLocker locker(globalRedirectionsMutex());
+    QPaintDeviceRedirectionList *redirections = globalRedirections();
+    Q_ASSERT(redirections != 0);
+    for (int i = redirections->size()-1; i >= 0; --i)
+        if (redirections->at(i) == device) {
+            if (offset)
+                *offset = redirections->at(i).offset;
+            return redirections->at(i).replacement;
+        }
+    if (offset)
+        *offset = QPoint(0, 0);
+    return 0;
+}
+
+
+void qt_painter_removePaintDevice(QPaintDevice *dev)
+{
+    if (!globalRedirectionAtomic() || *globalRedirectionAtomic() == 0)
+        return;
+
+    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)
+                redirections->removeAt(i);
+            else
+                ++i;
+        }
+    }
+}
+
+void qt_format_text(const QFont &fnt, const QRectF &_r,
+                    int tf, const QString& str, QRectF *brect,
+                    int tabstops, int *ta, int tabarraylen,
+                    QPainter *painter)
+{
+    qt_format_text(fnt, _r,
+                    tf, 0, str, brect,
+                    tabstops, ta, tabarraylen,
+                    painter);
+}
+void qt_format_text(const QFont &fnt, const QRectF &_r,
+                    int tf, const QTextOption *option, const QString& str, QRectF *brect,
+                    int tabstops, int *ta, int tabarraylen,
+                    QPainter *painter)
+{
+
+    Q_ASSERT( !((tf & ~Qt::TextDontPrint)!=0 && option!=0) ); // we either have an option or flags
+
+    if (option) {
+        tf |= option->alignment();
+        if (option->wrapMode() != QTextOption::NoWrap)
+            tf |= Qt::TextWordWrap;
+
+        if (option->flags() & QTextOption::IncludeTrailingSpaces)
+            tf |= Qt::TextIncludeTrailingSpaces;
+
+        if (option->tabStop() >= 0 || !option->tabArray().isEmpty())
+            tf |= Qt::TextExpandTabs;
+    }
+
+    // we need to copy r here to protect against the case (&r == brect).
+    QRectF r(_r);
+
+    bool dontclip  = (tf & Qt::TextDontClip);
+    bool wordwrap  = (tf & Qt::TextWordWrap) || (tf & Qt::TextWrapAnywhere);
+    bool singleline = (tf & Qt::TextSingleLine);
+    bool showmnemonic = (tf & Qt::TextShowMnemonic);
+    bool hidemnmemonic = (tf & Qt::TextHideMnemonic);
+
+    Qt::LayoutDirection layout_direction;
+    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)
+        layout_direction = painter->layoutDirection();
+    else
+        layout_direction = Qt::LeftToRight;
+
+    tf = QStyle::visualAlignment(layout_direction, QFlag(tf));
+
+    bool isRightToLeft = layout_direction == Qt::RightToLeft;
+    bool expandtabs = ((tf & Qt::TextExpandTabs) &&
+                        (((tf & Qt::AlignLeft) && !isRightToLeft) ||
+                          ((tf & Qt::AlignRight) && isRightToLeft)));
+
+    if (!painter)
+        tf |= Qt::TextDontPrint;
+
+    uint maxUnderlines = 0;
+    int numUnderlines = 0;
+    QVarLengthArray<int, 32> underlinePositions(1);
+
+    QFontMetricsF fm(fnt);
+    QString text = str;
+    int offset = 0;
+start_lengthVariant:
+    bool hasMoreLengthVariants = false;
+    // compatible behaviour to the old implementation. Replace
+    // tabs by spaces
+    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')) {
+            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;
+        }
+    }
+
+    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 = length;
+        while (l) {
+            if (*cin == QLatin1Char('&')) {
+                ++cin;
+                --length;
+                --l;
+                if (!l)
+                    break;
+                if (*cin != QLatin1Char('&') && !hidemnmemonic)
+                    underlinePositions[numUnderlines++] = cout - text.data() - old_offset;
+            }
+            *cout = *cin;
+            ++cout;
+            ++cin;
+            --l;
+        }
+    }
+
+    // no need to do extra work for underlines if we don't paint
+    if (tf & Qt::TextDontPrint)
+        numUnderlines = 0;
+
+    underlinePositions[numUnderlines] = -1;
+    qreal height = 0;
+    qreal width = 0;
+
+    QString finalText = text.mid(old_offset, length);
+    QStackTextEngine engine(finalText, fnt);
+    if (option) {
+        engine.option = *option;
+    }
+
+    if (engine.option.tabStop() < 0 && tabstops > 0)
+        engine.option.setTabStop(tabstops);
+
+    if (engine.option.tabs().isEmpty() && ta) {
+        QList<qreal> tabs;
+        for (int i = 0; i < tabarraylen; i++)
+            tabs.append(qreal(ta[i]));
+        engine.option.setTabArray(tabs);
+    }
+
+    engine.option.setTextDirection(layout_direction);
+    if (tf & Qt::AlignJustify)
+        engine.option.setAlignment(Qt::AlignJustify);
+    else
+        engine.option.setAlignment(Qt::AlignLeft); // do not do alignment twice
+
+    if (!option && (tf & Qt::TextWrapAnywhere))
+        engine.option.setWrapMode(QTextOption::WrapAnywhere);
+
+    if (tf & Qt::TextJustificationForced)
+        engine.forceJustification = true;
+    QTextLayout textLayout(&engine);
+    textLayout.setCacheEnabled(true);
+    textLayout.engine()->underlinePositions = underlinePositions.data();
+
+    if (finalText.isEmpty()) {
+        height = fm.height();
+        width = 0;
+        tf |= Qt::TextDontPrint;
+    } else {
+        qreal lineWidth = 0x01000000;
+        if (wordwrap || (tf & Qt::TextJustificationForced))
+            lineWidth = qMax<qreal>(0, r.width());
+        if(!wordwrap)
+            tf |= Qt::TextIncludeTrailingSpaces;
+        textLayout.engine()->ignoreBidi = bool(tf & Qt::TextDontPrint);
+        textLayout.beginLayout();
+
+        qreal leading = fm.leading();
+        height = -leading;
+
+        while (1) {
+            QTextLine l = textLayout.createLine();
+            if (!l.isValid())
+                break;
+
+            l.setLineWidth(lineWidth);
+            height += leading;
+            l.setPosition(QPointF(0., height));
+            height += l.height();
+            width = qMax(width, l.naturalTextWidth());
+            if (!dontclip && !brect && height >= r.height())
+                break;
+        }
+        textLayout.endLayout();
+    }
+
+    qreal yoff = 0;
+    qreal xoff = 0;
+    if (tf & Qt::AlignBottom) {
+        yoff = r.height() - height;
+    } else if (tf & Qt::AlignVCenter) {
+        yoff = (r.height() - height)/2;
+        if (painter) {
+            QTransform::TransformationType type = painter->transform().type();
+            if (type <= QTransform::TxScale) {
+                // do the rounding manually to work around inconsistencies
+                // in the paint engines when drawing on floating point offsets
+                const qreal scale = painter->transform().m22();
+                if (scale != 0)
+                    yoff = -qRound(-yoff * scale) / scale;
+            }
+        }
+    }
+    if (tf & Qt::AlignRight) {
+        xoff = r.width() - width;
+    } else if (tf & Qt::AlignHCenter) {
+        xoff = (r.width() - width)/2;
+        if (painter) {
+            QTransform::TransformationType type = painter->transform().type();
+            if (type <= QTransform::TxScale) {
+                // do the rounding manually to work around inconsistencies
+                // in the paint engines when drawing on floating point offsets
+                const qreal scale = painter->transform().m11();
+                if (scale != 0)
+                    xoff = qRound(xoff * scale) / scale;
+            }
+        }
+    }
+    QRectF bounds = QRectF(r.x() + xoff, r.y() + yoff, width, height);
+
+    if (hasMoreLengthVariants && !(tf & Qt::TextLongestVariant) && !r.contains(bounds)) {
+        offset++;
+        goto start_lengthVariant;
+    }
+    if (brect)
+        *brect = bounds;
+
+    if (!(tf & Qt::TextDontPrint)) {
+        bool restore = false;
+        if (!dontclip && !r.contains(bounds)) {
+            restore = true;
+            painter->save();
+            painter->setClipRect(r, Qt::IntersectClip);
+        }
+
+        for (int i = 0; i < textLayout.lineCount(); i++) {
+            QTextLine line = textLayout.lineAt(i);
+
+            qreal advance = line.horizontalAdvance();
+            xoff = 0;
+            if (tf & Qt::AlignRight) {
+                QTextEngine *eng = textLayout.engine();
+                xoff = r.width() - advance -
+                    eng->leadingSpaceWidth(eng->lines[line.lineNumber()]).toReal();
+            }
+            else if (tf & Qt::AlignHCenter)
+                xoff = (r.width() - advance) / 2;
+
+            line.draw(painter, QPointF(r.x() + xoff, r.y() + yoff));
+        }
+
+        if (restore) {
+            painter->restore();
+        }
+    }
+}
+
+/*!
+    Sets the layout direction used by the painter when drawing text,
+    to the specified \a direction.
+
+    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)
+{
+    Q_D(QPainter);
+    if (d->state)
+        d->state->layoutDirection = direction;
+}
+
+/*!
+    Returns the layout direction used by the painter when drawing text.
+
+    \sa QTextOption::textDirection(), setLayoutDirection(), drawText(), {QPainter#Settings}{Settings}
+*/
+Qt::LayoutDirection QPainter::layoutDirection() const
+{
+    Q_D(const QPainter);
+    return d->state ? d->state->layoutDirection : Qt::LayoutDirectionAuto;
+}
+
+QPainterState::QPainterState(const QPainterState *s)
+    : brushOrigin(s->brushOrigin), font(s->font), deviceFont(s->deviceFont),
+      pen(s->pen), brush(s->brush), bgBrush(s->bgBrush),
+      clipRegion(s->clipRegion), clipPath(s->clipPath),
+      clipOperation(s->clipOperation),
+      renderHints(s->renderHints), clipInfo(s->clipInfo),
+      worldMatrix(s->worldMatrix), matrix(s->matrix), redirectionMatrix(s->redirectionMatrix),
+      wx(s->wx), wy(s->wy), ww(s->ww), wh(s->wh),
+      vx(s->vx), vy(s->vy), vw(s->vw), vh(s->vh),
+      opacity(s->opacity), WxF(s->WxF), VxF(s->VxF),
+      clipEnabled(s->clipEnabled), bgMode(s->bgMode), painter(s->painter),
+      layoutDirection(s->layoutDirection),
+      composition_mode(s->composition_mode),
+      emulationSpecifier(s->emulationSpecifier), changeFlags(0)
+{
+    dirtyFlags = s->dirtyFlags;
+}
+
+QPainterState::QPainterState()
+    : brushOrigin(0, 0), bgBrush(Qt::white), clipOperation(Qt::NoClip),
+      renderHints(0),
+      wx(0), wy(0), ww(0), wh(0), vx(0), vy(0), vw(0), vh(0),
+      opacity(1), WxF(false), VxF(false), clipEnabled(true),
+      bgMode(Qt::TransparentMode), painter(0),
+      layoutDirection(QApplication::layoutDirection()),
+      composition_mode(QPainter::CompositionMode_SourceOver),
+      emulationSpecifier(0), changeFlags(0)
+{
+    dirtyFlags = 0;
+}
+
+QPainterState::~QPainterState()
+{
+}
+
+void QPainterState::init(QPainter *p) {
+    bgBrush = Qt::white;
+    bgMode = Qt::TransparentMode;
+    WxF = false;
+    VxF = false;
+    clipEnabled = true;
+    wx = wy = ww = wh = 0;
+    vx = vy = vw = vh = 0;
+    painter = p;
+    pen = QPen();
+    brushOrigin = QPointF(0, 0);
+    brush = QBrush();
+    font = deviceFont = QFont();
+    clipRegion = QRegion();
+    clipPath = QPainterPath();
+    clipOperation = Qt::NoClip;
+    clipInfo.clear();
+    worldMatrix.reset();
+    matrix.reset();
+    layoutDirection = QApplication::layoutDirection();
+    composition_mode = QPainter::CompositionMode_SourceOver;
+    emulationSpecifier = 0;
+    dirtyFlags = 0;
+    changeFlags = 0;
+    renderHints = 0;
+    opacity = 1;
+}
+
+#ifdef QT3_SUPPORT
+static void bitBlt_helper(QPaintDevice *dst, const QPoint &dp,
+                          const QPaintDevice *src, const QRect &sr, bool)
+{
+    Q_ASSERT(dst);
+    Q_ASSERT(src);
+
+    if (src->devType() == QInternal::Pixmap) {
+        const QPixmap *pixmap = static_cast<const QPixmap *>(src);
+        QPainter pt(dst);
+        pt.drawPixmap(dp, *pixmap, sr);
+
+    } else {
+        qWarning("QPainter: bitBlt only works when source is of type pixmap");
+    }
+}
+
+void bitBlt(QPaintDevice *dst, int dx, int dy,
+             const QPaintDevice *src, int sx, int sy, int sw, int sh,
+             bool ignoreMask )
+{
+    bitBlt_helper(dst, QPoint(dx, dy), src, QRect(sx, sy, sw, sh), ignoreMask);
+}
+
+void bitBlt(QPaintDevice *dst, const QPoint &dp, const QPaintDevice *src, const QRect &sr, bool ignoreMask)
+{
+    bitBlt_helper(dst, dp, src, sr, ignoreMask);
+}
+
+void bitBlt(QPaintDevice *dst, int dx, int dy,
+            const QImage *src, int sx, int sy, int sw, int sh, int fl)
+{
+    Qt::ImageConversionFlags flags(fl);
+    QPixmap srcPixmap = QPixmap::fromImage(*src, flags);
+    bitBlt_helper(dst, QPoint(dx, dy), &srcPixmap, QRect(sx, sy, sw, sh), false);
+}
+
+#endif // QT3_SUPPORT
+
+/*!
+    \fn void QPainter::setBackgroundColor(const QColor &color)
+
+    Use setBackground() instead.
+*/
+
+/*!
+    \fn const QColor &QPainter::backgroundColor() const
+
+    Use background() and QBrush::color() instead.
+
+    \oldcode
+        QColor myColor = backgroundColor();
+    \newcode
+        QColor myColor = background().color();
+    \endcode
+
+    Note that the background can be a complex brush such as a texture
+    or a gradient.
+*/
+
+/*!
+    \fn void QPainter::drawText(int x, int y, const QString &text, int pos, int length)
+    \compat
+
+    Use drawText() combined with QString::mid() instead.
+
+    \oldcode
+        QPainter painter(this);
+        painter.drawText(x, y, text, pos, length);
+    \newcode
+        QPainter painter(this);
+        painter.drawText(x, y, text.mid(pos, length));
+    \endcode
+*/
+
+/*!
+    \fn void QPainter::drawText(const QPoint &point, const QString &text, int pos, int length)
+    \compat
+
+    Use drawText() combined with QString::mid() instead.
+
+    \oldcode
+        QPainter painter(this);
+        painter.drawText(point, text, pos, length);
+    \newcode
+        QPainter painter(this);
+        painter.drawText(point, text.mid(pos, length));
+    \endcode
+*/
+
+/*!
+    \fn void QPainter::drawText(int x, int y, const QString &text, int length)
+    \compat
+
+    Use drawText() combined with QString::left() instead.
+
+    \oldcode
+        QPainter painter(this);
+        painter.drawText(x, y, text, length);
+    \newcode
+        QPainter painter(this);
+        painter.drawText(x, y, text.left(length));
+    \endcode
+*/
+
+/*!
+    \fn void QPainter::drawText(const QPoint &point, const QString &text, int length)
+    \compat
+
+    Use drawText() combined with QString::left() instead.
+
+    \oldcode
+        QPainter painter(this);
+        painter.drawText(point, text, length);
+    \newcode
+        QPainter painter(this);
+        painter.drawText(point, text.left(length));
+    \endcode
+*/
+
+/*!
+    \fn bool QPainter::begin(QPaintDevice *device, const QWidget *init)
+    \compat
+
+    Use begin() instead.
+
+    If the paint \a device is a QWidget, QPainter is initialized after
+    the widget's settings automatically. Otherwise, you must call the
+    initFrom() function to initialize the painters pen, background and
+    font to the same as any given widget.
+
+    \oldcode
+        QPainter painter(this);
+        painter.begin(device, init);
+    \newcode
+        QPainter painter(this);
+        painter.begin(device);
+        painter.initFrom(init);
+    \endcode
+*/
+
+/*!
+    \fn void QPainter::drawImage(const QRectF &target, const QImage &image, const QRectF &source,
+                         Qt::ImageConversionFlags flags)
+
+    Draws the rectangular portion \a source of the given \a image
+    into the \a target rectangle in the paint device.
+
+    \note The image is scaled to fit the rectangle, if both the image and rectangle size disagree.
+
+    If the image needs to be modified to fit in a lower-resolution
+    result (e.g. converting from 32-bit to 8-bit), use the \a flags to
+    specify how you would prefer this to happen.
+
+    \table 100%
+    \row
+    \o
+    \snippet doc/src/snippets/code/src_gui_painting_qpainter.cpp 20
+    \endtable
+
+    \sa drawPixmap()
+*/
+
+/*!
+    \fn void QPainter::drawImage(const QRect &target, const QImage &image, const QRect &source,
+                                 Qt::ImageConversionFlags flags)
+    \overload
+
+    Draws the rectangular portion \a source of the given \a image
+    into the \a target rectangle in the paint device.
+
+    \note The image is scaled to fit the rectangle, if both the image and rectangle size disagree.
+*/
+
+/*!
+    \fn void QPainter::drawImage(const QPointF &point, const QImage &image)
+
+    \overload
+
+    Draws the given \a image at the given \a point.
+*/
+
+/*!
+    \fn void QPainter::drawImage(const QPoint &point, const QImage &image)
+
+    \overload
+
+    Draws the given \a image at the given \a point.
+*/
+
+/*!
+    \fn void QPainter::drawImage(const QPointF &point, const QImage &image, const QRectF &source,
+                                 Qt::ImageConversionFlags flags = 0)
+
+    \overload
+
+    Draws the rectangular portion \a source of the given \a image with
+    its origin at the given \a point.
+*/
+
+/*!
+    \fn void QPainter::drawImage(const QPoint &point, const QImage &image, const QRect &source,
+                                 Qt::ImageConversionFlags flags = 0)
+    \overload
+
+    Draws the rectangular portion \a source of the given \a image with
+    its origin at the given \a point.
+*/
+
+/*!
+    \fn void QPainter::drawImage(const QRectF &rectangle, const QImage &image)
+
+    \overload
+
+    Draws the given \a image into the given \a rectangle.
+
+    \note The image is scaled to fit the rectangle, if both the image and rectangle size disagree.
+*/
+
+/*!
+    \fn void QPainter::drawImage(const QRect &rectangle, const QImage &image)
+
+    \overload
+
+    Draws the given \a image into the given \a rectangle.
+
+   \note The image is scaled to fit the rectangle, if both the image and rectangle size disagree.
+*/
+
+/*!
+    \fn void QPainter::drawImage(int x, int y, const QImage &image,
+                                 int sx, int sy, int sw, int sh,
+                                 Qt::ImageConversionFlags flags)
+    \overload
+
+    Draws an image at (\a{x}, \a{y}) by copying a part of \a image into
+    the paint device.
+
+    (\a{x}, \a{y}) specifies the top-left point in the paint device that is
+    to be drawn onto. (\a{sx}, \a{sy}) specifies the top-left point in \a
+    image that is to be drawn. The default is (0, 0).
+
+    (\a{sw}, \a{sh}) specifies the size of the image that is to be drawn.
+    The default, (0, 0) (and negative) means all the way to the
+    bottom-right of the image.
+*/
+
+/*!
+    \fn void QPainter::redirect(QPaintDevice *pdev, QPaintDevice *replacement)
+
+    Use setRedirected() instead.
+*/
+
+/*!
+    \fn QPaintDevice *QPainter::redirect(QPaintDevice *pdev)
+
+    Use redirected() instead.
+*/
+
+/*!
+    \fn QRect QPainter::boundingRect(const QRect &rectangle, int flags,
+                                     const QString &text, int length)
+    \compat
+
+    Returns the bounding rectangle for the given \a length of the \a
+    text constrained by the provided \a rectangle.
+
+    Use boundingRect() combined with QString::left() instead.
+
+    \oldcode
+        QRect rectangle = boundingRect(rect, flags, text, length);
+    \newcode
+        QRect rectangle = boundingRect(rect, flags, text.left(length));
+    \endcode
+*/
+
+/*!
+    \fn void QPainter::drawText(const QRect &rectangle, int flags, const QString &text,
+                                int length, QRect *br)
+    \compat
+
+    Use drawText() combined with QString::left() instead.
+
+    \oldcode
+        QPainter painter(this);
+        painter.drawText(rectangle, flags, text, length, br );
+    \newcode
+        QPainter painter(this);
+        painter.drawText(rectangle, flags, text.left(length), br );
+    \endcode
+*/
+
+/*!
+    \fn QRect QPainter::boundingRect(int x, int y, int width, int height, int flags,
+                                     const QString &text, int length);
+
+    \compat
+
+    Returns the bounding rectangle for the given \a length of the \a
+    text constrained by the rectangle that begins at point (\a{x},
+    \a{y}) with the given \a width and \a height.
+
+    Use boundingRect() combined with QString::left() instead.
+
+    \oldcode
+        QRect rectangle = boundingRect(x, y, width, height, flags, text, length);
+    \newcode
+        QRect rectangle = boundingRect(x, y, width, height, flags, text.left(length));
+    \endcode
+*/
+
+/*!
+    \fn void QPainter::drawText(int x, int y, int width, int height, int flags,
+                                const QString &text, int length, QRect *br)
+
+    \compat
+
+    Use drawText() combined with QString::left() instead.
+
+    \oldcode
+        QPainter painter(this);
+        painter.drawText(x, y, width, height, flags, text, length, br );
+    \newcode
+        QPainter painter(this);
+        painter.drawText(x, y, width, height, flags, text.left(length), br );
+    \endcode
+*/
+
+
+/*!
+    \class QPaintEngineState
+    \since 4.1
+
+    \brief The QPaintEngineState class provides information about the
+    active paint engine's current state.
+    \reentrant
+
+    QPaintEngineState records which properties that have changed since
+    the last time the paint engine was updated, as well as their
+    current value.
+
+    Which properties that have changed can at any time be retrieved
+    using the state() function. This function returns an instance of
+    the QPaintEngine::DirtyFlags type which stores an OR combination
+    of QPaintEngine::DirtyFlag values. The QPaintEngine::DirtyFlag
+    enum defines whether a property has changed since the last update
+    or not.
+
+    If a property is marked with a dirty flag, its current value can
+    be retrieved using the corresponding get function:
+
+    \target GetFunction
+
+    \table
+    \header \o Property Flag \o Current Property Value
+    \row \o QPaintEngine::DirtyBackground \o backgroundBrush()
+    \row \o QPaintEngine::DirtyBackgroundMode \o backgroundMode()
+    \row \o QPaintEngine::DirtyBrush \o brush()
+    \row \o QPaintEngine::DirtyBrushOrigin \o brushOrigin()
+    \row \o QPaintEngine::DirtyClipRegion \e or QPaintEngine::DirtyClipPath
+         \o clipOperation()
+    \row \o QPaintEngine::DirtyClipPath \o clipPath()
+    \row \o QPaintEngine::DirtyClipRegion \o clipRegion()
+    \row \o QPaintEngine::DirtyCompositionMode \o compositionMode()
+    \row \o QPaintEngine::DirtyFont \o font()
+    \row \o QPaintEngine::DirtyTransform \o transform()
+    \row \o QPaintEngine::DirtyClipEnabled \o isClipEnabled()
+    \row \o QPaintEngine::DirtyPen \o pen()
+    \row \o QPaintEngine::DirtyHints \o renderHints()
+    \endtable
+
+    The QPaintEngineState class also provide the painter() function
+    which returns a pointer to the painter that is currently updating
+    the paint engine.
+
+    An instance of this class, representing the current state of the
+    active paint engine, is passed as argument to the
+    QPaintEngine::updateState() function. The only situation in which
+    you will have to use this class directly is when implementing your
+    own paint engine.
+
+    \sa QPaintEngine
+*/
+
+
+/*!
+    \fn QPaintEngine::DirtyFlags QPaintEngineState::state() const
+
+    Returns a combination of flags identifying the set of properties
+    that need to be updated when updating the paint engine's state
+    (i.e. during a call to the QPaintEngine::updateState() function).
+
+    \sa QPaintEngine::updateState()
+*/
+
+
+/*!
+    Returns the pen in the current paint engine state.
+
+    This variable should only be used when the state() returns a
+    combination which includes the QPaintEngine::DirtyPen flag.
+
+    \sa state(), QPaintEngine::updateState()
+*/
+
+QPen QPaintEngineState::pen() const
+{
+    return static_cast<const QPainterState *>(this)->pen;
+}
+
+/*!
+    Returns the brush in the current paint engine state.
+
+    This variable should only be used when the state() returns a
+    combination which includes the QPaintEngine::DirtyBrush flag.
+
+    \sa state(), QPaintEngine::updateState()
+*/
+
+QBrush QPaintEngineState::brush() const
+{
+    return static_cast<const QPainterState *>(this)->brush;
+}
+
+/*!
+    Returns the brush origin in the current paint engine state.
+
+    This variable should only be used when the state() returns a
+    combination which includes the QPaintEngine::DirtyBrushOrigin flag.
+
+    \sa state(), QPaintEngine::updateState()
+*/
+
+QPointF QPaintEngineState::brushOrigin() const
+{
+    return static_cast<const QPainterState *>(this)->brushOrigin;
+}
+
+/*!
+    Returns the background brush in the current paint engine state.
+
+    This variable should only be used when the state() returns a
+    combination which includes the QPaintEngine::DirtyBackground flag.
+
+    \sa state(), QPaintEngine::updateState()
+*/
+
+QBrush QPaintEngineState::backgroundBrush() const
+{
+    return static_cast<const QPainterState *>(this)->bgBrush;
+}
+
+/*!
+    Returns the background mode in the current paint engine
+    state.
+
+    This variable should only be used when the state() returns a
+    combination which includes the QPaintEngine::DirtyBackgroundMode flag.
+
+    \sa state(), QPaintEngine::updateState()
+*/
+
+Qt::BGMode QPaintEngineState::backgroundMode() const
+{
+    return static_cast<const QPainterState *>(this)->bgMode;
+}
+
+/*!
+    Returns the font in the current paint engine
+    state.
+
+    This variable should only be used when the state() returns a
+    combination which includes the QPaintEngine::DirtyFont flag.
+
+    \sa state(), QPaintEngine::updateState()
+*/
+
+QFont QPaintEngineState::font() const
+{
+    return static_cast<const QPainterState *>(this)->font;
+}
+
+/*!
+    \since 4.2
+    \obsolete
+
+    Returns the matrix in the current paint engine
+    state.
+
+    \note It is advisable to use transform() instead of this function to
+    preserve the properties of perspective transformations.
+
+    This variable should only be used when the state() returns a
+    combination which includes the QPaintEngine::DirtyTransform flag.
+
+    \sa state(), QPaintEngine::updateState()
+*/
+
+QMatrix QPaintEngineState::matrix() const
+{
+    const QPainterState *st = static_cast<const QPainterState *>(this);
+
+    return st->matrix.toAffine();
+}
+
+/*!
+    \since 4.3
+
+    Returns the matrix in the current paint engine state.
+
+    This variable should only be used when the state() returns a
+    combination which includes the QPaintEngine::DirtyTransform flag.
+
+    \sa state(), QPaintEngine::updateState()
+*/
+
+
+QTransform QPaintEngineState::transform() const
+{
+    const QPainterState *st = static_cast<const QPainterState *>(this);
+
+    return st->matrix;
+}
+
+
+/*!
+    Returns the clip operation in the current paint engine
+    state.
+
+    This variable should only be used when the state() returns a
+    combination which includes either the QPaintEngine::DirtyClipPath
+    or the QPaintEngine::DirtyClipRegion flag.
+
+    \sa state(), QPaintEngine::updateState()
+*/
+
+Qt::ClipOperation QPaintEngineState::clipOperation() const
+{
+    return static_cast<const QPainterState *>(this)->clipOperation;
+}
+
+/*!
+    \since 4.3
+
+    Returns whether the coordinate of the fill have been specified
+    as bounded by the current rendering operation and have to be
+    resolved (about the currently rendered primitive).
+*/
+bool QPaintEngineState::brushNeedsResolving() const
+{
+    const QBrush &brush = static_cast<const QPainterState *>(this)->brush;
+    return needsResolving(brush);
+}
+
+
+/*!
+    \since 4.3
+
+    Returns whether the coordinate of the stroke have been specified
+    as bounded by the current rendering operation and have to be
+    resolved (about the currently rendered primitive).
+*/
+bool QPaintEngineState::penNeedsResolving() const
+{
+    const QPen &pen = static_cast<const QPainterState *>(this)->pen;
+    return needsResolving(pen.brush());
+}
+
+/*!
+    Returns the clip region in the current paint engine state.
+
+    This variable should only be used when the state() returns a
+    combination which includes the QPaintEngine::DirtyClipRegion flag.
+
+    \sa state(), QPaintEngine::updateState()
+*/
+
+QRegion QPaintEngineState::clipRegion() const
+{
+    return static_cast<const QPainterState *>(this)->clipRegion;
+}
+
+/*!
+    Returns the clip path in the current paint engine state.
+
+    This variable should only be used when the state() returns a
+    combination which includes the QPaintEngine::DirtyClipPath flag.
+
+    \sa state(), QPaintEngine::updateState()
+*/
+
+QPainterPath QPaintEngineState::clipPath() const
+{
+    return static_cast<const QPainterState *>(this)->clipPath;
+}
+
+/*!
+    Returns whether clipping is enabled or not in the current paint
+    engine state.
+
+    This variable should only be used when the state() returns a
+    combination which includes the QPaintEngine::DirtyClipEnabled
+    flag.
+
+    \sa state(), QPaintEngine::updateState()
+*/
+
+bool QPaintEngineState::isClipEnabled() const
+{
+    return static_cast<const QPainterState *>(this)->clipEnabled;
+}
+
+/*!
+    Returns the render hints in the current paint engine state.
+
+    This variable should only be used when the state() returns a
+    combination which includes the QPaintEngine::DirtyHints
+    flag.
+
+    \sa state(), QPaintEngine::updateState()
+*/
+
+QPainter::RenderHints QPaintEngineState::renderHints() const
+{
+    return static_cast<const QPainterState *>(this)->renderHints;
+}
+
+/*!
+    Returns the composition mode in the current paint engine state.
+
+    This variable should only be used when the state() returns a
+    combination which includes the QPaintEngine::DirtyCompositionMode
+    flag.
+
+    \sa state(), QPaintEngine::updateState()
+*/
+
+QPainter::CompositionMode QPaintEngineState::compositionMode() const
+{
+    return static_cast<const QPainterState *>(this)->composition_mode;
+}
+
+
+/*!
+    Returns a pointer to the painter currently updating the paint
+    engine.
+*/
+
+QPainter *QPaintEngineState::painter() const
+{
+    return static_cast<const QPainterState *>(this)->painter;
+}
+
+
+/*!
+    \since 4.2
+
+    Returns the opacity in the current paint engine state.
+*/
+
+qreal QPaintEngineState::opacity() const
+{
+    return static_cast<const QPainterState *>(this)->opacity;
+}
+
+/*!
+    \since 4.3
+
+    Sets the world transformation matrix.
+    If \a combine is true, the specified \a transform is combined with
+    the current matrix; otherwise it replaces the current matrix.
+
+    \sa transform() setWorldTransform()
+*/
+
+void QPainter::setTransform(const QTransform &transform, bool combine )
+{
+    setWorldTransform(transform, combine);
+}
+
+/*!
+    Returns the world transformation matrix.
+
+    \sa worldTransform()
+*/
+
+const QTransform & QPainter::transform() const
+{
+    return worldTransform();
+}
+
+
+/*!
+    Returns the matrix that transforms from logical coordinates to
+    device coordinates of the platform dependent paint device.
+
+    This function is \e only needed when using platform painting
+    commands on the platform dependent handle (Qt::HANDLE), and the
+    platform does not do transformations nativly.
+
+    The QPaintEngine::PaintEngineFeature enum can be queried to
+    determine whether the platform performs the transformations or
+    not.
+
+    \sa worldTransform(), QPaintEngine::hasFeature(),
+*/
+
+const QTransform & QPainter::deviceTransform() const
+{
+    Q_D(const QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::deviceTransform: Painter not active");
+        return d->fakeState()->transform;
+    }
+    return d->state->matrix;
+}
+
+
+/*!
+    Resets any transformations that were made using translate(),
+    scale(), shear(), rotate(), setWorldTransform(), setViewport()
+    and setWindow().
+
+    \sa {Coordinate Transformations}
+*/
+
+void QPainter::resetTransform()
+{
+     Q_D(QPainter);
+#ifdef QT_DEBUG_DRAW
+    if (qt_show_painter_debug_output)
+        printf("QPainter::resetMatrix()\n");
+#endif
+    if (!d->engine) {
+        qWarning("QPainter::resetMatrix: Painter not active");
+        return;
+    }
+
+    d->state->wx = d->state->wy = d->state->vx = d->state->vy = 0;                        // default view origins
+    d->state->ww = d->state->vw = d->device->metric(QPaintDevice::PdmWidth);
+    d->state->wh = d->state->vh = d->device->metric(QPaintDevice::PdmHeight);
+    d->state->worldMatrix = QTransform();
+    setMatrixEnabled(false);
+    setViewTransformEnabled(false);
+    if (d->extended)
+        d->extended->transformChanged();
+    else
+        d->state->dirtyFlags |= QPaintEngine::DirtyTransform;
+}
+
+/*!
+    Sets the world transformation matrix.
+    If \a combine is true, the specified \a matrix is combined with the current matrix;
+    otherwise it replaces the current matrix.
+
+    \sa transform(), setTransform()
+*/
+
+void QPainter::setWorldTransform(const QTransform &matrix, bool combine )
+{
+    Q_D(QPainter);
+
+    if (!d->engine) {
+        qWarning("QPainter::setWorldTransform: Painter not active");
+        return;
+    }
+
+    if (combine)
+        d->state->worldMatrix = matrix * d->state->worldMatrix;                        // combines
+    else
+        d->state->worldMatrix = matrix;                                // set new matrix
+
+    d->state->WxF = true;
+    d->updateMatrix();
+}
+
+/*!
+    Returns the world transformation matrix.
+*/
+
+const QTransform & QPainter::worldTransform() const
+{
+    Q_D(const QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::worldTransform: Painter not active");
+        return d->fakeState()->transform;
+    }
+    return d->state->worldMatrix;
+}
+
+/*!
+    Returns the transformation matrix combining the current
+    window/viewport and world transformation.
+
+    \sa setWorldTransform(), setWindow(), setViewport()
+*/
+
+QTransform QPainter::combinedTransform() const
+{
+    Q_D(const QPainter);
+    if (!d->engine) {
+        qWarning("QPainter::combinedTransform: Painter not active");
+        return QTransform();
+    }
+    return d->state->worldMatrix * d->viewTransform();
+}
+
+/*!
+    \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)
+{
+    p->draw_helper(path, operation);
+}
+
+/*! \fn Display *QPaintDevice::x11Display() const
+    Use QX11Info::display() instead.
+
+    \oldcode
+        Display *display = widget->x11Display();
+    \newcode
+        Display *display = QX11Info::display();
+    \endcode
+
+    \sa QWidget::x11Info(), QX11Info::display()
+*/
+
+/*! \fn int QPaintDevice::x11Screen() const
+    Use QX11Info::screen() instead.
+
+    \oldcode
+        int screen = widget->x11Screen();
+    \newcode
+        int screen = widget->x11Info().screen();
+    \endcode
+
+    \sa QWidget::x11Info(), QPixmap::x11Info()
+*/
+
+/*! \fn void *QPaintDevice::x11Visual() const
+    Use QX11Info::visual() instead.
+
+    \oldcode
+        void *visual = widget->x11Visual();
+    \newcode
+        void *visual = widget->x11Info().visual();
+    \endcode
+
+    \sa QWidget::x11Info(), QPixmap::x11Info()
+*/
+
+/*! \fn int QPaintDevice::x11Depth() const
+    Use QX11Info::depth() instead.
+
+    \oldcode
+        int depth = widget->x11Depth();
+    \newcode
+        int depth = widget->x11Info().depth();
+    \endcode
+
+    \sa QWidget::x11Info(), QPixmap::x11Info()
+*/
+
+/*! \fn int QPaintDevice::x11Cells() const
+    Use QX11Info::cells() instead.
+
+    \oldcode
+        int cells = widget->x11Cells();
+    \newcode
+        int cells = widget->x11Info().cells();
+    \endcode
+
+    \sa QWidget::x11Info(), QPixmap::x11Info()
+*/
+
+/*! \fn Qt::HANDLE QPaintDevice::x11Colormap() const
+    Use QX11Info::colormap() instead.
+
+    \oldcode
+        unsigned long screen = widget->x11Colormap();
+    \newcode
+        unsigned long screen = widget->x11Info().colormap();
+    \endcode
+
+    \sa QWidget::x11Info(), QPixmap::x11Info()
+*/
+
+/*! \fn bool QPaintDevice::x11DefaultColormap() const
+    Use QX11Info::defaultColormap() instead.
+
+    \oldcode
+        bool isDefault = widget->x11DefaultColormap();
+    \newcode
+        bool isDefault = widget->x11Info().defaultColormap();
+    \endcode
+
+    \sa QWidget::x11Info(), QPixmap::x11Info()
+*/
+
+/*! \fn bool QPaintDevice::x11DefaultVisual() const
+    Use QX11Info::defaultVisual() instead.
+
+    \oldcode
+        bool isDefault = widget->x11DefaultVisual();
+    \newcode
+        bool isDefault = widget->x11Info().defaultVisual();
+    \endcode
+
+    \sa QWidget::x11Info(), QPixmap::x11Info()
+*/
+
+/*! \fn void *QPaintDevice::x11AppVisual(int screen)
+    Use QX11Info::visual() instead.
+
+    \oldcode
+        void *visual = QPaintDevice::x11AppVisual(screen);
+    \newcode
+        void *visual = qApp->x11Info(screen).visual();
+    \endcode
+
+    \sa QWidget::x11Info(), QPixmap::x11Info()
+*/
+
+/*! \fn Qt::HANDLE QPaintDevice::x11AppColormap(int screen)
+    Use QX11Info::colormap() instead.
+
+    \oldcode
+        unsigned long colormap = QPaintDevice::x11AppColormap(screen);
+    \newcode
+        unsigned long colormap = qApp->x11Info(screen).colormap();
+    \endcode
+
+    \sa QWidget::x11Info(), QPixmap::x11Info()
+*/
+
+/*! \fn Display *QPaintDevice::x11AppDisplay()
+    Use QX11Info::display() instead.
+
+    \oldcode
+        Display *display = QPaintDevice::x11AppDisplay();
+    \newcode
+        Display *display = qApp->x11Info().display();
+    \endcode
+
+    \sa QWidget::x11Info(), QPixmap::x11Info()
+*/
+
+/*! \fn int QPaintDevice::x11AppScreen()
+    Use QX11Info::screen() instead.
+
+    \oldcode
+        int screen = QPaintDevice::x11AppScreen();
+    \newcode
+        int screen = qApp->x11Info().screen();
+    \endcode
+
+    \sa QWidget::x11Info(), QPixmap::x11Info()
+*/
+
+/*! \fn int QPaintDevice::x11AppDepth(int screen)
+    Use QX11Info::depth() instead.
+
+    \oldcode
+        int depth = QPaintDevice::x11AppDepth(screen);
+    \newcode
+        int depth = qApp->x11Info(screen).depth();
+    \endcode
+
+    \sa QWidget::x11Info(), QPixmap::x11Info()
+*/
+
+/*! \fn int QPaintDevice::x11AppCells(int screen)
+    Use QX11Info::cells() instead.
+
+    \oldcode
+        int cells = QPaintDevice::x11AppCells(screen);
+    \newcode
+        int cells = qApp->x11Info(screen).cells();
+    \endcode
+
+    \sa QWidget::x11Info(), QPixmap::x11Info()
+*/
+
+/*! \fn Qt::HANDLE QPaintDevice::x11AppRootWindow(int screen)
+    Use QX11Info::appRootWindow() instead.
+
+    \oldcode
+        unsigned long window = QPaintDevice::x11AppRootWindow(screen);
+    \newcode
+        unsigned long window = qApp->x11Info(screen).appRootWindow();
+    \endcode
+
+    \sa QWidget::x11Info(), QPixmap::x11Info()
+*/
+
+/*! \fn bool QPaintDevice::x11AppDefaultColormap(int screen)
+    Use QX11Info::defaultColormap() instead.
+
+    \oldcode
+        bool isDefault = QPaintDevice::x11AppDefaultColormap(screen);
+    \newcode
+        bool isDefault = qApp->x11Info(screen).defaultColormap();
+    \endcode
+
+    \sa QWidget::x11Info(), QPixmap::x11Info()
+*/
+
+/*! \fn bool QPaintDevice::x11AppDefaultVisual(int screen)
+    Use QX11Info::defaultVisual() instead.
+
+    \oldcode
+        bool isDefault = QPaintDevice::x11AppDefaultVisual(screen);
+    \newcode
+        bool isDefault = qApp->x11Info(screen).defaultVisual();
+    \endcode
+
+    \sa QWidget::x11Info(), QPixmap::x11Info()
+*/
+
+/*! \fn void QPaintDevice::x11SetAppDpiX(int dpi, int screen)
+    Use QX11Info::setAppDpiX() instead.
+*/
+
+/*! \fn void QPaintDevice::x11SetAppDpiY(int dpi, int screen)
+    Use QX11Info::setAppDpiY() instead.
+*/
+
+/*! \fn int QPaintDevice::x11AppDpiX(int screen)
+    Use QX11Info::appDpiX() instead.
+
+    \oldcode
+        bool isDefault = QPaintDevice::x11AppDpiX(screen);
+    \newcode
+        bool isDefault = qApp->x11Info(screen).appDpiX();
+    \endcode
+
+    \sa QWidget::x11Info(), QPixmap::x11Info()
+*/
+
+/*! \fn int QPaintDevice::x11AppDpiY(int screen)
+    Use QX11Info::appDpiY() instead.
+
+    \oldcode
+        bool isDefault = QPaintDevice::x11AppDpiY(screen);
+    \newcode
+        bool isDefault = qApp->x11Info(screen).appDpiY();
+    \endcode
+
+    \sa QWidget::x11Info(), QPixmap::x11Info()
+*/
+
+/*! \fn HDC QPaintDevice::getDC() const
+  \internal
+*/
+
+/*! \fn void QPaintDevice::releaseDC(HDC) const
+  \internal
+*/
+
+/*! \fn QWSDisplay *QPaintDevice::qwsDisplay()
+    \internal
+*/
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qpainter.h b/src/gui/painting/qpainter.h
new file mode 100644
index 0000000000..4b2c447cca
--- /dev/null
+++ b/src/gui/painting/qpainter.h
@@ -0,0 +1,1008 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPAINTER_H
+#define QPAINTER_H
+
+#include <QtCore/qnamespace.h>
+#include <QtCore/qrect.h>
+#include <QtCore/qpoint.h>
+#include <QtCore/qscopedpointer.h>
+#include <QtGui/qpixmap.h>
+#include <QtGui/qimage.h>
+#include <QtGui/qtextoption.h>
+#include <QtGui/qdrawutil.h>
+
+#ifndef QT_INCLUDE_COMPAT
+#include <QtGui/qpolygon.h>
+#include <QtGui/qpen.h>
+#include <QtGui/qbrush.h>
+#include <QtGui/qmatrix.h>
+#include <QtGui/qtransform.h>
+#include <QtGui/qfontinfo.h>
+#include <QtGui/qfontmetrics.h>
+#endif
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+class QBrush;
+class QFontInfo;
+class QFontMetrics;
+class QPaintDevice;
+class QPainterPath;
+class QPainterPrivate;
+class QPen;
+class QPolygon;
+class QTextItem;
+class QMatrix;
+class QTransform;
+class QStaticText;
+class QGlyphs;
+
+class QPainterPrivateDeleter;
+
+class Q_GUI_EXPORT QPainter
+{
+    Q_DECLARE_PRIVATE(QPainter)
+    Q_GADGET
+    Q_FLAGS(RenderHint RenderHints)
+
+public:
+    enum RenderHint {
+        Antialiasing = 0x01,
+        TextAntialiasing = 0x02,
+        SmoothPixmapTransform = 0x04,
+        HighQualityAntialiasing = 0x08,
+        NonCosmeticDefaultPen = 0x10
+    };
+
+    Q_DECLARE_FLAGS(RenderHints, RenderHint)
+
+    class PixmapFragment {
+    public:
+        qreal x;
+        qreal y;
+        qreal sourceLeft;
+        qreal sourceTop;
+        qreal width;
+        qreal height;
+        qreal scaleX;
+        qreal scaleY;
+        qreal rotation;
+        qreal opacity;
+        static PixmapFragment Q_GUI_EXPORT create(const QPointF &pos, const QRectF &sourceRect,
+                                            qreal scaleX = 1, qreal scaleY = 1,
+                                            qreal rotation = 0, qreal opacity = 1);
+    };
+
+    enum PixmapFragmentHint {
+        OpaqueHint = 0x01
+    };
+
+    Q_DECLARE_FLAGS(PixmapFragmentHints, PixmapFragmentHint)
+
+    QPainter();
+    explicit QPainter(QPaintDevice *);
+    ~QPainter();
+
+    QPaintDevice *device() const;
+
+    bool begin(QPaintDevice *);
+    bool end();
+    bool isActive() const;
+
+    void initFrom(const QWidget *widget);
+
+    enum CompositionMode {
+        CompositionMode_SourceOver,
+        CompositionMode_DestinationOver,
+        CompositionMode_Clear,
+        CompositionMode_Source,
+        CompositionMode_Destination,
+        CompositionMode_SourceIn,
+        CompositionMode_DestinationIn,
+        CompositionMode_SourceOut,
+        CompositionMode_DestinationOut,
+        CompositionMode_SourceAtop,
+        CompositionMode_DestinationAtop,
+        CompositionMode_Xor,
+
+        //svg 1.2 blend modes
+        CompositionMode_Plus,
+        CompositionMode_Multiply,
+        CompositionMode_Screen,
+        CompositionMode_Overlay,
+        CompositionMode_Darken,
+        CompositionMode_Lighten,
+        CompositionMode_ColorDodge,
+        CompositionMode_ColorBurn,
+        CompositionMode_HardLight,
+        CompositionMode_SoftLight,
+        CompositionMode_Difference,
+        CompositionMode_Exclusion,
+
+        // ROPs
+        RasterOp_SourceOrDestination,
+        RasterOp_SourceAndDestination,
+        RasterOp_SourceXorDestination,
+        RasterOp_NotSourceAndNotDestination,
+        RasterOp_NotSourceOrNotDestination,
+        RasterOp_NotSourceXorDestination,
+        RasterOp_NotSource,
+        RasterOp_NotSourceAndDestination,
+        RasterOp_SourceAndNotDestination
+    };
+    void setCompositionMode(CompositionMode mode);
+    CompositionMode compositionMode() const;
+
+    const QFont &font() const;
+    void setFont(const QFont &f);
+
+    QFontMetrics fontMetrics() const;
+    QFontInfo fontInfo() const;
+
+    void setPen(const QColor &color);
+    void setPen(const QPen &pen);
+    void setPen(Qt::PenStyle style);
+    const QPen &pen() const;
+
+    void setBrush(const QBrush &brush);
+    void setBrush(Qt::BrushStyle style);
+    const QBrush &brush() const;
+
+    // attributes/modes
+    void setBackgroundMode(Qt::BGMode mode);
+    Qt::BGMode backgroundMode() const;
+
+    QPoint brushOrigin() const;
+    inline void setBrushOrigin(int x, int y);
+    inline void setBrushOrigin(const QPoint &);
+    void setBrushOrigin(const QPointF &);
+
+    void setBackground(const QBrush &bg);
+    const QBrush &background() const;
+
+    qreal opacity() const;
+    void setOpacity(qreal opacity);
+
+    // Clip functions
+    QRegion clipRegion() const;
+    QPainterPath clipPath() const;
+
+    void setClipRect(const QRectF &, Qt::ClipOperation op = Qt::ReplaceClip);
+    void setClipRect(const QRect &, Qt::ClipOperation op = Qt::ReplaceClip);
+    inline void setClipRect(int x, int y, int w, int h, Qt::ClipOperation op = Qt::ReplaceClip);
+
+    void setClipRegion(const QRegion &, Qt::ClipOperation op = Qt::ReplaceClip);
+
+    void setClipPath(const QPainterPath &path, Qt::ClipOperation op = Qt::ReplaceClip);
+
+    void setClipping(bool enable);
+    bool hasClipping() const;
+
+    QRectF clipBoundingRect() const;
+
+    void save();
+    void restore();
+
+    // XForm functions
+    void setMatrix(const QMatrix &matrix, bool combine = false);
+    const QMatrix &matrix() const;
+    const QMatrix &deviceMatrix() const;
+    void resetMatrix();
+
+    void setTransform(const QTransform &transform, bool combine = false);
+    const QTransform &transform() const;
+    const QTransform &deviceTransform() const;
+    void resetTransform();
+
+    void setWorldMatrix(const QMatrix &matrix, bool combine = false);
+    const QMatrix &worldMatrix() const;
+
+    void setWorldTransform(const QTransform &matrix, bool combine = false);
+    const QTransform &worldTransform() const;
+
+    QMatrix combinedMatrix() const;
+    QTransform combinedTransform() const;
+
+    void setMatrixEnabled(bool enabled);
+    bool matrixEnabled() const;
+
+    void setWorldMatrixEnabled(bool enabled);
+    bool worldMatrixEnabled() const;
+
+    void scale(qreal sx, qreal sy);
+    void shear(qreal sh, qreal sv);
+    void rotate(qreal a);
+
+    void translate(const QPointF &offset);
+    inline void translate(const QPoint &offset);
+    inline void translate(qreal dx, qreal dy);
+
+    QRect window() const;
+    void setWindow(const QRect &window);
+    inline void setWindow(int x, int y, int w, int h);
+
+    QRect viewport() const;
+    void setViewport(const QRect &viewport);
+    inline void setViewport(int x, int y, int w, int h);
+
+    void setViewTransformEnabled(bool enable);
+    bool viewTransformEnabled() const;
+
+    // drawing functions
+    void strokePath(const QPainterPath &path, const QPen &pen);
+    void fillPath(const QPainterPath &path, const QBrush &brush);
+    void drawPath(const QPainterPath &path);
+
+    inline void drawPoint(const QPointF &pt);
+    inline void drawPoint(const QPoint &p);
+    inline void drawPoint(int x, int y);
+
+    void drawPoints(const QPointF *points, int pointCount);
+    inline void drawPoints(const QPolygonF &points);
+    void drawPoints(const QPoint *points, int pointCount);
+    inline void drawPoints(const QPolygon &points);
+
+    inline void drawLine(const QLineF &line);
+    inline void drawLine(const QLine &line);
+    inline void drawLine(int x1, int y1, int x2, int y2);
+    inline void drawLine(const QPoint &p1, const QPoint &p2);
+    inline void drawLine(const QPointF &p1, const QPointF &p2);
+
+    void drawLines(const QLineF *lines, int lineCount);
+    inline void drawLines(const QVector<QLineF> &lines);
+    void drawLines(const QPointF *pointPairs, int lineCount);
+    inline void drawLines(const QVector<QPointF> &pointPairs);
+    void drawLines(const QLine *lines, int lineCount);
+    inline void drawLines(const QVector<QLine> &lines);
+    void drawLines(const QPoint *pointPairs, int lineCount);
+    inline void drawLines(const QVector<QPoint> &pointPairs);
+
+    inline void drawRect(const QRectF &rect);
+    inline void drawRect(int x1, int y1, int w, int h);
+    inline void drawRect(const QRect &rect);
+
+    void drawRects(const QRectF *rects, int rectCount);
+    inline void drawRects(const QVector<QRectF> &rectangles);
+    void drawRects(const QRect *rects, int rectCount);
+    inline void drawRects(const QVector<QRect> &rectangles);
+
+    void drawEllipse(const QRectF &r);
+    void drawEllipse(const QRect &r);
+    inline void drawEllipse(int x, int y, int w, int h);
+
+    inline void drawEllipse(const QPointF &center, qreal rx, qreal ry);
+    inline void drawEllipse(const QPoint &center, int rx, int ry);
+
+    void drawPolyline(const QPointF *points, int pointCount);
+    inline void drawPolyline(const QPolygonF &polyline);
+    void drawPolyline(const QPoint *points, int pointCount);
+    inline void drawPolyline(const QPolygon &polygon);
+
+    void drawPolygon(const QPointF *points, int pointCount, Qt::FillRule fillRule = Qt::OddEvenFill);
+    inline void drawPolygon(const QPolygonF &polygon, Qt::FillRule fillRule = Qt::OddEvenFill);
+    void drawPolygon(const QPoint *points, int pointCount, Qt::FillRule fillRule = Qt::OddEvenFill);
+    inline void drawPolygon(const QPolygon &polygon, Qt::FillRule fillRule = Qt::OddEvenFill);
+
+    void drawConvexPolygon(const QPointF *points, int pointCount);
+    inline void drawConvexPolygon(const QPolygonF &polygon);
+    void drawConvexPolygon(const QPoint *points, int pointCount);
+    inline void drawConvexPolygon(const QPolygon &polygon);
+
+    void drawArc(const QRectF &rect, int a, int alen);
+    inline void drawArc(const QRect &, int a, int alen);
+    inline void drawArc(int x, int y, int w, int h, int a, int alen);
+
+    void drawPie(const QRectF &rect, int a, int alen);
+    inline void drawPie(int x, int y, int w, int h, int a, int alen);
+    inline void drawPie(const QRect &, int a, int alen);
+
+    void drawChord(const QRectF &rect, int a, int alen);
+    inline void drawChord(int x, int y, int w, int h, int a, int alen);
+    inline void drawChord(const QRect &, int a, int alen);
+
+    void drawRoundedRect(const QRectF &rect, qreal xRadius, qreal yRadius,
+                         Qt::SizeMode mode = Qt::AbsoluteSize);
+    inline void drawRoundedRect(int x, int y, int w, int h, qreal xRadius, qreal yRadius,
+                                Qt::SizeMode mode = Qt::AbsoluteSize);
+    inline void drawRoundedRect(const QRect &rect, qreal xRadius, qreal yRadius,
+                                Qt::SizeMode mode = Qt::AbsoluteSize);
+
+    void drawRoundRect(const QRectF &r, int xround = 25, int yround = 25);
+    inline void drawRoundRect(int x, int y, int w, int h, int = 25, int = 25);
+    inline void drawRoundRect(const QRect &r, int xround = 25, int yround = 25);
+
+    void drawTiledPixmap(const QRectF &rect, const QPixmap &pm, const QPointF &offset = QPointF());
+    inline void drawTiledPixmap(int x, int y, int w, int h, const QPixmap &, int sx=0, int sy=0);
+    inline void drawTiledPixmap(const QRect &, const QPixmap &, const QPoint & = QPoint());
+#ifndef QT_NO_PICTURE
+    void drawPicture(const QPointF &p, const QPicture &picture);
+    inline void drawPicture(int x, int y, const QPicture &picture);
+    inline void drawPicture(const QPoint &p, const QPicture &picture);
+#endif
+
+    void drawPixmap(const QRectF &targetRect, const QPixmap &pixmap, const QRectF &sourceRect);
+    inline void drawPixmap(const QRect &targetRect, const QPixmap &pixmap, const QRect &sourceRect);
+    inline void drawPixmap(int x, int y, int w, int h, const QPixmap &pm,
+                           int sx, int sy, int sw, int sh);
+    inline void drawPixmap(int x, int y, const QPixmap &pm,
+                           int sx, int sy, int sw, int sh);
+    inline void drawPixmap(const QPointF &p, const QPixmap &pm, const QRectF &sr);
+    inline void drawPixmap(const QPoint &p, const QPixmap &pm, const QRect &sr);
+    void drawPixmap(const QPointF &p, const QPixmap &pm);
+    inline void drawPixmap(const QPoint &p, const QPixmap &pm);
+    inline void drawPixmap(int x, int y, const QPixmap &pm);
+    inline void drawPixmap(const QRect &r, const QPixmap &pm);
+    inline void drawPixmap(int x, int y, int w, int h, const QPixmap &pm);
+
+    void drawPixmapFragments(const PixmapFragment *fragments, int fragmentCount,
+                             const QPixmap &pixmap, PixmapFragmentHints hints = 0);
+
+    void drawImage(const QRectF &targetRect, const QImage &image, const QRectF &sourceRect,
+                   Qt::ImageConversionFlags flags = Qt::AutoColor);
+    inline void drawImage(const QRect &targetRect, const QImage &image, const QRect &sourceRect,
+                          Qt::ImageConversionFlags flags = Qt::AutoColor);
+    inline void drawImage(const QPointF &p, const QImage &image, const QRectF &sr,
+                          Qt::ImageConversionFlags flags = Qt::AutoColor);
+    inline void drawImage(const QPoint &p, const QImage &image, const QRect &sr,
+                          Qt::ImageConversionFlags flags = Qt::AutoColor);
+    inline void drawImage(const QRectF &r, const QImage &image);
+    inline void drawImage(const QRect &r, const QImage &image);
+    void drawImage(const QPointF &p, const QImage &image);
+    inline void drawImage(const QPoint &p, const QImage &image);
+    inline void drawImage(int x, int y, const QImage &image, int sx = 0, int sy = 0,
+                          int sw = -1, int sh = -1, Qt::ImageConversionFlags flags = Qt::AutoColor);
+
+    void setLayoutDirection(Qt::LayoutDirection direction);
+    Qt::LayoutDirection layoutDirection() const;
+
+#if !defined(QT_NO_RAWFONT)
+    void drawGlyphs(const QPointF &position, const QGlyphs &glyphs);
+#endif
+
+    void drawStaticText(const QPointF &topLeftPosition, const QStaticText &staticText);
+    inline void drawStaticText(const QPoint &topLeftPosition, const QStaticText &staticText);
+    inline void drawStaticText(int left, int top, const QStaticText &staticText);
+
+    void drawText(const QPointF &p, const QString &s);
+    inline void drawText(const QPoint &p, const QString &s);
+    inline void drawText(int x, int y, const QString &s);
+
+    void drawText(const QPointF &p, const QString &str, int tf, int justificationPadding);
+
+    void drawText(const QRectF &r, int flags, const QString &text, QRectF *br=0);
+    void drawText(const QRect &r, int flags, const QString &text, QRect *br=0);
+    inline void drawText(int x, int y, int w, int h, int flags, const QString &text, QRect *br=0);
+
+    void drawText(const QRectF &r, const QString &text, const QTextOption &o = QTextOption());
+
+    QRectF boundingRect(const QRectF &rect, int flags, const QString &text);
+    QRect boundingRect(const QRect &rect, int flags, const QString &text);
+    inline QRect boundingRect(int x, int y, int w, int h, int flags, const QString &text);
+
+    QRectF boundingRect(const QRectF &rect, const QString &text, const QTextOption &o = QTextOption());
+
+    void drawTextItem(const QPointF &p, const QTextItem &ti);
+    inline void drawTextItem(int x, int y, const QTextItem &ti);
+    inline void drawTextItem(const QPoint &p, const QTextItem &ti);
+
+    void fillRect(const QRectF &, const QBrush &);
+    inline void fillRect(int x, int y, int w, int h, const QBrush &);
+    void fillRect(const QRect &, const QBrush &);
+
+    void fillRect(const QRectF &, const QColor &color);
+    inline void fillRect(int x, int y, int w, int h, const QColor &color);
+    void fillRect(const QRect &, const QColor &color);
+
+    inline void fillRect(int x, int y, int w, int h, Qt::GlobalColor c);
+    inline void fillRect(const QRect &r, Qt::GlobalColor c);
+    inline void fillRect(const QRectF &r, Qt::GlobalColor c);
+
+    inline void fillRect(int x, int y, int w, int h, Qt::BrushStyle style);
+    inline void fillRect(const QRect &r, Qt::BrushStyle style);
+    inline void fillRect(const QRectF &r, Qt::BrushStyle style);
+
+    void eraseRect(const QRectF &);
+    inline void eraseRect(int x, int y, int w, int h);
+    inline void eraseRect(const QRect &);
+
+    void setRenderHint(RenderHint hint, bool on = true);
+    void setRenderHints(RenderHints hints, bool on = true);
+    RenderHints renderHints() const;
+    inline bool testRenderHint(RenderHint hint) const { return renderHints() & hint; }
+
+    QPaintEngine *paintEngine() const;
+
+    static void setRedirected(const QPaintDevice *device, QPaintDevice *replacement,
+                              const QPoint& offset = QPoint());
+    static QPaintDevice *redirected(const QPaintDevice *device, QPoint *offset = 0);
+    static void restoreRedirected(const QPaintDevice *device);
+
+    void beginNativePainting();
+    void endNativePainting();
+
+#ifdef QT3_SUPPORT
+
+    inline QT3_SUPPORT void setBackgroundColor(const QColor &color) { setBackground(color); }
+    inline QT3_SUPPORT const QColor &backgroundColor() const { return background().color(); }
+
+    inline QT3_SUPPORT void drawText(int x, int y, const QString &s, int pos, int len)
+        { drawText(x, y, s.mid(pos, len)); }
+    inline QT3_SUPPORT void drawText(const QPoint &p, const QString &s, int pos, int len)
+        { drawText(p, s.mid(pos, len)); }
+    inline QT3_SUPPORT void drawText(int x, int y, const QString &s, int len)
+        { drawText(x, y, s.left(len)); }
+    inline QT3_SUPPORT void drawText(const QPoint &p, const QString &s, int len)
+        { drawText(p, s.left(len)); }
+    inline QT3_SUPPORT void drawText(const QRect &r, int flags, const QString &str, int len, QRect *br=0)
+        { drawText(r, flags, str.left(len), br); }
+    inline QT3_SUPPORT void drawText(int x, int y, int w, int h, int flags, const QString &text, int len, QRect *br=0)
+        { drawText(QRect(x, y, w, h), flags, text.left(len), br); }
+    inline QT3_SUPPORT QRect boundingRect(const QRect &rect, int flags, const QString &text, int len)
+        { return boundingRect(rect, flags, text.left(len)); }
+    inline QT3_SUPPORT QRect boundingRect(int x, int y, int w, int h, int flags, const QString &text, int len)
+        { return boundingRect(QRect(x, y, w, h), flags, text.left(len)); }
+
+    inline QT3_SUPPORT bool begin(QPaintDevice *pdev, const QWidget *init)
+        { bool ret = begin(pdev); initFrom(init); return ret; }
+    QT3_SUPPORT void drawPoints(const QPolygon &pa, int index, int npoints = -1)
+    { drawPoints(pa.constData() + index, npoints == -1 ? pa.size() - index : npoints); }
+
+    QT3_SUPPORT void drawCubicBezier(const QPolygon &pa, int index = 0);
+
+    QT3_SUPPORT void drawLineSegments(const QPolygon &points, int index = 0, int nlines = -1);
+
+    inline QT3_SUPPORT void drawPolyline(const QPolygon &pa, int index, int npoints = -1)
+    { drawPolyline(pa.constData() + index, npoints == -1 ? pa.size() - index : npoints); }
+
+    inline QT3_SUPPORT void drawPolygon(const QPolygon &pa, bool winding, int index = 0, int npoints = -1)
+    { drawPolygon(pa.constData() + index, npoints == -1 ? pa.size() - index : npoints,
+                  winding ? Qt::WindingFill : Qt::OddEvenFill); }
+
+    inline QT3_SUPPORT void drawPolygon(const QPolygonF &polygon, bool winding, int index = 0,
+                                      int npoints = -1)
+    { drawPolygon(polygon.constData() + index, npoints == -1 ? polygon.size() - index : npoints,
+                  winding ? Qt::WindingFill : Qt::OddEvenFill); }
+
+    inline QT3_SUPPORT void drawConvexPolygon(const QPolygonF &polygon, int index, int npoints = -1)
+    { drawConvexPolygon(polygon.constData() + index, npoints == -1 ? polygon.size() - index : npoints); }
+    inline QT3_SUPPORT void drawConvexPolygon(const QPolygon &pa, int index, int npoints = -1)
+    { drawConvexPolygon(pa.constData() + index, npoints == -1 ? pa.size() - index : npoints); }
+
+    static inline QT3_SUPPORT void redirect(QPaintDevice *pdev, QPaintDevice *replacement)
+    { setRedirected(pdev, replacement); }
+    static inline QT3_SUPPORT QPaintDevice *redirect(QPaintDevice *pdev)
+    { return const_cast<QPaintDevice*>(redirected(pdev)); }
+
+    inline QT3_SUPPORT void setWorldXForm(bool enabled) { setMatrixEnabled(enabled); }
+    inline QT3_SUPPORT bool hasWorldXForm() const { return matrixEnabled(); }
+    inline QT3_SUPPORT void resetXForm() { resetTransform(); }
+
+    inline QT3_SUPPORT void setViewXForm(bool enabled) { setViewTransformEnabled(enabled); }
+    inline QT3_SUPPORT bool hasViewXForm() const { return viewTransformEnabled(); }
+
+    QT3_SUPPORT void map(int x, int y, int *rx, int *ry) const;
+    QT3_SUPPORT QPoint xForm(const QPoint &) const; // map virtual -> deviceb
+    QT3_SUPPORT QRect xForm(const QRect &) const;
+    QT3_SUPPORT QPolygon xForm(const QPolygon &) const;
+    QT3_SUPPORT QPolygon xForm(const QPolygon &, int index, int npoints) const;
+    QT3_SUPPORT QPoint xFormDev(const QPoint &) const; // map device -> virtual
+    QT3_SUPPORT QRect xFormDev(const QRect &) const;
+    QT3_SUPPORT QPolygon xFormDev(const QPolygon &) const;
+    QT3_SUPPORT QPolygon xFormDev(const QPolygon &, int index, int npoints) const;
+    QT3_SUPPORT qreal translationX() const;
+    QT3_SUPPORT qreal translationY() const;
+#endif
+
+private:
+    Q_DISABLE_COPY(QPainter)
+    friend class Q3Painter;
+
+    QScopedPointer<QPainterPrivate> d_ptr;
+
+    friend class QFontEngine;
+    friend class QFontEngineBox;
+    friend class QFontEngineFT;
+    friend class QFontEngineMac;
+    friend class QFontEngineWin;
+    friend class QFontEngineXLFD;
+    friend class QWSManager;
+    friend class QPaintEngine;
+    friend class QPaintEngineExPrivate;
+    friend class QOpenGLPaintEngine;
+    friend class QX11PaintEngine;
+    friend class QX11PaintEnginePrivate;
+    friend class QWin32PaintEngine;
+    friend class QWin32PaintEnginePrivate;
+    friend class QRasterPaintEngine;
+    friend class QAlphaPaintEngine;
+    friend class QPreviewPaintEngine;
+};
+
+Q_DECLARE_OPERATORS_FOR_FLAGS(QPainter::RenderHints)
+
+//
+// functions
+//
+inline void QPainter::drawLine(const QLineF &l)
+{
+    drawLines(&l, 1);
+}
+
+inline void QPainter::drawLine(const QLine &line)
+{
+    drawLines(&line, 1);
+}
+
+inline void QPainter::drawLine(int x1, int y1, int x2, int y2)
+{
+    QLine l(x1, y1, x2, y2);
+    drawLines(&l, 1);
+}
+
+inline void QPainter::drawLine(const QPoint &p1, const QPoint &p2)
+{
+    QLine l(p1, p2);
+    drawLines(&l, 1);
+}
+
+inline void QPainter::drawLine(const QPointF &p1, const QPointF &p2)
+{
+    drawLine(QLineF(p1, p2));
+}
+
+inline void QPainter::drawLines(const QVector<QLineF> &lines)
+{
+    drawLines(lines.constData(), lines.size());
+}
+
+inline void QPainter::drawLines(const QVector<QLine> &lines)
+{
+    drawLines(lines.constData(), lines.size());
+}
+
+inline void QPainter::drawLines(const QVector<QPointF> &pointPairs)
+{
+    drawLines(pointPairs.constData(), pointPairs.size() / 2);
+}
+
+inline void QPainter::drawLines(const QVector<QPoint> &pointPairs)
+{
+    drawLines(pointPairs.constData(), pointPairs.size() / 2);
+}
+
+inline void QPainter::drawPolyline(const QPolygonF &polyline)
+{
+    drawPolyline(polyline.constData(), polyline.size());
+}
+
+inline void QPainter::drawPolyline(const QPolygon &polyline)
+{
+    drawPolyline(polyline.constData(), polyline.size());
+}
+
+inline void QPainter::drawPolygon(const QPolygonF &polygon, Qt::FillRule fillRule)
+{
+    drawPolygon(polygon.constData(), polygon.size(), fillRule);
+}
+
+inline void QPainter::drawPolygon(const QPolygon &polygon, Qt::FillRule fillRule)
+{
+    drawPolygon(polygon.constData(), polygon.size(), fillRule);
+}
+
+inline void QPainter::drawConvexPolygon(const QPolygonF &poly)
+{
+    drawConvexPolygon(poly.constData(), poly.size());
+}
+
+inline void QPainter::drawConvexPolygon(const QPolygon &poly)
+{
+    drawConvexPolygon(poly.constData(), poly.size());
+}
+
+inline void QPainter::drawRect(const QRectF &rect)
+{
+    drawRects(&rect, 1);
+}
+
+inline void QPainter::drawRect(int x, int y, int w, int h)
+{
+    QRect r(x, y, w, h);
+    drawRects(&r, 1);
+}
+
+inline void QPainter::drawRect(const QRect &r)
+{
+    drawRects(&r, 1);
+}
+
+inline void QPainter::drawRects(const QVector<QRectF> &rects)
+{
+    drawRects(rects.constData(), rects.size());
+}
+
+inline void QPainter::drawRects(const QVector<QRect> &rects)
+{
+    drawRects(rects.constData(), rects.size());
+}
+
+inline void QPainter::drawPoint(const QPointF &p)
+{
+    drawPoints(&p, 1);
+}
+
+inline void QPainter::drawPoint(int x, int y)
+{
+    QPoint p(x, y);
+    drawPoints(&p, 1);
+}
+
+inline void QPainter::drawPoint(const QPoint &p)
+{
+    drawPoints(&p, 1);
+}
+
+inline void QPainter::drawPoints(const QPolygonF &points)
+{
+    drawPoints(points.constData(), points.size());
+}
+
+inline void QPainter::drawPoints(const QPolygon &points)
+{
+    drawPoints(points.constData(), points.size());
+}
+
+inline void QPainter::drawRoundRect(int x, int y, int w, int h, int xRnd, int yRnd)
+{
+    drawRoundRect(QRectF(x, y, w, h), xRnd, yRnd);
+}
+
+inline void QPainter::drawRoundRect(const QRect &rect, int xRnd, int yRnd)
+{
+    drawRoundRect(QRectF(rect), xRnd, yRnd);
+}
+
+inline void QPainter::drawRoundedRect(int x, int y, int w, int h, qreal xRadius, qreal yRadius,
+                            Qt::SizeMode mode)
+{
+    drawRoundedRect(QRectF(x, y, w, h), xRadius, yRadius, mode);
+}
+
+inline void QPainter::drawRoundedRect(const QRect &rect, qreal xRadius, qreal yRadius,
+                            Qt::SizeMode mode)
+{
+    drawRoundedRect(QRectF(rect), xRadius, yRadius, mode);
+}
+
+inline void QPainter::drawEllipse(int x, int y, int w, int h)
+{
+    drawEllipse(QRect(x, y, w, h));
+}
+
+inline void QPainter::drawEllipse(const QPointF &center, qreal rx, qreal ry)
+{
+    drawEllipse(QRectF(center.x() - rx, center.y() - ry, 2 * rx, 2 * ry));
+}
+
+inline void QPainter::drawEllipse(const QPoint &center, int rx, int ry)
+{
+    drawEllipse(QRect(center.x() - rx, center.y() - ry, 2 * rx, 2 * ry));
+}
+
+inline void QPainter::drawArc(const QRect &r, int a, int alen)
+{
+    drawArc(QRectF(r), a, alen);
+}
+
+inline void QPainter::drawArc(int x, int y, int w, int h, int a, int alen)
+{
+    drawArc(QRectF(x, y, w, h), a, alen);
+}
+
+inline void QPainter::drawPie(const QRect &rect, int a, int alen)
+{
+    drawPie(QRectF(rect), a, alen);
+}
+
+inline void QPainter::drawPie(int x, int y, int w, int h, int a, int alen)
+{
+    drawPie(QRectF(x, y, w, h), a, alen);
+}
+
+inline void QPainter::drawChord(const QRect &rect, int a, int alen)
+{
+    drawChord(QRectF(rect), a, alen);
+}
+
+inline void QPainter::drawChord(int x, int y, int w, int h, int a, int alen)
+{
+    drawChord(QRectF(x, y, w, h), a, alen);
+}
+
+inline void QPainter::setClipRect(int x, int y, int w, int h, Qt::ClipOperation op)
+{
+    setClipRect(QRect(x, y, w, h), op);
+}
+
+inline void QPainter::eraseRect(const QRect &rect)
+{
+    eraseRect(QRectF(rect));
+}
+
+inline void QPainter::eraseRect(int x, int y, int w, int h)
+{
+    eraseRect(QRectF(x, y, w, h));
+}
+
+inline void QPainter::fillRect(int x, int y, int w, int h, const QBrush &b)
+{
+    fillRect(QRect(x, y, w, h), b);
+}
+
+inline void QPainter::fillRect(int x, int y, int w, int h, const QColor &b)
+{
+    fillRect(QRect(x, y, w, h), b);
+}
+
+inline void QPainter::fillRect(int x, int y, int w, int h, Qt::GlobalColor c)
+{
+    fillRect(QRect(x, y, w, h), QColor(c));
+}
+
+inline void QPainter::fillRect(const QRect &r, Qt::GlobalColor c)
+{
+    fillRect(r, QColor(c));
+}
+
+inline void QPainter::fillRect(const QRectF &r, Qt::GlobalColor c)
+{
+    fillRect(r, QColor(c));
+}
+
+inline void QPainter::fillRect(int x, int y, int w, int h, Qt::BrushStyle style)
+{
+    fillRect(QRectF(x, y, w, h), QBrush(style));
+}
+
+inline void QPainter::fillRect(const QRect &r, Qt::BrushStyle style)
+{
+    fillRect(QRectF(r), QBrush(style));
+}
+
+inline void QPainter::fillRect(const QRectF &r, Qt::BrushStyle style)
+{
+    fillRect(r, QBrush(style));
+}
+
+
+inline void QPainter::setBrushOrigin(int x, int y)
+{
+    setBrushOrigin(QPoint(x, y));
+}
+
+inline void QPainter::setBrushOrigin(const QPoint &p)
+{
+    setBrushOrigin(QPointF(p));
+}
+
+inline void QPainter::drawTiledPixmap(const QRect &rect, const QPixmap &pm, const QPoint &offset)
+{
+    drawTiledPixmap(QRectF(rect), pm, QPointF(offset));
+}
+
+inline void QPainter::drawTiledPixmap(int x, int y, int w, int h, const QPixmap &pm, int sx, int sy)
+{
+    drawTiledPixmap(QRectF(x, y, w, h), pm, QPointF(sx, sy));
+}
+
+inline void QPainter::drawPixmap(const QRect &targetRect, const QPixmap &pixmap, const QRect &sourceRect)
+{
+    drawPixmap(QRectF(targetRect), pixmap, QRectF(sourceRect));
+}
+
+inline void QPainter::drawPixmap(const QPoint &p, const QPixmap &pm)
+{
+    drawPixmap(QPointF(p), pm);
+}
+
+inline void QPainter::drawPixmap(const QRect &r, const QPixmap &pm)
+{
+    drawPixmap(QRectF(r), pm, QRectF());
+}
+
+inline void QPainter::drawPixmap(int x, int y, const QPixmap &pm)
+{
+    drawPixmap(QPointF(x, y), pm);
+}
+
+inline void QPainter::drawPixmap(int x, int y, int w, int h, const QPixmap &pm)
+{
+    drawPixmap(QRectF(x, y, w, h), pm, QRectF());
+}
+
+inline void QPainter::drawPixmap(int x, int y, int w, int h, const QPixmap &pm,
+                                 int sx, int sy, int sw, int sh)
+{
+    drawPixmap(QRectF(x, y, w, h), pm, QRectF(sx, sy, sw, sh));
+}
+
+inline void QPainter::drawPixmap(int x, int y, const QPixmap &pm,
+                                 int sx, int sy, int sw, int sh)
+{
+    drawPixmap(QRectF(x, y, -1, -1), pm, QRectF(sx, sy, sw, sh));
+}
+
+inline void QPainter::drawPixmap(const QPointF &p, const QPixmap &pm, const QRectF &sr)
+{
+    drawPixmap(QRectF(p.x(), p.y(), -1, -1), pm, sr);
+}
+
+inline void QPainter::drawPixmap(const QPoint &p, const QPixmap &pm, const QRect &sr)
+{
+    drawPixmap(QRectF(p.x(), p.y(), -1, -1), pm, sr);
+}
+
+inline void QPainter::drawTextItem(int x, int y, const QTextItem &ti)
+{
+    drawTextItem(QPointF(x, y), ti);
+}
+
+inline void QPainter::drawImage(const QRect &targetRect, const QImage &image, const QRect &sourceRect,
+                                Qt::ImageConversionFlags flags)
+{
+    drawImage(QRectF(targetRect), image, QRectF(sourceRect), flags);
+}
+
+inline void QPainter::drawImage(const QPointF &p, const QImage &image, const QRectF &sr,
+                                Qt::ImageConversionFlags flags)
+{
+    drawImage(QRectF(p.x(), p.y(), -1, -1), image, sr, flags);
+}
+
+inline void QPainter::drawImage(const QPoint &p, const QImage &image, const QRect &sr,
+                                Qt::ImageConversionFlags flags)
+{
+    drawImage(QRect(p.x(), p.y(), -1, -1), image, sr, flags);
+}
+
+
+inline void QPainter::drawImage(const QRectF &r, const QImage &image)
+{
+    drawImage(r, image, QRect(0, 0, image.width(), image.height()));
+}
+
+inline void QPainter::drawImage(const QRect &r, const QImage &image)
+{
+    drawImage(r, image, QRectF(0, 0, image.width(), image.height()));
+}
+
+inline void QPainter::drawImage(const QPoint &p, const QImage &image)
+{
+    drawImage(QPointF(p), image);
+}
+
+inline void QPainter::drawImage(int x, int y, const QImage &image, int sx, int sy, int sw, int sh,
+                                Qt::ImageConversionFlags flags)
+{
+    if (sx == 0 && sy == 0 && sw == -1 && sh == -1 && flags == Qt::AutoColor)
+        drawImage(QPointF(x, y), image);
+    else
+        drawImage(QRectF(x, y, -1, -1), image, QRectF(sx, sy, sw, sh), flags);
+}
+
+inline void QPainter::drawStaticText(const QPoint &p, const QStaticText &staticText)
+{
+    drawStaticText(QPointF(p), staticText);
+}
+
+inline void QPainter::drawStaticText(int x, int y, const QStaticText &staticText)
+{
+    drawStaticText(QPointF(x, y), staticText);
+}
+
+inline void QPainter::drawTextItem(const QPoint &p, const QTextItem &ti)
+{
+    drawTextItem(QPointF(p), ti);
+}
+
+inline void QPainter::drawText(const QPoint &p, const QString &s)
+{
+    drawText(QPointF(p), s);
+}
+
+inline void QPainter::drawText(int x, int y, int w, int h, int flags, const QString &str, QRect *br)
+{
+    drawText(QRect(x, y, w, h), flags, str, br);
+}
+
+inline void QPainter::drawText(int x, int y, const QString &s)
+{
+    drawText(QPointF(x, y), s);
+}
+
+inline QRect QPainter::boundingRect(int x, int y, int w, int h, int flags, const QString &text)
+{
+    return boundingRect(QRect(x, y, w, h), flags, text);
+}
+
+inline void QPainter::translate(qreal dx, qreal dy)
+{
+    translate(QPointF(dx, dy));
+}
+
+inline void QPainter::translate(const QPoint &offset)
+{
+    translate(offset.x(), offset.y());
+}
+
+inline void QPainter::setViewport(int x, int y, int w, int h)
+{
+    setViewport(QRect(x, y, w, h));
+}
+
+inline void QPainter::setWindow(int x, int y, int w, int h)
+{
+    setWindow(QRect(x, y, w, h));
+}
+
+#ifndef QT_NO_PICTURE
+inline void QPainter::drawPicture(int x, int y, const QPicture &p)
+{
+    drawPicture(QPoint(x, y), p);
+}
+
+inline void QPainter::drawPicture(const QPoint &pt, const QPicture &p)
+{
+    drawPicture(QPointF(pt), p);
+}
+#endif
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QPAINTER_H
diff --git a/src/gui/painting/qpainter_p.h b/src/gui/painting/qpainter_p.h
new file mode 100644
index 0000000000..205c10a09f
--- /dev/null
+++ b/src/gui/painting/qpainter_p.h
@@ -0,0 +1,273 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPAINTER_P_H
+#define QPAINTER_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "QtGui/qbrush.h"
+#include "QtGui/qfont.h"
+#include "QtGui/qpen.h"
+#include "QtGui/qregion.h"
+#include "QtGui/qmatrix.h"
+#include "QtGui/qpainter.h"
+#include "QtGui/qpainterpath.h"
+#include "QtGui/qpaintengine.h"
+#include <QtCore/qhash.h>
+
+#include <private/qpen_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QPaintEngine;
+class QEmulationPaintEngine;
+class QPaintEngineEx;
+struct QFixedPoint;
+
+struct QTLWExtra;
+
+struct DataPtrContainer {
+    void *ptr;
+};
+
+inline void *data_ptr(const QTransform &t) { return (DataPtrContainer *) &t; }
+inline bool qtransform_fast_equals(const QTransform &a, const QTransform &b) { return data_ptr(a) == data_ptr(b); }
+
+// QPen inline functions...
+inline QPen::DataPtr &data_ptr(const QPen &p) { return const_cast<QPen &>(p).data_ptr(); }
+inline bool qpen_fast_equals(const QPen &a, const QPen &b) { return data_ptr(a) == data_ptr(b); }
+inline QBrush qpen_brush(const QPen &p) { return data_ptr(p)->brush; }
+inline qreal qpen_widthf(const QPen &p) { return data_ptr(p)->width; }
+inline Qt::PenStyle qpen_style(const QPen &p) { return data_ptr(p)->style; }
+inline Qt::PenCapStyle qpen_capStyle(const QPen &p) { return data_ptr(p)->capStyle; }
+inline Qt::PenJoinStyle qpen_joinStyle(const QPen &p) { return data_ptr(p)->joinStyle; }
+
+// QBrush inline functions...
+inline QBrush::DataPtr &data_ptr(const QBrush &p) { return const_cast<QBrush &>(p).data_ptr(); }
+inline bool qbrush_fast_equals(const QBrush &a, const QBrush &b) { return data_ptr(a) == data_ptr(b); }
+inline Qt::BrushStyle qbrush_style(const QBrush &b) { return data_ptr(b)->style; }
+inline const QColor &qbrush_color(const QBrush &b) { return data_ptr(b)->color; }
+inline bool qbrush_has_transform(const QBrush &b) { return data_ptr(b)->transform.type() > QTransform::TxNone; }
+
+class QPainterClipInfo
+{
+public:
+    enum ClipType { RegionClip, PathClip, RectClip, RectFClip };
+
+    QPainterClipInfo(const QPainterPath &p, Qt::ClipOperation op, const QTransform &m) :
+        clipType(PathClip), matrix(m), operation(op), path(p) { }
+
+    QPainterClipInfo(const QRegion &r, Qt::ClipOperation op, const QTransform &m) :
+        clipType(RegionClip), matrix(m), operation(op), region(r) { }
+
+    QPainterClipInfo(const QRect &r, Qt::ClipOperation op, const QTransform &m) :
+        clipType(RectClip), matrix(m), operation(op), rect(r) { }
+
+    QPainterClipInfo(const QRectF &r, Qt::ClipOperation op, const QTransform &m) :
+        clipType(RectFClip), matrix(m), operation(op), rectf(r) { }
+
+    ClipType clipType;
+    QTransform matrix;
+    Qt::ClipOperation operation;
+    QPainterPath path;
+    QRegion region;
+    QRect rect;
+    QRectF rectf;
+
+    // ###
+//     union {
+//         QRegionData *d;
+//         QPainterPathPrivate *pathData;
+
+//         struct {
+//             int x, y, w, h;
+//         } rectData;
+//         struct {
+//             qreal x, y, w, h;
+//         } rectFData;
+//     };
+
+};
+
+
+class Q_GUI_EXPORT QPainterState : public QPaintEngineState
+{
+public:
+    QPainterState();
+    QPainterState(const QPainterState *s);
+    virtual ~QPainterState();
+    void init(QPainter *p);
+
+    QPointF brushOrigin;
+    QFont font;
+    QFont deviceFont;
+    QPen pen;
+    QBrush brush;
+    QBrush bgBrush;             // background brush
+    QRegion clipRegion;
+    QPainterPath clipPath;
+    Qt::ClipOperation clipOperation;
+    QPainter::RenderHints renderHints;
+    QList<QPainterClipInfo> clipInfo; // ### Make me smaller and faster to copy around...
+    QTransform worldMatrix;       // World transformation matrix, not window and viewport
+    QTransform matrix;            // Complete transformation matrix,
+    QTransform redirectionMatrix;
+    int wx, wy, ww, wh;         // window rectangle
+    int vx, vy, vw, vh;         // viewport rectangle
+    qreal opacity;
+
+    uint WxF:1;                 // World transformation
+    uint VxF:1;                 // View transformation
+    uint clipEnabled:1;
+
+    Qt::BGMode bgMode;
+    QPainter *painter;
+    Qt::LayoutDirection layoutDirection;
+    QPainter::CompositionMode composition_mode;
+    uint emulationSpecifier;
+    uint changeFlags;
+};
+
+struct QPainterDummyState
+{
+    QFont font;
+    QPen pen;
+    QBrush brush;
+    QTransform transform;
+};
+
+class QRawFont;
+class QPainterPrivate
+{
+    Q_DECLARE_PUBLIC(QPainter)
+public:
+    QPainterPrivate(QPainter *painter)
+    : q_ptr(painter), d_ptrs(0), state(0), dummyState(0), txinv(0), inDestructor(false), d_ptrs_size(0),
+        refcount(1), device(0), original_device(0), helper_device(0), engine(0), emulationEngine(0),
+        extended(0)
+    {
+    }
+
+    ~QPainterPrivate();
+
+    QPainter *q_ptr;
+    QPainterPrivate **d_ptrs;
+
+    QPainterState *state;
+    QVector<QPainterState*> states;
+
+    mutable QPainterDummyState *dummyState;
+
+    QTransform invMatrix;
+    uint txinv:1;
+    uint inDestructor : 1;
+    uint d_ptrs_size;
+    uint refcount;
+
+    enum DrawOperation { StrokeDraw        = 0x1,
+                         FillDraw          = 0x2,
+                         StrokeAndFillDraw = 0x3
+    };
+
+    QPainterDummyState *fakeState() const {
+        if (!dummyState)
+            dummyState = new QPainterDummyState();
+        return dummyState;
+    }
+
+    void updateEmulationSpecifier(QPainterState *s);
+    void updateStateImpl(QPainterState *state);
+    void updateState(QPainterState *state);
+
+    void draw_helper(const QPainterPath &path, DrawOperation operation = StrokeAndFillDraw);
+    void drawStretchedGradient(const QPainterPath &path, DrawOperation operation);
+    void drawOpaqueBackground(const QPainterPath &path, DrawOperation operation);
+
+#if !defined(QT_NO_RAWFONT)
+    void drawGlyphs(quint32 *glyphArray, QFixedPoint *positionArray, int glyphCount,
+                    const QRawFont &font, bool overline = false, bool underline = false,
+                    bool strikeOut = false);
+#endif
+
+    void updateMatrix();
+    void updateInvMatrix();
+
+    int rectSubtraction() const {
+        return state->pen.style() != Qt::NoPen && state->pen.width() == 0 ? 1 : 0;
+    }
+
+    void checkEmulation();
+
+    static QPainterPrivate *get(QPainter *painter)
+    {
+        return painter->d_ptr.data();
+    }
+
+    QTransform viewTransform() const;
+    static bool attachPainterPrivate(QPainter *q, QPaintDevice *pdev);
+    void detachPainterPrivate(QPainter *q);
+
+    QPaintDevice *device;
+    QPaintDevice *original_device;
+    QPaintDevice *helper_device;
+    QPaintEngine *engine;
+    QEmulationPaintEngine *emulationEngine;
+    QPaintEngineEx *extended;
+    QBrush colorBrush;          // for fill with solid color
+};
+
+Q_GUI_EXPORT void qt_draw_helper(QPainterPrivate *p, const QPainterPath &path, QPainterPrivate::DrawOperation operation);
+
+QString qt_generate_brush_key(const QBrush &brush);
+
+QT_END_NAMESPACE
+
+#endif // QPAINTER_P_H
diff --git a/src/gui/painting/qpainterpath.cpp b/src/gui/painting/qpainterpath.cpp
new file mode 100644
index 0000000000..27aed3226f
--- /dev/null
+++ b/src/gui/painting/qpainterpath.cpp
@@ -0,0 +1,3420 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qpainterpath.h"
+#include "qpainterpath_p.h"
+
+#include <qbitmap.h>
+#include <qdebug.h>
+#include <qiodevice.h>
+#include <qlist.h>
+#include <qmatrix.h>
+#include <qpen.h>
+#include <qpolygon.h>
+#include <qtextlayout.h>
+#include <qvarlengtharray.h>
+#include <qmath.h>
+
+#include <private/qbezier_p.h>
+#include <private/qfontengine_p.h>
+#include <private/qnumeric_p.h>
+#include <private/qobject_p.h>
+#include <private/qpathclipper_p.h>
+#include <private/qstroker_p.h>
+#include <private/qtextengine_p.h>
+
+#include <limits.h>
+
+#if 0
+#include <performance.h>
+#else
+#define PM_INIT
+#define PM_MEASURE(x)
+#define PM_DISPLAY
+#endif
+
+QT_BEGIN_NAMESPACE
+
+struct QPainterPathPrivateDeleter
+{
+    static inline void cleanup(QPainterPathPrivate *d)
+    {
+        // note - we must up-cast to QPainterPathData since QPainterPathPrivate
+        // has a non-virtual destructor!
+        if (d && !d->ref.deref())
+            delete static_cast<QPainterPathData *>(d);
+    }
+};
+
+// This value is used to determine the length of control point vectors
+// when approximating arc segments as curves. The factor is multiplied
+// with the radius of the circle.
+
+// #define QPP_DEBUG
+// #define QPP_STROKE_DEBUG
+//#define QPP_FILLPOLYGONS_DEBUG
+
+QPainterPath qt_stroke_dash(const QPainterPath &path, qreal *dashes, int dashCount);
+
+void qt_find_ellipse_coords(const QRectF &r, qreal angle, qreal length,
+                            QPointF* startPoint, QPointF *endPoint)
+{
+    if (r.isNull()) {
+        if (startPoint)
+            *startPoint = QPointF();
+        if (endPoint)
+            *endPoint = QPointF();
+        return;
+    }
+
+    qreal w2 = r.width() / 2;
+    qreal h2 = r.height() / 2;
+
+    qreal angles[2] = { angle, angle + length };
+    QPointF *points[2] = { startPoint, endPoint };
+
+    for (int i = 0; i < 2; ++i) {
+        if (!points[i])
+            continue;
+
+        qreal theta = angles[i] - 360 * qFloor(angles[i] / 360);
+        qreal t = theta / 90;
+        // truncate
+        int quadrant = int(t);
+        t -= quadrant;
+
+        t = qt_t_for_arc_angle(90 * t);
+
+        // swap x and y?
+        if (quadrant & 1)
+            t = 1 - t;
+
+        qreal a, b, c, d;
+        QBezier::coefficients(t, a, b, c, d);
+        QPointF p(a + b + c*QT_PATH_KAPPA, d + c + b*QT_PATH_KAPPA);
+
+        // left quadrants
+        if (quadrant == 1 || quadrant == 2)
+            p.rx() = -p.x();
+
+        // top quadrants
+        if (quadrant == 0 || quadrant == 1)
+            p.ry() = -p.y();
+
+        *points[i] = r.center() + QPointF(w2 * p.x(), h2 * p.y());
+    }
+}
+
+#ifdef QPP_DEBUG
+static void qt_debug_path(const QPainterPath &path)
+{
+    const char *names[] = {
+        "MoveTo     ",
+        "LineTo     ",
+        "CurveTo    ",
+        "CurveToData"
+    };
+
+    printf("\nQPainterPath: elementCount=%d\n", path.elementCount());
+    for (int i=0; i<path.elementCount(); ++i) {
+        const QPainterPath::Element &e = path.elementAt(i);
+        Q_ASSERT(e.type >= 0 && e.type <= QPainterPath::CurveToDataElement);
+        printf(" - %3d:: %s, (%.2f, %.2f)\n", i, names[e.type], e.x, e.y);
+    }
+}
+#endif
+
+/*!
+    \class QPainterPath
+    \ingroup painting
+    \ingroup shared
+
+    \brief The QPainterPath class provides a container for painting operations,
+    enabling graphical shapes to be constructed and reused.
+
+    A painter path is an object composed of a number of graphical
+    building blocks, such as rectangles, ellipses, lines, and curves.
+    Building blocks can be joined in closed subpaths, for example as a
+    rectangle or an ellipse. A closed path has coinciding start and
+    end points. Or they can exist independently as unclosed subpaths,
+    such as lines and curves.
+
+    A QPainterPath object can be used for filling, outlining, and
+    clipping. To generate fillable outlines for a given painter path,
+    use the QPainterPathStroker class.  The main advantage of painter
+    paths over normal drawing operations is that complex shapes only
+    need to be created once; then they can be drawn many times using
+    only calls to the QPainter::drawPath() function.
+
+    QPainterPath provides a collection of functions that can be used
+    to obtain information about the path and its elements. In addition
+    it is possible to reverse the order of the elements using the
+    toReversed() function. There are also several functions to convert
+    this painter path object into a polygon representation.
+
+    \tableofcontents
+
+    \section1 Composing a QPainterPath
+
+    A QPainterPath object can be constructed as an empty path, with a
+    given start point, or as a copy of another QPainterPath object.
+    Once created, lines and curves can be added to the path using the
+    lineTo(), arcTo(), cubicTo() and quadTo() functions. The lines and
+    curves stretch from the currentPosition() to the position passed
+    as argument.
+
+    The currentPosition() of the QPainterPath object is always the end
+    position of the last subpath that was added (or the initial start
+    point). Use the moveTo() function to move the currentPosition()
+    without adding a component. The moveTo() function implicitly
+    starts a new subpath, and closes the previous one.  Another way of
+    starting a new subpath is to call the closeSubpath() function
+    which closes the current path by adding a line from the
+    currentPosition() back to the path's start position. Note that the
+    new path will have (0, 0) as its initial currentPosition().
+
+    QPainterPath class also provides several convenience functions to
+    add closed subpaths to a painter path: addEllipse(), addPath(),
+    addRect(), addRegion() and addText(). The addPolygon() function
+    adds an \e unclosed subpath. In fact, these functions are all
+    collections of moveTo(), lineTo() and cubicTo() operations.
+
+    In addition, a path can be added to the current path using the
+    connectPath() function. But note that this function will connect
+    the last element of the current path to the first element of given
+    one by adding a line.
+
+    Below is a code snippet that shows how a QPainterPath object can
+    be used:
+
+    \table 100%
+    \row
+    \o \inlineimage qpainterpath-construction.png
+    \o
+    \snippet doc/src/snippets/code/src_gui_painting_qpainterpath.cpp 0
+    \endtable
+
+    The painter path is initially empty when constructed. We first add
+    a rectangle, which is a closed subpath. Then we add two bezier
+    curves which together form a closed subpath even though they are
+    not closed individually. Finally we draw the entire path. The path
+    is filled using the default fill rule, Qt::OddEvenFill. Qt
+    provides two methods for filling paths:
+
+    \table
+    \header
+    \o Qt::OddEvenFill
+    \o Qt::WindingFill
+    \row
+    \o \inlineimage qt-fillrule-oddeven.png
+    \o \inlineimage qt-fillrule-winding.png
+    \endtable
+
+    See the Qt::FillRule documentation for the definition of the
+    rules. A painter path's currently set fill rule can be retrieved
+    using the fillRule() function, and altered using the setFillRule()
+    function.
+
+    \section1 QPainterPath Information
+
+    The QPainterPath class provides a collection of functions that
+    returns information about the path and its elements.
+
+    The currentPosition() function returns the end point of the last
+    subpath that was added (or the initial start point). The
+    elementAt() function can be used to retrieve the various subpath
+    elements, the \e number of elements can be retrieved using the
+    elementCount() function, and the isEmpty() function tells whether
+    this QPainterPath object contains any elements at all.
+
+    The controlPointRect() function returns the rectangle containing
+    all the points and control points in this path. This function is
+    significantly faster to compute than the exact boundingRect()
+    which returns the bounding rectangle of this painter path with
+    floating point precision.
+
+    Finally, QPainterPath provides the contains() function which can
+    be used to determine whether a given point or rectangle is inside
+    the path, and the intersects() function which determines if any of
+    the points inside a given rectangle also are inside this path.
+
+    \section1 QPainterPath Conversion
+
+    For compatibility reasons, it might be required to simplify the
+    representation of a painter path: QPainterPath provides the
+    toFillPolygon(), toFillPolygons() and toSubpathPolygons()
+    functions which convert the painter path into a polygon. The
+    toFillPolygon() returns the painter path as one single polygon,
+    while the two latter functions return a list of polygons.
+
+    The toFillPolygons() and toSubpathPolygons() functions are
+    provided because it is usually faster to draw several small
+    polygons than to draw one large polygon, even though the total
+    number of points drawn is the same. The difference between the two
+    is the \e number of polygons they return: The toSubpathPolygons()
+    creates one polygon for each subpath regardless of intersecting
+    subpaths (i.e. overlapping bounding rectangles), while the
+    toFillPolygons() functions creates only one polygon for
+    overlapping subpaths.
+
+    The toFillPolygon() and toFillPolygons() functions first convert
+    all the subpaths to polygons, then uses a rewinding technique to
+    make sure that overlapping subpaths can be filled using the
+    correct fill rule. Note that rewinding inserts additional lines in
+    the polygon so the outline of the fill polygon does not match the
+    outline of the path.
+
+    \section1 Examples
+
+    Qt provides the \l {painting/painterpaths}{Painter Paths Example}
+    and the \l {demos/deform}{Vector Deformation Demo} which are
+    located in Qt's example and demo directories respectively.
+
+    The \l {painting/painterpaths}{Painter Paths Example} shows how
+    painter paths can be used to build complex shapes for rendering
+    and lets the user experiment with the filling and stroking.  The
+    \l {demos/deform}{Vector Deformation Demo} shows how to use
+    QPainterPath to draw text.
+
+    \table
+    \header
+    \o \l {painting/painterpaths}{Painter Paths Example}
+    \o \l {demos/deform}{Vector Deformation Demo}
+    \row
+    \o \inlineimage qpainterpath-example.png
+    \o \inlineimage qpainterpath-demo.png
+    \endtable
+
+    \sa QPainterPathStroker, QPainter, QRegion, {Painter Paths Example}
+*/
+
+/*!
+    \enum QPainterPath::ElementType
+
+    This enum describes the types of elements used to connect vertices
+    in subpaths.
+
+    Note that elements added as closed subpaths using the
+    addEllipse(), addPath(), addPolygon(), addRect(), addRegion() and
+    addText() convenience functions, is actually added to the path as
+    a collection of separate elements using the moveTo(), lineTo() and
+    cubicTo() functions.
+
+    \value MoveToElement          A new subpath. See also moveTo().
+    \value LineToElement            A line. See also lineTo().
+    \value CurveToElement         A curve. See also cubicTo() and quadTo().
+    \value CurveToDataElement  The extra data required to describe a curve in
+                                               a CurveToElement element.
+
+    \sa elementAt(),  elementCount()
+*/
+
+/*!
+    \class QPainterPath::Element
+
+    \brief The QPainterPath::Element class specifies the position and
+    type of a subpath.
+
+    Once a QPainterPath object is constructed, subpaths like lines and
+    curves can be added to the path (creating
+    QPainterPath::LineToElement and QPainterPath::CurveToElement
+    components).
+
+    The lines and curves stretch from the currentPosition() to the
+    position passed as argument. The currentPosition() of the
+    QPainterPath object is always the end position of the last subpath
+    that was added (or the initial start point). The moveTo() function
+    can be used to move the currentPosition() without adding a line or
+    curve, creating a QPainterPath::MoveToElement component.
+
+    \sa QPainterPath
+*/
+
+/*!
+    \variable QPainterPath::Element::x
+    \brief the x coordinate of the element's position.
+
+    \sa {operator QPointF()}
+*/
+
+/*!
+    \variable QPainterPath::Element::y
+    \brief the y coordinate of the element's position.
+
+    \sa {operator QPointF()}
+*/
+
+/*!
+    \variable QPainterPath::Element::type
+    \brief the type of element
+
+    \sa isCurveTo(), isLineTo(), isMoveTo()
+*/
+
+/*!
+    \fn bool QPainterPath::Element::operator==(const Element &other) const
+    \since 4.2
+
+    Returns true if this element is equal to \a other;
+    otherwise returns false.
+
+    \sa operator!=()
+*/
+
+/*!
+    \fn bool QPainterPath::Element::operator!=(const Element &other) const
+    \since 4.2
+
+    Returns true if this element is not equal to \a other;
+    otherwise returns false.
+
+    \sa operator==()
+*/
+
+/*!
+    \fn bool QPainterPath::Element::isCurveTo () const
+
+    Returns true if the element is a curve, otherwise returns false.
+
+    \sa type, QPainterPath::CurveToElement
+*/
+
+/*!
+    \fn bool QPainterPath::Element::isLineTo () const
+
+    Returns true if the element is a line, otherwise returns false.
+
+    \sa type, QPainterPath::LineToElement
+*/
+
+/*!
+    \fn bool QPainterPath::Element::isMoveTo () const
+
+    Returns true if the element is moving the current position,
+    otherwise returns false.
+
+    \sa type, QPainterPath::MoveToElement
+*/
+
+/*!
+    \fn QPainterPath::Element::operator QPointF () const
+
+    Returns the element's position.
+
+    \sa x, y
+*/
+
+/*!
+    \fn void QPainterPath::addEllipse(qreal x, qreal y, qreal width, qreal height)
+    \overload
+
+    Creates an ellipse within the bounding rectangle defined by its top-left
+    corner at (\a x, \a y), \a width and \a height, and adds it to the
+    painter path as a closed subpath.
+*/
+
+/*!
+    \since 4.4
+
+    \fn void QPainterPath::addEllipse(const QPointF &center, qreal rx, qreal ry)
+    \overload
+
+    Creates an ellipse positioned at \a{center} with radii \a{rx} and \a{ry},
+    and adds it to the painter path as a closed subpath.
+*/
+
+/*!
+    \fn void QPainterPath::addText(qreal x, qreal y, const QFont &font, const QString &text)
+    \overload
+
+    Adds the given \a text to this path as a set of closed subpaths created
+    from the \a font supplied. The subpaths are positioned so that the left
+    end of the text's baseline lies at the point specified by (\a x, \a y).
+*/
+
+/*!
+    \fn int QPainterPath::elementCount() const
+
+    Returns the number of path elements in the painter path.
+
+    \sa ElementType, elementAt(), isEmpty()
+*/
+
+/*!
+    \fn const QPainterPath::Element &QPainterPath::elementAt(int index) const
+
+    Returns the element at the given \a index in the painter path.
+
+    \sa ElementType, elementCount(), isEmpty()
+*/
+
+/*!
+    \fn void QPainterPath::setElementPositionAt(int index, qreal x, qreal y)
+    \since 4.2
+
+    Sets the x and y coordinate of the element at index \a index to \a
+    x and \a y.
+*/
+
+/*###
+    \fn QPainterPath &QPainterPath::operator +=(const QPainterPath &other)
+
+    Appends the \a other painter path to this painter path and returns a
+    reference to the result.
+*/
+
+/*!
+    Constructs an empty QPainterPath object.
+*/
+QPainterPath::QPainterPath()
+    : d_ptr(0)
+{
+}
+
+/*!
+    \fn QPainterPath::QPainterPath(const QPainterPath &path)
+
+    Creates a QPainterPath object that is a copy of the given \a path.
+
+    \sa operator=()
+*/
+QPainterPath::QPainterPath(const QPainterPath &other)
+    : d_ptr(other.d_ptr.data())
+{
+    if (d_ptr)
+        d_ptr->ref.ref();
+}
+
+/*!
+    Creates a QPainterPath object with the given \a startPoint as its
+    current position.
+*/
+
+QPainterPath::QPainterPath(const QPointF &startPoint)
+    : d_ptr(new QPainterPathData)
+{
+    Element e = { startPoint.x(), startPoint.y(), MoveToElement };
+    d_func()->elements << e;
+}
+
+/*!
+    \internal
+*/
+void QPainterPath::detach_helper()
+{
+    QPainterPathPrivate *data = new QPainterPathData(*d_func());
+    d_ptr.reset(data);
+}
+
+/*!
+    \internal
+*/
+void QPainterPath::ensureData_helper()
+{
+    QPainterPathPrivate *data = new QPainterPathData;
+    data->elements.reserve(16);
+    QPainterPath::Element e = { 0, 0, QPainterPath::MoveToElement };
+    data->elements << e;
+    d_ptr.reset(data);
+    Q_ASSERT(d_ptr != 0);
+}
+
+/*!
+    \fn QPainterPath &QPainterPath::operator=(const QPainterPath &path)
+
+    Assigns the given \a path to this painter path.
+
+    \sa QPainterPath()
+*/
+QPainterPath &QPainterPath::operator=(const QPainterPath &other)
+{
+    if (other.d_func() != d_func()) {
+        QPainterPathPrivate *data = other.d_func();
+        if (data)
+            data->ref.ref();
+        d_ptr.reset(data);
+    }
+    return *this;
+}
+
+/*!
+    \fn void QPainterPath::swap(QPainterPath &other)
+    \since 4.8
+
+    Swaps painter path \a other with this painter path. This operation is very
+    fast and never fails.
+*/
+
+/*!
+    Destroys this QPainterPath object.
+*/
+QPainterPath::~QPainterPath()
+{
+}
+
+/*!
+    Closes the current subpath by drawing a line to the beginning of
+    the subpath, automatically starting a new path. The current point
+    of the new path is (0, 0).
+
+    If the subpath does not contain any elements, this function does
+    nothing.
+
+    \sa moveTo(), {QPainterPath#Composing a QPainterPath}{Composing
+    a QPainterPath}
+ */
+void QPainterPath::closeSubpath()
+{
+#ifdef QPP_DEBUG
+    printf("QPainterPath::closeSubpath()\n");
+#endif
+    if (isEmpty())
+        return;
+    detach();
+
+    d_func()->close();
+}
+
+/*!
+    \fn void QPainterPath::moveTo(qreal x, qreal y)
+
+    \overload
+
+    Moves the current position to (\a{x}, \a{y}) and starts a new
+    subpath, implicitly closing the previous path.
+*/
+
+/*!
+    \fn void QPainterPath::moveTo(const QPointF &point)
+
+    Moves the current point to the given \a point, implicitly starting
+    a new subpath and closing the previous one.
+
+    \sa closeSubpath(), {QPainterPath#Composing a
+    QPainterPath}{Composing a QPainterPath}
+*/
+void QPainterPath::moveTo(const QPointF &p)
+{
+#ifdef QPP_DEBUG
+    printf("QPainterPath::moveTo() (%.2f,%.2f)\n", p.x(), p.y());
+#endif
+
+    if (!qt_is_finite(p.x()) || !qt_is_finite(p.y())) {
+#ifndef QT_NO_DEBUG
+        qWarning("QPainterPath::moveTo: Adding point where x or y is NaN or Inf, ignoring call");
+#endif
+        return;
+    }
+
+    ensureData();
+    detach();
+
+    QPainterPathData *d = d_func();
+    Q_ASSERT(!d->elements.isEmpty());
+
+    d->require_moveTo = false;
+
+    if (d->elements.last().type == MoveToElement) {
+        d->elements.last().x = p.x();
+        d->elements.last().y = p.y();
+    } else {
+        Element elm = { p.x(), p.y(), MoveToElement };
+        d->elements.append(elm);
+    }
+    d->cStart = d->elements.size() - 1;
+}
+
+/*!
+    \fn void QPainterPath::lineTo(qreal x, qreal y)
+
+    \overload
+
+    Draws a line from the current position to the point (\a{x},
+    \a{y}).
+*/
+
+/*!
+    \fn void QPainterPath::lineTo(const QPointF &endPoint)
+
+    Adds a straight line from the current position to the given \a
+    endPoint.  After the line is drawn, the current position is updated
+    to be at the end point of the line.
+
+    \sa addPolygon(), addRect(), {QPainterPath#Composing a
+    QPainterPath}{Composing a QPainterPath}
+ */
+void QPainterPath::lineTo(const QPointF &p)
+{
+#ifdef QPP_DEBUG
+    printf("QPainterPath::lineTo() (%.2f,%.2f)\n", p.x(), p.y());
+#endif
+
+    if (!qt_is_finite(p.x()) || !qt_is_finite(p.y())) {
+#ifndef QT_NO_DEBUG
+        qWarning("QPainterPath::lineTo: Adding point where x or y is NaN or Inf, ignoring call");
+#endif
+        return;
+    }
+
+    ensureData();
+    detach();
+
+    QPainterPathData *d = d_func();
+    Q_ASSERT(!d->elements.isEmpty());
+    d->maybeMoveTo();
+    if (p == QPointF(d->elements.last()))
+        return;
+    Element elm = { p.x(), p.y(), LineToElement };
+    d->elements.append(elm);
+
+    d->convex = d->elements.size() == 3 || (d->elements.size() == 4 && d->isClosed());
+}
+
+/*!
+    \fn void QPainterPath::cubicTo(qreal c1X, qreal c1Y, qreal c2X,
+    qreal c2Y, qreal endPointX, qreal endPointY);
+
+    \overload
+
+    Adds a cubic Bezier curve between the current position and the end
+    point (\a{endPointX}, \a{endPointY}) with control points specified
+    by (\a{c1X}, \a{c1Y}) and (\a{c2X}, \a{c2Y}).
+*/
+
+/*!
+    \fn void QPainterPath::cubicTo(const QPointF &c1, const QPointF &c2, const QPointF &endPoint)
+
+    Adds a cubic Bezier curve between the current position and the
+    given \a endPoint using the control points specified by \a c1, and
+    \a c2.
+
+    After the curve is added, the current position is updated to be at
+    the end point of the curve.
+
+    \table 100%
+    \row
+    \o \inlineimage qpainterpath-cubicto.png
+    \o
+    \snippet doc/src/snippets/code/src_gui_painting_qpainterpath.cpp 1
+    \endtable
+
+    \sa quadTo(), {QPainterPath#Composing a QPainterPath}{Composing
+    a QPainterPath}
+*/
+void QPainterPath::cubicTo(const QPointF &c1, const QPointF &c2, const QPointF &e)
+{
+#ifdef QPP_DEBUG
+    printf("QPainterPath::cubicTo() (%.2f,%.2f), (%.2f,%.2f), (%.2f,%.2f)\n",
+           c1.x(), c1.y(), c2.x(), c2.y(), e.x(), e.y());
+#endif
+
+    if (!qt_is_finite(c1.x()) || !qt_is_finite(c1.y()) || !qt_is_finite(c2.x()) || !qt_is_finite(c2.y())
+        || !qt_is_finite(e.x()) || !qt_is_finite(e.y())) {
+#ifndef QT_NO_DEBUG
+        qWarning("QPainterPath::cubicTo: Adding point where x or y is NaN or Inf, ignoring call");
+#endif
+        return;
+    }
+
+    ensureData();
+    detach();
+
+    QPainterPathData *d = d_func();
+    Q_ASSERT(!d->elements.isEmpty());
+
+
+    // Abort on empty curve as a stroker cannot handle this and the
+    // curve is irrelevant anyway.
+    if (d->elements.last() == c1 && c1 == c2 && c2 == e)
+        return;
+
+    d->maybeMoveTo();
+
+    Element ce1 = { c1.x(), c1.y(), CurveToElement };
+    Element ce2 = { c2.x(), c2.y(), CurveToDataElement };
+    Element ee = { e.x(), e.y(), CurveToDataElement };
+    d->elements << ce1 << ce2 << ee;
+}
+
+/*!
+    \fn void QPainterPath::quadTo(qreal cx, qreal cy, qreal endPointX, qreal endPointY);
+
+    \overload
+
+    Adds a quadratic Bezier curve between the current point and the endpoint
+    (\a{endPointX}, \a{endPointY}) with the control point specified by
+    (\a{cx}, \a{cy}).
+*/
+
+/*!
+    \fn void QPainterPath::quadTo(const QPointF &c, const QPointF &endPoint)
+
+    Adds a quadratic Bezier curve between the current position and the
+    given \a endPoint with the control point specified by \a c.
+
+    After the curve is added, the current point is updated to be at
+    the end point of the curve.
+
+    \sa cubicTo(), {QPainterPath#Composing a QPainterPath}{Composing a
+    QPainterPath}
+*/
+void QPainterPath::quadTo(const QPointF &c, const QPointF &e)
+{
+#ifdef QPP_DEBUG
+    printf("QPainterPath::quadTo() (%.2f,%.2f), (%.2f,%.2f)\n",
+           c.x(), c.y(), e.x(), e.y());
+#endif
+
+    if (!qt_is_finite(c.x()) || !qt_is_finite(c.y()) || !qt_is_finite(e.x()) || !qt_is_finite(e.y())) {
+#ifndef QT_NO_DEBUG
+        qWarning("QPainterPath::quadTo: Adding point where x or y is NaN or Inf, ignoring call");
+#endif
+        return;
+    }
+
+    ensureData();
+    detach();
+
+    Q_D(QPainterPath);
+    Q_ASSERT(!d->elements.isEmpty());
+    const QPainterPath::Element &elm = d->elements.at(elementCount()-1);
+    QPointF prev(elm.x, elm.y);
+
+    // Abort on empty curve as a stroker cannot handle this and the
+    // curve is irrelevant anyway.
+    if (prev == c && c == e)
+        return;
+
+    QPointF c1((prev.x() + 2*c.x()) / 3, (prev.y() + 2*c.y()) / 3);
+    QPointF c2((e.x() + 2*c.x()) / 3, (e.y() + 2*c.y()) / 3);
+    cubicTo(c1, c2, e);
+}
+
+/*!
+    \fn void QPainterPath::arcTo(qreal x, qreal y, qreal width, qreal
+    height, qreal startAngle, qreal sweepLength)
+
+    \overload
+
+    Creates an arc that occupies the rectangle QRectF(\a x, \a y, \a
+    width, \a height), beginning at the specified \a startAngle and
+    extending \a sweepLength degrees counter-clockwise.
+
+*/
+
+/*!
+    \fn void QPainterPath::arcTo(const QRectF &rectangle, qreal startAngle, qreal sweepLength)
+
+    Creates an arc that occupies the given \a rectangle, beginning at
+    the specified \a startAngle and extending \a sweepLength degrees
+    counter-clockwise.
+
+    Angles are specified in degrees. Clockwise arcs can be specified
+    using negative angles.
+
+    Note that this function connects the starting point of the arc to
+    the current position if they are not already connected. After the
+    arc has been added, the current position is the last point in
+    arc. To draw a line back to the first point, use the
+    closeSubpath() function.
+
+    \table 100%
+    \row
+    \o \inlineimage qpainterpath-arcto.png
+    \o
+    \snippet doc/src/snippets/code/src_gui_painting_qpainterpath.cpp 2
+    \endtable
+
+    \sa arcMoveTo(), addEllipse(), QPainter::drawArc(), QPainter::drawPie(),
+    {QPainterPath#Composing a QPainterPath}{Composing a
+    QPainterPath}
+*/
+void QPainterPath::arcTo(const QRectF &rect, qreal startAngle, qreal sweepLength)
+{
+#ifdef QPP_DEBUG
+    printf("QPainterPath::arcTo() (%.2f, %.2f, %.2f, %.2f, angle=%.2f, sweep=%.2f\n",
+           rect.x(), rect.y(), rect.width(), rect.height(), startAngle, sweepLength);
+#endif
+
+    if ((!qt_is_finite(rect.x()) && !qt_is_finite(rect.y())) || !qt_is_finite(rect.width()) || !qt_is_finite(rect.height())
+        || !qt_is_finite(startAngle) || !qt_is_finite(sweepLength)) {
+#ifndef QT_NO_DEBUG
+        qWarning("QPainterPath::arcTo: Adding arc where a parameter is NaN or Inf, ignoring call");
+#endif
+        return;
+    }
+
+    if (rect.isNull())
+        return;
+
+    ensureData();
+    detach();
+
+    int point_count;
+    QPointF pts[15];
+    QPointF curve_start = qt_curves_for_arc(rect, startAngle, sweepLength, pts, &point_count);
+
+    lineTo(curve_start);
+    for (int i=0; i<point_count; i+=3) {
+        cubicTo(pts[i].x(), pts[i].y(),
+                pts[i+1].x(), pts[i+1].y(),
+                pts[i+2].x(), pts[i+2].y());
+    }
+
+}
+
+
+/*!
+    \fn void QPainterPath::arcMoveTo(qreal x, qreal y, qreal width, qreal height, qreal angle)
+    \overload
+    \since 4.2
+
+    Creates a move to that lies on the arc that occupies the
+    QRectF(\a x, \a y, \a width, \a height) at \a angle.
+*/
+
+
+/*!
+    \fn void QPainterPath::arcMoveTo(const QRectF &rectangle, qreal angle)
+    \since 4.2
+
+    Creates a move to that lies on the arc that occupies the given \a
+    rectangle at \a angle.
+
+    Angles are specified in degrees. Clockwise arcs can be specified
+    using negative angles.
+
+    \sa moveTo(), arcTo()
+*/
+
+void QPainterPath::arcMoveTo(const QRectF &rect, qreal angle)
+{
+    if (rect.isNull())
+        return;
+
+    QPointF pt;
+    qt_find_ellipse_coords(rect, angle, 0, &pt, 0);
+    moveTo(pt);
+}
+
+
+
+/*!
+    \fn QPointF QPainterPath::currentPosition() const
+
+    Returns the current position of the path.
+*/
+QPointF QPainterPath::currentPosition() const
+{
+    return !d_ptr || d_func()->elements.isEmpty()
+        ? QPointF()
+        : QPointF(d_func()->elements.last().x, d_func()->elements.last().y);
+}
+
+
+/*!
+    \fn void QPainterPath::addRect(qreal x, qreal y, qreal width, qreal height)
+
+    \overload
+
+    Adds a rectangle at position (\a{x}, \a{y}), with the given \a
+    width and \a height, as a closed subpath.
+*/
+
+/*!
+    \fn void QPainterPath::addRect(const QRectF &rectangle)
+
+    Adds the given \a rectangle to this path as a closed subpath.
+
+    The \a rectangle is added as a clockwise set of lines. The painter
+    path's current position after the \a rectangle has been added is
+    at the top-left corner of the rectangle.
+
+    \table 100%
+    \row
+    \o \inlineimage qpainterpath-addrectangle.png
+    \o
+    \snippet doc/src/snippets/code/src_gui_painting_qpainterpath.cpp 3
+    \endtable
+
+    \sa addRegion(), lineTo(), {QPainterPath#Composing a
+    QPainterPath}{Composing a QPainterPath}
+*/
+void QPainterPath::addRect(const QRectF &r)
+{
+    if (!qt_is_finite(r.x()) || !qt_is_finite(r.y()) || !qt_is_finite(r.width()) || !qt_is_finite(r.height())) {
+#ifndef QT_NO_DEBUG
+        qWarning("QPainterPath::addRect: Adding rect where a parameter is NaN or Inf, ignoring call");
+#endif
+        return;
+    }
+
+    if (r.isNull())
+        return;
+
+    ensureData();
+    detach();
+
+    bool first = d_func()->elements.size() < 2;
+
+    d_func()->elements.reserve(d_func()->elements.size() + 5);
+    moveTo(r.x(), r.y());
+
+    Element l1 = { r.x() + r.width(), r.y(), LineToElement };
+    Element l2 = { r.x() + r.width(), r.y() + r.height(), LineToElement };
+    Element l3 = { r.x(), r.y() + r.height(), LineToElement };
+    Element l4 = { r.x(), r.y(), LineToElement };
+
+    d_func()->elements << l1 << l2 << l3 << l4;
+    d_func()->require_moveTo = true;
+    d_func()->convex = first;
+}
+
+/*!
+    Adds the given \a polygon to the path as an (unclosed) subpath.
+
+    Note that the current position after the polygon has been added,
+    is the last point in \a polygon. To draw a line back to the first
+    point, use the closeSubpath() function.
+
+    \table 100%
+    \row
+    \o \inlineimage qpainterpath-addpolygon.png
+    \o
+    \snippet doc/src/snippets/code/src_gui_painting_qpainterpath.cpp 4
+    \endtable
+
+    \sa lineTo(), {QPainterPath#Composing a QPainterPath}{Composing
+    a QPainterPath}
+*/
+void QPainterPath::addPolygon(const QPolygonF &polygon)
+{
+    if (polygon.isEmpty())
+        return;
+
+    ensureData();
+    detach();
+
+    d_func()->elements.reserve(d_func()->elements.size() + polygon.size());
+
+    moveTo(polygon.first());
+    for (int i=1; i<polygon.size(); ++i) {
+        Element elm = { polygon.at(i).x(), polygon.at(i).y(), LineToElement };
+        d_func()->elements << elm;
+    }
+}
+
+/*!
+    \fn void QPainterPath::addEllipse(const QRectF &boundingRectangle)
+
+    Creates an ellipse within the specified \a boundingRectangle
+    and adds it to the painter path as a closed subpath.
+
+    The ellipse is composed of a clockwise curve, starting and
+    finishing at zero degrees (the 3 o'clock position).
+
+    \table 100%
+    \row
+    \o \inlineimage qpainterpath-addellipse.png
+    \o
+    \snippet doc/src/snippets/code/src_gui_painting_qpainterpath.cpp 5
+    \endtable
+
+    \sa arcTo(), QPainter::drawEllipse(), {QPainterPath#Composing a
+    QPainterPath}{Composing a QPainterPath}
+*/
+void QPainterPath::addEllipse(const QRectF &boundingRect)
+{
+    if (!qt_is_finite(boundingRect.x()) || !qt_is_finite(boundingRect.y())
+        || !qt_is_finite(boundingRect.width()) || !qt_is_finite(boundingRect.height())) {
+#ifndef QT_NO_DEBUG
+        qWarning("QPainterPath::addEllipse: Adding ellipse where a parameter is NaN or Inf, ignoring call");
+#endif
+        return;
+    }
+
+    if (boundingRect.isNull())
+        return;
+
+    ensureData();
+    detach();
+
+    Q_D(QPainterPath);
+    bool first = d_func()->elements.size() < 2;
+    d->elements.reserve(d->elements.size() + 13);
+
+    QPointF pts[12];
+    int point_count;
+    QPointF start = qt_curves_for_arc(boundingRect, 0, -360, pts, &point_count);
+
+    moveTo(start);
+    cubicTo(pts[0], pts[1], pts[2]);           // 0 -> 270
+    cubicTo(pts[3], pts[4], pts[5]);           // 270 -> 180
+    cubicTo(pts[6], pts[7], pts[8]);           // 180 -> 90
+    cubicTo(pts[9], pts[10], pts[11]);         // 90 - >0
+    d_func()->require_moveTo = true;
+
+    d_func()->convex = first;
+}
+
+/*!
+    \fn void QPainterPath::addText(const QPointF &point, const QFont &font, const QString &text)
+
+    Adds the given \a text to this path as a set of closed subpaths
+    created from the \a font supplied. The subpaths are positioned so
+    that the left end of the text's baseline lies at the specified \a
+    point.
+
+    \table 100%
+    \row
+    \o \inlineimage qpainterpath-addtext.png
+    \o
+    \snippet doc/src/snippets/code/src_gui_painting_qpainterpath.cpp 6
+    \endtable
+
+    \sa QPainter::drawText(), {QPainterPath#Composing a
+    QPainterPath}{Composing a QPainterPath}
+*/
+void QPainterPath::addText(const QPointF &point, const QFont &f, const QString &text)
+{
+    if (text.isEmpty())
+        return;
+
+    ensureData();
+    detach();
+
+    QTextLayout layout(text, f);
+    layout.setCacheEnabled(true);
+    QTextEngine *eng = layout.engine();
+    layout.beginLayout();
+    QTextLine line = layout.createLine();
+    layout.endLayout();
+    const QScriptLine &sl = eng->lines[0];
+    if (!sl.length || !eng->layoutData)
+        return;
+
+    int nItems = eng->layoutData->items.size();
+
+    qreal x(point.x());
+    qreal y(point.y());
+
+    QVarLengthArray<int> visualOrder(nItems);
+    QVarLengthArray<uchar> levels(nItems);
+    for (int i = 0; i < nItems; ++i)
+        levels[i] = eng->layoutData->items[i].analysis.bidiLevel;
+    QTextEngine::bidiReorder(nItems, levels.data(), visualOrder.data());
+
+    for (int i = 0; i < nItems; ++i) {
+        int item = visualOrder[i];
+        QScriptItem &si = eng->layoutData->items[item];
+
+        if (si.analysis.flags < QScriptAnalysis::TabOrObject) {
+            QGlyphLayout glyphs = eng->shapedGlyphs(&si);
+            QFontEngine *fe = f.d->engineForScript(si.analysis.script);
+            Q_ASSERT(fe);
+            fe->addOutlineToPath(x, y, glyphs, this,
+                                 si.analysis.bidiLevel % 2
+                                 ? QTextItem::RenderFlags(QTextItem::RightToLeft)
+                                 : QTextItem::RenderFlags(0));
+
+            const qreal lw = fe->lineThickness().toReal();
+            if (f.d->underline) {
+                qreal pos = fe->underlinePosition().toReal();
+                addRect(x, y + pos, si.width.toReal(), lw);
+            }
+            if (f.d->overline) {
+                qreal pos = fe->ascent().toReal() + 1;
+                addRect(x, y - pos, si.width.toReal(), lw);
+            }
+            if (f.d->strikeOut) {
+                qreal pos = fe->ascent().toReal() / 3;
+                addRect(x, y - pos, si.width.toReal(), lw);
+            }
+        }
+        x += si.width.toReal();
+    }
+}
+
+/*!
+    \fn void QPainterPath::addPath(const QPainterPath &path)
+
+    Adds the given \a path to \e this path as a closed subpath.
+
+    \sa connectPath(), {QPainterPath#Composing a
+    QPainterPath}{Composing a QPainterPath}
+*/
+void QPainterPath::addPath(const QPainterPath &other)
+{
+    if (other.isEmpty())
+        return;
+
+    ensureData();
+    detach();
+
+    QPainterPathData *d = reinterpret_cast<QPainterPathData *>(d_func());
+    // Remove last moveto so we don't get multiple moveto's
+    if (d->elements.last().type == MoveToElement)
+        d->elements.remove(d->elements.size()-1);
+
+    // Locate where our own current subpath will start after the other path is added.
+    int cStart = d->elements.size() + other.d_func()->cStart;
+    d->elements += other.d_func()->elements;
+    d->cStart = cStart;
+
+    d->require_moveTo = other.d_func()->isClosed();
+}
+
+
+/*!
+    \fn void QPainterPath::connectPath(const QPainterPath &path)
+
+    Connects the given \a path to \e this path by adding a line from the
+    last element of this path to the first element of the given path.
+
+    \sa addPath(), {QPainterPath#Composing a QPainterPath}{Composing
+    a QPainterPath}
+*/
+void QPainterPath::connectPath(const QPainterPath &other)
+{
+    if (other.isEmpty())
+        return;
+
+    ensureData();
+    detach();
+
+    QPainterPathData *d = reinterpret_cast<QPainterPathData *>(d_func());
+    // Remove last moveto so we don't get multiple moveto's
+    if (d->elements.last().type == MoveToElement)
+        d->elements.remove(d->elements.size()-1);
+
+    // Locate where our own current subpath will start after the other path is added.
+    int cStart = d->elements.size() + other.d_func()->cStart;
+    int first = d->elements.size();
+    d->elements += other.d_func()->elements;
+
+    if (first != 0)
+        d->elements[first].type = LineToElement;
+
+    // avoid duplicate points
+    if (first > 0 && QPointF(d->elements[first]) == QPointF(d->elements[first - 1])) {
+        d->elements.remove(first--);
+        --cStart;
+    }
+
+    if (cStart != first)
+        d->cStart = cStart;
+}
+
+/*!
+    Adds the given \a region to the path by adding each rectangle in
+    the region as a separate closed subpath.
+
+    \sa addRect(), {QPainterPath#Composing a QPainterPath}{Composing
+    a QPainterPath}
+*/
+void QPainterPath::addRegion(const QRegion &region)
+{
+    ensureData();
+    detach();
+
+    QVector<QRect> rects = region.rects();
+    d_func()->elements.reserve(rects.size() * 5);
+    for (int i=0; i<rects.size(); ++i)
+        addRect(rects.at(i));
+}
+
+
+/*!
+    Returns the painter path's currently set fill rule.
+
+    \sa setFillRule()
+*/
+Qt::FillRule QPainterPath::fillRule() const
+{
+    return isEmpty() ? Qt::OddEvenFill : d_func()->fillRule;
+}
+
+/*!
+    \fn void QPainterPath::setFillRule(Qt::FillRule fillRule)
+
+    Sets the fill rule of the painter path to the given \a
+    fillRule. Qt provides two methods for filling paths:
+
+    \table
+    \header
+    \o Qt::OddEvenFill (default)
+    \o Qt::WindingFill
+    \row
+    \o \inlineimage qt-fillrule-oddeven.png
+    \o \inlineimage qt-fillrule-winding.png
+    \endtable
+
+    \sa fillRule()
+*/
+void QPainterPath::setFillRule(Qt::FillRule fillRule)
+{
+    ensureData();
+    if (d_func()->fillRule == fillRule)
+        return;
+    detach();
+
+    d_func()->fillRule = fillRule;
+}
+
+#define QT_BEZIER_A(bezier, coord) 3 * (-bezier.coord##1 \
+                                        + 3*bezier.coord##2 \
+                                        - 3*bezier.coord##3 \
+                                        +bezier.coord##4)
+
+#define QT_BEZIER_B(bezier, coord) 6 * (bezier.coord##1 \
+                                        - 2*bezier.coord##2 \
+                                        + bezier.coord##3)
+
+#define QT_BEZIER_C(bezier, coord) 3 * (- bezier.coord##1 \
+                                        + bezier.coord##2)
+
+#define QT_BEZIER_CHECK_T(bezier, t) \
+    if (t >= 0 && t <= 1) { \
+        QPointF p(b.pointAt(t)); \
+        if (p.x() < minx) minx = p.x(); \
+        else if (p.x() > maxx) maxx = p.x(); \
+        if (p.y() < miny) miny = p.y(); \
+        else if (p.y() > maxy) maxy = p.y(); \
+    }
+
+
+static QRectF qt_painterpath_bezier_extrema(const QBezier &b)
+{
+    qreal minx, miny, maxx, maxy;
+
+    // initialize with end points
+    if (b.x1 < b.x4) {
+        minx = b.x1;
+        maxx = b.x4;
+    } else {
+        minx = b.x4;
+        maxx = b.x1;
+    }
+    if (b.y1 < b.y4) {
+        miny = b.y1;
+        maxy = b.y4;
+    } else {
+        miny = b.y4;
+        maxy = b.y1;
+    }
+
+    // Update for the X extrema
+    {
+        qreal ax = QT_BEZIER_A(b, x);
+        qreal bx = QT_BEZIER_B(b, x);
+        qreal cx = QT_BEZIER_C(b, x);
+        // specialcase quadratic curves to avoid div by zero
+        if (qFuzzyIsNull(ax)) {
+
+            // linear curves are covered by initialization.
+            if (!qFuzzyIsNull(bx)) {
+                qreal t = -cx / bx;
+                QT_BEZIER_CHECK_T(b, t);
+            }
+
+        } else {
+            const qreal tx = bx * bx - 4 * ax * cx;
+
+            if (tx >= 0) {
+                qreal temp = qSqrt(tx);
+                qreal rcp = 1 / (2 * ax);
+                qreal t1 = (-bx + temp) * rcp;
+                QT_BEZIER_CHECK_T(b, t1);
+
+                qreal t2 = (-bx - temp) * rcp;
+                QT_BEZIER_CHECK_T(b, t2);
+            }
+        }
+    }
+
+    // Update for the Y extrema
+    {
+        qreal ay = QT_BEZIER_A(b, y);
+        qreal by = QT_BEZIER_B(b, y);
+        qreal cy = QT_BEZIER_C(b, y);
+
+        // specialcase quadratic curves to avoid div by zero
+        if (qFuzzyIsNull(ay)) {
+
+            // linear curves are covered by initialization.
+            if (!qFuzzyIsNull(by)) {
+                qreal t = -cy / by;
+                QT_BEZIER_CHECK_T(b, t);
+            }
+
+        } else {
+            const qreal ty = by * by - 4 * ay * cy;
+
+            if (ty > 0) {
+                qreal temp = qSqrt(ty);
+                qreal rcp = 1 / (2 * ay);
+                qreal t1 = (-by + temp) * rcp;
+                QT_BEZIER_CHECK_T(b, t1);
+
+                qreal t2 = (-by - temp) * rcp;
+                QT_BEZIER_CHECK_T(b, t2);
+            }
+        }
+    }
+    return QRectF(minx, miny, maxx - minx, maxy - miny);
+}
+
+/*!
+    Returns the bounding rectangle of this painter path as a rectangle with
+    floating point precision.
+
+    \sa controlPointRect()
+*/
+QRectF QPainterPath::boundingRect() const
+{
+    if (!d_ptr)
+        return QRectF();
+    QPainterPathData *d = d_func();
+
+    if (d->dirtyBounds)
+        computeBoundingRect();
+    return d->bounds;
+}
+
+/*!
+    Returns the rectangle containing all the points and control points
+    in this path.
+
+    This function is significantly faster to compute than the exact
+    boundingRect(), and the returned rectangle is always a superset of
+    the rectangle returned by boundingRect().
+
+    \sa boundingRect()
+*/
+QRectF QPainterPath::controlPointRect() const
+{
+    if (!d_ptr)
+        return QRectF();
+    QPainterPathData *d = d_func();
+
+    if (d->dirtyControlBounds)
+        computeControlPointRect();
+    return d->controlBounds;
+}
+
+
+/*!
+    \fn bool QPainterPath::isEmpty() const
+
+    Returns true if either there are no elements in this path, or if the only
+    element is a MoveToElement; otherwise returns false.
+
+    \sa elementCount()
+*/
+
+/*!
+    Creates and returns a reversed copy of the path.
+
+    It is the order of the elements that is reversed: If a
+    QPainterPath is composed by calling the moveTo(), lineTo() and
+    cubicTo() functions in the specified order, the reversed copy is
+    composed by calling cubicTo(), lineTo() and moveTo().
+*/
+QPainterPath QPainterPath::toReversed() const
+{
+    Q_D(const QPainterPath);
+    QPainterPath rev;
+
+    if (isEmpty()) {
+        rev = *this;
+        return rev;
+    }
+
+    rev.moveTo(d->elements.at(d->elements.size()-1).x, d->elements.at(d->elements.size()-1).y);
+
+    for (int i=d->elements.size()-1; i>=1; --i) {
+        const QPainterPath::Element &elm = d->elements.at(i);
+        const QPainterPath::Element &prev = d->elements.at(i-1);
+        switch (elm.type) {
+        case LineToElement:
+            rev.lineTo(prev.x, prev.y);
+            break;
+        case MoveToElement:
+            rev.moveTo(prev.x, prev.y);
+            break;
+        case CurveToDataElement:
+            {
+                Q_ASSERT(i>=3);
+                const QPainterPath::Element &cp1 = d->elements.at(i-2);
+                const QPainterPath::Element &sp = d->elements.at(i-3);
+                Q_ASSERT(prev.type == CurveToDataElement);
+                Q_ASSERT(cp1.type == CurveToElement);
+                rev.cubicTo(prev.x, prev.y, cp1.x, cp1.y, sp.x, sp.y);
+                i -= 2;
+                break;
+            }
+        default:
+            Q_ASSERT(!"qt_reversed_path");
+            break;
+        }
+    }
+    //qt_debug_path(rev);
+    return rev;
+}
+
+/*!
+    Converts the path into a list of polygons using the QTransform
+    \a matrix, and returns the list.
+
+    This function creates one polygon for each subpath regardless of
+    intersecting subpaths (i.e. overlapping bounding rectangles). To
+    make sure that such overlapping subpaths are filled correctly, use
+    the toFillPolygons() function instead.
+
+    \sa toFillPolygons(), toFillPolygon(), {QPainterPath#QPainterPath
+    Conversion}{QPainterPath Conversion}
+*/
+QList<QPolygonF> QPainterPath::toSubpathPolygons(const QTransform &matrix) const
+{
+
+    Q_D(const QPainterPath);
+    QList<QPolygonF> flatCurves;
+    if (isEmpty())
+        return flatCurves;
+
+    QPolygonF current;
+    for (int i=0; i<elementCount(); ++i) {
+        const QPainterPath::Element &e = d->elements.at(i);
+        switch (e.type) {
+        case QPainterPath::MoveToElement:
+            if (current.size() > 1)
+                flatCurves += current;
+            current.clear();
+            current.reserve(16);
+            current += QPointF(e.x, e.y) * matrix;
+            break;
+        case QPainterPath::LineToElement:
+            current += QPointF(e.x, e.y) * matrix;
+            break;
+        case QPainterPath::CurveToElement: {
+            Q_ASSERT(d->elements.at(i+1).type == QPainterPath::CurveToDataElement);
+            Q_ASSERT(d->elements.at(i+2).type == QPainterPath::CurveToDataElement);
+            QBezier bezier = QBezier::fromPoints(QPointF(d->elements.at(i-1).x, d->elements.at(i-1).y) * matrix,
+                                       QPointF(e.x, e.y) * matrix,
+                                       QPointF(d->elements.at(i+1).x, d->elements.at(i+1).y) * matrix,
+                                                 QPointF(d->elements.at(i+2).x, d->elements.at(i+2).y) * matrix);
+            bezier.addToPolygon(&current);
+            i+=2;
+            break;
+        }
+        case QPainterPath::CurveToDataElement:
+            Q_ASSERT(!"QPainterPath::toSubpathPolygons(), bad element type");
+            break;
+        }
+    }
+
+    if (current.size()>1)
+        flatCurves += current;
+
+    return flatCurves;
+}
+
+/*!
+  \overload
+ */
+QList<QPolygonF> QPainterPath::toSubpathPolygons(const QMatrix &matrix) const
+{
+    return toSubpathPolygons(QTransform(matrix));
+}
+
+/*!
+    Converts the path into a list of polygons using the
+    QTransform \a matrix, and returns the list.
+
+    The function differs from the toFillPolygon() function in that it
+    creates several polygons. It is provided because it is usually
+    faster to draw several small polygons than to draw one large
+    polygon, even though the total number of points drawn is the same.
+
+    The toFillPolygons() function differs from the toSubpathPolygons()
+    function in that it create only polygon for subpaths that have
+    overlapping bounding rectangles.
+
+    Like the toFillPolygon() function, this function uses a rewinding
+    technique to make sure that overlapping subpaths can be filled
+    using the correct fill rule. Note that rewinding inserts addition
+    lines in the polygons so the outline of the fill polygon does not
+    match the outline of the path.
+
+    \sa toSubpathPolygons(), toFillPolygon(),
+    {QPainterPath#QPainterPath Conversion}{QPainterPath Conversion}
+*/
+QList<QPolygonF> QPainterPath::toFillPolygons(const QTransform &matrix) const
+{
+
+    QList<QPolygonF> polys;
+
+    QList<QPolygonF> subpaths = toSubpathPolygons(matrix);
+    int count = subpaths.size();
+
+    if (count == 0)
+        return polys;
+
+    QList<QRectF> bounds;
+    for (int i=0; i<count; ++i)
+        bounds += subpaths.at(i).boundingRect();
+
+#ifdef QPP_FILLPOLYGONS_DEBUG
+    printf("QPainterPath::toFillPolygons, subpathCount=%d\n", count);
+    for (int i=0; i<bounds.size(); ++i)
+        qDebug() << " bounds" << i << bounds.at(i);
+#endif
+
+    QVector< QList<int> > isects;
+    isects.resize(count);
+
+    // find all intersections
+    for (int j=0; j<count; ++j) {
+        if (subpaths.at(j).size() <= 2)
+            continue;
+        QRectF cbounds = bounds.at(j);
+        for (int i=0; i<count; ++i) {
+            if (cbounds.intersects(bounds.at(i))) {
+                isects[j] << i;
+            }
+        }
+    }
+
+#ifdef QPP_FILLPOLYGONS_DEBUG
+    printf("Intersections before flattening:\n");
+    for (int i = 0; i < count; ++i) {
+        printf("%d: ", i);
+        for (int j = 0; j < isects[i].size(); ++j) {
+            printf("%d ", isects[i][j]);
+        }
+        printf("\n");
+    }
+#endif
+
+    // flatten the sets of intersections
+    for (int i=0; i<count; ++i) {
+        const QList<int> &current_isects = isects.at(i);
+        for (int j=0; j<current_isects.size(); ++j) {
+            int isect_j = current_isects.at(j);
+            if (isect_j == i)
+                continue;
+            for (int k=0; k<isects[isect_j].size(); ++k) {
+                int isect_k = isects[isect_j][k];
+                if (isect_k != i && !isects.at(i).contains(isect_k)) {
+                    isects[i] += isect_k;
+                }
+            }
+            isects[isect_j].clear();
+        }
+    }
+
+#ifdef QPP_FILLPOLYGONS_DEBUG
+    printf("Intersections after flattening:\n");
+    for (int i = 0; i < count; ++i) {
+        printf("%d: ", i);
+        for (int j = 0; j < isects[i].size(); ++j) {
+            printf("%d ", isects[i][j]);
+        }
+        printf("\n");
+    }
+#endif
+
+    // Join the intersected subpaths as rewinded polygons
+    for (int i=0; i<count; ++i) {
+        const QList<int> &subpath_list = isects[i];
+        if (!subpath_list.isEmpty()) {
+            QPolygonF buildUp;
+            for (int j=0; j<subpath_list.size(); ++j) {
+                const QPolygonF &subpath = subpaths.at(subpath_list.at(j));
+                buildUp += subpath;
+                if (!subpath.isClosed())
+                    buildUp += subpath.first();
+                if (!buildUp.isClosed())
+                    buildUp += buildUp.first();
+            }
+            polys += buildUp;
+        }
+    }
+
+    return polys;
+}
+
+/*!
+  \overload
+ */
+QList<QPolygonF> QPainterPath::toFillPolygons(const QMatrix &matrix) const
+{
+    return toFillPolygons(QTransform(matrix));
+}
+
+//same as qt_polygon_isect_line in qpolygon.cpp
+static void qt_painterpath_isect_line(const QPointF &p1,
+				      const QPointF &p2,
+				      const QPointF &pos,
+                                      int *winding)
+{
+    qreal x1 = p1.x();
+    qreal y1 = p1.y();
+    qreal x2 = p2.x();
+    qreal y2 = p2.y();
+    qreal y = pos.y();
+
+    int dir = 1;
+
+    if (qFuzzyCompare(y1, y2)) {
+        // ignore horizontal lines according to scan conversion rule
+        return;
+    } else if (y2 < y1) {
+        qreal x_tmp = x2; x2 = x1; x1 = x_tmp;
+        qreal y_tmp = y2; y2 = y1; y1 = y_tmp;
+        dir = -1;
+    }
+
+    if (y >= y1 && y < y2) {
+        qreal x = x1 + ((x2 - x1) / (y2 - y1)) * (y - y1);
+
+        // count up the winding number if we're
+        if (x<=pos.x()) {
+            (*winding) += dir;
+        }
+    }
+}
+
+static void qt_painterpath_isect_curve(const QBezier &bezier, const QPointF &pt,
+                                       int *winding, int depth = 0)
+{
+    qreal y = pt.y();
+    qreal x = pt.x();
+    QRectF bounds = bezier.bounds();
+
+    // potential intersection, divide and try again...
+    // Please note that a sideeffect of the bottom exclusion is that
+    // horizontal lines are dropped, but this is correct according to
+    // scan conversion rules.
+    if (y >= bounds.y() && y < bounds.y() + bounds.height()) {
+
+        // hit lower limit... This is a rough threshold, but its a
+        // tradeoff between speed and precision.
+        const qreal lower_bound = qreal(.001);
+        if (depth == 32 || (bounds.width() < lower_bound && bounds.height() < lower_bound)) {
+            // We make the assumption here that the curve starts to
+            // approximate a line after while (i.e. that it doesn't
+            // change direction drastically during its slope)
+            if (bezier.pt1().x() <= x) {
+                (*winding) += (bezier.pt4().y() > bezier.pt1().y() ? 1 : -1);
+            }
+            return;
+        }
+
+        // split curve and try again...
+        QBezier first_half, second_half;
+        bezier.split(&first_half, &second_half);
+        qt_painterpath_isect_curve(first_half, pt, winding, depth + 1);
+        qt_painterpath_isect_curve(second_half, pt, winding, depth + 1);
+    }
+}
+
+/*!
+    \fn bool QPainterPath::contains(const QPointF &point) const
+
+    Returns true if the given \a point is inside the path, otherwise
+    returns false.
+
+    \sa intersects()
+*/
+bool QPainterPath::contains(const QPointF &pt) const
+{
+    if (isEmpty() || !controlPointRect().contains(pt))
+        return false;
+
+    QPainterPathData *d = d_func();
+
+    int winding_number = 0;
+
+    QPointF last_pt;
+    QPointF last_start;
+    for (int i=0; i<d->elements.size(); ++i) {
+        const Element &e = d->elements.at(i);
+
+        switch (e.type) {
+
+        case MoveToElement:
+            if (i > 0) // implicitly close all paths.
+                qt_painterpath_isect_line(last_pt, last_start, pt, &winding_number);
+            last_start = last_pt = e;
+            break;
+
+        case LineToElement:
+            qt_painterpath_isect_line(last_pt, e, pt, &winding_number);
+            last_pt = e;
+            break;
+
+        case CurveToElement:
+            {
+                const QPainterPath::Element &cp2 = d->elements.at(++i);
+                const QPainterPath::Element &ep = d->elements.at(++i);
+                qt_painterpath_isect_curve(QBezier::fromPoints(last_pt, e, cp2, ep),
+                                           pt, &winding_number);
+                last_pt = ep;
+
+            }
+            break;
+
+        default:
+            break;
+        }
+    }
+
+    // implicitly close last subpath
+    if (last_pt != last_start)
+        qt_painterpath_isect_line(last_pt, last_start, pt, &winding_number);
+
+    return (d->fillRule == Qt::WindingFill
+            ? (winding_number != 0)
+            : ((winding_number % 2) != 0));
+}
+
+static bool qt_painterpath_isect_line_rect(qreal x1, qreal y1, qreal x2, qreal y2,
+                                           const QRectF &rect)
+{
+    qreal left = rect.left();
+    qreal right = rect.right();
+    qreal top = rect.top();
+    qreal bottom = rect.bottom();
+
+    enum { Left, Right, Top, Bottom };
+    // clip the lines, after cohen-sutherland, see e.g. http://www.nondot.org/~sabre/graphpro/line6.html
+    int p1 = ((x1 < left) << Left)
+             | ((x1 > right) << Right)
+             | ((y1 < top) << Top)
+             | ((y1 > bottom) << Bottom);
+    int p2 = ((x2 < left) << Left)
+             | ((x2 > right) << Right)
+             | ((y2 < top) << Top)
+             | ((y2 > bottom) << Bottom);
+
+    if (p1 & p2)
+        // completely inside
+        return false;
+
+    if (p1 | p2) {
+        qreal dx = x2 - x1;
+        qreal dy = y2 - y1;
+
+        // clip x coordinates
+        if (x1 < left) {
+            y1 += dy/dx * (left - x1);
+            x1 = left;
+        } else if (x1 > right) {
+            y1 -= dy/dx * (x1 - right);
+            x1 = right;
+        }
+        if (x2 < left) {
+            y2 += dy/dx * (left - x2);
+            x2 = left;
+        } else if (x2 > right) {
+            y2 -= dy/dx * (x2 - right);
+            x2 = right;
+        }
+
+        p1 = ((y1 < top) << Top)
+             | ((y1 > bottom) << Bottom);
+        p2 = ((y2 < top) << Top)
+             | ((y2 > bottom) << Bottom);
+
+        if (p1 & p2)
+            return false;
+
+        // clip y coordinates
+        if (y1 < top) {
+            x1 += dx/dy * (top - y1);
+            y1 = top;
+        } else if (y1 > bottom) {
+            x1 -= dx/dy * (y1 - bottom);
+            y1 = bottom;
+        }
+        if (y2 < top) {
+            x2 += dx/dy * (top - y2);
+            y2 = top;
+        } else if (y2 > bottom) {
+            x2 -= dx/dy * (y2 - bottom);
+            y2 = bottom;
+        }
+
+        p1 = ((x1 < left) << Left)
+             | ((x1 > right) << Right);
+        p2 = ((x2 < left) << Left)
+             | ((x2 > right) << Right);
+
+        if (p1 & p2)
+            return false;
+
+        return true;
+    }
+    return false;
+}
+
+static bool qt_isect_curve_horizontal(const QBezier &bezier, qreal y, qreal x1, qreal x2, int depth = 0)
+{
+    QRectF bounds = bezier.bounds();
+
+    if (y >= bounds.top() && y < bounds.bottom()
+        && bounds.right() >= x1 && bounds.left() < x2) {
+        const qreal lower_bound = qreal(.01);
+        if (depth == 32 || (bounds.width() < lower_bound && bounds.height() < lower_bound))
+            return true;
+
+        QBezier first_half, second_half;
+        bezier.split(&first_half, &second_half);
+        if (qt_isect_curve_horizontal(first_half, y, x1, x2, depth + 1)
+            || qt_isect_curve_horizontal(second_half, y, x1, x2, depth + 1))
+            return true;
+    }
+    return false;
+}
+
+static bool qt_isect_curve_vertical(const QBezier &bezier, qreal x, qreal y1, qreal y2, int depth = 0)
+{
+    QRectF bounds = bezier.bounds();
+
+    if (x >= bounds.left() && x < bounds.right()
+        && bounds.bottom() >= y1 && bounds.top() < y2) {
+        const qreal lower_bound = qreal(.01);
+        if (depth == 32 || (bounds.width() < lower_bound && bounds.height() < lower_bound))
+            return true;
+
+        QBezier first_half, second_half;
+        bezier.split(&first_half, &second_half);
+        if (qt_isect_curve_vertical(first_half, x, y1, y2, depth + 1)
+            || qt_isect_curve_vertical(second_half, x, y1, y2, depth + 1))
+            return true;
+    }
+     return false;
+}
+
+/*
+    Returns true if any lines or curves cross the four edges in of rect
+*/
+static bool qt_painterpath_check_crossing(const QPainterPath *path, const QRectF &rect)
+{
+    QPointF last_pt;
+    QPointF last_start;
+    for (int i=0; i<path->elementCount(); ++i) {
+        const QPainterPath::Element &e = path->elementAt(i);
+
+        switch (e.type) {
+
+        case QPainterPath::MoveToElement:
+            if (i > 0
+                && qFuzzyCompare(last_pt.x(), last_start.x())
+                && qFuzzyCompare(last_pt.y(), last_start.y())
+                && qt_painterpath_isect_line_rect(last_pt.x(), last_pt.y(),
+                                                  last_start.x(), last_start.y(), rect))
+                return true;
+            last_start = last_pt = e;
+            break;
+
+        case QPainterPath::LineToElement:
+            if (qt_painterpath_isect_line_rect(last_pt.x(), last_pt.y(), e.x, e.y, rect))
+                return true;
+            last_pt = e;
+            break;
+
+        case QPainterPath::CurveToElement:
+            {
+                QPointF cp2 = path->elementAt(++i);
+                QPointF ep = path->elementAt(++i);
+                QBezier bezier = QBezier::fromPoints(last_pt, e, cp2, ep);
+                if (qt_isect_curve_horizontal(bezier, rect.top(), rect.left(), rect.right())
+                    || qt_isect_curve_horizontal(bezier, rect.bottom(), rect.left(), rect.right())
+                    || qt_isect_curve_vertical(bezier, rect.left(), rect.top(), rect.bottom())
+                    || qt_isect_curve_vertical(bezier, rect.right(), rect.top(), rect.bottom()))
+                    return true;
+                last_pt = ep;
+            }
+            break;
+
+        default:
+            break;
+        }
+    }
+
+    // implicitly close last subpath
+    if (last_pt != last_start
+        && qt_painterpath_isect_line_rect(last_pt.x(), last_pt.y(),
+                                          last_start.x(), last_start.y(), rect))
+        return true;
+
+    return false;
+}
+
+/*!
+    \fn bool QPainterPath::intersects(const QRectF &rectangle) const
+
+    Returns true if any point in the given \a rectangle intersects the
+    path; otherwise returns false.
+
+    There is an intersection if any of the lines making up the
+    rectangle crosses a part of the path or if any part of the
+    rectangle overlaps with any area enclosed by the path. This
+    function respects the current fillRule to determine what is
+    considered inside the path.
+
+    \sa contains()
+*/
+bool QPainterPath::intersects(const QRectF &rect) const
+{
+    if (elementCount() == 1 && rect.contains(elementAt(0)))
+        return true;
+
+    if (isEmpty())
+        return false;
+
+    QRectF cp = controlPointRect();
+    QRectF rn = rect.normalized();
+
+    // QRectF::intersects returns false if one of the rects is a null rect
+    // which would happen for a painter path consisting of a vertical or
+    // horizontal line
+    if (qMax(rn.left(), cp.left()) > qMin(rn.right(), cp.right())
+        || qMax(rn.top(), cp.top()) > qMin(rn.bottom(), cp.bottom()))
+        return false;
+
+    // If any path element cross the rect its bound to be an intersection
+    if (qt_painterpath_check_crossing(this, rect))
+        return true;
+
+    if (contains(rect.center()))
+        return true;
+
+    Q_D(QPainterPath);
+
+    // Check if the rectangle surounds any subpath...
+    for (int i=0; i<d->elements.size(); ++i) {
+        const Element &e = d->elements.at(i);
+        if (e.type == QPainterPath::MoveToElement && rect.contains(e))
+            return true;
+    }
+
+    return false;
+}
+
+/*!
+    Translates all elements in the path by (\a{dx}, \a{dy}).
+
+    \since 4.6
+    \sa translated()
+*/
+void QPainterPath::translate(qreal dx, qreal dy)
+{
+    if (!d_ptr || (dx == 0 && dy == 0))
+        return;
+
+    int elementsLeft = d_ptr->elements.size();
+    if (elementsLeft <= 0)
+        return;
+
+    detach();
+    QPainterPath::Element *element = d_func()->elements.data();
+    Q_ASSERT(element);
+    while (elementsLeft--) {
+        element->x += dx;
+        element->y += dy;
+        ++element;
+    }
+}
+
+/*!
+    \fn void QPainterPath::translate(const QPointF &offset)
+    \overload
+    \since 4.6
+
+    Translates all elements in the path by the given \a offset.
+
+    \sa translated()
+*/
+
+/*!
+    Returns a copy of the path that is translated by (\a{dx}, \a{dy}).
+
+    \since 4.6
+    \sa translate()
+*/
+QPainterPath QPainterPath::translated(qreal dx, qreal dy) const
+{
+    QPainterPath copy(*this);
+    copy.translate(dx, dy);
+    return copy;
+}
+
+/*!
+    \fn QPainterPath QPainterPath::translated(const QPointF &offset) const;
+    \overload
+    \since 4.6
+
+    Returns a copy of the path that is translated by the given \a offset.
+
+    \sa translate()
+*/
+
+/*!
+    \fn bool QPainterPath::contains(const QRectF &rectangle) const
+
+    Returns true if the given \a rectangle is inside the path,
+    otherwise returns false.
+*/
+bool QPainterPath::contains(const QRectF &rect) const
+{
+    Q_D(QPainterPath);
+
+    // the path is empty or the control point rect doesn't completely
+    // cover the rectangle we abort stratight away.
+    if (isEmpty() || !controlPointRect().contains(rect))
+        return false;
+
+    // if there are intersections, chances are that the rect is not
+    // contained, except if we have winding rule, in which case it
+    // still might.
+    if (qt_painterpath_check_crossing(this, rect)) {
+        if (fillRule() == Qt::OddEvenFill) {
+            return false;
+        } else {
+            // Do some wague sampling in the winding case. This is not
+            // precise but it should mostly be good enough.
+            if (!contains(rect.topLeft()) ||
+                !contains(rect.topRight()) ||
+                !contains(rect.bottomRight()) ||
+                !contains(rect.bottomLeft()))
+                return false;
+        }
+    }
+
+    // If there exists a point inside that is not part of the path its
+    // because: rectangle lies completely outside path or a subpath
+    // excludes parts of the rectangle. Both cases mean that the rect
+    // is not contained
+    if (!contains(rect.center()))
+        return false;
+
+    // If there are any subpaths inside this rectangle we need to
+    // check if they are still contained as a result of the fill
+    // rule. This can only be the case for WindingFill though. For
+    // OddEvenFill the rect will never be contained if it surrounds a
+    // subpath. (the case where two subpaths are completely identical
+    // can be argued but we choose to neglect it).
+    for (int i=0; i<d->elements.size(); ++i) {
+        const Element &e = d->elements.at(i);
+        if (e.type == QPainterPath::MoveToElement && rect.contains(e)) {
+            if (fillRule() == Qt::OddEvenFill)
+                return false;
+
+            bool stop = false;
+            for (; !stop && i<d->elements.size(); ++i) {
+                const Element &el = d->elements.at(i);
+                switch (el.type) {
+                case MoveToElement:
+                    stop = true;
+                    break;
+                case LineToElement:
+                    if (!contains(el))
+                        return false;
+                    break;
+                case CurveToElement:
+                    if (!contains(d->elements.at(i+2)))
+                        return false;
+                    i += 2;
+                    break;
+                default:
+                    break;
+                }
+            }
+
+            // compensate for the last ++i in the inner for
+            --i;
+        }
+    }
+
+    return true;
+}
+
+static inline bool epsilonCompare(const QPointF &a, const QPointF &b, const QSizeF &epsilon)
+{
+    return qAbs(a.x() - b.x()) <= epsilon.width()
+        && qAbs(a.y() - b.y()) <= epsilon.height();
+}
+
+/*!
+    Returns true if this painterpath is equal to the given \a path.
+
+    Note that comparing paths may involve a per element comparison
+    which can be slow for complex paths.
+
+    \sa operator!=()
+*/
+
+bool QPainterPath::operator==(const QPainterPath &path) const
+{
+    QPainterPathData *d = reinterpret_cast<QPainterPathData *>(d_func());
+    if (path.d_func() == d)
+        return true;
+    else if (!d || !path.d_func())
+        return false;
+    else if (d->fillRule != path.d_func()->fillRule)
+        return false;
+    else if (d->elements.size() != path.d_func()->elements.size())
+        return false;
+
+    const qreal qt_epsilon = sizeof(qreal) == sizeof(double) ? 1e-12 : qreal(1e-5);
+
+    QSizeF epsilon = boundingRect().size();
+    epsilon.rwidth() *= qt_epsilon;
+    epsilon.rheight() *= qt_epsilon;
+
+    for (int i = 0; i < d->elements.size(); ++i)
+        if (d->elements.at(i).type != path.d_func()->elements.at(i).type
+            || !epsilonCompare(d->elements.at(i), path.d_func()->elements.at(i), epsilon))
+            return false;
+
+    return true;
+}
+
+/*!
+    Returns true if this painter path differs from the given \a path.
+
+    Note that comparing paths may involve a per element comparison
+    which can be slow for complex paths.
+
+    \sa operator==()
+*/
+
+bool QPainterPath::operator!=(const QPainterPath &path) const
+{
+    return !(*this==path);
+}
+
+/*!
+    \since 4.5
+
+    Returns the intersection of this path and the \a other path.
+
+    \sa intersected(), operator&=(), united(), operator|()
+*/
+QPainterPath QPainterPath::operator&(const QPainterPath &other) const
+{
+    return intersected(other);
+}
+
+/*!
+    \since 4.5
+
+    Returns the union of this path and the \a other path.
+
+    \sa united(), operator|=(), intersected(), operator&()
+*/
+QPainterPath QPainterPath::operator|(const QPainterPath &other) const
+{
+    return united(other);
+}
+
+/*!
+    \since 4.5
+
+    Returns the union of this path and the \a other path. This function is equivalent
+    to operator|().
+
+    \sa united(), operator+=(), operator-()
+*/
+QPainterPath QPainterPath::operator+(const QPainterPath &other) const
+{
+    return united(other);
+}
+
+/*!
+    \since 4.5
+
+    Subtracts the \a other path from a copy of this path, and returns the copy.
+
+    \sa subtracted(), operator-=(), operator+()
+*/
+QPainterPath QPainterPath::operator-(const QPainterPath &other) const
+{
+    return subtracted(other);
+}
+
+/*!
+    \since 4.5
+
+    Intersects this path with \a other and returns a reference to this path.
+
+    \sa intersected(), operator&(), operator|=()
+*/
+QPainterPath &QPainterPath::operator&=(const QPainterPath &other)
+{
+    return *this = (*this & other);
+}
+
+/*!
+    \since 4.5
+
+    Unites this path with \a other and returns a reference to this path.
+
+    \sa united(), operator|(), operator&=()
+*/
+QPainterPath &QPainterPath::operator|=(const QPainterPath &other)
+{
+    return *this = (*this | other);
+}
+
+/*!
+    \since 4.5
+
+    Unites this path with \a other, and returns a reference to this path. This
+    is equivalent to operator|=().
+
+    \sa united(), operator+(), operator-=()
+*/
+QPainterPath &QPainterPath::operator+=(const QPainterPath &other)
+{
+    return *this = (*this + other);
+}
+
+/*!
+    \since 4.5
+
+    Subtracts \a other from this path, and returns a reference to this
+    path.
+
+    \sa subtracted(), operator-(), operator+=()
+*/
+QPainterPath &QPainterPath::operator-=(const QPainterPath &other)
+{
+    return *this = (*this - other);
+}
+
+#ifndef QT_NO_DATASTREAM
+/*!
+    \fn QDataStream &operator<<(QDataStream &stream, const QPainterPath &path)
+    \relates QPainterPath
+
+    Writes the given painter \a path to the given \a stream, and
+    returns a reference to the \a stream.
+
+    \sa {Serializing Qt Data Types}
+*/
+QDataStream &operator<<(QDataStream &s, const QPainterPath &p)
+{
+    if (p.isEmpty()) {
+        s << 0;
+        return s;
+    }
+
+    s << p.elementCount();
+    for (int i=0; i < p.d_func()->elements.size(); ++i) {
+        const QPainterPath::Element &e = p.d_func()->elements.at(i);
+        s << int(e.type);
+        s << double(e.x) << double(e.y);
+    }
+    s << p.d_func()->cStart;
+    s << int(p.d_func()->fillRule);
+    return s;
+}
+
+/*!
+    \fn QDataStream &operator>>(QDataStream &stream, QPainterPath &path)
+    \relates QPainterPath
+
+    Reads a painter path from the given \a stream into the specified \a path,
+    and returns a reference to the \a stream.
+
+    \sa {Serializing Qt Data Types}
+*/
+QDataStream &operator>>(QDataStream &s, QPainterPath &p)
+{
+    int size;
+    s >> size;
+
+    if (size == 0)
+        return s;
+
+    p.ensureData(); // in case if p.d_func() == 0
+    if (p.d_func()->elements.size() == 1) {
+        Q_ASSERT(p.d_func()->elements.at(0).type == QPainterPath::MoveToElement);
+        p.d_func()->elements.clear();
+    }
+    p.d_func()->elements.reserve(p.d_func()->elements.size() + size);
+    for (int i=0; i<size; ++i) {
+        int type;
+        double x, y;
+        s >> type;
+        s >> x;
+        s >> y;
+        Q_ASSERT(type >= 0 && type <= 3);
+        if (!qt_is_finite(x) || !qt_is_finite(y)) {
+#ifndef QT_NO_DEBUG
+            qWarning("QDataStream::operator>>: NaN or Inf element found in path, skipping it");
+#endif
+            continue;
+        }
+        QPainterPath::Element elm = { x, y, QPainterPath::ElementType(type) };
+        p.d_func()->elements.append(elm);
+    }
+    s >> p.d_func()->cStart;
+    int fillRule;
+    s >> fillRule;
+    Q_ASSERT(fillRule == Qt::OddEvenFill || Qt::WindingFill);
+    p.d_func()->fillRule = Qt::FillRule(fillRule);
+    p.d_func()->dirtyBounds = true;
+    p.d_func()->dirtyControlBounds = true;
+    return s;
+}
+#endif // QT_NO_DATASTREAM
+
+
+/*******************************************************************************
+ * class QPainterPathStroker
+ */
+
+void qt_path_stroke_move_to(qfixed x, qfixed y, void *data)
+{
+    ((QPainterPath *) data)->moveTo(qt_fixed_to_real(x), qt_fixed_to_real(y));
+}
+
+void qt_path_stroke_line_to(qfixed x, qfixed y, void *data)
+{
+    ((QPainterPath *) data)->lineTo(qt_fixed_to_real(x), qt_fixed_to_real(y));
+}
+
+void qt_path_stroke_cubic_to(qfixed c1x, qfixed c1y,
+                             qfixed c2x, qfixed c2y,
+                             qfixed ex, qfixed ey,
+                             void *data)
+{
+    ((QPainterPath *) data)->cubicTo(qt_fixed_to_real(c1x), qt_fixed_to_real(c1y),
+                                     qt_fixed_to_real(c2x), qt_fixed_to_real(c2y),
+                                     qt_fixed_to_real(ex), qt_fixed_to_real(ey));
+}
+
+/*!
+    \since 4.1
+    \class QPainterPathStroker
+    \ingroup painting
+
+    \brief The QPainterPathStroker class is used to generate fillable
+    outlines for a given painter path.
+
+    By calling the createStroke() function, passing a given
+    QPainterPath as argument, a new painter path representing the
+    outline of the given path is created. The newly created painter
+    path can then be filled to draw the original painter path's
+    outline.
+
+    You can control the various design aspects (width, cap styles,
+    join styles and dash pattern) of the outlining using the following
+    functions:
+
+    \list
+    \o setWidth()
+    \o setCapStyle()
+    \o setJoinStyle()
+    \o setDashPattern()
+    \endlist
+
+    The setDashPattern() function accepts both a Qt::PenStyle object
+    and a vector representation of the pattern as argument.
+
+    In addition you can specify a curve's threshold, controlling the
+    granularity with which a curve is drawn, using the
+    setCurveThreshold() function. The default threshold is a well
+    adjusted value (0.25), and normally you should not need to modify
+    it. However, you can make the curve's appearance smoother by
+    decreasing its value.
+
+    You can also control the miter limit for the generated outline
+    using the setMiterLimit() function. The miter limit describes how
+    far from each join the miter join can extend. The limit is
+    specified in the units of width so the pixelwise miter limit will
+    be \c {miterlimit * width}. This value is only used if the join
+    style is Qt::MiterJoin.
+
+    The painter path generated by the createStroke() function should
+    only be used for outlining the given painter path. Otherwise it
+    may cause unexpected behavior. Generated outlines also require the
+    Qt::WindingFill rule which is set by default.
+
+    \sa QPen, QBrush
+*/
+
+QPainterPathStrokerPrivate::QPainterPathStrokerPrivate()
+    : dashOffset(0)
+{
+    stroker.setMoveToHook(qt_path_stroke_move_to);
+    stroker.setLineToHook(qt_path_stroke_line_to);
+    stroker.setCubicToHook(qt_path_stroke_cubic_to);
+}
+
+/*!
+   Creates a new stroker.
+ */
+QPainterPathStroker::QPainterPathStroker()
+    : d_ptr(new QPainterPathStrokerPrivate)
+{
+}
+
+/*!
+    Destroys the stroker.
+*/
+QPainterPathStroker::~QPainterPathStroker()
+{
+}
+
+
+/*!
+    Generates a new path that is a fillable area representing the
+    outline of the given \a path.
+
+    The various design aspects of the outline are based on the
+    stroker's properties: width(), capStyle(), joinStyle(),
+    dashPattern(), curveThreshold() and miterLimit().
+
+    The generated path should only be used for outlining the given
+    painter path. Otherwise it may cause unexpected
+    behavior. Generated outlines also require the Qt::WindingFill rule
+    which is set by default.
+*/
+QPainterPath QPainterPathStroker::createStroke(const QPainterPath &path) const
+{
+    QPainterPathStrokerPrivate *d = const_cast<QPainterPathStrokerPrivate *>(d_func());
+    QPainterPath stroke;
+    if (path.isEmpty())
+        return path;
+    if (d->dashPattern.isEmpty()) {
+        d->stroker.strokePath(path, &stroke, QTransform());
+    } else {
+        QDashStroker dashStroker(&d->stroker);
+        dashStroker.setDashPattern(d->dashPattern);
+        dashStroker.setDashOffset(d->dashOffset);
+        dashStroker.setClipRect(d->stroker.clipRect());
+        dashStroker.strokePath(path, &stroke, QTransform());
+    }
+    stroke.setFillRule(Qt::WindingFill);
+    return stroke;
+}
+
+/*!
+    Sets the width of the generated outline painter path to \a width.
+
+    The generated outlines will extend approximately 50% of \a width
+    to each side of the given input path's original outline.
+*/
+void QPainterPathStroker::setWidth(qreal width)
+{
+    Q_D(QPainterPathStroker);
+    if (width <= 0)
+        width = 1;
+    d->stroker.setStrokeWidth(qt_real_to_fixed(width));
+}
+
+/*!
+    Returns the width of the generated outlines.
+*/
+qreal QPainterPathStroker::width() const
+{
+    return qt_fixed_to_real(d_func()->stroker.strokeWidth());
+}
+
+
+/*!
+    Sets the cap style of the generated outlines to \a style.  If a
+    dash pattern is set, each segment of the pattern is subject to the
+    cap \a style.
+*/
+void QPainterPathStroker::setCapStyle(Qt::PenCapStyle style)
+{
+    d_func()->stroker.setCapStyle(style);
+}
+
+
+/*!
+    Returns the cap style of the generated outlines.
+*/
+Qt::PenCapStyle QPainterPathStroker::capStyle() const
+{
+    return d_func()->stroker.capStyle();
+}
+
+/*!
+    Sets the join style of the generated outlines to \a style.
+*/
+void QPainterPathStroker::setJoinStyle(Qt::PenJoinStyle style)
+{
+    d_func()->stroker.setJoinStyle(style);
+}
+
+/*!
+    Returns the join style of the generated outlines.
+*/
+Qt::PenJoinStyle QPainterPathStroker::joinStyle() const
+{
+    return d_func()->stroker.joinStyle();
+}
+
+/*!
+    Sets the miter limit of the generated outlines to \a limit.
+
+    The miter limit describes how far from each join the miter join
+    can extend. The limit is specified in units of the currently set
+    width. So the pixelwise miter limit will be \c { miterlimit *
+    width}.
+
+    This value is only used if the join style is Qt::MiterJoin.
+*/
+void QPainterPathStroker::setMiterLimit(qreal limit)
+{
+    d_func()->stroker.setMiterLimit(qt_real_to_fixed(limit));
+}
+
+/*!
+    Returns the miter limit for the generated outlines.
+*/
+qreal QPainterPathStroker::miterLimit() const
+{
+    return qt_fixed_to_real(d_func()->stroker.miterLimit());
+}
+
+
+/*!
+    Specifies the curve flattening \a threshold, controlling the
+    granularity with which the generated outlines' curve is drawn.
+
+    The default threshold is a well adjusted value (0.25), and
+    normally you should not need to modify it. However, you can make
+    the curve's appearance smoother by decreasing its value.
+*/
+void QPainterPathStroker::setCurveThreshold(qreal threshold)
+{
+    d_func()->stroker.setCurveThreshold(qt_real_to_fixed(threshold));
+}
+
+/*!
+    Returns the curve flattening threshold for the generated
+    outlines.
+*/
+qreal QPainterPathStroker::curveThreshold() const
+{
+    return qt_fixed_to_real(d_func()->stroker.curveThreshold());
+}
+
+/*!
+    Sets the dash pattern for the generated outlines to \a style.
+*/
+void QPainterPathStroker::setDashPattern(Qt::PenStyle style)
+{
+    d_func()->dashPattern = QDashStroker::patternForStyle(style);
+}
+
+/*!
+    \overload
+
+    Sets the dash pattern for the generated outlines to \a
+    dashPattern.  This function makes it possible to specify custom
+    dash patterns.
+
+    Each element in the vector contains the lengths of the dashes and spaces
+    in the stroke, beginning with the first dash in the first element, the
+    first space in the second element, and alternating between dashes and
+    spaces for each following pair of elements.
+
+    The vector can contain an odd number of elements, in which case the last
+    element will be extended by the length of the first element when the
+    pattern repeats.
+*/
+void QPainterPathStroker::setDashPattern(const QVector<qreal> &dashPattern)
+{
+    d_func()->dashPattern.clear();
+    for (int i=0; i<dashPattern.size(); ++i)
+        d_func()->dashPattern << qt_real_to_fixed(dashPattern.at(i));
+}
+
+/*!
+    Returns the dash pattern for the generated outlines.
+*/
+QVector<qreal> QPainterPathStroker::dashPattern() const
+{
+    return d_func()->dashPattern;
+}
+
+/*!
+    Returns the dash offset for the generated outlines.
+ */
+qreal QPainterPathStroker::dashOffset() const
+{
+    return d_func()->dashOffset;
+}
+
+/*!
+  Sets the dash offset for the generated outlines to \a offset.
+
+  See the documentation for QPen::setDashOffset() for a description of the
+  dash offset.
+ */
+void QPainterPathStroker::setDashOffset(qreal offset)
+{
+    d_func()->dashOffset = offset;
+}
+
+/*!
+  Converts the path into a polygon using the QTransform
+  \a matrix, and returns the polygon.
+
+  The polygon is created by first converting all subpaths to
+  polygons, then using a rewinding technique to make sure that
+  overlapping subpaths can be filled using the correct fill rule.
+
+  Note that rewinding inserts addition lines in the polygon so
+  the outline of the fill polygon does not match the outline of
+  the path.
+
+  \sa toSubpathPolygons(), toFillPolygons(),
+  {QPainterPath#QPainterPath Conversion}{QPainterPath Conversion}
+*/
+QPolygonF QPainterPath::toFillPolygon(const QTransform &matrix) const
+{
+
+    QList<QPolygonF> flats = toSubpathPolygons(matrix);
+    QPolygonF polygon;
+    if (flats.isEmpty())
+        return polygon;
+    QPointF first = flats.first().first();
+    for (int i=0; i<flats.size(); ++i) {
+        polygon += flats.at(i);
+        if (!flats.at(i).isClosed())
+            polygon += flats.at(i).first();
+        if (i > 0)
+            polygon += first;
+    }
+    return polygon;
+}
+
+/*!
+  \overload
+*/
+QPolygonF QPainterPath::toFillPolygon(const QMatrix &matrix) const
+{
+    return toFillPolygon(QTransform(matrix));
+}
+
+
+//derivative of the equation
+static inline qreal slopeAt(qreal t, qreal a, qreal b, qreal c, qreal d)
+{
+    return 3*t*t*(d - 3*c + 3*b - a) + 6*t*(c - 2*b + a) + 3*(b - a);
+}
+
+/*!
+    Returns the length of the current path.
+*/
+qreal QPainterPath::length() const
+{
+    Q_D(QPainterPath);
+    if (isEmpty())
+        return 0;
+
+    qreal len = 0;
+    for (int i=1; i<d->elements.size(); ++i) {
+        const Element &e = d->elements.at(i);
+
+        switch (e.type) {
+        case MoveToElement:
+            break;
+        case LineToElement:
+        {
+            len += QLineF(d->elements.at(i-1), e).length();
+            break;
+        }
+        case CurveToElement:
+        {
+            QBezier b = QBezier::fromPoints(d->elements.at(i-1),
+                                            e,
+                                            d->elements.at(i+1),
+                                            d->elements.at(i+2));
+            len += b.length();
+            i += 2;
+            break;
+        }
+        default:
+            break;
+        }
+    }
+    return len;
+}
+
+/*!
+    Returns percentage of the whole path at the specified length \a len.
+
+    Note that similarly to other percent methods, the percentage measurement
+    is not linear with regards to the length, if curves are present
+    in the path. When curves are present the percentage argument is mapped
+    to the t parameter of the Bezier equations.
+*/
+qreal QPainterPath::percentAtLength(qreal len) const
+{
+    Q_D(QPainterPath);
+    if (isEmpty() || len <= 0)
+        return 0;
+
+    qreal totalLength = length();
+    if (len > totalLength)
+        return 1;
+
+    qreal curLen = 0;
+    for (int i=1; i<d->elements.size(); ++i) {
+        const Element &e = d->elements.at(i);
+
+        switch (e.type) {
+        case MoveToElement:
+            break;
+        case LineToElement:
+        {
+            QLineF line(d->elements.at(i-1), e);
+            qreal llen = line.length();
+            curLen += llen;
+            if (curLen >= len) {
+                return len/totalLength ;
+            }
+
+            break;
+        }
+        case CurveToElement:
+        {
+            QBezier b = QBezier::fromPoints(d->elements.at(i-1),
+                                            e,
+                                            d->elements.at(i+1),
+                                            d->elements.at(i+2));
+            qreal blen = b.length();
+            qreal prevLen = curLen;
+            curLen += blen;
+
+            if (curLen >= len) {
+                qreal res = b.tAtLength(len - prevLen);
+                return (res * blen + prevLen)/totalLength;
+            }
+
+            i += 2;
+            break;
+        }
+        default:
+            break;
+        }
+    }
+
+    return 0;
+}
+
+static inline QBezier bezierAtT(const QPainterPath &path, qreal t, qreal *startingLength, qreal *bezierLength)
+{
+    *startingLength = 0;
+    if (t > 1)
+        return QBezier();
+
+    qreal curLen = 0;
+    qreal totalLength = path.length();
+
+    const int lastElement = path.elementCount() - 1;
+    for (int i=0; i <= lastElement; ++i) {
+        const QPainterPath::Element &e = path.elementAt(i);
+
+        switch (e.type) {
+        case QPainterPath::MoveToElement:
+            break;
+        case QPainterPath::LineToElement:
+        {
+            QLineF line(path.elementAt(i-1), e);
+            qreal llen = line.length();
+            curLen += llen;
+            if (i == lastElement || curLen/totalLength >= t) {
+                *bezierLength = llen;
+                QPointF a = path.elementAt(i-1);
+                QPointF delta = e - a;
+                return QBezier::fromPoints(a, a + delta / 3, a + 2 * delta / 3, e);
+            }
+            break;
+        }
+        case QPainterPath::CurveToElement:
+        {
+            QBezier b = QBezier::fromPoints(path.elementAt(i-1),
+                                            e,
+                                            path.elementAt(i+1),
+                                            path.elementAt(i+2));
+            qreal blen = b.length();
+            curLen += blen;
+
+            if (i + 2 == lastElement || curLen/totalLength >= t) {
+                *bezierLength = blen;
+                return b;
+            }
+
+            i += 2;
+            break;
+        }
+        default:
+            break;
+        }
+        *startingLength = curLen;
+    }
+    return QBezier();
+}
+
+/*!
+    Returns the point at at the percentage \a t of the current path.
+    The argument \a t has to be between 0 and 1.
+
+    Note that similarly to other percent methods, the percentage measurement
+    is not linear with regards to the length, if curves are present
+    in the path. When curves are present the percentage argument is mapped
+    to the t parameter of the Bezier equations.
+*/
+QPointF QPainterPath::pointAtPercent(qreal t) const
+{
+    if (t < 0 || t > 1) {
+        qWarning("QPainterPath::pointAtPercent accepts only values between 0 and 1");
+        return QPointF();
+    }
+
+    if (!d_ptr || d_ptr->elements.size() == 0)
+        return QPointF();
+
+    if (d_ptr->elements.size() == 1)
+        return d_ptr->elements.at(0);
+
+    qreal totalLength = length();
+    qreal curLen = 0;
+    qreal bezierLen = 0;
+    QBezier b = bezierAtT(*this, t, &curLen, &bezierLen);
+    qreal realT = (totalLength * t - curLen) / bezierLen;
+
+    return b.pointAt(qBound(qreal(0), realT, qreal(1)));
+}
+
+/*!
+    Returns the angle of the path tangent at the percentage \a t.
+    The argument \a t has to be between 0 and 1.
+
+    Positive values for the angles mean counter-clockwise while negative values
+    mean the clockwise direction. Zero degrees is at the 3 o'clock position.
+
+    Note that similarly to the other percent methods, the percentage measurement
+    is not linear with regards to the length if curves are present
+    in the path. When curves are present the percentage argument is mapped
+    to the t parameter of the Bezier equations.
+*/
+qreal QPainterPath::angleAtPercent(qreal t) const
+{
+    if (t < 0 || t > 1) {
+        qWarning("QPainterPath::angleAtPercent accepts only values between 0 and 1");
+        return 0;
+    }
+
+    qreal totalLength = length();
+    qreal curLen = 0;
+    qreal bezierLen = 0;
+    QBezier bez = bezierAtT(*this, t, &curLen, &bezierLen);
+    qreal realT = (totalLength * t - curLen) / bezierLen;
+
+    qreal m1 = slopeAt(realT, bez.x1, bez.x2, bez.x3, bez.x4);
+    qreal m2 = slopeAt(realT, bez.y1, bez.y2, bez.y3, bez.y4);
+
+    return QLineF(0, 0, m1, m2).angle();
+}
+
+#if defined(Q_WS_WINCE)
+#pragma warning( disable : 4056 4756 )
+#endif
+
+/*!
+    Returns the slope of the path at the percentage \a t. The
+    argument \a t has to be between 0 and 1.
+
+    Note that similarly to other percent methods, the percentage measurement
+    is not linear with regards to the length, if curves are present
+    in the path. When curves are present the percentage argument is mapped
+    to the t parameter of the Bezier equations.
+*/
+qreal QPainterPath::slopeAtPercent(qreal t) const
+{
+    if (t < 0 || t > 1) {
+        qWarning("QPainterPath::slopeAtPercent accepts only values between 0 and 1");
+        return 0;
+    }
+
+    qreal totalLength = length();
+    qreal curLen = 0;
+    qreal bezierLen = 0;
+    QBezier bez = bezierAtT(*this, t, &curLen, &bezierLen);
+    qreal realT = (totalLength * t - curLen) / bezierLen;
+
+    qreal m1 = slopeAt(realT, bez.x1, bez.x2, bez.x3, bez.x4);
+    qreal m2 = slopeAt(realT, bez.y1, bez.y2, bez.y3, bez.y4);
+    //tangent line
+    qreal slope = 0;
+
+#define SIGN(x) ((x < 0)?-1:1)
+    if (m1)
+        slope = m2/m1;
+    else {
+        //windows doesn't define INFINITY :(
+#ifdef INFINITY
+        slope = INFINITY*SIGN(m2);
+#else
+        if (sizeof(qreal) == sizeof(double)) {
+            return 1.79769313486231570e+308;
+        } else {
+            return ((qreal)3.40282346638528860e+38);
+        }
+#endif
+    }
+
+    return slope;
+}
+
+/*!
+  \since 4.4
+
+  Adds the given rectangle \a rect with rounded corners to the path.
+
+  The \a xRadius and \a yRadius arguments specify the radii of
+  the ellipses defining the corners of the rounded rectangle.
+  When \a mode is Qt::RelativeSize, \a xRadius and
+  \a yRadius are specified in percentage of half the rectangle's
+  width and height respectively, and should be in the range 0.0 to 100.0.
+
+  \sa addRect()
+*/
+void QPainterPath::addRoundedRect(const QRectF &rect, qreal xRadius, qreal yRadius,
+                                  Qt::SizeMode mode)
+{
+    QRectF r = rect.normalized();
+
+    if (r.isNull())
+        return;
+
+    if (mode == Qt::AbsoluteSize) {
+        qreal w = r.width() / 2;
+        qreal h = r.height() / 2;
+
+        if (w == 0) {
+            xRadius = 0;
+        } else {
+            xRadius = 100 * qMin(xRadius, w) / w;
+        }
+        if (h == 0) {
+            yRadius = 0;
+        } else {
+            yRadius = 100 * qMin(yRadius, h) / h;
+        }
+    } else {
+        if (xRadius > 100)                          // fix ranges
+            xRadius = 100;
+
+        if (yRadius > 100)
+            yRadius = 100;
+    }
+
+    if (xRadius <= 0 || yRadius <= 0) {             // add normal rectangle
+        addRect(r);
+        return;
+    }
+
+    qreal x = r.x();
+    qreal y = r.y();
+    qreal w = r.width();
+    qreal h = r.height();
+    qreal rxx2 = w*xRadius/100;
+    qreal ryy2 = h*yRadius/100;
+
+    ensureData();
+    detach();
+
+    bool first = d_func()->elements.size() < 2;
+
+    arcMoveTo(x, y, rxx2, ryy2, 180);
+    arcTo(x, y, rxx2, ryy2, 180, -90);
+    arcTo(x+w-rxx2, y, rxx2, ryy2, 90, -90);
+    arcTo(x+w-rxx2, y+h-ryy2, rxx2, ryy2, 0, -90);
+    arcTo(x, y+h-ryy2, rxx2, ryy2, 270, -90);
+    closeSubpath();
+
+    d_func()->require_moveTo = true;
+    d_func()->convex = first;
+}
+
+/*!
+  \fn void QPainterPath::addRoundedRect(qreal x, qreal y, qreal w, qreal h, qreal xRadius, qreal yRadius, Qt::SizeMode mode = Qt::AbsoluteSize);
+  \since 4.4
+  \overload
+
+  Adds the given rectangle \a x, \a y, \a w, \a h  with rounded corners to the path.
+ */
+
+/*!
+  \obsolete
+
+  Adds a rectangle \a r with rounded corners to the path.
+
+  The \a xRnd and \a yRnd arguments specify how rounded the corners
+  should be. 0 is angled corners, 99 is maximum roundedness.
+
+  \sa addRoundedRect()
+*/
+void QPainterPath::addRoundRect(const QRectF &r, int xRnd, int yRnd)
+{
+    if(xRnd >= 100)                          // fix ranges
+        xRnd = 99;
+    if(yRnd >= 100)
+        yRnd = 99;
+    if(xRnd <= 0 || yRnd <= 0) {             // add normal rectangle
+        addRect(r);
+        return;
+    }
+
+    QRectF rect = r.normalized();
+
+    if (rect.isNull())
+        return;
+
+    qreal x = rect.x();
+    qreal y = rect.y();
+    qreal w = rect.width();
+    qreal h = rect.height();
+    qreal rxx2 = w*xRnd/100;
+    qreal ryy2 = h*yRnd/100;
+
+    ensureData();
+    detach();
+
+    bool first = d_func()->elements.size() < 2;
+
+    arcMoveTo(x, y, rxx2, ryy2, 180);
+    arcTo(x, y, rxx2, ryy2, 180, -90);
+    arcTo(x+w-rxx2, y, rxx2, ryy2, 90, -90);
+    arcTo(x+w-rxx2, y+h-ryy2, rxx2, ryy2, 0, -90);
+    arcTo(x, y+h-ryy2, rxx2, ryy2, 270, -90);
+    closeSubpath();
+
+    d_func()->require_moveTo = true;
+    d_func()->convex = first;
+}
+
+/*!
+  \obsolete
+
+  \fn bool QPainterPath::addRoundRect(const QRectF &rect, int roundness);
+  \since 4.3
+  \overload
+
+  Adds a rounded rectangle, \a rect, to the path.
+
+  The \a roundness argument specifies uniform roundness for the
+  rectangle.  Vertical and horizontal roundness factors will be
+  adjusted accordingly to act uniformly around both axes. Use this
+  method if you want a rectangle equally rounded across both the X and
+  Y axis.
+
+  \sa addRoundedRect()
+*/
+
+/*!
+  \obsolete
+
+  \fn void QPainterPath::addRoundRect(qreal x, qreal y, qreal w, qreal h, int xRnd, int yRnd);
+  \overload
+
+  Adds a rectangle with rounded corners to the path. The rectangle
+  is constructed from \a x, \a y, and the width and height \a w
+  and \a h.
+
+  The \a xRnd and \a yRnd arguments specify how rounded the corners
+  should be. 0 is angled corners, 99 is maximum roundedness.
+
+  \sa addRoundedRect()
+ */
+
+/*!
+  \obsolete
+
+  \fn bool QPainterPath::addRoundRect(qreal x, qreal y, qreal width, qreal height, int roundness);
+  \since 4.3
+  \overload
+
+  Adds a rounded rectangle to the path, defined by the coordinates \a
+  x and \a y with the specified \a width and \a height.
+
+  The \a roundness argument specifies uniform roundness for the
+  rectangle. Vertical and horizontal roundness factors will be
+  adjusted accordingly to act uniformly around both axes. Use this
+  method if you want a rectangle equally rounded across both the X and
+  Y axis.
+
+  \sa addRoundedRect()
+*/
+
+/*!
+    \since 4.3
+
+    Returns a path which is the union of this path's fill area and \a p's fill area.
+
+    Set operations on paths will treat the paths as areas. Non-closed
+    paths will be treated as implicitly closed.
+    Bezier curves may be flattened to line segments due to numerical instability of
+    doing bezier curve intersections.
+
+    \sa intersected(), subtracted()
+*/
+QPainterPath QPainterPath::united(const QPainterPath &p) const
+{
+    if (isEmpty() || p.isEmpty())
+        return isEmpty() ? p : *this;
+    QPathClipper clipper(*this, p);
+    return clipper.clip(QPathClipper::BoolOr);
+}
+
+/*!
+    \since 4.3
+
+    Returns a path which is the intersection of this path's fill area and \a p's fill area.
+    Bezier curves may be flattened to line segments due to numerical instability of
+    doing bezier curve intersections.
+*/
+QPainterPath QPainterPath::intersected(const QPainterPath &p) const
+{
+    if (isEmpty() || p.isEmpty())
+        return QPainterPath();
+    QPathClipper clipper(*this, p);
+    return clipper.clip(QPathClipper::BoolAnd);
+}
+
+/*!
+    \since 4.3
+
+    Returns a path which is \a p's fill area subtracted from this path's fill area.
+
+    Set operations on paths will treat the paths as areas. Non-closed
+    paths will be treated as implicitly closed.
+    Bezier curves may be flattened to line segments due to numerical instability of
+    doing bezier curve intersections.
+*/
+QPainterPath QPainterPath::subtracted(const QPainterPath &p) const
+{
+    if (isEmpty() || p.isEmpty())
+        return *this;
+    QPathClipper clipper(*this, p);
+    return clipper.clip(QPathClipper::BoolSub);
+}
+
+/*!
+    \since 4.3
+    \obsolete
+
+    Use subtracted() instead.
+
+    \sa subtracted()
+*/
+QPainterPath QPainterPath::subtractedInverted(const QPainterPath &p) const
+{
+    return p.subtracted(*this);
+}
+
+/*!
+    \since 4.4
+
+    Returns a simplified version of this path. This implies merging all subpaths that intersect,
+    and returning a path containing no intersecting edges. Consecutive parallel lines will also
+    be merged. The simplified path will always use the default fill rule, Qt::OddEvenFill.
+    Bezier curves may be flattened to line segments due to numerical instability of
+    doing bezier curve intersections.
+*/
+QPainterPath QPainterPath::simplified() const
+{
+    if(isEmpty())
+        return *this;
+    QPathClipper clipper(*this, QPainterPath());
+    return clipper.clip(QPathClipper::Simplify);
+}
+
+/*!
+  \since 4.3
+
+  Returns true if the current path intersects at any point the given path \a p.
+  Also returns true if the current path contains or is contained by any part of \a p.
+
+  Set operations on paths will treat the paths as areas. Non-closed
+  paths will be treated as implicitly closed.
+
+  \sa contains()
+ */
+bool QPainterPath::intersects(const QPainterPath &p) const
+{
+    if (p.elementCount() == 1)
+        return contains(p.elementAt(0));
+    if (isEmpty() || p.isEmpty())
+        return false;
+    QPathClipper clipper(*this, p);
+    return clipper.intersect();
+}
+
+/*!
+  \since 4.3
+
+  Returns true if the given path \a p is contained within
+  the current path. Returns false if any edges of the current path and
+  \a p intersect.
+
+  Set operations on paths will treat the paths as areas. Non-closed
+  paths will be treated as implicitly closed.
+
+  \sa intersects()
+ */
+bool QPainterPath::contains(const QPainterPath &p) const
+{
+    if (p.elementCount() == 1)
+        return contains(p.elementAt(0));
+    if (isEmpty() || p.isEmpty())
+        return false;
+    QPathClipper clipper(*this, p);
+    return clipper.contains();
+}
+
+void QPainterPath::setDirty(bool dirty)
+{
+    d_func()->dirtyBounds        = dirty;
+    d_func()->dirtyControlBounds = dirty;
+    delete d_func()->pathConverter;
+    d_func()->pathConverter = 0;
+    d_func()->convex = false;
+}
+
+void QPainterPath::computeBoundingRect() const
+{
+    QPainterPathData *d = d_func();
+    d->dirtyBounds = false;
+    if (!d_ptr) {
+        d->bounds = QRect();
+        return;
+    }
+
+    qreal minx, maxx, miny, maxy;
+    minx = maxx = d->elements.at(0).x;
+    miny = maxy = d->elements.at(0).y;
+    for (int i=1; i<d->elements.size(); ++i) {
+        const Element &e = d->elements.at(i);
+
+        switch (e.type) {
+        case MoveToElement:
+        case LineToElement:
+            if (e.x > maxx) maxx = e.x;
+            else if (e.x < minx) minx = e.x;
+            if (e.y > maxy) maxy = e.y;
+            else if (e.y < miny) miny = e.y;
+            break;
+        case CurveToElement:
+            {
+                QBezier b = QBezier::fromPoints(d->elements.at(i-1),
+                                                e,
+                                                d->elements.at(i+1),
+                                                d->elements.at(i+2));
+                QRectF r = qt_painterpath_bezier_extrema(b);
+                qreal right = r.right();
+                qreal bottom = r.bottom();
+                if (r.x() < minx) minx = r.x();
+                if (right > maxx) maxx = right;
+                if (r.y() < miny) miny = r.y();
+                if (bottom > maxy) maxy = bottom;
+                i += 2;
+            }
+            break;
+        default:
+            break;
+        }
+    }
+    d->bounds = QRectF(minx, miny, maxx - minx, maxy - miny);
+}
+
+
+void QPainterPath::computeControlPointRect() const
+{
+    QPainterPathData *d = d_func();
+    d->dirtyControlBounds = false;
+    if (!d_ptr) {
+        d->controlBounds = QRect();
+        return;
+    }
+
+    qreal minx, maxx, miny, maxy;
+    minx = maxx = d->elements.at(0).x;
+    miny = maxy = d->elements.at(0).y;
+    for (int i=1; i<d->elements.size(); ++i) {
+        const Element &e = d->elements.at(i);
+        if (e.x > maxx) maxx = e.x;
+        else if (e.x < minx) minx = e.x;
+        if (e.y > maxy) maxy = e.y;
+        else if (e.y < miny) miny = e.y;
+    }
+    d->controlBounds = QRectF(minx, miny, maxx - minx, maxy - miny);
+}
+
+#ifndef QT_NO_DEBUG_STREAM
+QDebug operator<<(QDebug s, const QPainterPath &p)
+{
+    s.nospace() << "QPainterPath: Element count=" << p.elementCount() << endl;
+    const char *types[] = {"MoveTo", "LineTo", "CurveTo", "CurveToData"};
+    for (int i=0; i<p.elementCount(); ++i) {
+        s.nospace() << " -> " << types[p.elementAt(i).type] << "(x=" << p.elementAt(i).x << ", y=" << p.elementAt(i).y << ')' << endl;
+
+    }
+    return s;
+}
+#endif
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qpainterpath.h b/src/gui/painting/qpainterpath.h
new file mode 100644
index 0000000000..3c23282d8e
--- /dev/null
+++ b/src/gui/painting/qpainterpath.h
@@ -0,0 +1,435 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPAINTERPATH_H
+#define QPAINTERPATH_H
+
+#include <QtGui/qmatrix.h>
+#include <QtCore/qglobal.h>
+#include <QtCore/qrect.h>
+#include <QtCore/qline.h>
+#include <QtCore/qvector.h>
+#include <QtCore/qscopedpointer.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+class QFont;
+class QPainterPathPrivate;
+struct QPainterPathPrivateDeleter;
+class QPainterPathData;
+class QPainterPathStrokerPrivate;
+class QPolygonF;
+class QRegion;
+class QVectorPath;
+
+class Q_GUI_EXPORT QPainterPath
+{
+public:
+    enum ElementType {
+        MoveToElement,
+        LineToElement,
+        CurveToElement,
+        CurveToDataElement
+    };
+
+    class Element {
+    public:
+        qreal x;
+        qreal y;
+        ElementType type;
+
+        bool isMoveTo() const { return type == MoveToElement; }
+        bool isLineTo() const { return type == LineToElement; }
+        bool isCurveTo() const { return type == CurveToElement; }
+
+        operator QPointF () const { return QPointF(x, y); }
+
+        bool operator==(const Element &e) const { return qFuzzyCompare(x, e.x)
+            && qFuzzyCompare(y, e.y) && type == e.type; }
+        inline bool operator!=(const Element &e) const { return !operator==(e); }
+    };
+
+    QPainterPath();
+    explicit QPainterPath(const QPointF &startPoint);
+    QPainterPath(const QPainterPath &other);
+    QPainterPath &operator=(const QPainterPath &other);
+#ifdef Q_COMPILER_RVALUE_REFS
+    inline QPainterPath &operator=(QPainterPath &&other)
+    { qSwap(d_ptr, other.d_ptr); return *this; }
+#endif
+    ~QPainterPath();
+    inline void swap(QPainterPath &other) { d_ptr.swap(other.d_ptr); }
+
+    void closeSubpath();
+
+    void moveTo(const QPointF &p);
+    inline void moveTo(qreal x, qreal y);
+
+    void lineTo(const QPointF &p);
+    inline void lineTo(qreal x, qreal y);
+
+    void arcMoveTo(const QRectF &rect, qreal angle);
+    inline void arcMoveTo(qreal x, qreal y, qreal w, qreal h, qreal angle);
+
+    void arcTo(const QRectF &rect, qreal startAngle, qreal arcLength);
+    inline void arcTo(qreal x, qreal y, qreal w, qreal h, qreal startAngle, qreal arcLength);
+
+    void cubicTo(const QPointF &ctrlPt1, const QPointF &ctrlPt2, const QPointF &endPt);
+    inline void cubicTo(qreal ctrlPt1x, qreal ctrlPt1y, qreal ctrlPt2x, qreal ctrlPt2y,
+                        qreal endPtx, qreal endPty);
+    void quadTo(const QPointF &ctrlPt, const QPointF &endPt);
+    inline void quadTo(qreal ctrlPtx, qreal ctrlPty, qreal endPtx, qreal endPty);
+
+    QPointF currentPosition() const;
+
+    void addRect(const QRectF &rect);
+    inline void addRect(qreal x, qreal y, qreal w, qreal h);
+    void addEllipse(const QRectF &rect);
+    inline void addEllipse(qreal x, qreal y, qreal w, qreal h);
+    inline void addEllipse(const QPointF &center, qreal rx, qreal ry);
+    void addPolygon(const QPolygonF &polygon);
+    void addText(const QPointF &point, const QFont &f, const QString &text);
+    inline void addText(qreal x, qreal y, const QFont &f, const QString &text);
+    void addPath(const QPainterPath &path);
+    void addRegion(const QRegion &region);
+
+    void addRoundedRect(const QRectF &rect, qreal xRadius, qreal yRadius,
+                        Qt::SizeMode mode = Qt::AbsoluteSize);
+    inline void addRoundedRect(qreal x, qreal y, qreal w, qreal h,
+                               qreal xRadius, qreal yRadius,
+                               Qt::SizeMode mode = Qt::AbsoluteSize);
+
+    void addRoundRect(const QRectF &rect, int xRnd, int yRnd);
+    inline void addRoundRect(qreal x, qreal y, qreal w, qreal h,
+                             int xRnd, int yRnd);
+    inline void addRoundRect(const QRectF &rect, int roundness);
+    inline void addRoundRect(qreal x, qreal y, qreal w, qreal h,
+                             int roundness);
+
+    void connectPath(const QPainterPath &path);
+
+    bool contains(const QPointF &pt) const;
+    bool contains(const QRectF &rect) const;
+    bool intersects(const QRectF &rect) const;
+
+    void translate(qreal dx, qreal dy);
+    inline void translate(const QPointF &offset);
+
+    QPainterPath translated(qreal dx, qreal dy) const;
+    inline QPainterPath translated(const QPointF &offset) const;
+
+    QRectF boundingRect() const;
+    QRectF controlPointRect() const;
+
+    Qt::FillRule fillRule() const;
+    void setFillRule(Qt::FillRule fillRule);
+
+    inline bool isEmpty() const;
+
+    QPainterPath toReversed() const;
+    QList<QPolygonF> toSubpathPolygons(const QMatrix &matrix = QMatrix()) const;
+    QList<QPolygonF> toFillPolygons(const QMatrix &matrix = QMatrix()) const;
+    QPolygonF toFillPolygon(const QMatrix &matrix = QMatrix()) const;
+    QList<QPolygonF> toSubpathPolygons(const QTransform &matrix) const;
+    QList<QPolygonF> toFillPolygons(const QTransform &matrix) const;
+    QPolygonF toFillPolygon(const QTransform &matrix) const;
+
+    inline int elementCount() const;
+    inline const QPainterPath::Element &elementAt(int i) const;
+    inline void setElementPositionAt(int i, qreal x, qreal y);
+
+    qreal   length() const;
+    qreal   percentAtLength(qreal t) const;
+    QPointF pointAtPercent(qreal t) const;
+    qreal   angleAtPercent(qreal t) const;
+    qreal   slopeAtPercent(qreal t) const;
+
+    bool intersects(const QPainterPath &p) const;
+    bool contains(const QPainterPath &p) const;
+    QPainterPath united(const QPainterPath &r) const;
+    QPainterPath intersected(const QPainterPath &r) const;
+    QPainterPath subtracted(const QPainterPath &r) const;
+    QPainterPath subtractedInverted(const QPainterPath &r) const;
+
+    QPainterPath simplified() const;
+
+    bool operator==(const QPainterPath &other) const;
+    bool operator!=(const QPainterPath &other) const;
+
+    QPainterPath operator&(const QPainterPath &other) const;
+    QPainterPath operator|(const QPainterPath &other) const;
+    QPainterPath operator+(const QPainterPath &other) const;
+    QPainterPath operator-(const QPainterPath &other) const;
+    QPainterPath &operator&=(const QPainterPath &other);
+    QPainterPath &operator|=(const QPainterPath &other);
+    QPainterPath &operator+=(const QPainterPath &other);
+    QPainterPath &operator-=(const QPainterPath &other);
+
+private:
+    QScopedPointer<QPainterPathPrivate, QPainterPathPrivateDeleter> d_ptr;
+
+    inline void ensureData() { if (!d_ptr) ensureData_helper(); }
+    void ensureData_helper();
+    inline void detach();
+    void detach_helper();
+    void setDirty(bool);
+    void computeBoundingRect() const;
+    void computeControlPointRect() const;
+
+    QPainterPathData *d_func() const { return reinterpret_cast<QPainterPathData *>(d_ptr.data()); }
+
+    friend class QPainterPathData;
+    friend class QPainterPathStroker;
+    friend class QPainterPathStrokerPrivate;
+    friend class QMatrix;
+    friend class QTransform;
+    friend class QVectorPath;
+    friend Q_GUI_EXPORT const QVectorPath &qtVectorPathForPath(const QPainterPath &);
+
+#ifndef QT_NO_DATASTREAM
+    friend Q_GUI_EXPORT QDataStream &operator<<(QDataStream &, const QPainterPath &);
+    friend Q_GUI_EXPORT QDataStream &operator>>(QDataStream &, QPainterPath &);
+#endif
+};
+
+class QPainterPathPrivate
+{
+public:
+    friend class QPainterPath;
+    friend class QPainterPathData;
+    friend class QPainterPathStroker;
+    friend class QPainterPathStrokerPrivate;
+    friend class QMatrix;
+    friend class QTransform;
+    friend class QVectorPath;
+    friend struct QPainterPathPrivateDeleter;
+#ifndef QT_NO_DATASTREAM
+    friend Q_GUI_EXPORT QDataStream &operator<<(QDataStream &, const QPainterPath &);
+    friend Q_GUI_EXPORT QDataStream &operator>>(QDataStream &, QPainterPath &);
+#endif
+private:
+    QAtomicInt ref;
+    QVector<QPainterPath::Element> elements;
+};
+
+Q_DECLARE_TYPEINFO(QPainterPath::Element, Q_PRIMITIVE_TYPE);
+
+#ifndef QT_NO_DATASTREAM
+Q_GUI_EXPORT QDataStream &operator<<(QDataStream &, const QPainterPath &);
+Q_GUI_EXPORT QDataStream &operator>>(QDataStream &, QPainterPath &);
+#endif
+
+class Q_GUI_EXPORT QPainterPathStroker
+{
+    Q_DECLARE_PRIVATE(QPainterPathStroker)
+public:
+    QPainterPathStroker();
+    ~QPainterPathStroker();
+
+    void setWidth(qreal width);
+    qreal width() const;
+
+    void setCapStyle(Qt::PenCapStyle style);
+    Qt::PenCapStyle capStyle() const;
+
+    void setJoinStyle(Qt::PenJoinStyle style);
+    Qt::PenJoinStyle joinStyle() const;
+
+    void setMiterLimit(qreal length);
+    qreal miterLimit() const;
+
+    void setCurveThreshold(qreal threshold);
+    qreal curveThreshold() const;
+
+    void setDashPattern(Qt::PenStyle);
+    void setDashPattern(const QVector<qreal> &dashPattern);
+    QVector<qreal> dashPattern() const;
+
+    void setDashOffset(qreal offset);
+    qreal dashOffset() const;
+
+    QPainterPath createStroke(const QPainterPath &path) const;
+
+private:
+    Q_DISABLE_COPY(QPainterPathStroker)
+
+    friend class QX11PaintEngine;
+
+    QScopedPointer<QPainterPathStrokerPrivate> d_ptr;
+};
+
+inline void QPainterPath::moveTo(qreal x, qreal y)
+{
+    moveTo(QPointF(x, y));
+}
+
+inline void QPainterPath::lineTo(qreal x, qreal y)
+{
+    lineTo(QPointF(x, y));
+}
+
+inline void QPainterPath::arcTo(qreal x, qreal y, qreal w, qreal h, qreal startAngle, qreal arcLength)
+{
+    arcTo(QRectF(x, y, w, h), startAngle, arcLength);
+}
+
+inline void QPainterPath::arcMoveTo(qreal x, qreal y, qreal w, qreal h, qreal angle)
+{
+    arcMoveTo(QRectF(x, y, w, h), angle);
+}
+
+inline void QPainterPath::cubicTo(qreal ctrlPt1x, qreal ctrlPt1y, qreal ctrlPt2x, qreal ctrlPt2y,
+                                   qreal endPtx, qreal endPty)
+{
+    cubicTo(QPointF(ctrlPt1x, ctrlPt1y), QPointF(ctrlPt2x, ctrlPt2y),
+            QPointF(endPtx, endPty));
+}
+
+inline void QPainterPath::quadTo(qreal ctrlPtx, qreal ctrlPty, qreal endPtx, qreal endPty)
+{
+    quadTo(QPointF(ctrlPtx, ctrlPty), QPointF(endPtx, endPty));
+}
+
+inline void QPainterPath::addEllipse(qreal x, qreal y, qreal w, qreal h)
+{
+    addEllipse(QRectF(x, y, w, h));
+}
+
+inline void QPainterPath::addEllipse(const QPointF &center, qreal rx, qreal ry)
+{
+    addEllipse(QRectF(center.x() - rx, center.y() - ry, 2 * rx, 2 * ry));
+}
+
+inline void QPainterPath::addRect(qreal x, qreal y, qreal w, qreal h)
+{
+    addRect(QRectF(x, y, w, h));
+}
+
+inline void QPainterPath::addRoundedRect(qreal x, qreal y, qreal w, qreal h,
+                                         qreal xRadius, qreal yRadius,
+                                         Qt::SizeMode mode)
+{
+    addRoundedRect(QRectF(x, y, w, h), xRadius, yRadius, mode);
+}
+
+inline void QPainterPath::addRoundRect(qreal x, qreal y, qreal w, qreal h,
+                                       int xRnd, int yRnd)
+{
+    addRoundRect(QRectF(x, y, w, h), xRnd, yRnd);
+}
+
+inline void QPainterPath::addRoundRect(const QRectF &rect,
+                                       int roundness)
+{
+    int xRnd = roundness;
+    int yRnd = roundness;
+    if (rect.width() > rect.height())
+        xRnd = int(roundness * rect.height()/rect.width());
+    else
+        yRnd = int(roundness * rect.width()/rect.height());
+    addRoundRect(rect, xRnd, yRnd);
+}
+
+inline void QPainterPath::addRoundRect(qreal x, qreal y, qreal w, qreal h,
+                                       int roundness)
+{
+    addRoundRect(QRectF(x, y, w, h), roundness);
+}
+
+inline void QPainterPath::addText(qreal x, qreal y, const QFont &f, const QString &text)
+{
+    addText(QPointF(x, y), f, text);
+}
+
+inline void QPainterPath::translate(const QPointF &offset)
+{ translate(offset.x(), offset.y()); }
+
+inline QPainterPath QPainterPath::translated(const QPointF &offset) const
+{ return translated(offset.x(), offset.y()); }
+
+inline bool QPainterPath::isEmpty() const
+{
+    return !d_ptr || (d_ptr->elements.size() == 1 && d_ptr->elements.first().type == MoveToElement);
+}
+
+inline int QPainterPath::elementCount() const
+{
+    return d_ptr ? d_ptr->elements.size() : 0;
+}
+
+inline const QPainterPath::Element &QPainterPath::elementAt(int i) const
+{
+    Q_ASSERT(d_ptr);
+    Q_ASSERT(i >= 0 && i < elementCount());
+    return d_ptr->elements.at(i);
+}
+
+inline void QPainterPath::setElementPositionAt(int i, qreal x, qreal y)
+{
+    Q_ASSERT(d_ptr);
+    Q_ASSERT(i >= 0 && i < elementCount());
+    detach();
+    QPainterPath::Element &e = d_ptr->elements[i];
+    e.x = x;
+    e.y = y;
+}
+
+
+inline void QPainterPath::detach()
+{
+    if (d_ptr->ref != 1)
+        detach_helper();
+    setDirty(true);
+}
+
+#ifndef QT_NO_DEBUG_STREAM
+Q_GUI_EXPORT QDebug operator<<(QDebug, const QPainterPath &);
+#endif
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QPAINTERPATH_H
diff --git a/src/gui/painting/qpainterpath_p.h b/src/gui/painting/qpainterpath_p.h
new file mode 100644
index 0000000000..8e05569893
--- /dev/null
+++ b/src/gui/painting/qpainterpath_p.h
@@ -0,0 +1,278 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPAINTERPATH_P_H
+#define QPAINTERPATH_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of other Qt classes.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "QtGui/qpainterpath.h"
+#include "QtGui/qregion.h"
+#include "QtCore/qlist.h"
+#include "QtCore/qvarlengtharray.h"
+
+#include <qdebug.h>
+
+#include <private/qvectorpath_p.h>
+#include <private/qstroker_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QPainterPathStrokerPrivate
+{
+public:
+    QPainterPathStrokerPrivate();
+
+    QStroker stroker;
+    QVector<qfixed> dashPattern;
+    qreal dashOffset;
+};
+
+class QPolygonF;
+class QVectorPathConverter;
+
+class QVectorPathConverter
+{
+public:
+    QVectorPathConverter(const QVector<QPainterPath::Element> &path, uint fillRule, bool convex)
+        : pathData(path, fillRule, convex),
+          path(pathData.points.data(), path.size(),
+               pathData.elements.data(), pathData.flags) {}
+
+    const QVectorPath &vectorPath() {
+        return path;
+    }
+
+    struct QVectorPathData {
+        QVectorPathData(const QVector<QPainterPath::Element> &path, uint fillRule, bool convex)
+            : elements(path.size()),
+              points(path.size() * 2),
+              flags(0)
+        {
+            int ptsPos = 0;
+            bool isLines = true;
+            for (int i=0; i<path.size(); ++i) {
+                const QPainterPath::Element &e = path.at(i);
+                elements[i] = e.type;
+                points[ptsPos++] = e.x;
+                points[ptsPos++] = e.y;
+                if (e.type == QPainterPath::CurveToElement)
+                    flags |= QVectorPath::CurvedShapeMask;
+
+                // This is to check if the path contains only alternating lineTo/moveTo,
+                // in which case we can set the LinesHint in the path. MoveTo is 0 and
+                // LineTo is 1 so the i%2 gets us what we want cheaply.
+                isLines = isLines && e.type == (QPainterPath::ElementType) (i%2);
+            }
+
+            if (fillRule == Qt::WindingFill)
+                flags |= QVectorPath::WindingFill;
+            else
+                flags |= QVectorPath::OddEvenFill;
+
+            if (isLines)
+                flags |= QVectorPath::LinesShapeMask;
+            else {
+                flags |= QVectorPath::AreaShapeMask;
+                if (!convex)
+                    flags |= QVectorPath::NonConvexShapeMask;
+            }
+
+        }
+        QVarLengthArray<QPainterPath::ElementType> elements;
+        QVarLengthArray<qreal> points;
+        uint flags;
+    };
+
+    QVectorPathData pathData;
+    QVectorPath path;
+
+private:
+    Q_DISABLE_COPY(QVectorPathConverter)
+};
+
+class QPainterPathData : public QPainterPathPrivate
+{
+public:
+    QPainterPathData() :
+        cStart(0),
+        fillRule(Qt::OddEvenFill),
+        dirtyBounds(false),
+        dirtyControlBounds(false),
+        pathConverter(0)
+    {
+        ref = 1;
+        require_moveTo = false;
+        convex = false;
+    }
+
+    QPainterPathData(const QPainterPathData &other) :
+        QPainterPathPrivate(), cStart(other.cStart), fillRule(other.fillRule),
+        bounds(other.bounds),
+        controlBounds(other.controlBounds),
+        dirtyBounds(other.dirtyBounds),
+        dirtyControlBounds(other.dirtyControlBounds),
+        convex(other.convex),
+        pathConverter(0)
+    {
+        ref = 1;
+        require_moveTo = false;
+        elements = other.elements;
+    }
+
+    ~QPainterPathData() {
+        delete pathConverter;
+    }
+
+    inline bool isClosed() const;
+    inline void close();
+    inline void maybeMoveTo();
+
+    const QVectorPath &vectorPath() {
+        if (!pathConverter)
+            pathConverter = new QVectorPathConverter(elements, fillRule, convex);
+        return pathConverter->path;
+    }
+
+    int cStart;
+    Qt::FillRule fillRule;
+
+    QRectF bounds;
+    QRectF controlBounds;
+
+    uint require_moveTo : 1;
+    uint dirtyBounds : 1;
+    uint dirtyControlBounds : 1;
+    uint convex : 1;
+
+    QVectorPathConverter *pathConverter;
+};
+
+
+inline const QPainterPath QVectorPath::convertToPainterPath() const
+{
+        QPainterPath path;
+        path.ensureData();
+        QPainterPathData *data = path.d_func();
+        data->elements.reserve(m_count);
+        int index = 0;
+        data->elements[0].x = m_points[index++];
+        data->elements[0].y = m_points[index++];
+
+        if (m_elements) {
+            data->elements[0].type = m_elements[0];
+            for (int i=1; i<m_count; ++i) {
+                QPainterPath::Element element;
+                element.x = m_points[index++];
+                element.y = m_points[index++];
+                element.type = m_elements[i];
+                data->elements << element;
+            }
+        } else {
+            data->elements[0].type = QPainterPath::MoveToElement;
+            for (int i=1; i<m_count; ++i) {
+                QPainterPath::Element element;
+                element.x = m_points[index++];
+                element.y = m_points[index++];
+                element.type = QPainterPath::LineToElement;
+                data->elements << element;
+            }
+        }
+
+        if (m_hints & OddEvenFill)
+            data->fillRule = Qt::OddEvenFill;
+        else
+            data->fillRule = Qt::WindingFill;
+        return path;
+}
+
+void Q_GUI_EXPORT qt_find_ellipse_coords(const QRectF &r, qreal angle, qreal length,
+                                         QPointF* startPoint, QPointF *endPoint);
+
+inline bool QPainterPathData::isClosed() const
+{
+    const QPainterPath::Element &first = elements.at(cStart);
+    const QPainterPath::Element &last = elements.last();
+    return first.x == last.x && first.y == last.y;
+}
+
+inline void QPainterPathData::close()
+{
+    Q_ASSERT(ref == 1);
+    require_moveTo = true;
+    const QPainterPath::Element &first = elements.at(cStart);
+    QPainterPath::Element &last = elements.last();
+    if (first.x != last.x || first.y != last.y) {
+        if (qFuzzyCompare(first.x, last.x) && qFuzzyCompare(first.y, last.y)) {
+            last.x = first.x;
+            last.y = first.y;
+        } else {
+            QPainterPath::Element e = { first.x, first.y, QPainterPath::LineToElement };
+            elements << e;
+        }
+    }
+}
+
+inline void QPainterPathData::maybeMoveTo()
+{
+    if (require_moveTo) {
+        QPainterPath::Element e = elements.last();
+        e.type = QPainterPath::MoveToElement;
+        elements.append(e);
+        require_moveTo = false;
+    }
+}
+
+#define KAPPA 0.5522847498
+
+
+QT_END_NAMESPACE
+
+#endif // QPAINTERPATH_P_H
diff --git a/src/gui/painting/qpathclipper.cpp b/src/gui/painting/qpathclipper.cpp
new file mode 100644
index 0000000000..d18fba2e7c
--- /dev/null
+++ b/src/gui/painting/qpathclipper.cpp
@@ -0,0 +1,2149 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qpathclipper_p.h"
+
+#include <private/qbezier_p.h>
+#include <private/qdatabuffer_p.h>
+#include <private/qnumeric_p.h>
+#include <qmath.h>
+
+/**
+  The algorithm is as follows:
+
+  1. Find all intersections between the two paths (including self-intersections),
+     and build a winged edge structure of non-intersecting parts.
+  2. While there are more unhandled edges:
+    3. Pick a y-coordinate from an unhandled edge.
+    4. Intersect the horizontal line at y-coordinate with all edges.
+    5. Traverse intersections left to right deciding whether each subpath should be added or not.
+    6. If the subpath should be added, traverse the winged-edge structure and add the edges to
+       a separate winged edge structure.
+    7. Mark all edges in subpaths crossing the horizontal line as handled.
+ 8. (Optional) Simplify the resulting winged edge structure by merging shared edges.
+ 9. Convert the resulting winged edge structure to a painter path.
+ */
+
+#include <qdebug.h>
+
+QT_BEGIN_NAMESPACE
+
+static inline bool fuzzyIsNull(qreal d)
+{
+    if (sizeof(qreal) == sizeof(double))
+        return qAbs(d) <= 1e-12;
+    else
+        return qAbs(d) <= 1e-5f;
+}
+
+static inline bool comparePoints(const QPointF &a, const QPointF &b)
+{
+    return fuzzyIsNull(a.x() - b.x())
+           && fuzzyIsNull(a.y() - b.y());
+}
+
+//#define QDEBUG_CLIPPER
+static qreal dot(const QPointF &a, const QPointF &b)
+{
+    return a.x() * b.x() + a.y() * b.y();
+}
+
+static void normalize(double &x, double &y)
+{
+    double reciprocal = 1 / qSqrt(x * x + y * y);
+    x *= reciprocal;
+    y *= reciprocal;
+}
+
+struct QIntersection
+{
+    qreal alphaA;
+    qreal alphaB;
+
+    QPointF pos;
+};
+
+class QIntersectionFinder
+{
+public:
+    void produceIntersections(QPathSegments &segments);
+    bool hasIntersections(const QPathSegments &a, const QPathSegments &b) const;
+
+private:
+    bool linesIntersect(const QLineF &a, const QLineF &b) const;
+};
+
+bool QIntersectionFinder::linesIntersect(const QLineF &a, const QLineF &b) const
+{
+    const QPointF p1 = a.p1();
+    const QPointF p2 = a.p2();
+
+    const QPointF q1 = b.p1();
+    const QPointF q2 = b.p2();
+
+    if (comparePoints(p1, p2) || comparePoints(q1, q2))
+        return false;
+
+    const bool p1_equals_q1 = comparePoints(p1, q1);
+    const bool p2_equals_q2 = comparePoints(p2, q2);
+
+    if (p1_equals_q1 && p2_equals_q2)
+        return true;
+
+    const bool p1_equals_q2 = comparePoints(p1, q2);
+    const bool p2_equals_q1 = comparePoints(p2, q1);
+
+    if (p1_equals_q2 && p2_equals_q1)
+        return true;
+
+    const QPointF pDelta = p2 - p1;
+    const QPointF qDelta = q2 - q1;
+
+    const qreal par = pDelta.x() * qDelta.y() - pDelta.y() * qDelta.x();
+
+    if (qFuzzyIsNull(par)) {
+        const QPointF normal(-pDelta.y(), pDelta.x());
+
+        // coinciding?
+        if (qFuzzyIsNull(dot(normal, q1 - p1))) {
+            const qreal dp = dot(pDelta, pDelta);
+
+            const qreal tq1 = dot(pDelta, q1 - p1);
+            const qreal tq2 = dot(pDelta, q2 - p1);
+
+            if ((tq1 > 0 && tq1 < dp) || (tq2 > 0 && tq2 < dp))
+                return true;
+
+            const qreal dq = dot(qDelta, qDelta);
+
+            const qreal tp1 = dot(qDelta, p1 - q1);
+            const qreal tp2 = dot(qDelta, p2 - q1);
+
+            if ((tp1 > 0 && tp1 < dq) || (tp2 > 0 && tp2 < dq))
+                return true;
+        }
+
+        return false;
+    }
+
+    const qreal invPar = 1 / par;
+
+    const qreal tp = (qDelta.y() * (q1.x() - p1.x()) -
+                      qDelta.x() * (q1.y() - p1.y())) * invPar;
+
+    if (tp < 0 || tp > 1)
+        return false;
+
+    const qreal tq = (pDelta.y() * (q1.x() - p1.x()) -
+                      pDelta.x() * (q1.y() - p1.y())) * invPar;
+
+    return tq >= 0 && tq <= 1;
+}
+
+bool QIntersectionFinder::hasIntersections(const QPathSegments &a, const QPathSegments &b) const
+{
+    if (a.segments() == 0 || b.segments() == 0)
+        return false;
+
+    const QRectF &rb0 = b.elementBounds(0);
+
+    qreal minX = rb0.left();
+    qreal minY = rb0.top();
+    qreal maxX = rb0.right();
+    qreal maxY = rb0.bottom();
+
+    for (int i = 1; i < b.segments(); ++i) {
+        const QRectF &r = b.elementBounds(i);
+        minX = qMin(minX, r.left());
+        minY = qMin(minY, r.top());
+        maxX = qMax(maxX, r.right());
+        maxY = qMax(maxY, r.bottom());
+    }
+
+    QRectF rb(minX, minY, maxX - minX, maxY - minY);
+
+    for (int i = 0; i < a.segments(); ++i) {
+        const QRectF &r1 = a.elementBounds(i);
+
+        if (r1.left() > rb.right() || rb.left() > r1.right())
+            continue;
+        if (r1.top() > rb.bottom() || rb.top() > r1.bottom())
+            continue;
+
+        for (int j = 0; j < b.segments(); ++j) {
+            const QRectF &r2 = b.elementBounds(j);
+
+            if (r1.left() > r2.right() || r2.left() > r1.right())
+                continue;
+            if (r1.top() > r2.bottom() || r2.top() > r1.bottom())
+                continue;
+
+            if (linesIntersect(a.lineAt(i), b.lineAt(j)))
+                return true;
+        }
+    }
+
+    return false;
+}
+
+namespace {
+struct TreeNode
+{
+    qreal splitLeft;
+    qreal splitRight;
+    bool leaf;
+
+    int lowestLeftIndex;
+    int lowestRightIndex;
+
+    union {
+        struct {
+            int first;
+            int last;
+        } interval;
+        struct {
+            int left;
+            int right;
+        } children;
+    } index;
+};
+
+struct RectF
+{
+    qreal x1;
+    qreal y1;
+    qreal x2;
+    qreal y2;
+};
+
+class SegmentTree
+{
+public:
+    SegmentTree(QPathSegments &segments);
+
+    QRectF boundingRect() const;
+
+    void produceIntersections(int segment);
+
+private:
+    TreeNode buildTree(int first, int last, int depth, const RectF &bounds);
+
+    void produceIntersectionsLeaf(const TreeNode &node, int segment);
+    void produceIntersections(const TreeNode &node, int segment, const RectF &segmentBounds, const RectF &nodeBounds, int axis);
+    void intersectLines(const QLineF &a, const QLineF &b, QDataBuffer<QIntersection> &intersections);
+
+    QPathSegments &m_segments;
+    QVector<int> m_index;
+
+    RectF m_bounds;
+
+    QVector<TreeNode> m_tree;
+    QDataBuffer<QIntersection> m_intersections;
+};
+
+SegmentTree::SegmentTree(QPathSegments &segments)
+    : m_segments(segments),
+      m_intersections(0)
+{
+    m_bounds.x1 = qt_inf();
+    m_bounds.y1 = qt_inf();
+    m_bounds.x2 = -qt_inf();
+    m_bounds.y2 = -qt_inf();
+
+    m_index.resize(m_segments.segments());
+
+    for (int i = 0; i < m_index.size(); ++i) {
+        m_index[i] = i;
+
+        const QRectF &segmentBounds = m_segments.elementBounds(i);
+
+        if (segmentBounds.left() < m_bounds.x1)
+            m_bounds.x1 = segmentBounds.left();
+        if (segmentBounds.top() < m_bounds.y1)
+            m_bounds.y1 = segmentBounds.top();
+        if (segmentBounds.right() > m_bounds.x2)
+            m_bounds.x2 = segmentBounds.right();
+        if (segmentBounds.bottom() > m_bounds.y2)
+            m_bounds.y2 = segmentBounds.bottom();
+    }
+
+    m_tree.resize(1);
+
+    TreeNode root = buildTree(0, m_index.size(), 0, m_bounds);
+    m_tree[0] = root;
+}
+
+QRectF SegmentTree::boundingRect() const
+{
+    return QRectF(QPointF(m_bounds.x1, m_bounds.y1),
+                  QPointF(m_bounds.x2, m_bounds.y2));
+}
+
+static inline qreal coordinate(const QPointF &pos, int axis)
+{
+    return axis == 0 ? pos.x() : pos.y();
+}
+
+TreeNode SegmentTree::buildTree(int first, int last, int depth, const RectF &bounds)
+{
+    if (depth >= 24 || (last - first) <= 10) {
+        TreeNode node;
+        node.leaf = true;
+        node.index.interval.first = first;
+        node.index.interval.last = last;
+
+        return node;
+    }
+
+    int splitAxis = (depth & 1);
+
+    TreeNode node;
+    node.leaf = false;
+
+    qreal split = 0.5f * ((&bounds.x1)[splitAxis] + (&bounds.x2)[splitAxis]);
+
+    node.splitLeft = (&bounds.x1)[splitAxis];
+    node.splitRight = (&bounds.x2)[splitAxis];
+
+    node.lowestLeftIndex = INT_MAX;
+    node.lowestRightIndex = INT_MAX;
+
+    const int treeSize = m_tree.size();
+
+    node.index.children.left = treeSize;
+    node.index.children.right = treeSize + 1;
+
+    m_tree.resize(treeSize + 2);
+
+    int l = first;
+    int r = last - 1;
+
+    // partition into left and right sets
+    while (l <= r) {
+        const int index = m_index.at(l);
+        const QRectF &segmentBounds = m_segments.elementBounds(index);
+
+        qreal lowCoordinate = coordinate(segmentBounds.topLeft(), splitAxis);
+
+        if (coordinate(segmentBounds.center(), splitAxis) < split) {
+            qreal highCoordinate = coordinate(segmentBounds.bottomRight(), splitAxis);
+            if (highCoordinate > node.splitLeft)
+                node.splitLeft = highCoordinate;
+            if (index < node.lowestLeftIndex)
+                node.lowestLeftIndex = index;
+            ++l;
+        } else {
+            if (lowCoordinate < node.splitRight)
+                node.splitRight = lowCoordinate;
+            if (index < node.lowestRightIndex)
+                node.lowestRightIndex = index;
+            qSwap(m_index[l], m_index[r]);
+            --r;
+        }
+    }
+
+    RectF lbounds = bounds;
+    (&lbounds.x2)[splitAxis] = node.splitLeft;
+
+    RectF rbounds = bounds;
+    (&rbounds.x1)[splitAxis] = node.splitRight;
+
+    TreeNode left = buildTree(first, l, depth + 1, lbounds);
+    m_tree[node.index.children.left] = left;
+
+    TreeNode right = buildTree(l, last, depth + 1, rbounds);
+    m_tree[node.index.children.right] = right;
+
+    return node;
+}
+
+void SegmentTree::intersectLines(const QLineF &a, const QLineF &b, QDataBuffer<QIntersection> &intersections)
+{
+    const QPointF p1 = a.p1();
+    const QPointF p2 = a.p2();
+
+    const QPointF q1 = b.p1();
+    const QPointF q2 = b.p2();
+
+    if (comparePoints(p1, p2) || comparePoints(q1, q2))
+        return;
+
+    const bool p1_equals_q1 = comparePoints(p1, q1);
+    const bool p2_equals_q2 = comparePoints(p2, q2);
+
+    if (p1_equals_q1 && p2_equals_q2)
+        return;
+
+    const bool p1_equals_q2 = comparePoints(p1, q2);
+    const bool p2_equals_q1 = comparePoints(p2, q1);
+
+    if (p1_equals_q2 && p2_equals_q1)
+        return;
+
+    const QPointF pDelta = p2 - p1;
+    const QPointF qDelta = q2 - q1;
+
+    const qreal par = pDelta.x() * qDelta.y() - pDelta.y() * qDelta.x();
+
+    if (qFuzzyIsNull(par)) {
+        const QPointF normal(-pDelta.y(), pDelta.x());
+
+        // coinciding?
+        if (qFuzzyIsNull(dot(normal, q1 - p1))) {
+            const qreal invDp = 1 / dot(pDelta, pDelta);
+
+            const qreal tq1 = dot(pDelta, q1 - p1) * invDp;
+            const qreal tq2 = dot(pDelta, q2 - p1) * invDp;
+
+            if (tq1 > 0 && tq1 < 1) {
+                QIntersection intersection;
+                intersection.alphaA = tq1;
+                intersection.alphaB = 0;
+                intersection.pos = q1;
+                intersections.add(intersection);
+            }
+
+            if (tq2 > 0 && tq2 < 1) {
+                QIntersection intersection;
+                intersection.alphaA = tq2;
+                intersection.alphaB = 1;
+                intersection.pos = q2;
+                intersections.add(intersection);
+            }
+
+            const qreal invDq = 1 / dot(qDelta, qDelta);
+
+            const qreal tp1 = dot(qDelta, p1 - q1) * invDq;
+            const qreal tp2 = dot(qDelta, p2 - q1) * invDq;
+
+            if (tp1 > 0 && tp1 < 1) {
+                QIntersection intersection;
+                intersection.alphaA = 0;
+                intersection.alphaB = tp1;
+                intersection.pos = p1;
+                intersections.add(intersection);
+            }
+
+            if (tp2 > 0 && tp2 < 1) {
+                QIntersection intersection;
+                intersection.alphaA = 1;
+                intersection.alphaB = tp2;
+                intersection.pos = p2;
+                intersections.add(intersection);
+            }
+        }
+
+        return;
+    }
+
+    // if the lines are not parallel and share a common end point, then they
+    // don't intersect
+    if (p1_equals_q1 || p1_equals_q2 || p2_equals_q1 || p2_equals_q2)
+        return;
+
+
+    const qreal tp = (qDelta.y() * (q1.x() - p1.x()) -
+                      qDelta.x() * (q1.y() - p1.y())) / par;
+    const qreal tq = (pDelta.y() * (q1.x() - p1.x()) -
+                      pDelta.x() * (q1.y() - p1.y())) / par;
+
+    if (tp<0 || tp>1 || tq<0 || tq>1)
+        return;
+
+    const bool p_zero = qFuzzyIsNull(tp);
+    const bool p_one = qFuzzyIsNull(tp - 1);
+
+    const bool q_zero = qFuzzyIsNull(tq);
+    const bool q_one = qFuzzyIsNull(tq - 1);
+
+    if ((q_zero || q_one) && (p_zero || p_one))
+        return;
+
+    QPointF pt;
+    if (p_zero) {
+        pt = p1;
+    } else if (p_one) {
+        pt = p2;
+    } else if (q_zero) {
+        pt = q1;
+    } else if (q_one) {
+        pt = q2;
+    } else {
+        pt = q1 + (q2 - q1) * tq;
+    }
+
+    QIntersection intersection;
+    intersection.alphaA = tp;
+    intersection.alphaB = tq;
+    intersection.pos = pt;
+    intersections.add(intersection);
+}
+
+void SegmentTree::produceIntersections(int segment)
+{
+    const QRectF &segmentBounds = m_segments.elementBounds(segment);
+
+    RectF sbounds;
+    sbounds.x1 = segmentBounds.left();
+    sbounds.y1 = segmentBounds.top();
+    sbounds.x2 = segmentBounds.right();
+    sbounds.y2 = segmentBounds.bottom();
+
+    produceIntersections(m_tree.at(0), segment, sbounds, m_bounds, 0);
+}
+
+void SegmentTree::produceIntersectionsLeaf(const TreeNode &node, int segment)
+{
+    const QRectF &r1 = m_segments.elementBounds(segment);
+    const QLineF lineA = m_segments.lineAt(segment);
+
+    for (int i = node.index.interval.first; i < node.index.interval.last; ++i) {
+        const int other = m_index.at(i);
+        if (other >= segment)
+            continue;
+
+        const QRectF &r2 = m_segments.elementBounds(other);
+
+        if (r1.left() > r2.right() || r2.left() > r1.right())
+            continue;
+        if (r1.top() > r2.bottom() || r2.top() > r1.bottom())
+            continue;
+
+        m_intersections.reset();
+
+        const QLineF lineB = m_segments.lineAt(other);
+
+        intersectLines(lineA, lineB, m_intersections);
+
+        for (int k = 0; k < m_intersections.size(); ++k) {
+            QPathSegments::Intersection i_isect, j_isect;
+            i_isect.vertex = j_isect.vertex = m_segments.addPoint(m_intersections.at(k).pos);
+
+            i_isect.t = m_intersections.at(k).alphaA;
+            j_isect.t = m_intersections.at(k).alphaB;
+
+            i_isect.next = 0;
+            j_isect.next = 0;
+
+            m_segments.addIntersection(segment, i_isect);
+            m_segments.addIntersection(other, j_isect);
+        }
+    }
+}
+
+void SegmentTree::produceIntersections(const TreeNode &node, int segment, const RectF &segmentBounds, const RectF &nodeBounds, int axis)
+{
+    if (node.leaf) {
+        produceIntersectionsLeaf(node, segment);
+        return;
+    }
+
+    RectF lbounds = nodeBounds;
+    (&lbounds.x2)[axis] = node.splitLeft;
+
+    RectF rbounds = nodeBounds;
+    (&rbounds.x1)[axis] = node.splitRight;
+
+    if (segment > node.lowestLeftIndex && (&segmentBounds.x1)[axis] <= node.splitLeft)
+        produceIntersections(m_tree.at(node.index.children.left), segment, segmentBounds, lbounds, !axis);
+
+    if (segment > node.lowestRightIndex && (&segmentBounds.x2)[axis] >= node.splitRight)
+        produceIntersections(m_tree.at(node.index.children.right), segment, segmentBounds, rbounds, !axis);
+}
+
+}
+
+void QIntersectionFinder::produceIntersections(QPathSegments &segments)
+{
+    SegmentTree tree(segments);
+
+    for (int i = 0; i < segments.segments(); ++i)
+        tree.produceIntersections(i);
+}
+
+class QKdPointTree
+{
+public:
+    enum Traversal {
+        TraverseBoth,
+        TraverseLeft,
+        TraverseRight,
+        TraverseNone
+    };
+
+    struct Node {
+        int point;
+        int id;
+
+        Node *left;
+        Node *right;
+    };
+
+    QKdPointTree(const QPathSegments &segments)
+        : m_segments(&segments)
+        , m_nodes(m_segments->points())
+        , m_id(0)
+    {
+        m_nodes.resize(m_segments->points());
+
+        for (int i = 0; i < m_nodes.size(); ++i) {
+            m_nodes.at(i).point = i;
+            m_nodes.at(i).id = -1;
+        }
+
+        m_rootNode = build(0, m_nodes.size());
+    }
+
+    int build(int begin, int end, int depth = 0);
+
+    Node *rootNode()
+    {
+        return &m_nodes.at(m_rootNode);
+    }
+
+    inline int nextId()
+    {
+        return m_id++;
+    }
+
+private:
+    const QPathSegments *m_segments;
+    QDataBuffer<Node> m_nodes;
+
+    int m_rootNode;
+    int m_id;
+};
+
+template <typename T>
+void qTraverseKdPointTree(QKdPointTree::Node &node, T &t, int depth = 0)
+{
+    QKdPointTree::Traversal status = t(node, depth);
+
+    const bool traverseRight = (status == QKdPointTree::TraverseBoth || status == QKdPointTree::TraverseRight);
+    const bool traverseLeft = (status == QKdPointTree::TraverseBoth || status == QKdPointTree::TraverseLeft);
+
+    if (traverseLeft && node.left)
+        QT_PREPEND_NAMESPACE(qTraverseKdPointTree<T>)(*node.left, t, depth + 1);
+
+    if (traverseRight && node.right)
+        QT_PREPEND_NAMESPACE(qTraverseKdPointTree<T>)(*node.right, t, depth + 1);
+}
+
+static inline qreal component(const QPointF &point, unsigned int i)
+{
+    Q_ASSERT(i < 2);
+    const qreal components[] = { point.x(), point.y() };
+    return components[i];
+}
+
+int QKdPointTree::build(int begin, int end, int depth)
+{
+    Q_ASSERT(end > begin);
+
+    const qreal pivot = component(m_segments->pointAt(m_nodes.at(begin).point), depth & 1);
+
+    int first = begin + 1;
+    int last = end - 1;
+
+    while (first <= last) {
+        const qreal value = component(m_segments->pointAt(m_nodes.at(first).point), depth & 1);
+
+        if (value < pivot)
+            ++first;
+        else {
+            qSwap(m_nodes.at(first), m_nodes.at(last));
+            --last;
+        }
+    }
+
+    qSwap(m_nodes.at(last), m_nodes.at(begin));
+
+    if (last > begin)
+        m_nodes.at(last).left = &m_nodes.at(build(begin, last, depth + 1));
+    else
+        m_nodes.at(last).left = 0;
+
+    if (last + 1 < end)
+        m_nodes.at(last).right = &m_nodes.at(build(last + 1, end, depth + 1));
+    else
+        m_nodes.at(last).right = 0;
+
+    return last;
+}
+
+class QKdPointFinder
+{
+public:
+    QKdPointFinder(int point, const QPathSegments &segments, QKdPointTree &tree)
+        : m_point(point)
+        , m_result(-1)
+        , m_segments(&segments)
+        , m_tree(&tree)
+    {
+        pointComponents[0] = segments.pointAt(point).x();
+        pointComponents[1] = segments.pointAt(point).y();
+    }
+
+    inline QKdPointTree::Traversal operator()(QKdPointTree::Node &node, int depth)
+    {
+        if (m_result != -1)
+            return QKdPointTree::TraverseNone;
+
+        const QPointF &nodePoint = m_segments->pointAt(node.point);
+
+        const qreal pivotComponents[] = { nodePoint.x(), nodePoint.y() };
+
+        const qreal pivot = pivotComponents[depth & 1];
+        const qreal value = pointComponents[depth & 1];
+
+        if (fuzzyIsNull(pivot - value)) {
+            const qreal pivot2 = pivotComponents[(depth + 1) & 1];
+            const qreal value2 = pointComponents[(depth + 1) & 1];
+
+            if (fuzzyIsNull(pivot2 - value2)) {
+                if (node.id < 0)
+                    node.id = m_tree->nextId();
+
+                m_result = node.id;
+                return QKdPointTree::TraverseNone;
+            } else
+                return QKdPointTree::TraverseBoth;
+        } else if (value < pivot) {
+            return QKdPointTree::TraverseLeft;
+        } else {
+            return QKdPointTree::TraverseRight;
+        }
+    }
+
+    int result() const
+    {
+        return m_result;
+    }
+
+private:
+    int m_point;
+    qreal pointComponents[2];
+    int m_result;
+    const QPathSegments *m_segments;
+    QKdPointTree *m_tree;
+};
+
+// merge all points that are within qFuzzyCompare range of each other
+void QPathSegments::mergePoints()
+{
+    QKdPointTree tree(*this);
+
+    if (tree.rootNode()) {
+        QDataBuffer<QPointF> mergedPoints(points());
+        QDataBuffer<int> pointIndices(points());
+
+        for (int i = 0; i < points(); ++i) {
+            QKdPointFinder finder(i, *this, tree);
+            QT_PREPEND_NAMESPACE(qTraverseKdPointTree<QKdPointFinder>)(*tree.rootNode(), finder);
+
+            Q_ASSERT(finder.result() != -1);
+
+            if (finder.result() >= mergedPoints.size())
+                mergedPoints << m_points.at(i);
+
+            pointIndices << finder.result();
+        }
+
+        for (int i = 0; i < m_segments.size(); ++i) {
+            m_segments.at(i).va = pointIndices.at(m_segments.at(i).va);
+            m_segments.at(i).vb = pointIndices.at(m_segments.at(i).vb);
+        }
+
+        for (int i = 0; i < m_intersections.size(); ++i)
+            m_intersections.at(i).vertex = pointIndices.at(m_intersections.at(i).vertex);
+
+        m_points.swap(mergedPoints);
+    }
+}
+
+void QWingedEdge::intersectAndAdd()
+{
+    QIntersectionFinder finder;
+    finder.produceIntersections(m_segments);
+
+    m_segments.mergePoints();
+
+    for (int i = 0; i < m_segments.points(); ++i)
+        addVertex(m_segments.pointAt(i));
+
+    QDataBuffer<QPathSegments::Intersection> intersections(m_segments.segments());
+    for (int i = 0; i < m_segments.segments(); ++i) {
+        intersections.reset();
+
+        int pathId = m_segments.pathId(i);
+
+        const QPathSegments::Intersection *isect = m_segments.intersectionAt(i);
+        while (isect) {
+            intersections << *isect;
+
+            if (isect->next) {
+                isect += isect->next;
+            } else {
+                isect = 0;
+            }
+        }
+
+        qSort(intersections.data(), intersections.data() + intersections.size());
+
+        int first = m_segments.segmentAt(i).va;
+        int second = m_segments.segmentAt(i).vb;
+
+        int last = first;
+        for (int j = 0; j < intersections.size(); ++j) {
+            const QPathSegments::Intersection &isect = intersections.at(j);
+
+            QPathEdge *ep = edge(addEdge(last, isect.vertex));
+
+            if (ep) {
+                const int dir = m_segments.pointAt(last).y() < m_segments.pointAt(isect.vertex).y() ? 1 : -1;
+                if (pathId == 0)
+                    ep->windingA += dir;
+                else
+                    ep->windingB += dir;
+            }
+
+            last = isect.vertex;
+        }
+
+        QPathEdge *ep = edge(addEdge(last, second));
+
+        if (ep) {
+            const int dir = m_segments.pointAt(last).y() < m_segments.pointAt(second).y() ? 1 : -1;
+            if (pathId == 0)
+                ep->windingA += dir;
+            else
+                ep->windingB += dir;
+        }
+    }
+}
+
+QWingedEdge::QWingedEdge() :
+    m_edges(0),
+    m_vertices(0),
+    m_segments(0)
+{
+}
+
+QWingedEdge::QWingedEdge(const QPainterPath &subject, const QPainterPath &clip) :
+    m_edges(subject.elementCount()),
+    m_vertices(subject.elementCount()),
+    m_segments(subject.elementCount())
+{
+    m_segments.setPath(subject);
+    m_segments.addPath(clip);
+
+    intersectAndAdd();
+}
+
+QWingedEdge::TraversalStatus QWingedEdge::next(const QWingedEdge::TraversalStatus &status) const
+{
+    const QPathEdge *sp = edge(status.edge);
+    Q_ASSERT(sp);
+
+    TraversalStatus result;
+    result.edge = sp->next(status.traversal, status.direction);
+    result.traversal = status.traversal;
+    result.direction = status.direction;
+
+    const QPathEdge *rp = edge(result.edge);
+    Q_ASSERT(rp);
+
+    if (sp->vertex(status.direction) == rp->vertex(status.direction))
+        result.flip();
+
+    return result;
+}
+
+static bool isLine(const QBezier &bezier)
+{
+    const bool equal_1_2 = comparePoints(bezier.pt1(), bezier.pt2());
+    const bool equal_2_3 = comparePoints(bezier.pt2(), bezier.pt3());
+    const bool equal_3_4 = comparePoints(bezier.pt3(), bezier.pt4());
+
+    // point?
+    if (equal_1_2 && equal_2_3 && equal_3_4)
+        return true;
+
+    if (comparePoints(bezier.pt1(), bezier.pt4()))
+        return equal_1_2 || equal_3_4;
+
+    return (equal_1_2 && equal_3_4) || (equal_1_2 && equal_2_3) || (equal_2_3 && equal_3_4);
+}
+
+void QPathSegments::setPath(const QPainterPath &path)
+{
+    m_points.reset();
+    m_intersections.reset();
+    m_segments.reset();
+
+    m_pathId = 0;
+
+    addPath(path);
+}
+
+void QPathSegments::addPath(const QPainterPath &path)
+{
+    int firstSegment = m_segments.size();
+
+    bool hasMoveTo = false;
+    int lastMoveTo = 0;
+    int last = 0;
+    for (int i = 0; i < path.elementCount(); ++i) {
+        int current = m_points.size();
+
+        QPointF currentPoint;
+        if (path.elementAt(i).type == QPainterPath::CurveToElement)
+            currentPoint = path.elementAt(i+2);
+        else
+            currentPoint = path.elementAt(i);
+
+        if (i > 0 && comparePoints(m_points.at(lastMoveTo), currentPoint))
+            current = lastMoveTo;
+        else
+            m_points << currentPoint;
+
+        switch (path.elementAt(i).type) {
+        case QPainterPath::MoveToElement:
+            if (hasMoveTo && last != lastMoveTo && !comparePoints(m_points.at(last), m_points.at(lastMoveTo)))
+                m_segments << Segment(m_pathId, last, lastMoveTo);
+            hasMoveTo = true;
+            last = lastMoveTo = current;
+            break;
+        case QPainterPath::LineToElement:
+            m_segments << Segment(m_pathId, last, current);
+            last = current;
+            break;
+        case QPainterPath::CurveToElement:
+            {
+                QBezier bezier = QBezier::fromPoints(m_points.at(last), path.elementAt(i), path.elementAt(i+1), path.elementAt(i+2));
+                if (isLine(bezier)) {
+                    m_segments << Segment(m_pathId, last, current);
+                } else {
+                    QRectF bounds = bezier.bounds();
+
+                    // threshold based on similar algorithm as in qtriangulatingstroker.cpp
+                    int threshold = qMin<float>(64, qMax(bounds.width(), bounds.height()) * (2 * qreal(3.14) / 6));
+
+                    if (threshold < 3) threshold = 3;
+                    qreal one_over_threshold_minus_1 = qreal(1) / (threshold - 1);
+
+                    for (int t = 1; t < threshold - 1; ++t) {
+                        currentPoint = bezier.pointAt(t * one_over_threshold_minus_1);
+
+                        int index = m_points.size();
+                        m_segments << Segment(m_pathId, last, index);
+                        last = index;
+
+                        m_points << currentPoint;
+                    }
+
+                    m_segments << Segment(m_pathId, last, current);
+                }
+            }
+            last = current;
+            i += 2;
+            break;
+        default:
+            Q_ASSERT(false);
+            break;
+        }
+    }
+
+    if (hasMoveTo && last != lastMoveTo && !comparePoints(m_points.at(last), m_points.at(lastMoveTo)))
+        m_segments << Segment(m_pathId, last, lastMoveTo);
+
+    for (int i = firstSegment; i < m_segments.size(); ++i) {
+        const QLineF line = lineAt(i);
+
+        qreal x1 = line.p1().x();
+        qreal y1 = line.p1().y();
+        qreal x2 = line.p2().x();
+        qreal y2 = line.p2().y();
+
+        if (x2 < x1)
+            qSwap(x1, x2);
+        if (y2 < y1)
+            qSwap(y1, y2);
+
+        m_segments.at(i).bounds = QRectF(x1, y1, x2 - x1, y2 - y1);
+    }
+
+    ++m_pathId;
+}
+
+qreal QWingedEdge::delta(int vertex, int a, int b) const
+{
+    const QPathEdge *ap = edge(a);
+    const QPathEdge *bp = edge(b);
+
+    double a_angle = ap->angle;
+    double b_angle = bp->angle;
+
+    if (vertex == ap->second)
+        a_angle = ap->invAngle;
+
+    if (vertex == bp->second)
+        b_angle = bp->invAngle;
+
+    double result = b_angle - a_angle;
+
+    if (result >= 128.)
+        return result - 128.;
+    else if (result < 0)
+        return result + 128.;
+    else
+        return result;
+}
+
+static inline QPointF midPoint(const QWingedEdge &list, int ei)
+{
+    const QPathEdge *ep = list.edge(ei);
+    Q_ASSERT(ep);
+
+    const QPointF a = *list.vertex(ep->first);
+    const QPointF b = *list.vertex(ep->second);
+    return a + 0.5 * (b - a);
+}
+
+QWingedEdge::TraversalStatus QWingedEdge::findInsertStatus(int vi, int ei) const
+{
+    const QPathVertex *vp = vertex(vi);
+
+    Q_ASSERT(vp);
+    Q_ASSERT(ei >= 0);
+    Q_ASSERT(vp->edge >= 0);
+
+    int position = vp->edge;
+    qreal d = 128.;
+
+    TraversalStatus status;
+    status.direction = edge(vp->edge)->directionTo(vi);
+    status.traversal = QPathEdge::RightTraversal;
+    status.edge = vp->edge;
+
+#ifdef QDEBUG_CLIPPER
+    const QPathEdge *ep = edge(ei);
+    qDebug() << "Finding insert status for edge" << ei << "at vertex" << QPointF(*vp) << ", angles: " << ep->angle << ep->invAngle;
+#endif
+
+    do {
+        status = next(status);
+        status.flip();
+
+        Q_ASSERT(edge(status.edge)->vertex(status.direction) == vi);
+        qreal d2 = delta(vi, ei, status.edge);
+
+#ifdef QDEBUG_CLIPPER
+        const QPathEdge *op = edge(status.edge);
+        qDebug() << "Delta to edge" << status.edge << d2 << ", angles: " << op->angle << op->invAngle;
+#endif
+
+        if (d2 < d) {
+            position = status.edge;
+            d = d2;
+        }
+    } while (status.edge != vp->edge);
+
+    status.traversal = QPathEdge::LeftTraversal;
+    status.direction = QPathEdge::Forward;
+    status.edge = position;
+
+    if (edge(status.edge)->vertex(status.direction) != vi)
+        status.flip();
+
+#ifdef QDEBUG_CLIPPER
+    qDebug() << "Inserting edge" << ei << "to" << (status.traversal == QPathEdge::LeftTraversal ? "left" : "right") << "of edge" << status.edge;
+#endif
+
+    Q_ASSERT(edge(status.edge)->vertex(status.direction) == vi);
+
+    return status;
+}
+
+void QWingedEdge::removeEdge(int ei)
+{
+    QPathEdge *ep = edge(ei);
+
+    TraversalStatus status;
+    status.direction = QPathEdge::Forward;
+    status.traversal = QPathEdge::RightTraversal;
+    status.edge = ei;
+
+    TraversalStatus forwardRight = next(status);
+    forwardRight.flipDirection();
+
+    status.traversal = QPathEdge::LeftTraversal;
+    TraversalStatus forwardLeft = next(status);
+    forwardLeft.flipDirection();
+
+    status.direction = QPathEdge::Backward;
+    TraversalStatus backwardLeft = next(status);
+    backwardLeft.flipDirection();
+
+    status.traversal = QPathEdge::RightTraversal;
+    TraversalStatus backwardRight = next(status);
+    backwardRight.flipDirection();
+
+    edge(forwardRight.edge)->setNext(forwardRight.traversal, forwardRight.direction, forwardLeft.edge);
+    edge(forwardLeft.edge)->setNext(forwardLeft.traversal, forwardLeft.direction, forwardRight.edge);
+
+    edge(backwardRight.edge)->setNext(backwardRight.traversal, backwardRight.direction, backwardLeft.edge);
+    edge(backwardLeft.edge)->setNext(backwardLeft.traversal, backwardLeft.direction, backwardRight.edge);
+
+    ep->setNext(QPathEdge::Forward, ei);
+    ep->setNext(QPathEdge::Backward, ei);
+
+    QPathVertex *a = vertex(ep->first);
+    QPathVertex *b = vertex(ep->second);
+
+    a->edge = backwardRight.edge;
+    b->edge = forwardRight.edge;
+}
+
+static int commonEdge(const QWingedEdge &list, int a, int b)
+{
+    const QPathVertex *ap = list.vertex(a);
+    Q_ASSERT(ap);
+
+    const QPathVertex *bp = list.vertex(b);
+    Q_ASSERT(bp);
+
+    if (ap->edge < 0 || bp->edge < 0)
+        return -1;
+
+    QWingedEdge::TraversalStatus status;
+    status.edge = ap->edge;
+    status.direction = list.edge(status.edge)->directionTo(a);
+    status.traversal = QPathEdge::RightTraversal;
+
+    do {
+        const QPathEdge *ep = list.edge(status.edge);
+
+        if ((ep->first == a && ep->second == b)
+            || (ep->first == b && ep->second == a))
+            return status.edge;
+
+        status = list.next(status);
+        status.flip();
+    } while (status.edge != ap->edge);
+
+    return -1;
+}
+
+static double computeAngle(const QPointF &v)
+{
+#if 1
+    if (v.x() == 0) {
+        return v.y() <= 0 ? 0 : 64.;
+    } else if (v.y() == 0) {
+        return v.x() <= 0 ? 32. : 96.;
+    }
+
+    double vx = v.x();
+    double vy = v.y();
+    normalize(vx, vy);
+    if (vy < 0) {
+        if (vx < 0) { // 0 - 32
+            return -32. * vx;
+        } else { // 96 - 128
+            return 128. - 32. * vx;
+        }
+    } else { // 32 - 96
+        return 64. + 32. * vx;
+    }
+#else
+    // doesn't seem to be robust enough
+    return qAtan2(v.x(), v.y()) + Q_PI;
+#endif
+}
+
+int QWingedEdge::addEdge(const QPointF &a, const QPointF &b)
+{
+    int fi = insert(a);
+    int si = insert(b);
+
+    return addEdge(fi, si);
+}
+
+int QWingedEdge::addEdge(int fi, int si)
+{
+    if (fi == si)
+        return -1;
+
+    int common = commonEdge(*this, fi, si);
+    if (common >= 0)
+        return common;
+
+    m_edges << QPathEdge(fi, si);
+
+    int ei = m_edges.size() - 1;
+
+    QPathVertex *fp = vertex(fi);
+    QPathVertex *sp = vertex(si);
+
+    QPathEdge *ep = edge(ei);
+
+    const QPointF tangent = QPointF(*sp) - QPointF(*fp);
+    ep->angle = computeAngle(tangent);
+    ep->invAngle = ep->angle + 64;
+    if (ep->invAngle >= 128)
+        ep->invAngle -= 128;
+
+    QPathVertex *vertices[2] = { fp, sp };
+    QPathEdge::Direction dirs[2] = { QPathEdge::Backward, QPathEdge::Forward };
+
+#ifdef QDEBUG_CLIPPER
+    printf("** Adding edge %d / vertices: %.07f %.07f, %.07f %.07f\n", ei, fp->x, fp->y, sp->x, sp->y);
+#endif
+
+    for (int i = 0; i < 2; ++i) {
+        QPathVertex *vp = vertices[i];
+        if (vp->edge < 0) {
+            vp->edge = ei;
+            ep->setNext(dirs[i], ei);
+        } else {
+            int vi = ep->vertex(dirs[i]);
+            Q_ASSERT(vertex(vi) == vertices[i]);
+
+            TraversalStatus os = findInsertStatus(vi, ei);
+            QPathEdge *op = edge(os.edge);
+
+            Q_ASSERT(vertex(op->vertex(os.direction)) == vertices[i]);
+
+            TraversalStatus ns = next(os);
+            ns.flipDirection();
+            QPathEdge *np = edge(ns.edge);
+
+            op->setNext(os.traversal, os.direction, ei);
+            np->setNext(ns.traversal, ns.direction, ei);
+
+            int oe = os.edge;
+            int ne = ns.edge;
+
+            os = next(os);
+            ns = next(ns);
+
+            os.flipDirection();
+            ns.flipDirection();
+
+            Q_ASSERT(os.edge == ei);
+            Q_ASSERT(ns.edge == ei);
+
+            ep->setNext(os.traversal, os.direction, oe);
+            ep->setNext(ns.traversal, ns.direction, ne);
+        }
+    }
+
+    Q_ASSERT(ep->next(QPathEdge::RightTraversal, QPathEdge::Forward) >= 0);
+    Q_ASSERT(ep->next(QPathEdge::RightTraversal, QPathEdge::Backward) >= 0);
+    Q_ASSERT(ep->next(QPathEdge::LeftTraversal, QPathEdge::Forward) >= 0);
+    Q_ASSERT(ep->next(QPathEdge::LeftTraversal, QPathEdge::Backward) >= 0);
+
+    return ei;
+}
+
+int QWingedEdge::insert(const QPathVertex &vertex)
+{
+    if (!m_vertices.isEmpty()) {
+        const QPathVertex &last = m_vertices.last();
+        if (vertex.x == last.x && vertex.y == last.y)
+            return m_vertices.size() - 1;
+
+        for (int i = 0; i < m_vertices.size(); ++i) {
+            const QPathVertex &v = m_vertices.at(i);
+            if (qFuzzyCompare(v.x, vertex.x) && qFuzzyCompare(v.y, vertex.y)) {
+                return i;
+            }
+        }
+    }
+
+    m_vertices << vertex;
+    return m_vertices.size() - 1;
+}
+
+static void addLineTo(QPainterPath &path, const QPointF &point)
+{
+    const int elementCount = path.elementCount();
+    if (elementCount >= 2) {
+        const QPainterPath::Element &middle = path.elementAt(elementCount - 1);
+        if (middle.type == QPainterPath::LineToElement) {
+            const QPointF first = path.elementAt(elementCount - 2);
+            const QPointF d1 = point - first;
+            const QPointF d2 = middle - first;
+
+            const QPointF p(-d1.y(), d1.x());
+
+            if (qFuzzyIsNull(dot(p, d2))) {
+                path.setElementPositionAt(elementCount - 1, point.x(), point.y());
+                return;
+            }
+        }
+    }
+
+    path.lineTo(point);
+}
+
+static void add(QPainterPath &path, const QWingedEdge &list, int edge, QPathEdge::Traversal traversal)
+{
+    QWingedEdge::TraversalStatus status;
+    status.edge = edge;
+    status.traversal = traversal;
+    status.direction = QPathEdge::Forward;
+
+    path.moveTo(*list.vertex(list.edge(edge)->first));
+
+    do {
+        const QPathEdge *ep = list.edge(status.edge);
+
+        addLineTo(path, *list.vertex(ep->vertex(status.direction)));
+
+        if (status.traversal == QPathEdge::LeftTraversal)
+            ep->flag &= ~16;
+        else
+            ep->flag &= ~32;
+
+        status = list.next(status);
+    } while (status.edge != edge);
+}
+
+void QWingedEdge::simplify()
+{
+    for (int i = 0; i < edgeCount(); ++i) {
+        const QPathEdge *ep = edge(i);
+
+        // if both sides are part of the inside then we can collapse the edge
+        int flag = 0x3 << 4;
+        if ((ep->flag & flag) == flag) {
+            removeEdge(i);
+
+            ep->flag &= ~flag;
+        }
+    }
+}
+
+QPainterPath QWingedEdge::toPath() const
+{
+    QPainterPath path;
+
+    for (int i = 0; i < edgeCount(); ++i) {
+        const QPathEdge *ep = edge(i);
+
+        if (ep->flag & 16) {
+            add(path, *this, i, QPathEdge::LeftTraversal);
+        }
+
+        if (ep->flag & 32)
+            add(path, *this, i, QPathEdge::RightTraversal);
+    }
+
+    return path;
+}
+
+bool QPathClipper::intersect()
+{
+    if (subjectPath == clipPath)
+        return true;
+
+    QRectF r1 = subjectPath.controlPointRect();
+    QRectF r2 = clipPath.controlPointRect();
+    if (qMax(r1.x(), r2.x()) > qMin(r1.x() + r1.width(), r2.x() + r2.width()) ||
+        qMax(r1.y(), r2.y()) > qMin(r1.y() + r1.height(), r2.y() + r2.height())) {
+        // no way we could intersect
+        return false;
+    }
+
+    bool subjectIsRect = pathToRect(subjectPath);
+    bool clipIsRect = pathToRect(clipPath);
+
+    if (subjectIsRect && clipIsRect)
+        return true;
+    else if (subjectIsRect)
+        return clipPath.intersects(r1);
+    else if (clipIsRect)
+        return subjectPath.intersects(r2);
+
+    QPathSegments a(subjectPath.elementCount());
+    a.setPath(subjectPath);
+    QPathSegments b(clipPath.elementCount());
+    b.setPath(clipPath);
+
+    QIntersectionFinder finder;
+    if (finder.hasIntersections(a, b))
+        return true;
+
+    for (int i = 0; i < clipPath.elementCount(); ++i) {
+        if (clipPath.elementAt(i).type == QPainterPath::MoveToElement) {
+            const QPointF point = clipPath.elementAt(i);
+            if (r1.contains(point) && subjectPath.contains(point))
+                return true;
+        }
+    }
+
+    for (int i = 0; i < subjectPath.elementCount(); ++i) {
+        if (subjectPath.elementAt(i).type == QPainterPath::MoveToElement) {
+            const QPointF point = subjectPath.elementAt(i);
+            if (r2.contains(point) && clipPath.contains(point))
+                return true;
+        }
+    }
+
+    return false;
+}
+
+bool QPathClipper::contains()
+{
+    if (subjectPath == clipPath)
+        return false;
+
+    QRectF r1 = subjectPath.controlPointRect();
+    QRectF r2 = clipPath.controlPointRect();
+    if (qMax(r1.x(), r2.x()) > qMin(r1.x() + r1.width(), r2.x() + r2.width()) ||
+        qMax(r1.y(), r2.y()) > qMin(r1.y() + r1.height(), r2.y() + r2.height())) {
+        // no intersection -> not contained
+        return false;
+    }
+
+    bool clipIsRect = pathToRect(clipPath);
+    if (clipIsRect)
+        return subjectPath.contains(r2);
+
+    QPathSegments a(subjectPath.elementCount());
+    a.setPath(subjectPath);
+    QPathSegments b(clipPath.elementCount());
+    b.setPath(clipPath);
+
+    QIntersectionFinder finder;
+    if (finder.hasIntersections(a, b))
+        return false;
+
+    for (int i = 0; i < clipPath.elementCount(); ++i) {
+        if (clipPath.elementAt(i).type == QPainterPath::MoveToElement) {
+            const QPointF point = clipPath.elementAt(i);
+            if (!r1.contains(point) || !subjectPath.contains(point))
+                return false;
+        }
+    }
+
+    return true;
+}
+
+QPathClipper::QPathClipper(const QPainterPath &subject,
+                           const QPainterPath &clip)
+    : subjectPath(subject)
+    , clipPath(clip)
+{
+    aMask = subjectPath.fillRule() == Qt::WindingFill ? ~0x0 : 0x1;
+    bMask = clipPath.fillRule() == Qt::WindingFill ? ~0x0 : 0x1;
+}
+
+template <typename Iterator, typename Equality>
+Iterator qRemoveDuplicates(Iterator begin, Iterator end, Equality eq)
+{
+    if (begin == end)
+        return end;
+
+    Iterator last = begin;
+    ++begin;
+    Iterator insert = begin;
+    for (Iterator it = begin; it != end; ++it) {
+        if (!eq(*it, *last)) {
+            *insert++ = *it;
+            last = it;
+        }
+    }
+
+    return insert;
+}
+
+static void clear(QWingedEdge& list, int edge, QPathEdge::Traversal traversal)
+{
+    QWingedEdge::TraversalStatus status;
+    status.edge = edge;
+    status.traversal = traversal;
+    status.direction = QPathEdge::Forward;
+
+    do {
+        if (status.traversal == QPathEdge::LeftTraversal)
+            list.edge(status.edge)->flag |= 1;
+        else
+            list.edge(status.edge)->flag |= 2;
+
+        status = list.next(status);
+    } while (status.edge != edge);
+}
+
+template <typename InputIterator>
+InputIterator qFuzzyFind(InputIterator first, InputIterator last, qreal val)
+{
+    while (first != last && !QT_PREPEND_NAMESPACE(qFuzzyCompare)(qreal(*first), qreal(val)))
+        ++first;
+    return first;
+}
+
+static bool fuzzyCompare(qreal a, qreal b)
+{
+    return qFuzzyCompare(a, b);
+}
+
+bool QPathClipper::pathToRect(const QPainterPath &path, QRectF *rect)
+{
+    if (path.elementCount() != 5)
+        return false;
+
+    const bool mightBeRect = path.elementAt(0).isMoveTo()
+        && path.elementAt(1).isLineTo()
+        && path.elementAt(2).isLineTo()
+        && path.elementAt(3).isLineTo()
+        && path.elementAt(4).isLineTo();
+
+    if (!mightBeRect)
+        return false;
+
+    const qreal x1 = path.elementAt(0).x;
+    const qreal y1 = path.elementAt(0).y;
+
+    const qreal x2 = path.elementAt(1).x;
+    const qreal y2 = path.elementAt(2).y;
+
+    if (path.elementAt(1).y != y1)
+        return false;
+
+    if (path.elementAt(2).x != x2)
+        return false;
+
+    if (path.elementAt(3).x != x1 || path.elementAt(3).y != y2)
+        return false;
+
+    if (path.elementAt(4).x != x1 || path.elementAt(4).y != y1)
+        return false;
+
+    if (rect)
+        rect->setCoords(x1, y1, x2, y2);
+
+    return true;
+}
+
+
+QPainterPath QPathClipper::clip(Operation operation)
+{
+    op = operation;
+
+    if (op != Simplify) {
+        if (subjectPath == clipPath)
+            return op == BoolSub ? QPainterPath() : subjectPath;
+
+        bool subjectIsRect = pathToRect(subjectPath, 0);
+        bool clipIsRect = pathToRect(clipPath, 0);
+
+        const QRectF clipBounds = clipPath.boundingRect();
+        const QRectF subjectBounds = subjectPath.boundingRect();
+
+        if (!clipBounds.intersects(subjectBounds)) {
+            switch (op) {
+            case BoolSub:
+                return subjectPath;
+            case BoolAnd:
+                return QPainterPath();
+            case BoolOr: {
+                QPainterPath result = subjectPath;
+                if (result.fillRule() == clipPath.fillRule()) {
+                    result.addPath(clipPath);
+                } else if (result.fillRule() == Qt::WindingFill) {
+                    result = result.simplified();
+                    result.addPath(clipPath);
+                } else {
+                    result.addPath(clipPath.simplified());
+                }
+                return result;
+             }
+            default:
+                break;
+            }
+        }
+
+        if (clipBounds.contains(subjectBounds)) {
+            if (clipIsRect) {
+                switch (op) {
+                case BoolSub:
+                    return QPainterPath();
+                case BoolAnd:
+                    return subjectPath;
+                case BoolOr:
+                    return clipPath;
+                default:
+                    break;
+                }
+            }
+        } else if (subjectBounds.contains(clipBounds)) {
+            if (subjectIsRect) {
+                switch (op) {
+                case BoolSub:
+                    if (clipPath.fillRule() == Qt::OddEvenFill) {
+                        QPainterPath result = clipPath;
+                        result.addRect(subjectBounds);
+                        return result;
+                    } else {
+                        QPainterPath result = clipPath.simplified();
+                        result.addRect(subjectBounds);
+                        return result;
+                    }
+                    break;
+                case BoolAnd:
+                    return clipPath;
+                case BoolOr:
+                    return subjectPath;
+                default:
+                    break;
+                }
+            }
+        }
+
+        if (op == BoolAnd) {
+            if (subjectIsRect)
+                return intersect(clipPath, subjectBounds);
+            else if (clipIsRect)
+                return intersect(subjectPath, clipBounds);
+        }
+    }
+
+    QWingedEdge list(subjectPath, clipPath);
+
+    doClip(list, ClipMode);
+
+    QPainterPath path = list.toPath();
+    return path;
+}
+
+bool QPathClipper::doClip(QWingedEdge &list, ClipperMode mode)
+{
+    QVector<qreal> y_coords;
+    y_coords.reserve(list.vertexCount());
+    for (int i = 0; i < list.vertexCount(); ++i)
+        y_coords << list.vertex(i)->y;
+
+    qSort(y_coords.begin(), y_coords.end());
+    y_coords.resize(qRemoveDuplicates(y_coords.begin(), y_coords.end(), fuzzyCompare) - y_coords.begin());
+
+#ifdef QDEBUG_CLIPPER
+    printf("sorted y coords:\n");
+    for (int i = 0; i < y_coords.size(); ++i) {
+        printf("%.9f\n", y_coords[i]);
+    }
+#endif
+
+    bool found;
+    do {
+        found = false;
+        int index = 0;
+        qreal maxHeight = 0;
+        for (int i = 0; i < list.edgeCount(); ++i) {
+            QPathEdge *edge = list.edge(i);
+
+            // have both sides of this edge already been handled?
+            if ((edge->flag & 0x3) == 0x3)
+                continue;
+
+            QPathVertex *a = list.vertex(edge->first);
+            QPathVertex *b = list.vertex(edge->second);
+
+            if (qFuzzyCompare(a->y, b->y))
+                continue;
+
+            found = true;
+
+            qreal height = qAbs(a->y - b->y);
+            if (height > maxHeight) {
+                index = i;
+                maxHeight = height;
+            }
+        }
+
+        if (found) {
+            QPathEdge *edge = list.edge(index);
+
+            QPathVertex *a = list.vertex(edge->first);
+            QPathVertex *b = list.vertex(edge->second);
+
+            // FIXME: this can be optimized by using binary search
+            const int first = qFuzzyFind(y_coords.begin(), y_coords.end(), qMin(a->y, b->y)) - y_coords.begin();
+            const int last = qFuzzyFind(y_coords.begin() + first, y_coords.end(), qMax(a->y, b->y)) - y_coords.begin();
+
+            Q_ASSERT(first < y_coords.size() - 1);
+            Q_ASSERT(last < y_coords.size());
+
+            qreal bestY = 0.5 * (y_coords[first] + y_coords[first+1]);
+            qreal biggestGap = y_coords[first+1] - y_coords[first];
+
+            for (int i = first + 1; i < last; ++i) {
+                qreal gap = y_coords[i+1] - y_coords[i];
+
+                if (gap > biggestGap) {
+                    bestY = 0.5 * (y_coords[i] + y_coords[i+1]);
+                    biggestGap = gap;
+                }
+            }
+
+#ifdef QDEBUG_CLIPPER
+            printf("y: %.9f, gap: %.9f\n", bestY, biggestGap);
+#endif
+
+            if (handleCrossingEdges(list, bestY, mode) && mode == CheckMode)
+                return true;
+
+            edge->flag |= 0x3;
+        }
+    } while (found);
+
+    if (mode == ClipMode)
+        list.simplify();
+
+    return false;
+}
+
+static void traverse(QWingedEdge &list, int edge, QPathEdge::Traversal traversal)
+{
+    QWingedEdge::TraversalStatus status;
+    status.edge = edge;
+    status.traversal = traversal;
+    status.direction = QPathEdge::Forward;
+
+    do {
+        int flag = status.traversal == QPathEdge::LeftTraversal ? 1 : 2;
+
+        QPathEdge *ep = list.edge(status.edge);
+
+        ep->flag |= (flag | (flag << 4));
+
+#ifdef QDEBUG_CLIPPER
+        qDebug() << "traverse: adding edge " << status.edge << ", mask:" << (flag << 4) <<ep->flag;
+#endif
+
+        status = list.next(status);
+    } while (status.edge != edge);
+}
+
+struct QCrossingEdge
+{
+    int edge;
+    qreal x;
+
+    bool operator<(const QCrossingEdge &edge) const
+    {
+        return x < edge.x;
+    }
+};
+
+static bool bool_op(bool a, bool b, QPathClipper::Operation op)
+{
+    switch (op) {
+    case QPathClipper::BoolAnd:
+        return a && b;
+    case QPathClipper::BoolOr: // fall-through
+    case QPathClipper::Simplify:
+        return a || b;
+    case QPathClipper::BoolSub:
+        return a && !b;
+    default:
+        Q_ASSERT(false);
+        return false;
+    }
+}
+
+bool QWingedEdge::isInside(qreal x, qreal y) const
+{
+    int winding = 0;
+    for (int i = 0; i < edgeCount(); ++i) {
+        const QPathEdge *ep = edge(i);
+
+        // left xor right
+        int w = ((ep->flag >> 4) ^ (ep->flag >> 5)) & 1;
+
+        if (!w)
+            continue;
+
+        QPointF a = *vertex(ep->first);
+        QPointF b = *vertex(ep->second);
+
+        if ((a.y() < y && b.y() > y) || (a.y() > y && b.y() < y)) {
+            qreal intersectionX = a.x() + (b.x() - a.x()) * (y - a.y()) / (b.y() - a.y());
+
+            if (intersectionX > x)
+                winding += w;
+        }
+    }
+
+    return winding & 1;
+}
+
+static QVector<QCrossingEdge> findCrossings(const QWingedEdge &list, qreal y)
+{
+    QVector<QCrossingEdge> crossings;
+    for (int i = 0; i < list.edgeCount(); ++i) {
+        const QPathEdge *edge = list.edge(i);
+        QPointF a = *list.vertex(edge->first);
+        QPointF b = *list.vertex(edge->second);
+
+        if ((a.y() < y && b.y() > y) || (a.y() > y && b.y() < y)) {
+            const qreal intersection = a.x() + (b.x() - a.x()) * (y - a.y()) / (b.y() - a.y());
+            const QCrossingEdge edge = { i, intersection };
+            crossings << edge;
+        }
+    }
+    return crossings;
+}
+
+bool QPathClipper::handleCrossingEdges(QWingedEdge &list, qreal y, ClipperMode mode)
+{
+    QVector<QCrossingEdge> crossings = findCrossings(list, y);
+
+    Q_ASSERT(!crossings.isEmpty());
+    qSort(crossings.begin(), crossings.end());
+
+    int windingA = 0;
+    int windingB = 0;
+
+    int windingD = 0;
+
+#ifdef QDEBUG_CLIPPER
+    qDebug() << "crossings:" << crossings.size();
+#endif
+    for (int i = 0; i < crossings.size() - 1; ++i) {
+        int ei = crossings.at(i).edge;
+        const QPathEdge *edge = list.edge(ei);
+
+        windingA += edge->windingA;
+        windingB += edge->windingB;
+
+        const bool hasLeft = (edge->flag >> 4) & 1;
+        const bool hasRight = (edge->flag >> 4) & 2;
+
+        windingD += hasLeft ^ hasRight;
+
+        const bool inA = (windingA & aMask) != 0;
+        const bool inB = (windingB & bMask) != 0;
+        const bool inD = (windingD & 0x1) != 0;
+
+        const bool inside = bool_op(inA, inB, op);
+        const bool add = inD ^ inside;
+
+#ifdef QDEBUG_CLIPPER
+        printf("y %f, x %f, inA: %d, inB: %d, inD: %d, inside: %d, flag: %x, bezier: %p, edge: %d\n", y, crossings.at(i).x, inA, inB, inD, inside, edge->flag, edge->bezier, ei);
+#endif
+
+        if (add) {
+            if (mode == CheckMode)
+                return true;
+
+            qreal y0 = list.vertex(edge->first)->y;
+            qreal y1 = list.vertex(edge->second)->y;
+
+            if (y0 < y1) {
+                if (!(edge->flag & 1))
+                    traverse(list, ei, QPathEdge::LeftTraversal);
+
+                if (!(edge->flag & 2))
+                    clear(list, ei, QPathEdge::RightTraversal);
+            } else {
+                if (!(edge->flag & 1))
+                    clear(list, ei, QPathEdge::LeftTraversal);
+
+                if (!(edge->flag & 2))
+                    traverse(list, ei, QPathEdge::RightTraversal);
+            }
+
+            ++windingD;
+        } else {
+            if (!(edge->flag & 1))
+                clear(list, ei, QPathEdge::LeftTraversal);
+
+            if (!(edge->flag & 2))
+                clear(list, ei, QPathEdge::RightTraversal);
+        }
+    }
+
+    return false;
+}
+
+namespace {
+
+QList<QPainterPath> toSubpaths(const QPainterPath &path)
+{
+
+    QList<QPainterPath> subpaths;
+    if (path.isEmpty())
+        return subpaths;
+
+    QPainterPath current;
+    for (int i = 0; i < path.elementCount(); ++i) {
+        const QPainterPath::Element &e = path.elementAt(i);
+        switch (e.type) {
+        case QPainterPath::MoveToElement:
+            if (current.elementCount() > 1)
+                subpaths += current;
+            current = QPainterPath();
+            current.moveTo(e);
+            break;
+        case QPainterPath::LineToElement:
+            current.lineTo(e);
+            break;
+        case QPainterPath::CurveToElement: {
+            current.cubicTo(e, path.elementAt(i + 1), path.elementAt(i + 2));
+            i+=2;
+            break;
+        }
+        case QPainterPath::CurveToDataElement:
+            Q_ASSERT(!"toSubpaths(), bad element type");
+            break;
+        }
+    }
+
+    if (current.elementCount() > 1)
+        subpaths << current;
+
+    return subpaths;
+}
+
+enum Edge
+{
+    Left, Top, Right, Bottom
+};
+
+static bool isVertical(Edge edge)
+{
+    return edge == Left || edge == Right;
+}
+
+template <Edge edge>
+bool compare(const QPointF &p, qreal t)
+{
+    switch (edge)
+    {
+    case Left:
+        return p.x() < t;
+    case Right:
+        return p.x() > t;
+    case Top:
+        return p.y() < t;
+    default:
+        return p.y() > t;
+    }
+}
+
+template <Edge edge>
+QPointF intersectLine(const QPointF &a, const QPointF &b, qreal t)
+{
+    QLineF line(a, b);
+    switch (edge) {
+    case Left: // fall-through
+    case Right:
+        return line.pointAt((t - a.x()) / (b.x() - a.x()));
+    default:
+        return line.pointAt((t - a.y()) / (b.y() - a.y()));
+    }
+}
+
+void addLine(QPainterPath &path, const QLineF &line)
+{
+    if (path.elementCount() > 0)
+        path.lineTo(line.p1());
+    else
+        path.moveTo(line.p1());
+
+    path.lineTo(line.p2());
+}
+
+template <Edge edge>
+void clipLine(const QPointF &a, const QPointF &b, qreal t, QPainterPath &result)
+{
+    bool outA = compare<edge>(a, t);
+    bool outB = compare<edge>(b, t);
+    if (outA && outB)
+        return;
+
+    if (outA)
+        addLine(result, QLineF(intersectLine<edge>(a, b, t), b));
+    else if(outB)
+        addLine(result, QLineF(a, intersectLine<edge>(a, b, t)));
+    else
+        addLine(result, QLineF(a, b));
+}
+
+void addBezier(QPainterPath &path, const QBezier &bezier)
+{
+    if (path.elementCount() > 0)
+        path.lineTo(bezier.pt1());
+    else
+        path.moveTo(bezier.pt1());
+
+    path.cubicTo(bezier.pt2(), bezier.pt3(), bezier.pt4());
+}
+
+template <Edge edge>
+void clipBezier(const QPointF &a, const QPointF &b, const QPointF &c, const QPointF &d, qreal t, QPainterPath &result)
+{
+    QBezier bezier = QBezier::fromPoints(a, b, c, d);
+
+    bool outA = compare<edge>(a, t);
+    bool outB = compare<edge>(b, t);
+    bool outC = compare<edge>(c, t);
+    bool outD = compare<edge>(d, t);
+
+    int outCount = int(outA) + int(outB) + int(outC) + int(outD);
+
+    if (outCount == 4)
+        return;
+
+    if (outCount == 0) {
+        addBezier(result, bezier);
+        return;
+    }
+
+    QTransform flip = isVertical(edge) ? QTransform(0, 1, 1, 0, 0, 0) : QTransform();
+    QBezier unflipped = bezier;
+    QBezier flipped = bezier.mapBy(flip);
+
+    qreal t0 = 0, t1 = 1;
+    int stationary = flipped.stationaryYPoints(t0, t1);
+
+    qreal segments[4];
+    QPointF points[4];
+    points[0] = unflipped.pt1();
+    segments[0] = 0;
+
+    int segmentCount = 0;
+    if (stationary > 0) {
+        ++segmentCount;
+        segments[segmentCount] = t0;
+        points[segmentCount] = unflipped.pointAt(t0);
+    }
+    if (stationary > 1) {
+        ++segmentCount;
+        segments[segmentCount] = t1;
+        points[segmentCount] = unflipped.pointAt(t1);
+    }
+    ++segmentCount;
+    segments[segmentCount] = 1;
+    points[segmentCount] = unflipped.pt4();
+
+    qreal lastIntersection = 0;
+    for (int i = 0; i < segmentCount; ++i) {
+        outA = compare<edge>(points[i], t);
+        outB = compare<edge>(points[i+1], t);
+
+        if (outA != outB) {
+            qreal intersection = flipped.tForY(segments[i], segments[i+1], t);
+
+            if (outB)
+                addBezier(result, unflipped.getSubRange(lastIntersection, intersection));
+
+            lastIntersection = intersection;
+        }
+    }
+
+    if (!outB)
+        addBezier(result, unflipped.getSubRange(lastIntersection, 1));
+}
+
+// clips a single subpath against a single edge
+template <Edge edge>
+QPainterPath clip(const QPainterPath &path, qreal t)
+{
+    QPainterPath result;
+    for (int i = 1; i < path.elementCount(); ++i) {
+        const QPainterPath::Element &element = path.elementAt(i);
+        Q_ASSERT(!element.isMoveTo());
+        if (element.isLineTo()) {
+            clipLine<edge>(path.elementAt(i-1), path.elementAt(i), t, result);
+        } else {
+            clipBezier<edge>(path.elementAt(i-1), path.elementAt(i), path.elementAt(i+1), path.elementAt(i+2), t, result);
+            i += 2;
+        }
+    }
+
+    int last = path.elementCount() - 1;
+    if (QPointF(path.elementAt(last)) != QPointF(path.elementAt(0)))
+        clipLine<edge>(path.elementAt(last), path.elementAt(0), t, result);
+
+    return result;
+}
+
+QPainterPath intersectPath(const QPainterPath &path, const QRectF &rect)
+{
+    QList<QPainterPath> subpaths = toSubpaths(path);
+
+    QPainterPath result;
+    result.setFillRule(path.fillRule());
+    for (int i = 0; i < subpaths.size(); ++i) {
+        QPainterPath subPath = subpaths.at(i);
+        QRectF bounds = subPath.boundingRect();
+        if (bounds.intersects(rect)) {
+            if (bounds.left() < rect.left())
+                subPath = clip<Left>(subPath, rect.left());
+            if (bounds.right() > rect.right())
+                subPath = clip<Right>(subPath, rect.right());
+
+            bounds = subPath.boundingRect();
+
+            if (bounds.top() < rect.top())
+                subPath = clip<Top>(subPath, rect.top());
+            if (bounds.bottom() > rect.bottom())
+                subPath = clip<Bottom>(subPath, rect.bottom());
+
+            if (subPath.elementCount() > 1)
+                result.addPath(subPath);
+        }
+    }
+    return result;
+}
+
+}
+
+QPainterPath QPathClipper::intersect(const QPainterPath &path, const QRectF &rect)
+{
+    return intersectPath(path, rect);
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qpathclipper_p.h b/src/gui/painting/qpathclipper_p.h
new file mode 100644
index 0000000000..226c55d29e
--- /dev/null
+++ b/src/gui/painting/qpathclipper_p.h
@@ -0,0 +1,494 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPATHCLIPPER_P_H
+#define QPATHCLIPPER_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtGui/qpainterpath.h>
+#include <QtCore/qlist.h>
+
+#include <private/qbezier_p.h>
+#include <private/qdatabuffer_p.h>
+#include <stdio.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+class QWingedEdge;
+
+class Q_AUTOTEST_EXPORT QPathClipper
+{
+public:
+    enum Operation {
+        BoolAnd,
+        BoolOr,
+        BoolSub,
+        Simplify
+    };
+public:
+    QPathClipper(const QPainterPath &subject,
+                 const QPainterPath &clip);
+
+    QPainterPath clip(Operation op = BoolAnd);
+
+    bool intersect();
+    bool contains();
+
+    static bool pathToRect(const QPainterPath &path, QRectF *rect = 0);
+    static QPainterPath intersect(const QPainterPath &path, const QRectF &rect);
+
+private:
+    Q_DISABLE_COPY(QPathClipper)
+
+    enum ClipperMode {
+        ClipMode, // do the full clip
+        CheckMode // for contains/intersects (only interested in whether the result path is non-empty)
+    };
+
+    bool handleCrossingEdges(QWingedEdge &list, qreal y, ClipperMode mode);
+    bool doClip(QWingedEdge &list, ClipperMode mode);
+
+    QPainterPath subjectPath;
+    QPainterPath clipPath;
+    Operation op;
+
+    int aMask;
+    int bMask;
+};
+
+struct QPathVertex
+{
+public:
+    QPathVertex(const QPointF &p = QPointF(), int e = -1);
+    operator QPointF() const;
+
+    int edge;
+
+    qreal x;
+    qreal y;
+};
+
+class QPathEdge
+{
+public:
+    enum Traversal {
+        RightTraversal,
+        LeftTraversal
+    };
+
+    enum Direction {
+        Forward,
+        Backward
+    };
+
+    enum Type {
+        Line,
+        Curve
+    };
+
+    QPathEdge(int a = -1, int b = -1);
+
+    mutable int flag;
+
+    int windingA;
+    int windingB;
+
+    int first;
+    int second;
+
+    double angle;
+    double invAngle;
+
+    int next(Traversal traversal, Direction direction) const;
+
+    void setNext(Traversal traversal, Direction direction, int next);
+    void setNext(Direction direction, int next);
+
+    Direction directionTo(int vertex) const;
+    int vertex(Direction direction) const;
+
+private:
+    int m_next[2][2];
+};
+
+class QPathSegments
+{
+public:
+    struct Intersection {
+        int vertex;
+        qreal t;
+
+        int next;
+
+        bool operator<(const Intersection &o) const {
+            return t < o.t;
+        }
+    };
+
+    struct Segment {
+        Segment(int pathId, int vertexA, int vertexB)
+            : path(pathId)
+            , va(vertexA)
+            , vb(vertexB)
+            , intersection(-1)
+        {
+        }
+
+        int path;
+
+        // vertices
+        int va;
+        int vb;
+
+        // intersection index
+        int intersection;
+
+        QRectF bounds;
+    };
+
+
+    QPathSegments(int reserve);
+
+    void setPath(const QPainterPath &path);
+    void addPath(const QPainterPath &path);
+
+    int intersections() const;
+    int segments() const;
+    int points() const;
+
+    const Segment &segmentAt(int index) const;
+    const QLineF lineAt(int index) const;
+    const QRectF &elementBounds(int index) const;
+    int pathId(int index) const;
+
+    const QPointF &pointAt(int vertex) const;
+    int addPoint(const QPointF &point);
+
+    const Intersection *intersectionAt(int index) const;
+    void addIntersection(int index, const Intersection &intersection);
+
+    void mergePoints();
+
+private:
+    QDataBuffer<QPointF> m_points;
+    QDataBuffer<Segment> m_segments;
+    QDataBuffer<Intersection> m_intersections;
+
+    int m_pathId;
+};
+
+class Q_AUTOTEST_EXPORT QWingedEdge
+{
+public:
+    struct TraversalStatus
+    {
+        int edge;
+        QPathEdge::Traversal traversal;
+        QPathEdge::Direction direction;
+
+        void flipDirection();
+        void flipTraversal();
+
+        void flip();
+    };
+
+    QWingedEdge();
+    QWingedEdge(const QPainterPath &subject, const QPainterPath &clip);
+
+    void simplify();
+    QPainterPath toPath() const;
+
+    int edgeCount() const;
+
+    QPathEdge *edge(int edge);
+    const QPathEdge *edge(int edge) const;
+
+    int vertexCount() const;
+
+    int addVertex(const QPointF &p);
+
+    QPathVertex *vertex(int vertex);
+    const QPathVertex *vertex(int vertex) const;
+
+    TraversalStatus next(const TraversalStatus &status) const;
+
+    int addEdge(const QPointF &a, const QPointF &b);
+    int addEdge(int vertexA, int vertexB);
+
+    bool isInside(qreal x, qreal y) const;
+
+    static QPathEdge::Traversal flip(QPathEdge::Traversal traversal);
+    static QPathEdge::Direction flip(QPathEdge::Direction direction);
+
+private:
+    void intersectAndAdd();
+
+    void printNode(int i, FILE *handle);
+
+    void removeEdge(int ei);
+
+    int insert(const QPathVertex &vertex);
+    TraversalStatus findInsertStatus(int vertex, int edge) const;
+
+    qreal delta(int vertex, int a, int b) const;
+
+    QDataBuffer<QPathEdge> m_edges;
+    QDataBuffer<QPathVertex> m_vertices;
+
+    QVector<qreal> m_splitPoints;
+
+    QPathSegments m_segments;
+};
+
+inline QPathEdge::QPathEdge(int a, int b)
+    : flag(0)
+    , windingA(0)
+    , windingB(0)
+    , first(a)
+    , second(b)
+    , angle(0)
+    , invAngle(0)
+{
+    m_next[0][0] = -1;
+    m_next[1][0] = -1;
+    m_next[0][0] = -1;
+    m_next[1][0] = -1;
+}
+
+inline int QPathEdge::next(Traversal traversal, Direction direction) const
+{
+    return m_next[int(traversal)][int(direction)];
+}
+
+inline void QPathEdge::setNext(Traversal traversal, Direction direction, int next)
+{
+    m_next[int(traversal)][int(direction)] = next;
+}
+
+inline void QPathEdge::setNext(Direction direction, int next)
+{
+    m_next[0][int(direction)] = next;
+    m_next[1][int(direction)] = next;
+}
+
+inline QPathEdge::Direction QPathEdge::directionTo(int vertex) const
+{
+    return first == vertex ? Backward : Forward;
+}
+
+inline int QPathEdge::vertex(Direction direction) const
+{
+    return direction == Backward ? first : second;
+}
+
+inline QPathVertex::QPathVertex(const QPointF &p, int e)
+    : edge(e)
+    , x(p.x())
+    , y(p.y())
+{
+}
+
+inline QPathVertex::operator QPointF() const
+{
+    return QPointF(x, y);
+}
+
+inline QPathSegments::QPathSegments(int reserve) :
+    m_points(reserve),
+    m_segments(reserve),
+    m_intersections(reserve)
+{
+}
+
+inline int QPathSegments::segments() const
+{
+    return m_segments.size();
+}
+
+inline int QPathSegments::points() const
+{
+    return m_points.size();
+}
+
+inline const QPointF &QPathSegments::pointAt(int i) const
+{
+    return m_points.at(i);
+}
+
+inline int QPathSegments::addPoint(const QPointF &point)
+{
+    m_points << point;
+    return m_points.size() - 1;
+}
+
+inline const QPathSegments::Segment &QPathSegments::segmentAt(int index) const
+{
+    return m_segments.at(index);
+}
+
+inline const QLineF QPathSegments::lineAt(int index) const
+{
+    const Segment &segment = m_segments.at(index);
+    return QLineF(m_points.at(segment.va), m_points.at(segment.vb));
+}
+
+inline const QRectF &QPathSegments::elementBounds(int index) const
+{
+    return m_segments.at(index).bounds;
+}
+
+inline int QPathSegments::pathId(int index) const
+{
+    return m_segments.at(index).path;
+}
+
+inline const QPathSegments::Intersection *QPathSegments::intersectionAt(int index) const
+{
+    const int intersection = m_segments.at(index).intersection;
+    if (intersection < 0)
+        return 0;
+    else
+        return &m_intersections.at(intersection);
+}
+
+inline int QPathSegments::intersections() const
+{
+    return m_intersections.size();
+}
+
+inline void QPathSegments::addIntersection(int index, const Intersection &intersection)
+{
+    m_intersections << intersection;
+
+    Segment &segment = m_segments.at(index);
+    if (segment.intersection < 0) {
+        segment.intersection = m_intersections.size() - 1;
+    } else {
+        Intersection *isect = &m_intersections.at(segment.intersection);
+
+        while (isect->next != 0)
+            isect += isect->next;
+
+        isect->next = (m_intersections.size() - 1) - (isect - m_intersections.data());
+    }
+}
+
+inline void QWingedEdge::TraversalStatus::flipDirection()
+{
+    direction = QWingedEdge::flip(direction);
+}
+
+inline void QWingedEdge::TraversalStatus::flipTraversal()
+{
+    traversal = QWingedEdge::flip(traversal);
+}
+
+inline void QWingedEdge::TraversalStatus::flip()
+{
+    flipDirection();
+    flipTraversal();
+}
+
+inline int QWingedEdge::edgeCount() const
+{
+    return m_edges.size();
+}
+
+inline QPathEdge *QWingedEdge::edge(int edge)
+{
+    return edge < 0 ? 0 : &m_edges.at(edge);
+}
+
+inline const QPathEdge *QWingedEdge::edge(int edge) const
+{
+    return edge < 0 ? 0 : &m_edges.at(edge);
+}
+
+inline int QWingedEdge::vertexCount() const
+{
+    return m_vertices.size();
+}
+
+inline int QWingedEdge::addVertex(const QPointF &p)
+{
+    m_vertices << p;
+    return m_vertices.size() - 1;
+}
+
+inline QPathVertex *QWingedEdge::vertex(int vertex)
+{
+    return vertex < 0 ? 0 : &m_vertices.at(vertex);
+}
+
+inline const QPathVertex *QWingedEdge::vertex(int vertex) const
+{
+    return vertex < 0 ? 0 : &m_vertices.at(vertex);
+}
+
+inline QPathEdge::Traversal QWingedEdge::flip(QPathEdge::Traversal traversal)
+{
+    return traversal == QPathEdge::RightTraversal ? QPathEdge::LeftTraversal : QPathEdge::RightTraversal;
+}
+
+inline QPathEdge::Direction QWingedEdge::flip(QPathEdge::Direction direction)
+{
+    return direction == QPathEdge::Forward ? QPathEdge::Backward : QPathEdge::Forward;
+}
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QPATHCLIPPER_P_H
diff --git a/src/gui/painting/qpdf.cpp b/src/gui/painting/qpdf.cpp
new file mode 100644
index 0000000000..0271a39b16
--- /dev/null
+++ b/src/gui/painting/qpdf.cpp
@@ -0,0 +1,2106 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include "qplatformdefs.h"
+#include <qdebug.h>
+#include "qpdf_p.h"
+#include <qfile.h>
+#include <qtemporaryfile.h>
+#include <private/qmath_p.h>
+#include "private/qcups_p.h"
+#include "qprinterinfo.h"
+#include <qnumeric.h>
+#include "private/qfont_p.h"
+
+#ifdef Q_OS_UNIX
+#include "private/qcore_unix_p.h" // overrides QT_OPEN
+#endif
+
+QT_BEGIN_NAMESPACE
+
+#ifndef QT_NO_PRINTER
+
+extern QSizeF qt_paperSizeToQSizeF(QPrinter::PaperSize size);
+
+/* also adds a space at the end of the number */
+const char *qt_real_to_string(qreal val, char *buf) {
+    const char *ret = buf;
+
+    if (qIsNaN(val)) {
+        *(buf++) = '0';
+        *(buf++) = ' ';
+        *buf = 0;
+        return ret;
+    }
+
+    if (val < 0) {
+        *(buf++) = '-';
+        val = -val;
+    }
+    unsigned int ival = (unsigned int) val;
+    qreal frac = val - (qreal)ival;
+
+    int ifrac = (int)(frac * 1000000000);
+    if (ifrac == 1000000000) {
+        ++ival;
+        ifrac = 0;
+    }
+    char output[256];
+    int i = 0;
+    while (ival) {
+        output[i] = '0' + (ival % 10);
+        ++i;
+        ival /= 10;
+    }
+    int fact = 100000000;
+    if (i == 0) {
+        *(buf++) = '0';
+    } else {
+        while (i) {
+            *(buf++) = output[--i];
+            fact /= 10;
+            ifrac /= 10;
+        }
+    }
+
+    if (ifrac) {
+        *(buf++) =  '.';
+        while (fact) {
+            *(buf++) = '0' + ((ifrac/fact) % 10);
+            fact /= 10;
+        }
+    }
+    *(buf++) = ' ';
+    *buf = 0;
+    return ret;
+}
+
+const char *qt_int_to_string(int val, char *buf) {
+    const char *ret = buf;
+    if (val < 0) {
+        *(buf++) = '-';
+        val = -val;
+    }
+    char output[256];
+    int i = 0;
+    while (val) {
+        output[i] = '0' + (val % 10);
+        ++i;
+        val /= 10;
+    }
+    if (i == 0) {
+        *(buf++) = '0';
+    } else {
+        while (i)
+            *(buf++) = output[--i];
+    }
+    *(buf++) = ' ';
+    *buf = 0;
+    return ret;
+}
+
+
+namespace QPdf {
+    ByteStream::ByteStream(QByteArray *byteArray, bool fileBacking)
+            : dev(new QBuffer(byteArray)),
+            fileBackingEnabled(fileBacking),
+            fileBackingActive(false),
+            handleDirty(false)
+    {
+        dev->open(QIODevice::ReadWrite | QIODevice::Append);
+    }
+
+    ByteStream::ByteStream(bool fileBacking)
+            : dev(new QBuffer(&ba)),
+            fileBackingEnabled(fileBacking),
+            fileBackingActive(false),
+            handleDirty(false)
+    {
+        dev->open(QIODevice::ReadWrite);
+    }
+
+    ByteStream::~ByteStream()
+    {
+        delete dev;
+    }
+
+    ByteStream &ByteStream::operator <<(char chr)
+    {
+        if (handleDirty) prepareBuffer();
+        dev->write(&chr, 1);
+        return *this;
+    }
+
+    ByteStream &ByteStream::operator <<(const char *str)
+    {
+        if (handleDirty) prepareBuffer();
+        dev->write(str, strlen(str));
+        return *this;
+    }
+
+    ByteStream &ByteStream::operator <<(const QByteArray &str)
+    {
+        if (handleDirty) prepareBuffer();
+        dev->write(str);
+        return *this;
+    }
+
+    ByteStream &ByteStream::operator <<(const ByteStream &src)
+    {
+        Q_ASSERT(!src.dev->isSequential());
+        if (handleDirty) prepareBuffer();
+        // We do play nice here, even though it looks ugly.
+        // We save the position and restore it afterwards.
+        ByteStream &s = const_cast<ByteStream&>(src);
+        qint64 pos = s.dev->pos();
+        s.dev->reset();
+        while (!s.dev->atEnd()) {
+            QByteArray buf = s.dev->read(chunkSize());
+            dev->write(buf);
+        }
+        s.dev->seek(pos);
+        return *this;
+    }
+
+    ByteStream &ByteStream::operator <<(qreal val) {
+        char buf[256];
+        qt_real_to_string(val, buf);
+        *this << buf;
+        return *this;
+    }
+
+    ByteStream &ByteStream::operator <<(int val) {
+        char buf[256];
+        qt_int_to_string(val, buf);
+        *this << buf;
+        return *this;
+    }
+
+    ByteStream &ByteStream::operator <<(const QPointF &p) {
+        char buf[256];
+        qt_real_to_string(p.x(), buf);
+        *this << buf;
+        qt_real_to_string(p.y(), buf);
+        *this << buf;
+        return *this;
+    }
+
+    QIODevice *ByteStream::stream()
+    {
+        dev->reset();
+        handleDirty = true;
+        return dev;
+    }
+
+    void ByteStream::clear()
+    {
+        dev->open(QIODevice::ReadWrite | QIODevice::Truncate);
+    }
+
+    void ByteStream::constructor_helper(QByteArray *ba)
+    {
+        delete dev;
+        dev = new QBuffer(ba);
+        dev->open(QIODevice::ReadWrite);
+    }
+
+    void ByteStream::prepareBuffer()
+    {
+        Q_ASSERT(!dev->isSequential());
+        qint64 size = dev->size();
+        if (fileBackingEnabled && !fileBackingActive
+                && size > maxMemorySize()) {
+            // Switch to file backing.
+            QTemporaryFile *newFile = new QTemporaryFile;
+            newFile->open();
+            dev->reset();
+            while (!dev->atEnd()) {
+                QByteArray buf = dev->read(chunkSize());
+                newFile->write(buf);
+            }
+            delete dev;
+            dev = newFile;
+            ba.clear();
+            fileBackingActive = true;
+        }
+        if (dev->pos() != size) {
+            dev->seek(size);
+            handleDirty = false;
+        }
+    }
+}
+
+#define QT_PATH_ELEMENT(elm)
+
+QByteArray QPdf::generatePath(const QPainterPath &path, const QTransform &matrix, PathFlags flags)
+{
+    QByteArray result;
+    if (!path.elementCount())
+        return result;
+
+    ByteStream s(&result);
+
+    int start = -1;
+    for (int i = 0; i < path.elementCount(); ++i) {
+        const QPainterPath::Element &elm = path.elementAt(i);
+        switch (elm.type) {
+        case QPainterPath::MoveToElement:
+            if (start >= 0
+                && path.elementAt(start).x == path.elementAt(i-1).x
+                && path.elementAt(start).y == path.elementAt(i-1).y)
+                s << "h\n";
+            s << matrix.map(QPointF(elm.x, elm.y)) << "m\n";
+            start = i;
+                break;
+        case QPainterPath::LineToElement:
+            s << matrix.map(QPointF(elm.x, elm.y)) << "l\n";
+            break;
+        case QPainterPath::CurveToElement:
+            Q_ASSERT(path.elementAt(i+1).type == QPainterPath::CurveToDataElement);
+            Q_ASSERT(path.elementAt(i+2).type == QPainterPath::CurveToDataElement);
+            s << matrix.map(QPointF(elm.x, elm.y))
+              << matrix.map(QPointF(path.elementAt(i+1).x, path.elementAt(i+1).y))
+              << matrix.map(QPointF(path.elementAt(i+2).x, path.elementAt(i+2).y))
+              << "c\n";
+            i += 2;
+            break;
+        default:
+            qFatal("QPdf::generatePath(), unhandled type: %d", elm.type);
+        }
+    }
+    if (start >= 0
+        && path.elementAt(start).x == path.elementAt(path.elementCount()-1).x
+        && path.elementAt(start).y == path.elementAt(path.elementCount()-1).y)
+        s << "h\n";
+
+    Qt::FillRule fillRule = path.fillRule();
+
+    const char *op = "";
+    switch (flags) {
+    case ClipPath:
+        op = (fillRule == Qt::WindingFill) ? "W n\n" : "W* n\n";
+        break;
+    case FillPath:
+        op = (fillRule == Qt::WindingFill) ? "f\n" : "f*\n";
+        break;
+    case StrokePath:
+        op = "S\n";
+        break;
+    case FillAndStrokePath:
+        op = (fillRule == Qt::WindingFill) ? "B\n" : "B*\n";
+        break;
+    }
+    s << op;
+    return result;
+}
+
+QByteArray QPdf::generateMatrix(const QTransform &matrix)
+{
+    QByteArray result;
+    ByteStream s(&result);
+    s << matrix.m11()
+      << matrix.m12()
+      << matrix.m21()
+      << matrix.m22()
+      << matrix.dx()
+      << matrix.dy()
+      << "cm\n";
+    return result;
+}
+
+QByteArray QPdf::generateDashes(const QPen &pen)
+{
+    QByteArray result;
+    ByteStream s(&result);
+    s << '[';
+
+    QVector<qreal> dasharray = pen.dashPattern();
+    qreal w = pen.widthF();
+    if (w < 0.001)
+        w = 1;
+    for (int i = 0; i < dasharray.size(); ++i) {
+        qreal dw = dasharray.at(i)*w;
+        if (dw < 0.0001) dw = 0.0001;
+        s << dw;
+    }
+    s << ']';
+    //qDebug() << "dasharray: pen has" << dasharray;
+    //qDebug() << "  => " << result;
+    return result;
+}
+
+
+
+static const char* pattern_for_brush[] = {
+    0, // NoBrush
+    0, // SolidPattern
+    "0 J\n"
+    "6 w\n"
+    "[] 0 d\n"
+    "4 0 m\n"
+    "4 8 l\n"
+    "0 4 m\n"
+    "8 4 l\n"
+    "S\n", // Dense1Pattern
+
+    "0 J\n"
+    "2 w\n"
+    "[6 2] 1 d\n"
+    "0 0 m\n"
+    "0 8 l\n"
+    "8 0 m\n"
+    "8 8 l\n"
+    "S\n"
+    "[] 0 d\n"
+    "2 0 m\n"
+    "2 8 l\n"
+    "6 0 m\n"
+    "6 8 l\n"
+    "S\n"
+    "[6 2] -3 d\n"
+    "4 0 m\n"
+    "4 8 l\n"
+    "S\n", // Dense2Pattern
+
+    "0 J\n"
+    "2 w\n"
+    "[6 2] 1 d\n"
+    "0 0 m\n"
+    "0 8 l\n"
+    "8 0 m\n"
+    "8 8 l\n"
+    "S\n"
+    "[2 2] -1 d\n"
+    "2 0 m\n"
+    "2 8 l\n"
+    "6 0 m\n"
+    "6 8 l\n"
+    "S\n"
+    "[6 2] -3 d\n"
+    "4 0 m\n"
+    "4 8 l\n"
+    "S\n", // Dense3Pattern
+
+    "0 J\n"
+    "2 w\n"
+    "[2 2] 1 d\n"
+    "0 0 m\n"
+    "0 8 l\n"
+    "8 0 m\n"
+    "8 8 l\n"
+    "S\n"
+    "[2 2] -1 d\n"
+    "2 0 m\n"
+    "2 8 l\n"
+    "6 0 m\n"
+    "6 8 l\n"
+    "S\n"
+    "[2 2] 1 d\n"
+    "4 0 m\n"
+    "4 8 l\n"
+    "S\n", // Dense4Pattern
+
+    "0 J\n"
+    "2 w\n"
+    "[2 6] -1 d\n"
+    "0 0 m\n"
+    "0 8 l\n"
+    "8 0 m\n"
+    "8 8 l\n"
+    "S\n"
+    "[2 2] 1 d\n"
+    "2 0 m\n"
+    "2 8 l\n"
+    "6 0 m\n"
+    "6 8 l\n"
+    "S\n"
+    "[2 6] 3 d\n"
+    "4 0 m\n"
+    "4 8 l\n"
+    "S\n", // Dense5Pattern
+
+    "0 J\n"
+    "2 w\n"
+    "[2 6] -1 d\n"
+    "0 0 m\n"
+    "0 8 l\n"
+    "8 0 m\n"
+    "8 8 l\n"
+    "S\n"
+    "[2 6] 3 d\n"
+    "4 0 m\n"
+    "4 8 l\n"
+    "S\n", // Dense6Pattern
+
+    "0 J\n"
+    "2 w\n"
+    "[2 6] -1 d\n"
+    "0 0 m\n"
+    "0 8 l\n"
+    "8 0 m\n"
+    "8 8 l\n"
+    "S\n", // Dense7Pattern
+
+    "1 w\n"
+    "0 4 m\n"
+    "8 4 l\n"
+    "S\n", // HorPattern
+
+    "1 w\n"
+    "4 0 m\n"
+    "4 8 l\n"
+    "S\n", // VerPattern
+
+    "1 w\n"
+    "4 0 m\n"
+    "4 8 l\n"
+    "0 4 m\n"
+    "8 4 l\n"
+    "S\n", // CrossPattern
+
+    "1 w\n"
+    "-1 5 m\n"
+    "5 -1 l\n"
+    "3 9 m\n"
+    "9 3 l\n"
+    "S\n", // BDiagPattern
+
+    "1 w\n"
+    "-1 3 m\n"
+    "5 9 l\n"
+    "3 -1 m\n"
+    "9 5 l\n"
+    "S\n", // FDiagPattern
+
+    "1 w\n"
+    "-1 3 m\n"
+    "5 9 l\n"
+    "3 -1 m\n"
+    "9 5 l\n"
+    "-1 5 m\n"
+    "5 -1 l\n"
+    "3 9 m\n"
+    "9 3 l\n"
+    "S\n", // DiagCrossPattern
+};
+
+QByteArray QPdf::patternForBrush(const QBrush &b)
+{
+    int style = b.style();
+    if (style > Qt::DiagCrossPattern)
+        return QByteArray();
+    return pattern_for_brush[style];
+}
+
+#ifdef USE_NATIVE_GRADIENTS
+static void writeTriangleLine(uchar *&data, int xpos, int ypos, int xoff, int yoff, uint rgb, uchar flag, bool alpha)
+{
+    data[0] =  flag;
+    data[1] = (uchar)(xpos >> 16);
+    data[2] = (uchar)(xpos >> 8);
+    data[3] = (uchar)(xpos >> 0);
+    data[4] = (uchar)(ypos >> 16);
+    data[5] = (uchar)(ypos >> 8);
+    data[6] = (uchar)(ypos >> 0);
+    data += 7;
+    if (alpha) {
+        *data++ = (uchar)qAlpha(rgb);
+    } else {
+        *data++ = (uchar)qRed(rgb);
+        *data++ = (uchar)qGreen(rgb);
+        *data++ = (uchar)qBlue(rgb);
+    }
+    xpos += xoff;
+    ypos += yoff;
+    data[0] =  flag;
+    data[1] = (uchar)(xpos >> 16);
+    data[2] = (uchar)(xpos >> 8);
+    data[3] = (uchar)(xpos >> 0);
+    data[4] = (uchar)(ypos >> 16);
+    data[5] = (uchar)(ypos >> 8);
+    data[6] = (uchar)(ypos >> 0);
+    data += 7;
+    if (alpha) {
+        *data++ = (uchar)qAlpha(rgb);
+    } else {
+        *data++ = (uchar)qRed(rgb);
+        *data++ = (uchar)qGreen(rgb);
+        *data++ = (uchar)qBlue(rgb);
+    }
+}
+
+
+QByteArray QPdf::generateLinearGradientShader(const QLinearGradient *gradient, const QPointF *page_rect, bool alpha)
+{
+    // generate list of triangles with colors
+    QPointF start = gradient->start();
+    QPointF stop = gradient->finalStop();
+    QGradientStops stops = gradient->stops();
+    QPointF offset = stop - start;
+    QGradient::Spread spread = gradient->spread();
+
+    if (gradient->spread() == QGradient::ReflectSpread) {
+        offset *= 2;
+        for (int i = stops.size() - 2; i >= 0; --i) {
+            QGradientStop stop = stops.at(i);
+            stop.first = 2. - stop.first;
+            stops.append(stop);
+        }
+        for (int i = 0 ; i < stops.size(); ++i)
+            stops[i].first /= 2.;
+    }
+
+    QPointF orthogonal(offset.y(), -offset.x());
+    qreal length = offset.x()*offset.x() + offset.y()*offset.y();
+
+    // find the max and min values in offset and orth direction that are needed to cover
+    // the whole page
+    int off_min = INT_MAX;
+    int off_max = INT_MIN;
+    qreal ort_min = INT_MAX;
+    qreal ort_max = INT_MIN;
+    for (int i = 0; i < 4; ++i) {
+        qreal off = ((page_rect[i].x() - start.x()) * offset.x() + (page_rect[i].y() - start.y()) * offset.y())/length;
+        qreal ort = ((page_rect[i].x() - start.x()) * orthogonal.x() + (page_rect[i].y() - start.y()) * orthogonal.y())/length;
+        off_min = qMin(off_min, qFloor(off));
+        off_max = qMax(off_max, qCeil(off));
+        ort_min = qMin(ort_min, ort);
+        ort_max = qMax(ort_max, ort);
+    }
+    ort_min -= 1;
+    ort_max += 1;
+
+    start += off_min * offset + ort_min * orthogonal;
+    orthogonal *= (ort_max - ort_min);
+    int num = off_max - off_min;
+
+    QPointF gradient_rect[4] = { start,
+                                 start + orthogonal,
+                                 start + num*offset,
+                                 start + num*offset + orthogonal };
+    qreal xmin = gradient_rect[0].x();
+    qreal xmax = gradient_rect[0].x();
+    qreal ymin = gradient_rect[0].y();
+    qreal ymax = gradient_rect[0].y();
+    for (int i = 1; i < 4; ++i) {
+        xmin = qMin(xmin, gradient_rect[i].x());
+        xmax = qMax(xmax, gradient_rect[i].x());
+        ymin = qMin(ymin, gradient_rect[i].y());
+        ymax = qMax(ymax, gradient_rect[i].y());
+    }
+    xmin -= 1000;
+    xmax += 1000;
+    ymin -= 1000;
+    ymax += 1000;
+    start -= QPointF(xmin, ymin);
+    qreal factor_x = qreal(1<<24)/(xmax - xmin);
+    qreal factor_y = qreal(1<<24)/(ymax - ymin);
+    int xoff = (int)(orthogonal.x()*factor_x);
+    int yoff = (int)(orthogonal.y()*factor_y);
+
+    QByteArray triangles;
+    triangles.resize(spread == QGradient::PadSpread ? 20*(stops.size()+2) : 20*num*stops.size());
+    uchar *data = (uchar *) triangles.data();
+    if (spread == QGradient::PadSpread) {
+        if (off_min > 0 || off_max < 1) {
+            // linear gradient outside of page
+            const QGradientStop &current_stop = off_min > 0 ? stops.at(stops.size()-1) : stops.at(0);
+            uint rgb = current_stop.second.rgba();
+            int xpos = (int)(start.x()*factor_x);
+            int ypos = (int)(start.y()*factor_y);
+            writeTriangleLine(data, xpos, ypos, xoff, yoff, rgb, 0, alpha);
+            start += num*offset;
+            xpos = (int)(start.x()*factor_x);
+            ypos = (int)(start.y()*factor_y);
+            writeTriangleLine(data, xpos, ypos, xoff, yoff, rgb, 1, alpha);
+        } else {
+            int flag = 0;
+            if (off_min < 0) {
+                uint rgb = stops.at(0).second.rgba();
+                int xpos = (int)(start.x()*factor_x);
+                int ypos = (int)(start.y()*factor_y);
+                writeTriangleLine(data, xpos, ypos, xoff, yoff, rgb, flag, alpha);
+                start -= off_min*offset;
+                flag = 1;
+            }
+            for (int s = 0; s < stops.size(); ++s) {
+                const QGradientStop &current_stop = stops.at(s);
+                uint rgb = current_stop.second.rgba();
+                int xpos = (int)(start.x()*factor_x);
+                int ypos = (int)(start.y()*factor_y);
+                writeTriangleLine(data, xpos, ypos, xoff, yoff, rgb, flag, alpha);
+                if (s < stops.size()-1)
+                    start += offset*(stops.at(s+1).first - stops.at(s).first);
+                flag = 1;
+            }
+            if (off_max > 1) {
+                start += (off_max - 1)*offset;
+                uint rgb = stops.at(stops.size()-1).second.rgba();
+                int xpos = (int)(start.x()*factor_x);
+                int ypos = (int)(start.y()*factor_y);
+                writeTriangleLine(data, xpos, ypos, xoff, yoff, rgb, flag, alpha);
+            }
+        }
+    } else {
+        for (int i = 0; i < num; ++i) {
+            uchar flag = 0;
+            for (int s = 0; s < stops.size(); ++s) {
+                uint rgb = stops.at(s).second.rgba();
+                int xpos = (int)(start.x()*factor_x);
+                int ypos = (int)(start.y()*factor_y);
+                writeTriangleLine(data, xpos, ypos, xoff, yoff, rgb, flag, alpha);
+                if (s < stops.size()-1)
+                    start += offset*(stops.at(s+1).first - stops.at(s).first);
+                flag = 1;
+            }
+        }
+    }
+    triangles.resize((char *)data - triangles.constData());
+
+    QByteArray shader;
+    QPdf::ByteStream s(&shader);
+    s << "<<\n"
+        "/ShadingType 4\n"
+        "/ColorSpace " << (alpha ? "/DeviceGray\n" : "/DeviceRGB\n") <<
+        "/AntiAlias true\n"
+        "/BitsPerCoordinate 24\n"
+        "/BitsPerComponent 8\n"
+        "/BitsPerFlag 8\n"
+        "/Decode [" << xmin << xmax << ymin << ymax << (alpha ? "0 1]\n" : "0 1 0 1 0 1]\n") <<
+        "/AntiAlias true\n"
+        "/Length " << triangles.length() << "\n"
+        ">>\n"
+        "stream\n" << triangles << "endstream\n"
+        "endobj\n";
+    return shader;
+}
+#endif
+
+static void moveToHook(qfixed x, qfixed y, void *data)
+{
+    QPdf::Stroker *t = (QPdf::Stroker *)data;
+    if (!t->first)
+        *t->stream << "h\n";
+    if (!t->cosmeticPen)
+        t->matrix.map(x, y, &x, &y);
+    *t->stream << x << y << "m\n";
+    t->first = false;
+}
+
+static void lineToHook(qfixed x, qfixed y, void *data)
+{
+    QPdf::Stroker *t = (QPdf::Stroker *)data;
+    if (!t->cosmeticPen)
+        t->matrix.map(x, y, &x, &y);
+    *t->stream << x << y << "l\n";
+}
+
+static void cubicToHook(qfixed c1x, qfixed c1y,
+                        qfixed c2x, qfixed c2y,
+                        qfixed ex, qfixed ey,
+                        void *data)
+{
+    QPdf::Stroker *t = (QPdf::Stroker *)data;
+    if (!t->cosmeticPen) {
+        t->matrix.map(c1x, c1y, &c1x, &c1y);
+        t->matrix.map(c2x, c2y, &c2x, &c2y);
+        t->matrix.map(ex, ey, &ex, &ey);
+    }
+    *t->stream << c1x << c1y
+               << c2x << c2y
+               << ex << ey
+               << "c\n";
+}
+
+QPdf::Stroker::Stroker()
+    : stream(0),
+    first(true),
+    dashStroker(&basicStroker)
+{
+    stroker = &basicStroker;
+    basicStroker.setMoveToHook(moveToHook);
+    basicStroker.setLineToHook(lineToHook);
+    basicStroker.setCubicToHook(cubicToHook);
+    cosmeticPen = true;
+    basicStroker.setStrokeWidth(.1);
+}
+
+void QPdf::Stroker::setPen(const QPen &pen)
+{
+    if (pen.style() == Qt::NoPen) {
+        stroker = 0;
+        return;
+    }
+    qreal w = pen.widthF();
+    bool zeroWidth = w < 0.0001;
+    cosmeticPen = pen.isCosmetic();
+    if (zeroWidth)
+        w = .1;
+
+    basicStroker.setStrokeWidth(w);
+    basicStroker.setCapStyle(pen.capStyle());
+    basicStroker.setJoinStyle(pen.joinStyle());
+    basicStroker.setMiterLimit(pen.miterLimit());
+
+    QVector<qreal> dashpattern = pen.dashPattern();
+    if (zeroWidth) {
+        for (int i = 0; i < dashpattern.size(); ++i)
+            dashpattern[i] *= 10.;
+    }
+    if (!dashpattern.isEmpty()) {
+        dashStroker.setDashPattern(dashpattern);
+        dashStroker.setDashOffset(pen.dashOffset());
+        stroker = &dashStroker;
+    } else {
+        stroker = &basicStroker;
+    }
+}
+
+void QPdf::Stroker::strokePath(const QPainterPath &path)
+{
+    if (!stroker)
+        return;
+    first = true;
+
+    stroker->strokePath(path, this, cosmeticPen ? matrix : QTransform());
+    *stream << "h f\n";
+}
+
+QByteArray QPdf::ascii85Encode(const QByteArray &input)
+{
+    int isize = input.size()/4*4;
+    QByteArray output;
+    output.resize(input.size()*5/4+7);
+    char *out = output.data();
+    const uchar *in = (const uchar *)input.constData();
+    for (int i = 0; i < isize; i += 4) {
+        uint val = (((uint)in[i])<<24) + (((uint)in[i+1])<<16) + (((uint)in[i+2])<<8) + (uint)in[i+3];
+        if (val == 0) {
+            *out = 'z';
+            ++out;
+        } else {
+            char base[5];
+            base[4] = val % 85;
+            val /= 85;
+            base[3] = val % 85;
+            val /= 85;
+            base[2] = val % 85;
+            val /= 85;
+            base[1] = val % 85;
+            val /= 85;
+            base[0] = val % 85;
+            *(out++) = base[0] + '!';
+            *(out++) = base[1] + '!';
+            *(out++) = base[2] + '!';
+            *(out++) = base[3] + '!';
+            *(out++) = base[4] + '!';
+        }
+    }
+    //write the last few bytes
+    int remaining = input.size() - isize;
+    if (remaining) {
+        uint val = 0;
+        for (int i = isize; i < input.size(); ++i)
+            val = (val << 8) + in[i];
+        val <<= 8*(4-remaining);
+        char base[5];
+        base[4] = val % 85;
+        val /= 85;
+        base[3] = val % 85;
+        val /= 85;
+        base[2] = val % 85;
+        val /= 85;
+        base[1] = val % 85;
+        val /= 85;
+        base[0] = val % 85;
+        for (int i = 0; i < remaining+1; ++i)
+            *(out++) = base[i] + '!';
+    }
+    *(out++) = '~';
+    *(out++) = '>';
+    output.resize(out-output.data());
+    return output;
+}
+
+const char *QPdf::toHex(ushort u, char *buffer)
+{
+    int i = 3;
+    while (i >= 0) {
+        ushort hex = (u & 0x000f);
+        if (hex < 0x0a)
+            buffer[i] = '0'+hex;
+        else
+            buffer[i] = 'A'+(hex-0x0a);
+        u = u >> 4;
+        i--;
+    }
+    buffer[4] = '\0';
+    return buffer;
+}
+
+const char *QPdf::toHex(uchar u, char *buffer)
+{
+    int i = 1;
+    while (i >= 0) {
+        ushort hex = (u & 0x000f);
+        if (hex < 0x0a)
+            buffer[i] = '0'+hex;
+        else
+            buffer[i] = 'A'+(hex-0x0a);
+        u = u >> 4;
+        i--;
+    }
+    buffer[2] = '\0';
+    return buffer;
+}
+
+#define Q_MM(n) int((n * 720 + 127) / 254)
+#define Q_IN(n) int(n * 72)
+
+static const char * const psToStr[QPrinter::NPaperSize+1] =
+{
+    "A4", "B5", "Letter", "Legal", "Executive",
+    "A0", "A1", "A2", "A3", "A5", "A6", "A7", "A8", "A9", "B0", "B1",
+    "B10", "B2", "B3", "B4", "B6", "B7", "B8", "B9", "C5E", "Comm10E",
+    "DLE", "Folio", "Ledger", "Tabloid", 0
+};
+
+QPdf::PaperSize QPdf::paperSize(QPrinter::PaperSize paperSize)
+{
+    QSizeF s = qt_paperSizeToQSizeF(paperSize);
+    PaperSize p = { Q_MM(s.width()), Q_MM(s.height()) };
+    return p;
+}
+
+const char *QPdf::paperSizeToString(QPrinter::PaperSize paperSize)
+{
+    return psToStr[paperSize];
+}
+
+// -------------------------- base engine, shared code between PS and PDF -----------------------
+
+QPdfBaseEngine::QPdfBaseEngine(QPdfBaseEnginePrivate &dd, PaintEngineFeatures f)
+    : QAlphaPaintEngine(dd, f)
+{
+    Q_D(QPdfBaseEngine);
+#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
+    if (QCUPSSupport::isAvailable()) {
+        QCUPSSupport cups;
+        const cups_dest_t* printers = cups.availablePrinters();
+        int prnCount = cups.availablePrintersCount();
+
+        for (int i = 0; i <  prnCount; ++i) {
+            if (printers[i].is_default) {
+                d->printerName = QString::fromLocal8Bit(printers[i].name);
+                break;
+            }
+        }
+
+    } else
+#endif
+    {
+        d->printerName = QString::fromLocal8Bit(qgetenv("PRINTER"));
+        if (d->printerName.isEmpty())
+            d->printerName = QString::fromLocal8Bit(qgetenv("LPDEST"));
+        if (d->printerName.isEmpty())
+            d->printerName = QString::fromLocal8Bit(qgetenv("NPRINTER"));
+        if (d->printerName.isEmpty())
+            d->printerName = QString::fromLocal8Bit(qgetenv("NGPRINTER"));
+    }
+}
+
+void QPdfBaseEngine::drawPoints (const QPointF *points, int pointCount)
+{
+    if (!points)
+        return;
+
+    Q_D(QPdfBaseEngine);
+    QPainterPath p;
+    for (int i=0; i!=pointCount;++i) {
+        p.moveTo(points[i]);
+        p.lineTo(points[i] + QPointF(0, 0.001));
+    }
+
+    bool hadBrush = d->hasBrush;
+    d->hasBrush = false;
+    drawPath(p);
+    d->hasBrush = hadBrush;
+}
+
+void QPdfBaseEngine::drawLines (const QLineF *lines, int lineCount)
+{
+    if (!lines)
+        return;
+
+    Q_D(QPdfBaseEngine);
+    QPainterPath p;
+    for (int i=0; i!=lineCount;++i) {
+        p.moveTo(lines[i].p1());
+        p.lineTo(lines[i].p2());
+    }
+    bool hadBrush = d->hasBrush;
+    d->hasBrush = false;
+    drawPath(p);
+    d->hasBrush = hadBrush;
+}
+
+void QPdfBaseEngine::drawRects (const QRectF *rects, int rectCount)
+{
+    if (!rects)
+        return;
+
+    Q_D(QPdfBaseEngine);
+    if (d->useAlphaEngine) {
+        QAlphaPaintEngine::drawRects(rects, rectCount);
+        if (!continueCall())
+            return;
+    }
+
+    if (d->clipEnabled && d->allClipped)
+        return;
+    if (!d->hasPen && !d->hasBrush)
+        return;
+
+    QBrush penBrush = d->pen.brush();
+    if (d->simplePen || !d->hasPen) {
+        // draw strokes natively in this case for better output
+        if(!d->simplePen && !d->stroker.matrix.isIdentity())
+            *d->currentPage << "q\n" << QPdf::generateMatrix(d->stroker.matrix);
+        for (int i = 0; i < rectCount; ++i)
+            *d->currentPage << rects[i].x() << rects[i].y() << rects[i].width() << rects[i].height() << "re\n";
+        *d->currentPage << (d->hasPen ? (d->hasBrush ? "B\n" : "S\n") : "f\n");
+        if(!d->simplePen && !d->stroker.matrix.isIdentity())
+            *d->currentPage << "Q\n";
+    } else {
+        QPainterPath p;
+        for (int i=0; i!=rectCount; ++i)
+            p.addRect(rects[i]);
+        drawPath(p);
+    }
+}
+
+void QPdfBaseEngine::drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode)
+{
+    Q_D(QPdfBaseEngine);
+
+    if (d->useAlphaEngine) {
+        QAlphaPaintEngine::drawPolygon(points, pointCount, mode);
+        if (!continueCall())
+            return;
+    }
+
+    if (!points || !pointCount)
+        return;
+
+    bool hb = d->hasBrush;
+    QPainterPath p;
+
+    switch(mode) {
+        case OddEvenMode:
+            p.setFillRule(Qt::OddEvenFill);
+            break;
+        case ConvexMode:
+        case WindingMode:
+            p.setFillRule(Qt::WindingFill);
+            break;
+        case PolylineMode:
+            d->hasBrush = false;
+            break;
+        default:
+            break;
+    }
+
+    p.moveTo(points[0]);
+    for (int i = 1; i < pointCount; ++i)
+        p.lineTo(points[i]);
+
+    if (mode != PolylineMode)
+        p.closeSubpath();
+    drawPath(p);
+
+    d->hasBrush = hb;
+}
+
+void QPdfBaseEngine::drawPath (const QPainterPath &p)
+{
+    Q_D(QPdfBaseEngine);
+
+    if (d->useAlphaEngine) {
+        QAlphaPaintEngine::drawPath(p);
+        if (!continueCall())
+            return;
+    }
+
+    if (d->clipEnabled && d->allClipped)
+        return;
+    if (!d->hasPen && !d->hasBrush)
+        return;
+
+    if (d->simplePen) {
+        // draw strokes natively in this case for better output
+        *d->currentPage << QPdf::generatePath(p, QTransform(), d->hasBrush ? QPdf::FillAndStrokePath : QPdf::StrokePath);
+    } else {
+        if (d->hasBrush)
+            *d->currentPage << QPdf::generatePath(p, d->stroker.matrix, QPdf::FillPath);
+        if (d->hasPen) {
+            *d->currentPage << "q\n";
+            QBrush b = d->brush;
+            d->brush = d->pen.brush();
+            setBrush();
+            d->stroker.strokePath(p);
+            *d->currentPage << "Q\n";
+            d->brush = b;
+        }
+    }
+}
+
+void QPdfBaseEngine::drawTextItem(const QPointF &p, const QTextItem &textItem)
+{
+    Q_D(QPdfBaseEngine);
+
+    if (d->useAlphaEngine) {
+        QAlphaPaintEngine::drawTextItem(p, textItem);
+        if (!continueCall())
+            return;
+    }
+
+    if (!d->hasPen || (d->clipEnabled && d->allClipped))
+        return;
+
+    if (d->stroker.matrix.type() >= QTransform::TxProject) {
+        QPaintEngine::drawTextItem(p, textItem);
+        return;
+    }
+
+    *d->currentPage << "q\n";
+    if(!d->simplePen)
+        *d->currentPage << QPdf::generateMatrix(d->stroker.matrix);
+
+    bool hp = d->hasPen;
+    d->hasPen = false;
+    QBrush b = d->brush;
+    d->brush = d->pen.brush();
+    setBrush();
+
+    const QTextItemInt &ti = static_cast<const QTextItemInt &>(textItem);
+    Q_ASSERT(ti.fontEngine->type() != QFontEngine::Multi);
+    d->drawTextItem(p, ti);
+    d->hasPen = hp;
+    d->brush = b;
+    *d->currentPage << "Q\n";
+}
+
+
+void QPdfBaseEngine::updateState(const QPaintEngineState &state)
+{
+    Q_D(QPdfBaseEngine);
+
+    if (d->useAlphaEngine) {
+        QAlphaPaintEngine::updateState(state);
+        if (!continueCall())
+            return;
+    }
+
+    QPaintEngine::DirtyFlags flags = state.state();
+
+    if (flags & DirtyTransform)
+        d->stroker.matrix = state.transform();
+
+    if (flags & DirtyPen) {
+        d->pen = state.pen();
+        d->hasPen = d->pen.style() != Qt::NoPen;
+        d->stroker.setPen(d->pen);
+        QBrush penBrush = d->pen.brush();
+        bool oldSimple = d->simplePen;
+        d->simplePen = (d->hasPen && (penBrush.style() == Qt::SolidPattern) && penBrush.isOpaque());
+        if (oldSimple != d->simplePen)
+            flags |= DirtyTransform;
+    }
+    if (flags & DirtyBrush) {
+        d->brush = state.brush();
+        if (d->brush.color().alpha() == 0 && d->brush.style() == Qt::SolidPattern)
+            d->brush.setStyle(Qt::NoBrush);
+        d->hasBrush = d->brush.style() != Qt::NoBrush;
+    }
+    if (flags & DirtyBrushOrigin) {
+        d->brushOrigin = state.brushOrigin();
+        flags |= DirtyBrush;
+    }
+    if (flags & DirtyOpacity)
+        d->opacity = state.opacity();
+
+    bool ce = d->clipEnabled;
+    if (flags & DirtyClipPath) {
+        d->clipEnabled = true;
+        updateClipPath(state.clipPath(), state.clipOperation());
+    } else if (flags & DirtyClipRegion) {
+        d->clipEnabled = true;
+        QPainterPath path;
+        QVector<QRect> rects = state.clipRegion().rects();
+        for (int i = 0; i < rects.size(); ++i)
+            path.addRect(rects.at(i));
+        updateClipPath(path, state.clipOperation());
+        flags |= DirtyClipPath;
+    } else if (flags & DirtyClipEnabled) {
+        d->clipEnabled = state.isClipEnabled();
+    }
+
+    if (ce != d->clipEnabled)
+        flags |= DirtyClipPath;
+    else if (!d->clipEnabled)
+        flags &= ~DirtyClipPath;
+
+    setupGraphicsState(flags);
+}
+
+void QPdfBaseEngine::setupGraphicsState(QPaintEngine::DirtyFlags flags)
+{
+    Q_D(QPdfBaseEngine);
+    if (flags & DirtyClipPath)
+        flags |= DirtyTransform|DirtyPen|DirtyBrush;
+
+    if (flags & DirtyTransform) {
+        *d->currentPage << "Q\n";
+        flags |= DirtyPen|DirtyBrush;
+    }
+
+    if (flags & DirtyClipPath) {
+        *d->currentPage << "Q q\n";
+
+        d->allClipped = false;
+        if (d->clipEnabled && !d->clips.isEmpty()) {
+            for (int i = 0; i < d->clips.size(); ++i) {
+                if (d->clips.at(i).isEmpty()) {
+                    d->allClipped = true;
+                    break;
+                }
+            }
+            if (!d->allClipped) {
+                for (int i = 0; i < d->clips.size(); ++i) {
+                    *d->currentPage << QPdf::generatePath(d->clips.at(i), QTransform(), QPdf::ClipPath);
+                }
+            }
+        }
+    }
+
+    if (flags & DirtyTransform) {
+        *d->currentPage << "q\n";
+        if (d->simplePen && !d->stroker.matrix.isIdentity())
+            *d->currentPage << QPdf::generateMatrix(d->stroker.matrix);
+    }
+    if (flags & DirtyBrush)
+        setBrush();
+    if (d->simplePen && (flags & DirtyPen))
+        setPen();
+}
+
+extern QPainterPath qt_regionToPath(const QRegion &region);
+
+void QPdfBaseEngine::updateClipPath(const QPainterPath &p, Qt::ClipOperation op)
+{
+    Q_D(QPdfBaseEngine);
+    QPainterPath path = d->stroker.matrix.map(p);
+    //qDebug() << "updateClipPath: " << d->stroker.matrix << p.boundingRect() << path.boundingRect() << op;
+
+    if (op == Qt::NoClip) {
+        d->clipEnabled = false;
+        d->clips.clear();
+    } else if (op == Qt::ReplaceClip) {
+        d->clips.clear();
+        d->clips.append(path);
+    } else if (op == Qt::IntersectClip) {
+        d->clips.append(path);
+    } else { // UniteClip
+        // ask the painter for the current clipping path. that's the easiest solution
+        path = painter()->clipPath();
+        path = d->stroker.matrix.map(path);
+        d->clips.clear();
+        d->clips.append(path);
+    }
+
+    if (d->useAlphaEngine) {
+        // if we have an alpha region, we have to subtract that from the
+        // any existing clip region since that region will be filled in
+        // later with images
+        QPainterPath alphaClip = qt_regionToPath(alphaClipping());
+        if (!alphaClip.isEmpty()) {
+            if (!d->clipEnabled) {
+                QRect r = d->fullPage ? d->paperRect() : d->pageRect();
+                QPainterPath dev;
+                dev.addRect(QRect(0, 0, r.width(), r.height()));
+                if (path.isEmpty())
+                    path = dev;
+                else
+                    path = path.intersected(dev);
+                d->clipEnabled = true;
+            } else {
+                path = painter()->clipPath();
+                path = d->stroker.matrix.map(path);
+            }
+            path = path.subtracted(alphaClip);
+            d->clips.clear();
+            d->clips.append(path);
+        }
+    }
+}
+
+void QPdfBaseEngine::setPen()
+{
+    Q_D(QPdfBaseEngine);
+    if (d->pen.style() == Qt::NoPen)
+        return;
+    QBrush b = d->pen.brush();
+    Q_ASSERT(b.style() == Qt::SolidPattern && b.isOpaque());
+
+    QColor rgba = b.color();
+    if (d->colorMode == QPrinter::GrayScale) {
+        qreal gray = qGray(rgba.rgba())/255.;
+        *d->currentPage << gray << gray << gray;
+    } else {
+        *d->currentPage << rgba.redF()
+                        << rgba.greenF()
+                        << rgba.blueF();
+    }
+    *d->currentPage << "SCN\n";
+
+    *d->currentPage << d->pen.widthF() << "w ";
+
+    int pdfCapStyle = 0;
+    switch(d->pen.capStyle()) {
+    case Qt::FlatCap:
+        pdfCapStyle = 0;
+        break;
+    case Qt::SquareCap:
+        pdfCapStyle = 2;
+        break;
+    case Qt::RoundCap:
+        pdfCapStyle = 1;
+        break;
+    default:
+        break;
+    }
+    *d->currentPage << pdfCapStyle << "J ";
+
+    int pdfJoinStyle = 0;
+    switch(d->pen.joinStyle()) {
+    case Qt::MiterJoin:
+        pdfJoinStyle = 0;
+        break;
+    case Qt::BevelJoin:
+        pdfJoinStyle = 2;
+        break;
+    case Qt::RoundJoin:
+        pdfJoinStyle = 1;
+        break;
+    default:
+        break;
+    }
+    *d->currentPage << pdfJoinStyle << "j ";
+
+    *d->currentPage << QPdf::generateDashes(d->pen) << " 0 d\n";
+}
+
+bool QPdfBaseEngine::newPage()
+{
+    Q_D(QPdfBaseEngine);
+    setupGraphicsState(DirtyBrush|DirtyPen|DirtyClipPath);
+    QFile *outfile = qobject_cast<QFile*> (d->outDevice);
+    if (outfile && outfile->error() != QFile::NoError)
+        return false;
+    return true;
+}
+
+
+int QPdfBaseEngine::metric(QPaintDevice::PaintDeviceMetric metricType) const
+{
+    Q_D(const QPdfBaseEngine);
+    int val;
+    QRect r = d->fullPage ? d->paperRect() : d->pageRect();
+    switch (metricType) {
+    case QPaintDevice::PdmWidth:
+        val = r.width();
+        break;
+    case QPaintDevice::PdmHeight:
+        val = r.height();
+        break;
+    case QPaintDevice::PdmDpiX:
+    case QPaintDevice::PdmDpiY:
+        val = d->resolution;
+        break;
+    case QPaintDevice::PdmPhysicalDpiX:
+    case QPaintDevice::PdmPhysicalDpiY:
+        val = 1200;
+        break;
+    case QPaintDevice::PdmWidthMM:
+        val = qRound(r.width()*25.4/d->resolution);
+        break;
+    case QPaintDevice::PdmHeightMM:
+        val = qRound(r.height()*25.4/d->resolution);
+        break;
+    case QPaintDevice::PdmNumColors:
+        val = INT_MAX;
+        break;
+    case QPaintDevice::PdmDepth:
+        val = 32;
+        break;
+    default:
+        qWarning("QPrinter::metric: Invalid metric command");
+        return 0;
+    }
+    return val;
+}
+
+void QPdfBaseEngine::setProperty(PrintEnginePropertyKey key, const QVariant &value)
+{
+    Q_D(QPdfBaseEngine);
+    switch (int(key)) {
+    case PPK_CollateCopies:
+        d->collate = value.toBool();
+        break;
+    case PPK_ColorMode:
+        d->colorMode = QPrinter::ColorMode(value.toInt());
+        break;
+    case PPK_Creator:
+        d->creator = value.toString();
+        break;
+    case PPK_DocumentName:
+        d->title = value.toString();
+        break;
+    case PPK_FullPage:
+        d->fullPage = value.toBool();
+        break;
+    case PPK_CopyCount: // fallthrough
+    case PPK_NumberOfCopies:
+        d->copies = value.toInt();
+        break;
+    case PPK_Orientation:
+        d->orientation = QPrinter::Orientation(value.toInt());
+        break;
+    case PPK_OutputFileName:
+        d->outputFileName = value.toString();
+        break;
+    case PPK_PageOrder:
+        d->pageOrder = QPrinter::PageOrder(value.toInt());
+        break;
+    case PPK_PaperSize:
+        d->paperSize = QPrinter::PaperSize(value.toInt());
+        break;
+    case PPK_PaperSource:
+        d->paperSource = QPrinter::PaperSource(value.toInt());
+        break;
+    case PPK_PrinterName:
+        d->printerName = value.toString();
+        break;
+    case PPK_PrinterProgram:
+        d->printProgram = value.toString();
+        break;
+    case PPK_Resolution:
+        d->resolution = value.toInt();
+        break;
+    case PPK_SelectionOption:
+        d->selectionOption = value.toString();
+        break;
+    case PPK_FontEmbedding:
+        d->embedFonts = value.toBool();
+        break;
+    case PPK_Duplex:
+        d->duplex = static_cast<QPrinter::DuplexMode> (value.toInt());
+        break;
+    case PPK_CupsPageRect:
+        d->cupsPageRect = value.toRect();
+        break;
+    case PPK_CupsPaperRect:
+        d->cupsPaperRect = value.toRect();
+        break;
+    case PPK_CupsOptions:
+        d->cupsOptions = value.toStringList();
+        break;
+    case PPK_CupsStringPageSize:
+        d->cupsStringPageSize = value.toString();
+        break;
+    case PPK_CustomPaperSize:
+        d->paperSize = QPrinter::Custom;
+        d->customPaperSize = value.toSizeF();
+        break;
+    case PPK_PageMargins:
+    {
+        QList<QVariant> margins(value.toList());
+        Q_ASSERT(margins.size() == 4);
+        d->leftMargin = margins.at(0).toReal();
+        d->topMargin = margins.at(1).toReal();
+        d->rightMargin = margins.at(2).toReal();
+        d->bottomMargin = margins.at(3).toReal();
+        d->hasCustomPageMargins = true;
+        break;
+    }
+    default:
+        break;
+    }
+}
+
+QVariant QPdfBaseEngine::property(PrintEnginePropertyKey key) const
+{
+    Q_D(const QPdfBaseEngine);
+
+    QVariant ret;
+    switch (int(key)) {
+    case PPK_CollateCopies:
+        ret = d->collate;
+        break;
+    case PPK_ColorMode:
+        ret = d->colorMode;
+        break;
+    case PPK_Creator:
+        ret = d->creator;
+        break;
+    case PPK_DocumentName:
+        ret = d->title;
+        break;
+    case PPK_FullPage:
+        ret = d->fullPage;
+        break;
+    case PPK_CopyCount:
+        ret = d->copies;
+        break;
+    case PPK_SupportsMultipleCopies:
+#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
+        if (QCUPSSupport::isAvailable())
+            ret = true;
+        else
+#endif
+            ret = false;
+        break;
+    case PPK_NumberOfCopies:
+#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
+        if (QCUPSSupport::isAvailable())
+            ret = 1;
+        else
+#endif
+            ret = d->copies;
+        break;
+    case PPK_Orientation:
+        ret = d->orientation;
+        break;
+    case PPK_OutputFileName:
+        ret = d->outputFileName;
+        break;
+    case PPK_PageOrder:
+        ret = d->pageOrder;
+        break;
+    case PPK_PaperSize:
+        ret = d->paperSize;
+        break;
+    case PPK_PaperSource:
+        ret = d->paperSource;
+        break;
+    case PPK_PrinterName:
+        ret = d->printerName;
+        break;
+    case PPK_PrinterProgram:
+        ret = d->printProgram;
+        break;
+    case PPK_Resolution:
+        ret = d->resolution;
+        break;
+    case PPK_SupportedResolutions:
+        ret = QList<QVariant>() << 72;
+        break;
+    case PPK_PaperRect:
+        ret = d->paperRect();
+        break;
+    case PPK_PageRect:
+        ret = d->pageRect();
+        break;
+    case PPK_SelectionOption:
+        ret = d->selectionOption;
+        break;
+    case PPK_FontEmbedding:
+        ret = d->embedFonts;
+        break;
+    case PPK_Duplex:
+        ret = d->duplex;
+        break;
+    case PPK_CupsPageRect:
+        ret = d->cupsPageRect;
+        break;
+    case PPK_CupsPaperRect:
+        ret = d->cupsPaperRect;
+        break;
+    case PPK_CupsOptions:
+        ret = d->cupsOptions;
+        break;
+    case PPK_CupsStringPageSize:
+        ret = d->cupsStringPageSize;
+        break;
+    case PPK_CustomPaperSize:
+        ret = d->customPaperSize;
+        break;
+    case PPK_PageMargins:
+    {
+        QList<QVariant> margins;
+        if (d->hasCustomPageMargins) {
+            margins << d->leftMargin << d->topMargin
+                    << d->rightMargin << d->bottomMargin;
+        } else {
+            const qreal defaultMargin = 10; // ~3.5 mm
+            margins << defaultMargin << defaultMargin
+                    << defaultMargin << defaultMargin;
+        }
+        ret = margins;
+        break;
+    }
+    default:
+        break;
+    }
+    return ret;
+}
+
+QPdfBaseEnginePrivate::QPdfBaseEnginePrivate(QPrinter::PrinterMode m)
+    : clipEnabled(false), allClipped(false), hasPen(true), hasBrush(false), simplePen(false),
+      useAlphaEngine(false),
+      outDevice(0), fd(-1),
+      duplex(QPrinter::DuplexNone), collate(false), fullPage(false), embedFonts(true), copies(1),
+      pageOrder(QPrinter::FirstPageFirst), orientation(QPrinter::Portrait),
+      paperSize(QPrinter::A4), colorMode(QPrinter::Color), paperSource(QPrinter::Auto),
+      hasCustomPageMargins(false),
+      leftMargin(0), topMargin(0), rightMargin(0), bottomMargin(0)
+{
+    resolution = 72;
+    if (m == QPrinter::HighResolution)
+        resolution = 1200;
+    else if (m == QPrinter::ScreenResolution)
+        resolution = qt_defaultDpi();
+
+    postscript = false;
+    currentObject = 1;
+    currentPage = 0;
+    stroker.stream = 0;
+}
+
+bool QPdfBaseEngine::begin(QPaintDevice *pdev)
+{
+    Q_D(QPdfBaseEngine);
+    d->pdev = pdev;
+
+    d->postscript = false;
+    d->currentObject = 1;
+
+    d->currentPage = new QPdfPage;
+    d->stroker.stream = d->currentPage;
+    d->opacity = 1.0;
+
+    return d->openPrintDevice();
+}
+
+bool QPdfBaseEngine::end()
+{
+    Q_D(QPdfBaseEngine);
+    qDeleteAll(d->fonts);
+    d->fonts.clear();
+    delete d->currentPage;
+    d->currentPage = 0;
+
+    d->closePrintDevice();
+    return true;
+}
+
+#ifndef QT_NO_LPR
+static void closeAllOpenFds()
+{
+    // hack time... getting the maximum number of open
+    // files, if possible.  if not we assume it's the
+    // larger of 256 and the fd we got
+    int i;
+#if defined(_SC_OPEN_MAX)
+    i = (int)sysconf(_SC_OPEN_MAX);
+#elif defined(_POSIX_OPEN_MAX)
+    i = (int)_POSIX_OPEN_MAX;
+#elif defined(OPEN_MAX)
+    i = (int)OPEN_MAX;
+#else
+    i = 256;
+#endif
+    // leave stdin/out/err untouched
+    while(--i > 2)
+        QT_CLOSE(i);
+}
+#endif
+
+bool QPdfBaseEnginePrivate::openPrintDevice()
+{
+    if(outDevice)
+        return false;
+
+    if (!outputFileName.isEmpty()) {
+        QFile *file = new QFile(outputFileName);
+        if (! file->open(QFile::WriteOnly|QFile::Truncate)) {
+            delete file;
+            return false;
+        }
+        outDevice = file;
+#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
+    } else if (QCUPSSupport::isAvailable()) {
+        QCUPSSupport cups;
+        QPair<int, QString> ret = cups.tempFd();
+        if (ret.first < 0) {
+            qWarning("QPdfPrinter: Could not open temporary file to print");
+            return false;
+        }
+        cupsTempFile = ret.second;
+        outDevice = new QFile();
+        static_cast<QFile *>(outDevice)->open(ret.first, QIODevice::WriteOnly);
+#endif
+#ifndef QT_NO_LPR
+    } else {
+        QString pr;
+        if (!printerName.isEmpty())
+            pr = printerName;
+        int fds[2];
+        if (qt_safe_pipe(fds) != 0) {
+            qWarning("QPdfPrinter: Could not open pipe to print");
+            return false;
+        }
+
+        pid_t pid = fork();
+        if (pid == 0) {       // child process
+            // if possible, exit quickly, so the actual lp/lpr
+            // becomes a child of init, and ::waitpid() is
+            // guaranteed not to wait.
+            if (fork() > 0) {
+                closeAllOpenFds();
+
+                // try to replace this process with "true" - this prevents
+                // global destructors from being called (that could possibly
+                // do wrong things to the parent process)
+                (void)execlp("true", "true", (char *)0);
+                (void)execl("/bin/true", "true", (char *)0);
+                (void)execl("/usr/bin/true", "true", (char *)0);
+                ::_exit(0);
+            }
+            qt_safe_dup2(fds[0], 0, 0);
+
+            closeAllOpenFds();
+
+            if (!printProgram.isEmpty()) {
+                if (!selectionOption.isEmpty())
+                    pr.prepend(selectionOption);
+                else
+                    pr.prepend(QLatin1String("-P"));
+                (void)execlp(printProgram.toLocal8Bit().data(), printProgram.toLocal8Bit().data(),
+                             pr.toLocal8Bit().data(), (char *)0);
+            } else {
+                // if no print program has been specified, be smart
+                // about the option string too.
+                QList<QByteArray> lprhack;
+                QList<QByteArray> lphack;
+                QByteArray media;
+                if (!pr.isEmpty() || !selectionOption.isEmpty()) {
+                    if (!selectionOption.isEmpty()) {
+                        QStringList list = selectionOption.split(QLatin1Char(' '));
+                        for (int i = 0; i < list.size(); ++i)
+                            lprhack.append(list.at(i).toLocal8Bit());
+                        lphack = lprhack;
+                    } else {
+                        lprhack.append("-P");
+                        lphack.append("-d");
+                    }
+                    lprhack.append(pr.toLocal8Bit());
+                    lphack.append(pr.toLocal8Bit());
+                }
+                lphack.append("-s");
+
+                char ** lpargs = new char *[lphack.size()+6];
+                char lp[] = "lp";
+                lpargs[0] = lp;
+                int i;
+                for (i = 0; i < lphack.size(); ++i)
+                    lpargs[i+1] = (char *)lphack.at(i).constData();
+#ifndef Q_OS_OSF
+                if (QPdf::paperSizeToString(paperSize)) {
+                    char dash_o[] = "-o";
+                    lpargs[++i] = dash_o;
+                    lpargs[++i] = const_cast<char *>(QPdf::paperSizeToString(paperSize));
+                    lpargs[++i] = dash_o;
+                    media = "media=";
+                    media += QPdf::paperSizeToString(paperSize);
+                    lpargs[++i] = media.data();
+                }
+#endif
+                lpargs[++i] = 0;
+                char **lprargs = new char *[lprhack.size()+2];
+                char lpr[] = "lpr";
+                lprargs[0] = lpr;
+                for (int i = 0; i < lprhack.size(); ++i)
+                    lprargs[i+1] = (char *)lprhack[i].constData();
+                lprargs[lprhack.size() + 1] = 0;
+                (void)execvp("lp", lpargs);
+                (void)execvp("lpr", lprargs);
+                (void)execv("/bin/lp", lpargs);
+                (void)execv("/bin/lpr", lprargs);
+                (void)execv("/usr/bin/lp", lpargs);
+                (void)execv("/usr/bin/lpr", lprargs);
+
+                delete []lpargs;
+                delete []lprargs;
+            }
+            // if we couldn't exec anything, close the fd,
+            // wait for a second so the parent process (the
+            // child of the GUI process) has exited.  then
+            // exit.
+            QT_CLOSE(0);
+            (void)::sleep(1);
+            ::_exit(0);
+        }
+        // parent process
+        QT_CLOSE(fds[0]);
+        fd = fds[1];
+        (void)qt_safe_waitpid(pid, 0, 0);
+
+        if (fd < 0)
+            return false;
+
+        outDevice = new QFile();
+        static_cast<QFile *>(outDevice)->open(fd, QIODevice::WriteOnly);
+#endif
+    }
+
+    return true;
+}
+
+void QPdfBaseEnginePrivate::closePrintDevice()
+{
+    if (!outDevice)
+        return;
+    outDevice->close();
+    if (fd >= 0)
+#if defined(Q_OS_WIN) && defined(_MSC_VER) && _MSC_VER >= 1400
+        ::_close(fd);
+#else
+        ::close(fd);
+#endif
+    fd = -1;
+    delete outDevice;
+    outDevice = 0;
+
+#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
+    if (!cupsTempFile.isEmpty()) {
+        QString tempFile = cupsTempFile;
+        cupsTempFile.clear();
+        QCUPSSupport cups;
+
+        // Set up print options.
+        QByteArray prnName;
+        QList<QPair<QByteArray, QByteArray> > options;
+        QVector<cups_option_t> cupsOptStruct;
+
+        if (!printerName.isEmpty()) {
+            prnName = printerName.toLocal8Bit();
+        } else {
+            QPrinterInfo def = QPrinterInfo::defaultPrinter();
+            if (def.isNull()) {
+                qWarning("Could not determine printer to print to");
+                QFile::remove(tempFile);
+                return;
+            }
+            prnName = def.printerName().toLocal8Bit();
+        }
+
+        if (!cupsStringPageSize.isEmpty()) {
+            options.append(QPair<QByteArray, QByteArray>("media", cupsStringPageSize.toLocal8Bit()));
+        }
+
+        if (copies > 1) {
+            options.append(QPair<QByteArray, QByteArray>("copies", QString::number(copies).toLocal8Bit()));
+        }
+
+        if (collate) {
+            options.append(QPair<QByteArray, QByteArray>("Collate", "True"));
+        }
+
+        if (duplex != QPrinter::DuplexNone) {
+            switch(duplex) {
+            case QPrinter::DuplexNone: break;
+            case QPrinter::DuplexAuto:
+                if (orientation == QPrinter::Portrait)
+                    options.append(QPair<QByteArray, QByteArray>("sides", "two-sided-long-edge"));
+                else
+                    options.append(QPair<QByteArray, QByteArray>("sides", "two-sided-short-edge"));
+                break;
+            case QPrinter::DuplexLongSide:
+                options.append(QPair<QByteArray, QByteArray>("sides", "two-sided-long-edge"));
+                break;
+            case QPrinter::DuplexShortSide:
+                options.append(QPair<QByteArray, QByteArray>("sides", "two-sided-short-edge"));
+                break;
+            }
+        }
+
+        if (QCUPSSupport::cupsVersion() >= 10300 && orientation == QPrinter::Landscape) {
+            options.append(QPair<QByteArray, QByteArray>("landscape", ""));
+        }
+
+        QStringList::const_iterator it = cupsOptions.constBegin();
+        while (it != cupsOptions.constEnd()) {
+            options.append(QPair<QByteArray, QByteArray>((*it).toLocal8Bit(), (*(it+1)).toLocal8Bit()));
+            it += 2;
+        }
+
+        for (int c = 0; c < options.size(); ++c) {
+            cups_option_t opt;
+            opt.name = options[c].first.data();
+            opt.value = options[c].second.data();
+            cupsOptStruct.append(opt);
+        }
+
+        // Print the file.
+        cups_option_t* optPtr = cupsOptStruct.size() ? &cupsOptStruct.first() : 0;
+        cups.printFile(prnName.constData(), tempFile.toLocal8Bit().constData(),
+                title.toLocal8Bit().constData(), cupsOptStruct.size(), optPtr);
+
+        QFile::remove(tempFile);
+    }
+#endif
+}
+
+QPdfBaseEnginePrivate::~QPdfBaseEnginePrivate()
+{
+    qDeleteAll(fonts);
+    delete currentPage;
+}
+
+void QPdfBaseEnginePrivate::drawTextItem(const QPointF &p, const QTextItemInt &ti)
+{
+    Q_Q(QPdfBaseEngine);
+
+    QFontEngine *fe = ti.fontEngine;
+
+    QFontEngine::FaceId face_id = fe->faceId();
+    bool noEmbed = false;
+    if (face_id.filename.isEmpty()
+        || (!postscript && ((fe->fsType & 0x200) /* bitmap embedding only */
+                            || (fe->fsType == 2) /* no embedding allowed */))) {
+        *currentPage << "Q\n";
+        q->QPaintEngine::drawTextItem(p, ti);
+        *currentPage << "q\n";
+        if (face_id.filename.isEmpty())
+            return;
+        noEmbed = true;
+    }
+
+    QFontSubset *font = fonts.value(face_id, 0);
+    if (!font) {
+        font = new QFontSubset(fe, requestObject());
+        font->noEmbed = noEmbed;
+    }
+    fonts.insert(face_id, font);
+
+    if (!currentPage->fonts.contains(font->object_id))
+        currentPage->fonts.append(font->object_id);
+
+    qreal size = ti.fontEngine->fontDef.pixelSize;
+#ifdef Q_WS_WIN
+    if (ti.fontEngine->type() == QFontEngine::Win) {
+        QFontEngineWin *fe = static_cast<QFontEngineWin *>(ti.fontEngine);
+        size = fe->tm.tmHeight;
+    }
+#endif
+
+    QVarLengthArray<glyph_t> glyphs;
+    QVarLengthArray<QFixedPoint> positions;
+    QTransform m = QTransform::fromTranslate(p.x(), p.y());
+    ti.fontEngine->getGlyphPositions(ti.glyphs, m, ti.flags,
+                                     glyphs, positions);
+    if (glyphs.size() == 0)
+        return;
+    int synthesized = ti.fontEngine->synthesized();
+    qreal stretch = synthesized & QFontEngine::SynthesizedStretch ? ti.fontEngine->fontDef.stretch/100. : 1.;
+
+    *currentPage << "BT\n"
+                 << "/F" << font->object_id << size << "Tf "
+                 << stretch << (synthesized & QFontEngine::SynthesizedItalic
+                                ? "0 .3 -1 0 0 Tm\n"
+                                : "0 0 -1 0 0 Tm\n");
+
+
+#if 0
+    // #### implement actual text for complex languages
+    const unsigned short *logClusters = ti.logClusters;
+    int pos = 0;
+    do {
+        int end = pos + 1;
+        while (end < ti.num_chars && logClusters[end] == logClusters[pos])
+            ++end;
+        *currentPage << "/Span << /ActualText <FEFF";
+        for (int i = pos; i < end; ++i) {
+            s << toHex((ushort)ti.chars[i].unicode(), buf);
+        }
+        *currentPage << "> >>\n"
+            "BDC\n"
+            "<";
+        int ge = end == ti.num_chars ? ti.num_glyphs : logClusters[end];
+        for (int gs = logClusters[pos]; gs < ge; ++gs)
+            *currentPage << toHex((ushort)ti.glyphs[gs].glyph, buf);
+        *currentPage << "> Tj\n"
+            "EMC\n";
+        pos = end;
+    } while (pos < ti.num_chars);
+#else
+    qreal last_x = 0.;
+    qreal last_y = 0.;
+    for (int i = 0; i < glyphs.size(); ++i) {
+        qreal x = positions[i].x.toReal();
+        qreal y = positions[i].y.toReal();
+        if (synthesized & QFontEngine::SynthesizedItalic)
+            x += .3*y;
+        x /= stretch;
+        char buf[5];
+        int g = font->addGlyph(glyphs[i]);
+        *currentPage << x - last_x << last_y - y << "Td <"
+                     << QPdf::toHex((ushort)g, buf) << "> Tj\n";
+        last_x = x;
+        last_y = y;
+    }
+    if (synthesized & QFontEngine::SynthesizedBold) {
+        *currentPage << stretch << (synthesized & QFontEngine::SynthesizedItalic
+                            ? "0 .3 -1 0 0 Tm\n"
+                            : "0 0 -1 0 0 Tm\n");
+        *currentPage << "/Span << /ActualText <> >> BDC\n";
+        last_x = 0.5*fe->lineThickness().toReal();
+        last_y = 0.;
+        for (int i = 0; i < glyphs.size(); ++i) {
+            qreal x = positions[i].x.toReal();
+            qreal y = positions[i].y.toReal();
+            if (synthesized & QFontEngine::SynthesizedItalic)
+                x += .3*y;
+            x /= stretch;
+            char buf[5];
+            int g = font->addGlyph(glyphs[i]);
+            *currentPage << x - last_x << last_y - y << "Td <"
+                        << QPdf::toHex((ushort)g, buf) << "> Tj\n";
+            last_x = x;
+            last_y = y;
+        }
+        *currentPage << "EMC\n";
+    }
+#endif
+
+    *currentPage << "ET\n";
+}
+
+QRect QPdfBaseEnginePrivate::paperRect() const
+{
+    int w;
+    int h;
+    if (paperSize == QPrinter::Custom) {
+        w = qRound(customPaperSize.width()*resolution/72.);
+        h = qRound(customPaperSize.height()*resolution/72.);
+    } else {
+#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
+        if (QCUPSSupport::isAvailable() && !cupsPaperRect.isNull()) {
+            QRect r = cupsPaperRect;
+            w = r.width();
+            h = r.height();
+        } else
+#endif
+        {
+            QPdf::PaperSize s = QPdf::paperSize(paperSize);
+            w = s.width;
+            h = s.height;
+        }
+        w = qRound(w*resolution/72.);
+        h = qRound(h*resolution/72.);
+    }
+    if (orientation == QPrinter::Portrait)
+        return QRect(0, 0, w, h);
+    else
+        return QRect(0, 0, h, w);
+}
+
+QRect QPdfBaseEnginePrivate::pageRect() const
+{
+    if(fullPage)
+        return paperRect();
+
+    QRect r;
+
+#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
+    if (!hasCustomPageMargins && QCUPSSupport::isAvailable() && !cupsPageRect.isNull()) {
+        r = cupsPageRect;
+        if (r == cupsPaperRect) {
+            // if cups doesn't define any margins, give it at least approx 3.5 mm
+            r = QRect(10, 10, r.width() - 20, r.height() - 20);
+        }
+    } else
+#endif
+    {
+        QPdf::PaperSize s;
+        if (paperSize == QPrinter::Custom) {
+            s.width = qRound(customPaperSize.width());
+            s.height = qRound(customPaperSize.height());
+        } else {
+            s = QPdf::paperSize(paperSize);
+        }
+        if (hasCustomPageMargins)
+            r = QRect(0, 0, s.width, s.height);
+        else
+            r = QRect(72/3, 72/3, s.width - 2*72/3, s.height - 2*72/3);
+    }
+
+    int x = qRound(r.left()*resolution/72.);
+    int y = qRound(r.top()*resolution/72.);
+    int w = qRound(r.width()*resolution/72.);
+    int h = qRound(r.height()*resolution/72.);
+    if (orientation == QPrinter::Portrait)
+        r = QRect(x, y, w, h);
+    else
+        r = QRect(y, x, h, w);
+
+    if (hasCustomPageMargins) {
+        r.adjust(qRound(leftMargin*(resolution/72.)),
+                 qRound(topMargin*(resolution/72.)),
+                 -qRound(rightMargin*(resolution/72.)),
+                 -qRound(bottomMargin*(resolution/72.)));
+    }
+    return r;
+}
+
+#endif
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qpdf_p.h b/src/gui/painting/qpdf_p.h
new file mode 100644
index 0000000000..39e6c21620
--- /dev/null
+++ b/src/gui/painting/qpdf_p.h
@@ -0,0 +1,299 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPDF_P_H
+#define QPDF_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+#include "QtGui/qmatrix.h"
+#include "QtCore/qstring.h"
+#include "QtCore/qvector.h"
+#include "private/qstroker_p.h"
+#include "private/qfontengine_p.h"
+#include "QtGui/qprinter.h"
+#include "private/qfontsubset_p.h"
+#include "private/qpaintengine_alpha_p.h"
+#include "qprintengine.h"
+#include "qbuffer.h"
+
+#ifndef QT_NO_PRINTER
+
+QT_BEGIN_NAMESPACE
+
+#define PPK_CupsOptions QPrintEngine::PrintEnginePropertyKey(0xfe00)
+#define PPK_CupsPageRect QPrintEngine::PrintEnginePropertyKey(0xfe01)
+#define PPK_CupsPaperRect QPrintEngine::PrintEnginePropertyKey(0xfe02)
+#define PPK_CupsStringPageSize QPrintEngine::PrintEnginePropertyKey(0xfe03)
+
+const char *qt_real_to_string(qreal val, char *buf);
+const char *qt_int_to_string(int val, char *buf);
+
+namespace QPdf {
+
+    class ByteStream
+    {
+    public:
+        // fileBacking means that ByteStream will buffer the contents on disk
+        // if the size exceeds a certain threshold. In this case, if a byte
+        // array was passed in, its contents may no longer correspond to the
+        // ByteStream contents.
+        explicit ByteStream(bool fileBacking = false);
+        explicit ByteStream(QByteArray *ba, bool fileBacking = false);
+        ~ByteStream();
+        ByteStream &operator <<(char chr);
+        ByteStream &operator <<(const char *str);
+        ByteStream &operator <<(const QByteArray &str);
+        ByteStream &operator <<(const ByteStream &src);
+        ByteStream &operator <<(qreal val);
+        ByteStream &operator <<(int val);
+        ByteStream &operator <<(const QPointF &p);
+        // Note that the stream may be invalidated by calls that insert data.
+        QIODevice *stream();
+        void clear();
+
+        static inline int maxMemorySize() { return 100000000; }
+        static inline int chunkSize()     { return 10000000; }
+
+    protected:
+        void constructor_helper(QIODevice *dev);
+        void constructor_helper(QByteArray *ba);
+
+    private:
+        void prepareBuffer();
+
+    private:
+        QIODevice *dev;
+        QByteArray ba;
+        bool fileBackingEnabled;
+        bool fileBackingActive;
+        bool handleDirty;
+    };
+
+    enum PathFlags {
+        ClipPath,
+        FillPath,
+        StrokePath,
+        FillAndStrokePath
+    };
+    QByteArray generatePath(const QPainterPath &path, const QTransform &matrix, PathFlags flags);
+    QByteArray generateMatrix(const QTransform &matrix);
+    QByteArray generateDashes(const QPen &pen);
+    QByteArray patternForBrush(const QBrush &b);
+#ifdef USE_NATIVE_GRADIENTS
+    QByteArray generateLinearGradientShader(const QLinearGradient *lg, const QPointF *page_rect, bool alpha = false);
+#endif
+
+    struct Stroker {
+        Stroker();
+        void setPen(const QPen &pen);
+        void strokePath(const QPainterPath &path);
+        ByteStream *stream;
+        bool first;
+        QTransform matrix;
+        bool cosmeticPen;
+    private:
+        QStroker basicStroker;
+        QDashStroker dashStroker;
+        QStrokerOps *stroker;
+    };
+
+    QByteArray ascii85Encode(const QByteArray &input);
+
+    const char *toHex(ushort u, char *buffer);
+    const char *toHex(uchar u, char *buffer);
+
+
+    struct PaperSize {
+        int width, height; // in postscript points
+    };
+    PaperSize paperSize(QPrinter::PaperSize paperSize);
+    const char *paperSizeToString(QPrinter::PaperSize paperSize);
+
+}
+
+
+class QPdfPage : public QPdf::ByteStream
+{
+public:
+    QPdfPage();
+
+    QVector<uint> images;
+    QVector<uint> graphicStates;
+    QVector<uint> patterns;
+    QVector<uint> fonts;
+    QVector<uint> annotations;
+
+    void streamImage(int w, int h, int object);
+
+    QSize pageSize;
+private:
+};
+
+
+class QPdfBaseEnginePrivate;
+
+class QPdfBaseEngine : public QAlphaPaintEngine, public QPrintEngine
+{
+    Q_DECLARE_PRIVATE(QPdfBaseEngine)
+public:
+    QPdfBaseEngine(QPdfBaseEnginePrivate &d, PaintEngineFeatures f);
+    ~QPdfBaseEngine() {}
+
+    // reimplementations QPaintEngine
+    bool begin(QPaintDevice *pdev);
+    bool end();
+
+    void drawPoints(const QPointF *points, int pointCount);
+    void drawLines(const QLineF *lines, int lineCount);
+    void drawRects(const QRectF *rects, int rectCount);
+    void drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode);
+    void drawPath (const QPainterPath & path);
+
+    void drawTextItem(const QPointF &p, const QTextItem &textItem);
+
+    void updateState(const QPaintEngineState &state);
+
+    int metric(QPaintDevice::PaintDeviceMetric metricType) const;
+    // end reimplementations QPaintEngine
+
+    // Printer stuff...
+    bool newPage();
+    void setProperty(PrintEnginePropertyKey key, const QVariant &value);
+    QVariant property(PrintEnginePropertyKey key) const;
+
+    void setPen();
+    virtual void setBrush() = 0;
+    void setupGraphicsState(QPaintEngine::DirtyFlags flags);
+
+private:
+    void updateClipPath(const QPainterPath & path, Qt::ClipOperation op);
+};
+
+class QPdfBaseEnginePrivate : public QAlphaPaintEnginePrivate
+{
+    Q_DECLARE_PUBLIC(QPdfBaseEngine)
+public:
+    QPdfBaseEnginePrivate(QPrinter::PrinterMode m);
+    ~QPdfBaseEnginePrivate();
+
+    bool openPrintDevice();
+    void closePrintDevice();
+
+
+    virtual void drawTextItem(const QPointF &p, const QTextItemInt &ti);
+    inline uint requestObject() { return currentObject++; }
+
+    QRect paperRect() const;
+    QRect pageRect() const;
+
+    bool postscript;
+    int currentObject;
+
+    QPdfPage* currentPage;
+    QPdf::Stroker stroker;
+
+    QPointF brushOrigin;
+    QBrush brush;
+    QPen pen;
+    QList<QPainterPath> clips;
+    bool clipEnabled;
+    bool allClipped;
+    bool hasPen;
+    bool hasBrush;
+    bool simplePen;
+    qreal opacity;
+    bool useAlphaEngine;
+
+    QHash<QFontEngine::FaceId, QFontSubset *> fonts;
+
+    QPaintDevice *pdev;
+
+    // the device the output is in the end streamed to.
+    QIODevice *outDevice;
+    int fd;
+
+    // printer options
+    QString outputFileName;
+    QString printerName;
+    QString printProgram;
+    QString selectionOption;
+    QString title;
+    QString creator;
+    QPrinter::DuplexMode duplex;
+    bool collate;
+    bool fullPage;
+    bool embedFonts;
+    int copies;
+    int resolution;
+    QPrinter::PageOrder pageOrder;
+    QPrinter::Orientation orientation;
+    QPrinter::PaperSize paperSize;
+    QPrinter::ColorMode colorMode;
+    QPrinter::PaperSource paperSource;
+
+    QStringList cupsOptions;
+    QRect cupsPaperRect;
+    QRect cupsPageRect;
+    QString cupsStringPageSize;
+    QSizeF customPaperSize; // in postscript points
+    bool hasCustomPageMargins;
+    qreal leftMargin, topMargin, rightMargin, bottomMargin;
+
+#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
+    QString cupsTempFile;
+#endif
+};
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_PRINTER
+
+#endif // QPDF_P_H
+
diff --git a/src/gui/painting/qpen.cpp b/src/gui/painting/qpen.cpp
new file mode 100644
index 0000000000..b69458dca5
--- /dev/null
+++ b/src/gui/painting/qpen.cpp
@@ -0,0 +1,1032 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include "qpen.h"
+#include "qpen_p.h"
+#include "qdatastream.h"
+#include "qvariant.h"
+#include "qbrush.h"
+
+#include <qdebug.h>
+
+QT_BEGIN_NAMESPACE
+
+typedef QPenPrivate QPenData;
+
+/*!
+    \class QPen
+    \ingroup painting
+    \ingroup shared
+
+
+    \brief The QPen class defines how a QPainter should draw lines and outlines
+    of shapes.
+
+    A pen has a style(), width(), brush(), capStyle() and joinStyle().
+
+    The pen style defines the line type. The brush is used to fill
+    strokes generated with the pen. Use the QBrush class to specify
+    fill styles.  The cap style determines the line end caps that can
+    be drawn using QPainter, while the join style describes how joins
+    between two lines are drawn. The pen width can be specified in
+    both integer (width()) and floating point (widthF()) precision. A
+    line width of zero indicates a cosmetic pen.  This means that the
+    pen width is always drawn one pixel wide, independent of the \l
+    {QPainter#Coordinate Transformations}{transformation} set on the
+    painter.
+
+    The various settings can easily be modified using the
+    corresponding setStyle(), setWidth(), setBrush(), setCapStyle()
+    and setJoinStyle() functions (note that the painter's pen must be
+    reset when altering the pen's properties).
+
+    For example:
+
+    \snippet doc/src/snippets/code/src_gui_painting_qpen.cpp 0
+
+    which is equivalent to
+
+    \snippet doc/src/snippets/code/src_gui_painting_qpen.cpp 1
+
+    The default pen is a solid black brush with 0 width, square
+    cap style (Qt::SquareCap), and  bevel join style (Qt::BevelJoin).
+
+    In addition QPen provides the color() and setColor()
+    convenience functions to extract and set the color of the pen's
+    brush, respectively. Pens may also be compared and streamed.
+
+    For more information about painting in general, see the \l{Paint
+    System} documentation.
+
+    \tableofcontents
+
+    \section1 Pen Style
+
+    Qt provides several built-in styles represented by the
+    Qt::PenStyle enum:
+
+    \table
+    \row
+    \o \inlineimage qpen-solid.png
+    \o \inlineimage qpen-dash.png
+    \o \inlineimage qpen-dot.png
+    \row
+    \o Qt::SolidLine
+    \o Qt::DashLine
+    \o Qt::DotLine
+    \row
+    \o \inlineimage qpen-dashdot.png
+    \o \inlineimage qpen-dashdotdot.png
+    \o \inlineimage qpen-custom.png
+    \row
+    \o Qt::DashDotLine
+    \o Qt::DashDotDotLine
+    \o Qt::CustomDashLine
+    \endtable
+
+    Simply use the setStyle() function to convert the pen style to
+    either of the built-in styles, except the Qt::CustomDashLine style
+    which we will come back to shortly. Setting the style to Qt::NoPen
+    tells the painter to not draw lines or outlines. The default pen
+    style is Qt::SolidLine.
+
+    Since Qt 4.1 it is also possible to specify a custom dash pattern
+    using the setDashPattern() function which implicitly converts the
+    style of the pen to Qt::CustomDashLine. The pattern argument, a
+    QVector, must be specified as an even number of \l qreal entries
+    where the entries 1, 3, 5... are the dashes and 2, 4, 6... are the
+    spaces. For example, the custom pattern shown above is created
+    using the following code:
+
+    \snippet doc/src/snippets/code/src_gui_painting_qpen.cpp 2
+
+    Note that the dash pattern is specified in units of the pens
+    width, e.g. a dash of length 5 in width 10 is 50 pixels long.
+
+    The currently set dash pattern can be retrieved using the
+    dashPattern() function. Use the isSolid() function to determine
+    whether the pen has a solid fill, or not.
+
+    \section1 Cap Style
+
+    The cap style defines how the end points of lines are drawn using
+    QPainter.  The cap style only apply to wide lines, i.e. when the
+    width is 1 or greater. The Qt::PenCapStyle enum provides the
+    following styles:
+
+    \table
+    \row
+    \o \inlineimage qpen-square.png
+    \o \inlineimage qpen-flat.png
+    \o \inlineimage qpen-roundcap.png
+    \row
+    \o Qt::SquareCap
+    \o Qt::FlatCap
+    \o Qt::RoundCap
+    \endtable
+
+    The Qt::SquareCap style is a square line end that covers the end
+    point and extends beyond it by half the line width. The
+    Qt::FlatCap style is a square line end that does not cover the end
+    point of the line. And the Qt::RoundCap style is a rounded line
+    end covering the end point.
+
+    The default is Qt::SquareCap.
+
+    Whether or not end points are drawn when the pen width is 0 or 1
+    depends on the cap style. Using Qt::SquareCap or Qt::RoundCap they
+    are drawn, using Qt::FlatCap they are not drawn.
+
+    \section1 Join Style
+
+    The join style defines how joins between two connected lines can
+    be drawn using QPainter. The join style only apply to wide lines,
+    i.e. when the width is 1 or greater. The Qt::PenJoinStyle enum
+    provides the following styles:
+
+    \table
+    \row
+    \o \inlineimage qpen-bevel.png
+    \o \inlineimage qpen-miter.png
+    \o \inlineimage qpen-roundjoin.png
+    \row
+    \o Qt::BevelJoin
+    \o Qt::MiterJoin
+    \o Qt::RoundJoin
+    \endtable
+
+    The Qt::BevelJoin style fills the triangular notch between the two
+    lines. The Qt::MiterJoin style extends the lines to meet at an
+    angle. And the Qt::RoundJoin style fills a circular arc between
+    the two lines.
+
+    The default is Qt::BevelJoin.
+
+    \image qpen-miterlimit.png
+
+    When the Qt::MiterJoin style is applied, it is possible to use the
+    setMiterLimit() function to specify how far the miter join can
+    extend from the join point. The miterLimit() is used to reduce
+    artifacts between line joins where the lines are close to
+    parallel.
+
+    The miterLimit() must be specified in units of the pens width,
+    e.g. a miter limit of 5 in width 10 is 50 pixels long. The
+    default miter limit is 2, i.e. twice the pen width in pixels.
+
+    \table 100%
+    \row
+    \o \inlineimage qpen-demo.png
+    \o \bold {\l {demos/pathstroke}{The Path Stroking Demo}}
+
+    The Path Stroking demo shows Qt's built-in dash patterns and shows
+    how custom patterns can be used to extend the range of available
+    patterns.
+    \endtable
+
+    \sa QPainter, QBrush, {demos/pathstroke}{Path Stroking Demo},
+        {Scribble Example}
+*/
+
+/*!
+  \internal
+*/
+inline QPenPrivate::QPenPrivate(const QBrush &_brush, qreal _width, Qt::PenStyle penStyle,
+                                Qt::PenCapStyle _capStyle, Qt::PenJoinStyle _joinStyle)
+    : dashOffset(0), miterLimit(2),
+      cosmetic(false)
+{
+    ref = 1;
+    width = _width;
+    brush = _brush;
+    style = penStyle;
+    capStyle = _capStyle;
+    joinStyle = _joinStyle;
+}
+
+static const Qt::PenCapStyle qpen_default_cap = Qt::SquareCap;
+static const Qt::PenJoinStyle qpen_default_join = Qt::BevelJoin;
+
+#ifndef QT_NO_THREAD
+// Special deleter that only deletes if the ref-count goes to zero
+template <>
+class QGlobalStaticDeleter<QPenPrivate>
+{
+public:
+    QGlobalStatic<QPenPrivate> &globalStatic;
+    QGlobalStaticDeleter(QGlobalStatic<QPenPrivate> &_globalStatic)
+        : globalStatic(_globalStatic)
+    { }
+
+    inline ~QGlobalStaticDeleter()
+    {
+        if (!globalStatic.pointer->ref.deref())
+            delete globalStatic.pointer;
+        globalStatic.pointer = 0;
+        globalStatic.destroyed = true;
+    }
+};
+#endif
+
+Q_GLOBAL_STATIC_WITH_ARGS(QPenData, defaultPenInstance,
+                          (Qt::black, 0, Qt::SolidLine, qpen_default_cap, qpen_default_join))
+Q_GLOBAL_STATIC_WITH_ARGS(QPenData, nullPenInstance,
+                          (Qt::black, 0, Qt::NoPen, qpen_default_cap, qpen_default_join))
+
+/*!
+    Constructs a default black solid line pen with 0 width.
+*/
+
+QPen::QPen()
+{
+    d = defaultPenInstance();
+    d->ref.ref();
+}
+
+/*!
+    Constructs a black pen with 0 width and the given \a style.
+
+    \sa setStyle()
+*/
+
+QPen::QPen(Qt::PenStyle style)
+{
+    if (style == Qt::NoPen) {
+        d = nullPenInstance();
+        d->ref.ref();
+    } else {
+        d = new QPenData(Qt::black, 0, style, qpen_default_cap, qpen_default_join);
+    }
+}
+
+
+/*!
+    Constructs a solid line pen with 0 width and the given \a color.
+
+    \sa setBrush(), setColor()
+*/
+
+QPen::QPen(const QColor &color)
+{
+    d = new QPenData(color, 0, Qt::SolidLine, qpen_default_cap, qpen_default_join);
+}
+
+
+/*!
+    \fn QPen::QPen(const QBrush &brush, qreal width, Qt::PenStyle style, Qt::PenCapStyle cap, Qt::PenJoinStyle join)
+
+    Constructs a pen with the specified \a brush, \a width, pen \a style,
+    \a cap style and \a join style.
+
+    \sa setBrush(), setWidth(), setStyle(),  setCapStyle(), setJoinStyle()
+*/
+
+QPen::QPen(const QBrush &brush, qreal width, Qt::PenStyle s, Qt::PenCapStyle c, Qt::PenJoinStyle j)
+{
+    d = new QPenData(brush, width, s, c, j);
+}
+
+/*!
+    \fn QPen::QPen(const QPen &pen)
+
+    Constructs a pen that is a copy of the given \a pen.
+*/
+
+QPen::QPen(const QPen &p)
+{
+    d = p.d;
+    d->ref.ref();
+}
+
+
+/*!
+    Destroys the pen.
+*/
+
+QPen::~QPen()
+{
+    if (!d->ref.deref())
+        delete d;
+}
+
+/*!
+    \fn void QPen::detach()
+    Detaches from shared pen data to make sure that this pen is the
+    only one referring the data.
+
+    If multiple pens share common data, this pen dereferences the data
+    and gets a copy of the data. Nothing is done if there is just a
+    single reference.
+*/
+
+void QPen::detach()
+{
+    if (d->ref == 1)
+        return;
+
+    QPenData *x = new QPenData(*static_cast<QPenData *>(d));
+    if (!d->ref.deref())
+        delete d;
+    x->ref = 1;
+    d = x;
+}
+
+
+/*!
+    \fn QPen &QPen::operator=(const QPen &pen)
+
+    Assigns the given \a pen to this pen and returns a reference to
+    this pen.
+*/
+
+QPen &QPen::operator=(const QPen &p)
+{
+    qAtomicAssign(d, p.d);
+    return *this;
+}
+
+/*!
+    \fn void QPen::swap(QPen &other)
+    \since 4.8
+
+    Swaps pen \a other with this pen. This operation is very
+    fast and never fails.
+*/
+
+/*!
+   Returns the pen as a QVariant.
+*/
+QPen::operator QVariant() const
+{
+    return QVariant(QVariant::Pen, this);
+}
+
+/*!
+    \fn Qt::PenStyle QPen::style() const
+
+    Returns the pen style.
+
+    \sa setStyle(), {QPen#Pen Style}{Pen Style}
+*/
+Qt::PenStyle QPen::style() const
+{
+    return d->style;
+}
+/*!
+    \fn void QPen::setStyle(Qt::PenStyle style)
+
+    Sets the pen style to the given \a style.
+
+    See the \l Qt::PenStyle documentation for a list of the available
+    styles. Since Qt 4.1 it is also possible to specify a custom dash
+    pattern using the setDashPattern() function which implicitly
+    converts the style of the pen to Qt::CustomDashLine.
+
+    \note This function resets the dash offset to zero.
+
+    \sa style(), {QPen#Pen Style}{Pen Style}
+*/
+
+void QPen::setStyle(Qt::PenStyle s)
+{
+    if (d->style == s)
+        return;
+    detach();
+    d->style = s;
+    QPenData *dd = static_cast<QPenData *>(d);
+    dd->dashPattern.clear();
+    dd->dashOffset = 0;
+}
+
+/*!
+    Returns the dash pattern of this pen.
+
+    \sa style(), isSolid()
+ */
+QVector<qreal> QPen::dashPattern() const
+{
+    QPenData *dd = static_cast<QPenData *>(d);
+    if (d->style == Qt::SolidLine || d->style == Qt::NoPen) {
+        return QVector<qreal>();
+    } else if (dd->dashPattern.isEmpty()) {
+        const qreal space = 2;
+        const qreal dot = 1;
+        const qreal dash = 4;
+
+        switch (d->style) {
+        case Qt::DashLine:
+            dd->dashPattern << dash << space;
+            break;
+        case Qt::DotLine:
+            dd->dashPattern << dot << space;
+            break;
+        case Qt::DashDotLine:
+            dd->dashPattern << dash << space << dot << space;
+            break;
+        case Qt::DashDotDotLine:
+            dd->dashPattern << dash << space << dot << space << dot << space;
+            break;
+        default:
+            break;
+        }
+    }
+    return dd->dashPattern;
+}
+
+/*!
+    Sets the dash pattern for this pen to the given \a pattern. This
+    implicitly converts the style of the pen to Qt::CustomDashLine.
+
+    The pattern must be specified as an even number of positive entries
+    where the entries 1, 3, 5... are the dashes and 2, 4, 6... are the
+    spaces. For example:
+
+    \table 100%
+    \row
+    \o \inlineimage qpen-custom.png
+    \o
+    \snippet doc/src/snippets/code/src_gui_painting_qpen.cpp 3
+    \endtable
+
+    The dash pattern is specified in units of the pens width; e.g. a
+    dash of length 5 in width 10 is 50 pixels long. Note that a pen
+    with zero width is equivalent to a cosmetic pen with a width of 1
+    pixel.
+
+    Each dash is also subject to cap styles so a dash of 1 with square
+    cap set will extend 0.5 pixels out in each direction resulting in
+    a total width of 2.
+
+    Note that the default cap style is Qt::SquareCap, meaning that a
+    square line end covers the end point and extends beyond it by half
+    the line width.
+
+    \sa setStyle(), dashPattern(), setCapStyle(), setCosmetic()
+ */
+void QPen::setDashPattern(const QVector<qreal> &pattern)
+{
+    if (pattern.isEmpty())
+        return;
+    detach();
+
+    QPenData *dd = static_cast<QPenData *>(d);
+    dd->dashPattern = pattern;
+    d->style = Qt::CustomDashLine;
+
+    if ((dd->dashPattern.size() % 2) == 1) {
+        qWarning("QPen::setDashPattern: Pattern not of even length");
+        dd->dashPattern << 1;
+    }
+}
+
+
+/*!
+    Returns the dash offset for the pen.
+
+    \sa setDashOffset()
+*/
+qreal QPen::dashOffset() const
+{
+    QPenData *dd = static_cast<QPenData *>(d);
+    return dd->dashOffset;
+}
+/*!
+    Sets the dash offset (the starting point on the dash pattern) for this pen
+    to the \a offset specified. The offset is measured in terms of the units used
+    to specify the dash pattern.
+
+    \table
+    \row \o \inlineimage qpen-dashpattern.png
+    \o For example, a pattern where each stroke is four units long, followed by a gap
+    of two units, will begin with the stroke when drawn as a line.
+
+    However, if the dash offset is set to 4.0, any line drawn will begin with the gap.
+    Values of the offset up to 4.0 will cause part of the stroke to be drawn first,
+    and values of the offset between 4.0 and 6.0 will cause the line to begin with
+    part of the gap.
+    \endtable
+
+    \note This implicitly converts the style of the pen to Qt::CustomDashLine.
+*/
+void QPen::setDashOffset(qreal offset)
+{
+    if (qFuzzyCompare(offset, static_cast<QPenData *>(d)->dashOffset))
+        return;
+    detach();
+    QPenData *dd = static_cast<QPenData *>(d);
+    dd->dashOffset = offset;
+    if (d->style != Qt::CustomDashLine) {
+        dd->dashPattern = dashPattern();
+        d->style = Qt::CustomDashLine;
+    }
+}
+
+/*!
+    Returns the miter limit of the pen. The miter limit is only
+    relevant when the join style is set to Qt::MiterJoin.
+
+    \sa setMiterLimit(),  {QPen#Join Style}{Join Style}
+*/
+qreal QPen::miterLimit() const
+{
+    const QPenData *dd = static_cast<QPenData *>(d);
+    return dd->miterLimit;
+}
+
+/*!
+    Sets the miter limit of this pen to the given \a limit.
+
+    \image qpen-miterlimit.png
+
+    The miter limit describes how far a miter join can extend from the
+    join point. This is used to reduce artifacts between line joins
+    where the lines are close to parallel.
+
+    This value does only have effect when the pen style is set to
+    Qt::MiterJoin. The value is specified in units of the pen's width,
+    e.g. a miter limit of 5 in width 10 is 50 pixels long. The default
+    miter limit is 2, i.e. twice the pen width in pixels.
+
+    \sa miterLimit(), setJoinStyle(), {QPen#Join Style}{Join Style}
+*/
+void QPen::setMiterLimit(qreal limit)
+{
+    detach();
+    QPenData *dd = static_cast<QPenData *>(d);
+    dd->miterLimit = limit;
+}
+
+
+/*!
+    \fn qreal QPen::width() const
+
+    Returns the pen width with integer precision.
+
+    \sa setWidth(), widthF()
+*/
+
+int QPen::width() const
+{
+    return qRound(d->width);
+}
+
+/*!
+    \fn qreal QPen::widthF() const
+
+    Returns the pen width with floating point precision.
+
+    \sa setWidthF() width()
+*/
+qreal QPen::widthF() const
+{
+    return d->width;
+}
+
+/*!
+    \fn QPen::setWidth(int width)
+
+    Sets the pen width to the given \a width in pixels with integer
+    precision.
+
+    A line width of zero indicates a cosmetic pen. This means that the
+    pen width is always drawn one pixel wide, independent of the \l
+    {QPainter#Coordinate Transformations}{transformation} set on the
+    painter.
+
+    Setting a pen width with a negative value is not supported.
+
+    \sa setWidthF(), width()
+*/
+void QPen::setWidth(int width)
+{
+    if (width < 0)
+        qWarning("QPen::setWidth: Setting a pen width with a negative value is not defined");
+    if ((qreal)width == d->width)
+        return;
+    detach();
+    d->width = width;
+}
+
+/*!
+    Sets the pen width to the given \a width in pixels with floating point
+    precision.
+
+    A line width of zero indicates a cosmetic pen. This means that the
+    pen width is always drawn one pixel wide, independent of the \l
+    {QPainter#Coordinate Transformations}{transformation} on the
+    painter.
+
+    Setting a pen width with a negative value is not supported.
+
+    \sa setWidth() widthF()
+*/
+
+void QPen::setWidthF(qreal width)
+{
+    if (width < 0.f)
+        qWarning("QPen::setWidthF: Setting a pen width with a negative value is not defined");
+    if (qAbs(d->width - width) < 0.00000001f)
+        return;
+    detach();
+    d->width = width;
+}
+
+
+/*!
+    Returns the pen's cap style.
+
+    \sa setCapStyle(), {QPen#Cap Style}{Cap Style}
+*/
+Qt::PenCapStyle QPen::capStyle() const
+{
+    return d->capStyle;
+}
+
+/*!
+    \fn void QPen::setCapStyle(Qt::PenCapStyle style)
+
+    Sets the pen's cap style to the given \a style. The default value
+    is Qt::SquareCap.
+
+    \sa capStyle(), {QPen#Cap Style}{Cap Style}
+*/
+
+void QPen::setCapStyle(Qt::PenCapStyle c)
+{
+    if (d->capStyle == c)
+        return;
+    detach();
+    d->capStyle = c;
+}
+
+/*!
+    Returns the pen's join style.
+
+    \sa setJoinStyle(),  {QPen#Join Style}{Join Style}
+*/
+Qt::PenJoinStyle QPen::joinStyle() const
+{
+    return d->joinStyle;
+}
+
+/*!
+    \fn void QPen::setJoinStyle(Qt::PenJoinStyle style)
+
+    Sets the pen's join style to the given \a style. The default value
+    is Qt::BevelJoin.
+
+    \sa joinStyle(), {QPen#Join Style}{Join Style}
+*/
+
+void QPen::setJoinStyle(Qt::PenJoinStyle j)
+{
+    if (d->joinStyle == j)
+        return;
+    detach();
+    d->joinStyle = j;
+}
+
+/*!
+    \fn const QColor &QPen::color() const
+
+    Returns the color of this pen's brush.
+
+    \sa brush(), setColor()
+*/
+QColor QPen::color() const
+{
+    return d->brush.color();
+}
+
+/*!
+    \fn void QPen::setColor(const QColor &color)
+
+    Sets the color of this pen's brush to the given \a color.
+
+    \sa setBrush(), color()
+*/
+
+void QPen::setColor(const QColor &c)
+{
+    detach();
+    d->brush = QBrush(c);
+}
+
+
+/*!
+    Returns the brush used to fill strokes generated with this pen.
+*/
+QBrush QPen::brush() const
+{
+    return d->brush;
+}
+
+/*!
+    Sets the brush used to fill strokes generated with this pen to the given
+    \a brush.
+
+    \sa brush(), setColor()
+*/
+void QPen::setBrush(const QBrush &brush)
+{
+    detach();
+    d->brush = brush;
+}
+
+
+/*!
+    Returns true if the pen has a solid fill, otherwise false.
+
+    \sa style(), dashPattern()
+*/
+bool QPen::isSolid() const
+{
+    return d->brush.style() == Qt::SolidPattern;
+}
+
+
+/*!
+    Returns true if the pen is cosmetic; otherwise returns false.
+
+    Cosmetic pens are used to draw strokes that have a constant width
+    regardless of any transformations applied to the QPainter they are
+    used with. Drawing a shape with a cosmetic pen ensures that its
+    outline will have the same thickness at different scale factors.
+
+    A zero width pen is cosmetic by default; pens with a non-zero width
+    are non-cosmetic.
+
+    \sa setCosmetic(), widthF()
+*/
+
+bool QPen::isCosmetic() const
+{
+    QPenData *dd = static_cast<QPenData *>(d);
+    return (dd->cosmetic == true) || d->width == 0;
+}
+
+
+/*!
+    Sets this pen to cosmetic or non-cosmetic, depending on the value of
+    \a cosmetic.
+
+    \sa isCosmetic()
+*/
+
+void QPen::setCosmetic(bool cosmetic)
+{
+    detach();
+    QPenData *dd = static_cast<QPenData *>(d);
+    dd->cosmetic = cosmetic;
+}
+
+
+
+/*!
+    \fn bool QPen::operator!=(const QPen &pen) const
+
+    Returns true if the pen is different from the given \a pen;
+    otherwise false. Two pens are different if they have different
+    styles, widths or colors.
+
+    \sa operator==()
+*/
+
+/*!
+    \fn bool QPen::operator==(const QPen &pen) const
+
+    Returns true if the pen is equal to the given \a pen; otherwise
+    false. Two pens are equal if they have equal styles, widths and
+    colors.
+
+    \sa operator!=()
+*/
+
+bool QPen::operator==(const QPen &p) const
+{
+    QPenData *dd = static_cast<QPenData *>(d);
+    QPenData *pdd = static_cast<QPenData *>(p.d);
+    return (p.d == d)
+        || (p.d->style == d->style
+            && p.d->capStyle == d->capStyle
+            && p.d->joinStyle == d->joinStyle
+            && p.d->width == d->width
+            && pdd->miterLimit == dd->miterLimit
+            && (d->style != Qt::CustomDashLine
+                || (qFuzzyCompare(pdd->dashOffset, dd->dashOffset) &&
+                    pdd->dashPattern == dd->dashPattern))
+            && p.d->brush == d->brush
+            && pdd->cosmetic == dd->cosmetic);
+}
+
+
+/*!
+    \fn bool QPen::isDetached()
+
+    \internal
+*/
+
+bool QPen::isDetached()
+{
+    return d->ref == 1;
+}
+
+
+/*****************************************************************************
+  QPen stream functions
+ *****************************************************************************/
+#ifndef QT_NO_DATASTREAM
+/*!
+    \fn QDataStream &operator<<(QDataStream &stream, const QPen &pen)
+    \relates QPen
+
+    Writes the given \a pen to the given \a stream and returns a reference to
+    the \a stream.
+
+    \sa {Serializing Qt Data Types}
+*/
+
+QDataStream &operator<<(QDataStream &s, const QPen &p)
+{
+    QPenData *dd = static_cast<QPenData *>(p.d);
+    if (s.version() < 3) {
+        s << (quint8)p.style();
+    } else if (s.version() < QDataStream::Qt_4_3) {
+        s << (quint8)(p.style() | p.capStyle() | p.joinStyle());
+    } else {
+        s << (quint16)(p.style() | p.capStyle() | p.joinStyle());
+        s << (bool)(dd->cosmetic);
+    }
+
+    if (s.version() < 7) {
+        s << (quint8)p.width();
+        s << p.color();
+    } else {
+        s << double(p.widthF());
+        s << p.brush();
+        s << double(p.miterLimit());
+        if (sizeof(qreal) == sizeof(double)) {
+            s << p.dashPattern();
+        } else {
+            // ensure that we write doubles here instead of streaming the pattern
+            // directly; otherwise, platforms that redefine qreal might generate
+            // data that cannot be read on other platforms.
+            QVector<qreal> pattern = p.dashPattern();
+            s << quint32(pattern.size());
+            for (int i = 0; i < pattern.size(); ++i)
+                s << double(pattern.at(i));
+        }
+        if (s.version() >= 9)
+            s << double(p.dashOffset());
+    }
+    return s;
+}
+
+/*!
+    \fn QDataStream &operator>>(QDataStream &stream, QPen &pen)
+    \relates QPen
+
+    Reads a pen from the given \a stream into the given \a pen and
+    returns a reference to the \a stream.
+
+    \sa {Serializing Qt Data Types}
+*/
+
+QDataStream &operator>>(QDataStream &s, QPen &p)
+{
+    quint16 style;
+    quint8 width8 = 0;
+    double width = 0;
+    QColor color;
+    QBrush brush;
+    double miterLimit = 2;
+    QVector<qreal> dashPattern;
+    double dashOffset = 0;
+    bool cosmetic = false;
+    if (s.version() < QDataStream::Qt_4_3) {
+        quint8 style8;
+        s >> style8;
+        style = style8;
+    } else {
+        s >> style;
+        s >> cosmetic;
+    }
+    if (s.version() < 7) {
+        s >> width8;
+        s >> color;
+        brush = color;
+        width = width8;
+    } else {
+        s >> width;
+        s >> brush;
+        s >> miterLimit;
+        if (sizeof(qreal) == sizeof(double)) {
+            s >> dashPattern;
+        } else {
+            quint32 numDashes;
+            s >> numDashes;
+            double dash;
+            for (quint32 i = 0; i < numDashes; ++i) {
+                s >> dash;
+                dashPattern << dash;
+            }
+        }
+        if (s.version() >= 9)
+            s >> dashOffset;
+    }
+
+    p.detach();
+    QPenData *dd = static_cast<QPenData *>(p.d);
+    dd->width = width;
+    dd->brush = brush;
+    dd->style = Qt::PenStyle(style & Qt::MPenStyle);
+    dd->capStyle = Qt::PenCapStyle(style & Qt::MPenCapStyle);
+    dd->joinStyle = Qt::PenJoinStyle(style & Qt::MPenJoinStyle);
+    dd->dashPattern = dashPattern;
+    dd->miterLimit = miterLimit;
+    dd->dashOffset = dashOffset;
+    dd->cosmetic = cosmetic;
+
+    return s;
+}
+#endif //QT_NO_DATASTREAM
+
+#ifndef QT_NO_DEBUG_STREAM
+QDebug operator<<(QDebug dbg, const QPen &p)
+{
+#ifndef Q_BROKEN_DEBUG_STREAM
+    const char *PEN_STYLES[] = {
+        "NoPen",
+        "SolidLine",
+        "DashLine",
+        "DotLine",
+        "DashDotLine",
+        "DashDotDotLine",
+        "CustomDashLine"
+    };
+
+    dbg.nospace() << "QPen(" << p.width() << ',' << p.brush()
+                  << ',' << PEN_STYLES[p.style()] << ',' << int(p.capStyle())
+                  << ',' << int(p.joinStyle()) << ',' << p.dashPattern()
+                  << ',' << p.dashOffset()
+                  << ',' << p.miterLimit() << ')';
+    return dbg.space();
+#else
+    qWarning("This compiler doesn't support streaming QPen to QDebug");
+    return dbg;
+    Q_UNUSED(p);
+#endif
+}
+#endif
+
+/*!
+    \fn DataPtr &QPen::data_ptr()
+    \internal
+*/
+
+/*!
+    \typedef QPen::DataPtr
+
+    \internal
+*/
+
+QT_END_NAMESPACE
+
+#undef QT_COMPILING_QPEN
diff --git a/src/gui/painting/qpen.h b/src/gui/painting/qpen.h
new file mode 100644
index 0000000000..001cd448e0
--- /dev/null
+++ b/src/gui/painting/qpen.h
@@ -0,0 +1,145 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPEN_H
+#define QPEN_H
+
+#include <QtGui/qcolor.h>
+#include <QtGui/qbrush.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+class QVariant;
+class QPenPrivate;
+class QBrush;
+class QPen;
+
+#ifndef QT_NO_DATASTREAM
+Q_GUI_EXPORT QDataStream &operator<<(QDataStream &, const QPen &);
+Q_GUI_EXPORT QDataStream &operator>>(QDataStream &, QPen &);
+#endif
+
+class Q_GUI_EXPORT QPen
+{
+public:
+    QPen();
+    QPen(Qt::PenStyle);
+    QPen(const QColor &color);
+    QPen(const QBrush &brush, qreal width, Qt::PenStyle s = Qt::SolidLine,
+         Qt::PenCapStyle c = Qt::SquareCap, Qt::PenJoinStyle j = Qt::BevelJoin);
+    QPen(const QPen &pen);
+
+    ~QPen();
+
+    QPen &operator=(const QPen &pen);
+#ifdef Q_COMPILER_RVALUE_REFS
+    inline QPen &operator=(QPen &&other)
+    { qSwap(d, other.d); return *this; }
+#endif
+    inline void swap(QPen &other) { qSwap(d, other.d); }
+
+    Qt::PenStyle style() const;
+    void setStyle(Qt::PenStyle);
+
+    QVector<qreal> dashPattern() const;
+    void setDashPattern(const QVector<qreal> &pattern);
+
+    qreal dashOffset() const;
+    void setDashOffset(qreal doffset);
+
+    qreal miterLimit() const;
+    void setMiterLimit(qreal limit);
+
+    qreal widthF() const;
+    void setWidthF(qreal width);
+
+    int width() const;
+    void setWidth(int width);
+
+    QColor color() const;
+    void setColor(const QColor &color);
+
+    QBrush brush() const;
+    void setBrush(const QBrush &brush);
+
+    bool isSolid() const;
+
+    Qt::PenCapStyle capStyle() const;
+    void setCapStyle(Qt::PenCapStyle pcs);
+
+    Qt::PenJoinStyle joinStyle() const;
+    void setJoinStyle(Qt::PenJoinStyle pcs);
+
+    bool isCosmetic() const;
+    void setCosmetic(bool cosmetic);
+
+    bool operator==(const QPen &p) const;
+    inline bool operator!=(const QPen &p) const { return !(operator==(p)); }
+    operator QVariant() const;
+
+    bool isDetached();
+private:
+    friend Q_GUI_EXPORT QDataStream &operator>>(QDataStream &, QPen &);
+    friend Q_GUI_EXPORT QDataStream &operator<<(QDataStream &, const QPen &);
+
+    void detach();
+    class QPenPrivate *d;
+
+public:
+    typedef QPenPrivate * DataPtr;
+    inline DataPtr &data_ptr() { return d; }
+};
+Q_DECLARE_TYPEINFO(QPen, Q_MOVABLE_TYPE);
+Q_DECLARE_SHARED(QPen)
+
+#ifndef QT_NO_DEBUG_STREAM
+Q_GUI_EXPORT QDebug operator<<(QDebug, const QPen &);
+#endif
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QPEN_H
diff --git a/src/gui/painting/qpen_p.h b/src/gui/painting/qpen_p.h
new file mode 100644
index 0000000000..ef63b7650f
--- /dev/null
+++ b/src/gui/painting/qpen_p.h
@@ -0,0 +1,78 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPEN_P_H
+#define QPEN_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtCore/qglobal.h>
+
+QT_BEGIN_NAMESPACE
+
+class QPenPrivate {
+public:
+    QPenPrivate(const QBrush &brush, qreal width, Qt::PenStyle, Qt::PenCapStyle,
+                Qt::PenJoinStyle _joinStyle);
+    QAtomicInt ref;
+    qreal width;
+    QBrush brush;
+    Qt::PenStyle style;
+    Qt::PenCapStyle capStyle;
+    Qt::PenJoinStyle joinStyle;
+    mutable QVector<qreal> dashPattern;
+    qreal dashOffset;
+    qreal miterLimit;
+    uint cosmetic : 1;
+};
+
+QT_END_NAMESPACE
+
+#endif // QPEN_P_H
diff --git a/src/gui/painting/qpolygon.cpp b/src/gui/painting/qpolygon.cpp
new file mode 100644
index 0000000000..41b686adef
--- /dev/null
+++ b/src/gui/painting/qpolygon.cpp
@@ -0,0 +1,1003 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qpolygon.h"
+#include "qrect.h"
+#include "qdatastream.h"
+#include "qmatrix.h"
+#include "qdebug.h"
+#include "qpainterpath.h"
+#include "qvariant.h"
+#include "qpainterpath_p.h"
+#include "qbezier_p.h"
+
+#include <stdarg.h>
+
+QT_BEGIN_NAMESPACE
+
+//same as qt_painterpath_isect_line in qpainterpath.cpp
+static void qt_polygon_isect_line(const QPointF &p1, const QPointF &p2, const QPointF &pos,
+                                  int *winding)
+{
+    qreal x1 = p1.x();
+    qreal y1 = p1.y();
+    qreal x2 = p2.x();
+    qreal y2 = p2.y();
+    qreal y = pos.y();
+
+    int dir = 1;
+
+    if (qFuzzyCompare(y1, y2)) {
+        // ignore horizontal lines according to scan conversion rule
+        return;
+    } else if (y2 < y1) {
+        qreal x_tmp = x2; x2 = x1; x1 = x_tmp;
+        qreal y_tmp = y2; y2 = y1; y1 = y_tmp;
+        dir = -1;
+    }
+
+    if (y >= y1 && y < y2) {
+        qreal x = x1 + ((x2 - x1) / (y2 - y1)) * (y - y1);
+
+        // count up the winding number if we're
+        if (x<=pos.x()) {
+            (*winding) += dir;
+        }
+    }
+}
+
+/*!
+    \class QPolygon
+    \brief The QPolygon class provides a vector of points using
+    integer precision.
+
+    \reentrant
+
+    \ingroup painting
+    \ingroup shared
+
+    A QPolygon object is a QVector<QPoint>.  The easiest way to add
+    points to a QPolygon is to use QVector's streaming operator, as
+    illustrated below:
+
+    \snippet doc/src/snippets/polygon/polygon.cpp 0
+
+    In addition to the functions provided by QVector, QPolygon
+    provides some point-specific functions.
+
+    Each point in a polygon can be retrieved by passing its index to
+    the point() function. To populate the polygon, QPolygon provides
+    the setPoint() function to set the point at a given index, the
+    setPoints() function to set all the points in the polygon
+    (resizing it to the given number of points), and the putPoints()
+    function which copies a number of given points into the polygon
+    from a specified index (resizing the polygon if necessary).
+
+    QPolygon provides the boundingRect() and translate() functions for
+    geometry functions. Use the QMatrix::map() function for more
+    general transformations of QPolygons.
+
+    The QPolygon class is \l {Implicit Data Sharing}{implicitly
+    shared}.
+
+    \sa QVector, QPolygonF, QLine
+*/
+
+
+/*****************************************************************************
+  QPolygon member functions
+ *****************************************************************************/
+
+/*!
+    \fn QPolygon::QPolygon()
+
+    Constructs a polygon with no points.
+
+    \sa QVector::isEmpty()
+*/
+
+/*!
+    \fn QPolygon::QPolygon(int size)
+
+    Constructs a polygon of the given \a size. Creates an empty
+    polygon if \a size == 0.
+
+    \sa QVector::isEmpty()
+*/
+
+/*!
+    \fn QPolygon::QPolygon(const QPolygon &polygon)
+
+    Constructs a copy of the given \a polygon.
+
+    \sa setPoints()
+*/
+
+/*!
+    \fn QPolygon::QPolygon(const QVector<QPoint> &points)
+
+    Constructs a polygon containing the specified \a points.
+
+    \sa setPoints()
+*/
+
+/*!
+    \fn QPolygon::QPolygon(const QRect &rectangle, bool closed)
+
+    Constructs a polygon from the given \a rectangle.  If \a closed is
+    false, the polygon just contains the four points of the rectangle
+    ordered clockwise, otherwise the polygon's fifth point is set to
+    \a {rectangle}.topLeft().
+
+    Note that the bottom-right corner of the rectangle is located at
+    (rectangle.x() + rectangle.width(), rectangle.y() +
+    rectangle.height()).
+
+    \sa setPoints()
+*/
+
+QPolygon::QPolygon(const QRect &r, bool closed)
+{
+    reserve(closed ? 5 : 4);
+    *this << QPoint(r.x(), r.y())
+          << QPoint(r.x() + r.width(), r.y())
+          << QPoint(r.x() + r.width(), r.y() + r.height())
+          << QPoint(r.x(), r.y() + r.height());
+    if (closed)
+        *this << QPoint(r.left(), r.top());
+}
+
+/*!
+    \internal
+    Constructs a point array with \a nPoints points, taken from the
+    \a points array.
+
+    Equivalent to setPoints(nPoints, points).
+*/
+
+QPolygon::QPolygon(int nPoints, const int *points)
+{
+    setPoints(nPoints, points);
+}
+
+
+/*!
+    \fn QPolygon::~QPolygon()
+
+    Destroys the polygon.
+*/
+
+
+/*!
+    Translates all points in the polygon by (\a{dx}, \a{dy}).
+
+    \sa translated()
+*/
+
+void QPolygon::translate(int dx, int dy)
+{
+    if (dx == 0 && dy == 0)
+        return;
+
+    register QPoint *p = data();
+    register int i = size();
+    QPoint pt(dx, dy);
+    while (i--) {
+        *p += pt;
+        ++p;
+    }
+}
+
+/*!
+    \fn void QPolygon::translate(const QPoint &offset)
+    \overload
+
+    Translates all points in the polygon by the given \a offset.
+
+    \sa translated()
+*/
+
+/*!
+    Returns a copy of the polygon that is translated by (\a{dx}, \a{dy}).
+
+    \since 4.6
+    \sa translate()
+*/
+QPolygon QPolygon::translated(int dx, int dy) const
+{
+    QPolygon copy(*this);
+    copy.translate(dx, dy);
+    return copy;
+}
+
+/*!
+    \fn void QPolygon::translated(const QPoint &offset) const
+    \overload
+    \since 4.6
+
+    Returns a copy of the polygon that is translated by the given \a offset.
+
+    \sa translate()
+*/
+
+/*!
+    Extracts the coordinates of the point at the given \a index to
+    *\a{x} and *\a{y} (if they are valid pointers).
+
+    \sa setPoint()
+*/
+
+void QPolygon::point(int index, int *x, int *y) const
+{
+    QPoint p = at(index);
+    if (x)
+        *x = (int)p.x();
+    if (y)
+        *y = (int)p.y();
+}
+
+/*!
+    \fn QPoint QPolygon::point(int index) const
+    \overload
+
+    Returns the point at the given \a index.
+*/
+
+/*!
+    \fn void QPolygon::setPoint(int index, const QPoint &point)
+    \overload
+
+    Sets the point at the given \a index to the given \a point.
+*/
+
+/*!
+    \fn void QPolygon::setPoint(int index, int x, int y)
+
+    Sets the point at the given \a index to the point specified by
+    (\a{x}, \a{y}).
+
+    \sa point(), putPoints(), setPoints(),
+*/
+
+/*!
+    Resizes the polygon to \a nPoints and populates it with the given
+    \a points.
+
+    The example code creates a polygon with two points (10, 20) and
+    (30, 40):
+
+    \snippet doc/src/snippets/polygon/polygon.cpp 2
+
+    \sa setPoint() putPoints()
+*/
+
+void QPolygon::setPoints(int nPoints, const int *points)
+{
+    resize(nPoints);
+    int i = 0;
+    while (nPoints--) {
+        setPoint(i++, *points, *(points+1));
+        points += 2;
+    }
+}
+
+/*!
+    \overload
+
+    Resizes the polygon to \a nPoints and populates it with the points
+    specified by the variable argument list.  The points are given as a
+    sequence of integers, starting with \a firstx then \a firsty, and
+    so on.
+
+    The example code creates a polygon with two points (10, 20) and
+    (30, 40):
+
+    \snippet doc/src/snippets/polygon/polygon.cpp 3
+*/
+
+void QPolygon::setPoints(int nPoints, int firstx, int firsty, ...)
+{
+    va_list ap;
+    resize(nPoints);
+    setPoint(0, firstx, firsty);
+    int i = 0, x, y;
+    va_start(ap, firsty);
+    while (--nPoints) {
+        x = va_arg(ap, int);
+        y = va_arg(ap, int);
+        setPoint(++i, x, y);
+    }
+    va_end(ap);
+}
+
+/*!
+    \overload
+    \internal
+
+    Copies \a nPoints points from the \a points coord array into this
+    point array, and resizes the point array if \c{index+nPoints}
+    exceeds the size of the array.
+
+    \sa setPoint()
+*/
+
+void QPolygon::putPoints(int index, int nPoints, const int *points)
+{
+    if (index + nPoints > size())
+        resize(index + nPoints);
+    int i = index;
+    while (nPoints--) {
+        setPoint(i++, *points, *(points+1));
+        points += 2;
+    }
+}
+
+/*!
+    Copies \a nPoints points from the variable argument list into this
+    polygon from the given \a index.
+
+    The points are given as a sequence of integers, starting with \a
+    firstx then \a firsty, and so on. The polygon is resized if
+    \c{index+nPoints} exceeds its current size.
+
+    The example code creates a polygon with three points (4,5), (6,7)
+    and (8,9), by expanding the polygon from 1 to 3 points:
+
+    \snippet doc/src/snippets/polygon/polygon.cpp 4
+
+    The following code has the same result, but here the putPoints()
+    function overwrites rather than extends:
+
+    \snippet doc/src/snippets/polygon/polygon.cpp 5
+
+    \sa setPoints()
+*/
+
+void QPolygon::putPoints(int index, int nPoints, int firstx, int firsty, ...)
+{
+    va_list ap;
+    if (index + nPoints > size())
+        resize(index + nPoints);
+    if (nPoints <= 0)
+        return;
+    setPoint(index, firstx, firsty);
+    int i = index, x, y;
+    va_start(ap, firsty);
+    while (--nPoints) {
+        x = va_arg(ap, int);
+        y = va_arg(ap, int);
+        setPoint(++i, x, y);
+    }
+    va_end(ap);
+}
+
+
+/*!
+    \fn void QPolygon::putPoints(int index, int nPoints, const QPolygon &fromPolygon, int fromIndex)
+    \overload
+
+    Copies \a nPoints points from the given \a fromIndex ( 0 by
+    default) in \a fromPolygon into this polygon, starting at the
+    specified \a index. For example:
+
+    \snippet doc/src/snippets/polygon/polygon.cpp 6
+*/
+
+void QPolygon::putPoints(int index, int nPoints, const QPolygon & from, int fromIndex)
+{
+    if (index + nPoints > size())
+        resize(index + nPoints);
+    if (nPoints <= 0)
+        return;
+    int n = 0;
+    while(n < nPoints) {
+        setPoint(index + n, from[fromIndex+n]);
+        ++n;
+    }
+}
+
+
+/*!
+    Returns the bounding rectangle of the polygon, or QRect(0, 0, 0,
+    0) if the polygon is empty.
+
+    \sa QVector::isEmpty()
+*/
+
+QRect QPolygon::boundingRect() const
+{
+    if (isEmpty())
+        return QRect(0, 0, 0, 0);
+    register const QPoint *pd = constData();
+    int minx, maxx, miny, maxy;
+    minx = maxx = pd->x();
+    miny = maxy = pd->y();
+    ++pd;
+    for (int i = 1; i < size(); ++i) {
+        if (pd->x() < minx)
+            minx = pd->x();
+        else if (pd->x() > maxx)
+            maxx = pd->x();
+        if (pd->y() < miny)
+            miny = pd->y();
+        else if (pd->y() > maxy)
+            maxy = pd->y();
+        ++pd;
+    }
+    return QRect(QPoint(minx,miny), QPoint(maxx,maxy));
+}
+
+#ifndef QT_NO_DEBUG_STREAM
+QDebug operator<<(QDebug dbg, const QPolygon &a)
+{
+#ifndef Q_BROKEN_DEBUG_STREAM
+    dbg.nospace() << "QPolygon(";
+    for (int i = 0; i < a.count(); ++i)
+        dbg.nospace() << a.at(i);
+    dbg.nospace() << ')';
+    return dbg.space();
+#else
+    qWarning("This compiler doesn't support streaming QPolygon to QDebug");
+    return dbg;
+    Q_UNUSED(a);
+#endif
+}
+#endif
+
+
+/*!
+    \class QPolygonF
+    \brief The QPolygonF class provides a vector of points using
+    floating point precision.
+
+    \reentrant
+    \ingroup painting
+    \ingroup shared
+
+    A QPolygonF is a QVector<QPointF>. The easiest way to add points
+    to a QPolygonF is to use its streaming operator, as illustrated
+    below:
+
+    \snippet doc/src/snippets/polygon/polygon.cpp 1
+
+    In addition to the functions provided by QVector, QPolygonF
+    provides the boundingRect() and translate() functions for geometry
+    operations. Use the QMatrix::map() function for more general
+    transformations of QPolygonFs.
+
+    QPolygonF also provides the isClosed() function to determine
+    whether a polygon's start and end points are the same, and the
+    toPolygon() function returning an integer precision copy of this
+    polygon.
+
+    The QPolygonF class is \l {Implicit Data Sharing}{implicitly
+    shared}.
+
+    \sa QVector, QPolygon, QLineF
+*/
+
+
+/*****************************************************************************
+  QPolygonF member functions
+ *****************************************************************************/
+
+/*!
+    \fn QPolygonF::QPolygonF()
+
+    Constructs a polygon with no points.
+
+    \sa QVector::isEmpty()
+*/
+
+/*!
+    \fn QPolygonF::QPolygonF(int size)
+
+    Constructs a polygon of the given \a size. Creates an empty
+    polygon if \a size == 0.
+
+    \sa QVector::isEmpty()
+*/
+
+/*!
+    \fn QPolygonF::QPolygonF(const QPolygonF &polygon)
+
+    Constructs a copy of the given \a polygon.
+*/
+
+/*!
+    \fn QPolygonF::QPolygonF(const QVector<QPointF> &points)
+
+    Constructs a polygon containing the specified \a points.
+*/
+
+/*!
+    \fn QPolygonF::QPolygonF(const QRectF &rectangle)
+
+    Constructs a closed polygon from the specified \a rectangle.
+
+    The polygon contains the four vertices of the rectangle in
+    clockwise order starting and ending with the top-left vertex.
+
+    \sa isClosed()
+*/
+
+QPolygonF::QPolygonF(const QRectF &r)
+{
+    reserve(5);
+    append(QPointF(r.x(), r.y()));
+    append(QPointF(r.x() + r.width(), r.y()));
+    append(QPointF(r.x() + r.width(), r.y() + r.height()));
+    append(QPointF(r.x(), r.y() + r.height()));
+    append(QPointF(r.x(), r.y()));
+}
+
+/*!
+    \fn QPolygonF::QPolygonF(const QPolygon &polygon)
+
+    Constructs a float based polygon from the specified integer based
+    \a polygon.
+
+    \sa toPolygon()
+*/
+
+QPolygonF::QPolygonF(const QPolygon &a)
+{
+    reserve(a.size());
+    for (int i=0; i<a.size(); ++i)
+        append(a.at(i));
+}
+
+/*!
+    \fn QPolygonF::~QPolygonF()
+
+    Destroys the polygon.
+*/
+
+
+/*!
+    Translate all points in the polygon by the given \a offset.
+
+    \sa translated()
+*/
+
+void QPolygonF::translate(const QPointF &offset)
+{
+    if (offset.isNull())
+        return;
+
+    register QPointF *p = data();
+    register int i = size();
+    while (i--) {
+        *p += offset;
+        ++p;
+    }
+}
+
+/*!
+    \fn void QPolygonF::translate(qreal dx, qreal dy)
+    \overload
+
+    Translates all points in the polygon by (\a{dx}, \a{dy}).
+
+    \sa translated()
+*/
+
+/*!
+    Returns a copy of the polygon that is translated by the given \a offset.
+
+    \since 4.6
+    \sa translate()
+*/
+QPolygonF QPolygonF::translated(const QPointF &offset) const
+{
+    QPolygonF copy(*this);
+    copy.translate(offset);
+    return copy;
+}
+
+/*!
+    \fn void QPolygonF::translated(qreal dx, qreal dy) const
+    \overload
+    \since 4.6
+
+    Returns a copy of the polygon that is translated by (\a{dx}, \a{dy}).
+
+    \sa translate()
+*/
+
+/*!
+    \fn bool QPolygonF::isClosed() const
+
+    Returns true if the polygon is closed; otherwise returns false.
+
+    A polygon is said to be closed if its start point and end point are equal.
+
+    \sa QVector::first(), QVector::last()
+*/
+
+/*!
+    Returns the bounding rectangle of the polygon, or QRectF(0,0,0,0)
+    if the polygon is empty.
+
+    \sa QVector::isEmpty()
+*/
+
+QRectF QPolygonF::boundingRect() const
+{
+    if (isEmpty())
+        return QRectF(0, 0, 0, 0);
+    register const QPointF *pd = constData();
+    qreal minx, maxx, miny, maxy;
+    minx = maxx = pd->x();
+    miny = maxy = pd->y();
+    ++pd;
+    for (int i = 1; i < size(); ++i) {
+        if (pd->x() < minx)
+            minx = pd->x();
+        else if (pd->x() > maxx)
+            maxx = pd->x();
+        if (pd->y() < miny)
+            miny = pd->y();
+        else if (pd->y() > maxy)
+            maxy = pd->y();
+        ++pd;
+    }
+    return QRectF(minx,miny, maxx - minx, maxy - miny);
+}
+
+/*!
+    Creates and returns a QPolygon by converting each QPointF to a
+    QPoint.
+
+    \sa QPointF::toPoint()
+*/
+
+QPolygon QPolygonF::toPolygon() const
+{
+    QPolygon a;
+    a.reserve(size());
+    for (int i=0; i<size(); ++i)
+        a.append(at(i).toPoint());
+    return a;
+}
+
+/*!
+    \fn void QPolygon::swap(QPolygon &other)
+    \since 4.8
+
+    Swaps polygon \a other with this polygon. This operation is very
+    fast and never fails.
+*/
+
+/*!
+    \fn void QPolygonF::swap(QPolygonF &other)
+    \since 4.8
+
+    Swaps polygon \a other with this polygon. This operation is very
+    fast and never fails.
+*/
+
+/*!
+   Returns the polygon as a QVariant
+*/
+QPolygon::operator QVariant() const
+{
+    return QVariant(QVariant::Polygon, this);
+}
+
+/*****************************************************************************
+  QPolygon stream functions
+ *****************************************************************************/
+#ifndef QT_NO_DATASTREAM
+/*!
+    \fn QDataStream &operator<<(QDataStream &stream, const QPolygon &polygon)
+    \since 4.4
+    \relates QPolygon
+
+    Writes the given \a polygon to the given \a stream, and returns a
+    reference to the stream.
+
+    \sa {Serializing Qt Data Types}
+*/
+QDataStream &operator<<(QDataStream &s, const QPolygon &a)
+{
+    const QVector<QPoint> &v = a;
+    return s << v;
+}
+
+/*!
+    \fn QDataStream &operator>>(QDataStream &stream, QPolygon &polygon)
+    \since 4.4
+    \relates QPolygon
+
+    Reads a polygon from the given \a stream into the given \a
+    polygon, and returns a reference to the stream.
+
+    \sa {Serializing Qt Data Types}
+*/
+QDataStream &operator>>(QDataStream &s, QPolygon &a)
+{
+    QVector<QPoint> &v = a;
+    return s >> v;
+}
+#endif // QT_NO_DATASTREAM
+
+/*****************************************************************************
+  QPolygonF stream functions
+ *****************************************************************************/
+#ifndef QT_NO_DATASTREAM
+/*!
+    \fn QDataStream &operator<<(QDataStream &stream, const QPolygonF &polygon)
+    \relates QPolygonF
+
+    Writes the given \a polygon to the given \a stream, and returns a
+    reference to the stream.
+
+    \sa {Serializing Qt Data Types}
+*/
+
+QDataStream &operator<<(QDataStream &s, const QPolygonF &a)
+{
+    quint32 len = a.size();
+    uint i;
+
+    s << len;
+    for (i = 0; i < len; ++i)
+        s << a.at(i);
+    return s;
+}
+
+/*!
+    \fn QDataStream &operator>>(QDataStream &stream, QPolygonF &polygon)
+    \relates QPolygonF
+
+    Reads a polygon from the given \a stream into the given \a
+    polygon, and returns a reference to the stream.
+
+    \sa {Serializing Qt Data Types}
+*/
+
+QDataStream &operator>>(QDataStream &s, QPolygonF &a)
+{
+    quint32 len;
+    uint i;
+
+    s >> len;
+    a.reserve(a.size() + (int)len);
+    QPointF p;
+    for (i = 0; i < len; ++i) {
+        s >> p;
+        a.insert(i, p);
+    }
+    return s;
+}
+#endif //QT_NO_DATASTREAM
+
+#ifndef QT_NO_DEBUG_STREAM
+QDebug operator<<(QDebug dbg, const QPolygonF &a)
+{
+#ifndef Q_BROKEN_DEBUG_STREAM
+    dbg.nospace() << "QPolygonF(";
+    for (int i = 0; i < a.count(); ++i)
+        dbg.nospace() << a.at(i);
+    dbg.nospace() << ')';
+    return dbg.space();
+#else
+    qWarning("This compiler doesn't support streaming QPolygonF to QDebug");
+    return dbg;
+    Q_UNUSED(a);
+#endif
+}
+#endif
+
+
+/*!
+    \since 4.3
+
+    \fn bool QPolygonF::containsPoint(const QPointF &point, Qt::FillRule fillRule) const
+
+    Returns true if the given \a point is inside the polygon according to
+    the specified \a fillRule; otherwise returns false.
+*/
+bool QPolygonF::containsPoint(const QPointF &pt, Qt::FillRule fillRule) const
+{
+    if (isEmpty())
+        return false;
+
+    int winding_number = 0;
+
+    QPointF last_pt = at(0);
+    QPointF last_start = at(0);
+    for (int i = 1; i < size(); ++i) {
+        const QPointF &e = at(i);
+        qt_polygon_isect_line(last_pt, e, pt, &winding_number);
+        last_pt = e;
+    }
+
+    // implicitly close last subpath
+    if (last_pt != last_start)
+        qt_polygon_isect_line(last_pt, last_start, pt, &winding_number);
+
+    return (fillRule == Qt::WindingFill
+            ? (winding_number != 0)
+            : ((winding_number % 2) != 0));
+}
+
+/*!
+    \since 4.3
+
+    \fn bool QPolygon::containsPoint(const QPoint &point, Qt::FillRule fillRule) const
+    Returns true if the given \a point is inside the polygon according to
+    the specified \a fillRule; otherwise returns false.
+*/
+bool QPolygon::containsPoint(const QPoint &pt, Qt::FillRule fillRule) const
+{
+    if (isEmpty())
+        return false;
+
+    int winding_number = 0;
+
+    QPoint last_pt = at(0);
+    QPoint last_start = at(0);
+    for (int i = 1; i < size(); ++i) {
+        const QPoint &e = at(i);
+        qt_polygon_isect_line(last_pt, e, pt, &winding_number);
+        last_pt = e;
+    }
+
+    // implicitly close last subpath
+    if (last_pt != last_start)
+        qt_polygon_isect_line(last_pt, last_start, pt, &winding_number);
+
+    return (fillRule == Qt::WindingFill
+            ? (winding_number != 0)
+            : ((winding_number % 2) != 0));
+}
+
+/*!
+    \since 4.3
+
+    Returns a polygon which is the union of this polygon and \a r.
+
+    Set operations on polygons, will treat the polygons as areas, and
+    implicitly close the polygon.
+
+    \sa intersected(), subtracted()
+*/
+
+QPolygon QPolygon::united(const QPolygon &r) const
+{
+    QPainterPath subject; subject.addPolygon(*this);
+    QPainterPath clip; clip.addPolygon(r);
+
+    return subject.united(clip).toFillPolygon().toPolygon();
+}
+
+/*!
+    \since 4.3
+
+    Returns a polygon which is the intersection of this polygon and \a r.
+
+    Set operations on polygons will treat the polygons as
+    areas. Non-closed polygons will be treated as implicitly closed.
+*/
+
+QPolygon QPolygon::intersected(const QPolygon &r) const
+{
+    QPainterPath subject; subject.addPolygon(*this);
+    QPainterPath clip; clip.addPolygon(r);
+
+    return subject.intersected(clip).toFillPolygon().toPolygon();
+}
+
+/*!
+    \since 4.3
+
+    Returns a polygon which is \a r subtracted from this polygon.
+
+    Set operations on polygons will treat the polygons as
+    areas. Non-closed polygons will be treated as implicitly closed.
+
+*/
+
+QPolygon QPolygon::subtracted(const QPolygon &r) const
+{
+    QPainterPath subject; subject.addPolygon(*this);
+    QPainterPath clip; clip.addPolygon(r);
+
+    return subject.subtracted(clip).toFillPolygon().toPolygon();
+}
+
+/*!
+    \since 4.3
+
+    Returns a polygon which is the union of this polygon and \a r.
+
+    Set operations on polygons will treat the polygons as
+    areas. Non-closed polygons will be treated as implicitly closed.
+
+    \sa intersected(), subtracted()
+*/
+
+QPolygonF QPolygonF::united(const QPolygonF &r) const
+{
+    QPainterPath subject; subject.addPolygon(*this);
+    QPainterPath clip; clip.addPolygon(r);
+
+    return subject.united(clip).toFillPolygon();
+}
+
+/*!
+    \since 4.3
+
+    Returns a polygon which is the intersection of this polygon and \a r.
+
+    Set operations on polygons will treat the polygons as
+    areas. Non-closed polygons will be treated as implicitly closed.
+
+*/
+
+QPolygonF QPolygonF::intersected(const QPolygonF &r) const
+{
+    QPainterPath subject; subject.addPolygon(*this);
+    QPainterPath clip; clip.addPolygon(r);
+
+    return subject.intersected(clip).toFillPolygon();
+}
+
+/*!
+    \since 4.3
+
+    Returns a polygon which is \a r subtracted from this polygon.
+
+    Set operations on polygons will treat the polygons as
+    areas. Non-closed polygons will be treated as implicitly closed.
+
+*/
+
+QPolygonF QPolygonF::subtracted(const QPolygonF &r) const
+{
+    QPainterPath subject; subject.addPolygon(*this);
+    QPainterPath clip; clip.addPolygon(r);
+    return subject.subtracted(clip).toFillPolygon();
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qpolygon.h b/src/gui/painting/qpolygon.h
new file mode 100644
index 0000000000..0f4a8b3450
--- /dev/null
+++ b/src/gui/painting/qpolygon.h
@@ -0,0 +1,189 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPOLYGON_H
+#define QPOLYGON_H
+
+#include <QtCore/qvector.h>
+#include <QtCore/qpoint.h>
+#include <QtCore/qrect.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+class QMatrix;
+class QTransform;
+class QRect;
+class QVariant;
+
+class Q_GUI_EXPORT QPolygon : public QVector<QPoint>
+{
+public:
+    inline QPolygon() {}
+    inline ~QPolygon() {}
+    inline QPolygon(int size);
+    inline QPolygon(const QPolygon &a) : QVector<QPoint>(a) {}
+    inline QPolygon(const QVector<QPoint> &v) : QVector<QPoint>(v) {}
+    QPolygon(const QRect &r, bool closed=false);
+    QPolygon(int nPoints, const int *points);
+    inline void swap(QPolygon &other) { QVector<QPoint>::swap(other); } // prevent QVector<QPoint><->QPolygon swaps
+
+    operator QVariant() const;
+
+    void translate(int dx, int dy);
+    void translate(const QPoint &offset);
+
+    QPolygon translated(int dx, int dy) const;
+    inline QPolygon translated(const QPoint &offset) const;
+
+    QRect boundingRect() const;
+
+    void point(int i, int *x, int *y) const;
+    QPoint point(int i) const;
+    void setPoint(int index, int x, int y);
+    void setPoint(int index, const QPoint &p);
+    void setPoints(int nPoints, const int *points);
+    void setPoints(int nPoints, int firstx, int firsty, ...);
+    void putPoints(int index, int nPoints, const int *points);
+    void putPoints(int index, int nPoints, int firstx, int firsty, ...);
+    void putPoints(int index, int nPoints, const QPolygon & from, int fromIndex=0);
+
+    bool containsPoint(const QPoint &pt, Qt::FillRule fillRule) const;
+
+    QPolygon united(const QPolygon &r) const;
+    QPolygon intersected(const QPolygon &r) const;
+    QPolygon subtracted(const QPolygon &r) const;
+};
+
+inline QPolygon::QPolygon(int asize) : QVector<QPoint>(asize) {}
+
+#ifndef QT_NO_DEBUG_STREAM
+Q_GUI_EXPORT QDebug operator<<(QDebug, const QPolygon &);
+#endif
+
+/*****************************************************************************
+  QPolygon stream functions
+ *****************************************************************************/
+#ifndef QT_NO_DATASTREAM
+Q_GUI_EXPORT QDataStream &operator<<(QDataStream &stream, const QPolygon &polygon);
+Q_GUI_EXPORT QDataStream &operator>>(QDataStream &stream, QPolygon &polygon);
+#endif
+
+/*****************************************************************************
+  Misc. QPolygon functions
+ *****************************************************************************/
+
+inline void QPolygon::setPoint(int index, const QPoint &pt)
+{ (*this)[index] = pt; }
+
+inline void QPolygon::setPoint(int index, int x, int y)
+{ (*this)[index] = QPoint(x, y); }
+
+inline QPoint QPolygon::point(int index) const
+{ return at(index); }
+
+inline void QPolygon::translate(const QPoint &offset)
+{ translate(offset.x(), offset.y()); }
+
+inline QPolygon QPolygon::translated(const QPoint &offset) const
+{ return translated(offset.x(), offset.y()); }
+
+class QRectF;
+
+class Q_GUI_EXPORT QPolygonF : public QVector<QPointF>
+{
+public:
+    inline QPolygonF() {}
+    inline ~QPolygonF() {}
+    inline QPolygonF(int size);
+    inline QPolygonF(const QPolygonF &a) : QVector<QPointF>(a) {}
+    inline QPolygonF(const QVector<QPointF> &v) : QVector<QPointF>(v) {}
+    QPolygonF(const QRectF &r);
+    QPolygonF(const QPolygon &a);
+    inline void swap(QPolygonF &other) { QVector<QPointF>::swap(other); } // prevent QVector<QPointF><->QPolygonF swaps
+
+    inline void translate(qreal dx, qreal dy);
+    void translate(const QPointF &offset);
+
+    inline QPolygonF translated(qreal dx, qreal dy) const;
+    QPolygonF translated(const QPointF &offset) const;
+
+    QPolygon toPolygon() const;
+
+    bool isClosed() const { return !isEmpty() && first() == last(); }
+
+    QRectF boundingRect() const;
+
+    bool containsPoint(const QPointF &pt, Qt::FillRule fillRule) const;
+
+    QPolygonF united(const QPolygonF &r) const;
+    QPolygonF intersected(const QPolygonF &r) const;
+    QPolygonF subtracted(const QPolygonF &r) const;
+};
+
+inline QPolygonF::QPolygonF(int asize) : QVector<QPointF>(asize) {}
+
+#ifndef QT_NO_DEBUG_STREAM
+Q_GUI_EXPORT QDebug operator<<(QDebug, const QPolygonF &);
+#endif
+
+/*****************************************************************************
+  QPolygonF stream functions
+ *****************************************************************************/
+#ifndef QT_NO_DATASTREAM
+Q_GUI_EXPORT QDataStream &operator<<(QDataStream &stream, const QPolygonF &array);
+Q_GUI_EXPORT QDataStream &operator>>(QDataStream &stream, QPolygonF &array);
+#endif
+
+inline void QPolygonF::translate(qreal dx, qreal dy)
+{ translate(QPointF(dx, dy)); }
+
+inline QPolygonF QPolygonF::translated(qreal dx, qreal dy) const
+{ return translated(QPointF(dx, dy)); }
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QPOLYGON_H
diff --git a/src/gui/painting/qpolygonclipper_p.h b/src/gui/painting/qpolygonclipper_p.h
new file mode 100644
index 0000000000..287190ab8b
--- /dev/null
+++ b/src/gui/painting/qpolygonclipper_p.h
@@ -0,0 +1,317 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPOLYGONCLIPPER_P_H
+#define QPOLYGONCLIPPER_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of other Qt classes.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "private/qdatabuffer_p.h"
+
+QT_BEGIN_NAMESPACE
+
+/* based on sutherland-hodgman line-by-line clipping, as described in
+   Computer Graphics and Principles */
+template <typename InType, typename OutType, typename CastType> class QPolygonClipper
+{
+public:
+    QPolygonClipper() :
+        buffer1(0), buffer2(0)
+    {
+        x1 = y1 = x2 = y2 = 0;
+    }
+
+    ~QPolygonClipper()
+    {
+    }
+
+    void setBoundingRect(const QRect bounds)
+    {
+        x1 = bounds.x();
+        x2 = bounds.x() + bounds.width();
+        y1 = bounds.y();
+        y2 = bounds.y() + bounds.height();
+    }
+
+    QRect boundingRect()
+    {
+        return QRect(QPoint(x1, y1), QPoint(x2, y2));
+    }
+
+    inline OutType intersectLeft(const OutType &p1, const OutType &p2)
+    {
+        OutType t;
+        qreal dy = (p1.y - p2.y) / qreal(p1.x - p2.x);
+        t.x = x1;
+        t.y = static_cast<CastType>(p2.y + (x1 - p2.x) * dy);
+        return t;
+    }
+
+
+    inline OutType intersectRight(const OutType &p1, const OutType &p2)
+    {
+        OutType t;
+        qreal dy = (p1.y - p2.y) / qreal(p1.x - p2.x);
+        t.x = x2;
+        t.y = static_cast<CastType>(p2.y + (x2 - p2.x) * dy);
+        return t;
+    }
+
+
+    inline OutType intersectTop(const OutType &p1, const OutType &p2)
+    {
+        OutType t;
+        qreal dx = (p1.x - p2.x) / qreal(p1.y - p2.y);
+        t.x = static_cast<CastType>(p2.x + (y1 - p2.y) * dx);
+        t.y = y1;
+        return t;
+    }
+
+
+    inline OutType intersectBottom(const OutType &p1, const OutType &p2)
+    {
+        OutType t;
+        qreal dx = (p1.x - p2.x) / qreal(p1.y - p2.y);
+        t.x = static_cast<CastType>(p2.x + (y2 - p2.y) * dx);
+        t.y = y2;
+        return t;
+    }
+
+
+    void clipPolygon(const InType *inPoints, int inCount, OutType **outPoints, int *outCount,
+                     bool closePolygon = true)
+    {
+        Q_ASSERT(outPoints);
+        Q_ASSERT(outCount);
+
+        if (inCount < 2) {
+            *outCount = 0;
+            return;
+        }
+
+        buffer1.reset();
+        buffer2.reset();
+
+        QDataBuffer<OutType> *source = &buffer1;
+        QDataBuffer<OutType> *clipped = &buffer2;
+
+        // Gather some info since we are iterating through the points anyway..
+        bool doLeft = false, doRight = false, doTop = false, doBottom = false;
+        OutType ot;
+        for (int i=0; i<inCount; ++i) {
+            ot = inPoints[i];
+            clipped->add(ot);
+
+            if (ot.x < x1)
+                doLeft = true;
+            else if (ot.x > x2)
+                doRight = true;
+            if (ot.y < y1)
+                doTop = true;
+            else if (ot.y > y2)
+                doBottom = true;
+        }
+
+        if (doLeft && clipped->size() > 1) {
+            QDataBuffer<OutType> *tmp = source;
+            source = clipped;
+            clipped = tmp;
+            clipped->reset();
+            int lastPos, start;
+            if (closePolygon) {
+                lastPos = source->size() - 1;
+                start = 0;
+            } else {
+                lastPos = 0;
+                start = 1;
+                if (source->at(0).x >= x1)
+                    clipped->add(source->at(0));
+            }
+            for (int i=start; i<inCount; ++i) {
+                const OutType &cpt = source->at(i);
+                const OutType &ppt = source->at(lastPos);
+
+                if (cpt.x >= x1) {
+                    if (ppt.x >= x1) {
+                        clipped->add(cpt);
+                    } else {
+                        clipped->add(intersectLeft(cpt, ppt));
+                        clipped->add(cpt);
+                    }
+                } else if (ppt.x >= x1) {
+                    clipped->add(intersectLeft(cpt, ppt));
+                }
+                lastPos = i;
+            }
+        }
+
+        if (doRight && clipped->size() > 1) {
+            QDataBuffer<OutType> *tmp = source;
+            source = clipped;
+            clipped = tmp;
+            clipped->reset();
+            int lastPos, start;
+            if (closePolygon) {
+                lastPos = source->size() - 1;
+                start = 0;
+            } else {
+                lastPos = 0;
+                start = 1;
+                if (source->at(0).x <= x2)
+                    clipped->add(source->at(0));
+            }
+            for (int i=start; i<source->size(); ++i) {
+                const OutType &cpt = source->at(i);
+                const OutType &ppt = source->at(lastPos);
+
+                if (cpt.x <= x2) {
+                    if (ppt.x <= x2) {
+                        clipped->add(cpt);
+                    } else {
+                        clipped->add(intersectRight(cpt, ppt));
+                        clipped->add(cpt);
+                    }
+                } else if (ppt.x <= x2) {
+                    clipped->add(intersectRight(cpt, ppt));
+                }
+
+                lastPos = i;
+            }
+
+        }
+
+        if (doTop && clipped->size() > 1) {
+            QDataBuffer<OutType> *tmp = source;
+            source = clipped;
+            clipped = tmp;
+            clipped->reset();
+            int lastPos, start;
+            if (closePolygon) {
+                lastPos = source->size() - 1;
+                start = 0;
+            } else {
+                lastPos = 0;
+                start = 1;
+                if (source->at(0).y >= y1)
+                    clipped->add(source->at(0));
+            }
+            for (int i=start; i<source->size(); ++i) {
+                const OutType &cpt = source->at(i);
+                const OutType &ppt = source->at(lastPos);
+
+                if (cpt.y >= y1) {
+                    if (ppt.y >= y1) {
+                        clipped->add(cpt);
+                    } else {
+                        clipped->add(intersectTop(cpt, ppt));
+                        clipped->add(cpt);
+                    }
+                } else if (ppt.y >= y1) {
+                    clipped->add(intersectTop(cpt, ppt));
+                }
+
+                lastPos = i;
+            }
+        }
+
+        if (doBottom && clipped->size() > 1) {
+            QDataBuffer<OutType> *tmp = source;
+            source = clipped;
+            clipped = tmp;
+            clipped->reset();
+            int lastPos, start;
+            if (closePolygon) {
+                lastPos = source->size() - 1;
+                start = 0;
+            } else {
+                lastPos = 0;
+                start = 1;
+                if (source->at(0).y <= y2)
+                    clipped->add(source->at(0));
+            }
+            for (int i=start; i<source->size(); ++i) {
+                const OutType &cpt = source->at(i);
+                const OutType &ppt = source->at(lastPos);
+
+                if (cpt.y <= y2) {
+                    if (ppt.y <= y2) {
+                        clipped->add(cpt);
+                    } else {
+                        clipped->add(intersectBottom(cpt, ppt));
+                        clipped->add(cpt);
+                    }
+                } else if (ppt.y <= y2) {
+                    clipped->add(intersectBottom(cpt, ppt));
+                }
+                lastPos = i;
+            }
+        }
+
+        if (closePolygon && clipped->size() > 0) {
+            // close clipped polygon
+            if (clipped->at(0).x != clipped->at(clipped->size()-1).x ||
+                clipped->at(0).y != clipped->at(clipped->size()-1).y) {
+                OutType ot = clipped->at(0);
+                clipped->add(ot);
+            }
+        }
+        *outCount = clipped->size();
+        *outPoints = clipped->data();
+    }
+
+private:
+    int x1, x2, y1, y2;
+    QDataBuffer<OutType> buffer1;
+    QDataBuffer<OutType> buffer2;
+};
+
+QT_END_NAMESPACE
+
+#endif // QPOLYGONCLIPPER_P_H
diff --git a/src/gui/painting/qprintengine.h b/src/gui/painting/qprintengine.h
new file mode 100644
index 0000000000..b04ea068a3
--- /dev/null
+++ b/src/gui/painting/qprintengine.h
@@ -0,0 +1,119 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPRINTENGINE_H
+#define QPRINTENGINE_H
+
+#include <QtCore/qvariant.h>
+#include <QtGui/qprinter.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+#ifndef QT_NO_PRINTER
+
+class Q_GUI_EXPORT QPrintEngine
+{
+public:
+    virtual ~QPrintEngine() {}
+    enum PrintEnginePropertyKey {
+        PPK_CollateCopies,
+        PPK_ColorMode,
+        PPK_Creator,
+        PPK_DocumentName,
+        PPK_FullPage,
+        PPK_NumberOfCopies,
+        PPK_Orientation,
+        PPK_OutputFileName,
+        PPK_PageOrder,
+        PPK_PageRect,
+        PPK_PageSize,
+        PPK_PaperRect,
+        PPK_PaperSource,
+        PPK_PrinterName,
+        PPK_PrinterProgram,
+        PPK_Resolution,
+        PPK_SelectionOption,
+        PPK_SupportedResolutions,
+
+        PPK_WindowsPageSize,
+        PPK_FontEmbedding,
+        PPK_SuppressSystemPrintStatus,
+
+        PPK_Duplex,
+
+        PPK_PaperSources,
+        PPK_CustomPaperSize,
+        PPK_PageMargins,
+        PPK_CopyCount,
+        PPK_SupportsMultipleCopies,
+        PPK_PaperSize = PPK_PageSize,
+
+        PPK_CustomBase = 0xff00
+    };
+
+    virtual void setProperty(PrintEnginePropertyKey key, const QVariant &value) = 0;
+    virtual QVariant property(PrintEnginePropertyKey key) const = 0;
+
+    virtual bool newPage() = 0;
+    virtual bool abort() = 0;
+
+    virtual int metric(QPaintDevice::PaintDeviceMetric) const = 0;
+
+    virtual QPrinter::PrinterState printerState() const = 0;
+
+#ifdef Q_WS_WIN
+    virtual HDC getPrinterDC() const { return 0; }
+    virtual void releasePrinterDC(HDC) const { }
+#endif
+
+};
+
+#endif // QT_NO_PRINTER
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QPRINTENGINE_H
diff --git a/src/gui/painting/qprintengine_mac.mm b/src/gui/painting/qprintengine_mac.mm
new file mode 100644
index 0000000000..1dce30301f
--- /dev/null
+++ b/src/gui/painting/qprintengine_mac.mm
@@ -0,0 +1,911 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <private/qprintengine_mac_p.h>
+#include <qdebug.h>
+#include <qthread.h>
+#include <QtCore/qcoreapplication.h>
+
+#ifndef QT_NO_PRINTER
+
+QT_BEGIN_NAMESPACE
+
+extern QSizeF qt_paperSizeToQSizeF(QPrinter::PaperSize size);
+
+QMacPrintEngine::QMacPrintEngine(QPrinter::PrinterMode mode) : QPaintEngine(*(new QMacPrintEnginePrivate))
+{
+    Q_D(QMacPrintEngine);
+    d->mode = mode;
+    d->initialize();
+}
+
+bool QMacPrintEngine::begin(QPaintDevice *dev)
+{
+    Q_D(QMacPrintEngine);
+
+    Q_ASSERT(dev && dev->devType() == QInternal::Printer);
+    if (!static_cast<QPrinter *>(dev)->isValid())
+	return false;
+
+    if (d->state == QPrinter::Idle && !d->isPrintSessionInitialized()) // Need to reinitialize
+        d->initialize();
+
+    d->paintEngine->state = state;
+    d->paintEngine->begin(dev);
+    Q_ASSERT_X(d->state == QPrinter::Idle, "QMacPrintEngine", "printer already active");
+
+    if (PMSessionValidatePrintSettings(d->session, d->settings, kPMDontWantBoolean) != noErr
+        || PMSessionValidatePageFormat(d->session, d->format, kPMDontWantBoolean) != noErr) {
+        d->state = QPrinter::Error;
+        return false;
+    }
+
+    if (!d->outputFilename.isEmpty()) {
+        QCFType<CFURLRef> outFile = CFURLCreateWithFileSystemPath(kCFAllocatorSystemDefault,
+                                                                  QCFString(d->outputFilename),
+                                                                  kCFURLPOSIXPathStyle,
+                                                                  false);
+        if (PMSessionSetDestination(d->session, d->settings, kPMDestinationFile,
+                                    kPMDocumentFormatPDF, outFile) != noErr) {
+            qWarning("QMacPrintEngine::begin: Problem setting file [%s]", d->outputFilename.toUtf8().constData());
+            return false;
+        }
+    }
+    OSStatus status = noErr;
+#ifndef QT_MAC_USE_COCOA
+    status = d->shouldSuppressStatus() ? PMSessionBeginCGDocumentNoDialog(d->session, d->settings, d->format)
+                                       : PMSessionBeginCGDocument(d->session, d->settings, d->format);
+#else
+    status = PMSessionBeginCGDocumentNoDialog(d->session, d->settings, d->format);
+#endif
+
+    if (status != noErr) {
+        d->state = QPrinter::Error;
+        return false;
+    }
+
+    d->state = QPrinter::Active;
+    setActive(true);
+    d->newPage_helper();
+    return true;
+}
+
+bool QMacPrintEngine::end()
+{
+    Q_D(QMacPrintEngine);
+    if (d->state == QPrinter::Aborted)
+        return true;  // I was just here a function call ago :)
+    if(d->paintEngine->type() == QPaintEngine::CoreGraphics) {
+        // We dont need the paint engine to call restoreGraphicsState()
+        static_cast<QCoreGraphicsPaintEngine*>(d->paintEngine)->d_func()->stackCount = 0;
+        static_cast<QCoreGraphicsPaintEngine*>(d->paintEngine)->d_func()->hd = 0;
+    }
+    d->paintEngine->end();
+    if (d->state != QPrinter::Idle)
+	d->releaseSession();
+    d->state  = QPrinter::Idle;
+    return true;
+}
+
+QPaintEngine *
+QMacPrintEngine::paintEngine() const
+{
+    return d_func()->paintEngine;
+}
+
+Qt::HANDLE QMacPrintEngine::handle() const
+{
+    QCoreGraphicsPaintEngine *cgEngine = static_cast<QCoreGraphicsPaintEngine*>(paintEngine());
+    return cgEngine->d_func()->hd;
+}
+
+QMacPrintEnginePrivate::~QMacPrintEnginePrivate()
+{
+#ifdef QT_MAC_USE_COCOA
+    [printInfo release];
+#endif
+    delete paintEngine;
+}
+
+void QMacPrintEnginePrivate::setPaperSize(QPrinter::PaperSize ps)
+{
+    Q_Q(QMacPrintEngine);
+    QSizeF newSize = qt_paperSizeToQSizeF(ps);
+    QCFType<CFArrayRef> formats;
+    PMPrinter printer;
+
+    if (PMSessionGetCurrentPrinter(session, &printer) == noErr
+        && PMSessionCreatePageFormatList(session, printer, &formats) == noErr) {
+        CFIndex total = CFArrayGetCount(formats);
+        PMPageFormat tmp;
+        PMRect paper;
+        for (CFIndex idx = 0; idx < total; ++idx) {
+            tmp = static_cast<PMPageFormat>(
+                                        const_cast<void *>(CFArrayGetValueAtIndex(formats, idx)));
+            PMGetUnadjustedPaperRect(tmp, &paper);
+            int wMM = int((paper.right - paper.left) / 72 * 25.4 + 0.5);
+            int hMM = int((paper.bottom - paper.top) / 72 * 25.4 + 0.5);
+            if (newSize.width() == wMM && newSize.height() == hMM) {
+                PMCopyPageFormat(tmp, format);
+                // reset the orientation and resolution as they are lost in the copy.
+                q->setProperty(QPrintEngine::PPK_Orientation, orient);
+                if (PMSessionValidatePageFormat(session, format, kPMDontWantBoolean) != noErr) {
+                    // Don't know, warn for the moment.
+                    qWarning("QMacPrintEngine, problem setting format and resolution for this page size");
+                }
+                break;
+            }
+        }
+    }
+}
+
+QPrinter::PaperSize QMacPrintEnginePrivate::paperSize() const
+{
+    PMRect paper;
+    PMGetUnadjustedPaperRect(format, &paper);
+    int wMM = int((paper.right - paper.left) / 72 * 25.4 + 0.5);
+    int hMM = int((paper.bottom - paper.top) / 72 * 25.4 + 0.5);
+    for (int i = QPrinter::A4; i < QPrinter::NPaperSize; ++i) {
+        QSizeF s = qt_paperSizeToQSizeF(QPrinter::PaperSize(i));
+        if (s.width() == wMM && s.height() == hMM)
+            return (QPrinter::PaperSize)i;
+    }
+    return QPrinter::Custom;
+}
+
+QList<QVariant> QMacPrintEnginePrivate::supportedResolutions() const
+{
+    Q_ASSERT_X(session, "QMacPrinterEngine::supportedResolutions",
+               "must have a valid printer session");
+    UInt32 resCount;
+    QList<QVariant> resolutions;
+    PMPrinter printer;
+    if (PMSessionGetCurrentPrinter(session, &printer) == noErr) {
+        PMResolution res;
+        OSStatus status = PMPrinterGetPrinterResolutionCount(printer, &resCount);
+        if (status  == kPMNotImplemented) {
+#if (MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_5)
+            // *Sigh* we have to use the non-indexed version.
+            if (PMPrinterGetPrinterResolution(printer, kPMMinSquareResolution, &res) == noErr)
+                resolutions.append(int(res.hRes));
+            if (PMPrinterGetPrinterResolution(printer, kPMMaxSquareResolution, &res) == noErr) {
+                QVariant var(int(res.hRes));
+                if (!resolutions.contains(var))
+                    resolutions.append(var);
+            }
+            if (PMPrinterGetPrinterResolution(printer, kPMDefaultResolution, &res) == noErr) {
+                QVariant var(int(res.hRes));
+                if (!resolutions.contains(var))
+                    resolutions.append(var);
+            }
+#endif
+        } else if (status == noErr) {
+            // According to the docs, index start at 1.
+            for (UInt32 i = 1; i <= resCount; ++i) {
+                if (PMPrinterGetIndexedPrinterResolution(printer, i, &res) == noErr)
+                    resolutions.append(QVariant(int(res.hRes)));
+            }
+        } else {
+            qWarning("QMacPrintEngine::supportedResolutions: Unexpected error: %ld", long(status));
+        }
+    }
+    return resolutions;
+}
+
+bool QMacPrintEnginePrivate::shouldSuppressStatus() const
+{
+    if (suppressStatus == true)
+        return true;
+
+    // Supress displaying the automatic progress dialog if we are printing
+    // from a non-gui thread.
+    return (qApp->thread() != QThread::currentThread());
+}
+
+QPrinter::PrinterState QMacPrintEngine::printerState() const
+{
+    return d_func()->state;
+}
+
+bool QMacPrintEngine::newPage()
+{
+    Q_D(QMacPrintEngine);
+    Q_ASSERT(d->state == QPrinter::Active);
+    OSStatus err =
+#ifndef QT_MAC_USE_COCOA
+    d->shouldSuppressStatus() ? PMSessionEndPageNoDialog(d->session)
+                              : PMSessionEndPage(d->session);
+#else
+    PMSessionEndPageNoDialog(d->session);
+#endif
+    if (err != noErr)  {
+        if (err == kPMCancel) {
+            // User canceled, we need to abort!
+            abort();
+        } else {
+            // Not sure what the problem is...
+            qWarning("QMacPrintEngine::newPage: Cannot end current page. %ld", long(err));
+            d->state = QPrinter::Error;
+        }
+        return false;
+    }
+    return d->newPage_helper();
+}
+
+bool QMacPrintEngine::abort()
+{
+    Q_D(QMacPrintEngine);
+    if (d->state != QPrinter::Active)
+        return false;
+    bool ret = end();
+    d->state = QPrinter::Aborted;
+    return ret;
+}
+
+static inline int qt_get_PDMWidth(PMPageFormat pformat, bool fullPage,
+                                  const PMResolution &resolution)
+{
+    int val = 0;
+    PMRect r;
+    qreal hRatio = resolution.hRes / 72;
+    if (fullPage) {
+        if (PMGetAdjustedPaperRect(pformat, &r) == noErr)
+            val = qRound((r.right - r.left) * hRatio);
+    } else {
+        if (PMGetAdjustedPageRect(pformat, &r) == noErr)
+            val = qRound((r.right - r.left) * hRatio);
+    }
+    return val;
+}
+
+static inline int qt_get_PDMHeight(PMPageFormat pformat, bool fullPage,
+                                   const PMResolution &resolution)
+{
+    int val = 0;
+    PMRect r;
+    qreal vRatio = resolution.vRes / 72;
+    if (fullPage) {
+        if (PMGetAdjustedPaperRect(pformat, &r) == noErr)
+            val = qRound((r.bottom - r.top) * vRatio);
+    } else {
+        if (PMGetAdjustedPageRect(pformat, &r) == noErr)
+            val = qRound((r.bottom - r.top) * vRatio);
+    }
+    return val;
+}
+
+
+int QMacPrintEngine::metric(QPaintDevice::PaintDeviceMetric m) const
+{
+    Q_D(const QMacPrintEngine);
+    int val = 1;
+    switch (m) {
+    case QPaintDevice::PdmWidth:
+        if (d->hasCustomPaperSize) {
+            val = qRound(d->customSize.width());
+            if (d->hasCustomPageMargins) {
+                val -= qRound(d->leftMargin + d->rightMargin);
+            } else {
+                QList<QVariant> margins = property(QPrintEngine::PPK_PageMargins).toList();
+                val -= qRound(margins.at(0).toDouble() + margins.at(2).toDouble());
+            }
+        } else {
+            val = qt_get_PDMWidth(d->format, property(PPK_FullPage).toBool(), d->resolution);
+        }
+        break;
+    case QPaintDevice::PdmHeight:
+        if (d->hasCustomPaperSize) {
+            val = qRound(d->customSize.height());
+            if (d->hasCustomPageMargins) {
+                val -= qRound(d->topMargin + d->bottomMargin);
+            } else {
+                QList<QVariant> margins = property(QPrintEngine::PPK_PageMargins).toList();
+                val -= qRound(margins.at(1).toDouble() + margins.at(3).toDouble());
+            }
+        } else {
+            val = qt_get_PDMHeight(d->format, property(PPK_FullPage).toBool(), d->resolution);
+        }
+        break;
+    case QPaintDevice::PdmWidthMM:
+        val = metric(QPaintDevice::PdmWidth);
+        val = int((val * 254 + 5 * d->resolution.hRes) / (10 * d->resolution.hRes));
+        break;
+    case QPaintDevice::PdmHeightMM:
+        val = metric(QPaintDevice::PdmHeight);
+        val = int((val * 254 + 5 * d->resolution.vRes) / (10 * d->resolution.vRes));
+        break;
+    case QPaintDevice::PdmPhysicalDpiX:
+    case QPaintDevice::PdmPhysicalDpiY: {
+        PMPrinter printer;
+        if(PMSessionGetCurrentPrinter(d->session, &printer) == noErr) {
+            PMResolution resolution;
+#ifndef QT_MAC_USE_COCOA
+#  if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5)
+            if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_5) {
+                PMPrinterGetOutputResolution(printer, d->settings, &resolution);
+            } else
+#  endif
+            {
+                PMPrinterGetPrinterResolution(printer, kPMCurrentValue, &resolution);
+            }
+#else
+            PMPrinterGetOutputResolution(printer, d->settings, &resolution);
+#endif
+            val = (int)resolution.vRes;
+            break;
+        }
+        //otherwise fall through
+    }
+    case QPaintDevice::PdmDpiY:
+        val = (int)d->resolution.vRes;
+        break;
+    case QPaintDevice::PdmDpiX:
+        val = (int)d->resolution.hRes;
+        break;
+    case QPaintDevice::PdmNumColors:
+        val = (1 << metric(QPaintDevice::PdmDepth));
+        break;
+    case QPaintDevice::PdmDepth:
+        val = 24;
+        break;
+    default:
+        val = 0;
+        qWarning("QPrinter::metric: Invalid metric command");
+    }
+    return val;
+}
+
+void QMacPrintEnginePrivate::initialize()
+{
+    Q_Q(QMacPrintEngine);
+
+#ifndef QT_MAC_USE_COCOA
+    Q_ASSERT(!session);
+#else
+    Q_ASSERT(!printInfo);
+#endif
+
+    if (!paintEngine)
+        paintEngine = new QCoreGraphicsPaintEngine();
+
+    q->gccaps = paintEngine->gccaps;
+
+    fullPage = false;
+
+#ifndef QT_MAC_USE_COCOA
+    if (PMCreateSession(&session) != 0)
+        session = 0;
+#else
+    QMacCocoaAutoReleasePool pool;
+    printInfo = [[NSPrintInfo alloc] initWithDictionary:[NSDictionary dictionary]];
+    session = static_cast<PMPrintSession>([printInfo PMPrintSession]);
+#endif
+
+    PMPrinter printer;
+    if (session && PMSessionGetCurrentPrinter(session, &printer) == noErr) {
+        QList<QVariant> resolutions = supportedResolutions();
+        if (!resolutions.isEmpty() && mode != QPrinter::ScreenResolution) {
+            if (resolutions.count() > 1 && mode == QPrinter::HighResolution) {
+                int max = 0;
+                for (int i = 0; i < resolutions.count(); ++i) {
+                    int value = resolutions.at(i).toInt();
+                    if (value > max)
+                        max = value;
+                }
+                resolution.hRes = resolution.vRes = max;
+            } else {
+                resolution.hRes = resolution.vRes = resolutions.at(0).toInt();
+            }
+            if(resolution.hRes == 0)
+                resolution.hRes = resolution.vRes = 600;
+        } else {
+            resolution.hRes = resolution.vRes = qt_defaultDpi();
+        }
+    }
+
+#ifndef QT_MAC_USE_COCOA
+    bool settingsInitialized = (settings != 0);
+    bool settingsOK = !settingsInitialized ? PMCreatePrintSettings(&settings) == noErr : true;
+    if (settingsOK && !settingsInitialized)
+        settingsOK = PMSessionDefaultPrintSettings(session, settings) == noErr;
+
+
+    bool formatInitialized = (format != 0);
+    bool formatOK = !formatInitialized ? PMCreatePageFormat(&format) == noErr : true;
+    if (formatOK) {
+        if (!formatInitialized) {
+            formatOK = PMSessionDefaultPageFormat(session, format) == noErr;
+        }
+        formatOK = PMSessionValidatePageFormat(session, format, kPMDontWantBoolean) == noErr;
+    }
+#else
+    settings = static_cast<PMPrintSettings>([printInfo PMPrintSettings]);
+    format = static_cast<PMPageFormat>([printInfo PMPageFormat]);
+#endif
+
+#ifndef QT_MAC_USE_COCOA
+    if (!settingsOK || !formatOK) {
+        qWarning("QMacPrintEngine::initialize: Unable to initialize QPainter");
+        state = QPrinter::Error;
+    }
+#endif
+
+    QHash<QMacPrintEngine::PrintEnginePropertyKey, QVariant>::const_iterator propC;
+    for (propC = valueCache.constBegin(); propC != valueCache.constEnd(); propC++) {
+        q->setProperty(propC.key(), propC.value());
+    }
+}
+
+void QMacPrintEnginePrivate::releaseSession()
+{
+#ifndef QT_MAC_USE_COCOA
+    if (shouldSuppressStatus()) {
+	PMSessionEndPageNoDialog(session);
+	PMSessionEndDocumentNoDialog(session);
+    } else {
+	PMSessionEndPage(session);
+	PMSessionEndDocument(session);
+    }
+    PMRelease(session);
+#else
+    PMSessionEndPageNoDialog(session);
+    PMSessionEndDocumentNoDialog(session);
+    [printInfo release];
+#endif
+    printInfo = 0;
+    session = 0;
+}
+
+bool QMacPrintEnginePrivate::newPage_helper()
+{
+    Q_Q(QMacPrintEngine);
+    Q_ASSERT(state == QPrinter::Active);
+
+    if (PMSessionError(session) != noErr) {
+        q->abort();
+        return false;
+    }
+
+    // pop the stack of saved graphic states, in case we get the same
+    // context back - either way, the stack count should be 0 when we
+    // get the new one
+    QCoreGraphicsPaintEngine *cgEngine = static_cast<QCoreGraphicsPaintEngine*>(paintEngine);
+    while (cgEngine->d_func()->stackCount > 0)
+        cgEngine->d_func()->restoreGraphicsState();
+
+    OSStatus status =
+#ifndef QT_MAC_USE_COCOA
+        shouldSuppressStatus() ? PMSessionBeginPageNoDialog(session, format, 0)
+                               : PMSessionBeginPage(session, format, 0);
+#else
+        PMSessionBeginPageNoDialog(session, format, 0);
+#endif
+    if(status != noErr) {
+        state = QPrinter::Error;
+        return false;
+    }
+
+    QRect page = q->property(QPrintEngine::PPK_PageRect).toRect();
+    QRect paper = q->property(QPrintEngine::PPK_PaperRect).toRect();
+
+    CGContextRef cgContext;
+    OSStatus err = noErr;
+    err = PMSessionGetCGGraphicsContext(session, &cgContext);
+    if(err != noErr) {
+        qWarning("QMacPrintEngine::newPage: Cannot retrieve CoreGraphics context: %ld", long(err));
+        state = QPrinter::Error;
+        return false;
+    }
+    cgEngine->d_func()->hd = cgContext;
+
+    // Set the resolution as a scaling ration of 72 (the default).
+    CGContextScaleCTM(cgContext, 72 / resolution.hRes, 72 / resolution.vRes);
+
+    CGContextScaleCTM(cgContext, 1, -1);
+    CGContextTranslateCTM(cgContext, 0, -paper.height());
+    if (!fullPage)
+        CGContextTranslateCTM(cgContext, page.x() - paper.x(), page.y() - paper.y());
+    cgEngine->d_func()->orig_xform = CGContextGetCTM(cgContext);
+    cgEngine->d_func()->setClip(0);
+    cgEngine->state->dirtyFlags = QPaintEngine::DirtyFlag(QPaintEngine::AllDirty
+							  & ~(QPaintEngine::DirtyClipEnabled
+							      | QPaintEngine::DirtyClipRegion
+							      | QPaintEngine::DirtyClipPath));
+    if (cgEngine->painter()->hasClipping())
+        cgEngine->state->dirtyFlags |= QPaintEngine::DirtyClipEnabled;
+    cgEngine->syncState();
+    return true;
+}
+
+
+void QMacPrintEngine::updateState(const QPaintEngineState &state)
+{
+    d_func()->paintEngine->updateState(state);
+}
+
+void QMacPrintEngine::drawRects(const QRectF *r, int num)
+{
+    Q_D(QMacPrintEngine);
+    Q_ASSERT(d->state == QPrinter::Active);
+    d->paintEngine->drawRects(r, num);
+}
+
+void QMacPrintEngine::drawPoints(const QPointF *points, int pointCount)
+{
+    Q_D(QMacPrintEngine);
+    Q_ASSERT(d->state == QPrinter::Active);
+    d->paintEngine->drawPoints(points, pointCount);
+}
+
+void QMacPrintEngine::drawEllipse(const QRectF &r)
+{
+    Q_D(QMacPrintEngine);
+    Q_ASSERT(d->state == QPrinter::Active);
+    d->paintEngine->drawEllipse(r);
+}
+
+void QMacPrintEngine::drawLines(const QLineF *lines, int lineCount)
+{
+    Q_D(QMacPrintEngine);
+    Q_ASSERT(d->state == QPrinter::Active);
+    d->paintEngine->drawLines(lines, lineCount);
+}
+
+void QMacPrintEngine::drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode)
+{
+    Q_D(QMacPrintEngine);
+    Q_ASSERT(d->state == QPrinter::Active);
+    d->paintEngine->drawPolygon(points, pointCount, mode);
+}
+
+void QMacPrintEngine::drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr)
+{
+    Q_D(QMacPrintEngine);
+    Q_ASSERT(d->state == QPrinter::Active);
+    d->paintEngine->drawPixmap(r, pm, sr);
+}
+
+void QMacPrintEngine::drawImage(const QRectF &r, const QImage &pm, const QRectF &sr, Qt::ImageConversionFlags flags)
+{
+    Q_D(QMacPrintEngine);
+    Q_ASSERT(d->state == QPrinter::Active);
+    d->paintEngine->drawImage(r, pm, sr, flags);
+}
+
+void QMacPrintEngine::drawTextItem(const QPointF &p, const QTextItem &ti)
+{
+    Q_D(QMacPrintEngine);
+    Q_ASSERT(d->state == QPrinter::Active);
+    d->paintEngine->drawTextItem(p, ti);
+}
+
+void QMacPrintEngine::drawTiledPixmap(const QRectF &dr, const QPixmap &pixmap, const QPointF &sr)
+{
+    Q_D(QMacPrintEngine);
+    Q_ASSERT(d->state == QPrinter::Active);
+    d->paintEngine->drawTiledPixmap(dr, pixmap, sr);
+}
+
+void QMacPrintEngine::drawPath(const QPainterPath &path)
+{
+    Q_D(QMacPrintEngine);
+    Q_ASSERT(d->state == QPrinter::Active);
+    d->paintEngine->drawPath(path);
+}
+
+
+void QMacPrintEngine::setProperty(PrintEnginePropertyKey key, const QVariant &value)
+{
+    Q_D(QMacPrintEngine);
+
+    d->valueCache.insert(key, value);
+    if (!d->session)
+        return;
+
+    switch (key) {
+    case PPK_CollateCopies:
+        break;
+    case PPK_ColorMode:
+        break;
+    case PPK_Creator:
+        break;
+    case PPK_DocumentName:
+        break;
+    case PPK_PageOrder:
+        break;
+    case PPK_PaperSource:
+        break;
+    case PPK_SelectionOption:
+        break;
+    case PPK_Resolution:  {
+        PMPrinter printer;
+        UInt32 count;
+        if (PMSessionGetCurrentPrinter(d->session, &printer) != noErr)
+            break;
+        if (PMPrinterGetPrinterResolutionCount(printer, &count) != noErr)
+            break;
+        PMResolution resolution = { 0.0, 0.0 };
+        PMResolution bestResolution = { 0.0, 0.0 };
+        int dpi = value.toInt();
+        int bestDistance = INT_MAX;
+        for (UInt32 i = 1; i <= count; ++i) {  // Yes, it starts at 1
+            if (PMPrinterGetIndexedPrinterResolution(printer, i, &resolution) == noErr) {
+                if (dpi == int(resolution.hRes)) {
+                    bestResolution = resolution;
+                    break;
+                } else {
+                    int distance = qAbs(dpi - int(resolution.hRes));
+                    if (distance < bestDistance) {
+                        bestDistance = distance;
+                        bestResolution = resolution;
+                    }
+                }
+            }
+        }
+        PMSessionValidatePageFormat(d->session, d->format, kPMDontWantBoolean);
+        break;
+    }
+
+    case PPK_FullPage:
+        d->fullPage = value.toBool();
+        break;
+    case PPK_CopyCount: // fallthrough
+    case PPK_NumberOfCopies:
+        PMSetCopies(d->settings, value.toInt(), false);
+        break;
+    case PPK_Orientation: {
+        if (d->state == QPrinter::Active) {
+            qWarning("QMacPrintEngine::setOrientation: Orientation cannot be changed during a print job, ignoring change");
+        } else {
+            QPrinter::Orientation newOrientation = QPrinter::Orientation(value.toInt());
+            if (d->hasCustomPaperSize && (d->orient != newOrientation))
+                d->customSize = QSizeF(d->customSize.height(), d->customSize.width());
+            d->orient = newOrientation;
+            PMOrientation o = d->orient == QPrinter::Portrait ? kPMPortrait : kPMLandscape;
+            PMSetOrientation(d->format, o, false);
+            PMSessionValidatePageFormat(d->session, d->format, kPMDontWantBoolean);
+        }
+        break; }
+    case PPK_OutputFileName:
+        d->outputFilename = value.toString();
+        break;
+    case PPK_PaperSize:
+        d->setPaperSize(QPrinter::PaperSize(value.toInt()));
+        break;
+    case PPK_PrinterName: {
+        bool printerNameSet = false;
+        OSStatus status = noErr;
+        QCFType<CFArrayRef> printerList;
+        status = PMServerCreatePrinterList(kPMServerLocal, &printerList);
+        if (status == noErr) {
+            CFIndex count = CFArrayGetCount(printerList);
+            for (CFIndex i=0; i<count; ++i) {
+                PMPrinter printer = static_cast<PMPrinter>(const_cast<void *>(CFArrayGetValueAtIndex(printerList, i)));
+                QString name = QCFString::toQString(PMPrinterGetName(printer));
+                if (name == value.toString()) {
+                    status = PMSessionSetCurrentPMPrinter(d->session, printer);
+                    printerNameSet = true;
+                    break;
+                }
+            }
+        }
+        if (status != noErr)
+            qWarning("QMacPrintEngine::setPrinterName: Error setting printer: %ld", long(status));
+	if (!printerNameSet) {
+            qWarning("QMacPrintEngine::setPrinterName: Failed to set printer named '%s'.", qPrintable(value.toString()));
+            d->releaseSession();
+            d->state = QPrinter::Idle;
+        }
+        break; }
+    case PPK_SuppressSystemPrintStatus:
+        d->suppressStatus = value.toBool();
+        break;
+    case PPK_CustomPaperSize:
+    {
+        PMOrientation orientation;
+        PMGetOrientation(d->format, &orientation);
+        d->hasCustomPaperSize = true;
+        d->customSize = value.toSizeF();
+        if (orientation != kPMPortrait)
+            d->customSize = QSizeF(d->customSize.height(), d->customSize.width());
+        break;
+    }
+    case PPK_PageMargins:
+    {
+        QList<QVariant> margins(value.toList());
+        Q_ASSERT(margins.size() == 4);
+        d->leftMargin = margins.at(0).toDouble();
+        d->topMargin = margins.at(1).toDouble();
+        d->rightMargin = margins.at(2).toDouble();
+        d->bottomMargin = margins.at(3).toDouble();
+        d->hasCustomPageMargins = true;
+        break;
+    }
+
+    default:
+        break;
+    }
+}
+
+QVariant QMacPrintEngine::property(PrintEnginePropertyKey key) const
+{
+    Q_D(const QMacPrintEngine);
+    QVariant ret;
+
+    if (!d->session && d->valueCache.contains(key))
+        return *d->valueCache.find(key);
+
+    switch (key) {
+    case PPK_CollateCopies:
+        ret = false;
+        break;
+    case PPK_ColorMode:
+        ret = QPrinter::Color;
+        break;
+    case PPK_Creator:
+        break;
+    case PPK_DocumentName:
+        break;
+    case PPK_FullPage:
+        ret = d->fullPage;
+        break;
+    case PPK_NumberOfCopies:
+        ret = 1;
+        break;
+    case PPK_CopyCount: {
+        UInt32 copies = 1;
+        PMGetCopies(d->settings, &copies);
+        ret = (uint) copies;
+        break;
+    }
+    case PPK_SupportsMultipleCopies:
+        ret = true;
+        break;
+    case PPK_Orientation:
+        PMOrientation orientation;
+        PMGetOrientation(d->format, &orientation);
+        ret = orientation == kPMPortrait ? QPrinter::Portrait : QPrinter::Landscape;
+        break;
+    case PPK_OutputFileName:
+        ret = d->outputFilename;
+        break;
+    case PPK_PageOrder:
+        break;
+    case PPK_PaperSource:
+        break;
+    case PPK_PageRect: {
+        // PageRect is returned in device pixels
+        QRect r;
+        PMRect macrect, macpaper;
+        qreal hRatio = d->resolution.hRes / 72;
+        qreal vRatio = d->resolution.vRes / 72;
+        if (d->hasCustomPaperSize) {
+            r = QRect(0, 0, qRound(d->customSize.width() * hRatio), qRound(d->customSize.height() * vRatio));
+            if (d->hasCustomPageMargins) {
+                r.adjust(qRound(d->leftMargin * hRatio), qRound(d->topMargin * vRatio), 
+                         -qRound(d->rightMargin * hRatio), -qRound(d->bottomMargin * vRatio));
+            } else {
+                QList<QVariant> margins = property(QPrintEngine::PPK_PageMargins).toList();
+                r.adjust(qRound(margins.at(0).toDouble() * hRatio),
+                         qRound(margins.at(1).toDouble() * vRatio),
+                         -qRound(margins.at(2).toDouble() * hRatio),
+                         -qRound(margins.at(3).toDouble()) * vRatio);
+            }
+        } else if (PMGetAdjustedPageRect(d->format, &macrect) == noErr
+                   && PMGetAdjustedPaperRect(d->format, &macpaper) == noErr)
+        {
+            if (d->fullPage || d->hasCustomPageMargins) {
+                r.setCoords(int(macpaper.left * hRatio), int(macpaper.top * vRatio),
+                            int(macpaper.right * hRatio), int(macpaper.bottom * vRatio));
+                r.translate(-r.x(), -r.y());
+                if (d->hasCustomPageMargins) {
+                    r.adjust(qRound(d->leftMargin * hRatio), qRound(d->topMargin * vRatio),
+                             -qRound(d->rightMargin * hRatio), -qRound(d->bottomMargin * vRatio));
+                }
+            } else {
+                r.setCoords(int(macrect.left * hRatio), int(macrect.top * vRatio),
+                            int(macrect.right * hRatio), int(macrect.bottom * vRatio));
+                r.translate(int(-macpaper.left * hRatio), int(-macpaper.top * vRatio));
+            } 
+        }
+        ret = r;
+        break; }
+    case PPK_PaperSize:
+        ret = d->paperSize();
+        break;
+    case PPK_PaperRect: {
+        QRect r;
+        PMRect macrect;
+        if (d->hasCustomPaperSize) {
+            r = QRect(0, 0, qRound(d->customSize.width()), qRound(d->customSize.height()));
+        } else if (PMGetAdjustedPaperRect(d->format, &macrect) == noErr) {
+            qreal hRatio = d->resolution.hRes / 72;
+            qreal vRatio = d->resolution.vRes / 72;
+            r.setCoords(int(macrect.left * hRatio), int(macrect.top * vRatio),
+                        int(macrect.right * hRatio), int(macrect.bottom * vRatio));
+            r.translate(-r.x(), -r.y());
+        }
+        ret = r;
+        break; }
+    case PPK_PrinterName: {
+        PMPrinter printer;
+        OSStatus status = PMSessionGetCurrentPrinter(d->session, &printer);
+        if (status != noErr)
+            qWarning("QMacPrintEngine::printerName: Failed getting current PMPrinter: %ld", long(status));
+        if (printer)
+            ret = QCFString::toQString(PMPrinterGetName(printer));
+        break; }
+    case PPK_Resolution: {
+        ret = d->resolution.hRes;
+        break;
+    }
+    case PPK_SupportedResolutions:
+        ret = d->supportedResolutions();
+        break;
+    case PPK_CustomPaperSize:
+        ret = d->customSize;
+        break;
+    case PPK_PageMargins:
+    {
+        QList<QVariant> margins;
+        if (d->hasCustomPageMargins) {
+            margins << d->leftMargin << d->topMargin
+                    << d->rightMargin << d->bottomMargin;
+        } else {
+            PMPaperMargins paperMargins;
+            PMPaper paper;
+            PMGetPageFormatPaper(d->format, &paper);
+            PMPaperGetMargins(paper, &paperMargins);
+            margins << paperMargins.left << paperMargins.top
+                    << paperMargins.right << paperMargins.bottom;
+        }
+        ret = margins;
+        break;
+    }
+    default:
+        break;
+    }
+    return ret;
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_PRINTER
diff --git a/src/gui/painting/qprintengine_mac_p.h b/src/gui/painting/qprintengine_mac_p.h
new file mode 100644
index 0000000000..511705d26f
--- /dev/null
+++ b/src/gui/painting/qprintengine_mac_p.h
@@ -0,0 +1,166 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPRINTENGINE_MAC_P_H
+#define QPRINTENGINE_MAC_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#ifndef QT_NO_PRINTER
+
+#include "QtGui/qprinter.h"
+#include "QtGui/qprintengine.h"
+#include "private/qpaintengine_mac_p.h"
+#include "private/qpainter_p.h"
+
+#ifdef __OBJC__
+@class NSPrintInfo;
+#else
+typedef void NSPrintInfo;
+#endif
+
+QT_BEGIN_NAMESPACE
+
+class QPrinterPrivate;
+class QMacPrintEnginePrivate;
+class QMacPrintEngine : public QPaintEngine, public QPrintEngine
+{
+    Q_DECLARE_PRIVATE(QMacPrintEngine)
+public:
+    QMacPrintEngine(QPrinter::PrinterMode mode);
+
+    Qt::HANDLE handle() const;
+
+    bool begin(QPaintDevice *dev);
+    bool end();
+    virtual QPaintEngine::Type type() const { return QPaintEngine::MacPrinter; }
+
+    QPaintEngine *paintEngine() const;
+
+    void setProperty(PrintEnginePropertyKey key, const QVariant &value);
+    QVariant property(PrintEnginePropertyKey key) const;
+
+    QPrinter::PrinterState printerState() const;
+
+    bool newPage();
+    bool abort();
+    int metric(QPaintDevice::PaintDeviceMetric) const;
+
+    //forwarded functions
+
+    void updateState(const QPaintEngineState &state);
+
+    virtual void drawLines(const QLineF *lines, int lineCount);
+    virtual void drawRects(const QRectF *r, int num);
+    virtual void drawPoints(const QPointF *p, int pointCount);
+    virtual void drawEllipse(const QRectF &r);
+    virtual void drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode);
+    virtual void drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr);
+    virtual void drawImage(const QRectF &r, const QImage &pm, const QRectF &sr, Qt::ImageConversionFlags flags);
+    virtual void drawTextItem(const QPointF &p, const QTextItem &ti);
+    virtual void drawTiledPixmap(const QRectF &r, const QPixmap &pixmap, const QPointF &s);
+    virtual void drawPath(const QPainterPath &);
+
+private:
+    friend class QPrintDialog;
+    friend class QPageSetupDialog;
+};
+
+class QMacPrintEnginePrivate : public QPaintEnginePrivate
+{
+    Q_DECLARE_PUBLIC(QMacPrintEngine)
+public:
+    QPrinter::PrinterMode mode;
+    QPrinter::PrinterState state;
+    QPrinter::Orientation orient;
+    NSPrintInfo *printInfo;
+    PMPageFormat format;
+    PMPrintSettings settings;
+    PMPrintSession session;
+    PMResolution resolution;
+    QString outputFilename;
+    bool fullPage;
+    QPaintEngine *paintEngine;
+    bool suppressStatus;
+    bool hasCustomPaperSize;
+    QSizeF customSize;
+    bool hasCustomPageMargins;
+    qreal leftMargin;
+    qreal topMargin;
+    qreal rightMargin;
+    qreal bottomMargin;
+    QHash<QMacPrintEngine::PrintEnginePropertyKey, QVariant> valueCache;
+    QMacPrintEnginePrivate() : mode(QPrinter::ScreenResolution), state(QPrinter::Idle),
+                               orient(QPrinter::Portrait), printInfo(0), format(0), settings(0),
+                               session(0), paintEngine(0), suppressStatus(false),
+                               hasCustomPaperSize(false), hasCustomPageMargins(false) {}
+    ~QMacPrintEnginePrivate();
+    void initialize();
+    void releaseSession();
+    bool newPage_helper();
+    void setPaperSize(QPrinter::PaperSize ps);
+    QPrinter::PaperSize paperSize() const;
+    QList<QVariant> supportedResolutions() const;
+    inline bool isPrintSessionInitialized() const
+    {
+#ifndef QT_MAC_USE_COCOA
+        return session != 0;
+#else
+        return printInfo != 0;
+#endif
+    }
+    bool shouldSuppressStatus() const;
+};
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_PRINTER
+
+#endif // QPRINTENGINE_WIN_P_H
diff --git a/src/gui/painting/qprintengine_pdf.cpp b/src/gui/painting/qprintengine_pdf.cpp
new file mode 100644
index 0000000000..b7f51606da
--- /dev/null
+++ b/src/gui/painting/qprintengine_pdf.cpp
@@ -0,0 +1,1241 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtGui/qprintengine.h>
+
+#include <qiodevice.h>
+#include <qpainter.h>
+#include <qbitmap.h>
+#include <qpainterpath.h>
+#include <qpaintdevice.h>
+#include <qfile.h>
+#include <qdebug.h>
+#include <qimagewriter.h>
+#include <qbuffer.h>
+#include <qdatetime.h>
+
+#ifndef QT_NO_PRINTER
+#include <limits.h>
+#include <math.h>
+#ifndef QT_NO_COMPRESS
+#include <zlib.h>
+#endif
+
+#if defined(Q_OS_WINCE)
+#include "qwinfunctions_wince.h"
+#endif
+
+#include "qprintengine_pdf_p.h"
+#include "private/qdrawhelper_p.h"
+
+QT_BEGIN_NAMESPACE
+
+extern qint64 qt_pixmap_id(const QPixmap &pixmap);
+extern qint64 qt_image_id(const QImage &image);
+
+//#define FONT_DUMP
+
+// might be helpful for smooth transforms of images
+// Can't use it though, as gs generates completely wrong images if this is true.
+static const bool interpolateImages = false;
+
+#ifdef QT_NO_COMPRESS
+static const bool do_compress = false;
+#else
+static const bool do_compress = true;
+#endif
+
+QPdfPage::QPdfPage()
+    : QPdf::ByteStream(true) // Enable file backing
+{
+}
+
+void QPdfPage::streamImage(int w, int h, int object)
+{
+    *this << w << "0 0 " << -h << "0 " << h << "cm /Im" << object << " Do\n";
+    if (!images.contains(object))
+        images.append(object);
+}
+
+
+inline QPaintEngine::PaintEngineFeatures qt_pdf_decide_features()
+{
+    QPaintEngine::PaintEngineFeatures f = QPaintEngine::AllFeatures;
+    f &= ~(QPaintEngine::PorterDuff | QPaintEngine::PerspectiveTransform
+           | QPaintEngine::ObjectBoundingModeGradients
+#ifndef USE_NATIVE_GRADIENTS
+           | QPaintEngine::LinearGradientFill
+#endif
+           | QPaintEngine::RadialGradientFill
+           | QPaintEngine::ConicalGradientFill);
+    return f;
+}
+
+QPdfEngine::QPdfEngine(QPrinter::PrinterMode m)
+    : QPdfBaseEngine(*new QPdfEnginePrivate(m), qt_pdf_decide_features())
+{
+    state = QPrinter::Idle;
+}
+
+QPdfEngine::~QPdfEngine()
+{
+}
+
+bool QPdfEngine::begin(QPaintDevice *pdev)
+{
+    Q_D(QPdfEngine);
+
+    if(!QPdfBaseEngine::begin(pdev)) {
+        state = QPrinter::Error;
+        return false;
+    }
+    d->stream->setDevice(d->outDevice);
+
+    d->streampos = 0;
+    d->hasPen = true;
+    d->hasBrush = false;
+    d->clipEnabled = false;
+    d->allClipped = false;
+
+    d->xrefPositions.clear();
+    d->pageRoot = 0;
+    d->catalog = 0;
+    d->info = 0;
+    d->graphicsState = 0;
+    d->patternColorSpace = 0;
+
+    d->pages.clear();
+    d->imageCache.clear();
+
+    setActive(true);
+    state = QPrinter::Active;
+    d->writeHeader();
+    newPage();
+
+    return true;
+}
+
+bool QPdfEngine::end()
+{
+    Q_D(QPdfEngine);
+    d->writeTail();
+
+    d->stream->unsetDevice();
+    QPdfBaseEngine::end();
+    setActive(false);
+    state = QPrinter::Idle;
+    return true;
+}
+
+
+void QPdfEngine::drawPixmap (const QRectF &rectangle, const QPixmap &pixmap, const QRectF &sr)
+{
+    if (sr.isEmpty() || rectangle.isEmpty() || pixmap.isNull())
+        return;
+    Q_D(QPdfEngine);
+
+    QBrush b = d->brush;
+
+    QRect sourceRect = sr.toRect();
+    QPixmap pm = sourceRect != pixmap.rect() ? pixmap.copy(sourceRect) : pixmap;
+    QImage image = pm.toImage();
+    bool bitmap = true;
+    const int object = d->addImage(image, &bitmap, pm.cacheKey());
+    if (object < 0)
+        return;
+
+    *d->currentPage << "q\n/GSa gs\n";
+    *d->currentPage
+        << QPdf::generateMatrix(QTransform(rectangle.width() / sr.width(), 0, 0, rectangle.height() / sr.height(),
+                                           rectangle.x(), rectangle.y()) * (d->simplePen ? QTransform() : d->stroker.matrix));
+    if (bitmap) {
+        // set current pen as d->brush
+        d->brush = d->pen.brush();
+    }
+    setBrush();
+    d->currentPage->streamImage(image.width(), image.height(), object);
+    *d->currentPage << "Q\n";
+
+    d->brush = b;
+}
+
+void QPdfEngine::drawImage(const QRectF &rectangle, const QImage &image, const QRectF &sr, Qt::ImageConversionFlags)
+{
+    if (sr.isEmpty() || rectangle.isEmpty() || image.isNull())
+        return;
+    Q_D(QPdfEngine);
+
+    QRect sourceRect = sr.toRect();
+    QImage im = sourceRect != image.rect() ? image.copy(sourceRect) : image;
+    bool bitmap = true;
+    const int object = d->addImage(im, &bitmap, im.cacheKey());
+    if (object < 0)
+        return;
+
+    *d->currentPage << "q\n/GSa gs\n";
+    *d->currentPage
+        << QPdf::generateMatrix(QTransform(rectangle.width() / sr.width(), 0, 0, rectangle.height() / sr.height(),
+                                           rectangle.x(), rectangle.y()) * (d->simplePen ? QTransform() : d->stroker.matrix));
+    setBrush();
+    d->currentPage->streamImage(im.width(), im.height(), object);
+    *d->currentPage << "Q\n";
+}
+
+void QPdfEngine::drawTiledPixmap (const QRectF &rectangle, const QPixmap &pixmap, const QPointF &point)
+{
+    Q_D(QPdfEngine);
+
+    bool bitmap = (pixmap.depth() == 1);
+    QBrush b = d->brush;
+    QPointF bo = d->brushOrigin;
+    bool hp = d->hasPen;
+    d->hasPen = false;
+    bool hb = d->hasBrush;
+    d->hasBrush = true;
+
+    d->brush = QBrush(pixmap);
+    if (bitmap)
+        // #### fix bitmap case where we have a brush pen
+        d->brush.setColor(d->pen.color());
+
+    d->brushOrigin = -point;
+    *d->currentPage << "q\n";
+    setBrush();
+
+    drawRects(&rectangle, 1);
+    *d->currentPage << "Q\n";
+
+    d->hasPen = hp;
+    d->hasBrush = hb;
+    d->brush = b;
+    d->brushOrigin = bo;
+}
+
+
+void QPdfEngine::setBrush()
+{
+    Q_D(QPdfEngine);
+    Qt::BrushStyle style = d->brush.style();
+    if (style == Qt::NoBrush)
+        return;
+
+    bool specifyColor;
+    int gStateObject = 0;
+    int patternObject = d->addBrushPattern(d->stroker.matrix, &specifyColor, &gStateObject);
+
+    *d->currentPage << (patternObject ? "/PCSp cs " : "/CSp cs ");
+    if (specifyColor) {
+        QColor rgba = d->brush.color();
+        if (d->colorMode == QPrinter::GrayScale) {
+            qreal gray = qGray(rgba.rgba())/255.;
+            *d->currentPage << gray << gray << gray;
+        } else {
+            *d->currentPage << rgba.redF()
+                            << rgba.greenF()
+                            << rgba.blueF();
+        }
+    }
+    if (patternObject)
+        *d->currentPage << "/Pat" << patternObject;
+    *d->currentPage << "scn\n";
+
+    if (gStateObject)
+        *d->currentPage << "/GState" << gStateObject << "gs\n";
+    else
+        *d->currentPage << "/GSa gs\n";
+}
+
+QPaintEngine::Type QPdfEngine::type() const
+{
+    return QPaintEngine::Pdf;
+}
+
+bool QPdfEngine::newPage()
+{
+    Q_D(QPdfEngine);
+    if (!isActive())
+        return false;
+    d->newPage();
+    return QPdfBaseEngine::newPage();
+}
+
+QPdfEnginePrivate::QPdfEnginePrivate(QPrinter::PrinterMode m)
+    : QPdfBaseEnginePrivate(m)
+{
+    streampos = 0;
+
+    stream = new QDataStream;
+    pageOrder = QPrinter::FirstPageFirst;
+    orientation = QPrinter::Portrait;
+    fullPage = false;
+}
+
+QPdfEnginePrivate::~QPdfEnginePrivate()
+{
+    delete stream;
+}
+
+
+#ifdef USE_NATIVE_GRADIENTS
+int QPdfEnginePrivate::gradientBrush(const QBrush &b, const QMatrix &matrix, int *gStateObject)
+{
+    const QGradient *gradient = b.gradient();
+    if (!gradient)
+        return 0;
+
+    QTransform inv = matrix.inverted();
+    QPointF page_rect[4] = { inv.map(QPointF(0, 0)),
+                             inv.map(QPointF(width_, 0)),
+                             inv.map(QPointF(0, height_)),
+                             inv.map(QPointF(width_, height_)) };
+
+    bool opaque = b.isOpaque();
+
+    QByteArray shader;
+    QByteArray alphaShader;
+    if (gradient->type() == QGradient::LinearGradient) {
+        const QLinearGradient *lg = static_cast<const QLinearGradient *>(gradient);
+        shader = QPdf::generateLinearGradientShader(lg, page_rect);
+        if (!opaque)
+            alphaShader = QPdf::generateLinearGradientShader(lg, page_rect, true);
+    } else {
+        // #############
+        return 0;
+    }
+    int shaderObject = addXrefEntry(-1);
+    write(shader);
+
+    QByteArray str;
+    QPdf::ByteStream s(&str);
+    s << "<<\n"
+        "/Type /Pattern\n"
+        "/PatternType 2\n"
+        "/Shading " << shaderObject << "0 R\n"
+        "/Matrix ["
+      << matrix.m11()
+      << matrix.m12()
+      << matrix.m21()
+      << matrix.m22()
+      << matrix.dx()
+      << matrix.dy() << "]\n";
+    s << ">>\n"
+        "endobj\n";
+
+    int patternObj = addXrefEntry(-1);
+    write(str);
+    currentPage->patterns.append(patternObj);
+
+    if (!opaque) {
+        bool ca = true;
+        QGradientStops stops = gradient->stops();
+        int a = stops.at(0).second.alpha();
+        for (int i = 1; i < stops.size(); ++i) {
+            if (stops.at(i).second.alpha() != a) {
+                ca = false;
+                break;
+            }
+        }
+        if (ca) {
+            *gStateObject = addConstantAlphaObject(stops.at(0).second.alpha());
+        } else {
+            int alphaShaderObject = addXrefEntry(-1);
+            write(alphaShader);
+
+            QByteArray content;
+            QPdf::ByteStream c(&content);
+            c << "/Shader" << alphaShaderObject << "sh\n";
+
+            QByteArray form;
+            QPdf::ByteStream f(&form);
+            f << "<<\n"
+                "/Type /XObject\n"
+                "/Subtype /Form\n"
+                "/BBox [0 0 " << width_ << height_ << "]\n"
+                "/Group <</S /Transparency >>\n"
+                "/Resources <<\n"
+                "/Shading << /Shader" << alphaShaderObject << alphaShaderObject << "0 R >>\n"
+                ">>\n";
+
+            f << "/Length " << content.length() << "\n"
+                ">>\n"
+                "stream\n"
+              << content
+              << "endstream\n"
+                "endobj\n";
+
+            int softMaskFormObject = addXrefEntry(-1);
+            write(form);
+            *gStateObject = addXrefEntry(-1);
+            xprintf("<< /SMask << /S /Alpha /G %d 0 R >> >>\n"
+                    "endobj\n", softMaskFormObject);
+            currentPage->graphicStates.append(*gStateObject);
+        }
+    }
+
+    return patternObj;
+}
+#endif
+
+int QPdfEnginePrivate::addConstantAlphaObject(int brushAlpha, int penAlpha)
+{
+    if (brushAlpha == 255 && penAlpha == 255)
+        return 0;
+    int object = alphaCache.value(QPair<uint, uint>(brushAlpha, penAlpha), 0);
+    if (!object) {
+        object = addXrefEntry(-1);
+        QByteArray alphaDef;
+        QPdf::ByteStream s(&alphaDef);
+        s << "<<\n/ca " << (brushAlpha/qreal(255.)) << '\n';
+        s << "/CA " << (penAlpha/qreal(255.)) << "\n>>";
+        xprintf("%s\nendobj\n", alphaDef.constData());
+        alphaCache.insert(QPair<uint, uint>(brushAlpha, penAlpha), object);
+    }
+    if (currentPage->graphicStates.indexOf(object) < 0)
+        currentPage->graphicStates.append(object);
+
+    return object;
+}
+
+int QPdfEnginePrivate::addBrushPattern(const QTransform &m, bool *specifyColor, int *gStateObject)
+{
+    int paintType = 2; // Uncolored tiling
+    int w = 8;
+    int h = 8;
+
+    *specifyColor = true;
+    *gStateObject = 0;
+
+    QTransform matrix = m;
+    matrix.translate(brushOrigin.x(), brushOrigin.y());
+    matrix = matrix * pageMatrix();
+    //qDebug() << brushOrigin << matrix;
+
+    Qt::BrushStyle style = brush.style();
+    if (style == Qt::LinearGradientPattern) {// && style <= Qt::ConicalGradientPattern) {
+#ifdef USE_NATIVE_GRADIENTS
+        *specifyColor = false;
+        return gradientBrush(b, matrix, gStateObject);
+#else
+        return 0;
+#endif
+    }
+
+    if ((!brush.isOpaque() && brush.style() < Qt::LinearGradientPattern) || opacity != 1.0)
+        *gStateObject = addConstantAlphaObject(qRound(brush.color().alpha() * opacity),
+                                               qRound(pen.color().alpha() * opacity));
+
+    int imageObject = -1;
+    QByteArray pattern = QPdf::patternForBrush(brush);
+    if (pattern.isEmpty()) {
+        if (brush.style() != Qt::TexturePattern)
+            return 0;
+        QImage image = brush.texture().toImage();
+        bool bitmap = true;
+        imageObject = addImage(image, &bitmap, qt_pixmap_id(brush.texture()));
+        if (imageObject != -1) {
+            QImage::Format f = image.format();
+            if (f != QImage::Format_MonoLSB && f != QImage::Format_Mono) {
+                paintType = 1; // Colored tiling
+                *specifyColor = false;
+            }
+            w = image.width();
+            h = image.height();
+            QTransform m(w, 0, 0, -h, 0, h);
+            QPdf::ByteStream s(&pattern);
+            s << QPdf::generateMatrix(m);
+            s << "/Im" << imageObject << " Do\n";
+        }
+    }
+
+    QByteArray str;
+    QPdf::ByteStream s(&str);
+    s << "<<\n"
+        "/Type /Pattern\n"
+        "/PatternType 1\n"
+        "/PaintType " << paintType << "\n"
+        "/TilingType 1\n"
+        "/BBox [0 0 " << w << h << "]\n"
+        "/XStep " << w << "\n"
+        "/YStep " << h << "\n"
+        "/Matrix ["
+      << matrix.m11()
+      << matrix.m12()
+      << matrix.m21()
+      << matrix.m22()
+      << matrix.dx()
+      << matrix.dy() << "]\n"
+        "/Resources \n<< "; // open resource tree
+    if (imageObject > 0) {
+        s << "/XObject << /Im" << imageObject << ' ' << imageObject << "0 R >> ";
+    }
+    s << ">>\n"
+        "/Length " << pattern.length() << "\n"
+        ">>\n"
+        "stream\n"
+      << pattern
+      << "endstream\n"
+        "endobj\n";
+
+    int patternObj = addXrefEntry(-1);
+    write(str);
+    currentPage->patterns.append(patternObj);
+    return patternObj;
+}
+
+/*!
+ * Adds an image to the pdf and return the pdf-object id. Returns -1 if adding the image failed.
+ */
+int QPdfEnginePrivate::addImage(const QImage &img, bool *bitmap, qint64 serial_no)
+{
+    if (img.isNull())
+        return -1;
+
+    int object = imageCache.value(serial_no);
+    if(object)
+        return object;
+
+    QImage image = img;
+    QImage::Format format = image.format();
+    if (image.depth() == 1 && *bitmap && img.colorTable().size() == 0) {
+        if (format == QImage::Format_MonoLSB)
+            image = image.convertToFormat(QImage::Format_Mono);
+        format = QImage::Format_Mono;
+    } else {
+        *bitmap = false;
+        if (format != QImage::Format_RGB32 && format != QImage::Format_ARGB32) {
+            image = image.convertToFormat(QImage::Format_ARGB32);
+            format = QImage::Format_ARGB32;
+        }
+    }
+
+    int w = image.width();
+    int h = image.height();
+    int d = image.depth();
+
+    if (format == QImage::Format_Mono) {
+        int bytesPerLine = (w + 7) >> 3;
+        QByteArray data;
+        data.resize(bytesPerLine * h);
+        char *rawdata = data.data();
+        for (int y = 0; y < h; ++y) {
+            memcpy(rawdata, image.scanLine(y), bytesPerLine);
+            rawdata += bytesPerLine;
+        }
+        object = writeImage(data, w, h, d, 0, 0);
+    } else {
+        QByteArray softMaskData;
+        bool dct = false;
+        QByteArray imageData;
+        bool hasAlpha = false;
+        bool hasMask = false;
+
+        if (QImageWriter::supportedImageFormats().contains("jpeg") && colorMode != QPrinter::GrayScale) {
+            QBuffer buffer(&imageData);
+            QImageWriter writer(&buffer, "jpeg");
+            writer.setQuality(94);
+            writer.write(image);
+            dct = true;
+
+            if (format != QImage::Format_RGB32) {
+                softMaskData.resize(w * h);
+                uchar *sdata = (uchar *)softMaskData.data();
+                for (int y = 0; y < h; ++y) {
+                    const QRgb *rgb = (const QRgb *)image.scanLine(y);
+                    for (int x = 0; x < w; ++x) {
+                        uchar alpha = qAlpha(*rgb);
+                        *sdata++ = alpha;
+                        hasMask |= (alpha < 255);
+                        hasAlpha |= (alpha != 0 && alpha != 255);
+                        ++rgb;
+                    }
+                }
+            }
+        } else {
+            imageData.resize(colorMode == QPrinter::GrayScale ? w * h : 3 * w * h);
+            uchar *data = (uchar *)imageData.data();
+            softMaskData.resize(w * h);
+            uchar *sdata = (uchar *)softMaskData.data();
+            for (int y = 0; y < h; ++y) {
+                const QRgb *rgb = (const QRgb *)image.scanLine(y);
+                if (colorMode == QPrinter::GrayScale) {
+                    for (int x = 0; x < w; ++x) {
+                        *(data++) = qGray(*rgb);
+                        uchar alpha = qAlpha(*rgb);
+                        *sdata++ = alpha;
+                        hasMask |= (alpha < 255);
+                        hasAlpha |= (alpha != 0 && alpha != 255);
+                        ++rgb;
+                    }
+                } else {
+                    for (int x = 0; x < w; ++x) {
+                        *(data++) = qRed(*rgb);
+                        *(data++) = qGreen(*rgb);
+                        *(data++) = qBlue(*rgb);
+                        uchar alpha = qAlpha(*rgb);
+                        *sdata++ = alpha;
+                        hasMask |= (alpha < 255);
+                        hasAlpha |= (alpha != 0 && alpha != 255);
+                        ++rgb;
+                    }
+                }
+            }
+            if (format == QImage::Format_RGB32)
+                hasAlpha = hasMask = false;
+        }
+        int maskObject = 0;
+        int softMaskObject = 0;
+        if (hasAlpha) {
+            softMaskObject = writeImage(softMaskData, w, h, 8, 0, 0);
+        } else if (hasMask) {
+            // dither the soft mask to 1bit and add it. This also helps PDF viewers
+            // without transparency support
+            int bytesPerLine = (w + 7) >> 3;
+            QByteArray mask(bytesPerLine * h, 0);
+            uchar *mdata = (uchar *)mask.data();
+            const uchar *sdata = (const uchar *)softMaskData.constData();
+            for (int y = 0; y < h; ++y) {
+                for (int x = 0; x < w; ++x) {
+                    if (*sdata)
+                        mdata[x>>3] |= (0x80 >> (x&7));
+                    ++sdata;
+                }
+                mdata += bytesPerLine;
+            }
+            maskObject = writeImage(mask, w, h, 1, 0, 0);
+        }
+        object = writeImage(imageData, w, h, colorMode == QPrinter::GrayScale ? 8 : 32,
+                            maskObject, softMaskObject, dct);
+    }
+    imageCache.insert(serial_no, object);
+    return object;
+}
+
+void QPdfEnginePrivate::drawTextItem(const QPointF &p, const QTextItemInt &ti)
+{
+    if (ti.charFormat.isAnchor()) {
+        qreal size = ti.fontEngine->fontDef.pixelSize;
+#ifdef Q_WS_WIN
+        if (ti.fontEngine->type() == QFontEngine::Win) {
+            QFontEngineWin *fe = static_cast<QFontEngineWin *>(ti.fontEngine);
+            size = fe->tm.tmHeight;
+        }
+#endif
+        int synthesized = ti.fontEngine->synthesized();
+        qreal stretch = synthesized & QFontEngine::SynthesizedStretch ? ti.fontEngine->fontDef.stretch/100. : 1.;
+
+        QTransform trans;
+        // Build text rendering matrix (Trm). We need it to map the text area to user
+        // space units on the PDF page.
+        trans = QTransform(size*stretch, 0, 0, size, 0, 0);
+        // Apply text matrix (Tm).
+        trans *= QTransform(1,0,0,-1,p.x(),p.y());
+        // Apply page displacement (Identity for first page).
+        trans *= stroker.matrix;
+        // Apply Current Transformation Matrix (CTM)
+        trans *= pageMatrix();
+        qreal x1, y1, x2, y2;
+        trans.map(0, 0, &x1, &y1);
+        trans.map(ti.width.toReal()/size, (ti.ascent.toReal()-ti.descent.toReal())/size, &x2, &y2);
+
+        uint annot = addXrefEntry(-1);
+#ifdef Q_DEBUG_PDF_LINKS
+        xprintf("<<\n/Type /Annot\n/Subtype /Link\n/Rect [%f %f %f %f]\n/Border [16 16 1]\n/A <<\n",
+#else
+        xprintf("<<\n/Type /Annot\n/Subtype /Link\n/Rect [%f %f %f %f]\n/Border [0 0 0]\n/A <<\n",
+#endif
+                static_cast<double>(x1),
+                static_cast<double>(y1),
+                static_cast<double>(x2),
+                static_cast<double>(y2));
+        xprintf("/Type /Action\n/S /URI\n/URI (%s)\n",
+                ti.charFormat.anchorHref().toLatin1().constData());
+        xprintf(">>\n>>\n");
+        xprintf("endobj\n");
+
+        if (!currentPage->annotations.contains(annot)) {
+            currentPage->annotations.append(annot);
+        }
+    }
+
+    QPdfBaseEnginePrivate::drawTextItem(p, ti);
+}
+
+QTransform QPdfEnginePrivate::pageMatrix() const
+{
+    qreal scale = 72./resolution;
+    QTransform tmp(scale, 0.0, 0.0, -scale, 0.0, height());
+    if (!fullPage) {
+        QRect r = pageRect();
+        tmp.translate(r.left(), r.top());
+    }
+    return tmp;
+}
+
+void QPdfEnginePrivate::newPage()
+{
+    if (currentPage && currentPage->pageSize.isEmpty())
+        currentPage->pageSize = QSize(width(), height());
+    writePage();
+
+    delete currentPage;
+    currentPage = new QPdfPage;
+    currentPage->pageSize = QSize(width(), height());
+    stroker.stream = currentPage;
+    pages.append(requestObject());
+
+    *currentPage << "/GSa gs /CSp cs /CSp CS\n"
+                 << QPdf::generateMatrix(pageMatrix())
+                 << "q q\n";
+}
+
+
+// For strings up to 10000 bytes only !
+void QPdfEnginePrivate::xprintf(const char* fmt, ...)
+{
+    if (!stream)
+        return;
+
+    const int msize = 10000;
+    char buf[msize];
+
+    va_list args;
+    va_start(args, fmt);
+    int bufsize = qvsnprintf(buf, msize, fmt, args);
+
+    Q_ASSERT(bufsize<msize);
+
+    va_end(args);
+
+    stream->writeRawData(buf, bufsize);
+    streampos += bufsize;
+}
+
+int QPdfEnginePrivate::writeCompressed(QIODevice *dev)
+{
+#ifndef QT_NO_COMPRESS
+    if (do_compress) {
+        int size = QPdfPage::chunkSize();
+        int sum = 0;
+        ::z_stream zStruct;
+        zStruct.zalloc = Z_NULL;
+        zStruct.zfree = Z_NULL;
+        zStruct.opaque = Z_NULL;
+        if (::deflateInit(&zStruct, Z_DEFAULT_COMPRESSION) != Z_OK) {
+            qWarning("QPdfStream::writeCompressed: Error in deflateInit()");
+            return sum;
+        }
+        zStruct.avail_in = 0;
+        QByteArray in, out;
+        out.resize(size);
+        while (!dev->atEnd() || zStruct.avail_in != 0) {
+            if (zStruct.avail_in == 0) {
+                in = dev->read(size);
+                zStruct.avail_in = in.size();
+                zStruct.next_in = reinterpret_cast<unsigned char*>(in.data());
+                if (in.size() <= 0) {
+                    qWarning("QPdfStream::writeCompressed: Error in read()");
+                    ::deflateEnd(&zStruct);
+                    return sum;
+                }
+            }
+            zStruct.next_out = reinterpret_cast<unsigned char*>(out.data());
+            zStruct.avail_out = out.size();
+            if (::deflate(&zStruct, 0) != Z_OK) {
+                qWarning("QPdfStream::writeCompressed: Error in deflate()");
+                ::deflateEnd(&zStruct);
+                return sum;
+            }
+            int written = out.size() - zStruct.avail_out;
+            stream->writeRawData(out.constData(), written);
+            streampos += written;
+            sum += written;
+        }
+        int ret;
+        do {
+            zStruct.next_out = reinterpret_cast<unsigned char*>(out.data());
+            zStruct.avail_out = out.size();
+            ret = ::deflate(&zStruct, Z_FINISH);
+            if (ret != Z_OK && ret != Z_STREAM_END) {
+                qWarning("QPdfStream::writeCompressed: Error in deflate()");
+                ::deflateEnd(&zStruct);
+                return sum;
+            }
+            int written = out.size() - zStruct.avail_out;
+            stream->writeRawData(out.constData(), written);
+            streampos += written;
+            sum += written;
+        } while (ret == Z_OK);
+
+        ::deflateEnd(&zStruct);
+
+        return sum;
+    } else
+#endif
+    {
+        QByteArray arr;
+        int sum = 0;
+        while (!dev->atEnd()) {
+            arr = dev->read(QPdfPage::chunkSize());
+            stream->writeRawData(arr.constData(), arr.size());
+            streampos += arr.size();
+            sum += arr.size();
+        }
+        return sum;
+    }
+}
+
+int QPdfEnginePrivate::writeCompressed(const char *src, int len)
+{
+#ifndef QT_NO_COMPRESS
+    if(do_compress) {
+        uLongf destLen = len + len/100 + 13; // zlib requirement
+        Bytef* dest = new Bytef[destLen];
+        if (Z_OK == ::compress(dest, &destLen, (const Bytef*) src, (uLongf)len)) {
+            stream->writeRawData((const char*)dest, destLen);
+        } else {
+            qWarning("QPdfStream::writeCompressed: Error in compress()");
+            destLen = 0;
+        }
+        delete [] dest;
+        len = destLen;
+    } else
+#endif
+    {
+        stream->writeRawData(src,len);
+    }
+    streampos += len;
+    return len;
+}
+
+int QPdfEnginePrivate::writeImage(const QByteArray &data, int width, int height, int depth,
+                                  int maskObject, int softMaskObject, bool dct)
+{
+    int image = addXrefEntry(-1);
+    xprintf("<<\n"
+            "/Type /XObject\n"
+            "/Subtype /Image\n"
+            "/Width %d\n"
+            "/Height %d\n", width, height);
+
+    if (depth == 1) {
+        xprintf("/ImageMask true\n"
+                "/Decode [1 0]\n");
+    } else {
+        xprintf("/BitsPerComponent 8\n"
+                "/ColorSpace %s\n", (depth == 32) ? "/DeviceRGB" : "/DeviceGray");
+    }
+    if (maskObject > 0)
+        xprintf("/Mask %d 0 R\n", maskObject);
+    if (softMaskObject > 0)
+        xprintf("/SMask %d 0 R\n", softMaskObject);
+
+    int lenobj = requestObject();
+    xprintf("/Length %d 0 R\n", lenobj);
+    if (interpolateImages)
+        xprintf("/Interpolate true\n");
+    int len = 0;
+    if (dct) {
+        //qDebug() << "DCT";
+        xprintf("/Filter /DCTDecode\n>>\nstream\n");
+        write(data);
+        len = data.length();
+    } else {
+        if (do_compress)
+            xprintf("/Filter /FlateDecode\n>>\nstream\n");
+        else
+            xprintf(">>\nstream\n");
+        len = writeCompressed(data);
+    }
+    xprintf("endstream\n"
+            "endobj\n");
+    addXrefEntry(lenobj);
+    xprintf("%d\n"
+            "endobj\n", len);
+    return image;
+}
+
+
+void QPdfEnginePrivate::writeHeader()
+{
+    addXrefEntry(0,false);
+
+    xprintf("%%PDF-1.4\n");
+
+    writeInfo();
+
+    catalog = addXrefEntry(-1);
+    pageRoot = requestObject();
+    xprintf("<<\n"
+            "/Type /Catalog\n"
+            "/Pages %d 0 R\n"
+            ">>\n"
+            "endobj\n", pageRoot);
+
+    // graphics state
+    graphicsState = addXrefEntry(-1);
+    xprintf("<<\n"
+            "/Type /ExtGState\n"
+            "/SA true\n"
+            "/SM 0.02\n"
+            "/ca 1.0\n"
+            "/CA 1.0\n"
+            "/AIS false\n"
+            "/SMask /None"
+            ">>\n"
+            "endobj\n");
+
+    // color space for pattern
+    patternColorSpace = addXrefEntry(-1);
+    xprintf("[/Pattern /DeviceRGB]\n"
+            "endobj\n");
+}
+
+void QPdfEnginePrivate::writeInfo()
+{
+    info = addXrefEntry(-1);
+    xprintf("<<\n/Title ");
+    printString(title);
+    xprintf("\n/Creator ");
+    printString(creator);
+    xprintf("\n/Producer ");
+    printString(QString::fromLatin1("Qt " QT_VERSION_STR " (C) 2011 Nokia Corporation and/or its subsidiary(-ies)"));
+    QDateTime now = QDateTime::currentDateTime().toUTC();
+    QTime t = now.time();
+    QDate d = now.date();
+    xprintf("\n/CreationDate (D:%d%02d%02d%02d%02d%02d)\n",
+            d.year(),
+            d.month(),
+            d.day(),
+            t.hour(),
+            t.minute(),
+            t.second());
+    xprintf(">>\n"
+            "endobj\n");
+}
+
+void QPdfEnginePrivate::writePageRoot()
+{
+    addXrefEntry(pageRoot);
+
+    xprintf("<<\n"
+            "/Type /Pages\n"
+            "/Kids \n"
+            "[\n");
+    int size = pages.size();
+    for (int i = 0; i < size; ++i)
+        xprintf("%d 0 R\n", pages[i]);
+    xprintf("]\n");
+
+    //xprintf("/Group <</S /Transparency /I true /K false>>\n");
+    xprintf("/Count %d\n", pages.size());
+
+    xprintf("/ProcSet [/PDF /Text /ImageB /ImageC]\n"
+            ">>\n"
+            "endobj\n");
+}
+
+
+void QPdfEnginePrivate::embedFont(QFontSubset *font)
+{
+    //qDebug() << "embedFont" << font->object_id;
+    int fontObject = font->object_id;
+    QByteArray fontData = font->toTruetype();
+#ifdef FONT_DUMP
+    static int i = 0;
+    QString fileName("font%1.ttf");
+    fileName = fileName.arg(i++);
+    QFile ff(fileName);
+    ff.open(QFile::WriteOnly);
+    ff.write(fontData);
+    ff.close();
+#endif
+
+    int fontDescriptor = requestObject();
+    int fontstream = requestObject();
+    int cidfont = requestObject();
+    int toUnicode = requestObject();
+
+    QFontEngine::Properties properties = font->fontEngine->properties();
+
+    {
+        qreal scale = 1000/properties.emSquare.toReal();
+        addXrefEntry(fontDescriptor);
+        QByteArray descriptor;
+        QPdf::ByteStream s(&descriptor);
+        s << "<< /Type /FontDescriptor\n"
+            "/FontName /Q";
+        int tag = fontDescriptor;
+        for (int i = 0; i < 5; ++i) {
+            s << (char)('A' + (tag % 26));
+            tag /= 26;
+        }
+        s <<  '+' << properties.postscriptName << "\n"
+            "/Flags " << 4 << "\n"
+            "/FontBBox ["
+          << properties.boundingBox.x()*scale
+          << -(properties.boundingBox.y() + properties.boundingBox.height())*scale
+          << (properties.boundingBox.x() + properties.boundingBox.width())*scale
+          << -properties.boundingBox.y()*scale  << "]\n"
+            "/ItalicAngle " << properties.italicAngle.toReal() << "\n"
+            "/Ascent " << properties.ascent.toReal()*scale << "\n"
+            "/Descent " << -properties.descent.toReal()*scale << "\n"
+            "/CapHeight " << properties.capHeight.toReal()*scale << "\n"
+            "/StemV " << properties.lineWidth.toReal()*scale << "\n"
+            "/FontFile2 " << fontstream << "0 R\n"
+            ">> endobj\n";
+        write(descriptor);
+    }
+    {
+        addXrefEntry(fontstream);
+        QByteArray header;
+        QPdf::ByteStream s(&header);
+
+        int length_object = requestObject();
+        s << "<<\n"
+            "/Length1 " << fontData.size() << "\n"
+            "/Length " << length_object << "0 R\n";
+        if (do_compress)
+            s << "/Filter /FlateDecode\n";
+        s << ">>\n"
+            "stream\n";
+        write(header);
+        int len = writeCompressed(fontData);
+        write("endstream\n"
+              "endobj\n");
+        addXrefEntry(length_object);
+        xprintf("%d\n"
+                "endobj\n", len);
+    }
+    {
+        addXrefEntry(cidfont);
+        QByteArray cid;
+        QPdf::ByteStream s(&cid);
+        s << "<< /Type /Font\n"
+            "/Subtype /CIDFontType2\n"
+            "/BaseFont /" << properties.postscriptName << "\n"
+            "/CIDSystemInfo << /Registry (Adobe) /Ordering (Identity) /Supplement 0 >>\n"
+            "/FontDescriptor " << fontDescriptor << "0 R\n"
+            "/CIDToGIDMap /Identity\n"
+          << font->widthArray() <<
+            ">>\n"
+            "endobj\n";
+        write(cid);
+    }
+    {
+        addXrefEntry(toUnicode);
+        QByteArray touc = font->createToUnicodeMap();
+        xprintf("<< /Length %d >>\n"
+                "stream\n", touc.length());
+        write(touc);
+        write("endstream\n"
+              "endobj\n");
+    }
+    {
+        addXrefEntry(fontObject);
+        QByteArray font;
+        QPdf::ByteStream s(&font);
+        s << "<< /Type /Font\n"
+            "/Subtype /Type0\n"
+            "/BaseFont /" << properties.postscriptName << "\n"
+            "/Encoding /Identity-H\n"
+            "/DescendantFonts [" << cidfont << "0 R]\n"
+            "/ToUnicode " << toUnicode << "0 R"
+            ">>\n"
+            "endobj\n";
+        write(font);
+    }
+}
+
+
+void QPdfEnginePrivate::writeFonts()
+{
+    for (QHash<QFontEngine::FaceId, QFontSubset *>::iterator it = fonts.begin(); it != fonts.end(); ++it) {
+        embedFont(*it);
+        delete *it;
+    }
+    fonts.clear();
+}
+
+void QPdfEnginePrivate::writePage()
+{
+    if (pages.empty())
+        return;
+
+    *currentPage << "Q Q\n";
+
+    uint pageStream = requestObject();
+    uint pageStreamLength = requestObject();
+    uint resources = requestObject();
+    uint annots = requestObject();
+
+    addXrefEntry(pages.last());
+    xprintf("<<\n"
+            "/Type /Page\n"
+            "/Parent %d 0 R\n"
+            "/Contents %d 0 R\n"
+            "/Resources %d 0 R\n"
+            "/Annots %d 0 R\n"
+            "/MediaBox [0 0 %d %d]\n"
+            ">>\n"
+            "endobj\n",
+            pageRoot, pageStream, resources, annots,
+            // make sure we use the pagesize from when we started the page, since the user may have changed it
+            currentPage->pageSize.width(), currentPage->pageSize.height());
+
+    addXrefEntry(resources);
+    xprintf("<<\n"
+            "/ColorSpace <<\n"
+            "/PCSp %d 0 R\n"
+            "/CSp /DeviceRGB\n"
+            "/CSpg /DeviceGray\n"
+            ">>\n"
+            "/ExtGState <<\n"
+            "/GSa %d 0 R\n",
+            patternColorSpace, graphicsState);
+
+    for (int i = 0; i < currentPage->graphicStates.size(); ++i)
+        xprintf("/GState%d %d 0 R\n", currentPage->graphicStates.at(i), currentPage->graphicStates.at(i));
+    xprintf(">>\n");
+
+    xprintf("/Pattern <<\n");
+    for (int i = 0; i < currentPage->patterns.size(); ++i)
+        xprintf("/Pat%d %d 0 R\n", currentPage->patterns.at(i), currentPage->patterns.at(i));
+    xprintf(">>\n");
+
+    xprintf("/Font <<\n");
+    for (int i = 0; i < currentPage->fonts.size();++i)
+        xprintf("/F%d %d 0 R\n", currentPage->fonts[i], currentPage->fonts[i]);
+    xprintf(">>\n");
+
+    xprintf("/XObject <<\n");
+    for (int i = 0; i<currentPage->images.size(); ++i) {
+        xprintf("/Im%d %d 0 R\n", currentPage->images.at(i), currentPage->images.at(i));
+    }
+    xprintf(">>\n");
+
+    xprintf(">>\n"
+            "endobj\n");
+
+    addXrefEntry(annots);
+    xprintf("[ ");
+    for (int i = 0; i<currentPage->annotations.size(); ++i) {
+        xprintf("%d 0 R ", currentPage->annotations.at(i));
+    }
+    xprintf("]\nendobj\n");
+
+    addXrefEntry(pageStream);
+    xprintf("<<\n"
+            "/Length %d 0 R\n", pageStreamLength); // object number for stream length object
+    if (do_compress)
+        xprintf("/Filter /FlateDecode\n");
+
+    xprintf(">>\n");
+    xprintf("stream\n");
+    QIODevice *content = currentPage->stream();
+    int len = writeCompressed(content);
+    xprintf("endstream\n"
+            "endobj\n");
+
+    addXrefEntry(pageStreamLength);
+    xprintf("%d\nendobj\n",len);
+}
+
+void QPdfEnginePrivate::writeTail()
+{
+    writePage();
+    writeFonts();
+    writePageRoot();
+    addXrefEntry(xrefPositions.size(),false);
+    xprintf("xref\n"
+            "0 %d\n"
+            "%010d 65535 f \n", xrefPositions.size()-1, xrefPositions[0]);
+
+    for (int i = 1; i < xrefPositions.size()-1; ++i)
+        xprintf("%010d 00000 n \n", xrefPositions[i]);
+
+    xprintf("trailer\n"
+            "<<\n"
+            "/Size %d\n"
+            "/Info %d 0 R\n"
+            "/Root %d 0 R\n"
+            ">>\n"
+            "startxref\n%d\n"
+            "%%%%EOF\n",
+            xrefPositions.size()-1, info, catalog, xrefPositions.last());
+}
+
+int QPdfEnginePrivate::addXrefEntry(int object, bool printostr)
+{
+    if (object < 0)
+        object = requestObject();
+
+    if (object>=xrefPositions.size())
+        xrefPositions.resize(object+1);
+
+    xrefPositions[object] = streampos;
+    if (printostr)
+        xprintf("%d 0 obj\n",object);
+
+    return object;
+}
+
+void QPdfEnginePrivate::printString(const QString &string) {
+    // The 'text string' type in PDF is encoded either as PDFDocEncoding, or
+    // Unicode UTF-16 with a Unicode byte order mark as the first character
+    // (0xfeff), with the high-order byte first.
+    QByteArray array("(\xfe\xff");
+    const ushort *utf16 = string.utf16();
+    
+    for (int i=0; i < string.size(); ++i) {
+        char part[2] = {char((*(utf16 + i)) >> 8), char((*(utf16 + i)) & 0xff)};
+        for(int j=0; j < 2; ++j) {
+            if (part[j] == '(' || part[j] == ')' || part[j] == '\\')
+                array.append('\\');
+            array.append(part[j]);
+        }
+    }
+    array.append(")");
+    write(array);
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_PRINTER
diff --git a/src/gui/painting/qprintengine_pdf_p.h b/src/gui/painting/qprintengine_pdf_p.h
new file mode 100644
index 0000000000..13171ae501
--- /dev/null
+++ b/src/gui/painting/qprintengine_pdf_p.h
@@ -0,0 +1,195 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPRINTENGINE_PDF_P_H
+#define QPRINTENGINE_PDF_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "QtGui/qprintengine.h"
+
+#ifndef QT_NO_PRINTER
+#include "QtCore/qmap.h"
+#include "QtGui/qmatrix.h"
+#include "QtCore/qstring.h"
+#include "QtCore/qvector.h"
+#include "QtGui/qpaintengine.h"
+#include "QtGui/qpainterpath.h"
+#include "QtCore/qdatastream.h"
+
+#include "private/qfontengine_p.h"
+#include "private/qpdf_p.h"
+#include "private/qpaintengine_p.h"
+
+QT_BEGIN_NAMESPACE
+
+// #define USE_NATIVE_GRADIENTS
+
+class QImage;
+class QDataStream;
+class QPen;
+class QPointF;
+class QRegion;
+class QFile;
+class QPdfEngine;
+
+class QPdfEnginePrivate;
+
+class QPdfEngine : public QPdfBaseEngine
+{
+    Q_DECLARE_PRIVATE(QPdfEngine)
+public:
+    QPdfEngine(QPrinter::PrinterMode m);
+    virtual ~QPdfEngine();
+
+    // reimplementations QPaintEngine
+    bool begin(QPaintDevice *pdev);
+    bool end();
+    void drawPixmap (const QRectF & rectangle, const QPixmap & pixmap, const QRectF & sr);
+    void drawImage(const QRectF &r, const QImage &pm, const QRectF &sr,
+                   Qt::ImageConversionFlags flags = Qt::AutoColor);
+    void drawTiledPixmap (const QRectF & rectangle, const QPixmap & pixmap, const QPointF & point);
+
+    Type type() const;
+    // end reimplementations QPaintEngine
+
+    // reimplementations QPrintEngine
+    bool abort() {return false;}
+    bool newPage();
+    QPrinter::PrinterState printerState() const {return state;}
+    // end reimplementations QPrintEngine
+
+    void setBrush();
+
+    // ### unused, should have something for this in QPrintEngine
+    void setAuthor(const QString &author);
+    QString author() const;
+
+    void setDevice(QIODevice* dev);
+
+private:
+    Q_DISABLE_COPY(QPdfEngine)
+
+    QPrinter::PrinterState state;
+};
+
+class QPdfEnginePrivate : public QPdfBaseEnginePrivate
+{
+    Q_DECLARE_PUBLIC(QPdfEngine)
+public:
+    QPdfEnginePrivate(QPrinter::PrinterMode m);
+    ~QPdfEnginePrivate();
+
+    void newPage();
+
+    int width() const {
+        QRect r = paperRect();
+        return qRound(r.width()*72./resolution);
+    }
+    int height() const {
+        QRect r = paperRect();
+        return qRound(r.height()*72./resolution);
+    }
+
+    void writeHeader();
+    void writeTail();
+
+    int addImage(const QImage &image, bool *bitmap, qint64 serial_no);
+    int addConstantAlphaObject(int brushAlpha, int penAlpha = 255);
+    int addBrushPattern(const QTransform &matrix, bool *specifyColor, int *gStateObject);
+
+    void drawTextItem(const QPointF &p, const QTextItemInt &ti);
+
+    QTransform pageMatrix() const;
+
+private:
+    Q_DISABLE_COPY(QPdfEnginePrivate)
+
+#ifdef USE_NATIVE_GRADIENTS
+    int gradientBrush(const QBrush &b, const QMatrix &matrix, int *gStateObject);
+#endif
+
+    void writeInfo();
+    void writePageRoot();
+    void writeFonts();
+    void embedFont(QFontSubset *font);
+
+    QVector<int> xrefPositions;
+    QDataStream* stream;
+    int streampos;
+
+    int writeImage(const QByteArray &data, int width, int height, int depth,
+                   int maskObject, int softMaskObject, bool dct = false);
+    void writePage();
+
+    int addXrefEntry(int object, bool printostr = true);
+    void printString(const QString &string);
+    void xprintf(const char* fmt, ...);
+    inline void write(const QByteArray &data) {
+        stream->writeRawData(data.constData(), data.size());
+        streampos += data.size();
+    }
+
+    int writeCompressed(const char *src, int len);
+    inline int writeCompressed(const QByteArray &data) { return writeCompressed(data.constData(), data.length()); }
+    int writeCompressed(QIODevice *dev);
+
+    // various PDF objects
+    int pageRoot, catalog, info, graphicsState, patternColorSpace;
+    QVector<uint> pages;
+    QHash<qint64, uint> imageCache;
+    QHash<QPair<uint, uint>, uint > alphaCache;
+};
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_PRINTER
+
+#endif // QPRINTENGINE_PDF_P_H
diff --git a/src/gui/painting/qprintengine_ps.cpp b/src/gui/painting/qprintengine_ps.cpp
new file mode 100644
index 0000000000..d55d532fdb
--- /dev/null
+++ b/src/gui/painting/qprintengine_ps.cpp
@@ -0,0 +1,972 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qplatformdefs.h"
+
+#include <private/qprintengine_ps_p.h>
+#include <private/qpainter_p.h>
+#include <private/qfontengine_p.h>
+#include <private/qpaintengine_p.h>
+#include <private/qpdf_p.h>
+
+#ifndef QT_NO_PRINTER
+
+#include "qprinter.h"
+#include "qpainter.h"
+#include "qapplication.h"
+#include "qpixmap.h"
+#include "qimage.h"
+#include "qdatetime.h"
+#include "qstring.h"
+#include "qbytearray.h"
+#include "qhash.h"
+#include "qbuffer.h"
+#include "qsettings.h"
+#include "qmap.h"
+#include "qbitmap.h"
+#include "qregion.h"
+#include "qimagewriter.h"
+#include <private/qpainterpath_p.h>
+#include <qdebug.h>
+#include <private/qdrawhelper_p.h>
+#include <private/qmutexpool_p.h>
+
+#ifndef Q_OS_WIN
+#include <unistd.h>
+#endif
+#include <stdlib.h>
+#include <limits.h>
+
+QT_BEGIN_NAMESPACE
+
+static bool qt_gen_epsf = false;
+
+void qt_generate_epsf(bool b)
+{
+    qt_gen_epsf = b;
+}
+
+static const char *const ps_header =
+"/BD{bind def}bind def/d2{dup dup}BD/ED{exch def}BD/D0{0 ED}BD/F{setfont}BD\n"
+"/RL{rlineto}BD/CM{currentmatrix}BD/SM{setmatrix}BD/TR{translate}BD/SD\n"
+"{setdash}BD/SC{aload pop setrgbcolor}BD/CR{currentfile read pop}BD/i{index}\n"
+"BD/scs{setcolorspace}BD/DB{dict dup begin}BD/DE{end def}BD/ie{ifelse}BD/gs\n"
+"{gsave}BD/gr{grestore}BD/w{setlinewidth}BD/d{setdash}BD/J{setlinecap}BD/j\n"
+"{setlinejoin}BD/scn{3 array astore/BCol exch def}BD/SCN{3 array astore/PCol\n"
+"exch def}BD/cm{6 array astore concat}BD/m{moveto}BD/l{lineto}BD/c{curveto}BD\n"
+"/h{closepath}BD/W{clip}BD/W*{eoclip}BD/n{newpath}BD/q{gsave 10 dict begin}BD\n"
+"/Q{end grestore}BD/re{4 2 roll m dup 0 exch RL exch 0 RL 0 exch neg RL h}BD\n"
+"/S{gs PCol SC stroke gr n}BD/BT{gsave 10 dict begin/_m matrix CM def BCol\n"
+"SC}BD/ET{end grestore}BD/Tf{/_fs ED findfont[_fs 0 0 _fs 0 0]makefont F}BD\n"
+"/Tm{6 array astore concat}BD/Td{translate}BD/Tj{0 0 m show}BD/BDC{pop pop}BD\n"
+"/EMC{}BD/BSt 0 def/WFi false def/BCol[1 1 1]def/PCol[0 0 0]def/BDArr[0.94\n"
+"0.88 0.63 0.50 0.37 0.12 0.06]def/level3{/languagelevel where{pop\n"
+"languagelevel 3 ge}{false}ie}BD/QCIgray D0/QCIcolor D0/QCIindex D0/QCI{\n"
+"/colorimage where{pop false 3 colorimage}{exec/QCIcolor ED/QCIgray QCIcolor\n"
+"length 3 idiv string def 0 1 QCIcolor length 3 idiv 1 sub{/QCIindex ED/_x\n"
+"QCIindex 3 mul def QCIgray QCIindex QCIcolor _x get 0.30 mul QCIcolor _x 1\n"
+"add get 0.59 mul QCIcolor _x 2 add get 0.11 mul add add cvi put}for QCIgray\n"
+"image}ie}BD/di{gs TR 1 i 1 eq{pop pop false 3 1 roll BCol SC imagemask}{dup\n"
+"false ne{level3}{false}ie{/_ma ED 8 eq{/_dc[0 1]def/DeviceGray}{/_dc[0 1 0 1\n"
+"0 1]def/DeviceRGB}ie scs/_im ED/_mt ED/_h ED/_w ED <</ImageType 3/DataDict\n"
+"<</ImageType 1/Width _w/Height _h/ImageMatrix _mt/DataSource _im\n"
+"/BitsPerComponent 8/Decode _dc >>/MaskDict <</ImageType 1/Width _w/Height _h\n"
+"/ImageMatrix _mt/DataSource _ma/BitsPerComponent 1/Decode[0 1]>>\n"
+"/InterleaveType 3 >> image}{pop 8 4 1 roll 8 eq{image}{QCI}ie}ie}ie gr}BD/BF\n"
+"{gs BSt 1 eq{BCol SC WFi{fill}{eofill}ie}if BSt 2 ge BSt 8 le and{BDArr BSt\n"
+"2 sub get/_sc ED BCol{1. exch sub _sc mul 1. exch sub}forall 3 array astore\n"
+"SC WFi{fill}{eofill}ie}if BSt 9 ge BSt 14 le and{WFi{W}{W*}ie pathbbox 3 i 3\n"
+"i TR 4 2 roll 3 2 roll exch sub/_h ED sub/_w ED BCol SC 0.3 w n BSt 9 eq BSt\n"
+"11 eq or{0 4 _h{dup 0 exch m _w exch l}for}if BSt 10 eq BSt 11 eq or{0 4 _w{\n"
+"dup 0 m _h l}for}if BSt 12 eq BSt 14 eq or{_w _h gt{0 6 _w _h add{dup 0 m _h\n"
+"sub _h l}for}{0 6 _w _h add{dup 0 exch m _w sub _w exch l}for}ie}if BSt 13\n"
+"eq BSt 14 eq or{_w _h gt{0 6 _w _h add{dup _h m _h sub 0 l}for}{0 6 _w _h\n"
+"add{dup _w exch m _w sub 0 exch l}for}ie}if stroke}if BSt 15 eq{}if BSt 24\n"
+"eq{}if gr}BD/f{/WFi true def BF n}BD/f*{/WFi false def BF n}BD/B{/WFi true\n"
+"def BF S n}BD/B*{/WFi false def BF S n}BD/QI{/C save def pageinit q n}BD/QP{\n"
+"Q C restore showpage}BD/SPD{/setpagedevice where{<< 3 1 roll >>\n"
+"setpagedevice}{pop pop}ie}BD/T1AddMapping{10 dict begin/glyphs ED/fnt ED\n"
+"/current fnt/NumGlyphs get def/CMap fnt/CMap get def 0 1 glyphs length 1 sub\n"
+"{glyphs exch get/gn ED current dup 256 mod/min ED 256 idiv/maj ED CMap dup\n"
+"maj get dup null eq{pop 256 array 0 1 255{1 i exch/.notdef put}for}if dup\n"
+"min gn put maj exch put/current current 1 add def}for fnt/CMap CMap put fnt\n"
+"/NumGlyphs current put end}def/T1AddGlyphs{10 dict begin/glyphs ED/fnt ED\n"
+"/current fnt/NumGlyphs get def/CMap fnt/CMap get def/CharStrings fnt\n"
+"/CharStrings get def 0 1 glyphs length 2 idiv 1 sub{2 mul dup glyphs exch\n"
+"get/gn ED 1 add glyphs exch get/cs ED current dup 256 mod/min ED 256 idiv\n"
+"/maj ED CMap dup maj get dup null eq{pop 256 array 0 1 255{1 i exch/.notdef\n"
+"put}for}if dup min gn put maj exch put CharStrings gn cs put/current current\n"
+"1 add def}for fnt/CharStrings CharStrings put fnt/CMap CMap put fnt\n"
+"/NumGlyphs current put end}def/StringAdd{1 i length 1 i length add string 3\n"
+"1 roll 2 i 0 3 i putinterval 2 i 2 i length 2 i putinterval pop pop}def\n"
+"/T1Setup{10 dict begin dup/FontName ED (-Base) StringAdd cvx cvn/Font ED\n"
+"/MaxPage Font/NumGlyphs get 1 sub 256 idiv def/FDepVector MaxPage 1 add\n"
+"array def/Encoding MaxPage 1 add array def 0 1 MaxPage{dup Encoding exch dup\n"
+"put dup/Page ED FontName (-) StringAdd exch 20 string cvs StringAdd cvn Font\n"
+"0 dict copy d2/CMap get Page get/Encoding exch put definefont FDepVector\n"
+"exch Page exch put}for FontName cvn <</FontType 0/FMapType 2/FontMatrix[1 0\n"
+"0 1 0 0]/Encoding Encoding/FDepVector FDepVector >> definefont pop end}def\n";
+
+
+
+// ------------------------------End of static data ----------------------------------
+
+// make sure DSC comments are not longer than 255 chars per line.
+static QByteArray wrapDSC(const QByteArray &str)
+{
+    QByteArray dsc = str.simplified();
+    const int wrapAt = 254;
+    QByteArray wrapped;
+    if (dsc.length() < wrapAt)
+        wrapped = dsc;
+    else {
+        wrapped = dsc.left(wrapAt);
+        QByteArray tmp = dsc.mid(wrapAt);
+        while (tmp.length() > wrapAt-3) {
+            wrapped += "\n%%+" + tmp.left(wrapAt-3);
+            tmp = tmp.mid(wrapAt-3);
+        }
+        wrapped += "\n%%+" + tmp;
+    }
+    return wrapped + '\n';
+}
+
+// ----------------------------- Internal class declarations -----------------------------
+
+QPSPrintEnginePrivate::QPSPrintEnginePrivate(QPrinter::PrinterMode m)
+    : QPdfBaseEnginePrivate(m),
+      printerState(QPrinter::Idle), hugeDocument(false), headerDone(false)
+{
+    useAlphaEngine = true;
+    postscript = true;
+
+    firstPage = true;
+
+#ifndef QT_NO_SETTINGS
+    QSettings settings(QSettings::UserScope, QLatin1String("Trolltech"));
+    settings.beginGroup(QLatin1String("Qt"));
+    embedFonts = settings.value(QLatin1String("embedFonts"), true).toBool();
+#else
+    embedFonts = true;
+#endif
+}
+
+QPSPrintEnginePrivate::~QPSPrintEnginePrivate()
+{
+}
+
+QT_BEGIN_INCLUDE_NAMESPACE
+#include <qdebug.h>
+QT_END_INCLUDE_NAMESPACE
+
+static void ps_r7(QPdf::ByteStream& stream, const char * s, int l)
+{
+    int i = 0;
+    uchar line[84];
+    int col = 0;
+
+    while(i < l) {
+        line[col++] = s[i++];
+        if (i < l - 1 && col >= 76) {
+            line[col++] = '\n';
+            line[col++] = '\0';
+            stream << (const char *)line;
+            col = 0;
+        }
+    }
+    if (col > 0) {
+        while((col&3) != 0)
+            line[col++] = '%'; // use a comment as padding
+        line[col++] = '\n';
+        line[col++] = '\0';
+        stream << (const char *)line;
+    }
+}
+
+static QByteArray runlengthEncode(const QByteArray &input)
+{
+    if (!input.length())
+        return input;
+
+    const char *data = input.constData();
+
+    QByteArray out;
+    int start = 0;
+    char last = *data;
+
+    enum State {
+        Undef,
+        Equal,
+        Diff
+    };
+    State state = Undef;
+
+    int i = 1;
+    int written = 0;
+    while (1) {
+        bool flush = (i == input.size());
+        if (!flush) {
+            switch(state) {
+            case Undef:
+                state = (last == data[i]) ? Equal : Diff;
+                break;
+            case Equal:
+                if (data[i] != last)
+                    flush = true;
+                break;
+            case Diff:
+                if (data[i] == last) {
+                    --i;
+                    flush = true;
+                }
+            }
+        }
+        if (flush || i - start == 128) {
+            int size = i - start;
+            if (state == Equal) {
+                out.append((char)(uchar)(257-size));
+                out.append(last);
+                written += size;
+            } else {
+                out.append((char)(uchar)size-1);
+                while (start < i)
+                    out.append(data[start++]);
+                written += size;
+            }
+            state = Undef;
+            start = i;
+            if (i == input.size())
+                break;
+        }
+        last = data[i];
+        ++i;
+    };
+    out.append((char)(uchar)128);
+    return out;
+}
+
+enum format {
+    Raw,
+    Runlength,
+    DCT
+};
+static const char *const filters[3] = {
+    " ",
+    "/RunLengthDecode filter ",
+    "/DCTDecode filter "
+};
+
+static QByteArray compressHelper(const QImage &image, bool gray, int *format)
+{
+    // we can't use premultiplied here
+    QByteArray pixelData;
+    int depth = image.depth();
+
+    Q_ASSERT(image.format() != QImage::Format_ARGB32_Premultiplied);
+
+    if (depth != 1 && !gray && QImageWriter::supportedImageFormats().contains("jpeg")) {
+        QBuffer buffer(&pixelData);
+        QImageWriter writer(&buffer, "jpeg");
+        writer.setQuality(94);
+        writer.write(image);
+        *format = DCT;
+    } else {
+        int width = image.width();
+        int height = image.height();
+        int size = width*height;
+
+        if (depth == 1)
+            size = (width+7)/8*height;
+        else if (!gray)
+            size = size*3;
+
+        pixelData.resize(size);
+        uchar *pixel = (uchar *)pixelData.data();
+        int i = 0;
+        if (depth == 1) {
+            QImage::Format format = image.format();
+            memset(pixel, 0xff, size);
+            for(int y=0; y < height; y++) {
+                const uchar * s = image.scanLine(y);
+                for(int x=0; x < width; x++) {
+                    // need to copy bit for bit...
+                    bool b = (format == QImage::Format_MonoLSB) ?
+                             (*(s + (x >> 3)) >> (x & 7)) & 1 :
+                             (*(s + (x >> 3)) << (x & 7)) & 0x80 ;
+                    if (b)
+                        pixel[i >> 3] ^= (0x80 >> (i & 7));
+                    i++;
+                }
+                // we need to align to 8 bit here
+                i = (i+7) & 0xffffff8;
+            }
+        } else if (depth == 8) {
+            for(int y=0; y < height; y++) {
+                const uchar * s = image.scanLine(y);
+                for(int x=0; x < width; x++) {
+                    QRgb rgb = image.color(s[x]);
+                    if (gray) {
+                        pixel[i] = (unsigned char) qGray(rgb);
+                        i++;
+                    } else {
+                        pixel[i] = (unsigned char) qRed(rgb);
+                        pixel[i+1] = (unsigned char) qGreen(rgb);
+                        pixel[i+2] = (unsigned char) qBlue(rgb);
+                        i += 3;
+                    }
+                }
+            }
+        } else {
+            for(int y=0; y < height; y++) {
+                QRgb * s = (QRgb*)(image.scanLine(y));
+                for(int x=0; x < width; x++) {
+                    QRgb rgb = (*s++);
+                    if (gray) {
+                        pixel[i] = (unsigned char) qGray(rgb);
+                        i++;
+                    } else {
+                        pixel[i] = (unsigned char) qRed(rgb);
+                        pixel[i+1] = (unsigned char) qGreen(rgb);
+                        pixel[i+2] = (unsigned char) qBlue(rgb);
+                        i += 3;
+                    }
+                }
+            }
+        }
+        *format = Raw;
+        if (depth == 1) {
+            pixelData = runlengthEncode(pixelData);
+            *format = Runlength;
+        }
+    }
+    QByteArray outarr = QPdf::ascii85Encode(pixelData);
+    return outarr;
+}
+
+void QPSPrintEnginePrivate::drawImageHelper(qreal x, qreal y, qreal w, qreal h, const QImage &img,
+                                            const QImage &mask, bool gray, qreal scaleX, qreal scaleY)
+{
+    Q_UNUSED(h);
+    Q_UNUSED(w);
+    int width = img.width();
+    int height = img.height();
+
+    QByteArray out;
+    int size = 0;
+    const char *bits;
+
+    if (!mask.isNull()) {
+        int format;
+        out = compressHelper(mask, true, &format);
+        size = (width+7)/8*height;
+        *currentPage << "/mask currentfile/ASCII85Decode filter"
+                     << filters[format]
+                     << size << " string readstring\n";
+        ps_r7(*currentPage, out, out.size());
+        *currentPage << " pop def\n";
+    }
+    if (img.depth() == 1) {
+        size = (width+7)/8*height;
+        bits = "1 ";
+    } else if (gray) {
+        size = width*height;
+        bits = "8 ";
+    } else {
+        size = width*height*3;
+        bits = "24 ";
+    }
+
+    int format;
+    out = compressHelper(img, gray, &format);
+    *currentPage << "/sl currentfile/ASCII85Decode filter"
+                 << filters[format]
+                 << size << " string readstring\n";
+    ps_r7(*currentPage, out, out.size());
+    *currentPage << " pop def\n";
+    *currentPage << width << ' ' << height << '[' << scaleX << " 0 0 " << scaleY << " 0 0]sl "
+                 << bits << (!mask.isNull() ? "mask " : "false ")
+                 << x << ' ' << y << " di\n";
+}
+
+
+void QPSPrintEnginePrivate::drawImage(qreal x, qreal y, qreal w, qreal h,
+                                      const QImage &image, const QImage &msk)
+{
+    if (!w || !h || image.isNull()) return;
+
+    QImage img(image);
+    QImage mask(msk);
+
+    if (image.format() == QImage::Format_ARGB32_Premultiplied)
+        img = image.convertToFormat(QImage::Format_ARGB32);
+
+    if (!msk.isNull() && msk.format() == QImage::Format_ARGB32_Premultiplied)
+        mask = msk.convertToFormat(QImage::Format_ARGB32);
+
+    int width  = img.width();
+    int height = img.height();
+    qreal scaleX = width/w;
+    qreal scaleY = height/h;
+
+    bool gray = (colorMode == QPrinter::GrayScale) || img.allGray();
+    int splitSize = 21830 * (gray ? 3 : 1);
+    if (width * height > splitSize) { // 65535/3, tolerance for broken printers
+        int images, subheight;
+        images = (width * height + splitSize - 1) / splitSize;
+        subheight = (height + images-1) / images;
+        while (subheight * width > splitSize) {
+            images++;
+            subheight = (height + images-1) / images;
+        }
+        int suby = 0;
+        const QImage constImg(img);
+        const QImage constMask(mask);
+        while(suby < height) {
+            qreal subImageHeight = qMin(subheight, height-suby);
+            const QImage subImage(constImg.scanLine(suby), width, subImageHeight,
+                                  constImg.bytesPerLine(), constImg.format());
+            const QImage subMask = mask.isNull() ? mask : QImage(constMask.scanLine(suby), width, subImageHeight,
+                                                                 constMask.bytesPerLine(), constMask.format());
+            drawImageHelper(x, y + suby/scaleY, w, subImageHeight/scaleY,
+                            subImage, subMask, gray, scaleX, scaleY);
+            suby += subheight;
+        }
+    } else {
+        drawImageHelper(x, y, width, height, img, mask, gray, scaleX, scaleY);
+    }
+}
+
+void QPSPrintEnginePrivate::emitHeader(bool finished)
+{
+    QPSPrintEngine *q = static_cast<QPSPrintEngine *>(q_ptr);
+    QPrinter *printer = static_cast<QPrinter*>(pdev);
+
+    if (creator.isEmpty())
+        creator = QLatin1String("Qt " QT_VERSION_STR);
+
+    QByteArray header;
+    QPdf::ByteStream s(&header);
+
+    qreal scale = 72. / ((qreal) q->metric(QPaintDevice::PdmDpiY));
+    QRect pageRect = this->pageRect();
+    QRect paperRect = this->paperRect();
+    int mtop = pageRect.top() - paperRect.top();
+    int mleft = pageRect.left() - paperRect.left();
+    int mbottom = paperRect.bottom() - pageRect.bottom();
+    int mright = paperRect.right() - pageRect.right();
+    int width = pageRect.width();
+    int height = pageRect.height();
+    if (finished && pageCount == 1 && copies == 1 &&
+        ((fullPage && qt_gen_epsf) || (outputFileName.endsWith(QLatin1String(".eps")))))
+    {
+        // According to the EPSF 3.0 spec it is required that the PS
+        // version is PS-Adobe-3.0
+        s << "%!PS-Adobe-3.0";
+        if (!boundingBox.isValid())
+            boundingBox.setRect(0, 0, width, height);
+        if (orientation == QPrinter::Landscape) {
+            if (!fullPage)
+                boundingBox.translate(-mleft, -mtop);
+            s << " EPSF-3.0\n%%BoundingBox: "
+              << int((printer->height() - boundingBox.bottom())*scale) // llx
+              << int((printer->width() - boundingBox.right())*scale - 1) // lly
+              << int((printer->height() - boundingBox.top())*scale + 1) // urx
+              << int((printer->width() - boundingBox.left())*scale); // ury
+        } else {
+            if (!fullPage)
+                boundingBox.translate(mleft, -mtop);
+            s << " EPSF-3.0\n%%BoundingBox: "
+              << int((boundingBox.left())*scale)
+              << int((printer->height() - boundingBox.bottom())*scale - 1)
+              << int((boundingBox.right())*scale + 1)
+              << int((printer->height() - boundingBox.top())*scale);
+        }
+    } else {
+        s << "%!PS-Adobe-1.0";
+        int w = width + (fullPage ? 0 : mleft + mright);
+        int h = height + (fullPage ? 0 : mtop + mbottom);
+        w = (int)(w*scale);
+        h = (int)(h*scale);
+        // set a bounding box according to the DSC
+        if (orientation == QPrinter::Landscape)
+            s << "\n%%BoundingBox: 0 0 " << h << w;
+        else
+            s << "\n%%BoundingBox: 0 0 " << w << h;
+    }
+    s << '\n' << wrapDSC("%%Creator: " + creator.toUtf8());
+    if (!title.isEmpty())
+        s << wrapDSC("%%Title: " + title.toUtf8());
+#ifndef QT_NO_DATESTRING
+    s << "%%CreationDate: " << QDateTime::currentDateTime().toString().toUtf8();
+#endif
+    s << "\n%%Orientation: ";
+    if (orientation == QPrinter::Landscape)
+        s << "Landscape";
+    else
+        s << "Portrait";
+
+    s << "\n%%Pages: (atend)"
+        "\n%%DocumentFonts: (atend)"
+        "\n%%EndComments\n"
+
+        "%%BeginProlog\n"
+        "% Prolog copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies).\n"
+        "% You may copy this prolog in any way that is directly related to this document.\n"
+        "% For other use of this prolog, see your licensing agreement for Qt.\n"
+      << ps_header << '\n';
+
+
+    s << "/pageinit {\n";
+    if (!fullPage) {
+        if (orientation == QPrinter::Portrait)
+            s << mleft*scale << mbottom*scale << "translate\n";
+        else
+            s << mtop*scale << mleft*scale << "translate\n";
+    }
+    if (orientation == QPrinter::Portrait) {
+        s << "% " << printer->widthMM() << '*' << printer->heightMM()
+          << "mm (portrait)\n0 " << height*scale
+          << "translate " << scale << '-' << scale << "scale } def\n";
+    } else {
+        s << "% " << printer->heightMM() << '*' << printer->widthMM()
+          << " mm (landscape)\n 90 rotate " << scale << '-' << scale << "scale } def\n";
+    }
+    s << "%%EndProlog\n";
+
+    outDevice->write(header);
+    headerDone = true;
+}
+
+
+void QPSPrintEnginePrivate::emitPages()
+{
+    if (!hugeDocument) {
+        for (QHash<QFontEngine::FaceId, QFontSubset *>::const_iterator it = fonts.constBegin();
+             it != fonts.constEnd(); ++it)
+            outDevice->write((*it)->toType1());
+    }
+
+    QIODevice *content = buffer.stream();
+    // Write the page contents in chunks.
+    while (!content->atEnd()) {
+        QByteArray buf = content->read(currentPage->chunkSize());
+        if (!buf.isEmpty())
+            outDevice->write(buf);
+    }
+    content = currentPage->stream();
+    // Write the page contents in chunks.
+    while (!content->atEnd()) {
+        QByteArray buf = content->read(currentPage->chunkSize());
+        if (!buf.isEmpty())
+            outDevice->write(buf);
+    }
+    outDevice->write(trailer);
+
+    buffer.clear();
+    currentPage->clear();
+    trailer = QByteArray();
+    hugeDocument = true;
+}
+
+
+#ifdef Q_WS_QWS
+static const int max_in_memory_size = 2000000;
+#else
+static const int max_in_memory_size = 32000000;
+#endif
+
+void QPSPrintEnginePrivate::flushPage(bool last)
+{
+    if (!last && currentPage->stream()->size() == 0)
+        return;
+
+    QPdf::ByteStream e(&trailer);
+    buffer << "%%Page: "
+           << pageCount << pageCount << "\n"
+           "%%BeginPageSetup\n"
+           "QI\n";
+    if (hugeDocument) {
+        for (QHash<QFontEngine::FaceId, QFontSubset *>::const_iterator it = fonts.constBegin();
+             it != fonts.constEnd(); ++it) {
+            if (currentPage->fonts.contains((*it)->object_id)) {
+                if ((*it)->downloaded_glyphs == 0) {
+                    buffer << (*it)->toType1();
+                    (*it)->downloaded_glyphs = 0;
+                } else {
+                    buffer << (*it)->type1AddedGlyphs();
+                }
+            }
+        }
+    }
+    for (int i = 0; i < currentPage->fonts.size(); ++i)
+        buffer << "(F" << QByteArray::number(currentPage->fonts.at(i)) << ") T1Setup\n";
+
+    buffer << "%%EndPageSetup\nq\n";
+    e << "\nQ QP\n";
+    if (last || hugeDocument
+        || buffer.stream()->size() + currentPage->stream()->size() > max_in_memory_size) {
+//        qDebug("emiting header at page %d", pageCount);
+        if (!headerDone)
+            emitHeader(last);
+        emitPages();
+    } else {
+        buffer << *currentPage << e;
+        currentPage->clear();
+        trailer.clear();
+    }
+    pageCount++;
+}
+
+// ================ PSPrinter class ========================
+
+QPSPrintEngine::QPSPrintEngine(QPrinter::PrinterMode m)
+    : QPdfBaseEngine(*(new QPSPrintEnginePrivate(m)),
+                     PrimitiveTransform
+                     | PatternTransform
+                     | PixmapTransform
+                     | PainterPaths
+                     | PatternBrush
+        )
+{
+}
+
+static void ignoreSigPipe(bool b)
+{
+#ifndef QT_NO_LPR
+    static struct sigaction *users_sigpipe_handler = 0;
+    static int lockCount = 0;
+
+#ifndef QT_NO_THREAD
+    QMutexLocker locker(QMutexPool::globalInstanceGet(&users_sigpipe_handler));
+#endif
+
+    if (b) {
+        if (lockCount++ > 0)
+            return;
+
+        if (users_sigpipe_handler != 0)
+            return; // already ignoring sigpipe
+
+        users_sigpipe_handler = new struct sigaction;
+        struct sigaction tmp_sigpipe_handler;
+        tmp_sigpipe_handler.sa_handler = SIG_IGN;
+        sigemptyset(&tmp_sigpipe_handler.sa_mask);
+        tmp_sigpipe_handler.sa_flags = 0;
+
+        if (sigaction(SIGPIPE, &tmp_sigpipe_handler, users_sigpipe_handler) == -1) {
+            delete users_sigpipe_handler;
+            users_sigpipe_handler = 0;
+        }
+    }
+    else {
+        if (--lockCount > 0)
+            return;
+
+        if (users_sigpipe_handler == 0)
+            return; // not ignoring sigpipe
+
+        if (sigaction(SIGPIPE, users_sigpipe_handler, 0) == -1)
+            qWarning("QPSPrintEngine: Could not restore SIGPIPE handler");
+
+        delete users_sigpipe_handler;
+        users_sigpipe_handler = 0;
+    }
+#else
+    Q_UNUSED(b);
+#endif
+}
+QPSPrintEngine::~QPSPrintEngine()
+{
+    Q_D(QPSPrintEngine);
+    if (d->fd >= 0)
+#if defined(Q_OS_WIN) && defined(_MSC_VER) && _MSC_VER >= 1400
+        ::_close(d->fd);
+#else
+        ::close(d->fd);
+#endif
+}
+
+bool QPSPrintEngine::begin(QPaintDevice *pdev)
+{
+    Q_D(QPSPrintEngine);
+
+    if (d->fd >= 0)
+        return true;
+
+    if (d->useAlphaEngine) {
+        QAlphaPaintEngine::begin(pdev);
+        if (!continueCall())
+            return true;
+    }
+
+    if(!QPdfBaseEngine::begin(pdev)) {
+        d->printerState = QPrinter::Error;
+        return false;
+    }
+
+    d->pageCount = 1;                // initialize state
+
+    d->pen = QPen(Qt::black);
+    d->brush = Qt::NoBrush;
+    d->hasPen = true;
+    d->hasBrush = false;
+    d->clipEnabled = false;
+    d->allClipped = false;
+    d->boundingBox = QRect();
+    d->fontsUsed = "";
+    d->hugeDocument = false;
+    d->simplePen = false;
+
+    setActive(true);
+    d->printerState = QPrinter::Active;
+
+    newPage();
+
+    return true;
+}
+
+bool QPSPrintEngine::end()
+{
+    Q_D(QPSPrintEngine);
+
+    if (d->useAlphaEngine) {
+        QAlphaPaintEngine::end();
+        if (!continueCall())
+            return true;
+    }
+
+    // we're writing to lp/lpr through a pipe, we don't want to crash with SIGPIPE
+    // if lp/lpr dies
+    ignoreSigPipe(true);
+    d->flushPage(true);
+    QByteArray trailer;
+    QPdf::ByteStream s(&trailer);
+    s << "%%Trailer\n"
+         "%%Pages: " << d->pageCount - 1 << '\n' <<
+        wrapDSC("%%DocumentFonts: " + d->fontsUsed);
+    s << "%%EOF\n";
+    d->outDevice->write(trailer);
+
+    QPdfBaseEngine::end();
+    ignoreSigPipe(false);
+
+    d->firstPage = true;
+    d->headerDone = false;
+
+    setActive(false);
+    d->printerState = QPrinter::Idle;
+    d->pdev = 0;
+
+    return true;
+}
+
+void QPSPrintEngine::setBrush()
+{
+    Q_D(QPSPrintEngine);
+#if 0
+    bool specifyColor;
+    int gStateObject = 0;
+    int patternObject = d->addBrushPattern(brush, d->stroker.matrix, brushOrigin, &specifyColor, &gStateObject);
+
+    *d->currentPage << (patternObject ? "/PCSp cs " : "/CSp cs ");
+    if (specifyColor) {
+        QColor rgba = brush.color();
+        *d->currentPage << rgba.redF()
+                        << rgba.greenF()
+                        << rgba.blueF();
+    }
+    if (patternObject)
+        *d->currentPage << "/Pat" << patternObject;
+    *d->currentPage << "scn\n";
+#endif
+    QColor rgba = d->brush.color();
+    if (d->colorMode == QPrinter::GrayScale) {
+        qreal gray = qGray(rgba.rgba())/255.;
+        *d->currentPage << gray << gray << gray;
+    } else {
+        *d->currentPage << rgba.redF()
+                        << rgba.greenF()
+                        << rgba.blueF();
+    }
+    *d->currentPage << "scn\n"
+                    << "/BSt " << d->brush.style() << "def\n";
+}
+
+void QPSPrintEngine::drawImageInternal(const QRectF &r, QImage image, bool bitmap)
+{
+    Q_D(QPSPrintEngine);
+    if (d->clipEnabled && d->allClipped)
+        return;
+    if (bitmap && image.depth() != 1)
+        bitmap = false;
+    QImage mask;
+    // the below is not necessary since it's handled by the alpha
+    // engine
+    if (!d->useAlphaEngine && !bitmap) {
+        if (image.format() == QImage::Format_Mono || image.format() == QImage::Format_MonoLSB)
+            image = image.convertToFormat(QImage::Format_Indexed8);
+        if (image.hasAlphaChannel()) {
+            // get better alpha dithering
+            int xscale = image.width();
+            xscale *= xscale <= 800 ? 4 : (xscale <= 1600 ? 2 : 1);
+            int yscale = image.height();
+            yscale *= yscale <= 800 ? 4 : (yscale <= 1600 ? 2 : 1);
+            image = image.scaled(xscale, yscale);
+            mask = image.createAlphaMask(Qt::OrderedAlphaDither);
+        }
+    }
+    *d->currentPage << "q\n";
+    if(!d->simplePen)
+        *d->currentPage << QPdf::generateMatrix(d->stroker.matrix);
+    QBrush b = d->brush;
+    if (image.depth() == 1) {
+        // set current pen as brush
+        d->brush = d->pen.brush();
+        setBrush();
+    }
+    d->drawImage(r.x(), r.y(), r.width(), r.height(), image, mask);
+    *d->currentPage << "Q\n";
+    d->brush = b;
+}
+
+
+void QPSPrintEngine::drawImage(const QRectF &r, const QImage &img, const QRectF &sr,
+                               Qt::ImageConversionFlags)
+{
+    Q_D(QPSPrintEngine);
+
+    if (d->useAlphaEngine) {
+        QAlphaPaintEngine::drawImage(r, img, sr);
+        if (!continueCall())
+            return;
+    }
+    QImage image = img.copy(sr.toRect());
+    drawImageInternal(r, image, false);
+}
+
+void QPSPrintEngine::drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr)
+{
+    Q_D(QPSPrintEngine);
+
+    if (d->useAlphaEngine) {
+        QAlphaPaintEngine::drawPixmap(r, pm, sr);
+        if (!continueCall())
+            return;
+    }
+
+    QImage img = pm.copy(sr.toRect()).toImage();
+    drawImageInternal(r, img, true);
+}
+
+void QPSPrintEngine::drawTiledPixmap(const QRectF &r, const QPixmap &pixmap, const QPointF &p)
+{
+    Q_D(QPSPrintEngine);
+
+    if (d->useAlphaEngine) {
+        QAlphaPaintEngine::drawTiledPixmap(r, pixmap, p);
+        if (!continueCall())
+            return;
+    }
+
+    if (d->clipEnabled && d->allClipped)
+        return;
+    // ### Optimize implementation!
+    qreal yPos = r.y();
+    qreal yOff = p.y();
+    while(yPos < r.y() + r.height()) {
+        qreal drawH = pixmap.height() - yOff;    // Cropping first row
+        if (yPos + drawH > r.y() + r.height())        // Cropping last row
+            drawH = r.y() + r.height() - yPos;
+        qreal xPos = r.x();
+        qreal xOff = p.x();
+        while(xPos < r.x() + r.width()) {
+            qreal drawW = pixmap.width() - xOff; // Cropping first column
+            if (xPos + drawW > r.x() + r.width())    // Cropping last column
+                drawW = r.x() + r.width() - xPos;
+            // ########
+            painter()->drawPixmap(QPointF(xPos, yPos).toPoint(), pixmap,
+                                  QRectF(xOff, yOff, drawW, drawH).toRect());
+            xPos += drawW;
+            xOff = 0;
+        }
+        yPos += drawH;
+        yOff = 0;
+    }
+
+}
+
+bool QPSPrintEngine::newPage()
+{
+    Q_D(QPSPrintEngine);
+
+    if (!d->firstPage && d->useAlphaEngine)
+        flushAndInit();
+
+    // we're writing to lp/lpr through a pipe, we don't want to crash with SIGPIPE
+    // if lp/lpr dies
+    ignoreSigPipe(true);
+    if (!d->firstPage)
+        d->flushPage();
+    d->firstPage = false;
+    ignoreSigPipe(false);
+
+    delete d->currentPage;
+    d->currentPage = new QPdfPage;
+    d->stroker.stream = d->currentPage;
+
+    return QPdfBaseEngine::newPage();
+}
+
+bool QPSPrintEngine::abort()
+{
+    // ### abort!?!
+    return false;
+}
+
+QPrinter::PrinterState QPSPrintEngine::printerState() const
+{
+    Q_D(const QPSPrintEngine);
+    return d->printerState;
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_PRINTER
diff --git a/src/gui/painting/qprintengine_ps_p.h b/src/gui/painting/qprintengine_ps_p.h
new file mode 100644
index 0000000000..a1185d7867
--- /dev/null
+++ b/src/gui/painting/qprintengine_ps_p.h
@@ -0,0 +1,137 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPRINTENGINE_PS_P_H
+#define QPRINTENGINE_PS_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of qpsprinter.cpp and qprinter_x11.cpp.
+// This header file may change from version to version without notice,
+// or even be removed.
+//
+// We mean it.
+//
+
+#ifndef QT_NO_PRINTER
+
+#include "private/qpdf_p.h"
+#include "qplatformdefs.h"
+#include "QtCore/qlibrary.h"
+#include "QtCore/qstringlist.h"
+#include "QtCore/qhash.h"
+#include "QtCore/qabstractitemmodel.h"
+
+QT_BEGIN_NAMESPACE
+
+class QPrinter;
+class QPSPrintEnginePrivate;
+
+class QPSPrintEngine : public QPdfBaseEngine
+{
+    Q_DECLARE_PRIVATE(QPSPrintEngine)
+public:
+    // QPrinter uses these
+    explicit QPSPrintEngine(QPrinter::PrinterMode m);
+    ~QPSPrintEngine();
+
+
+    virtual bool begin(QPaintDevice *pdev);
+    virtual bool end();
+
+    void setBrush();
+
+    virtual void drawImage(const QRectF &r, const QImage &img, const QRectF &sr, Qt::ImageConversionFlags);
+    virtual void drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr);
+    virtual void drawTiledPixmap(const QRectF &r, const QPixmap &pixmap, const QPointF &s);
+
+    virtual void drawImageInternal(const QRectF &r, QImage img, bool bitmap);
+
+    virtual QPaintEngine::Type type() const { return QPaintEngine::PostScript; }
+
+    virtual bool newPage();
+    virtual bool abort();
+
+    virtual QPrinter::PrinterState printerState() const;
+
+    virtual Qt::HANDLE handle() const { return 0; }
+
+private:
+    Q_DISABLE_COPY(QPSPrintEngine)
+};
+
+class QPSPrintEnginePrivate : public QPdfBaseEnginePrivate {
+public:
+    QPSPrintEnginePrivate(QPrinter::PrinterMode m);
+    ~QPSPrintEnginePrivate();
+
+    void emitHeader(bool finished);
+    void emitPages();
+    void drawImage(qreal x, qreal y, qreal w, qreal h, const QImage &img, const QImage &mask);
+    void flushPage(bool last = false);
+    void drawImageHelper(qreal x, qreal y, qreal w, qreal h, const QImage &img, const QImage &mask,
+                         bool gray, qreal scaleX, qreal scaleY);
+
+    int         pageCount;
+    bool        epsf;
+    QByteArray     fontsUsed;
+
+    // stores the descriptions of the n first pages.
+    QPdf::ByteStream buffer;
+    QByteArray trailer;
+
+    bool firstPage;
+
+    QRect boundingBox;
+
+    QPrinter::PrinterState printerState;
+    bool hugeDocument;
+    bool headerDone;
+};
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_PRINTER
+
+#endif // QPRINTENGINE_PS_P_H
diff --git a/src/gui/painting/qprintengine_qws.cpp b/src/gui/painting/qprintengine_qws.cpp
new file mode 100644
index 0000000000..1aef2c68cf
--- /dev/null
+++ b/src/gui/painting/qprintengine_qws.cpp
@@ -0,0 +1,886 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <private/qprintengine_qws_p.h>
+
+#ifndef QT_NO_PRINTER
+
+#include <private/qpaintengine_raster_p.h>
+#include <qimage.h>
+#include <qfile.h>
+#include <qdebug.h>
+#include <QCopChannel>
+
+QT_BEGIN_NAMESPACE
+
+#define MM(n) int((n * 720 + 127) / 254)
+#define IN(n) int(n * 72)
+
+extern QSizeF qt_paperSizeToQSizeF(QPrinter::PaperSize size);
+
+QtopiaPrintEngine::QtopiaPrintEngine(QPrinter::PrinterMode mode)
+    : QPaintEngine(*(new QtopiaPrintEnginePrivate( mode )))
+{
+    d_func()->initialize();
+}
+
+bool QtopiaPrintEngine::begin(QPaintDevice *)
+{
+    Q_D(QtopiaPrintEngine);
+    Q_ASSERT_X(d->printerState == QPrinter::Idle, "QtopiaPrintEngine", "printer already active");
+
+    // Create a new off-screen monochrome image to handle the drawing process.
+    QSize size = paperRect().size();
+    if ( d->pageImage )
+	delete d->pageImage;
+    d->pageImage = new QImage( size, QImage::Format_RGB32 );
+    if ( !(d->pageImage) )
+	return false;
+
+    // Recreate the paint engine on the new image.
+    delete d->_paintEngine;
+    d->_paintEngine = 0;
+    d->paintEngine()->state = state;
+
+    // Begin the paint process on the image.
+    if (!d->paintEngine()->begin(d->pageImage))
+        return false;
+
+    // Clear the first page to all-white.
+    clearPage();
+
+    // Clear the print buffer and output the image header.
+    d->buffer.clear();
+    d->writeG3FaxHeader();
+
+    // The print engine is currently active.
+    d->printerState = QPrinter::Active;
+    return true;
+}
+
+bool QtopiaPrintEngine::end()
+{
+    Q_D(QtopiaPrintEngine);
+
+    d->paintEngine()->end();
+
+    // Flush the last page.
+    flushPage();
+
+    // Output the fax data to a file (TODO: send to the print queuing daemon).
+    QString filename;
+    if ( !d->outputFileName.isEmpty() )
+        filename = QString::fromLocal8Bit(qgetenv("HOME").constData()) + QLatin1String("/Documents/") + d->outputFileName;
+    else
+        filename = QString::fromLocal8Bit(qgetenv("HOME").constData()) + QLatin1String("/tmp/qwsfax.tiff");
+
+    setProperty(QPrintEngine::PPK_OutputFileName, filename);
+    QFile file( filename );
+    if ( !file.open( QIODevice::WriteOnly | QIODevice::Truncate ) ) {
+	qDebug( "Failed to open %s for printer output",
+		filename.toLatin1().constData() );
+    } else {
+	file.write( d->buffer.data() );
+	file.close();
+    }
+
+    // Free up the memory for the image buffer.
+    d->buffer.clear();
+
+    // Finalize the print job.
+    d->printerState = QPrinter::Idle;
+
+    // call qcop service
+    QMap<QString, QVariant> map;
+    for ( int x = 0; x <= QPrintEngine::PPK_Duplex; x++ )
+        map.insert( QString::number(x), property((QPrintEngine::PrintEnginePropertyKey)(x)));
+    QVariant variant(map);
+
+    QByteArray data;
+    QDataStream out(&data, QIODevice::WriteOnly);
+    out << variant;
+    QCopChannel::send(QLatin1String("QPE/Service/Print"), QLatin1String("print(QVariant)"), data);
+
+    return true;
+}
+
+QPaintEngine *QtopiaPrintEngine::paintEngine() const
+{
+    return const_cast<QtopiaPrintEnginePrivate *>(d_func())->paintEngine();
+}
+
+void QtopiaPrintEngine::drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr)
+{
+    Q_D(QtopiaPrintEngine);
+    Q_ASSERT(d->printerState == QPrinter::Active);
+    d->paintEngine()->drawPixmap(r, pm, sr);
+}
+
+void QtopiaPrintEngine::drawTextItem(const QPointF &p, const QTextItem &ti)
+{
+    Q_D(QtopiaPrintEngine);
+    Q_ASSERT(d->printerState == QPrinter::Active);
+    d->paintEngine()->drawTextItem(p, ti);
+}
+
+void QtopiaPrintEngine::updateState(const QPaintEngineState &state)
+{
+    Q_D(QtopiaPrintEngine);
+    d->paintEngine()->updateState(state);
+}
+
+QRect QtopiaPrintEngine::paperRect() const
+{
+    QSizeF s = qt_paperSizeToQSizeF(d_func()->paperSize);
+    s.rwidth() = MM(s.width());
+    s.rheight() = MM(s.height());
+    int w = qRound(s.width()*d_func()->resolution/72.);
+    int h = qRound(s.height()*d_func()->resolution/72.);
+    if (d_func()->orientation == QPrinter::Portrait)
+        return QRect(0, 0, w, h);
+    else
+        return QRect(0, 0, h, w);
+}
+
+QRect QtopiaPrintEngine::pageRect() const
+{
+    QRect r = paperRect();
+    if (d_func()->fullPage)
+        return r;
+    // would be nice to get better margins than this.
+    return QRect(d_func()->resolution/3, d_func()->resolution/3, r.width()-2*d_func()->resolution/3, r.height()-2*d_func()->resolution/3);
+}
+
+bool QtopiaPrintEngine::newPage()
+{
+    flushPage();
+    clearPage();
+    ++(d_func()->pageNumber);
+    return true;
+}
+
+bool QtopiaPrintEngine::abort()
+{
+    return false;
+}
+
+QPrinter::PrinterState QtopiaPrintEngine::printerState() const
+{
+    return d_func()->printerState;
+}
+
+int QtopiaPrintEngine::metric(QPaintDevice::PaintDeviceMetric metricType) const
+{
+    int val;
+    QRect r = d_func()->fullPage ? paperRect() : pageRect();
+    switch (metricType) {
+    case QPaintDevice::PdmWidth:
+        val = r.width();
+        break;
+    case QPaintDevice::PdmHeight:
+        val = r.height();
+        break;
+    case QPaintDevice::PdmDpiX:
+        val = d_func()->resolution;
+        break;
+    case QPaintDevice::PdmDpiY:
+        val = d_func()->resolution;
+        break;
+    case QPaintDevice::PdmPhysicalDpiX:
+    case QPaintDevice::PdmPhysicalDpiY:
+        val = QT_QWS_PRINTER_DEFAULT_DPI;
+        break;
+    case QPaintDevice::PdmWidthMM:
+        val = qRound(r.width()*25.4/d_func()->resolution);
+        break;
+    case QPaintDevice::PdmHeightMM:
+        val = qRound(r.height()*25.4/d_func()->resolution);
+        break;
+    case QPaintDevice::PdmNumColors:
+        val = 2;
+        break;
+    case QPaintDevice::PdmDepth:
+        val = 1;
+        break;
+    default:
+        qWarning("QtopiaPrintEngine::metric: Invalid metric command");
+        return 0;
+    }
+    return val;
+}
+
+QVariant QtopiaPrintEngine::property(PrintEnginePropertyKey key) const
+{
+    Q_D(const  QtopiaPrintEngine);
+    QVariant ret;
+
+    switch (key) {
+    case PPK_CollateCopies:
+        ret = d->collateCopies;
+        break;
+    case PPK_ColorMode:
+        ret = d->colorMode;
+        break;
+    case PPK_Creator:
+        ret = d->creator;
+        break;
+    case PPK_DocumentName:
+        ret = d->docName;
+        break;
+    case PPK_FullPage:
+        ret = d->fullPage;
+        break;
+    case PPK_CopyCount: // fallthrough
+    case PPK_NumberOfCopies:
+        ret = d->numCopies;
+        break;
+    case PPK_SupportsMultipleCopies:
+        ret = false;
+        break;
+    case PPK_Orientation:
+        ret = d->orientation;
+        break;
+    case PPK_OutputFileName:
+        ret = d->outputFileName;
+        break;
+    case PPK_PageOrder:
+        ret = d->pageOrder;
+        break;
+    case PPK_PageRect:
+        ret = pageRect();
+        break;
+    case PPK_PaperSize:
+        ret = d->paperSize;
+        break;
+    case PPK_PaperRect:
+        ret = paperRect();
+        break;
+    case PPK_PaperSource:
+        ret = d->paperSource;
+        break;
+    case PPK_PrinterName:
+        ret = d->printerName;
+        break;
+    case PPK_PrinterProgram:
+        ret = d->printProgram;
+        break;
+    case PPK_Resolution:
+        ret = d->resolution;
+        break;
+    case PPK_SupportedResolutions:
+        ret = QList<QVariant>() << QT_QWS_PRINTER_DEFAULT_DPI;
+        break;
+    default:
+        break;
+    }
+    return ret;
+}
+
+void QtopiaPrintEngine::setProperty(PrintEnginePropertyKey key, const QVariant &value)
+{
+    Q_D(QtopiaPrintEngine);
+    switch (key) {
+    case PPK_CollateCopies:
+        d->collateCopies = value.toBool();
+        break;
+    case PPK_ColorMode:
+        d->colorMode = QPrinter::ColorMode(value.toInt());
+        break;
+    case PPK_Creator:
+        d->creator = value.toString();
+        break;
+    case PPK_DocumentName:
+        d->docName = value.toString();
+        break;
+    case PPK_FullPage:
+        d->fullPage = value.toBool();
+        break;
+    case PPK_CopyCount: // fallthrough
+    case PPK_NumberOfCopies:
+        d->numCopies = value.toInt();
+        break;
+    case PPK_Orientation:
+        d->orientation = QPrinter::Orientation(value.toInt());
+        break;
+    case PPK_OutputFileName:
+        d->outputFileName = value.toString();
+        break;
+    case PPK_PageOrder:
+        d->pageOrder = QPrinter::PageOrder(value.toInt());
+        break;
+    case PPK_PaperSize:
+        d->paperSize = QPrinter::PaperSize(value.toInt());
+        break;
+    case PPK_PaperSource:
+        d->paperSource = QPrinter::PaperSource(value.toInt());
+    case PPK_PrinterName:
+        d->printerName = value.toString();
+        break;
+    case PPK_PrinterProgram:
+        d->printProgram = value.toString();
+        break;
+    case PPK_Resolution:
+        d->resolution = value.toInt();
+        break;
+    default:
+        break;
+    }
+}
+
+void QtopiaPrintEngine::clearPage()
+{
+    d_func()->pageImage->fill(QColor(255, 255, 255).rgb());
+}
+
+void QtopiaPrintEngine::flushPage()
+{
+    d_func()->writeG3FaxPage();
+}
+
+QtopiaPrintEnginePrivate::~QtopiaPrintEnginePrivate()
+{
+    if ( pageImage )
+	delete pageImage;
+}
+
+void QtopiaPrintEnginePrivate::initialize()
+{
+    _paintEngine = 0;
+}
+
+QPaintEngine *QtopiaPrintEnginePrivate::paintEngine()
+{
+    if (!_paintEngine)
+        _paintEngine = new QRasterPaintEngine(pageImage);
+    return _paintEngine;
+}
+
+void QtopiaPrintEnginePrivate::writeG3FaxHeader()
+{
+    // Write the TIFF file magic number (little-endian TIFF).
+    buffer.append( (char)'I' );
+    buffer.append( (char)'I' );
+    buffer.append( (char)42 );
+    buffer.append( (char)0 );
+
+    // Leave a place-holder for the IFD offset of the first page.
+    ifdPatch = buffer.size();
+    buffer.append( (int)0 );
+}
+
+// Tag values, from RFC 2301.
+#define	TIFF_IFD_NEW_SUB_FILE_TYPE	254
+#define	TIFF_IFD_IMAGE_WIDTH		256
+#define	TIFF_IFD_IMAGE_LENGTH		257
+#define	TIFF_IFD_BITS_PER_SAMPLE	258
+#define	TIFF_IFD_COMPRESSION		259
+#define	TIFF_IFD_PHOTOMETRIC_INTERP	262
+#define	TIFF_IFD_FILL_ORDER		266
+#define	TIFF_IFD_STRIP_OFFSETS		273
+#define	TIFF_IFD_ORIENTATION		274
+#define	TIFF_IFD_SAMPLES_PER_PIXEL	277
+#define	TIFF_IFD_ROWS_PER_STRIP		278
+#define	TIFF_IFD_STRIP_BYTE_COUNTS	279
+#define	TIFF_IFD_X_RESOLUTION	    	282
+#define	TIFF_IFD_Y_RESOLUTION	    	283
+#define	TIFF_IFD_PLANAR_CONFIG		284
+#define	TIFF_IFD_T4_OPTIONS		292
+#define	TIFF_IFD_RESOLUTION_UNIT	296
+#define	TIFF_IFD_PAGE_NUMBER	    	297
+#define	TIFF_IFD_CLEAN_FAX_DATA		327
+
+// IFD type values.
+#define	TIFF_TYPE_SHORT			3
+#define	TIFF_TYPE_LONG			4
+#define	TIFF_TYPE_RATIONAL		5
+
+// Construct a SHORT pair from two values.
+#define	TIFF_SHORT_PAIR(a,b)		(((a) & 0xFFFF) | ((b) << 16))
+
+// Width of a FAX page in pixels, in the baseline specification from RFC 2301.
+// This must be hard-wired, as per the RFC.  We truncate any pixels that
+// are beyond this limit, or pad lines to reach this limit.
+#define	TIFF_FAX_WIDTH			1728
+
+void QtopiaPrintEnginePrivate::writeG3FaxPage()
+{
+    // Pad the image file to a word boundary, just in case.
+    buffer.pad();
+
+    // Back-patch the IFD link for the previous page.
+    buffer.patch( ifdPatch, buffer.size() );
+
+    // Output the contents of the IFD for this page (these must be
+    // in ascending order of tag value).
+    buffer.append( (short)19 );	    // Number of IFD entries.
+    writeG3IFDEntry( TIFF_IFD_NEW_SUB_FILE_TYPE, TIFF_TYPE_LONG, 1, 2 );
+    writeG3IFDEntry( TIFF_IFD_IMAGE_WIDTH, TIFF_TYPE_LONG, 1, TIFF_FAX_WIDTH );
+    writeG3IFDEntry
+	( TIFF_IFD_IMAGE_LENGTH, TIFF_TYPE_LONG, 1, pageImage->height() );
+    writeG3IFDEntry( TIFF_IFD_BITS_PER_SAMPLE, TIFF_TYPE_SHORT, 1, 1 );
+    writeG3IFDEntry( TIFF_IFD_COMPRESSION, TIFF_TYPE_SHORT, 1, 3 );
+    writeG3IFDEntry( TIFF_IFD_PHOTOMETRIC_INTERP, TIFF_TYPE_SHORT, 1, 0 );
+    writeG3IFDEntry( TIFF_IFD_FILL_ORDER, TIFF_TYPE_SHORT, 1, 1 );
+    int stripOffsets =
+	writeG3IFDEntry( TIFF_IFD_STRIP_OFFSETS, TIFF_TYPE_LONG, 1, 0 );
+    writeG3IFDEntry( TIFF_IFD_ORIENTATION, TIFF_TYPE_SHORT, 1, 1 );
+    writeG3IFDEntry( TIFF_IFD_SAMPLES_PER_PIXEL, TIFF_TYPE_SHORT, 1, 1 );
+    writeG3IFDEntry
+	( TIFF_IFD_ROWS_PER_STRIP, TIFF_TYPE_LONG, 1, pageImage->height() );
+    int stripBytes = writeG3IFDEntry
+	( TIFF_IFD_STRIP_BYTE_COUNTS, TIFF_TYPE_LONG, 1, 0 );
+    int xres =
+	writeG3IFDEntry( TIFF_IFD_X_RESOLUTION, TIFF_TYPE_RATIONAL, 1, 0 );
+    int yres =
+	writeG3IFDEntry( TIFF_IFD_Y_RESOLUTION, TIFF_TYPE_RATIONAL, 1, 0 );
+    writeG3IFDEntry( TIFF_IFD_PLANAR_CONFIG, TIFF_TYPE_SHORT, 1, 1 );
+    writeG3IFDEntry( TIFF_IFD_T4_OPTIONS, TIFF_TYPE_LONG, 1, 2 );
+    writeG3IFDEntry( TIFF_IFD_RESOLUTION_UNIT, TIFF_TYPE_SHORT, 1, 2 );
+    writeG3IFDEntry( TIFF_IFD_PAGE_NUMBER, TIFF_TYPE_SHORT, 2,
+		     TIFF_SHORT_PAIR( pageNumber, 0 ) );
+    writeG3IFDEntry( TIFF_IFD_CLEAN_FAX_DATA, TIFF_TYPE_SHORT, 1, 0 );
+
+    // Leave a place-holder for the IFD offset of the next page.
+    ifdPatch = buffer.size();
+    buffer.append( (int)0 );
+
+    // Output the X and Y resolutions, as rational values (usually 200/1).
+    buffer.patch( xres, buffer.size() );
+    buffer.append( (int)resolution );
+    buffer.append( (int)1 );
+    buffer.patch( yres, buffer.size() );
+    buffer.append( (int)resolution );
+    buffer.append( (int)1 );
+
+    // We are now at the start of the image data - set the strip offset.
+    int start = buffer.size();
+    buffer.patch( stripOffsets, start );
+
+    // Output the image data.
+    int width = pageImage->width();
+    QImage::Format imageFormat = pageImage->format();
+    for ( int y = 0; y < pageImage->height(); ++y ) {
+	unsigned char *scan = pageImage->scanLine(y);
+	int prev, pixel, len;
+        writeG3EOL();
+	prev = 0;
+	len = 0;
+
+        uint currentColor = qRgb(255, 255, 255); // start with white
+
+	for ( int x = 0; x < width && x < TIFF_FAX_WIDTH; ++x ) {
+            if ( imageFormat == QImage::Format_RGB32 ) {
+                // read color of the current pixel
+                uint *p = (uint *)scan + x;
+
+                if ( *p == currentColor ) { // if it is the same color
+                    len++; // imcrement length
+                } else { // otherwise write color into the buffer
+                    if ( len > 0 ) {
+                        if ( currentColor == qRgb(0, 0, 0) )
+                            writeG3BlackRun( len );
+                        else
+                            writeG3WhiteRun( len );
+                    }
+                    // initialise length and color;
+                    len = 1;
+                    currentColor = *p;
+                }
+            } else if ( imageFormat == QImage::Format_Mono ) {
+    	        pixel = ((scan[x >> 3] & (1 << (x & 7))) != 0);
+    	        if ( pixel != prev ) {
+		    if ( prev ) {
+		        writeG3BlackRun( len );
+                    } else {
+	    	        writeG3WhiteRun( len );
+		    }
+		    prev = pixel;
+		    len = 1;
+	        } else {
+		    ++len;
+	        }
+            }
+	}
+
+        if ( imageFormat == QImage::Format_RGB32 ) {
+    	    // Output the last run on the line, and pad to TIFF_FAX_WIDTH.
+            if ( len != 0 ) {
+                if ( currentColor == qRgb(0, 0, 0) )
+                    writeG3BlackRun( len );
+                else
+                    writeG3WhiteRun( len );
+            }
+            if ( width < TIFF_FAX_WIDTH )
+                writeG3WhiteRun( TIFF_FAX_WIDTH - width );
+        } else if ( imageFormat == QImage::Format_Mono ) {
+            if ( len != 0 ) {
+	        if ( prev ) {
+		    writeG3BlackRun( len );
+		    if ( width < TIFF_FAX_WIDTH ) {
+		        writeG3WhiteRun( TIFF_FAX_WIDTH - width );
+		    }
+	        } else {
+		    if ( width < TIFF_FAX_WIDTH ) {
+		        writeG3WhiteRun( len + ( TIFF_FAX_WIDTH - width ) );
+		    } else {
+		        writeG3WhiteRun( len );
+		    }
+	        }
+	    }
+        }
+    }
+
+    // Flush the last partial byte, which is padded with zero fill bits.
+    if ( partialBits > 0 ) {
+	buffer.append( (char)( partialByte << ( 8 - partialBits ) ) );
+	partialByte = 0;
+	partialBits = 0;
+    }
+
+    // end of page add six EOLs
+    for ( int i = 0; i < 6; i++ )
+        writeG3EOL();
+
+    // Update the byte count for the image data strip.
+    buffer.patch( stripBytes, buffer.size() - start );
+}
+
+int QtopiaPrintEnginePrivate::writeG3IFDEntry
+	( int tag, int type, int count, int value )
+{
+    buffer.append( (short)tag );
+    buffer.append( (short)type );
+    buffer.append( count );
+    buffer.append( value );
+    return buffer.size() - 4;    // Offset of the value for back-patching.
+}
+
+void QtopiaPrintEnginePrivate::writeG3Code( int code, int bits )
+{
+    partialByte = ( ( partialByte << bits ) | code );
+    partialBits += bits;
+    while ( partialBits >= 8 ) {
+	partialBits -= 8;
+	buffer.append( (char)( partialByte >> partialBits ) );
+    }
+}
+
+void QtopiaPrintEnginePrivate::writeG3WhiteRun( int len )
+{
+    static struct {
+	unsigned short code;
+	unsigned short bits;
+    } whiteCodes[64 + 27] = {
+	{0x0035, 8},		// 0
+	{0x0007, 6},
+	{0x0007, 4},
+	{0x0008, 4},
+	{0x000B, 4},
+	{0x000C, 4},
+	{0x000E, 4},
+	{0x000F, 4},
+	{0x0013, 5},		// 8
+	{0x0014, 5},
+	{0x0007, 5},
+	{0x0008, 5},
+	{0x0008, 6},
+	{0x0003, 6},
+	{0x0034, 6},
+	{0x0035, 6},
+	{0x002A, 6},		// 16
+	{0x002B, 6},
+	{0x0027, 7},
+	{0x000C, 7},
+	{0x0008, 7},
+	{0x0017, 7},
+	{0x0003, 7},
+	{0x0004, 7},
+	{0x0028, 7},		// 24
+	{0x002B, 7},
+	{0x0013, 7},
+	{0x0024, 7},
+	{0x0018, 7},
+	{0x0002, 8},
+	{0x0003, 8},
+	{0x001A, 8},
+	{0x001B, 8},		// 32
+	{0x0012, 8},
+	{0x0013, 8},
+	{0x0014, 8},
+	{0x0015, 8},
+	{0x0016, 8},
+	{0x0017, 8},
+	{0x0028, 8},
+	{0x0029, 8},		// 40
+	{0x002A, 8},
+	{0x002B, 8},
+	{0x002C, 8},
+	{0x002D, 8},
+	{0x0004, 8},
+	{0x0005, 8},
+	{0x000A, 8},
+	{0x000B, 8},		// 48
+	{0x0052, 8},
+	{0x0053, 8},
+	{0x0054, 8},
+	{0x0055, 8},
+	{0x0024, 8},
+	{0x0025, 8},
+	{0x0058, 8},
+	{0x0059, 8},		// 56
+	{0x005A, 8},
+	{0x005B, 8},
+	{0x004A, 8},
+	{0x004B, 8},
+	{0x0032, 8},
+	{0x0033, 8},
+	{0x0034, 8},
+	{0x001B, 5},		// Make up codes: 64
+	{0x0012, 5},		// 128
+	{0x0017, 6},		// 192
+	{0x0037, 7},		// 256
+	{0x0036, 8},		// 320
+	{0x0037, 8},		// 384
+	{0x0064, 8},		// 448
+	{0x0065, 8},		// 512
+	{0x0068, 8},		// 576
+	{0x0067, 8},		// 640
+	{0x00CC, 9},		// 704
+	{0x00CD, 9},		// 768
+	{0x00D2, 9},		// 832
+	{0x00D3, 9},		// 896
+	{0x00D4, 9},		// 960
+	{0x00D5, 9},		// 1024
+	{0x00D6, 9},		// 1088
+	{0x00D7, 9},		// 1152
+	{0x00D8, 9},		// 1216
+	{0x00D9, 9},		// 1280
+	{0x00DA, 9},		// 1344
+	{0x00DB, 9},		// 1408
+	{0x0098, 9},		// 1472
+	{0x0099, 9},		// 1536
+	{0x009A, 9},		// 1600
+	{0x0018, 6},		// 1664
+	{0x009B, 9},		// 1728
+    };
+    if ( len >= 64 ) {
+	int index = 63 + (len >> 6);
+	writeG3Code( whiteCodes[index].code, whiteCodes[index].bits );
+	len &= 63;
+    }
+    writeG3Code( whiteCodes[len].code, whiteCodes[len].bits );
+}
+
+void QtopiaPrintEnginePrivate::writeG3BlackRun( int len )
+{
+    static struct {
+	unsigned short code;
+	unsigned short bits;
+    } blackCodes[64 + 27] = {
+	{0x0037, 10},		// 0
+	{0x0002, 3},
+	{0x0003, 2},
+	{0x0002, 2},
+	{0x0003, 3},
+	{0x0003, 4},
+	{0x0002, 4},
+	{0x0003, 5},
+	{0x0005, 6},		// 8
+	{0x0004, 6},
+	{0x0004, 7},
+	{0x0005, 7},
+	{0x0007, 7},
+	{0x0004, 8},
+	{0x0007, 8},
+	{0x0018, 9},
+	{0x0017, 10},		// 16
+	{0x0018, 10},
+	{0x0008, 10},
+	{0x0067, 11},
+	{0x0068, 11},
+	{0x006C, 11},
+	{0x0037, 11},
+	{0x0028, 11},
+	{0x0017, 11},		// 24
+	{0x0018, 11},
+	{0x00CA, 12},
+	{0x00CB, 12},
+	{0x00CC, 12},
+	{0x00CD, 12},
+	{0x0068, 12},
+	{0x0069, 12},
+	{0x006A, 12},		// 32
+	{0x006B, 12},
+	{0x00D2, 12},
+	{0x00D3, 12},
+	{0x00D4, 12},
+	{0x00D5, 12},
+	{0x00D6, 12},
+	{0x00D7, 12},
+	{0x006C, 12},		// 40
+	{0x006D, 12},
+	{0x00DA, 12},
+	{0x00DB, 12},
+	{0x0054, 12},
+	{0x0055, 12},
+	{0x0056, 12},
+	{0x0057, 12},
+	{0x0064, 12},		// 48
+	{0x0065, 12},
+	{0x0052, 12},
+	{0x0053, 12},
+	{0x0024, 12},
+	{0x0037, 12},
+	{0x0038, 12},
+	{0x0027, 12},
+	{0x0028, 12},		// 56
+	{0x0058, 12},
+	{0x0059, 12},
+	{0x002B, 12},
+	{0x002C, 12},
+	{0x005A, 12},
+	{0x0066, 12},
+	{0x0067, 12},
+	{0x000F, 10},		// Make up codes: 64
+	{0x00C8, 12},		// 128
+	{0x00C9, 12},		// 192
+	{0x005B, 12},		// 256
+	{0x0033, 12},		// 320
+	{0x0034, 12},		// 384
+	{0x0035, 12},		// 448
+	{0x006C, 13},		// 512
+	{0x006D, 13},		// 576
+	{0x004A, 13},		// 640
+	{0x004B, 13},		// 704
+	{0x004C, 13},		// 768
+	{0x004D, 13},		// 832
+	{0x0072, 13},		// 896
+	{0x0073, 13},		// 960
+	{0x0074, 13},		// 1024
+	{0x0075, 13},		// 1088
+	{0x0076, 13},		// 1152
+	{0x0077, 13},		// 1216
+	{0x0052, 13},		// 1280
+	{0x0053, 13},		// 1344
+	{0x0054, 13},		// 1408
+	{0x0055, 13},		// 1472
+	{0x005A, 13},		// 1536
+	{0x005B, 13},		// 1600
+	{0x0064, 13},		// 1664
+	{0x0065, 13},		// 1728
+    };
+    if ( len >= 64 ) {
+	int index = 63 + (len >> 6);
+	writeG3Code( blackCodes[index].code, blackCodes[index].bits );
+	len &= 63;
+    }
+    writeG3Code( blackCodes[len].code, blackCodes[len].bits );
+}
+
+void QtopiaPrintEnginePrivate::writeG3EOL()
+{
+    int bitToPad;
+    if ( partialBits <= 4 ) {
+        bitToPad = 4 - partialBits;
+    } else {
+        bitToPad = 8 - partialBits + 4;
+    }
+
+    partialByte = ((partialByte << (bitToPad + 12)) | 0x0001);
+    partialBits += bitToPad + 12;
+
+    while ( partialBits >= 8 ) {
+        partialBits -= 8;
+        buffer.append( (char)(partialByte >> partialBits ) );
+    }
+//    writeG3Code( 0x0001, 12 );
+}
+
+void QtopiaPrintBuffer::append( short value )
+{
+    if ( _bigEndian ) {
+	_data.append( (char)(value >> 8) );
+	_data.append( (char)value );
+    } else {
+	_data.append( (char)value );
+	_data.append( (char)(value >> 8) );
+    }
+}
+
+void QtopiaPrintBuffer::append( int value )
+{
+    if ( _bigEndian ) {
+	_data.append( (char)(value >> 24) );
+	_data.append( (char)(value >> 16) );
+	_data.append( (char)(value >> 8) );
+	_data.append( (char)value );
+    } else {
+	_data.append( (char)value );
+	_data.append( (char)(value >> 8) );
+	_data.append( (char)(value >> 16) );
+	_data.append( (char)(value >> 24) );
+    }
+}
+
+void QtopiaPrintBuffer::patch( int posn, int value )
+{
+    if ( _bigEndian ) {
+	_data[posn]     = (char)(value >> 24);
+	_data[posn + 1] = (char)(value >> 16);
+	_data[posn + 2] = (char)(value >> 8);
+	_data[posn + 3] = (char)value;
+    } else {
+        _data[posn]     = (char)value;
+	_data[posn + 1] = (char)(value >> 8);
+	_data[posn + 2] = (char)(value >> 16);
+	_data[posn + 3] = (char)(value >> 24);
+    }
+}
+
+void QtopiaPrintBuffer::pad()
+{
+    while ( ( _data.size() % 4 ) != 0 )
+	_data.append( (char)0 );
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_PRINTER
diff --git a/src/gui/painting/qprintengine_qws_p.h b/src/gui/painting/qprintengine_qws_p.h
new file mode 100644
index 0000000000..59cbe3eba8
--- /dev/null
+++ b/src/gui/painting/qprintengine_qws_p.h
@@ -0,0 +1,213 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPRINTENGINE_QWS_P_H
+#define QPRINTENGINE_QWS_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of other Qt classes.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "QtGui/qprinter.h"
+
+#ifndef QT_NO_PRINTER
+
+#include "QtGui/qprintengine.h"
+#include "QtCore/qbytearray.h"
+#include "private/qpaintengine_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QtopiaPrintEnginePrivate;
+class QRasterPaintEngine;
+class QPrinterPrivate;
+class QImage;
+
+class QtopiaPrintEngine : public QPaintEngine, public QPrintEngine
+{
+    Q_DECLARE_PRIVATE(QtopiaPrintEngine)
+public:
+    QtopiaPrintEngine(QPrinter::PrinterMode mode);
+
+    // override QWSPaintEngine
+    bool begin(QPaintDevice *dev);
+    bool end();
+    void drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr);
+    void drawTextItem(const QPointF &p, const QTextItem &ti);
+    QPaintEngine::Type type() const { return QPaintEngine::X11; }
+
+    QPaintEngine *paintEngine() const;
+
+    void updateState(const QPaintEngineState &state);
+
+    QRect paperRect() const;
+    QRect pageRect() const;
+
+    bool newPage();
+    bool abort();
+
+    QPrinter::PrinterState printerState() const;
+
+    int metric(QPaintDevice::PaintDeviceMetric metricType) const;
+
+    QVariant property(PrintEnginePropertyKey key) const;
+    void setProperty(PrintEnginePropertyKey key, const QVariant &value);
+
+private:
+    friend class QPrintDialog;
+    friend class QPageSetupDialog;
+
+    void clearPage();
+    void flushPage();
+};
+
+class QtopiaPrintBuffer
+{
+public:
+    QtopiaPrintBuffer( bool bigEndian=FALSE ) { _bigEndian = bigEndian; }
+    ~QtopiaPrintBuffer() {}
+
+    const QByteArray& data() const { return _data; }
+
+    int size() const { return _data.size(); }
+
+    void clear() { _data.clear(); }
+
+    void append( char value ) { _data.append( value ); }
+    void append( short value );
+    void append( int value );
+    void append( const QByteArray& array ) { _data.append( array ); }
+
+    void patch( int posn, int value );
+
+    void pad();
+
+private:
+    QByteArray _data;
+    bool _bigEndian;
+};
+
+#define	QT_QWS_PRINTER_DEFAULT_DPI	   200
+
+class QtopiaPrintEnginePrivate : public QPaintEnginePrivate
+{
+    Q_DECLARE_PUBLIC(QtopiaPrintEngine)
+public:
+    QtopiaPrintEnginePrivate(QPrinter::PrinterMode m) :
+	mode(m),
+	printerState(QPrinter::Idle),
+	orientation(QPrinter::Portrait),
+	paperSize(QPrinter::A4),
+	pageOrder(QPrinter::FirstPageFirst),
+	colorMode(QPrinter::GrayScale),
+	paperSource(QPrinter::OnlyOne),
+        resolution(QT_QWS_PRINTER_DEFAULT_DPI),
+        _paintEngine(0),
+	numCopies(1),
+        outputToFile(false),
+        fullPage(false),
+        collateCopies(false),
+	pageNumber(0),
+	pageImage(0),
+	partialByte(0),
+	partialBits(0)
+    {
+    }
+    ~QtopiaPrintEnginePrivate();
+
+    void initialize();
+    QPaintEngine *paintEngine();
+
+    QPrinter::PrinterMode mode;
+
+    QString printerName;
+    QString outputFileName;
+    QString printProgram;
+    QString docName;
+    QString creator;
+
+    QPrinter::PrinterState printerState;
+
+    QPrinter::Orientation orientation;
+    QPrinter::PaperSize paperSize;
+    QPrinter::PageOrder pageOrder;
+    QPrinter::ColorMode colorMode;
+    QPrinter::PaperSource paperSource;
+
+    int resolution;
+    QPaintEngine *_paintEngine;
+    int numCopies;
+
+    bool outputToFile;
+    bool fullPage;
+    bool collateCopies;
+
+    int pageNumber;
+
+    QImage *pageImage;
+
+    QtopiaPrintBuffer buffer;
+
+    // Definitions that are only relevant to G3FAX output.
+    int ifdPatch;
+    int partialByte;
+    int partialBits;
+    void writeG3FaxHeader();
+    void writeG3FaxPage();
+    int writeG3IFDEntry( int tag, int type, int count, int value );
+    void writeG3Code( int code, int bits );
+    void writeG3WhiteRun( int len );
+    void writeG3BlackRun( int len );
+    void writeG3EOL();
+};
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_PRINTER
+
+#endif // QPRINTENGINE_QWS_P_H
diff --git a/src/gui/painting/qprintengine_win.cpp b/src/gui/painting/qprintengine_win.cpp
new file mode 100644
index 0000000000..07d66f5bd0
--- /dev/null
+++ b/src/gui/painting/qprintengine_win.cpp
@@ -0,0 +1,1776 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QT_NO_PRINTER
+
+#include "qprinter_p.h"
+#include "qprintengine_win_p.h"
+
+#include <limits.h>
+
+#include <private/qfont_p.h>
+#include <private/qfontengine_p.h>
+#include <private/qpainter_p.h>
+
+#include <qbitmap.h>
+#include <qdebug.h>
+#include <qvector.h>
+#include <qpicture.h>
+#include <private/qpicture_p.h>
+
+QT_BEGIN_NAMESPACE
+
+extern QPainterPath qt_regionToPath(const QRegion &region);
+
+// #define QT_DEBUG_DRAW
+
+static void draw_text_item_win(const QPointF &_pos, const QTextItemInt &ti, HDC hdc,
+                               bool convertToText, const QTransform &xform, const QPointF &topLeft);
+
+static const struct {
+    int winSizeName;
+    QPrinter::PaperSize qtSizeName;
+} dmMapping[] = {
+    { DMPAPER_LETTER,             QPrinter::Letter },
+    { DMPAPER_LETTERSMALL,        QPrinter::Letter },
+    { DMPAPER_TABLOID,            QPrinter::Tabloid },
+    { DMPAPER_LEDGER,             QPrinter::Ledger },
+    { DMPAPER_LEGAL,              QPrinter::Legal },
+    { DMPAPER_EXECUTIVE,          QPrinter::Executive },
+    { DMPAPER_A3,                 QPrinter::A3 },
+    { DMPAPER_A4,                 QPrinter::A4 },
+    { DMPAPER_A4SMALL,            QPrinter::A4 },
+    { DMPAPER_A5,                 QPrinter::A5 },
+    { DMPAPER_B4,                 QPrinter::B4 },
+    { DMPAPER_B5,                 QPrinter::B5 },
+    { DMPAPER_FOLIO,              QPrinter::Folio },
+    { DMPAPER_ENV_10,             QPrinter::Comm10E },
+    { DMPAPER_ENV_DL,             QPrinter::DLE },
+    { DMPAPER_ENV_C3,             QPrinter::C5E },
+    { DMPAPER_LETTER_EXTRA,       QPrinter::Letter },
+    { DMPAPER_LEGAL_EXTRA,        QPrinter::Legal },
+    { DMPAPER_TABLOID_EXTRA,      QPrinter::Tabloid },
+    { DMPAPER_A4_EXTRA,           QPrinter::A4},
+    { DMPAPER_LETTER_TRANSVERSE,  QPrinter::Letter},
+    { DMPAPER_A4_TRANSVERSE,      QPrinter::A4},
+    { DMPAPER_LETTER_EXTRA_TRANSVERSE, QPrinter::Letter },
+    { DMPAPER_A_PLUS,             QPrinter::A4 },
+    { DMPAPER_B_PLUS,             QPrinter::A3 },
+    { DMPAPER_LETTER_PLUS,        QPrinter::Letter },
+    { DMPAPER_A4_PLUS,            QPrinter::A4 },
+    { DMPAPER_A5_TRANSVERSE,      QPrinter::A5 },
+    { DMPAPER_B5_TRANSVERSE,      QPrinter::B5 },
+    { DMPAPER_A3_EXTRA,           QPrinter::A3 },
+    { DMPAPER_A5_EXTRA,           QPrinter::A5 },
+    { DMPAPER_B5_EXTRA,           QPrinter::B5 },
+    { DMPAPER_A2,                 QPrinter::A2 },
+    { DMPAPER_A3_TRANSVERSE,      QPrinter::A3 },
+    { DMPAPER_A3_EXTRA_TRANSVERSE,QPrinter::A3 },
+    { 0, QPrinter::Custom }
+};
+
+QPrinter::PaperSize mapDevmodePaperSize(int s)
+{
+    int i = 0;
+    while ((dmMapping[i].winSizeName > 0) && (dmMapping[i].winSizeName != s))
+        i++;
+    return dmMapping[i].qtSizeName;
+}
+
+static int mapPaperSizeDevmode(QPrinter::PaperSize s)
+{
+    int i = 0;
+ while ((dmMapping[i].winSizeName > 0) && (dmMapping[i].qtSizeName != s))
+        i++;
+    return dmMapping[i].winSizeName;
+}
+
+static const struct {
+    int winSourceName;
+    QPrinter::PaperSource qtSourceName;
+}  sources[] = {
+    { DMBIN_ONLYONE,        QPrinter::OnlyOne },
+    { DMBIN_LOWER,          QPrinter::Lower },
+    { DMBIN_MIDDLE,         QPrinter::Middle },
+    { DMBIN_MANUAL,         QPrinter::Manual },
+    { DMBIN_ENVELOPE,       QPrinter::Envelope },
+    { DMBIN_ENVMANUAL,      QPrinter::EnvelopeManual },
+    { DMBIN_AUTO,           QPrinter::Auto },
+    { DMBIN_TRACTOR,        QPrinter::Tractor },
+    { DMBIN_SMALLFMT,       QPrinter::SmallFormat },
+    { DMBIN_LARGEFMT,       QPrinter::LargeFormat },
+    { DMBIN_LARGECAPACITY,  QPrinter::LargeCapacity },
+    { DMBIN_CASSETTE,       QPrinter::Cassette },
+    { DMBIN_FORMSOURCE,     QPrinter::FormSource },
+    { 0, (QPrinter::PaperSource) -1 }
+};
+
+static QPrinter::PaperSource mapDevmodePaperSource(int s)
+{
+    int i = 0;
+    while ((sources[i].winSourceName > 0) && (sources[i].winSourceName != s))
+        i++;
+    return sources[i].winSourceName ? sources[i].qtSourceName : (QPrinter::PaperSource) s;
+}
+
+static int mapPaperSourceDevmode(QPrinter::PaperSource s)
+{
+    int i = 0;
+    while ((sources[i].qtSourceName >= 0) && (sources[i].qtSourceName != s))
+        i++;
+    return sources[i].winSourceName ? sources[i].winSourceName : s;
+}
+
+QWin32PrintEngine::QWin32PrintEngine(QPrinter::PrinterMode mode)
+    : QAlphaPaintEngine(*(new QWin32PrintEnginePrivate),
+                   PaintEngineFeatures(PrimitiveTransform
+                                       | PixmapTransform
+                                       | PerspectiveTransform
+                                       | PainterPaths
+                                       | Antialiasing
+                                       | PaintOutsidePaintEvent))
+{
+    Q_D(QWin32PrintEngine);
+    d->docName = QLatin1String("document1");
+    d->mode = mode;
+    d->queryDefault();
+    d->initialize();
+}
+
+bool QWin32PrintEngine::begin(QPaintDevice *pdev)
+{
+    Q_D(QWin32PrintEngine);
+
+    QAlphaPaintEngine::begin(pdev);
+    if (!continueCall())
+        return true;
+
+    if (d->reinit) {
+       d->resetDC();
+       d->reinit = false;
+    }
+
+    // ### set default colors and stuff...
+
+    bool ok = d->state == QPrinter::Idle;
+
+    if (!d->hdc)
+        return false;
+
+    // Assign the FILE: to get the query...
+    if (d->printToFile && d->fileName.isEmpty())
+        d->fileName = d->port;
+
+    d->devMode->dmCopies = d->num_copies;
+
+    DOCINFO di;
+    memset(&di, 0, sizeof(DOCINFO));
+    di.cbSize = sizeof(DOCINFO);
+    di.lpszDocName = reinterpret_cast<const wchar_t *>(d->docName.utf16());
+    if (d->printToFile && !d->fileName.isEmpty())
+        di.lpszOutput = reinterpret_cast<const wchar_t *>(d->fileName.utf16());
+    if (ok && StartDoc(d->hdc, &di) == SP_ERROR) {
+        qErrnoWarning("QWin32PrintEngine::begin: StartDoc failed");
+        ok = false;
+    }
+
+    if (StartPage(d->hdc) <= 0) {
+        qErrnoWarning("QWin32PrintEngine::begin: StartPage failed");
+        ok = false;
+    }
+
+    if (!ok) {
+        d->state = QPrinter::Idle;
+    } else {
+        d->state = QPrinter::Active;
+    }
+
+    d->matrix = QTransform();
+    d->has_pen = true;
+    d->pen = QColor(Qt::black);
+    d->has_brush = false;
+
+    d->complex_xform = false;
+
+    updateMatrix(d->matrix);
+
+    if (!ok)
+        cleanUp();
+
+    return ok;
+}
+
+bool QWin32PrintEngine::end()
+{
+    Q_D(QWin32PrintEngine);
+
+    if (d->hdc) {
+        if (d->state == QPrinter::Aborted) {
+            cleanUp();
+            AbortDoc(d->hdc);
+            return true;
+        }
+    }
+
+    QAlphaPaintEngine::end();
+    if (!continueCall())
+        return true;
+
+    if (d->hdc) {
+        EndPage(d->hdc);                 // end; printing done
+        EndDoc(d->hdc);
+    }
+
+    d->state = QPrinter::Idle;
+    d->reinit = true;
+    return true;
+}
+
+bool QWin32PrintEngine::newPage()
+{
+    Q_D(QWin32PrintEngine);
+    Q_ASSERT(isActive());
+
+    Q_ASSERT(d->hdc);
+
+    flushAndInit();
+
+    bool transparent = GetBkMode(d->hdc) == TRANSPARENT;
+
+    if (!EndPage(d->hdc)) {
+        qErrnoWarning("QWin32PrintEngine::newPage: EndPage failed");
+        return false;
+    }
+
+    if (d->reinit) {
+        if (!d->resetDC()) {
+            qErrnoWarning("QWin32PrintEngine::newPage: ResetDC failed");
+            return false;
+        }
+        d->reinit = false;
+    }
+
+    if (!StartPage(d->hdc)) {
+        qErrnoWarning("Win32PrintEngine::newPage: StartPage failed");
+        return false;
+    }
+
+    SetTextAlign(d->hdc, TA_BASELINE);
+    if (transparent)
+        SetBkMode(d->hdc, TRANSPARENT);
+
+    // ###
+    return true;
+
+    bool success = false;
+    if (d->hdc && d->state == QPrinter::Active) {
+        if (EndPage(d->hdc) != SP_ERROR) {
+            // reinitialize the DC before StartPage if needed,
+            // because resetdc is disabled between calls to the StartPage and EndPage functions
+            // (see StartPage documentation in the Platform SDK:Windows GDI)
+//          state = PST_ACTIVEDOC;
+//          reinit();
+//          state = PST_ACTIVE;
+            // start the new page now
+            if (d->reinit) {
+                if (!d->resetDC())
+                    qErrnoWarning("QWin32PrintEngine::newPage(), ResetDC failed (2)");
+                d->reinit = false;
+            }
+            success = (StartPage(d->hdc) != SP_ERROR);
+        }
+        if (!success) {
+            d->state = QPrinter::Aborted;
+            return false;
+        }
+    }
+    return true;
+}
+
+bool QWin32PrintEngine::abort()
+{
+    // do nothing loop.
+    return false;
+}
+
+void QWin32PrintEngine::drawTextItem(const QPointF &p, const QTextItem &textItem)
+{
+    Q_D(const QWin32PrintEngine);
+
+    QAlphaPaintEngine::drawTextItem(p, textItem);
+    if (!continueCall())
+        return;
+
+    const QTextItemInt &ti = static_cast<const QTextItemInt &>(textItem);
+    QRgb brushColor = state->pen().brush().color().rgb();
+    bool fallBack = state->pen().brush().style() != Qt::SolidPattern
+                    || qAlpha(brushColor) != 0xff
+                    || d->txop >= QTransform::TxProject
+                    || ti.fontEngine->type() != QFontEngine::Win;
+
+
+    if (!fallBack) {
+        QFontEngineWin *fe = static_cast<QFontEngineWin *>(ti.fontEngine);
+
+        // Try selecting the font to see if we get a substitution font
+        SelectObject(d->hdc, fe->hfont);
+
+        if (GetDeviceCaps(d->hdc, TECHNOLOGY) != DT_CHARSTREAM) {
+            wchar_t n[64];
+            GetTextFace(d->hdc, 64, n);
+            fallBack = QString::fromWCharArray(n)
+                    != QString::fromWCharArray(fe->logfont.lfFaceName);
+        }
+    }
+
+
+    if (fallBack) {
+        QPaintEngine::drawTextItem(p, textItem);
+        return ;
+    }
+
+    // We only want to convert the glyphs to text if the entire string is compatible with ASCII
+    // and if we actually have access to the chars.
+    bool convertToText = ti.chars != 0;
+    for (int i=0;  i < ti.num_chars; ++i) {
+        if (ti.chars[i].unicode() >= 0x80) {
+            convertToText = false;
+            break;
+        }
+
+        if (ti.logClusters[i] != i) {
+            convertToText = false;
+            break;
+        }
+    }
+
+    COLORREF cf = RGB(qRed(brushColor), qGreen(brushColor), qBlue(brushColor));
+    SelectObject(d->hdc, CreateSolidBrush(cf));
+    SelectObject(d->hdc, CreatePen(PS_SOLID, 1, cf));
+    SetTextColor(d->hdc, cf);
+
+    draw_text_item_win(p, ti, d->hdc, convertToText, d->matrix, d->devPaperRect.topLeft());
+    DeleteObject(SelectObject(d->hdc,GetStockObject(HOLLOW_BRUSH)));
+    DeleteObject(SelectObject(d->hdc,GetStockObject(BLACK_PEN)));
+}
+
+static inline qreal mmToInches(double mm)
+{
+    return mm*0.039370147;
+}
+
+static inline qreal inchesToMM(double in)
+{
+    return in/0.039370147;
+}
+
+int QWin32PrintEngine::metric(QPaintDevice::PaintDeviceMetric m) const
+{
+    Q_D(const QWin32PrintEngine);
+
+    if (!d->hdc)
+        return 0;
+
+    int val;
+    int res = d->resolution;
+
+    switch (m) {
+    case QPaintDevice::PdmWidth:
+        if (d->has_custom_paper_size) {
+            val =  qRound(d->paper_size.width() * res / 72.0);
+        } else {
+            int logPixelsX = GetDeviceCaps(d->hdc, LOGPIXELSX);
+            if (logPixelsX == 0) {
+                qWarning("QWin32PrintEngine::metric: GetDeviceCaps() failed, "
+                        "might be a driver problem");
+                logPixelsX = 600; // Reasonable default
+            }
+            val = res
+                  * GetDeviceCaps(d->hdc, d->fullPage ? PHYSICALWIDTH : HORZRES)
+                  / logPixelsX;
+        }
+        if (d->pageMarginsSet)
+            val -= int(mmToInches((d->previousDialogMargins.left() +
+                                   d->previousDialogMargins.width()) / 100.0) * res);
+        break;
+    case QPaintDevice::PdmHeight:
+        if (d->has_custom_paper_size) {
+            val = qRound(d->paper_size.height() * res / 72.0);
+        } else {
+            int logPixelsY = GetDeviceCaps(d->hdc, LOGPIXELSY);
+            if (logPixelsY == 0) {
+                qWarning("QWin32PrintEngine::metric: GetDeviceCaps() failed, "
+                        "might be a driver problem");
+                logPixelsY = 600; // Reasonable default
+            }
+            val = res
+                  * GetDeviceCaps(d->hdc, d->fullPage ? PHYSICALHEIGHT : VERTRES)
+                  / logPixelsY;
+        }
+        if (d->pageMarginsSet)
+            val -= int(mmToInches((d->previousDialogMargins.top() +
+                                   d->previousDialogMargins.height()) / 100.0) * res);
+        break;
+    case QPaintDevice::PdmDpiX:
+        val = res;
+        break;
+    case QPaintDevice::PdmDpiY:
+        val = res;
+        break;
+    case QPaintDevice::PdmPhysicalDpiX:
+        val = GetDeviceCaps(d->hdc, LOGPIXELSX);
+        break;
+    case QPaintDevice::PdmPhysicalDpiY:
+        val = GetDeviceCaps(d->hdc, LOGPIXELSY);
+        break;
+    case QPaintDevice::PdmWidthMM:
+        if (d->has_custom_paper_size) {
+            val = qRound(d->paper_size.width()*25.4/72);
+        } else {
+            if (!d->fullPage) {
+                val = GetDeviceCaps(d->hdc, HORZSIZE);
+            } else {
+                float wi = 25.4 * GetDeviceCaps(d->hdc, PHYSICALWIDTH);
+                int logPixelsX = GetDeviceCaps(d->hdc,  LOGPIXELSX);
+                if (logPixelsX == 0) {
+                    qWarning("QWin32PrintEngine::metric: GetDeviceCaps() failed, "
+                            "might be a driver problem");
+                    logPixelsX = 600; // Reasonable default
+                }
+                val = qRound(wi / logPixelsX);
+            }
+        }
+        if (d->pageMarginsSet)
+            val -= (d->previousDialogMargins.left() +
+                    d->previousDialogMargins.width()) / 100.0;
+        break;
+    case QPaintDevice::PdmHeightMM:
+        if (d->has_custom_paper_size) {
+            val = qRound(d->paper_size.height()*25.4/72);
+        } else {
+            if (!d->fullPage) {
+                val = GetDeviceCaps(d->hdc, VERTSIZE);
+            } else {
+                float hi = 25.4 * GetDeviceCaps(d->hdc, PHYSICALHEIGHT);
+                int logPixelsY = GetDeviceCaps(d->hdc,  LOGPIXELSY);
+                if (logPixelsY == 0) {
+                    qWarning("QWin32PrintEngine::metric: GetDeviceCaps() failed, "
+                            "might be a driver problem");
+                    logPixelsY = 600; // Reasonable default
+                }
+                val = qRound(hi / logPixelsY);
+            }
+        }
+        if (d->pageMarginsSet)
+            val -= (d->previousDialogMargins.top() +
+                    d->previousDialogMargins.height()) / 100.0;
+        break;
+    case QPaintDevice::PdmNumColors:
+        {
+            int bpp = GetDeviceCaps(d->hdc, BITSPIXEL);
+            if(bpp==32)
+                val = INT_MAX;
+            else if(bpp<=8)
+                val = GetDeviceCaps(d->hdc, NUMCOLORS);
+            else
+                val = 1 << (bpp * GetDeviceCaps(d->hdc, PLANES));
+        }
+        break;
+    case QPaintDevice::PdmDepth:
+        val = GetDeviceCaps(d->hdc, PLANES);
+        break;
+    default:
+        qWarning("QPrinter::metric: Invalid metric command");
+        return 0;
+    }
+    return val;
+}
+
+void QWin32PrintEngine::updateState(const QPaintEngineState &state)
+{
+    Q_D(QWin32PrintEngine);
+
+    QAlphaPaintEngine::updateState(state);
+    if (!continueCall())
+        return;
+
+    if (state.state() & DirtyTransform) {
+        updateMatrix(state.transform());
+    }
+
+    if (state.state() & DirtyPen) {
+        d->pen = state.pen();
+        d->has_pen = d->pen.style() != Qt::NoPen && d->pen.isSolid();
+    }
+
+    if (state.state() & DirtyBrush) {
+        QBrush brush = state.brush();
+        d->has_brush = brush.style() == Qt::SolidPattern;
+        d->brush_color = brush.color();
+    }
+
+    if (state.state() & DirtyClipEnabled) {
+        if (state.isClipEnabled())
+            updateClipPath(painter()->clipPath(), Qt::ReplaceClip);
+        else
+            updateClipPath(QPainterPath(), Qt::NoClip);
+    }
+
+    if (state.state() & DirtyClipPath) {
+        updateClipPath(state.clipPath(), state.clipOperation());
+    }
+
+    if (state.state() & DirtyClipRegion) {
+        QRegion clipRegion = state.clipRegion();
+        QPainterPath clipPath = qt_regionToPath(clipRegion);
+        updateClipPath(clipPath, state.clipOperation());
+    }
+}
+
+void QWin32PrintEngine::updateClipPath(const QPainterPath &clipPath, Qt::ClipOperation op)
+{
+    Q_D(QWin32PrintEngine);
+
+    bool doclip = true;
+    if (op == Qt::NoClip) {
+        SelectClipRgn(d->hdc, 0);
+        doclip = false;
+    }
+
+    if (doclip) {
+        QPainterPath xformed = clipPath * d->matrix;
+
+        if (xformed.isEmpty()) {
+            QRegion empty(-0x1000000, -0x1000000, 1, 1);
+            SelectClipRgn(d->hdc, empty.handle());
+        } else {
+            d->composeGdiPath(xformed);
+            const int ops[] = {
+                -1,         // Qt::NoClip, covered above
+                RGN_COPY,   // Qt::ReplaceClip
+                RGN_AND,    // Qt::IntersectClip
+                RGN_OR      // Qt::UniteClip
+            };
+            Q_ASSERT(op > 0 && unsigned(op) <= sizeof(ops) / sizeof(int));
+            SelectClipPath(d->hdc, ops[op]);
+        }
+    }
+
+    QPainterPath aclip = qt_regionToPath(alphaClipping());
+    if (!aclip.isEmpty()) {
+        QTransform tx(d->stretch_x, 0, 0, d->stretch_y, d->origin_x, d->origin_y);
+        d->composeGdiPath(tx.map(aclip));
+        SelectClipPath(d->hdc, RGN_DIFF);
+    }
+}
+
+void QWin32PrintEngine::updateMatrix(const QTransform &m)
+{
+    Q_D(QWin32PrintEngine);
+
+    QTransform stretch(d->stretch_x, 0, 0, d->stretch_y, d->origin_x, d->origin_y);
+    d->painterMatrix = m;
+    d->matrix = d->painterMatrix * stretch;
+    d->txop = d->matrix.type();
+    d->complex_xform = (d->txop > QTransform::TxScale);
+}
+
+void QWin32PrintEngine::drawPixmap(const QRectF &targetRect,
+                                   const QPixmap &originalPixmap,
+                                   const QRectF &sourceRect)
+{
+    Q_D(QWin32PrintEngine);
+
+    QAlphaPaintEngine::drawPixmap(targetRect, originalPixmap, sourceRect);
+    if (!continueCall())
+        return;
+
+    const int tileSize = 2048;
+
+    QRectF r = targetRect;
+    QRectF sr = sourceRect;
+
+    QPixmap pixmap = originalPixmap;
+    if (sr.size() != pixmap.size()) {
+        pixmap = pixmap.copy(sr.toRect());
+    }
+
+    qreal scaleX = 1.0f;
+    qreal scaleY = 1.0f;
+
+    QTransform scaleMatrix = QTransform::fromScale(r.width() / pixmap.width(), r.height() / pixmap.height());
+    QTransform adapted = QPixmap::trueMatrix(d->painterMatrix * scaleMatrix,
+                                             pixmap.width(), pixmap.height());
+
+    qreal xform_offset_x = adapted.dx();
+    qreal xform_offset_y = adapted.dy();
+
+    if (d->complex_xform) {
+        pixmap = pixmap.transformed(adapted);
+        scaleX = d->stretch_x;
+        scaleY = d->stretch_y;
+    } else {
+        scaleX = d->stretch_x * (r.width() / pixmap.width()) * d->painterMatrix.m11();
+        scaleY = d->stretch_y * (r.height() / pixmap.height()) * d->painterMatrix.m22();
+    }
+
+    QPointF topLeft = r.topLeft() * d->painterMatrix;
+    int tx = int(topLeft.x() * d->stretch_x + d->origin_x);
+    int ty = int(topLeft.y() * d->stretch_y + d->origin_y);
+    int tw = qAbs(int(pixmap.width() * scaleX));
+    int th = qAbs(int(pixmap.height() * scaleY));
+
+    xform_offset_x *= d->stretch_x;
+    xform_offset_y *= d->stretch_y;
+
+    int dc_state = SaveDC(d->hdc);
+
+    int tilesw = pixmap.width() / tileSize;
+    int tilesh = pixmap.height() / tileSize;
+    ++tilesw;
+    ++tilesh;
+
+    int txinc = tileSize*scaleX;
+    int tyinc = tileSize*scaleY;
+
+    for (int y = 0; y < tilesh; ++y) {
+        int tposy = ty + (y * tyinc);
+        int imgh = tileSize;
+        int height = tyinc;
+        if (y == (tilesh - 1)) {
+            imgh = pixmap.height() - (y * tileSize);
+            height = (th - (y * tyinc));
+        }
+        for (int x = 0; x < tilesw; ++x) {
+            int tposx = tx + (x * txinc);
+            int imgw = tileSize;
+            int width = txinc;
+            if (x == (tilesw - 1)) {
+                imgw = pixmap.width() - (x * tileSize);
+                width = (tw - (x * txinc));
+            }
+
+            QPixmap p = pixmap.copy(tileSize * x, tileSize * y, imgw, imgh);
+            HBITMAP hbitmap = p.toWinHBITMAP(QPixmap::NoAlpha);
+            HDC display_dc = GetDC(0);
+            HDC hbitmap_hdc = CreateCompatibleDC(display_dc);
+            HGDIOBJ null_bitmap = SelectObject(hbitmap_hdc, hbitmap);
+
+            ReleaseDC(0, display_dc);
+
+            if (!StretchBlt(d->hdc, qRound(tposx - xform_offset_x), qRound(tposy - xform_offset_y), width, height,
+                            hbitmap_hdc, 0, 0, p.width(), p.height(), SRCCOPY))
+                qErrnoWarning("QWin32PrintEngine::drawPixmap, StretchBlt failed");
+
+            SelectObject(hbitmap_hdc, null_bitmap);
+            DeleteObject(hbitmap);
+            DeleteDC(hbitmap_hdc);
+        }
+    }
+
+    RestoreDC(d->hdc, dc_state);
+}
+
+
+void QWin32PrintEngine::drawTiledPixmap(const QRectF &r, const QPixmap &pm, const QPointF &pos)
+{
+    Q_D(QWin32PrintEngine);
+
+    QAlphaPaintEngine::drawTiledPixmap(r, pm, pos);
+    if (!continueCall())
+        return;
+
+    if (d->complex_xform || !pos.isNull()) {
+        QPaintEngine::drawTiledPixmap(r, pm, pos);
+    } else {
+        int dc_state = SaveDC(d->hdc);
+
+        HDC display_dc = GetDC(0);
+        HBITMAP hbitmap = pm.toWinHBITMAP(QPixmap::NoAlpha);
+        HDC hbitmap_hdc = CreateCompatibleDC(display_dc);
+        HGDIOBJ null_bitmap = SelectObject(hbitmap_hdc, hbitmap);
+
+        ReleaseDC(0, display_dc);
+
+        QRectF trect = d->painterMatrix.mapRect(r);
+        int tx = int(trect.left() * d->stretch_x + d->origin_x);
+        int ty = int(trect.top() * d->stretch_y + d->origin_y);
+
+        int xtiles = int(trect.width() / pm.width()) + 1;
+        int ytiles = int(trect.height() / pm.height()) + 1;
+        int xinc = int(pm.width() * d->stretch_x);
+        int yinc = int(pm.height() * d->stretch_y);
+
+        for (int y = 0; y < ytiles; ++y) {
+            int ity = ty + (yinc * y);
+            int ith = pm.height();
+            if (y == (ytiles - 1)) {
+                ith = int(trect.height() - (pm.height() * y));
+            }
+
+            for (int x = 0; x < xtiles; ++x) {
+                int itx = tx + (xinc * x);
+                int itw = pm.width();
+                if (x == (xtiles - 1)) {
+                    itw = int(trect.width() - (pm.width() * x));
+                }
+
+                if (!StretchBlt(d->hdc, itx, ity, int(itw * d->stretch_x), int(ith * d->stretch_y),
+                                hbitmap_hdc, 0, 0, itw, ith, SRCCOPY))
+                    qErrnoWarning("QWin32PrintEngine::drawPixmap, StretchBlt failed");
+
+            }
+        }
+
+        SelectObject(hbitmap_hdc, null_bitmap);
+        DeleteObject(hbitmap);
+        DeleteDC(hbitmap_hdc);
+
+        RestoreDC(d->hdc, dc_state);
+    }
+}
+
+
+void QWin32PrintEnginePrivate::composeGdiPath(const QPainterPath &path)
+{
+    if (!BeginPath(hdc))
+        qErrnoWarning("QWin32PrintEnginePrivate::drawPath: BeginPath failed");
+
+    // Drawing the subpaths
+    int start = -1;
+    for (int i=0; i<path.elementCount(); ++i) {
+        const QPainterPath::Element &elm = path.elementAt(i);
+        switch (elm.type) {
+        case QPainterPath::MoveToElement:
+            if (start >= 0
+                && path.elementAt(start).x == path.elementAt(i-1).x
+                && path.elementAt(start).y == path.elementAt(i-1).y)
+                CloseFigure(hdc);
+            start = i;
+            MoveToEx(hdc, qRound(elm.x), qRound(elm.y), 0);
+            break;
+        case QPainterPath::LineToElement:
+            LineTo(hdc, qRound(elm.x), qRound(elm.y));
+            break;
+        case QPainterPath::CurveToElement: {
+            POINT pts[3] = {
+                { qRound(elm.x), qRound(elm.y) },
+                { qRound(path.elementAt(i+1).x), qRound(path.elementAt(i+1).y) },
+                { qRound(path.elementAt(i+2).x), qRound(path.elementAt(i+2).y) }
+            };
+            i+=2;
+            PolyBezierTo(hdc, pts, 3);
+            break;
+        }
+        default:
+            qFatal("QWin32PaintEngine::drawPath: Unhandled type: %d", elm.type);
+        }
+    }
+
+    if (start >= 0
+        && path.elementAt(start).x == path.elementAt(path.elementCount()-1).x
+        && path.elementAt(start).y == path.elementAt(path.elementCount()-1).y)
+        CloseFigure(hdc);
+
+    if (!EndPath(hdc))
+        qErrnoWarning("QWin32PaintEngine::drawPath: EndPath failed");
+
+    SetPolyFillMode(hdc, path.fillRule() == Qt::WindingFill ? WINDING : ALTERNATE);
+}
+
+
+void QWin32PrintEnginePrivate::fillPath_dev(const QPainterPath &path, const QColor &color)
+{
+#ifdef QT_DEBUG_DRAW
+    qDebug() << " --- QWin32PrintEnginePrivate::fillPath() bound:" << path.boundingRect() << color;
+#endif
+
+    composeGdiPath(path);
+
+    HBRUSH brush = CreateSolidBrush(RGB(color.red(), color.green(), color.blue()));
+    HGDIOBJ old_brush = SelectObject(hdc, brush);
+    FillPath(hdc);
+    DeleteObject(SelectObject(hdc, old_brush));
+}
+
+void QWin32PrintEnginePrivate::strokePath_dev(const QPainterPath &path, const QColor &color, qreal penWidth)
+{
+    composeGdiPath(path);
+    LOGBRUSH brush;
+    brush.lbStyle = BS_SOLID;
+    brush.lbColor = RGB(color.red(), color.green(), color.blue());
+    DWORD capStyle = PS_ENDCAP_SQUARE;
+    DWORD joinStyle = PS_JOIN_BEVEL;
+    if (pen.capStyle() == Qt::FlatCap)
+        capStyle = PS_ENDCAP_FLAT;
+    else if (pen.capStyle() == Qt::RoundCap)
+        capStyle = PS_ENDCAP_ROUND;
+
+    if (pen.joinStyle() == Qt::MiterJoin)
+        joinStyle = PS_JOIN_MITER;
+    else if (pen.joinStyle() == Qt::RoundJoin)
+        joinStyle = PS_JOIN_ROUND;
+
+    HPEN pen = ExtCreatePen(((penWidth == 0) ? PS_COSMETIC : PS_GEOMETRIC)
+                            | PS_SOLID | capStyle | joinStyle,
+                            (penWidth == 0) ? 1 : penWidth, &brush, 0, 0);
+
+    HGDIOBJ old_pen = SelectObject(hdc, pen);
+    StrokePath(hdc);
+    DeleteObject(SelectObject(hdc, old_pen));
+}
+
+
+void QWin32PrintEnginePrivate::fillPath(const QPainterPath &path, const QColor &color)
+{
+    fillPath_dev(path * matrix, color);
+}
+
+void QWin32PrintEnginePrivate::strokePath(const QPainterPath &path, const QColor &color)
+{
+    QPainterPathStroker stroker;
+    if (pen.style() == Qt::CustomDashLine) {
+        stroker.setDashPattern(pen.dashPattern());
+        stroker.setDashOffset(pen.dashOffset());
+    } else {
+        stroker.setDashPattern(pen.style());
+    }
+    stroker.setCapStyle(pen.capStyle());
+    stroker.setJoinStyle(pen.joinStyle());
+    stroker.setMiterLimit(pen.miterLimit());
+
+    QPainterPath stroke;
+    qreal width = pen.widthF();
+    if (pen.style() == Qt::SolidLine && (pen.isCosmetic() || matrix.type() < QTransform::TxScale)) {
+        strokePath_dev(path * matrix, color, width);
+    } else {
+        stroker.setWidth(width);
+        if (pen.isCosmetic()) {
+            stroke = stroker.createStroke(path * matrix);
+        } else {
+            stroke = stroker.createStroke(path) * painterMatrix;
+            QTransform stretch(stretch_x, 0, 0, stretch_y, origin_x, origin_y);
+            stroke = stroke * stretch;
+        }
+
+        if (stroke.isEmpty())
+            return;
+
+        fillPath_dev(stroke, color);
+    }
+}
+
+
+void QWin32PrintEngine::drawPath(const QPainterPath &path)
+{
+#ifdef QT_DEBUG_DRAW
+    qDebug() << " - QWin32PrintEngine::drawPath(), bounds: " << path.boundingRect();
+#endif
+
+    Q_D(QWin32PrintEngine);
+
+    QAlphaPaintEngine::drawPath(path);
+    if (!continueCall())
+        return;
+
+    if (d->has_brush)
+        d->fillPath(path, d->brush_color);
+
+    if (d->has_pen)
+        d->strokePath(path, d->pen.color());
+}
+
+
+void QWin32PrintEngine::drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode)
+{
+#ifdef QT_DEBUG_DRAW
+    qDebug() << " - QWin32PrintEngine::drawPolygon(), pointCount: " << pointCount;
+#endif
+
+    QAlphaPaintEngine::drawPolygon(points, pointCount, mode);
+    if (!continueCall())
+        return;
+
+    Q_ASSERT(pointCount > 1);
+
+    QPainterPath path(points[0]);
+
+    for (int i=1; i<pointCount; ++i) {
+        path.lineTo(points[i]);
+    }
+
+    Q_D(QWin32PrintEngine);
+
+    bool has_brush = d->has_brush;
+
+    if (mode == PolylineMode)
+        d->has_brush = false; // No brush for polylines
+    else
+        path.closeSubpath(); // polygons are should always be closed.
+
+    drawPath(path);
+    d->has_brush = has_brush;
+}
+
+void QWin32PrintEnginePrivate::queryDefault()
+{
+    /* Read the default printer name, driver and port with the intuitive function
+     * Strings "windows" and "device" are specified in the MSDN under EnumPrinters()
+     */
+    QString noPrinters(QLatin1String("qt_no_printers"));
+    wchar_t buffer[256];
+    GetProfileString(L"windows", L"device",
+                     reinterpret_cast<const wchar_t *>(noPrinters.utf16()),
+                     buffer, 256);
+    QString output = QString::fromWCharArray(buffer);
+    if (output.isEmpty() || output == noPrinters) // no printers
+        return;
+
+    QStringList info = output.split(QLatin1Char(','));
+    int infoSize = info.size();
+    if (infoSize > 0) {
+        if (name.isEmpty())
+            name = info.at(0);
+        if (program.isEmpty() && infoSize > 1)
+            program = info.at(1);
+        if (port.isEmpty() && infoSize > 2)
+            port = info.at(2);
+    }
+}
+
+QWin32PrintEnginePrivate::~QWin32PrintEnginePrivate()
+{
+    if (hdc)
+        release();
+}
+
+void QWin32PrintEnginePrivate::initialize()
+{
+    if (hdc)
+        release();
+    Q_ASSERT(!hPrinter);
+    Q_ASSERT(!hdc);
+    Q_ASSERT(!devMode);
+    Q_ASSERT(!pInfo);
+
+    if (name.isEmpty())
+        return;
+
+    txop = QTransform::TxNone;
+
+    bool ok = OpenPrinter((LPWSTR)name.utf16(), (LPHANDLE)&hPrinter, 0);
+    if (!ok) {
+        qErrnoWarning("QWin32PrintEngine::initialize: OpenPrinter failed");
+        return;
+    }
+
+    // Fetch the PRINTER_INFO_2 with DEVMODE data containing the
+    // printer settings.
+    DWORD infoSize, numBytes;
+    GetPrinter(hPrinter, 2, NULL, 0, &infoSize);
+    hMem = GlobalAlloc(GHND, infoSize);
+    pInfo = (PRINTER_INFO_2*) GlobalLock(hMem);
+    ok = GetPrinter(hPrinter, 2, (LPBYTE)pInfo, infoSize, &numBytes);
+
+    if (!ok) {
+        qErrnoWarning("QWin32PrintEngine::initialize: GetPrinter failed");
+        GlobalUnlock(pInfo);
+        GlobalFree(hMem);
+        ClosePrinter(hPrinter);
+        pInfo = 0;
+        hMem = 0;
+        hPrinter = 0;
+        return;
+    }
+
+    devMode = pInfo->pDevMode;
+    hdc = CreateDC(reinterpret_cast<const wchar_t *>(program.utf16()),
+                   reinterpret_cast<const wchar_t *>(name.utf16()), 0, devMode);
+
+    Q_ASSERT(hPrinter);
+    Q_ASSERT(pInfo);
+
+    if (devMode) {
+        num_copies = devMode->dmCopies;
+    }
+
+    initHDC();
+
+#ifdef QT_DEBUG_DRAW
+    qDebug() << "QWin32PrintEngine::initialize()" << endl
+             << " - paperRect" << devPaperRect << endl
+             << " - pageRect" << devPageRect << endl
+             << " - stretch_x" << stretch_x << endl
+             << " - stretch_y" << stretch_y << endl
+             << " - origin_x" << origin_x << endl
+             << " - origin_y" << origin_y << endl;
+#endif
+}
+
+void QWin32PrintEnginePrivate::initHDC()
+{
+    Q_ASSERT(hdc);
+
+    HDC display_dc = GetDC(0);
+    dpi_x = GetDeviceCaps(hdc, LOGPIXELSX);
+    dpi_y = GetDeviceCaps(hdc, LOGPIXELSY);
+    dpi_display = GetDeviceCaps(display_dc, LOGPIXELSY);
+    ReleaseDC(0, display_dc);
+    if (dpi_display == 0) {
+        qWarning("QWin32PrintEngine::metric: GetDeviceCaps() failed, "
+                "might be a driver problem");
+        dpi_display = 96; // Reasonable default
+    }
+
+    switch(mode) {
+    case QPrinter::ScreenResolution:
+        resolution = dpi_display;
+        stretch_x = dpi_x / double(dpi_display);
+        stretch_y = dpi_y / double(dpi_display);
+        break;
+    case QPrinter::PrinterResolution:
+    case QPrinter::HighResolution:
+        resolution = dpi_y;
+        stretch_x = 1;
+        stretch_y = 1;
+        break;
+    default:
+        break;
+    }
+
+    initDevRects();
+}
+
+void QWin32PrintEnginePrivate::initDevRects()
+{
+    devPaperRect = QRect(0, 0,
+                         GetDeviceCaps(hdc, PHYSICALWIDTH),
+                         GetDeviceCaps(hdc, PHYSICALHEIGHT));
+    devPhysicalPageRect = QRect(GetDeviceCaps(hdc, PHYSICALOFFSETX),
+                                GetDeviceCaps(hdc, PHYSICALOFFSETY),
+                                GetDeviceCaps(hdc, HORZRES),
+                                GetDeviceCaps(hdc, VERTRES));
+    if (!pageMarginsSet)
+        devPageRect = devPhysicalPageRect;
+    else
+        devPageRect = devPaperRect.adjusted(qRound(mmToInches(previousDialogMargins.left() / 100.0) * dpi_x),
+                                            qRound(mmToInches(previousDialogMargins.top() / 100.0) * dpi_y),
+                                            -qRound(mmToInches(previousDialogMargins.width() / 100.0) * dpi_x),
+                                            -qRound(mmToInches(previousDialogMargins.height() / 100.0) * dpi_y));
+    updateOrigin();
+}
+
+void QWin32PrintEnginePrivate::setPageMargins(int marginLeft, int marginTop, int marginRight, int marginBottom)
+{
+    pageMarginsSet = true;
+    previousDialogMargins = QRect(marginLeft, marginTop, marginRight, marginBottom);
+
+    devPageRect = devPaperRect.adjusted(qRound(mmToInches(marginLeft / 100.0) * dpi_x),
+                                        qRound(mmToInches(marginTop / 100.0) * dpi_y),
+                                        - qRound(mmToInches(marginRight / 100.0) * dpi_x),
+                                        - qRound(mmToInches(marginBottom / 100.0) * dpi_y));
+    updateOrigin();
+}
+
+QRect QWin32PrintEnginePrivate::getPageMargins() const
+{
+    if (pageMarginsSet)
+        return previousDialogMargins;
+    else
+        return QRect(qRound(inchesToMM(devPhysicalPageRect.left()) * 100.0 / dpi_x),
+                     qRound(inchesToMM(devPhysicalPageRect.top()) * 100.0 / dpi_y),
+                     qRound(inchesToMM(devPaperRect.right() - devPhysicalPageRect.right()) * 100.0 / dpi_x),
+                     qRound(inchesToMM(devPaperRect.bottom() - devPhysicalPageRect.bottom()) * 100.0 / dpi_y));
+}
+
+void QWin32PrintEnginePrivate::release()
+{
+    if (hdc == 0)
+        return;
+
+    if (globalDevMode) { // Devmode comes from print dialog
+        GlobalUnlock(globalDevMode);
+    } else {            // Devmode comes from initialize...
+        // devMode is a part of the same memory block as pInfo so one free is enough...
+        GlobalUnlock(hMem);
+        GlobalFree(hMem);
+    }
+    if (hPrinter)
+        ClosePrinter(hPrinter);
+    DeleteDC(hdc);
+
+    hdc = 0;
+    hPrinter = 0;
+    pInfo = 0;
+    hMem = 0;
+    devMode = 0;
+}
+
+QList<QVariant> QWin32PrintEnginePrivate::queryResolutions() const
+{
+    // Read the supported resolutions of the printer.
+    QList<QVariant> list;
+
+    DWORD numRes = DeviceCapabilities(reinterpret_cast<const wchar_t *>(name.utf16()),
+                                      reinterpret_cast<const wchar_t *>(port.utf16()),
+                                      DC_ENUMRESOLUTIONS, 0, 0);
+    if (numRes == (DWORD)-1)
+        return list;
+
+    LONG *enumRes = (LONG*)malloc(numRes * 2 * sizeof(LONG));
+    DWORD errRes = DeviceCapabilities(reinterpret_cast<const wchar_t *>(name.utf16()),
+                                      reinterpret_cast<const wchar_t *>(port.utf16()),
+                                      DC_ENUMRESOLUTIONS, (LPWSTR)enumRes, 0);
+
+    if (errRes == (DWORD)-1) {
+        qErrnoWarning("QWin32PrintEngine::queryResolutions: DeviceCapabilities failed");
+        return list;
+    }
+
+    for (uint i=0; i<numRes; ++i)
+        list.append(int(enumRes[i * 2]));
+
+    return list;
+}
+
+void QWin32PrintEnginePrivate::doReinit()
+{
+    if (state == QPrinter::Active) {
+        reinit = true;
+    } else {
+        resetDC();
+        initDevRects();
+        reinit = false;
+    }
+}
+
+void QWin32PrintEnginePrivate::updateOrigin()
+{
+    if (fullPage) {
+        // subtract physical margins to make (0,0) absolute top corner of paper
+        // then add user defined margins
+        origin_x = -devPhysicalPageRect.x();
+        origin_y = -devPhysicalPageRect.y();
+        if (pageMarginsSet) {
+            origin_x += devPageRect.left();
+            origin_y += devPageRect.top();
+        }
+    } else {
+        origin_x = 0;
+        origin_y = 0;
+        if (pageMarginsSet) {
+            origin_x = devPageRect.left() - devPhysicalPageRect.x();
+            origin_y = devPageRect.top() - devPhysicalPageRect.y();
+        }
+    }
+}
+
+void QWin32PrintEngine::setProperty(PrintEnginePropertyKey key, const QVariant &value)
+{
+    Q_D(QWin32PrintEngine);
+    switch (key) {
+    case PPK_CollateCopies:
+        {
+            if (!d->devMode)
+                break;
+            d->devMode->dmCollate = value.toBool() ? DMCOLLATE_TRUE : DMCOLLATE_FALSE;
+            d->doReinit();
+        }
+        break;
+
+    case PPK_ColorMode:
+        {
+            if (!d->devMode)
+                break;
+            d->devMode->dmColor = (value.toInt() == QPrinter::Color) ? DMCOLOR_COLOR : DMCOLOR_MONOCHROME;
+            d->doReinit();
+        }
+        break;
+
+    case PPK_Creator:
+
+        break;
+
+    case PPK_DocumentName:
+        if (isActive()) {
+            qWarning("QWin32PrintEngine: Cannot change document name while printing is active");
+            return;
+        }
+        d->docName = value.toString();
+        break;
+
+    case PPK_FullPage:
+        d->fullPage = value.toBool();
+        d->updateOrigin();
+        break;
+
+    case PPK_CopyCount: // fallthrough
+    case PPK_NumberOfCopies:
+        if (!d->devMode)
+            break;
+        d->num_copies = value.toInt();
+        d->devMode->dmCopies = d->num_copies;
+        d->doReinit();
+        break;
+
+    case PPK_Orientation:
+        {
+            if (!d->devMode)
+                break;
+            int orientation = value.toInt() == QPrinter::Landscape ? DMORIENT_LANDSCAPE : DMORIENT_PORTRAIT;
+            int old_orientation = d->devMode->dmOrientation;
+            d->devMode->dmOrientation = orientation;
+            if (d->has_custom_paper_size && old_orientation != orientation)
+                d->paper_size = QSizeF(d->paper_size.height(), d->paper_size.width());
+            d->doReinit();
+        }
+        break;
+
+    case PPK_OutputFileName:
+        if (isActive()) {
+            qWarning("QWin32PrintEngine: Cannot change filename while printing");
+        } else {
+            d->fileName = value.toString();
+            d->printToFile = !value.toString().isEmpty();
+        }
+        break;
+
+    case PPK_PaperSize:
+        if (!d->devMode)
+            break;
+        d->devMode->dmPaperSize = mapPaperSizeDevmode(QPrinter::PaperSize(value.toInt()));
+        d->has_custom_paper_size = (QPrinter::PaperSize(value.toInt()) == QPrinter::Custom);
+        d->doReinit();
+        break;
+
+    case PPK_PaperSource:
+        {
+            if (!d->devMode)
+                break;
+            int dmMapped = DMBIN_AUTO;
+
+            QList<QVariant> v = property(PPK_PaperSources).toList();
+            if (v.contains(value))
+                dmMapped = mapPaperSourceDevmode(QPrinter::PaperSource(value.toInt()));
+
+            d->devMode->dmDefaultSource = dmMapped;
+            d->doReinit();
+        }
+        break;
+
+    case PPK_PrinterName:
+        d->name = value.toString();
+        if(d->name.isEmpty())
+            d->queryDefault();
+        d->initialize();
+        break;
+
+    case PPK_Resolution:
+        {
+            d->resolution = value.toInt();
+
+            d->stretch_x = d->dpi_x / double(d->resolution);
+            d->stretch_y = d->dpi_y / double(d->resolution);
+        }
+        break;
+
+    case PPK_SelectionOption:
+
+        break;
+
+    case PPK_SupportedResolutions:
+
+        break;
+
+
+    case PPK_WindowsPageSize:
+        if (!d->devMode)
+            break;
+        d->has_custom_paper_size = false;
+        d->devMode->dmPaperSize = value.toInt();
+        d->doReinit();
+        break;
+
+    case PPK_CustomPaperSize:
+    {
+        d->has_custom_paper_size = true;
+        d->paper_size = value.toSizeF();
+        if (!d->devMode)
+            break;
+        int orientation = d->devMode->dmOrientation;
+        DWORD needed = 0;
+        DWORD returned = 0;
+        if (!EnumForms(d->hPrinter, 1, 0, 0, &needed, &returned)) {
+            BYTE *forms = (BYTE *) malloc(needed);
+            if (EnumForms(d->hPrinter, 1, forms, needed, &needed, &returned)) {
+                for (DWORD i=0; i< returned; ++i) {
+                    FORM_INFO_1 *formArray = reinterpret_cast<FORM_INFO_1 *>(forms);
+                    // the form sizes are specified in 1000th of a mm,
+                    // convert the size to Points
+                    QSizeF size((formArray[i].Size.cx * 72/25.4)/1000.0,
+                                (formArray[i].Size.cy * 72/25.4)/1000.0);
+                    if (qAbs(d->paper_size.width() - size.width()) <= 2
+                        && qAbs(d->paper_size.height() - size.height()) <= 2)
+                    {
+                        d->devMode->dmPaperSize = i + 1;
+                        break;
+                    }
+                }
+            }
+            free(forms);
+        }
+        if (orientation != DMORIENT_PORTRAIT)
+            d->paper_size = QSizeF(d->paper_size.height(), d->paper_size.width());
+        break;
+    }
+
+    case PPK_PageMargins:
+    {
+        QList<QVariant> margins(value.toList());
+        Q_ASSERT(margins.size() == 4);
+        int left, top, right, bottom;
+        // specified in 1/100 mm
+        left = (margins.at(0).toReal()*25.4/72.0) * 100;
+        top = (margins.at(1).toReal()*25.4/72.0) * 100;
+        right = (margins.at(2).toReal()*25.4/72.0) * 100;
+        bottom = (margins.at(3).toReal()*25.4/72.0) * 100;
+        d->setPageMargins(left, top, right, bottom);
+        break;
+    }
+    default:
+        // Do nothing
+        break;
+    }
+}
+
+QVariant QWin32PrintEngine::property(PrintEnginePropertyKey key) const
+{
+    Q_D(const QWin32PrintEngine);
+    QVariant value;
+    switch (key) {
+
+    case PPK_CollateCopies:
+        value = false;
+        break;
+
+    case PPK_ColorMode:
+        {
+            if (!d->devMode) {
+                value = QPrinter::Color;
+            } else {
+                value = (d->devMode->dmColor == DMCOLOR_COLOR) ? QPrinter::Color : QPrinter::GrayScale;
+            }
+        }
+        break;
+
+    case PPK_DocumentName:
+        value = d->docName;
+        break;
+
+    case PPK_FullPage:
+        value = d->fullPage;
+        break;
+
+    case PPK_CopyCount:
+        value = d->num_copies;
+        break;
+
+    case PPK_SupportsMultipleCopies:
+        value = true;
+        break;
+
+    case PPK_NumberOfCopies:
+        value = 1;
+        break;
+
+    case PPK_Orientation:
+        {
+            if (!d->devMode) {
+                value = QPrinter::Portrait;
+            } else {
+                value = (d->devMode->dmOrientation == DMORIENT_LANDSCAPE) ? QPrinter::Landscape : QPrinter::Portrait;
+            }
+        }
+        break;
+
+    case PPK_OutputFileName:
+        value = d->fileName;
+        break;
+
+    case PPK_PageRect:
+        if (d->has_custom_paper_size) {
+            QRect rect(0, 0,
+                       qRound(d->paper_size.width() * d->resolution / 72.0),
+                       qRound(d->paper_size.height() * d->resolution / 72.0));
+            if (d->pageMarginsSet) {
+                rect = rect.adjusted(qRound(mmToInches(d->previousDialogMargins.left()/100.0) * d->resolution),
+                                     qRound(mmToInches(d->previousDialogMargins.top()/100.0) * d->resolution),
+                                     -qRound(mmToInches(d->previousDialogMargins.width()/100.0) * d->resolution),
+                                     -qRound(mmToInches(d->previousDialogMargins.height()/100.0) * d->resolution));
+            }
+            value = rect;
+        } else {
+            value = QTransform(1/d->stretch_x, 0, 0, 1/d->stretch_y, 0, 0)
+                    .mapRect(d->fullPage ? d->devPhysicalPageRect : d->devPageRect);
+        }
+        break;
+
+    case PPK_PaperSize:
+        if (d->has_custom_paper_size) {
+            value = QPrinter::Custom;
+        } else {
+            if (!d->devMode) {
+                value = QPrinter::A4;
+            } else {
+                value = mapDevmodePaperSize(d->devMode->dmPaperSize);
+            }
+        }
+        break;
+
+    case PPK_PaperRect:
+        if (d->has_custom_paper_size) {
+            value = QRect(0, 0,
+                          qRound(d->paper_size.width() * d->resolution / 72.0),
+                          qRound(d->paper_size.height() * d->resolution / 72.0));
+        } else {
+            value = QTransform(1/d->stretch_x, 0, 0, 1/d->stretch_y, 0, 0).mapRect(d->devPaperRect);
+        }
+        break;
+
+    case PPK_PaperSource:
+        if (!d->devMode) {
+            value = QPrinter::Auto;
+        } else {
+            value = mapDevmodePaperSource(d->devMode->dmDefaultSource);
+        }
+        break;
+
+    case PPK_PrinterName:
+        value = d->name;
+        break;
+
+    case PPK_Resolution:
+        if (d->resolution || !d->name.isEmpty())
+            value = d->resolution;
+        break;
+
+    case PPK_SupportedResolutions:
+        value = d->queryResolutions();
+        break;
+
+    case PPK_WindowsPageSize:
+        if (!d->devMode) {
+            value = -1;
+        } else {
+            value = d->devMode->dmPaperSize;
+        }
+        break;
+
+    case PPK_PaperSources:
+        {
+            int available = DeviceCapabilities((const wchar_t *)d->name.utf16(),
+                                               (const wchar_t *)d->port.utf16(), DC_BINS, 0, d->devMode);
+
+            if (available <= 0)
+                break;
+
+            wchar_t *data = new wchar_t[available];
+            int count = DeviceCapabilities((const wchar_t *)d->name.utf16(),
+                                           (const wchar_t *)d->port.utf16(), DC_BINS, data, d->devMode);
+
+            QList<QVariant> out;
+            for (int i=0; i<count; ++i) {
+                QPrinter::PaperSource src = mapDevmodePaperSource(data[i]);
+                if (src != -1)
+                    out << (int) src;
+            }
+            value = out;
+
+            delete [] data;
+        }
+        break;
+
+    case PPK_CustomPaperSize:
+        value = d->paper_size;
+        break;
+
+    case PPK_PageMargins:
+    {
+        QList<QVariant> margins;
+        QRect pageMargins(d->getPageMargins());
+
+        // specified in 1/100 mm
+        margins << (mmToInches(pageMargins.left()/100.0) * 72)
+                << (mmToInches(pageMargins.top()/100.0) * 72)
+                << (mmToInches(pageMargins.width()/100.0) * 72)
+                << (mmToInches(pageMargins.height()/100.0) * 72);
+        value = margins;
+        break;
+    }
+    default:
+        // Do nothing
+        break;
+    }
+    return value;
+}
+
+QPrinter::PrinterState QWin32PrintEngine::printerState() const
+{
+    return d_func()->state;
+}
+
+HDC QWin32PrintEngine::getDC() const
+{
+    return d_func()->hdc;
+}
+
+void QWin32PrintEngine::releaseDC(HDC) const
+{
+
+}
+
+HGLOBAL *QWin32PrintEnginePrivate::createDevNames()
+{
+    int size = sizeof(DEVNAMES)
+               + program.length() * 2 + 2
+               + name.length() * 2 + 2
+               + port.length() * 2 + 2;
+    HGLOBAL *hGlobal = (HGLOBAL *) GlobalAlloc(GMEM_MOVEABLE, size);
+    DEVNAMES *dn = (DEVNAMES*) GlobalLock(hGlobal);
+
+    dn->wDriverOffset = sizeof(DEVNAMES) / sizeof(wchar_t);
+    dn->wDeviceOffset = dn->wDriverOffset + program.length() + 1;
+    dn->wOutputOffset = dn->wDeviceOffset + name.length() + 1;
+
+    memcpy((ushort*)dn + dn->wDriverOffset, program.utf16(), program.length() * 2 + 2);
+    memcpy((ushort*)dn + dn->wDeviceOffset, name.utf16(), name.length() * 2 + 2);
+    memcpy((ushort*)dn + dn->wOutputOffset, port.utf16(), port.length() * 2 + 2);
+    dn->wDefault = 0;
+
+    GlobalUnlock(hGlobal);
+
+//         printf("QPrintDialogWinPrivate::createDevNames()\n"
+//                " -> wDriverOffset: %d\n"
+//                " -> wDeviceOffset: %d\n"
+//                " -> wOutputOffset: %d\n",
+//                dn->wDriverOffset,
+//                dn->wDeviceOffset,
+//                dn->wOutputOffset);
+
+//         printf("QPrintDialogWinPrivate::createDevNames(): %s, %s, %s\n",
+//                QString::fromWCharArray((wchar_t*)(dn) + dn->wDriverOffset).latin1(),
+//                QString::fromWCharArray((wchar_t*)(dn) + dn->wDeviceOffset).latin1(),
+//                QString::fromWCharArray((wchar_t*)(dn) + dn->wOutputOffset).latin1());
+
+    return hGlobal;
+}
+
+void QWin32PrintEnginePrivate::readDevnames(HGLOBAL globalDevnames)
+{
+    if (globalDevnames) {
+        DEVNAMES *dn = (DEVNAMES*) GlobalLock(globalDevnames);
+        name = QString::fromWCharArray((wchar_t*)(dn) + dn->wDeviceOffset);
+        port = QString::fromWCharArray((wchar_t*)(dn) + dn->wOutputOffset);
+        program = QString::fromWCharArray((wchar_t*)(dn) + dn->wDriverOffset);
+        GlobalUnlock(globalDevnames);
+    }
+}
+
+void QWin32PrintEnginePrivate::readDevmode(HGLOBAL globalDevmode)
+{
+    if (globalDevmode) {
+        DEVMODE *dm = (DEVMODE*) GlobalLock(globalDevmode);
+        release();
+        globalDevMode = globalDevmode;
+        devMode = dm;
+        hdc = CreateDC(reinterpret_cast<const wchar_t *>(program.utf16()),
+                       reinterpret_cast<const wchar_t *>(name.utf16()), 0, dm);
+
+        num_copies = devMode->dmCopies;
+        if (!OpenPrinter((wchar_t*)name.utf16(), &hPrinter, 0))
+            qWarning("QPrinter: OpenPrinter() failed after reading DEVMODE.");
+    }
+
+    if (hdc)
+        initHDC();
+}
+
+static void draw_text_item_win(const QPointF &pos, const QTextItemInt &ti, HDC hdc,
+                               bool convertToText, const QTransform &xform, const QPointF &topLeft)
+{
+    QFontEngine *fe = ti.fontEngine;
+    QPointF baseline_pos = xform.inverted().map(xform.map(pos) - topLeft);
+
+    SetTextAlign(hdc, TA_BASELINE);
+    SetBkMode(hdc, TRANSPARENT);
+
+    bool has_kerning = ti.f && ti.f->kerning();
+    QFontEngineWin *winfe = (fe->type() == QFontEngine::Win) ? static_cast<QFontEngineWin *>(fe) : 0;
+
+    HFONT hfont;
+    bool ttf = false;
+
+    if (winfe) {
+        hfont = winfe->hfont;
+        ttf = winfe->ttf;
+    } else {
+        hfont = (HFONT)GetStockObject(ANSI_VAR_FONT);
+    }
+
+    HGDIOBJ old_font = SelectObject(hdc, hfont);
+    unsigned int options = (ttf && !convertToText) ? ETO_GLYPH_INDEX : 0;
+    wchar_t *convertedGlyphs = (wchar_t *)ti.chars;
+    QGlyphLayout glyphs = ti.glyphs;
+
+    bool fast = !has_kerning && !(ti.flags & QTextItem::RightToLeft);
+    for (int i = 0; fast && i < glyphs.numGlyphs; i++) {
+        if (glyphs.offsets[i].x != 0 || glyphs.offsets[i].y != 0 || glyphs.justifications[i].space_18d6 != 0
+            || glyphs.attributes[i].dontPrint) {
+            fast = false;
+            break;
+        }
+    }
+
+#if !defined(Q_OS_WINCE)
+    // Scale, rotate and translate here.
+    XFORM win_xform;
+    win_xform.eM11 = xform.m11();
+    win_xform.eM12 = xform.m12();
+    win_xform.eM21 = xform.m21();
+    win_xform.eM22 = xform.m22();
+    win_xform.eDx = xform.dx();
+    win_xform.eDy = xform.dy();
+
+    SetGraphicsMode(hdc, GM_ADVANCED);
+    SetWorldTransform(hdc, &win_xform);
+#endif
+
+    if (fast) {
+        // fast path
+        QVarLengthArray<wchar_t> g(glyphs.numGlyphs);
+        for (int i = 0; i < glyphs.numGlyphs; ++i)
+            g[i] = glyphs.glyphs[i];
+        ExtTextOut(hdc,
+                   qRound(baseline_pos.x() + glyphs.offsets[0].x.toReal()),
+                   qRound(baseline_pos.y() + glyphs.offsets[0].y.toReal()),
+                   options, 0, convertToText ? convertedGlyphs : g.data(), glyphs.numGlyphs, 0);
+    } else {
+        QVarLengthArray<QFixedPoint> positions;
+        QVarLengthArray<glyph_t> _glyphs;
+
+        QTransform matrix = QTransform::fromTranslate(baseline_pos.x(), baseline_pos.y());
+        ti.fontEngine->getGlyphPositions(ti.glyphs, matrix, ti.flags,
+            _glyphs, positions);
+        if (_glyphs.size() == 0) {
+            SelectObject(hdc, old_font);
+            return;
+        }
+
+        convertToText = convertToText && glyphs.numGlyphs == _glyphs.size();
+        bool outputEntireItem = _glyphs.size() > 0;
+
+        if (outputEntireItem) {
+            options |= ETO_PDY;
+            QVarLengthArray<INT> glyphDistances(_glyphs.size() * 2);
+            QVarLengthArray<wchar_t> g(_glyphs.size());
+            for (int i=0; i<_glyphs.size() - 1; ++i) {
+                glyphDistances[i * 2] = qRound(positions[i + 1].x) - qRound(positions[i].x);
+                glyphDistances[i * 2 + 1] = qRound(positions[i + 1].y) - qRound(positions[i].y);
+                g[i] = _glyphs[i];
+            }
+            glyphDistances[(_glyphs.size() - 1) * 2] = 0;
+            glyphDistances[(_glyphs.size() - 1) * 2 + 1] = 0;
+            g[_glyphs.size() - 1] = _glyphs[_glyphs.size() - 1];
+            ExtTextOut(hdc, qRound(positions[0].x), qRound(positions[0].y), options, 0,
+                       convertToText ? convertedGlyphs : g.data(), _glyphs.size(),
+                       glyphDistances.data());
+        } else {
+            int i = 0;
+            while(i < _glyphs.size()) {
+                wchar_t g = _glyphs[i];
+
+                ExtTextOut(hdc, qRound(positions[i].x),
+                           qRound(positions[i].y), options, 0,
+                           convertToText ? convertedGlyphs + i : &g, 1, 0);
+                ++i;
+            }
+        }
+    }
+
+#if !defined(Q_OS_WINCE)
+        win_xform.eM11 = win_xform.eM22 = 1.0;
+        win_xform.eM12 = win_xform.eM21 = win_xform.eDx = win_xform.eDy = 0.0;
+        SetWorldTransform(hdc, &win_xform);
+#endif
+
+    SelectObject(hdc, old_font);
+}
+
+
+void QWin32PrintEnginePrivate::updateCustomPaperSize()
+{
+    uint paperSize = devMode->dmPaperSize;
+    if (paperSize > 0 && mapDevmodePaperSize(paperSize) == QPrinter::Custom) {
+        has_custom_paper_size = true;
+        DWORD needed = 0;
+        DWORD returned = 0;
+        if (!EnumForms(hPrinter, 1, 0, 0, &needed, &returned)) {
+            BYTE *forms = (BYTE *) malloc(needed);
+            if (EnumForms(hPrinter, 1, forms, needed, &needed, &returned)) {
+                if (paperSize <= returned) {
+                    FORM_INFO_1 *formArray = (FORM_INFO_1 *) forms;
+                    int width = formArray[paperSize - 1].Size.cx; // 1/1000 of a mm
+                    int height = formArray[paperSize - 1].Size.cy; // 1/1000 of a mm
+                    paper_size = QSizeF((width * 72 /25.4) / 1000.0, (height * 72 / 25.4) / 1000.0);
+                } else {
+                    has_custom_paper_size = false;
+                }
+            }
+            free(forms);
+        }
+    } else {
+        has_custom_paper_size = false;
+    }
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_PRINTER
diff --git a/src/gui/painting/qprintengine_win_p.h b/src/gui/painting/qprintengine_win_p.h
new file mode 100644
index 0000000000..b4d0670e7b
--- /dev/null
+++ b/src/gui/painting/qprintengine_win_p.h
@@ -0,0 +1,261 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPRINTENGINE_WIN_P_H
+#define QPRINTENGINE_WIN_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of other Qt classes.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#ifndef QT_NO_PRINTER
+
+#include "QtGui/qprinter.h"
+#include "QtGui/qprintengine.h"
+#include "QtGui/qpaintengine.h"
+#include "QtCore/qt_windows.h"
+#include "private/qpaintengine_alpha_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QWin32PrintEnginePrivate;
+class QPrinterPrivate;
+class QPainterState;
+
+class QWin32PrintEngine : public QAlphaPaintEngine, public QPrintEngine
+{
+    Q_DECLARE_PRIVATE(QWin32PrintEngine)
+public:
+    QWin32PrintEngine(QPrinter::PrinterMode mode);
+
+    // override QWin32PaintEngine
+    bool begin(QPaintDevice *dev);
+    bool end();
+
+    void updateState(const QPaintEngineState &state);
+
+    void updateMatrix(const QTransform &matrix);
+    void updateClipPath(const QPainterPath &clip, Qt::ClipOperation op);
+
+    void drawPath(const QPainterPath &path);
+    void drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode);
+    void drawTextItem(const QPointF &p, const QTextItem &textItem);
+
+    void drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr);
+    void drawTiledPixmap(const QRectF &r, const QPixmap &pm, const QPointF &p);
+    void setProperty(PrintEnginePropertyKey key, const QVariant &value);
+    QVariant property(PrintEnginePropertyKey key) const;
+
+    bool newPage();
+    bool abort();
+    int metric(QPaintDevice::PaintDeviceMetric) const;
+
+    QPrinter::PrinterState printerState() const;
+
+    QPaintEngine::Type type() const { return Windows; }
+
+    HDC getDC() const;
+    void releaseDC(HDC) const;
+
+    HDC getPrinterDC() const { return getDC(); }
+    void releasePrinterDC(HDC dc) const { releaseDC(dc); }
+
+private:
+    friend class QPrintDialog;
+    friend class QPageSetupDialog;
+};
+
+class QWin32PrintEnginePrivate : public QAlphaPaintEnginePrivate
+{
+    Q_DECLARE_PUBLIC(QWin32PrintEngine)
+public:
+    QWin32PrintEnginePrivate() :
+        hPrinter(0),
+        globalDevMode(0),
+        devMode(0),
+        pInfo(0),
+        hdc(0),
+        mode(QPrinter::ScreenResolution),
+        state(QPrinter::Idle),
+        resolution(0),
+        pageMarginsSet(false),
+        num_copies(1),
+        printToFile(false),
+        fullPage(false),
+        reinit(false),
+        has_custom_paper_size(false)
+    {
+    }
+
+    ~QWin32PrintEnginePrivate();
+
+
+    /* Reads the default printer name and its driver (printerProgram) into
+       the engines private data. */
+    void queryDefault();
+
+    /* Initializes the printer data based on the current printer name. This
+       function creates a DEVMODE struct, HDC and a printer handle. If these
+       structures are already in use, they are freed using release
+    */
+    void initialize();
+
+    /* Initializes data in the print engine whenever the HDC has been renewed
+    */
+    void initHDC();
+
+    /* Releases all the handles the printer currently holds, HDC, DEVMODE,
+       etc and resets the corresponding members to 0. */
+    void release();
+
+    /* Queries the resolutions for the current printer, and returns them
+       in a list. */
+    QList<QVariant> queryResolutions() const;
+
+    /* Resets the DC with changes in devmode. If the printer is active
+       this function only sets the reinit variable to true so it
+       is handled in the next begin or newpage. */
+    void doReinit();
+
+    /* Used by print/page setup dialogs */
+    HGLOBAL *createDevNames();
+
+    void readDevmode(HGLOBAL globalDevmode);
+    void readDevnames(HGLOBAL globalDevnames);
+
+    inline bool resetDC() {
+        hdc = ResetDC(hdc, devMode);
+        return hdc != 0;
+    }
+
+    void strokePath(const QPainterPath &path, const QColor &color);
+    void fillPath(const QPainterPath &path, const QColor &color);
+
+    void composeGdiPath(const QPainterPath &path);
+    void fillPath_dev(const QPainterPath &path, const QColor &color);
+    void strokePath_dev(const QPainterPath &path, const QColor &color, qreal width);
+
+    void updateOrigin();
+
+    void initDevRects();
+    void setPageMargins(int margin_left, int margin_top, int margin_right, int margin_bottom);
+    QRect getPageMargins() const;
+    void updateCustomPaperSize();
+
+    // Windows GDI printer references.
+    HANDLE hPrinter;
+
+    HGLOBAL globalDevMode;
+    DEVMODE *devMode;
+    PRINTER_INFO_2 *pInfo;
+    HGLOBAL hMem;
+
+    HDC hdc;
+
+    QPrinter::PrinterMode mode;
+
+    // Printer info
+    QString name;
+    QString program;
+    QString port;
+
+    // Document info
+    QString docName;
+    QString fileName;
+
+    QPrinter::PrinterState state;
+    int resolution;
+
+    // This QRect is used to store the exact values
+    // entered into the PageSetup Dialog because those are
+    // entered in mm but are since converted to device coordinates.
+    // If they were to be converted back when displaying the dialog
+    // again, there would be inaccuracies so when the user entered 10
+    // it may show up as 9.99 the next time the dialog is opened.
+    // We don't want that confusion.
+    QRect previousDialogMargins;
+
+    bool pageMarginsSet;
+    QRect devPageRect;
+    QRect devPhysicalPageRect;
+    QRect devPaperRect;
+    qreal stretch_x;
+    qreal stretch_y;
+    int origin_x;
+    int origin_y;
+
+    int dpi_x;
+    int dpi_y;
+    int dpi_display;
+    int num_copies;
+
+    uint printToFile : 1;
+    uint fullPage : 1;
+    uint reinit : 1;
+
+    uint complex_xform : 1;
+    uint has_pen : 1;
+    uint has_brush : 1;
+    uint has_custom_paper_size : 1;
+
+    uint txop;
+
+    QColor brush_color;
+    QPen pen;
+    QColor pen_color;
+    QSizeF paper_size;
+
+    QTransform painterMatrix;
+    QTransform matrix;
+};
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_PRINTER
+
+#endif // QPRINTENGINE_WIN_P_H
diff --git a/src/gui/painting/qprinter.cpp b/src/gui/painting/qprinter.cpp
new file mode 100644
index 0000000000..5111bf4e2d
--- /dev/null
+++ b/src/gui/painting/qprinter.cpp
@@ -0,0 +1,2453 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qprinter_p.h"
+#include "qprinter.h"
+#include "qprintengine.h"
+#include "qprinterinfo.h"
+#include "qlist.h"
+#include <qpagesetupdialog.h>
+#include <qapplication.h>
+#include <qfileinfo.h>
+#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
+#include "private/qcups_p.h"
+#endif
+
+#ifndef QT_NO_PRINTER
+
+#if defined (Q_WS_WIN)
+#include <private/qprintengine_win_p.h>
+#elif defined (Q_WS_MAC)
+#include <private/qprintengine_mac_p.h>
+#elif defined (QTOPIA_PRINTENGINE)
+#include <private/qprintengine_qws_p.h>
+#endif
+#include <private/qprintengine_ps_p.h>
+
+#if defined(Q_WS_X11)
+#include <private/qt_x11_p.h>
+#endif
+
+#ifndef QT_NO_PDF
+#include "qprintengine_pdf_p.h"
+#endif
+
+#include <qpicture.h>
+#include <private/qpaintengine_preview_p.h>
+
+#if defined(QT3_SUPPORT)
+#  include "qprintdialog.h"
+#endif // QT3_SUPPORT
+
+QT_BEGIN_NAMESPACE
+
+#define ABORT_IF_ACTIVE(location) \
+    if (d->printEngine->printerState() == QPrinter::Active) { \
+        qWarning("%s: Cannot be changed while printer is active", location); \
+        return; \
+    }
+
+// NB! This table needs to be in sync with QPrinter::PaperSize
+static const float qt_paperSizes[][2] = {
+    {210, 297}, // A4
+    {176, 250}, // B5
+    {215.9f, 279.4f}, // Letter
+    {215.9f, 355.6f}, // Legal
+    {190.5f, 254}, // Executive
+    {841, 1189}, // A0
+    {594, 841}, // A1
+    {420, 594}, // A2
+    {297, 420}, // A3
+    {148, 210}, // A5
+    {105, 148}, // A6
+    {74, 105}, // A7
+    {52, 74}, // A8
+    {37, 52}, // A8
+    {1000, 1414}, // B0
+    {707, 1000}, // B1
+    {31, 44}, // B10
+    {500, 707}, // B2
+    {353, 500}, // B3
+    {250, 353}, // B4
+    {125, 176}, // B6
+    {88, 125}, // B7
+    {62, 88}, // B8
+    {33, 62}, // B9
+    {163, 229}, // C5E
+    {105, 241}, // US Common
+    {110, 220}, // DLE
+    {210, 330}, // Folio
+    {431.8f, 279.4f}, // Ledger
+    {279.4f, 431.8f} // Tabloid
+};
+
+/// return the multiplier of converting from the unit value to postscript-points.
+double qt_multiplierForUnit(QPrinter::Unit unit, int resolution)
+{
+    switch(unit) {
+    case QPrinter::Millimeter:
+        return 2.83464566929;
+    case QPrinter::Point:
+        return 1.0;
+    case QPrinter::Inch:
+        return 72.0;
+    case QPrinter::Pica:
+        return 12;
+    case QPrinter::Didot:
+        return 1.065826771;
+    case QPrinter::Cicero:
+        return 12.789921252;
+    case QPrinter::DevicePixel:
+        return 72.0/resolution;
+    }
+    return 1.0;
+}
+
+// not static: it's needed in qpagesetupdialog_unix.cpp
+QSizeF qt_printerPaperSize(QPrinter::Orientation orientation,
+                           QPrinter::PaperSize paperSize,
+                           QPrinter::Unit unit,
+                           int resolution)
+{
+    int width_index = 0;
+    int height_index = 1;
+    if (orientation == QPrinter::Landscape) {
+        width_index = 1;
+        height_index = 0;
+    }
+    const qreal multiplier = qt_multiplierForUnit(unit, resolution);
+    return QSizeF((qt_paperSizes[paperSize][width_index] * 72 / 25.4) / multiplier,
+                  (qt_paperSizes[paperSize][height_index] * 72 / 25.4) / multiplier);
+}
+
+void QPrinterPrivate::createDefaultEngines()
+{
+    QPrinter::OutputFormat realOutputFormat = outputFormat;
+#if !defined (QTOPIA_PRINTENGINE)
+#if defined (Q_OS_UNIX) && ! defined (Q_WS_MAC)
+    if(outputFormat == QPrinter::NativeFormat) {
+        realOutputFormat = QPrinter::PostScriptFormat;
+    }
+#endif
+#endif
+
+    switch (realOutputFormat) {
+    case QPrinter::NativeFormat: {
+#if defined (Q_WS_WIN)
+        QWin32PrintEngine *winEngine = new QWin32PrintEngine(printerMode);
+        paintEngine = winEngine;
+        printEngine = winEngine;
+#elif defined (Q_WS_MAC)
+        QMacPrintEngine *macEngine = new QMacPrintEngine(printerMode);
+        paintEngine = macEngine;
+        printEngine = macEngine;
+#elif defined (QTOPIA_PRINTENGINE)
+        QtopiaPrintEngine *qwsEngine = new QtopiaPrintEngine(printerMode);
+        paintEngine = qwsEngine;
+        printEngine = qwsEngine;
+#elif defined (Q_OS_UNIX)
+        Q_ASSERT(false);
+#endif
+        }
+        break;
+    case QPrinter::PdfFormat: {
+        QPdfEngine *pdfEngine = new QPdfEngine(printerMode);
+        paintEngine = pdfEngine;
+        printEngine = pdfEngine;
+    }
+        break;
+    case QPrinter::PostScriptFormat: {
+        QPSPrintEngine *psEngine = new QPSPrintEngine(printerMode);
+        paintEngine = psEngine;
+        printEngine = psEngine;
+    }
+        break;
+    }
+    use_default_engine = true;
+    had_default_engines = true;
+}
+
+#ifndef QT_NO_PRINTPREVIEWWIDGET
+QList<const QPicture *> QPrinterPrivate::previewPages() const
+{
+    if (previewEngine)
+        return previewEngine->pages();
+    return QList<const QPicture *>();
+}
+
+void QPrinterPrivate::setPreviewMode(bool enable)
+{
+    Q_Q(QPrinter);
+    if (enable) {
+        if (!previewEngine)
+            previewEngine = new QPreviewPaintEngine;
+        had_default_engines = use_default_engine;
+        use_default_engine = false;
+        realPrintEngine = printEngine;
+        realPaintEngine = paintEngine;
+        q->setEngines(previewEngine, previewEngine);
+        previewEngine->setProxyEngines(realPrintEngine, realPaintEngine);
+    } else {
+        q->setEngines(realPrintEngine, realPaintEngine);
+        use_default_engine = had_default_engines;
+    }
+}
+#endif // QT_NO_PRINTPREVIEWWIDGET
+
+void QPrinterPrivate::addToManualSetList(QPrintEngine::PrintEnginePropertyKey key)
+{
+    for (int c = 0; c < manualSetList.size(); ++c) {
+        if (manualSetList[c] == key) return;
+    }
+    manualSetList.append(key);
+}
+
+
+/*!
+  \class QPrinter
+  \reentrant
+
+  \brief The QPrinter class is a paint device that paints on a printer.
+
+  \ingroup printing
+
+
+  This device represents a series of pages of printed output, and is
+  used in almost exactly the same way as other paint devices such as
+  QWidget and QPixmap.
+  A set of additional functions are provided to manage device-specific
+  features, such as orientation and resolution, and to step through
+  the pages in a document as it is generated.
+
+  When printing directly to a printer on Windows or Mac OS X, QPrinter uses
+  the built-in printer drivers. On X11, QPrinter uses the
+  \l{Common Unix Printing System (CUPS)} or the standard Unix \l lpr utility
+  to send PostScript or PDF output to the printer. As an alternative,
+  the printProgram() function can be used to specify the command or utility
+  to use instead of the system default.
+
+  Note that setting parameters like paper size and resolution on an
+  invalid printer is undefined. You can use QPrinter::isValid() to
+  verify this before changing any parameters.
+
+  QPrinter supports a number of parameters, most of which can be
+  changed by the end user through a \l{QPrintDialog}{print dialog}. In
+  general, QPrinter passes these functions onto the underlying QPrintEngine.
+
+  The most important parameters are:
+  \list
+  \i setOrientation() tells QPrinter which page orientation to use.
+  \i setPaperSize() tells QPrinter what paper size to expect from the
+  printer.
+  \i setResolution() tells QPrinter what resolution you wish the
+  printer to provide, in dots per inch (DPI).
+  \i setFullPage() tells QPrinter whether you want to deal with the
+  full page or just with the part the printer can draw on.
+  \i setCopyCount() tells QPrinter how many copies of the document
+  it should print.
+  \endlist
+
+  Many of these functions can only be called before the actual printing
+  begins (i.e., before QPainter::begin() is called). This usually makes
+  sense because, for example, it's not possible to change the number of
+  copies when you are halfway through printing. There are also some
+  settings that the user sets (through the printer dialog) and that
+  applications are expected to obey. See QAbstractPrintDialog's
+  documentation for more details.
+
+  When QPainter::begin() is called, the QPrinter it operates on is prepared for
+  a new page, enabling the QPainter to be used immediately to paint the first
+  page in a document. Once the first page has been painted, newPage() can be
+  called to request a new blank page to paint on, or QPainter::end() can be
+  called to finish printing. The second page and all following pages are
+  prepared using a call to newPage() before they are painted.
+
+  The first page in a document does not need to be preceded by a call to
+  newPage(). You only need to calling newPage() after QPainter::begin() if you
+  need to insert a blank page at the beginning of a printed document.
+  Similarly, calling newPage() after the last page in a document is painted will
+  result in a trailing blank page appended to the end of the printed document.
+
+  If you want to abort the print job, abort() will try its best to
+  stop printing. It may cancel the entire job or just part of it.
+
+  Since QPrinter can print to any QPrintEngine subclass, it is possible to
+  extend printing support to cover new types of printing subsystem by
+  subclassing QPrintEngine and reimplementing its interface.
+
+  \sa QPrintDialog, {Printing with Qt}
+*/
+
+/*!
+    \enum QPrinter::PrinterState
+
+    \value Idle
+    \value Active
+    \value Aborted
+    \value Error
+*/
+
+/*!
+    \enum QPrinter::PrinterMode
+
+    This enum describes the mode the printer should work in. It
+    basically presets a certain resolution and working mode.
+
+    \value ScreenResolution Sets the resolution of the print device to
+    the screen resolution. This has the big advantage that the results
+    obtained when painting on the printer will match more or less
+    exactly the visible output on the screen. It is the easiest to
+    use, as font metrics on the screen and on the printer are the
+    same. This is the default value. ScreenResolution will produce a
+    lower quality output than HighResolution and should only be used
+    for drafts.
+
+    \value PrinterResolution This value is deprecated. Is is
+    equivalent to ScreenResolution on Unix and HighResolution on
+    Windows and Mac. Due do the difference between ScreenResolution
+    and HighResolution, use of this value may lead to non-portable
+    printer code.
+
+    \value HighResolution On Windows, sets the printer resolution to that
+    defined for the printer in use. For PostScript printing, sets the
+    resolution of the PostScript driver to 1200 dpi.
+
+    \note When rendering text on a QPrinter device, it is important
+    to realize that the size of text, when specified in points, is
+    independent of the resolution specified for the device itself.
+    Therefore, it may be useful to specify the font size in pixels
+    when combining text with graphics to ensure that their relative
+    sizes are what you expect.
+*/
+
+/*!
+  \enum QPrinter::Orientation
+
+  This enum type (not to be confused with \c Orientation) is used
+  to specify each page's orientation.
+
+  \value Portrait the page's height is greater than its width.
+
+  \value Landscape the page's width is greater than its height.
+
+  This type interacts with \l QPrinter::PaperSize and
+  QPrinter::setFullPage() to determine the final size of the page
+  available to the application.
+*/
+
+
+/*!
+    \enum QPrinter::PrintRange
+
+    Used to specify the print range selection option.
+
+    \value AllPages All pages should be printed.
+    \value Selection Only the selection should be printed.
+    \value PageRange The specified page range should be printed.
+    \value CurrentPage Only the current page should be printed.
+
+    \sa QAbstractPrintDialog::PrintRange
+*/
+
+/*!
+    \enum QPrinter::PrinterOption
+    \compat
+
+    Use QAbstractPrintDialog::PrintDialogOption instead.
+
+    \value PrintToFile
+    \value PrintSelection
+    \value PrintPageRange
+*/
+
+/*!
+  \enum QPrinter::PageSize
+
+  \obsolete
+  Use QPrinter::PaperSize instead.
+
+  \value A0 841 x 1189 mm
+  \value A1 594 x 841 mm
+  \value A2 420 x 594 mm
+  \value A3 297 x 420 mm
+  \value A4 210 x 297 mm, 8.26 x 11.69 inches
+  \value A5 148 x 210 mm
+  \value A6 105 x 148 mm
+  \value A7 74 x 105 mm
+  \value A8 52 x 74 mm
+  \value A9 37 x 52 mm
+  \value B0 1030 x 1456 mm
+  \value B1 728 x 1030 mm
+  \value B10 32 x 45 mm
+  \value B2 515 x 728 mm
+  \value B3 364 x 515 mm
+  \value B4 257 x 364 mm
+  \value B5 182 x 257 mm, 7.17 x 10.13 inches
+  \value B6 128 x 182 mm
+  \value B7 91 x 128 mm
+  \value B8 64 x 91 mm
+  \value B9 45 x 64 mm
+  \value C5E 163 x 229 mm
+  \value Comm10E 105 x 241 mm, U.S. Common 10 Envelope
+  \value DLE 110 x 220 mm
+  \value Executive 7.5 x 10 inches, 191 x 254 mm
+  \value Folio 210 x 330 mm
+  \value Ledger 432 x 279 mm
+  \value Legal 8.5 x 14 inches, 216 x 356 mm
+  \value Letter 8.5 x 11 inches, 216 x 279 mm
+  \value Tabloid 279 x 432 mm
+  \value Custom Unknown, or a user defined size.
+
+  \omitvalue NPageSize
+  */
+
+/*!
+  \enum QPrinter::PaperSize
+  \since 4.4
+
+  This enum type specifies what paper size QPrinter should use.
+  QPrinter does not check that the paper size is available; it just
+  uses this information, together with QPrinter::Orientation and
+  QPrinter::setFullPage(), to determine the printable area.
+
+  The defined sizes (with setFullPage(true)) are:
+
+  \value A0 841 x 1189 mm
+  \value A1 594 x 841 mm
+  \value A2 420 x 594 mm
+  \value A3 297 x 420 mm
+  \value A4 210 x 297 mm, 8.26 x 11.69 inches
+  \value A5 148 x 210 mm
+  \value A6 105 x 148 mm
+  \value A7 74 x 105 mm
+  \value A8 52 x 74 mm
+  \value A9 37 x 52 mm
+  \value B0 1000 x 1414 mm
+  \value B1 707 x 1000 mm
+  \value B2 500 x 707 mm
+  \value B3 353 x 500 mm
+  \value B4 250 x 353 mm
+  \value B5 176 x 250 mm, 6.93 x 9.84 inches
+  \value B6 125 x 176 mm
+  \value B7 88 x 125 mm
+  \value B8 62 x 88 mm
+  \value B9 33 x 62 mm
+  \value B10 31 x 44 mm
+  \value C5E 163 x 229 mm
+  \value Comm10E 105 x 241 mm, U.S. Common 10 Envelope
+  \value DLE 110 x 220 mm
+  \value Executive 7.5 x 10 inches, 190.5 x 254 mm
+  \value Folio 210 x 330 mm
+  \value Ledger 431.8 x 279.4 mm
+  \value Legal 8.5 x 14 inches, 215.9 x 355.6 mm
+  \value Letter 8.5 x 11 inches, 215.9 x 279.4 mm
+  \value Tabloid 279.4 x 431.8 mm
+  \value Custom Unknown, or a user defined size.
+
+  With setFullPage(false) (the default), the metrics will be a bit
+  smaller; how much depends on the printer in use.
+
+  \omitvalue NPageSize
+  \omitvalue NPaperSize
+*/
+
+
+/*!
+  \enum QPrinter::PageOrder
+
+  This enum type is used by QPrinter to tell the application program
+  how to print.
+
+  \value FirstPageFirst  the lowest-numbered page should be printed
+  first.
+
+  \value LastPageFirst  the highest-numbered page should be printed
+  first.
+*/
+
+/*!
+  \enum QPrinter::ColorMode
+
+  This enum type is used to indicate whether QPrinter should print
+  in color or not.
+
+  \value Color  print in color if available, otherwise in grayscale.
+
+  \value GrayScale  print in grayscale, even on color printers.
+*/
+
+/*!
+  \enum QPrinter::PaperSource
+
+  This enum type specifies what paper source QPrinter is to use.
+  QPrinter does not check that the paper source is available; it
+  just uses this information to try and set the paper source.
+  Whether it will set the paper source depends on whether the
+  printer has that particular source.
+
+  \warning This is currently only implemented for Windows.
+
+  \value Auto
+  \value Cassette
+  \value Envelope
+  \value EnvelopeManual
+  \value FormSource
+  \value LargeCapacity
+  \value LargeFormat
+  \value Lower
+  \value MaxPageSource
+  \value Middle
+  \value Manual
+  \value OnlyOne
+  \value Tractor
+  \value SmallFormat
+*/
+
+/*!
+  \enum QPrinter::Unit
+  \since 4.4
+
+  This enum type is used to specify the measurement unit for page and
+  paper sizes.
+
+  \value Millimeter
+  \value Point
+  \value Inch
+  \value Pica
+  \value Didot
+  \value Cicero
+  \value DevicePixel
+
+  Note the difference between Point and DevicePixel. The Point unit is
+  defined to be 1/72th of an inch, while the DevicePixel unit is
+  resolution dependant and is based on the actual pixels, or dots, on
+  the printer.
+*/
+
+
+/*
+  \enum QPrinter::PrintRange
+
+  This enum is used to specify which print range the application
+  should use to print.
+
+  \value AllPages All the pages should be printed.
+  \value Selection Only the selection should be printed.
+  \value PageRange Print according to the from page and to page options.
+  \value CurrentPage Only the current page should be printed.
+
+  \sa setPrintRange(), printRange()
+*/
+
+/*
+  \enum QPrinter::PrinterOption
+
+  This enum describes various printer options that appear in the
+  printer setup dialog. It is used to enable and disable these
+  options in the setup dialog.
+
+  \value PrintToFile Describes if print to file should be enabled.
+  \value PrintSelection Describes if printing selections should be enabled.
+  \value PrintPageRange Describes if printing page ranges (from, to) should
+  be enabled
+  \value PrintCurrentPage if Print Current Page option should be enabled
+
+  \sa setOptionEnabled(), isOptionEnabled()
+*/
+
+/*!
+    Creates a new printer object with the given \a mode.
+*/
+QPrinter::QPrinter(PrinterMode mode)
+    : QPaintDevice(),
+      d_ptr(new QPrinterPrivate(this))
+{
+    init(mode);
+    QPrinterInfo defPrn(QPrinterInfo::defaultPrinter());
+    if (!defPrn.isNull()) {
+        setPrinterName(defPrn.printerName());
+    } else if (QPrinterInfo::availablePrinters().isEmpty()
+               && d_ptr->paintEngine->type() != QPaintEngine::Windows
+               && d_ptr->paintEngine->type() != QPaintEngine::MacPrinter) {
+        setOutputFormat(QPrinter::PdfFormat);
+    }
+}
+
+/*!
+    \since 4.4
+
+    Creates a new printer object with the given \a printer and \a mode.
+*/
+QPrinter::QPrinter(const QPrinterInfo& printer, PrinterMode mode)
+    : QPaintDevice(),
+      d_ptr(new QPrinterPrivate(this))
+{
+    init(mode);
+    setPrinterName(printer.printerName());
+}
+
+void QPrinter::init(PrinterMode mode)
+{
+#if !defined(Q_WS_X11)
+    if (!qApp) {
+#else
+    if (!qApp || !X11) {
+#endif
+        qFatal("QPrinter: Must construct a QApplication before a QPaintDevice");
+        return;
+    }
+    Q_D(QPrinter);
+
+    d->printerMode = mode;
+    d->outputFormat = QPrinter::NativeFormat;
+    d->createDefaultEngines();
+
+#ifndef QT_NO_PRINTPREVIEWWIDGET
+    d->previewEngine = 0;
+#endif
+    d->realPrintEngine = 0;
+    d->realPaintEngine = 0;
+
+#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
+    if (QCUPSSupport::cupsVersion() >= 10200 && QCUPSSupport().currentPPD()) {
+        setOutputFormat(QPrinter::PdfFormat);
+        d->outputFormat = QPrinter::NativeFormat;
+    }
+#endif
+}
+
+/*!
+    This function is used by subclasses of QPrinter to specify custom
+    print and paint engines (\a printEngine and \a paintEngine,
+    respectively).
+
+    QPrinter does not take ownership of the engines, so you need to
+    manage these engine instances yourself.
+
+    Note that changing the engines will reset the printer state and
+    all its properties.
+
+    \sa printEngine() paintEngine() setOutputFormat()
+
+    \since 4.1
+*/
+void QPrinter::setEngines(QPrintEngine *printEngine, QPaintEngine *paintEngine)
+{
+    Q_D(QPrinter);
+
+    if (d->use_default_engine)
+        delete d->printEngine;
+
+    d->printEngine = printEngine;
+    d->paintEngine = paintEngine;
+    d->use_default_engine = false;
+}
+
+/*!
+    Destroys the printer object and frees any allocated resources. If
+    the printer is destroyed while a print job is in progress this may
+    or may not affect the print job.
+*/
+QPrinter::~QPrinter()
+{
+    Q_D(QPrinter);
+    if (d->use_default_engine)
+        delete d->printEngine;
+#ifndef QT_NO_PRINTPREVIEWWIDGET
+    delete d->previewEngine;
+#endif
+}
+
+/*!
+    \enum QPrinter::OutputFormat
+
+    The OutputFormat enum is used to describe the format QPrinter should
+    use for printing.
+
+    \value NativeFormat QPrinter will print output using a method defined
+    by the platform it is running on. This mode is the default when printing
+    directly to a printer.
+
+    \value PdfFormat QPrinter will generate its output as a searchable PDF file.
+    This mode is the default when printing to a file.
+
+    \value PostScriptFormat QPrinter will generate its output as in the PostScript format.
+    (This feature was introduced in Qt 4.2.)
+
+    \sa outputFormat(), setOutputFormat(), setOutputFileName()
+*/
+
+/*!
+    \since 4.1
+
+    Sets the output format for this printer to \a format.
+*/
+void QPrinter::setOutputFormat(OutputFormat format)
+{
+
+#ifndef QT_NO_PDF
+    Q_D(QPrinter);
+    if (d->validPrinter && d->outputFormat == format)
+        return;
+    d->outputFormat = format;
+
+    QPrintEngine *oldPrintEngine = d->printEngine;
+    const bool def_engine = d->use_default_engine;
+    d->printEngine = 0;
+
+    d->createDefaultEngines();
+
+    if (oldPrintEngine) {
+        for (int i = 0; i < d->manualSetList.size(); ++i) {
+            QPrintEngine::PrintEnginePropertyKey key = d->manualSetList[i];
+            QVariant prop;
+            // PPK_NumberOfCopies need special treatmeant since it in most cases
+            // will return 1, disregarding the actual value that was set
+            if (key == QPrintEngine::PPK_NumberOfCopies)
+                prop = QVariant(copyCount());
+            else
+                prop = oldPrintEngine->property(key);
+            if (prop.isValid())
+                d->printEngine->setProperty(key, prop);
+        }
+    }
+
+    if (def_engine)
+        delete oldPrintEngine;
+
+    if (d->outputFormat == QPrinter::PdfFormat || d->outputFormat == QPrinter::PostScriptFormat)
+        d->validPrinter = true;
+#else
+    Q_UNUSED(format);
+#endif
+}
+
+/*!
+    \since 4.1
+
+    Returns the output format for this printer.
+*/
+QPrinter::OutputFormat QPrinter::outputFormat() const
+{
+    Q_D(const QPrinter);
+    return d->outputFormat;
+}
+
+
+
+/*! \internal
+*/
+int QPrinter::devType() const
+{
+    return QInternal::Printer;
+}
+
+/*!
+    Returns the printer name. This value is initially set to the name
+    of the default printer.
+
+    \sa setPrinterName()
+*/
+QString QPrinter::printerName() const
+{
+    Q_D(const QPrinter);
+    return d->printEngine->property(QPrintEngine::PPK_PrinterName).toString();
+}
+
+/*!
+    Sets the printer name to \a name.
+
+    \sa printerName(), isValid()
+*/
+void QPrinter::setPrinterName(const QString &name)
+{
+    Q_D(QPrinter);
+    ABORT_IF_ACTIVE("QPrinter::setPrinterName");
+
+#if defined(Q_OS_UNIX) && !defined(QT_NO_CUPS)
+    if(d->use_default_engine
+        && d->outputFormat == QPrinter::NativeFormat) {
+        if (QCUPSSupport::cupsVersion() >= 10200
+            && QCUPSSupport::printerHasPPD(name.toLocal8Bit().constData()))
+            setOutputFormat(QPrinter::PdfFormat);
+        else
+            setOutputFormat(QPrinter::PostScriptFormat);
+        d->outputFormat = QPrinter::NativeFormat;
+    }
+#endif
+
+    QList<QPrinterInfo> prnList = QPrinterInfo::availablePrinters();
+    if (name.isEmpty()) {
+        d->validPrinter = d->outputFormat == QPrinter::PdfFormat || d->outputFormat == QPrinter::PostScriptFormat;
+    } else {
+        d->validPrinter = false;
+        for (int i = 0; i < prnList.size(); ++i) {
+            if (prnList[i].printerName() == name) {
+                d->validPrinter = true;
+                break;
+            }
+        }
+    }
+
+    d->printEngine->setProperty(QPrintEngine::PPK_PrinterName, name);
+    d->addToManualSetList(QPrintEngine::PPK_PrinterName);
+}
+
+
+/*!
+  \since 4.4
+
+  Returns true if the printer currently selected is a valid printer
+  in the system, or a pure PDF/PostScript printer; otherwise returns false.
+
+  To detect other failures check the output of QPainter::begin() or QPrinter::newPage().
+
+  \snippet doc/src/snippets/printing-qprinter/errors.cpp 0
+
+  \sa setPrinterName()
+*/
+bool QPrinter::isValid() const
+{
+    Q_D(const QPrinter);
+#if defined(Q_WS_X11)
+    if (!qApp || !X11) {
+        return false;
+    }
+#endif
+    return d->validPrinter;
+}
+
+
+/*!
+  \fn bool QPrinter::outputToFile() const
+
+  Returns true if the output should be written to a file, or false
+  if the output should be sent directly to the printer. The default
+  setting is false.
+
+  \sa setOutputToFile(), setOutputFileName()
+*/
+
+
+/*!
+  \fn void QPrinter::setOutputToFile(bool enable)
+
+  Specifies whether the output should be written to a file or sent
+  directly to the printer.
+
+  Will output to a file if \a enable is true, or will output
+  directly to the printer if \a enable is false.
+
+  \sa outputToFile(), setOutputFileName()
+*/
+
+
+/*!
+  \fn QString QPrinter::outputFileName() const
+
+  Returns the name of the output file. By default, this is an empty string
+  (indicating that the printer shouldn't print to file).
+
+  \sa QPrintEngine::PrintEnginePropertyKey
+
+*/
+
+QString QPrinter::outputFileName() const
+{
+    Q_D(const QPrinter);
+    return d->printEngine->property(QPrintEngine::PPK_OutputFileName).toString();
+}
+
+/*!
+    Sets the name of the output file to \a fileName.
+
+    Setting a null or empty name (0 or "") disables printing to a file.
+    Setting a non-empty name enables printing to a file.
+
+    This can change the value of outputFormat().  If the file name has the
+    suffix ".ps" then PostScript is automatically selected as output format.
+    If the file name has the ".pdf" suffix PDF is generated. If the file name
+    has a suffix other than ".ps" and ".pdf", the output format used is the
+    one set with setOutputFormat().
+
+    QPrinter uses Qt's cross-platform PostScript or PDF print engines
+    respectively. If you can produce this format natively, for example
+    Mac OS X can generate PDF's from its print engine, set the output format
+    back to NativeFormat.
+
+    \sa outputFileName() setOutputToFile() setOutputFormat()
+*/
+
+void QPrinter::setOutputFileName(const QString &fileName)
+{
+    Q_D(QPrinter);
+    ABORT_IF_ACTIVE("QPrinter::setOutputFileName");
+
+    QFileInfo fi(fileName);
+    if (!fi.suffix().compare(QLatin1String("ps"), Qt::CaseInsensitive))
+        setOutputFormat(QPrinter::PostScriptFormat);
+    else if (!fi.suffix().compare(QLatin1String("pdf"), Qt::CaseInsensitive))
+        setOutputFormat(QPrinter::PdfFormat);
+    else if (fileName.isEmpty())
+        setOutputFormat(QPrinter::NativeFormat);
+
+    d->printEngine->setProperty(QPrintEngine::PPK_OutputFileName, fileName);
+    d->addToManualSetList(QPrintEngine::PPK_OutputFileName);
+}
+
+
+/*!
+  Returns the name of the program that sends the print output to the
+  printer.
+
+  The default is to return an empty string; meaning that QPrinter will try to
+  be smart in a system-dependent way. On X11 only, you can set it to something
+  different to use a specific print program. On the other platforms, this
+  returns an empty string.
+
+  \sa setPrintProgram(), setPrinterSelectionOption()
+*/
+QString QPrinter::printProgram() const
+{
+    Q_D(const QPrinter);
+    return d->printEngine->property(QPrintEngine::PPK_PrinterProgram).toString();
+}
+
+
+/*!
+  Sets the name of the program that should do the print job to \a
+  printProg.
+
+  On X11, this function sets the program to call with the PostScript
+  output. On other platforms, it has no effect.
+
+  \sa printProgram()
+*/
+void QPrinter::setPrintProgram(const QString &printProg)
+{
+    Q_D(QPrinter);
+    ABORT_IF_ACTIVE("QPrinter::setPrintProgram");
+    d->printEngine->setProperty(QPrintEngine::PPK_PrinterProgram, printProg);
+    d->addToManualSetList(QPrintEngine::PPK_PrinterProgram);
+}
+
+
+/*!
+  Returns the document name.
+
+  \sa setDocName(), QPrintEngine::PrintEnginePropertyKey
+*/
+QString QPrinter::docName() const
+{
+    Q_D(const QPrinter);
+    return d->printEngine->property(QPrintEngine::PPK_DocumentName).toString();
+}
+
+
+/*!
+  Sets the document name to \a name.
+
+  On X11, the document name is for example used as the default
+  output filename in QPrintDialog. Note that the document name does
+  not affect the file name if the printer is printing to a file.
+  Use the setOutputFile() function for this.
+
+  \sa docName(), QPrintEngine::PrintEnginePropertyKey
+*/
+void QPrinter::setDocName(const QString &name)
+{
+    Q_D(QPrinter);
+    ABORT_IF_ACTIVE("QPrinter::setDocName");
+    d->printEngine->setProperty(QPrintEngine::PPK_DocumentName, name);
+    d->addToManualSetList(QPrintEngine::PPK_DocumentName);
+}
+
+
+/*!
+  Returns the name of the application that created the document.
+
+  \sa setCreator()
+*/
+QString QPrinter::creator() const
+{
+    Q_D(const QPrinter);
+    return d->printEngine->property(QPrintEngine::PPK_Creator).toString();
+}
+
+
+/*!
+  Sets the name of the application that created the document to \a
+  creator.
+
+  This function is only applicable to the X11 version of Qt. If no
+  creator name is specified, the creator will be set to "Qt"
+  followed by some version number.
+
+  \sa creator()
+*/
+void QPrinter::setCreator(const QString &creator)
+{
+    Q_D(QPrinter);
+    ABORT_IF_ACTIVE("QPrinter::setCreator");
+    d->printEngine->setProperty(QPrintEngine::PPK_Creator, creator);
+    d->addToManualSetList(QPrintEngine::PPK_Creator);
+}
+
+
+/*!
+  Returns the orientation setting. This is driver-dependent, but is usually
+  QPrinter::Portrait.
+
+  \sa setOrientation()
+*/
+QPrinter::Orientation QPrinter::orientation() const
+{
+    Q_D(const QPrinter);
+    return QPrinter::Orientation(d->printEngine->property(QPrintEngine::PPK_Orientation).toInt());
+}
+
+
+/*!
+  Sets the print orientation to \a orientation.
+
+  The orientation can be either QPrinter::Portrait or
+  QPrinter::Landscape.
+
+  The printer driver reads this setting and prints using the
+  specified orientation.
+
+  On Windows, this option can be changed while printing and will
+  take effect from the next call to newPage().
+
+  On Mac OS X, changing the orientation during a print job has no effect.
+
+  \sa orientation()
+*/
+
+void QPrinter::setOrientation(Orientation orientation)
+{
+    Q_D(QPrinter);
+    d->printEngine->setProperty(QPrintEngine::PPK_Orientation, orientation);
+    d->addToManualSetList(QPrintEngine::PPK_Orientation);
+}
+
+
+/*!
+    \since 4.4
+    Returns the printer paper size. The default value is driver-dependent.
+
+    \sa setPaperSize() pageRect() paperRect()
+*/
+
+QPrinter::PaperSize QPrinter::paperSize() const
+{
+    Q_D(const QPrinter);
+    return QPrinter::PaperSize(d->printEngine->property(QPrintEngine::PPK_PaperSize).toInt());
+}
+
+/*!
+    \since 4.4
+
+    Sets the printer paper size to \a newPaperSize if that size is
+    supported. The result is undefined if \a newPaperSize is not
+    supported.
+
+    The default paper size is driver-dependent.
+
+    This function is useful mostly for setting a default value that
+    the user can override in the print dialog.
+
+    \sa paperSize() PaperSize setFullPage() setResolution() pageRect() paperRect()
+*/
+void QPrinter::setPaperSize(PaperSize newPaperSize)
+{
+    Q_D(QPrinter);
+    if (d->paintEngine->type() != QPaintEngine::Pdf)
+        ABORT_IF_ACTIVE("QPrinter::setPaperSize");
+    if (newPaperSize < 0 || newPaperSize >= NPaperSize) {
+        qWarning("QPrinter::setPaperSize: Illegal paper size %d", newPaperSize);
+        return;
+    }
+    d->printEngine->setProperty(QPrintEngine::PPK_PaperSize, newPaperSize);
+    d->addToManualSetList(QPrintEngine::PPK_PaperSize);
+    d->hasUserSetPageSize = true;
+}
+
+/*!
+    \obsolete
+
+    Returns the printer page size. The default value is driver-dependent.
+
+    Use paperSize() instead.
+*/
+QPrinter::PageSize QPrinter::pageSize() const
+{
+    return paperSize();
+}
+
+
+/*!
+    \obsolete
+
+    Sets the printer page size based on \a newPageSize.
+
+    Use setPaperSize() instead.
+*/
+
+void QPrinter::setPageSize(PageSize newPageSize)
+{
+    setPaperSize(newPageSize);
+}
+
+/*!
+    \since 4.4
+
+    Sets the paper size based on \a paperSize in \a unit.
+
+    \sa paperSize()
+*/
+
+void QPrinter::setPaperSize(const QSizeF &paperSize, QPrinter::Unit unit)
+{
+    Q_D(QPrinter);
+    if (d->paintEngine->type() != QPaintEngine::Pdf)
+        ABORT_IF_ACTIVE("QPrinter::setPaperSize");
+    const qreal multiplier = qt_multiplierForUnit(unit, resolution());
+    QSizeF size(paperSize.width() * multiplier, paperSize.height() * multiplier);
+    d->printEngine->setProperty(QPrintEngine::PPK_CustomPaperSize, size);
+    d->addToManualSetList(QPrintEngine::PPK_CustomPaperSize);
+    d->hasUserSetPageSize = true;
+}
+
+/*!
+    \since 4.4
+
+    Returns the paper size in \a unit.
+
+    \sa setPaperSize()
+*/
+
+QSizeF QPrinter::paperSize(Unit unit) const
+{
+    Q_D(const QPrinter);
+    int res = resolution();
+    const qreal multiplier = qt_multiplierForUnit(unit, res);
+    PaperSize paperType = paperSize();
+    if (paperType == Custom) {
+        QSizeF size = d->printEngine->property(QPrintEngine::PPK_CustomPaperSize).toSizeF();
+        return QSizeF(size.width() / multiplier, size.height() / multiplier);
+    }
+    else {
+        return qt_printerPaperSize(orientation(), paperType, unit, res);
+    }
+}
+
+/*!
+    Sets the page order to \a pageOrder.
+
+    The page order can be QPrinter::FirstPageFirst or
+    QPrinter::LastPageFirst. The application is responsible for
+    reading the page order and printing accordingly.
+
+    This function is mostly useful for setting a default value that
+    the user can override in the print dialog.
+
+    This function is only supported under X11.
+*/
+
+void QPrinter::setPageOrder(PageOrder pageOrder)
+{
+    Q_D(QPrinter);
+    ABORT_IF_ACTIVE("QPrinter::setPageOrder");
+    d->printEngine->setProperty(QPrintEngine::PPK_PageOrder, pageOrder);
+    d->addToManualSetList(QPrintEngine::PPK_PageOrder);
+}
+
+
+/*!
+  Returns the current page order.
+
+  The default page order is \c FirstPageFirst.
+*/
+
+QPrinter::PageOrder QPrinter::pageOrder() const
+{
+    Q_D(const QPrinter);
+    return QPrinter::PageOrder(d->printEngine->property(QPrintEngine::PPK_PageOrder).toInt());
+}
+
+
+/*!
+  Sets the printer's color mode to \a newColorMode, which can be
+  either \c Color or \c GrayScale.
+
+  \sa colorMode()
+*/
+
+void QPrinter::setColorMode(ColorMode newColorMode)
+{
+    Q_D(QPrinter);
+    ABORT_IF_ACTIVE("QPrinter::setColorMode");
+    d->printEngine->setProperty(QPrintEngine::PPK_ColorMode, newColorMode);
+    d->addToManualSetList(QPrintEngine::PPK_ColorMode);
+}
+
+
+/*!
+  Returns the current color mode.
+
+  \sa setColorMode()
+*/
+QPrinter::ColorMode QPrinter::colorMode() const
+{
+    Q_D(const QPrinter);
+    return QPrinter::ColorMode(d->printEngine->property(QPrintEngine::PPK_ColorMode).toInt());
+}
+
+
+/*!
+  \obsolete
+  Returns the number of copies to be printed. The default value is 1.
+
+  On Windows, Mac OS X and X11 systems that support CUPS, this will always
+  return 1 as these operating systems can internally handle the number
+  of copies.
+
+  On X11, this value will return the number of times the application is
+  required to print in order to match the number specified in the printer setup
+  dialog. This has been done since some printer drivers are not capable of
+  buffering up the copies and in those cases the application must make an
+  explicit call to the print code for each copy.
+
+  Use copyCount() in conjunction with supportsMultipleCopies() instead.
+
+  \sa setNumCopies(), actualNumCopies()
+*/
+
+int QPrinter::numCopies() const
+{
+    Q_D(const QPrinter);
+   return d->printEngine->property(QPrintEngine::PPK_NumberOfCopies).toInt();
+}
+
+
+/*!
+    \obsolete
+    \since 4.6
+
+    Returns the number of copies that will be printed. The default
+    value is 1.
+
+    This function always returns the actual value specified in the print
+    dialog or using setNumCopies().
+
+    Use copyCount() instead.
+
+    \sa setNumCopies(), numCopies()
+*/
+int QPrinter::actualNumCopies() const
+{
+    return copyCount();
+}
+
+
+
+/*!
+  \obsolete
+  Sets the number of copies to be printed to \a numCopies.
+
+  The printer driver reads this setting and prints the specified
+  number of copies.
+
+  Use setCopyCount() instead.
+
+  \sa numCopies()
+*/
+
+void QPrinter::setNumCopies(int numCopies)
+{
+    Q_D(QPrinter);
+    ABORT_IF_ACTIVE("QPrinter::setNumCopies");
+    d->printEngine->setProperty(QPrintEngine::PPK_NumberOfCopies, numCopies);
+    d->addToManualSetList(QPrintEngine::PPK_NumberOfCopies);
+}
+
+/*!
+    \since 4.7
+
+    Sets the number of copies to be printed to \a count.
+
+    The printer driver reads this setting and prints the specified number of
+    copies.
+
+    \sa copyCount(), supportsMultipleCopies()
+*/
+
+void QPrinter::setCopyCount(int count)
+{
+    Q_D(QPrinter);
+    ABORT_IF_ACTIVE("QPrinter::setCopyCount;");
+    d->printEngine->setProperty(QPrintEngine::PPK_CopyCount, count);
+    d->addToManualSetList(QPrintEngine::PPK_CopyCount);
+}
+
+/*!
+    \since 4.7
+
+    Returns the number of copies that will be printed. The default value is 1.
+
+    \sa setCopyCount(), supportsMultipleCopies()
+*/
+
+int QPrinter::copyCount() const
+{
+    Q_D(const QPrinter);
+    return d->printEngine->property(QPrintEngine::PPK_CopyCount).toInt();
+}
+
+/*!
+    \since 4.7
+
+    Returns true if the printer supports printing multiple copies of the same
+    document in one job; otherwise false is returned.
+
+    On most systems this function will return true. However, on X11 systems
+    that do not support CUPS, this function will return false. That means the
+    application has to handle the number of copies by printing the same
+    document the required number of times.
+
+    \sa setCopyCount(), copyCount()
+*/
+
+bool QPrinter::supportsMultipleCopies() const
+{
+    Q_D(const QPrinter);
+    return d->printEngine->property(QPrintEngine::PPK_SupportsMultipleCopies).toBool();
+}
+
+/*!
+    \since 4.1
+
+    Returns true if collation is turned on when multiple copies is selected.
+    Returns false if it is turned off when multiple copies is selected.
+    When collating is turned off the printing of each individual page will be repeated
+    the numCopies() amount before the next page is started. With collating turned on
+    all pages are printed before the next copy of those pages is started.
+
+    \sa setCollateCopies()
+*/
+bool QPrinter::collateCopies() const
+{
+    Q_D(const QPrinter);
+    return d->printEngine->property(QPrintEngine::PPK_CollateCopies).toBool();
+}
+
+
+/*!
+    \since 4.1
+
+    Sets the default value for collation checkbox when the print
+    dialog appears.  If \a collate is true, it will enable
+    setCollateCopiesEnabled().  The default value is false. This value
+    will be changed by what the user presses in the print dialog.
+
+    \sa collateCopies()
+*/
+void QPrinter::setCollateCopies(bool collate)
+{
+    Q_D(QPrinter);
+    ABORT_IF_ACTIVE("QPrinter::setCollateCopies");
+    d->printEngine->setProperty(QPrintEngine::PPK_CollateCopies, collate);
+    d->addToManualSetList(QPrintEngine::PPK_CollateCopies);
+}
+
+
+
+/*!
+  If \a fp is true, enables support for painting over the entire page;
+  otherwise restricts painting to the printable area reported by the
+  device.
+
+  By default, full page printing is disabled. In this case, the origin
+  of the QPrinter's coordinate system coincides with the top-left
+  corner of the printable area.
+
+  If full page printing is enabled, the origin of the QPrinter's
+  coordinate system coincides with the top-left corner of the paper
+  itself. In this case, the
+  \l{QPaintDevice::PaintDeviceMetric}{device metrics} will report
+  the exact same dimensions as indicated by \l{PaperSize}. It may not
+  be possible to print on the entire physical page because of the
+  printer's margins, so the application must account for the margins
+  itself.
+
+  \sa fullPage(), setPaperSize(), width(), height(), {Printing with Qt}
+*/
+
+void QPrinter::setFullPage(bool fp)
+{
+    Q_D(QPrinter);
+    d->printEngine->setProperty(QPrintEngine::PPK_FullPage, fp);
+    d->addToManualSetList(QPrintEngine::PPK_FullPage);
+}
+
+
+/*!
+  Returns true if the origin of the printer's coordinate system is
+  at the corner of the page and false if it is at the edge of the
+  printable area.
+
+  See setFullPage() for details and caveats.
+
+  \sa setFullPage() PaperSize
+*/
+
+bool QPrinter::fullPage() const
+{
+    Q_D(const QPrinter);
+    return d->printEngine->property(QPrintEngine::PPK_FullPage).toBool();
+}
+
+
+/*!
+  Requests that the printer prints at \a dpi or as near to \a dpi as
+  possible.
+
+  This setting affects the coordinate system as returned by, for
+  example QPainter::viewport().
+
+  This function must be called before QPainter::begin() to have an effect on
+  all platforms.
+
+  \sa resolution() setPaperSize()
+*/
+
+void QPrinter::setResolution(int dpi)
+{
+    Q_D(QPrinter);
+    ABORT_IF_ACTIVE("QPrinter::setResolution");
+    d->printEngine->setProperty(QPrintEngine::PPK_Resolution, dpi);
+    d->addToManualSetList(QPrintEngine::PPK_Resolution);
+}
+
+
+/*!
+  Returns the current assumed resolution of the printer, as set by
+  setResolution() or by the printer driver.
+
+  \sa setResolution()
+*/
+
+int QPrinter::resolution() const
+{
+    Q_D(const QPrinter);
+    return d->printEngine->property(QPrintEngine::PPK_Resolution).toInt();
+}
+
+/*!
+  Sets the paper source setting to \a source.
+
+  Windows only: This option can be changed while printing and will
+  take effect from the next call to newPage()
+
+  \sa paperSource()
+*/
+
+void QPrinter::setPaperSource(PaperSource source)
+{
+    Q_D(QPrinter);
+    d->printEngine->setProperty(QPrintEngine::PPK_PaperSource, source);
+    d->addToManualSetList(QPrintEngine::PPK_PaperSource);
+}
+
+/*!
+    Returns the printer's paper source. This is \c Manual or a printer
+    tray or paper cassette.
+*/
+QPrinter::PaperSource QPrinter::paperSource() const
+{
+    Q_D(const QPrinter);
+    return QPrinter::PaperSource(d->printEngine->property(QPrintEngine::PPK_PaperSource).toInt());
+}
+
+
+/*!
+  \since 4.1
+
+  Enabled or disables font embedding depending on \a enable.
+
+  Currently this option is only supported on X11.
+
+  \sa fontEmbeddingEnabled()
+*/
+void QPrinter::setFontEmbeddingEnabled(bool enable)
+{
+    Q_D(QPrinter);
+    d->printEngine->setProperty(QPrintEngine::PPK_FontEmbedding, enable);
+    d->addToManualSetList(QPrintEngine::PPK_FontEmbedding);
+}
+
+/*!
+  \since 4.1
+
+  Returns true if font embedding is enabled.
+
+  Currently this option is only supported on X11.
+
+  \sa setFontEmbeddingEnabled()
+*/
+bool QPrinter::fontEmbeddingEnabled() const
+{
+    Q_D(const QPrinter);
+    return d->printEngine->property(QPrintEngine::PPK_FontEmbedding).toBool();
+}
+
+/*!
+    \enum QPrinter::DuplexMode
+    \since 4.4
+
+    This enum is used to indicate whether printing will occur on one or both sides
+    of each sheet of paper (simplex or duplex printing).
+
+    \value DuplexNone       Single sided (simplex) printing only.
+    \value DuplexAuto       The printer's default setting is used to determine whether
+                            duplex printing is used.
+    \value DuplexLongSide   Both sides of each sheet of paper are used for printing.
+                            The paper is turned over its longest edge before the second
+                            side is printed
+    \value DuplexShortSide  Both sides of each sheet of paper are used for printing.
+                            The paper is turned over its shortest edge before the second
+                            side is printed
+*/
+
+/*!
+  \since 4.2
+
+  Enables double sided printing if \a doubleSided is true; otherwise disables it.
+
+  Currently this option is only supported on X11.
+*/
+void QPrinter::setDoubleSidedPrinting(bool doubleSided)
+{
+    setDuplex(doubleSided ? DuplexAuto : DuplexNone);
+}
+
+
+/*!
+  \since 4.2
+
+  Returns true if double side printing is enabled.
+
+  Currently this option is only supported on X11.
+*/
+bool QPrinter::doubleSidedPrinting() const
+{
+    return duplex() != DuplexNone;
+}
+
+/*!
+  \since 4.4
+
+  Enables double sided printing based on the \a duplex mode.
+
+  Currently this option is only supported on X11.
+*/
+void QPrinter::setDuplex(DuplexMode duplex)
+{
+    Q_D(QPrinter);
+    d->printEngine->setProperty(QPrintEngine::PPK_Duplex, duplex);
+    d->addToManualSetList(QPrintEngine::PPK_Duplex);
+}
+
+/*!
+  \since 4.4
+
+  Returns the current duplex mode.
+
+  Currently this option is only supported on X11.
+*/
+QPrinter::DuplexMode QPrinter::duplex() const
+{
+    Q_D(const QPrinter);
+    return static_cast <DuplexMode> (d->printEngine->property(QPrintEngine::PPK_Duplex).toInt());
+}
+
+/*!
+    \since 4.4
+
+    Returns the page's rectangle in \a unit; this is usually smaller
+    than the paperRect() since the page normally has margins between
+    its borders and the paper.
+
+    \sa paperSize()
+*/
+QRectF QPrinter::pageRect(Unit unit) const
+{
+    Q_D(const QPrinter);
+    int res = resolution();
+    const qreal multiplier = qt_multiplierForUnit(unit, res);
+    // the page rect is in device pixels
+    QRect devRect(d->printEngine->property(QPrintEngine::PPK_PageRect).toRect());
+    if (unit == DevicePixel)
+        return devRect;
+    QRectF diRect(devRect.x()*72.0/res,
+                  devRect.y()*72.0/res,
+                  devRect.width()*72.0/res,
+                  devRect.height()*72.0/res);
+    return QRectF(diRect.x()/multiplier, diRect.y()/multiplier,
+                  diRect.width()/multiplier, diRect.height()/multiplier);
+}
+
+
+/*!
+    \since 4.4
+
+    Returns the paper's rectangle in \a unit; this is usually larger
+    than the pageRect().
+
+   \sa pageRect()
+*/
+QRectF QPrinter::paperRect(Unit unit) const
+{
+    Q_D(const QPrinter);
+    int res = resolution();
+    const qreal multiplier = qt_multiplierForUnit(unit, resolution());
+    // the page rect is in device pixels
+    QRect devRect(d->printEngine->property(QPrintEngine::PPK_PaperRect).toRect());
+    if (unit == DevicePixel)
+        return devRect;
+    QRectF diRect(devRect.x()*72.0/res,
+                  devRect.y()*72.0/res,
+                  devRect.width()*72.0/res,
+                  devRect.height()*72.0/res);
+    return QRectF(diRect.x()/multiplier, diRect.y()/multiplier,
+                  diRect.width()/multiplier, diRect.height()/multiplier);
+}
+
+/*!
+    Returns the page's rectangle; this is usually smaller than the
+    paperRect() since the page normally has margins between its
+    borders and the paper.
+
+    The unit of the returned rectangle is DevicePixel.
+
+    \sa paperSize()
+*/
+QRect QPrinter::pageRect() const
+{
+    Q_D(const QPrinter);
+    return d->printEngine->property(QPrintEngine::PPK_PageRect).toRect();
+}
+
+/*!
+    Returns the paper's rectangle; this is usually larger than the
+    pageRect().
+
+    The unit of the returned rectangle is DevicePixel.
+
+    \sa pageRect()
+*/
+QRect QPrinter::paperRect() const
+{
+    Q_D(const QPrinter);
+    return d->printEngine->property(QPrintEngine::PPK_PaperRect).toRect();
+}
+
+
+/*!
+    \since 4.4
+
+    This function sets the \a left, \a top, \a right and \a bottom
+    page margins for this printer. The unit of the margins are
+    specified with the \a unit parameter.
+*/
+void QPrinter::setPageMargins(qreal left, qreal top, qreal right, qreal bottom, QPrinter::Unit unit)
+{
+    Q_D(QPrinter);
+    const qreal multiplier = qt_multiplierForUnit(unit, resolution());
+    QList<QVariant> margins;
+    margins << (left * multiplier) << (top * multiplier)
+            << (right * multiplier) << (bottom * multiplier);
+    d->printEngine->setProperty(QPrintEngine::PPK_PageMargins, margins);
+    d->addToManualSetList(QPrintEngine::PPK_PageMargins);
+    d->hasCustomPageMargins = true;
+}
+
+/*!
+    \since 4.4
+
+    Returns the page margins for this printer in \a left, \a top, \a
+    right, \a bottom. The unit of the returned margins are specified
+    with the \a unit parameter.
+*/
+void QPrinter::getPageMargins(qreal *left, qreal *top, qreal *right, qreal *bottom, QPrinter::Unit unit) const
+{
+    Q_D(const QPrinter);
+    Q_ASSERT(left && top && right && bottom);
+    const qreal multiplier = qt_multiplierForUnit(unit, resolution());
+    QList<QVariant> margins(d->printEngine->property(QPrintEngine::PPK_PageMargins).toList());
+    *left = margins.at(0).toReal() / multiplier;
+    *top = margins.at(1).toReal() / multiplier;
+    *right = margins.at(2).toReal() / multiplier;
+    *bottom = margins.at(3).toReal() / multiplier;
+}
+
+/*!
+    \internal
+
+    Returns the metric for the given \a id.
+*/
+int QPrinter::metric(PaintDeviceMetric id) const
+{
+    Q_D(const QPrinter);
+    return d->printEngine->metric(id);
+}
+
+/*!
+    Returns the paint engine used by the printer.
+*/
+QPaintEngine *QPrinter::paintEngine() const
+{
+    Q_D(const QPrinter);
+    return d->paintEngine;
+}
+
+/*!
+    \since 4.1
+
+    Returns the print engine used by the printer.
+*/
+QPrintEngine *QPrinter::printEngine() const
+{
+    Q_D(const QPrinter);
+    return d->printEngine;
+}
+
+#if defined (Q_WS_WIN)
+/*!
+    Sets the page size to be used by the printer under Windows to \a
+    pageSize.
+
+    \warning This function is not portable so you may prefer to use
+    setPaperSize() instead.
+
+    \sa winPageSize()
+*/
+void QPrinter::setWinPageSize(int pageSize)
+{
+    Q_D(QPrinter);
+    ABORT_IF_ACTIVE("QPrinter::setWinPageSize");
+    d->printEngine->setProperty(QPrintEngine::PPK_WindowsPageSize, pageSize);
+    d->addToManualSetList(QPrintEngine::PPK_WindowsPageSize);
+}
+
+/*!
+    Returns the page size used by the printer under Windows.
+
+    \warning This function is not portable so you may prefer to use
+    paperSize() instead.
+
+    \sa setWinPageSize()
+*/
+int QPrinter::winPageSize() const
+{
+    Q_D(const QPrinter);
+    return d->printEngine->property(QPrintEngine::PPK_WindowsPageSize).toInt();
+}
+#endif // Q_WS_WIN
+
+/*!
+    Returns a list of the resolutions (a list of dots-per-inch
+    integers) that the printer says it supports.
+
+    For X11 where all printing is directly to postscript, this
+    function will always return a one item list containing only the
+    postscript resolution, i.e., 72 (72 dpi -- but see PrinterMode).
+*/
+QList<int> QPrinter::supportedResolutions() const
+{
+    Q_D(const QPrinter);
+    QList<QVariant> varlist
+        = d->printEngine->property(QPrintEngine::PPK_SupportedResolutions).toList();
+    QList<int> intlist;
+    for (int i=0; i<varlist.size(); ++i)
+        intlist << varlist.at(i).toInt();
+    return intlist;
+}
+
+/*!
+    Tells the printer to eject the current page and to continue
+    printing on a new page. Returns true if this was successful;
+    otherwise returns false.
+
+    Calling newPage() on an inactive QPrinter object will always
+    fail.
+*/
+bool QPrinter::newPage()
+{
+    Q_D(QPrinter);
+    if (d->printEngine->printerState() != QPrinter::Active)
+        return false;
+    return d->printEngine->newPage();
+}
+
+/*!
+    Aborts the current print run. Returns true if the print run was
+    successfully aborted and printerState() will return QPrinter::Aborted; otherwise
+    returns false.
+
+    It is not always possible to abort a print job. For example,
+    all the data has gone to the printer but the printer cannot or
+    will not cancel the job when asked to.
+*/
+bool QPrinter::abort()
+{
+    Q_D(QPrinter);
+    return d->printEngine->abort();
+}
+
+/*!
+    Returns the current state of the printer. This may not always be
+    accurate (for example if the printer doesn't have the capability
+    of reporting its state to the operating system).
+*/
+QPrinter::PrinterState QPrinter::printerState() const
+{
+    Q_D(const QPrinter);
+    return d->printEngine->printerState();
+}
+
+
+/*! \fn void QPrinter::margins(uint *top, uint *left, uint *bottom, uint *right) const
+
+    Sets *\a top, *\a left, *\a bottom, *\a right to be the top,
+    left, bottom, and right margins.
+
+    This function has been superseded by paperRect() and pageRect().
+    Use paperRect().top() - pageRect().top() for the top margin,
+    paperRect().left() - pageRect().left() for the left margin,
+    paperRect().bottom() - pageRect().bottom() for the bottom margin,
+    and papaerRect().right() - pageRect().right() for the right
+    margin.
+
+    \oldcode
+        uint rightMargin;
+        uint bottomMargin;
+        printer->margins(0, 0, &bottomMargin, &rightMargin);
+    \newcode
+        int rightMargin = printer->paperRect().right() - printer->pageRect().right();
+        int bottomMargin = printer->paperRect().bottom() - printer->pageRect().bottom();
+    \endcode
+*/
+
+/*! \fn QSize QPrinter::margins() const
+
+    \overload
+
+    Returns a QSize containing the left margin and the top margin.
+
+    This function has been superseded by paperRect() and pageRect().
+    Use paperRect().left() - pageRect().left() for the left margin,
+    and paperRect().top() - pageRect().top() for the top margin.
+
+    \oldcode
+        QSize margins = printer->margins();
+        int leftMargin = margins.width();
+        int topMargin = margins.height();
+    \newcode
+        int leftMargin = printer->paperRect().left() - printer->pageRect().left();
+        int topMargin = printer->paperRect().top() - printer->pageRect().top();
+    \endcode
+*/
+
+/*! \fn bool QPrinter::aborted()
+
+    Use printerState() == QPrinter::Aborted instead.
+*/
+
+#ifdef Q_WS_WIN
+/*!
+    \internal
+*/
+HDC QPrinter::getDC() const
+{
+    Q_D(const QPrinter);
+    return d->printEngine->getPrinterDC();
+}
+
+/*!
+    \internal
+*/
+void QPrinter::releaseDC(HDC hdc) const
+{
+    Q_D(const QPrinter);
+    d->printEngine->releasePrinterDC(hdc);
+}
+
+/*!
+    Returns the supported paper sizes for this printer.
+
+    The values will be either a value that matches an entry in the
+    QPrinter::PaperSource enum or a driver spesific value. The driver
+    spesific values are greater than the constant DMBIN_USER declared
+    in wingdi.h.
+
+    \warning This function is only available in windows.
+*/
+
+QList<QPrinter::PaperSource> QPrinter::supportedPaperSources() const
+{
+    Q_D(const QPrinter);
+    QVariant v = d->printEngine->property(QPrintEngine::PPK_PaperSources);
+
+    QList<QVariant> variant_list = v.toList();
+    QList<QPrinter::PaperSource> int_list;
+    for (int i=0; i<variant_list.size(); ++i)
+        int_list << (QPrinter::PaperSource) variant_list.at(i).toInt();
+
+    return int_list;
+}
+
+#endif
+
+/*!
+    \fn QString QPrinter::printerSelectionOption() const
+
+    Returns the printer options selection string. This is useful only
+    if the print command has been explicitly set.
+
+    The default value (an empty string) implies that the printer should
+    be selected in a system-dependent manner.
+
+    Any other value implies that the given value should be used.
+
+    \warning This function is not available on Windows.
+
+    \sa setPrinterSelectionOption()
+*/
+
+/*!
+    \fn void QPrinter::setPrinterSelectionOption(const QString &option)
+
+    Sets the printer to use \a option to select the printer. \a option
+    is null by default (which implies that Qt should be smart enough
+    to guess correctly), but it can be set to other values to use a
+    specific printer selection option.
+
+    If the printer selection option is changed while the printer is
+    active, the current print job may or may not be affected.
+
+    \warning This function is not available on Windows.
+
+    \sa printerSelectionOption()
+*/
+
+#ifndef Q_WS_WIN
+QString QPrinter::printerSelectionOption() const
+{
+    Q_D(const QPrinter);
+    return d->printEngine->property(QPrintEngine::PPK_SelectionOption).toString();
+}
+
+void QPrinter::setPrinterSelectionOption(const QString &option)
+{
+    Q_D(QPrinter);
+    d->printEngine->setProperty(QPrintEngine::PPK_SelectionOption, option);
+    d->addToManualSetList(QPrintEngine::PPK_SelectionOption);
+}
+#endif
+
+/*!
+    \since 4.1
+    \fn int QPrinter::fromPage() const
+
+    Returns the number of the first page in a range of pages to be printed
+    (the "from page" setting). Pages in a document are numbered according to
+    the convention that the first page is page 1.
+
+    By default, this function returns a special value of 0, meaning that
+    the "from page" setting is unset.
+
+    \note If fromPage() and toPage() both return 0, this indicates that
+    \e{the whole document will be printed}.
+
+    \sa setFromTo(), toPage()
+*/
+
+int QPrinter::fromPage() const
+{
+    Q_D(const QPrinter);
+    return d->fromPage;
+}
+
+/*!
+    \since 4.1
+
+    Returns the number of the last page in a range of pages to be printed
+    (the "to page" setting). Pages in a document are numbered according to
+    the convention that the first page is page 1.
+
+    By default, this function returns a special value of 0, meaning that
+    the "to page" setting is unset.
+
+    \note If fromPage() and toPage() both return 0, this indicates that
+    \e{the whole document will be printed}.
+
+    The programmer is responsible for reading this setting and
+    printing accordingly.
+
+    \sa setFromTo(), fromPage()
+*/
+
+int QPrinter::toPage() const
+{
+    Q_D(const QPrinter);
+    return d->toPage;
+}
+
+/*!
+    \since 4.1
+
+    Sets the range of pages to be printed to cover the pages with numbers
+    specified by \a from and \a to, where \a from corresponds to the first
+    page in the range and \a to corresponds to the last.
+
+    \note Pages in a document are numbered according to the convention that
+    the first page is page 1. However, if \a from and \a to are both set to 0,
+    the \e{whole document will be printed}.
+
+    This function is mostly used to set a default value that the user can
+    override in the print dialog when you call setup().
+
+    \sa fromPage(), toPage()
+*/
+
+void QPrinter::setFromTo(int from, int to)
+{
+    Q_D(QPrinter);
+    if (from > to) {
+        qWarning() << "QPrinter::setFromTo: 'from' must be less than or equal to 'to'";
+        from = to;
+    }
+    d->fromPage = from;
+    d->toPage = to;
+
+    if (d->minPage == 0 && d->maxPage == 0) {
+        d->minPage = 1;
+        d->maxPage = to;
+        d->options |= QAbstractPrintDialog::PrintPageRange;
+    }
+}
+
+/*!
+    \since 4.1
+
+    Sets the print range option in to be \a range.
+*/
+void QPrinter::setPrintRange( PrintRange range )
+{
+    Q_D(QPrinter);
+    d->printRange = QAbstractPrintDialog::PrintRange(range);
+}
+
+/*!
+    \since 4.1
+
+    Returns the page range of the QPrinter. After the print setup
+    dialog has been opened, this function returns the value selected
+    by the user.
+
+    \sa setPrintRange()
+*/
+QPrinter::PrintRange QPrinter::printRange() const
+{
+    Q_D(const QPrinter);
+    return PrintRange(d->printRange);
+}
+
+#if defined(QT3_SUPPORT)
+
+void QPrinter::setOutputToFile(bool f)
+{
+    if (f) {
+        if (outputFileName().isEmpty())
+            setOutputFileName(QLatin1String("untitled_printer_document"));
+    } else {
+        setOutputFileName(QString());
+    }
+}
+
+bool qt_compat_QPrinter_printSetup(QPrinter *printer, QPrinterPrivate *pd, QWidget *parent)
+{
+    Q_UNUSED(pd);
+    QPrintDialog dlg(printer, parent);
+    return dlg.exec() != 0;
+}
+
+
+#ifdef Q_WS_MAC
+bool qt_compat_QPrinter_pageSetup(QPrinter *p, QWidget *parent)
+{
+    QPageSetupDialog psd(p, parent);
+    return psd.exec() != 0;
+}
+
+/*!
+    Executes a page setup dialog so that the user can configure the type of
+    page used for printing. Returns true if the contents of the dialog are
+    accepted; returns false if the dialog is canceled.
+*/
+bool QPrinter::pageSetup(QWidget *parent)
+{
+    return qt_compat_QPrinter_pageSetup(this, parent);
+}
+
+/*!
+    Executes a print setup dialog so that the user can configure the printing
+    process. Returns true if the contents of the dialog are accepted; returns
+    false if the dialog is canceled.
+*/
+bool QPrinter::printSetup(QWidget *parent)
+{
+    Q_D(QPrinter);
+    return qt_compat_QPrinter_printSetup(this, d, parent);
+}
+#endif // Q_WS_MAC
+
+/*!
+    Use QPrintDialog instead.
+
+    \oldcode
+        if (printer->setup(parent))
+            ...
+    \newcode
+        QPrintDialog dialog(printer, parent);
+        if (dialog.exec())
+            ...
+    \endcode
+*/
+bool QPrinter::setup(QWidget *parent)
+{
+    Q_D(QPrinter);
+    return qt_compat_QPrinter_printSetup(this, d, parent)
+#ifdef Q_WS_MAC
+        && qt_compat_QPrinter_pageSetup(this, parent);
+#endif
+        ;
+}
+
+/*!
+    Use QPrintDialog::minPage() instead.
+*/
+int QPrinter::minPage() const
+{
+    Q_D(const QPrinter);
+    return d->minPage;
+}
+
+/*!
+    Use QPrintDialog::maxPage() instead.
+*/
+int QPrinter::maxPage() const
+{
+    Q_D(const QPrinter);
+    return d->maxPage;
+}
+
+/*!
+    Use QPrintDialog::setMinMax() instead.
+*/
+void QPrinter::setMinMax( int minPage, int maxPage )
+{
+    Q_D(QPrinter);
+    Q_ASSERT_X(minPage <= maxPage, "QPrinter::setMinMax",
+               "'min' must be less than or equal to 'max'");
+    d->minPage = minPage;
+    d->maxPage = maxPage;
+    d->options |= QPrintDialog::PrintPageRange;
+}
+
+/*!
+    Returns true if the printer is set up to collate copies of printed documents;
+    otherwise returns false.
+
+    Use QPrintDialog::isOptionEnabled(QPrintDialog::PrintCollateCopies)
+    instead.
+
+    \sa collateCopies()
+*/
+bool QPrinter::collateCopiesEnabled() const
+{
+    Q_D(const QPrinter);
+    return (d->options & QPrintDialog::PrintCollateCopies);
+}
+
+/*!
+    Use QPrintDialog::setOption(QPrintDialog::PrintCollateCopies)
+    or QPrintDialog::setOptions(QPrintDialog::options()
+    & ~QPrintDialog::PrintCollateCopies) instead, depending on \a
+    enable.
+*/
+void QPrinter::setCollateCopiesEnabled(bool enable)
+{
+    Q_D(QPrinter);
+
+    if (enable)
+        d->options |= QPrintDialog::PrintCollateCopies;
+    else
+        d->options &= ~QPrintDialog::PrintCollateCopies;
+}
+
+/*!
+    Use QPrintDialog instead.
+*/
+void QPrinter::setOptionEnabled( PrinterOption option, bool enable )
+{
+    Q_D(QPrinter);
+    if (enable)
+        d->options |= QPrintDialog::PrintDialogOption(1 << option);
+    else
+        d->options &= ~QPrintDialog::PrintDialogOption(1 << option);
+}
+
+/*!
+    Use QPrintDialog instead.
+*/
+bool QPrinter::isOptionEnabled( PrinterOption option ) const
+{
+    Q_D(const QPrinter);
+    return (d->options & QPrintDialog::PrintDialogOption(option));
+}
+
+#endif // QT3_SUPPORT
+
+/*!
+    \class QPrintEngine
+    \reentrant
+
+    \ingroup printing
+
+    \brief The QPrintEngine class defines an interface for how QPrinter
+    interacts with a given printing subsystem.
+
+    The common case when creating your own print engine is to derive from both
+    QPaintEngine and QPrintEngine. Various properties of a print engine are
+    given with property() and set with setProperty().
+
+    \sa QPaintEngine
+*/
+
+/*!
+    \enum QPrintEngine::PrintEnginePropertyKey
+
+    This enum is used to communicate properties between the print
+    engine and QPrinter. A property may or may not be supported by a
+    given print engine.
+
+    \value PPK_CollateCopies A boolean value indicating whether the
+    printout should be collated or not.
+
+    \value PPK_ColorMode Refers to QPrinter::ColorMode, either color or
+    monochrome.
+
+    \value PPK_Creator A string describing the document's creator.
+
+    \value PPK_Duplex A boolean value indicating whether both sides of
+    the printer paper should be used for the printout.
+
+    \value PPK_DocumentName A string describing the document name in
+    the spooler.
+
+    \value PPK_FontEmbedding A boolean value indicating whether data for
+    the document's fonts should be embedded in the data sent to the
+    printer.
+
+    \value PPK_FullPage A boolean describing if the printer should be
+    full page or not.
+
+    \value PPK_NumberOfCopies Obsolete. An integer specifying the number of
+    copies. Use PPK_CopyCount instead.
+
+    \value PPK_Orientation Specifies a QPrinter::Orientation value.
+
+    \value PPK_OutputFileName The output file name as a string. An
+    empty file name indicates that the printer should not print to a file.
+
+    \value PPK_PageOrder Specifies a QPrinter::PageOrder value.
+
+    \value PPK_PageRect A QRect specifying the page rectangle
+
+    \value PPK_PageSize Obsolete. Use PPK_PaperSize instead.
+
+    \value PPK_PaperRect A QRect specifying the paper rectangle.
+
+    \value PPK_PaperSource Specifies a QPrinter::PaperSource value.
+
+    \value PPK_PaperSources Specifies more than one QPrinter::PaperSource value.
+
+    \value PPK_PaperSize Specifies a QPrinter::PaperSize value.
+
+    \value PPK_PrinterName A string specifying the name of the printer.
+
+    \value PPK_PrinterProgram A string specifying the name of the
+    printer program used for printing,
+
+    \value PPK_Resolution An integer describing the dots per inch for
+    this printer.
+
+    \value PPK_SelectionOption
+
+    \value PPK_SupportedResolutions A list of integer QVariants
+    describing the set of supported resolutions that the printer has.
+
+    \value PPK_SuppressSystemPrintStatus Suppress the built-in dialog for showing
+    printing progress. As of 4.1 this only has effect on Mac OS X where, by default,
+    a status dialog is shown.
+
+    \value PPK_WindowsPageSize An integer specifying a DM_PAPER entry
+    on Windows.
+
+    \value PPK_CustomPaperSize A QSizeF specifying a custom paper size
+    in the QPrinter::Point unit.
+
+    \value PPK_PageMargins A QList<QVariant> containing the left, top,
+    right and bottom margin values.
+
+    \value PPK_CopyCount An integer specifying the number of copies to print.
+
+    \value PPK_SupportsMultipleCopies A boolean value indicating whether or not
+    the printer supports printing multiple copies in one job.
+
+    \value PPK_CustomBase Basis for extension.
+*/
+
+/*!
+    \fn QPrintEngine::~QPrintEngine()
+
+    Destroys the print engine.
+*/
+
+/*!
+    \fn void QPrintEngine::setProperty(PrintEnginePropertyKey key, const QVariant &value)
+
+    Sets the print engine's property specified by \a key to the given \a value.
+
+    \sa property()
+*/
+
+/*!
+    \fn void QPrintEngine::property(PrintEnginePropertyKey key) const
+
+    Returns the print engine's property specified by \a key.
+
+    \sa setProperty()
+*/
+
+/*!
+    \fn bool QPrintEngine::newPage()
+
+    Instructs the print engine to start a new page. Returns true if
+    the printer was able to create the new page; otherwise returns false.
+*/
+
+/*!
+    \fn bool QPrintEngine::abort()
+
+    Instructs the print engine to abort the printing process. Returns
+    true if successful; otherwise returns false.
+*/
+
+/*!
+    \fn int QPrintEngine::metric(QPaintDevice::PaintDeviceMetric id) const
+
+    Returns the metric for the given \a id.
+*/
+
+/*!
+    \fn QPrinter::PrinterState QPrintEngine::printerState() const
+
+    Returns the current state of the printer being used by the print engine.
+*/
+
+/*!
+    \fn HDC QPrintEngine::getPrinterDC() const
+    \internal
+*/
+
+/*!
+    \fn void QPrintEngine::releasePrinterDC(HDC) const
+    \internal
+*/
+
+/*
+    Returns the dimensions for the given paper size, \a size, in millimeters.
+*/
+QSizeF qt_paperSizeToQSizeF(QPrinter::PaperSize size)
+{
+    if (size == QPrinter::Custom) return QSizeF(0, 0);
+    return QSizeF(qt_paperSizes[size][0], qt_paperSizes[size][1]);
+}
+
+/*
+    Returns the PaperSize type that matches \a size, where \a size
+    is in millimeters.
+
+    Because dimensions may not always be completely accurate (for
+    example when converting between units), a particular PaperSize
+    will be returned if it matches within -1/+1 millimeters.
+*/
+QPrinter::PaperSize qSizeFTopaperSize(const QSizeF& size)
+{
+    for (int i = 0; i < static_cast<int>(QPrinter::NPaperSize); ++i) {
+        if (qt_paperSizes[i][0] >= size.width() - 1 &&
+                qt_paperSizes[i][0] <= size.width() + 1 &&
+                qt_paperSizes[i][1] >= size.height() - 1 &&
+                qt_paperSizes[i][1] <= size.height() + 1) {
+            return QPrinter::PaperSize(i);
+        }
+    }
+
+    return QPrinter::Custom;
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_PRINTER
diff --git a/src/gui/painting/qprinter.h b/src/gui/painting/qprinter.h
new file mode 100644
index 0000000000..6a5d0b7566
--- /dev/null
+++ b/src/gui/painting/qprinter.h
@@ -0,0 +1,337 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPRINTER_H
+#define QPRINTER_H
+
+#include <QtCore/qstring.h>
+#include <QtCore/qscopedpointer.h>
+#include <QtGui/qpaintdevice.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+#ifndef QT_NO_PRINTER
+
+#if defined(B0)
+#undef B0 // Terminal hang-up.  We assume that you do not want that.
+#endif
+
+class QPrinterPrivate;
+class QPaintEngine;
+class QPrintEngine;
+class QPrinterInfo;
+
+class Q_GUI_EXPORT QPrinter : public QPaintDevice
+{
+    Q_DECLARE_PRIVATE(QPrinter)
+public:
+    enum PrinterMode { ScreenResolution, PrinterResolution, HighResolution };
+
+    explicit QPrinter(PrinterMode mode = ScreenResolution);
+    explicit QPrinter(const QPrinterInfo& printer, PrinterMode mode = ScreenResolution);
+    ~QPrinter();
+
+    int devType() const;
+
+    enum Orientation { Portrait, Landscape };
+
+#ifndef Q_QDOC
+    enum PageSize { A4, B5, Letter, Legal, Executive,
+                    A0, A1, A2, A3, A5, A6, A7, A8, A9, B0, B1,
+                    B10, B2, B3, B4, B6, B7, B8, B9, C5E, Comm10E,
+                    DLE, Folio, Ledger, Tabloid, Custom, NPageSize = Custom, NPaperSize = Custom };
+    typedef PageSize PaperSize;
+#else
+    enum PageSize { A4, B5, Letter, Legal, Executive,
+                    A0, A1, A2, A3, A5, A6, A7, A8, A9, B0, B1,
+                    B10, B2, B3, B4, B6, B7, B8, B9, C5E, Comm10E,
+                    DLE, Folio, Ledger, Tabloid, Custom, NPageSize = Custom };
+    enum PaperSize { A4, B5, Letter, Legal, Executive,
+                     A0, A1, A2, A3, A5, A6, A7, A8, A9, B0, B1,
+                     B10, B2, B3, B4, B6, B7, B8, B9, C5E, Comm10E,
+                     DLE, Folio, Ledger, Tabloid, Custom, NPageSize = Custom, NPaperSize = Custom };
+#endif
+
+    enum PageOrder   { FirstPageFirst,
+                       LastPageFirst };
+
+    enum ColorMode   { GrayScale,
+                       Color };
+
+    enum PaperSource { OnlyOne,
+                       Lower,
+                       Middle,
+                       Manual,
+                       Envelope,
+                       EnvelopeManual,
+                       Auto,
+                       Tractor,
+                       SmallFormat,
+                       LargeFormat,
+                       LargeCapacity,
+                       Cassette,
+                       FormSource,
+                       MaxPageSource
+    };
+
+    enum PrinterState { Idle,
+                        Active,
+                        Aborted,
+                        Error };
+
+    enum OutputFormat { NativeFormat, PdfFormat, PostScriptFormat };
+
+    // ### Qt 5: Merge with QAbstractPrintDialog::PrintRange
+    enum PrintRange { AllPages, Selection, PageRange, CurrentPage };
+
+    enum Unit {
+        Millimeter,
+        Point,
+        Inch,
+        Pica,
+        Didot,
+        Cicero,
+        DevicePixel
+    };
+
+    enum DuplexMode {
+        DuplexNone = 0,
+        DuplexAuto,
+        DuplexLongSide,
+        DuplexShortSide
+    };
+
+#ifdef QT3_SUPPORT
+    enum PrinterOption { PrintToFile, PrintSelection, PrintPageRange };
+#endif // QT3_SUPPORT
+
+    void setOutputFormat(OutputFormat format);
+    OutputFormat outputFormat() const;
+
+    void setPrinterName(const QString &);
+    QString printerName() const;
+
+    bool isValid() const;
+
+    void setOutputFileName(const QString &);
+    QString outputFileName()const;
+
+    void setPrintProgram(const QString &);
+    QString printProgram() const;
+
+    void setDocName(const QString &);
+    QString docName() const;
+
+    void setCreator(const QString &);
+    QString creator() const;
+
+    void setOrientation(Orientation);
+    Orientation orientation() const;
+
+    void setPageSize(PageSize);
+    PageSize pageSize() const;
+
+    void setPaperSize(PaperSize);
+    PaperSize paperSize() const;
+
+    void setPaperSize(const QSizeF &paperSize, Unit unit);
+    QSizeF paperSize(Unit unit) const;
+
+    void setPageOrder(PageOrder);
+    PageOrder pageOrder() const;
+
+    void setResolution(int);
+    int resolution() const;
+
+    void setColorMode(ColorMode);
+    ColorMode colorMode() const;
+
+    void setCollateCopies(bool collate);
+    bool collateCopies() const;
+
+    void setFullPage(bool);
+    bool fullPage() const;
+
+    void setNumCopies(int);
+    int numCopies() const;
+
+    int actualNumCopies() const;
+
+    void setCopyCount(int);
+    int copyCount() const;
+    bool supportsMultipleCopies() const;
+
+    void setPaperSource(PaperSource);
+    PaperSource paperSource() const;
+
+    void setDuplex(DuplexMode duplex);
+    DuplexMode duplex() const;
+
+    QList<int> supportedResolutions() const;
+
+#ifdef Q_WS_WIN
+    QList<PaperSource> supportedPaperSources() const;
+#endif
+
+    void setFontEmbeddingEnabled(bool enable);
+    bool fontEmbeddingEnabled() const;
+
+    void setDoubleSidedPrinting(bool enable);
+    bool doubleSidedPrinting() const;
+
+#ifdef Q_WS_WIN
+    void setWinPageSize(int winPageSize);
+    int winPageSize() const;
+#endif
+
+    QRect paperRect() const;
+    QRect pageRect() const;
+    QRectF paperRect(Unit) const;
+    QRectF pageRect(Unit) const;
+
+#if !defined(Q_WS_WIN) || defined(qdoc)
+    QString printerSelectionOption() const;
+    void setPrinterSelectionOption(const QString &);
+#endif
+
+    bool newPage();
+    bool abort();
+
+    PrinterState printerState() const;
+
+    QPaintEngine *paintEngine() const;
+    QPrintEngine *printEngine() const;
+
+#ifdef Q_WS_WIN
+    HDC getDC() const;
+    void releaseDC(HDC hdc) const;
+#endif
+
+    void setFromTo(int fromPage, int toPage);
+    int fromPage() const;
+    int toPage() const;
+
+    void setPrintRange(PrintRange range);
+    PrintRange printRange() const;
+
+    void setPageMargins(qreal left, qreal top, qreal right, qreal bottom, Unit unit);
+    void getPageMargins(qreal *left, qreal *top, qreal *right, qreal *bottom, Unit unit) const;
+
+#ifdef QT3_SUPPORT
+#ifdef Q_WS_MAC
+    QT3_SUPPORT bool pageSetup(QWidget *parent = 0);
+    QT3_SUPPORT bool printSetup(QWidget *parent = 0);
+#endif
+
+    QT3_SUPPORT bool setup(QWidget *parent = 0);
+
+    QT3_SUPPORT void setMinMax(int minPage, int maxPage);
+    QT3_SUPPORT int minPage() const;
+    QT3_SUPPORT int maxPage() const;
+
+    QT3_SUPPORT void setCollateCopiesEnabled(bool);
+    QT3_SUPPORT bool collateCopiesEnabled() const;
+
+    QT3_SUPPORT void setOptionEnabled(PrinterOption, bool enable);
+    QT3_SUPPORT bool isOptionEnabled(PrinterOption) const;
+
+    inline QT3_SUPPORT QSize margins() const;
+    inline QT3_SUPPORT void margins(uint *top, uint *left, uint *bottom, uint *right) const;
+
+    inline QT3_SUPPORT bool aborted() { return printerState() == Aborted; }
+
+    QT3_SUPPORT void setOutputToFile(bool);
+    inline QT3_SUPPORT bool outputToFile() const { return !outputFileName().isEmpty(); }
+#endif
+
+protected:
+    int metric(PaintDeviceMetric) const;
+    void setEngines(QPrintEngine *printEngine, QPaintEngine *paintEngine);
+
+private:
+    void init(PrinterMode mode);
+
+    Q_DISABLE_COPY(QPrinter)
+
+    QScopedPointer<QPrinterPrivate> d_ptr;
+
+    friend class QPrintDialogPrivate;
+    friend class QAbstractPrintDialog;
+    friend class QAbstractPrintDialogPrivate;
+    friend class QPrintPreviewWidgetPrivate;
+    friend class QTextDocument;
+    friend class QPageSetupWidget;
+};
+
+#ifdef QT3_SUPPORT
+inline QSize QPrinter::margins() const
+{
+    QRect page = pageRect();
+    QRect paper = paperRect();
+    return QSize(page.left() - paper.left(), page.top() - paper.top());
+}
+
+inline void QPrinter::margins(uint *top, uint *left, uint *bottom, uint *right) const
+{
+    QRect page = pageRect();
+    QRect paper = paperRect();
+    if (top)
+        *top = page.top() - paper.top();
+    if (left)
+        *left = page.left() - paper.left();
+    if (bottom)
+        *bottom = paper.bottom() - page.bottom();
+    if (right)
+        *right = paper.right() - page.right();
+}
+#endif
+
+#endif // QT_NO_PRINTER
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QPRINTER_H
diff --git a/src/gui/painting/qprinter_p.h b/src/gui/painting/qprinter_p.h
new file mode 100644
index 0000000000..556f0f06c2
--- /dev/null
+++ b/src/gui/painting/qprinter_p.h
@@ -0,0 +1,140 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPRINTER_P_H
+#define QPRINTER_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+
+#include "QtCore/qglobal.h"
+
+#ifndef QT_NO_PRINTER
+
+#include "QtGui/qprinter.h"
+#include "QtGui/qprintengine.h"
+#include "QtGui/qprintdialog.h"
+#include "QtCore/qpointer.h"
+
+#include <limits.h>
+
+QT_BEGIN_NAMESPACE
+
+class QPrintEngine;
+class QPreviewPaintEngine;
+class QPicture;
+
+class QPrinterPrivate
+{
+    Q_DECLARE_PUBLIC(QPrinter)
+public:
+    QPrinterPrivate(QPrinter *printer)
+        : printEngine(0)
+        , paintEngine(0)
+        , q_ptr(printer)
+        , options(QAbstractPrintDialog::PrintToFile | QAbstractPrintDialog::PrintPageRange |
+                QAbstractPrintDialog::PrintCollateCopies | QAbstractPrintDialog::PrintShowPageSize)
+        , printRange(QAbstractPrintDialog::AllPages)
+        , minPage(1)
+        , maxPage(INT_MAX)
+        , fromPage(0)
+        , toPage(0)
+        , use_default_engine(true)
+        , validPrinter(false)
+        , hasCustomPageMargins(false)
+        , hasUserSetPageSize(false)
+    {
+    }
+
+    ~QPrinterPrivate() {
+
+    }
+
+    void createDefaultEngines();
+#ifndef QT_NO_PRINTPREVIEWWIDGET
+    QList<const QPicture *> previewPages() const;
+    void setPreviewMode(bool);
+#endif
+
+    void addToManualSetList(QPrintEngine::PrintEnginePropertyKey key);
+
+    QPrinter::PrinterMode printerMode;
+    QPrinter::OutputFormat outputFormat;
+    QPrintEngine *printEngine;
+    QPaintEngine *paintEngine;
+
+    QPrintEngine *realPrintEngine;
+    QPaintEngine *realPaintEngine;
+#ifndef QT_NO_PRINTPREVIEWWIDGET
+    QPreviewPaintEngine *previewEngine;
+#endif
+
+    QPrinter *q_ptr;
+
+    QAbstractPrintDialog::PrintDialogOptions options;
+    QAbstractPrintDialog::PrintRange printRange;
+    int minPage, maxPage, fromPage, toPage;
+
+    uint use_default_engine : 1;
+    uint had_default_engines : 1;
+
+    uint validPrinter : 1;
+    uint hasCustomPageMargins : 1;
+    uint hasUserSetPageSize : 1;
+
+    // Used to remember which properties have been manually set by the user.
+    QList<QPrintEngine::PrintEnginePropertyKey> manualSetList;
+};
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_PRINTER
+
+#endif // QPRINTER_P_H
diff --git a/src/gui/painting/qprinterinfo.cpp b/src/gui/painting/qprinterinfo.cpp
new file mode 100644
index 0000000000..f680ce1950
--- /dev/null
+++ b/src/gui/painting/qprinterinfo.cpp
@@ -0,0 +1,173 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Free Documentation License
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of this
+** file.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qprinterinfo.h"
+#include "qprinterinfo_p.h"
+
+#ifndef QT_NO_PRINTER
+
+QT_BEGIN_NAMESPACE
+
+QPrinterInfoPrivate QPrinterInfoPrivate::shared_null;
+
+
+/*!
+    \class QPrinterInfo
+
+    \brief The QPrinterInfo class gives access to information about
+    existing printers.
+    
+    \ingroup printing
+
+    Use the static functions to generate a list of QPrinterInfo
+    objects. Each QPrinterInfo object in the list represents a single
+    printer and can be queried for name, supported paper sizes, and
+    whether or not it is the default printer.
+
+    \since 4.4
+*/
+
+/*!
+    \fn QList<QPrinterInfo> QPrinterInfo::availablePrinters()
+
+    Returns a list of available printers on the system.
+*/
+
+/*!
+    \fn QPrinterInfo QPrinterInfo::defaultPrinter()
+
+    Returns the default printer on the system.
+
+    The return value should be checked using isNull() before being
+    used, in case there is no default printer.
+
+    \sa isNull()
+*/
+
+/*!
+    Constructs an empty QPrinterInfo object.
+
+    \sa isNull()
+*/
+QPrinterInfo::QPrinterInfo()
+    : d_ptr(&QPrinterInfoPrivate::shared_null)
+{
+}
+
+/*!
+    Constructs a copy of \a other.
+*/
+QPrinterInfo::QPrinterInfo(const QPrinterInfo &other)
+    : d_ptr(new QPrinterInfoPrivate(*other.d_ptr))
+{
+}
+
+/*!
+    Constructs a QPrinterInfo object from \a printer.
+*/
+QPrinterInfo::QPrinterInfo(const QPrinter &printer)
+    : d_ptr(&QPrinterInfoPrivate::shared_null)
+{
+    foreach (const QPrinterInfo &printerInfo, availablePrinters()) {
+        if (printerInfo.printerName() == printer.printerName()) {
+            d_ptr.reset(new QPrinterInfoPrivate(*printerInfo.d_ptr));
+            break;
+        }
+    }
+}
+
+/*!
+    \internal
+*/
+QPrinterInfo::QPrinterInfo(const QString &name)
+    : d_ptr(new QPrinterInfoPrivate(name))
+{
+}
+
+/*!
+    Destroys the QPrinterInfo object. References to the values in the
+    object become invalid.
+*/
+QPrinterInfo::~QPrinterInfo()
+{
+}
+
+/*!
+    Sets the QPrinterInfo object to be equal to \a other.
+*/
+QPrinterInfo &QPrinterInfo::operator=(const QPrinterInfo &other)
+{
+    Q_ASSERT(d_ptr);
+    d_ptr.reset(new QPrinterInfoPrivate(*other.d_ptr));
+    return *this;
+}
+
+/*!
+    Returns the name of the printer.
+
+    \sa QPrinter::setPrinterName()
+*/
+QString QPrinterInfo::printerName() const
+{
+    const Q_D(QPrinterInfo);
+    return d->name;
+}
+
+/*!
+    Returns whether this QPrinterInfo object holds a printer definition.
+
+    An empty QPrinterInfo object could result for example from calling
+    defaultPrinter() when there are no printers on the system.
+*/
+bool QPrinterInfo::isNull() const
+{
+    const Q_D(QPrinterInfo);
+    return d == &QPrinterInfoPrivate::shared_null;
+}
+
+/*!
+    Returns whether this printer is the default printer.
+*/
+bool QPrinterInfo::isDefault() const
+{
+    const Q_D(QPrinterInfo);
+    return d->isDefault;
+}
+
+/*!
+    \fn QList< QPrinter::PaperSize> QPrinterInfo::supportedPaperSizes() const
+    \since 4.4
+
+    Returns a list of supported paper sizes by the printer.
+
+    Not all printer drivers support this query, so the list may be empty.
+    On Mac OS X 10.3, this function always returns an empty list.
+*/
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_PRINTER
diff --git a/src/gui/painting/qprinterinfo.h b/src/gui/painting/qprinterinfo.h
new file mode 100644
index 0000000000..34379613de
--- /dev/null
+++ b/src/gui/painting/qprinterinfo.h
@@ -0,0 +1,90 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPRINTERINFO_H
+#define QPRINTERINFO_H
+
+#include <QtCore/QList>
+
+#include <QtGui/QPrinter>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+#ifndef QT_NO_PRINTER
+class QPrinterInfoPrivate;
+class QPrinterInfoPrivateDeleter;
+class Q_GUI_EXPORT QPrinterInfo
+{
+public:
+    QPrinterInfo();
+    QPrinterInfo(const QPrinterInfo &other);
+    QPrinterInfo(const QPrinter &printer);
+    ~QPrinterInfo();
+
+    QPrinterInfo &operator=(const QPrinterInfo &other);
+
+    QString printerName() const;
+    bool isNull() const;
+    bool isDefault() const;
+    QList<QPrinter::PaperSize> supportedPaperSizes() const;
+
+    static QList<QPrinterInfo> availablePrinters();
+    static QPrinterInfo defaultPrinter();
+
+private:
+    QPrinterInfo(const QString &name);
+
+private:
+    Q_DECLARE_PRIVATE(QPrinterInfo)
+    QScopedPointer<QPrinterInfoPrivate, QPrinterInfoPrivateDeleter> d_ptr;
+};
+
+#endif // QT_NO_PRINTER
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QPRINTERINFO_H
diff --git a/src/gui/painting/qprinterinfo_mac.cpp b/src/gui/painting/qprinterinfo_mac.cpp
new file mode 100644
index 0000000000..b24ab70267
--- /dev/null
+++ b/src/gui/painting/qprinterinfo_mac.cpp
@@ -0,0 +1,120 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qprinterinfo.h"
+#include "qprinterinfo_p.h"
+
+#include "private/qt_mac_p.h"
+
+QT_BEGIN_NAMESPACE
+
+#ifndef QT_NO_PRINTER
+
+extern QPrinter::PaperSize qSizeFTopaperSize(const QSizeF &size);
+
+QList<QPrinterInfo> QPrinterInfo::availablePrinters()
+{
+    QList<QPrinterInfo> printers;
+
+    QCFType<CFArrayRef> array;
+    if (PMServerCreatePrinterList(kPMServerLocal, &array) == noErr) {
+        CFIndex count = CFArrayGetCount(array);
+        for (int i = 0; i < count; ++i) {
+            PMPrinter printer = static_cast<PMPrinter>(const_cast<void *>(CFArrayGetValueAtIndex(array, i)));
+            QString printerName = QCFString::toQString(PMPrinterGetName(printer));
+
+            QPrinterInfo printerInfo(printerName);
+            if (PMPrinterIsDefault(printer))
+                printerInfo.d_ptr->isDefault = true;
+            printers.append(printerInfo);
+        }
+    }
+
+    return printers;
+}
+
+QPrinterInfo QPrinterInfo::defaultPrinter()
+{
+    QList<QPrinterInfo> printers = availablePrinters();
+    foreach (const QPrinterInfo &printerInfo, printers) {
+        if (printerInfo.isDefault())
+            return printerInfo;
+    }
+
+    return printers.value(0);
+}
+
+QList<QPrinter::PaperSize> QPrinterInfo::supportedPaperSizes() const
+{
+    const Q_D(QPrinterInfo);
+
+    QList<QPrinter::PaperSize> paperSizes;
+    if (isNull())
+        return paperSizes;
+
+    PMPrinter cfPrn = PMPrinterCreateFromPrinterID(QCFString::toCFStringRef(d->name));
+    if (!cfPrn)
+        return paperSizes;
+
+    CFArrayRef array;
+    if (PMPrinterGetPaperList(cfPrn, &array) != noErr) {
+        PMRelease(cfPrn);
+        return paperSizes;
+    }
+
+    int count = CFArrayGetCount(array);
+    for (int i = 0; i < count; ++i) {
+        PMPaper paper = static_cast<PMPaper>(const_cast<void *>(CFArrayGetValueAtIndex(array, i)));
+        double width, height;
+        if (PMPaperGetWidth(paper, &width) == noErr && PMPaperGetHeight(paper, &height) == noErr) {
+            QSizeF size(width * 0.3527, height * 0.3527);
+            paperSizes.append(qSizeFTopaperSize(size));
+        }
+    }
+
+    PMRelease(cfPrn);
+
+    return paperSizes;
+}
+
+#endif // QT_NO_PRINTER
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qprinterinfo_p.h b/src/gui/painting/qprinterinfo_p.h
new file mode 100644
index 0000000000..fcc1acb5d6
--- /dev/null
+++ b/src/gui/painting/qprinterinfo_p.h
@@ -0,0 +1,107 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPRINTERINFO_P_H
+#define QPRINTERINFO_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "QtCore/qglobal.h"
+
+#ifndef QT_NO_PRINTER
+
+#include "QtCore/qlist.h"
+
+QT_BEGIN_NAMESPACE
+
+class QPrinterInfoPrivate
+{
+public:
+    QPrinterInfoPrivate(const QString& name = QString()) :
+        name(name), isDefault(false)
+#if (defined(Q_OS_UNIX) && !defined(Q_OS_MAC) && !defined(Q_OS_SYMBIAN)) || defined(Q_WS_QPA)
+#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
+        , cupsPrinterIndex(0), hasPaperSizes(false)
+#endif
+#endif
+    {}
+    ~QPrinterInfoPrivate()
+    {}
+
+    static QPrinterInfoPrivate shared_null;
+
+    QString name;
+    bool isDefault;
+
+#if (defined(Q_OS_UNIX) && !defined(Q_OS_MAC) && !defined(Q_OS_SYMBIAN)) || defined(Q_WS_QPA)
+#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
+    int cupsPrinterIndex;
+    mutable bool hasPaperSizes;
+    mutable QList<QPrinter::PaperSize> paperSizes;
+#endif
+#endif
+};
+
+
+class QPrinterInfoPrivateDeleter
+{
+public:
+    static inline void cleanup(QPrinterInfoPrivate *d)
+    {
+        if (d != &QPrinterInfoPrivate::shared_null)
+            delete d;
+    }
+};
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_PRINTER
+
+#endif // QPRINTERINFO_P_H
diff --git a/src/gui/painting/qprinterinfo_unix.cpp b/src/gui/painting/qprinterinfo_unix.cpp
new file mode 100644
index 0000000000..38e9590b1d
--- /dev/null
+++ b/src/gui/painting/qprinterinfo_unix.cpp
@@ -0,0 +1,927 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qprinterinfo.h"
+#include "qprinterinfo_p.h"
+
+#include <qfile.h>
+#include <qfileinfo.h>
+#include <qdir.h>
+#include <qprintdialog.h>
+#include <qlibrary.h>
+#include <qtextstream.h>
+
+#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
+#  include <private/qcups_p.h>
+#  include <cups/cups.h>
+#  include <private/qpdf_p.h>
+#endif
+
+#include <private/qprinterinfo_unix_p.h>
+
+QT_BEGIN_NAMESPACE
+
+#ifndef QT_NO_PRINTER
+
+#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
+// preserver names in ascending order for the binary search
+static const struct NamedPaperSize {
+    const char *const name;
+    QPrinter::PaperSize size;
+} named_sizes_map[QPrinter::NPageSize] = {
+    { "A0", QPrinter::A0 },
+    { "A1", QPrinter::A1 },
+    { "A2", QPrinter::A2 },
+    { "A3", QPrinter::A3 },
+    { "A4", QPrinter::A4 },
+    { "A5", QPrinter::A5 },
+    { "A6", QPrinter::A6 },
+    { "A7", QPrinter::A7 },
+    { "A8", QPrinter::A8 },
+    { "A9", QPrinter::A9 },
+    { "B0", QPrinter::B0 },
+    { "B1", QPrinter::B1 },
+    { "B10", QPrinter::B10 },
+    { "B2", QPrinter::B2 },
+    { "B4", QPrinter::B4 },
+    { "B5", QPrinter::B5 },
+    { "B6", QPrinter::B6 },
+    { "B7", QPrinter::B7 },
+    { "B8", QPrinter::B8 },
+    { "B9", QPrinter::B9 },
+    { "C5E", QPrinter::C5E },
+    { "Comm10E", QPrinter::Comm10E },
+    { "Custom", QPrinter::Custom },
+    { "DLE", QPrinter::DLE },
+    { "Executive", QPrinter::Executive },
+    { "Folio", QPrinter::Folio },
+    { "Ledger", QPrinter::Ledger },
+    { "Legal", QPrinter::Legal },
+    { "Letter", QPrinter::Letter },
+    { "Tabloid", QPrinter::Tabloid }
+};
+
+inline bool operator<(const char *name, const NamedPaperSize &data)
+{ return qstrcmp(name, data.name) < 0; }
+inline bool operator<(const NamedPaperSize &data, const char *name)
+{ return qstrcmp(data.name, name) < 0; }
+
+static inline QPrinter::PaperSize string2PaperSize(const char *name)
+{
+    const NamedPaperSize *r = qBinaryFind(named_sizes_map, named_sizes_map + QPrinter::NPageSize, name);
+    if (r - named_sizes_map != QPrinter::NPageSize)
+        return r->size;
+    return QPrinter::Custom;
+}
+
+static inline const char *paperSize2String(QPrinter::PaperSize size)
+{
+    for (int i = 0; i < QPrinter::NPageSize; ++i) {
+        if (size == named_sizes_map[i].size)
+            return named_sizes_map[i].name;
+    }
+    return 0;
+}
+#endif
+
+void qt_perhapsAddPrinter(QList<QPrinterDescription> *printers, const QString &name,
+                               QString host, QString comment,
+                               QStringList aliases)
+{
+    for (int i = 0; i < printers->size(); ++i)
+        if (printers->at(i).samePrinter(name))
+            return;
+
+#ifndef QT_NO_PRINTDIALOG
+    if (host.isEmpty())
+        host = QPrintDialog::tr("locally connected");
+#endif
+    printers->append(QPrinterDescription(name.simplified(), host.simplified(), comment.simplified(), aliases));
+}
+
+void qt_parsePrinterDesc(QString printerDesc, QList<QPrinterDescription> *printers)
+{
+    if (printerDesc.length() < 1)
+        return;
+
+    printerDesc = printerDesc.simplified();
+    int i = printerDesc.indexOf(QLatin1Char(':'));
+    QString printerName, printerComment, printerHost;
+    QStringList aliases;
+
+    if (i >= 0) {
+        // have ':' want '|'
+        int j = printerDesc.indexOf(QLatin1Char('|'));
+        if (j > 0 && j < i) {
+            printerName = printerDesc.left(j);
+            aliases = printerDesc.mid(j + 1, i - j - 1).split(QLatin1Char('|'));
+#ifndef QT_NO_PRINTDIALOG
+            // try extracting a comment from the aliases
+            printerComment = QPrintDialog::tr("Aliases: %1")
+                             .arg(aliases.join(QLatin1String(", ")));
+#endif
+        } else {
+            printerName = printerDesc.left(i);
+        }
+        // look for lprng pseudo all printers entry
+        i = printerDesc.indexOf(QRegExp(QLatin1String(": *all *=")));
+        if (i >= 0)
+            printerName = QString();
+        // look for signs of this being a remote printer
+        i = printerDesc.indexOf(QRegExp(QLatin1String(": *rm *=")));
+        if (i >= 0) {
+            // point k at the end of remote host name
+            while (printerDesc[i] != QLatin1Char('='))
+                i++;
+            while (printerDesc[i] == QLatin1Char('=') || printerDesc[i].isSpace())
+                i++;
+            j = i;
+            while (j < (int)printerDesc.length() && printerDesc[j] != QLatin1Char(':'))
+                j++;
+
+            // and stuff that into the string
+            printerHost = printerDesc.mid(i, j - i);
+        }
+    }
+    if (printerName.length())
+        qt_perhapsAddPrinter(printers, printerName, printerHost, printerComment,
+                             aliases);
+}
+
+int qt_parsePrintcap(QList<QPrinterDescription> *printers, const QString& fileName)
+{
+    QFile printcap(fileName);
+    if (!printcap.open(QIODevice::ReadOnly))
+        return NotFound;
+
+    char *line_ascii = new char[1025];
+    line_ascii[1024] = '\0';
+
+    QString printerDesc;
+    bool atEnd = false;
+
+    while (!atEnd) {
+        if (printcap.atEnd() || printcap.readLine(line_ascii, 1024) <= 0)
+            atEnd = true;
+        QString line = QString::fromLocal8Bit(line_ascii);
+        line = line.trimmed();
+        if (line.length() >= 1 && line[int(line.length()) - 1] == QLatin1Char('\\'))
+            line.chop(1);
+        if (line[0] == QLatin1Char('#')) {
+            if (!atEnd)
+                continue;
+        } else if (line[0] == QLatin1Char('|') || line[0] == QLatin1Char(':')
+                || line.isEmpty()) {
+            printerDesc += line;
+            if (!atEnd)
+                continue;
+        }
+
+        qt_parsePrinterDesc(printerDesc, printers);
+
+        // add the first line of the new printer definition
+        printerDesc = line;
+    }
+    delete[] line_ascii;
+    return Success;
+}
+
+/*!
+  \internal
+
+  Checks $HOME/.printers for a line matching '_default <name>' (where
+  <name> does not contain any white space). The first such match
+  results in <name> being returned.
+  If no lines match then an empty string is returned.
+*/
+QString qt_getDefaultFromHomePrinters()
+{
+    QFile file(QDir::homePath() + QLatin1String("/.printers"));
+    if (!file.open(QIODevice::ReadOnly))
+        return QString();
+    QString all(QLatin1String(file.readAll()));
+    QStringList words = all.split(QRegExp(QLatin1String("\\W+")), QString::SkipEmptyParts);
+    const int i = words.indexOf(QLatin1String("_default"));
+    if (i != -1 && i < words.size() - 1)
+        return words.at(i + 1);
+    return QString();
+}
+
+// solaris, not 2.6
+void qt_parseEtcLpPrinters(QList<QPrinterDescription> *printers)
+{
+    QDir lp(QLatin1String("/etc/lp/printers"));
+    QFileInfoList dirs = lp.entryInfoList();
+    if (dirs.isEmpty())
+        return;
+
+    QString tmp;
+    for (int i = 0; i < dirs.size(); ++i) {
+        QFileInfo printer = dirs.at(i);
+        if (printer.isDir()) {
+            tmp.sprintf("/etc/lp/printers/%s/configuration",
+                         printer.fileName().toAscii().data());
+            QFile configuration(tmp);
+            char *line = new char[1025];
+            QString remote(QLatin1String("Remote:"));
+            QString contentType(QLatin1String("Content types:"));
+            QString printerHost;
+            bool canPrintPostscript = false;
+            if (configuration.open(QIODevice::ReadOnly)) {
+                while (!configuration.atEnd() &&
+                        configuration.readLine(line, 1024) > 0) {
+                    if (QString::fromLatin1(line).startsWith(remote)) {
+                        const char *p = line;
+                        while (*p != ':')
+                            p++;
+                        p++;
+                        while (isspace((uchar) *p))
+                            p++;
+                        printerHost = QString::fromLocal8Bit(p);
+                        printerHost = printerHost.simplified();
+                    } else if (QString::fromLatin1(line).startsWith(contentType)) {
+                        char *p = line;
+                        while (*p != ':')
+                            p++;
+                        p++;
+                        char *e;
+                        while (*p) {
+                            while (isspace((uchar) *p))
+                                p++;
+                            if (*p) {
+                                char s;
+                                e = p;
+                                while (isalnum((uchar) *e))
+                                    e++;
+                                s = *e;
+                                *e = '\0';
+                                if (!qstrcmp(p, "postscript") ||
+                                     !qstrcmp(p, "any"))
+                                    canPrintPostscript = true;
+                                *e = s;
+                                if (s == ',')
+                                    e++;
+                                p = e;
+                            }
+                        }
+                    }
+                }
+                if (canPrintPostscript)
+                    qt_perhapsAddPrinter(printers, printer.fileName(),
+                                         printerHost, QLatin1String(""));
+            }
+            delete[] line;
+        }
+    }
+}
+
+// solaris 2.6
+char *qt_parsePrintersConf(QList<QPrinterDescription> *printers, bool *found)
+{
+    QFile pc(QLatin1String("/etc/printers.conf"));
+    if (!pc.open(QIODevice::ReadOnly)) {
+        if (found)
+            *found = false;
+        return 0;
+    }
+    if (found)
+        *found = true;
+
+    char *line = new char[1025];
+    line[1024] = '\0';
+
+    QString printerDesc;
+    int lineLength = 0;
+
+    char *defaultPrinter = 0;
+
+    while (!pc.atEnd() &&
+            (lineLength=pc.readLine(line, 1024)) > 0) {
+        if (*line == '#') {
+            *line = '\0';
+            lineLength = 0;
+        }
+        if (lineLength >= 2 && line[lineLength-2] == '\\') {
+            line[lineLength-2] = '\0';
+            printerDesc += QString::fromLocal8Bit(line);
+        } else {
+            printerDesc += QString::fromLocal8Bit(line);
+            printerDesc = printerDesc.simplified();
+            int i = printerDesc.indexOf(QLatin1Char(':'));
+            QString printerName, printerHost, printerComment;
+            QStringList aliases;
+            if (i >= 0) {
+                // have : want |
+                int j = printerDesc.indexOf(QLatin1Char('|'));
+                if (j >= i)
+                    j = -1;
+                printerName = printerDesc.mid(0, j < 0 ? i : j);
+                if (printerName == QLatin1String("_default")) {
+                    i = printerDesc.indexOf(
+                        QRegExp(QLatin1String(": *use *=")));
+                    while (printerDesc[i] != QLatin1Char('='))
+                        i++;
+                    while (printerDesc[i] == QLatin1Char('=') || printerDesc[i].isSpace())
+                        i++;
+                    j = i;
+                    while (j < (int)printerDesc.length() &&
+                            printerDesc[j] != QLatin1Char(':') && printerDesc[j] != QLatin1Char(','))
+                        j++;
+                    // that's our default printer
+                    defaultPrinter =
+                        qstrdup(printerDesc.mid(i, j-i).toAscii().data());
+                    printerName = QString();
+                    printerDesc = QString();
+                } else if (printerName == QLatin1String("_all")) {
+                    // skip it.. any other cases we want to skip?
+                    printerName = QString();
+                    printerDesc = QString();
+                }
+
+                if (j > 0) {
+                    // try extracting a comment from the aliases
+                    aliases = printerDesc.mid(j + 1, i - j - 1).split(QLatin1Char('|'));
+#ifndef QT_NO_PRINTDIALOG
+                    printerComment = QPrintDialog::tr("Aliases: %1")
+                                     .arg(aliases.join(QLatin1String(", ")));
+#endif
+                }
+                // look for signs of this being a remote printer
+                i = printerDesc.indexOf(
+                    QRegExp(QLatin1String(": *bsdaddr *=")));
+                if (i >= 0) {
+                    // point k at the end of remote host name
+                    while (printerDesc[i] != QLatin1Char('='))
+                        i++;
+                    while (printerDesc[i] == QLatin1Char('=') || printerDesc[i].isSpace())
+                        i++;
+                    j = i;
+                    while (j < (int)printerDesc.length() &&
+                            printerDesc[j] != QLatin1Char(':') && printerDesc[j] != QLatin1Char(','))
+                        j++;
+                    // and stuff that into the string
+                    printerHost = printerDesc.mid(i, j-i);
+                    // maybe stick the remote printer name into the comment
+                    if (printerDesc[j] == QLatin1Char(',')) {
+                        i = ++j;
+                        while (printerDesc[i].isSpace())
+                            i++;
+                        j = i;
+                        while (j < (int)printerDesc.length() &&
+                                printerDesc[j] != QLatin1Char(':') && printerDesc[j] != QLatin1Char(','))
+                            j++;
+                        if (printerName != printerDesc.mid(i, j-i)) {
+                            printerComment =
+                                QLatin1String("Remote name: ");
+                            printerComment += printerDesc.mid(i, j-i);
+                        }
+                    }
+                }
+            }
+            if (printerComment == QLatin1String(":"))
+                printerComment = QString(); // for cups
+            if (printerName.length())
+                qt_perhapsAddPrinter(printers, printerName, printerHost,
+                                     printerComment, aliases);
+            // chop away the line, for processing the next one
+            printerDesc = QString();
+        }
+    }
+    delete[] line;
+    return defaultPrinter;
+}
+
+#ifndef QT_NO_NIS
+
+#if defined(Q_C_CALLBACKS)
+extern "C" {
+#endif
+
+int qt_pd_foreach(int /*status */, char * /*key */, int /*keyLen */,
+                    char *val, int valLen, char *data)
+{
+    qt_parsePrinterDesc(QString::fromLatin1(val, valLen), (QList<QPrinterDescription> *)data);
+    return 0;
+}
+
+#if defined(Q_C_CALLBACKS)
+}
+#endif
+
+int qt_retrieveNisPrinters(QList<QPrinterDescription> *printers)
+{
+#ifndef QT_NO_LIBRARY
+    typedef int (*WildCast)(int, char *, int, char *, int, char *);
+    char printersConfByname[] = "printers.conf.byname";
+    char *domain;
+    int err;
+
+    QLibrary lib(QLatin1String("nsl"));
+    typedef int (*ypGetDefaultDomain)(char **);
+    ypGetDefaultDomain _ypGetDefaultDomain = (ypGetDefaultDomain)lib.resolve("yp_get_default_domain");
+    typedef int (*ypAll)(const char *, const char *, const struct ypall_callback *);
+    ypAll _ypAll = (ypAll)lib.resolve("yp_all");
+
+    if (_ypGetDefaultDomain && _ypAll) {
+        err = _ypGetDefaultDomain(&domain);
+        if (err == 0) {
+            ypall_callback cb;
+            // wild cast to support K&R-style system headers
+            (WildCast &) cb.foreach = (WildCast) qt_pd_foreach;
+            cb.data = (char *) printers;
+            err = _ypAll(domain, printersConfByname, &cb);
+        }
+        if (!err)
+            return Success;
+    }
+#endif //QT_NO_LIBRARY
+    return Unavail;
+}
+
+#endif // QT_NO_NIS
+
+char *qt_parseNsswitchPrintersEntry(QList<QPrinterDescription> *printers, char *line)
+{
+#define skipSpaces() \
+    while (line[k] != '\0' && isspace((uchar) line[k])) \
+        k++
+
+    char *defaultPrinter = 0;
+    bool stop = false;
+    int lastStatus = NotFound;
+
+    int k = 8;
+    skipSpaces();
+    if (line[k] != ':')
+        return 0;
+    k++;
+
+    char *cp = strchr(line, '#');
+    if (cp != 0)
+        *cp = '\0';
+
+    while (line[k] != '\0') {
+        if (isspace((uchar) line[k])) {
+            k++;
+        } else if (line[k] == '[') {
+            k++;
+            skipSpaces();
+            while (line[k] != '\0') {
+                char status = tolower(line[k]);
+                char action = '?';
+
+                while (line[k] != '=' && line[k] != ']' && line[k] != '\0')
+                    k++;
+                if (line[k] == '=') {
+                    k++;
+                    skipSpaces();
+                    action = tolower(line[k]);
+                    while (line[k] != '\0' && !isspace((uchar) line[k]) && line[k] != ']')
+                        k++;
+                } else if (line[k] == ']') {
+                    k++;
+                    break;
+                }
+                skipSpaces();
+
+                if (lastStatus == status)
+                    stop = (action == (char) Return);
+            }
+        } else {
+            if (stop)
+                break;
+
+            QByteArray source;
+            while (line[k] != '\0' && !isspace((uchar) line[k]) && line[k] != '[') {
+                source += line[k];
+                k++;
+            }
+
+            if (source == "user") {
+                lastStatus = qt_parsePrintcap(printers,
+                        QDir::homePath() + QLatin1String("/.printers"));
+            } else if (source == "files") {
+                bool found;
+                defaultPrinter = qt_parsePrintersConf(printers, &found);
+                if (found)
+                    lastStatus = Success;
+#ifndef QT_NO_NIS
+            } else if (source == "nis") {
+                lastStatus = qt_retrieveNisPrinters(printers);
+#endif
+            } else {
+                // nisplus, dns, etc., are not implemented yet
+                lastStatus = NotFound;
+            }
+            stop = (lastStatus == Success);
+        }
+    }
+    return defaultPrinter;
+}
+
+char *qt_parseNsswitchConf(QList<QPrinterDescription> *printers)
+{
+    QFile nc(QLatin1String("/etc/nsswitch.conf"));
+    if (!nc.open(QIODevice::ReadOnly))
+        return 0;
+
+    char *defaultPrinter = 0;
+
+    char *line = new char[1025];
+    line[1024] = '\0';
+
+    while (!nc.atEnd() &&
+            nc.readLine(line, 1024) > 0) {
+        if (qstrncmp(line, "printers", 8) == 0) {
+            defaultPrinter = qt_parseNsswitchPrintersEntry(printers, line);
+            delete[] line;
+            return defaultPrinter;
+        }
+    }
+
+    strcpy(line, "printers: user files nis nisplus xfn");
+    defaultPrinter = qt_parseNsswitchPrintersEntry(printers, line);
+    delete[] line;
+    return defaultPrinter;
+}
+
+// HP-UX
+void qt_parseEtcLpMember(QList<QPrinterDescription> *printers)
+{
+    QDir lp(QLatin1String("/etc/lp/member"));
+    if (!lp.exists())
+        return;
+    QFileInfoList dirs = lp.entryInfoList();
+    if (dirs.isEmpty())
+        return;
+
+#ifdef QT_NO_PRINTDIALOG
+    Q_UNUSED(printers);
+#else
+    QString tmp;
+    for (int i = 0; i < dirs.size(); ++i) {
+        QFileInfo printer = dirs.at(i);
+        // I haven't found any real documentation, so I'm guessing that
+        // since lpstat uses /etc/lp/member rather than one of the
+        // other directories, it's the one to use.  I did not find a
+        // decent way to locate aliases and remote printers.
+        if (printer.isFile())
+            qt_perhapsAddPrinter(printers, printer.fileName(),
+                                 QPrintDialog::tr("unknown"),
+                                 QLatin1String(""));
+    }
+#endif
+}
+
+// IRIX 6.x
+void qt_parseSpoolInterface(QList<QPrinterDescription> *printers)
+{
+    QDir lp(QLatin1String("/usr/spool/lp/interface"));
+    if (!lp.exists())
+        return;
+    QFileInfoList files = lp.entryInfoList();
+    if(files.isEmpty())
+        return;
+
+    for (int i = 0; i < files.size(); ++i) {
+        QFileInfo printer = files.at(i);
+
+        if (!printer.isFile())
+            continue;
+
+        // parse out some information
+        QFile configFile(printer.filePath());
+        if (!configFile.open(QIODevice::ReadOnly))
+            continue;
+
+        QByteArray line;
+        line.resize(1025);
+        QString namePrinter;
+        QString hostName;
+        QString hostPrinter;
+        QString printerType;
+
+        QString nameKey(QLatin1String("NAME="));
+        QString typeKey(QLatin1String("TYPE="));
+        QString hostKey(QLatin1String("HOSTNAME="));
+        QString hostPrinterKey(QLatin1String("HOSTPRINTER="));
+
+        while (!configFile.atEnd() &&
+                (configFile.readLine(line.data(), 1024)) > 0) {
+            QString uline = QString::fromLocal8Bit(line);
+            if (uline.startsWith(typeKey) ) {
+                printerType = uline.mid(nameKey.length());
+                printerType = printerType.simplified();
+            } else if (uline.startsWith(hostKey)) {
+                hostName = uline.mid(hostKey.length());
+                hostName = hostName.simplified();
+            } else if (uline.startsWith(hostPrinterKey)) {
+                hostPrinter = uline.mid(hostPrinterKey.length());
+                hostPrinter = hostPrinter.simplified();
+            } else if (uline.startsWith(nameKey)) {
+                namePrinter = uline.mid(nameKey.length());
+                namePrinter = namePrinter.simplified();
+            }
+        }
+        configFile.close();
+
+        printerType = printerType.trimmed();
+        if (printerType.indexOf(QLatin1String("postscript"), 0, Qt::CaseInsensitive) < 0)
+            continue;
+
+        int ii = 0;
+        while ((ii = namePrinter.indexOf(QLatin1Char('"'), ii)) >= 0)
+            namePrinter.remove(ii, 1);
+
+        if (hostName.isEmpty() || hostPrinter.isEmpty()) {
+            qt_perhapsAddPrinter(printers, printer.fileName(),
+                                 QLatin1String(""), namePrinter);
+        } else {
+            QString comment;
+            comment = namePrinter;
+            comment += QLatin1String(" (");
+            comment += hostPrinter;
+            comment += QLatin1Char(')');
+            qt_perhapsAddPrinter(printers, printer.fileName(),
+                                 hostName, comment);
+        }
+    }
+}
+
+
+// Every unix must have its own.  It's a standard.  Here is AIX.
+void qt_parseQconfig(QList<QPrinterDescription> *printers)
+{
+    QFile qconfig(QLatin1String("/etc/qconfig"));
+    if (!qconfig.open(QIODevice::ReadOnly))
+        return;
+
+    QTextStream ts(&qconfig);
+    QString line;
+
+    QString stanzaName; // either a queue or a device name
+    bool up = true; // queue up?  default true, can be false
+    QString remoteHost; // null if local
+    QString deviceName; // null if remote
+
+    QRegExp newStanza(QLatin1String("^[0-z\\-]*:$"));
+
+    // our basic strategy here is to process each line, detecting new
+    // stanzas.  each time we see a new stanza, we check if the
+    // previous stanza was a valid queue for a) a remote printer or b)
+    // a local printer.  if it wasn't, we assume that what we see is
+    // the start of the first stanza, or that the previous stanza was
+    // a device stanza, or that there is some syntax error (we don't
+    // report those).
+
+    do {
+        line = ts.readLine();
+        bool indented = line[0].isSpace();
+        line = line.simplified();
+
+        int i = line.indexOf(QLatin1Char('='));
+        if (indented && i != -1) { // line in stanza
+            QString variable = line.left(i).simplified();
+            QString value=line.mid(i+1, line.length()).simplified();
+            if (variable == QLatin1String("device"))
+                deviceName = value;
+            else if (variable == QLatin1String("host"))
+                remoteHost = value;
+            else if (variable == QLatin1String("up"))
+                up = !(value.toLower() == QLatin1String("false"));
+        } else if (line[0] == QLatin1Char('*')) { // comment
+            // nothing to do
+        } else if (ts.atEnd() || // end of file, or beginning of new stanza
+                    (!indented && line.contains(newStanza))) {
+            if (up && stanzaName.length() > 0 && stanzaName.length() < 21) {
+                if (remoteHost.length()) // remote printer
+                    qt_perhapsAddPrinter(printers, stanzaName, remoteHost,
+                                         QString());
+                else if (deviceName.length()) // local printer
+                    qt_perhapsAddPrinter(printers, stanzaName, QString(),
+                                         QString());
+            }
+            line.chop(1);
+            if (line.length() >= 1 && line.length() <= 20)
+                stanzaName = line;
+            up = true;
+            remoteHost.clear();
+            deviceName.clear();
+        } else {
+            // syntax error?  ignore.
+        }
+    } while (!ts.atEnd());
+}
+
+int qt_getLprPrinters(QList<QPrinterDescription>& printers)
+{
+    QByteArray etcLpDefault;
+    qt_parsePrintcap(&printers, QLatin1String("/etc/printcap"));
+    qt_parseEtcLpMember(&printers);
+    qt_parseSpoolInterface(&printers);
+    qt_parseQconfig(&printers);
+
+    QFileInfo f;
+    f.setFile(QLatin1String("/etc/lp/printers"));
+    if (f.isDir()) {
+        qt_parseEtcLpPrinters(&printers);
+        QFile def(QLatin1String("/etc/lp/default"));
+        if (def.open(QIODevice::ReadOnly)) {
+            etcLpDefault.resize(1025);
+            if (def.readLine(etcLpDefault.data(), 1024) > 0) {
+                QRegExp rx(QLatin1String("^(\\S+)"));
+                if (rx.indexIn(QString::fromLatin1(etcLpDefault)) != -1)
+                    etcLpDefault = rx.cap(1).toAscii();
+            }
+        }
+    }
+
+    char *def = 0;
+    f.setFile(QLatin1String("/etc/nsswitch.conf"));
+    if (f.isFile()) {
+        def = qt_parseNsswitchConf(&printers);
+    } else {
+        f.setFile(QLatin1String("/etc/printers.conf"));
+        if (f.isFile())
+            def = qt_parsePrintersConf(&printers);
+    }
+
+    if (def) {
+        etcLpDefault = def;
+        delete [] def;
+    }
+
+    QString homePrintersDefault = qt_getDefaultFromHomePrinters();
+
+    // all printers hopefully known.  try to find a good default
+    QString dollarPrinter;
+    {
+        dollarPrinter = QString::fromLocal8Bit(qgetenv("PRINTER"));
+        if (dollarPrinter.isEmpty())
+            dollarPrinter = QString::fromLocal8Bit(qgetenv("LPDEST"));
+        if (dollarPrinter.isEmpty())
+            dollarPrinter = QString::fromLocal8Bit(qgetenv("NPRINTER"));
+        if (dollarPrinter.isEmpty())
+            dollarPrinter = QString::fromLocal8Bit(qgetenv("NGPRINTER"));
+#ifndef QT_NO_PRINTDIALOG
+        if (!dollarPrinter.isEmpty())
+            qt_perhapsAddPrinter(&printers, dollarPrinter,
+                                 QPrintDialog::tr("unknown"),
+                                 QLatin1String(""));
+#endif
+    }
+
+    QRegExp ps(QLatin1String("[^a-z]ps(?:[^a-z]|$)"));
+    QRegExp lp(QLatin1String("[^a-z]lp(?:[^a-z]|$)"));
+
+    int quality = 0;
+    int best = 0;
+    for (int i = 0; i < printers.size(); ++i) {
+        QString name = printers.at(i).name;
+        QString comment = printers.at(i).comment;
+        if (quality < 5 && name == dollarPrinter) {
+            best = i;
+            quality = 5;
+        } else if (quality < 4 && !homePrintersDefault.isEmpty() &&
+                   name == homePrintersDefault) {
+            best = i;
+            quality = 4;
+        } else if (quality < 3 && !etcLpDefault.isEmpty() &&
+                    name == QLatin1String(etcLpDefault)) {
+            best = i;
+            quality = 3;
+        } else if (quality < 2 &&
+                    (name == QLatin1String("ps") ||
+                     ps.indexIn(comment) != -1)) {
+            best = i;
+            quality = 2;
+        } else if (quality < 1 &&
+                    (name == QLatin1String("lp") ||
+                     lp.indexIn(comment) > -1)) {
+            best = i;
+            quality = 1;
+        }
+    }
+
+    return best;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////
+
+QList<QPrinterInfo> QPrinterInfo::availablePrinters()
+{
+    QList<QPrinterInfo> printers;
+
+#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
+    if (QCUPSSupport::isAvailable()) {
+        QCUPSSupport cups;
+        int cupsPrinterCount = cups.availablePrintersCount();
+        const cups_dest_t* cupsPrinters = cups.availablePrinters();
+        for (int i = 0; i < cupsPrinterCount; ++i) {
+            QString printerName(QString::fromLocal8Bit(cupsPrinters[i].name));
+            if (cupsPrinters[i].instance)
+                printerName += QLatin1Char('/') + QString::fromLocal8Bit(cupsPrinters[i].instance);
+
+            QPrinterInfo printerInfo(printerName);
+            if (cupsPrinters[i].is_default)
+                printerInfo.d_ptr->isDefault = true;
+            printerInfo.d_ptr->cupsPrinterIndex = i;
+            printers.append(printerInfo);
+        }
+    } else
+#endif
+           {
+        QList<QPrinterDescription> lprPrinters;
+        int defprn = qt_getLprPrinters(lprPrinters);
+        // populating printer combo
+        foreach (const QPrinterDescription &description, lprPrinters)
+            printers.append(QPrinterInfo(description.name));
+        if (defprn >= 0 && defprn < printers.size())
+            printers[defprn].d_ptr->isDefault = true;
+    }
+
+    return printers;
+}
+
+QPrinterInfo QPrinterInfo::defaultPrinter()
+{
+    QList<QPrinterInfo> printers = availablePrinters();
+    foreach (const QPrinterInfo &printerInfo, printers) {
+        if (printerInfo.isDefault())
+            return printerInfo;
+    }
+
+    return printers.value(0);
+}
+
+QList<QPrinter::PaperSize> QPrinterInfo::supportedPaperSizes() const
+{
+#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
+    const Q_D(QPrinterInfo);
+
+    if (isNull())
+        return d->paperSizes;
+
+    if (!d->hasPaperSizes) {
+        d->hasPaperSizes = true;
+
+        if (QCUPSSupport::isAvailable()) {
+            // Find paper sizes from CUPS.
+            QCUPSSupport cups;
+            cups.setCurrentPrinter(d->cupsPrinterIndex);
+            const ppd_option_t* sizes = cups.pageSizes();
+            if (sizes) {
+                for (int j = 0; j < sizes->num_choices; ++j)
+                    d->paperSizes.append(string2PaperSize(sizes->choices[j].choice));
+            }
+        }
+    }
+
+    return d->paperSizes;
+#else
+    return QList<QPrinter::PaperSize>();
+#endif
+}
+
+#endif // QT_NO_PRINTER
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qprinterinfo_unix_p.h b/src/gui/painting/qprinterinfo_unix_p.h
new file mode 100644
index 0000000000..c5a62cefcd
--- /dev/null
+++ b/src/gui/painting/qprinterinfo_unix_p.h
@@ -0,0 +1,125 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPRINTERINFO_UNIX_P_H
+#define QPRINTERINFO_UNIX_P_H
+
+#ifndef QT_NO_NIS
+#  ifndef BOOL_DEFINED
+#    define BOOL_DEFINED
+#  endif
+
+#  include <sys/types.h>
+#  include <rpc/rpc.h>
+#  include <rpcsvc/ypclnt.h>
+#  include <rpcsvc/yp_prot.h>
+#endif // QT_NO_NIS
+
+#ifdef Success
+#  undef Success
+#endif
+
+#include <ctype.h>
+
+QT_BEGIN_NAMESPACE
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#ifndef QT_NO_PRINTER
+
+struct QPrinterDescription {
+    QPrinterDescription(const QString &n, const QString &h, const QString &c, const QStringList &a)
+    : name(n), host(h), comment(c), aliases(a) {}
+    QString name;
+    QString host;
+    QString comment;
+    QStringList aliases;
+    bool samePrinter(const QString& printer) const {
+        return name == printer || aliases.contains(printer);
+    }
+};
+
+enum { Success = 's', Unavail = 'u', NotFound = 'n', TryAgain = 't' };
+enum { Continue = 'c', Return = 'r' };
+
+void qt_perhapsAddPrinter(QList<QPrinterDescription> *printers, const QString &name,
+                          QString host, QString comment,
+                          QStringList aliases = QStringList());
+void qt_parsePrinterDesc(QString printerDesc, QList<QPrinterDescription> *printers);
+
+int qt_parsePrintcap(QList<QPrinterDescription> *printers, const QString& fileName);
+QString qt_getDefaultFromHomePrinters();
+void qt_parseEtcLpPrinters(QList<QPrinterDescription> *printers);
+char *qt_parsePrintersConf(QList<QPrinterDescription> *printers, bool *found = 0);
+
+#ifndef QT_NO_NIS
+#if defined(Q_C_CALLBACKS)
+extern "C" {
+#endif
+int qt_pd_foreach(int /*status */, char * /*key */, int /*keyLen */,
+                  char *val, int valLen, char *data);
+
+#if defined(Q_C_CALLBACKS)
+}
+#endif
+int qt_retrieveNisPrinters(QList<QPrinterDescription> *printers);
+#endif // QT_NO_NIS
+char *qt_parseNsswitchPrintersEntry(QList<QPrinterDescription> *printers, char *line);
+char *qt_parseNsswitchConf(QList<QPrinterDescription> *printers);
+void qt_parseEtcLpMember(QList<QPrinterDescription> *printers);
+void qt_parseSpoolInterface(QList<QPrinterDescription> *printers);
+void qt_parseQconfig(QList<QPrinterDescription> *printers);
+int qt_getLprPrinters(QList<QPrinterDescription>& printers);
+
+#endif // QT_NO_PRINTER
+
+QT_END_NAMESPACE
+
+#endif // QPRINTERINFO_UNIX_P_H
diff --git a/src/gui/painting/qprinterinfo_win.cpp b/src/gui/painting/qprinterinfo_win.cpp
new file mode 100644
index 0000000000..2c4014d8dc
--- /dev/null
+++ b/src/gui/painting/qprinterinfo_win.cpp
@@ -0,0 +1,122 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qprinterinfo.h"
+#include "qprinterinfo_p.h"
+
+#include <qstringlist.h>
+
+#include <qt_windows.h>
+
+QT_BEGIN_NAMESPACE
+
+#ifndef QT_NO_PRINTER
+
+extern QPrinter::PaperSize mapDevmodePaperSize(int s);
+
+QList<QPrinterInfo> QPrinterInfo::availablePrinters()
+{
+    QList<QPrinterInfo> printers;
+
+    DWORD needed = 0;
+    DWORD returned = 0;
+    if (!EnumPrinters(PRINTER_ENUM_LOCAL | PRINTER_ENUM_CONNECTIONS, NULL, 4, 0, 0, &needed, &returned)) {
+        LPBYTE buffer = new BYTE[needed];
+        if (EnumPrinters(PRINTER_ENUM_LOCAL | PRINTER_ENUM_CONNECTIONS, NULL, 4, buffer, needed, &needed, &returned)) {
+            PPRINTER_INFO_4 infoList = reinterpret_cast<PPRINTER_INFO_4>(buffer);
+            QPrinterInfo defPrn = defaultPrinter();
+            for (uint i = 0; i < returned; ++i) {
+                QString printerName(QString::fromWCharArray(infoList[i].pPrinterName));
+
+                QPrinterInfo printerInfo(printerName);
+                if (printerInfo.printerName() == defPrn.printerName())
+                    printerInfo.d_ptr->isDefault = true;
+                printers.append(printerInfo);
+            }
+        }
+        delete [] buffer;
+    }
+
+    return printers;
+}
+
+QPrinterInfo QPrinterInfo::defaultPrinter()
+{
+    QString noPrinters(QLatin1String("qt_no_printers"));
+    wchar_t buffer[256];
+    GetProfileString(L"windows", L"device", (wchar_t*)noPrinters.utf16(), buffer, 256);
+    QString output = QString::fromWCharArray(buffer);
+    if (output != noPrinters) {
+        // Filter out the name of the printer, which should be everything before a comma.
+        QString printerName = output.split(QLatin1Char(',')).value(0);
+        QPrinterInfo printerInfo(printerName);
+        printerInfo.d_ptr->isDefault = true;
+        return printerInfo;
+    }
+
+    return QPrinterInfo();
+}
+
+QList<QPrinter::PaperSize> QPrinterInfo::supportedPaperSizes() const
+{
+    const Q_D(QPrinterInfo);
+
+    QList<QPrinter::PaperSize> paperSizes;
+    if (isNull())
+        return paperSizes;
+
+    DWORD size = DeviceCapabilities(reinterpret_cast<const wchar_t*>(d->name.utf16()),
+                                    NULL, DC_PAPERS, NULL, NULL);
+    if ((int)size != -1) {
+        wchar_t *papers = new wchar_t[size];
+        size = DeviceCapabilities(reinterpret_cast<const wchar_t*>(d->name.utf16()),
+                                  NULL, DC_PAPERS, papers, NULL);
+        for (int c = 0; c < (int)size; ++c)
+            paperSizes.append(mapDevmodePaperSize(papers[c]));
+        delete [] papers;
+    }
+
+    return paperSizes;
+}
+
+#endif // QT_NO_PRINTER
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qpsprinter.agl b/src/gui/painting/qpsprinter.agl
new file mode 100644
index 0000000000..137b64c53b
--- /dev/null
+++ b/src/gui/painting/qpsprinter.agl
@@ -0,0 +1,452 @@
+# the next table is derived from a list provided by Adobe on its web
+# server: http://partners.adobe.com/asn/developer/typeforum/glyphlist.txt
+
+# the start of the header comment:
+#
+# Name:          Adobe Glyph List
+# Table version: 1.2
+# Date:          22 Oct 1998
+#
+# Description:
+#
+#   The Adobe Glyph List (AGL) list relates Unicode values (UVs) to glyph
+#   names, and should be used only as described in the document "Unicode and
+#   Glyph Names," at
+#   http://partners.adobe.com:80/asn/developer/type/unicodegn.html
+#
+# IMPORTANT NOTE:
+# the list contains glyphs in the private use area of unicode. 
+# These should get removed when regenerating the glyphlist.
+#
+# also 0 should be mapped to .notdef
+#
+# grep '^[0-9A-F][0-9A-F][0-9A-F][0-9A-F];' < /tmp/glyphlist.txt | sed -e 's/;/, "/' -e 's-;-" },  // -' -e 's/^/    { 0x/' | sort
+#
+0x0000, ".notdef"
+0x0020, "space"  # SPACE
+0x0021, "exclam"  # EXCLAMATION MARK
+0x0022, "quotedbl"  # QUOTATION MARK
+0x0023, "numbersign"  # NUMBER SIGN
+0x0024, "dollar"  # DOLLAR SIGN
+0x0025, "percent"  # PERCENT SIGN
+0x0026, "ampersand"  # AMPERSAND
+0x0027, "quotesingle"  # APOSTROPHE
+0x0028, "parenleft"  # LEFT PARENTHESIS
+0x0029, "parenright"  # RIGHT PARENTHESIS
+0x002A, "asterisk"  # ASTERISK
+0x002B, "plus"  # PLUS SIGN
+0x002C, "comma"  # COMMA
+0x002D, "hyphen"  # HYPHEN-MINUS
+0x002E, "period"  # FULL STOP
+0x002F, "slash"  # SOLIDUS
+0x0030, "zero"  # DIGIT ZERO
+0x0031, "one"  # DIGIT ONE
+0x0032, "two"  # DIGIT TWO
+0x0033, "three"  # DIGIT THREE
+0x0034, "four"  # DIGIT FOUR
+0x0035, "five"  # DIGIT FIVE
+0x0036, "six"  # DIGIT SIX
+0x0037, "seven"  # DIGIT SEVEN
+0x0038, "eight"  # DIGIT EIGHT
+0x0039, "nine"  # DIGIT NINE
+0x003A, "colon"  # COLON
+0x003B, "semicolon"  # SEMICOLON
+0x003C, "less"  # LESS-THAN SIGN
+0x003D, "equal"  # EQUALS SIGN
+0x003E, "greater"  # GREATER-THAN SIGN
+0x003F, "question"  # QUESTION MARK
+0x0040, "at"  # COMMERCIAL AT
+0x0041, "A"  # LATIN CAPITAL LETTER A
+0x0042, "B"  # LATIN CAPITAL LETTER B
+0x0043, "C"  # LATIN CAPITAL LETTER C
+0x0044, "D"  # LATIN CAPITAL LETTER D
+0x0045, "E"  # LATIN CAPITAL LETTER E
+0x0046, "F"  # LATIN CAPITAL LETTER F
+0x0047, "G"  # LATIN CAPITAL LETTER G
+0x0048, "H"  # LATIN CAPITAL LETTER H
+0x0049, "I"  # LATIN CAPITAL LETTER I
+0x004A, "J"  # LATIN CAPITAL LETTER J
+0x004B, "K"  # LATIN CAPITAL LETTER K
+0x004C, "L"  # LATIN CAPITAL LETTER L
+0x004D, "M"  # LATIN CAPITAL LETTER M
+0x004E, "N"  # LATIN CAPITAL LETTER N
+0x004F, "O"  # LATIN CAPITAL LETTER O
+0x0050, "P"  # LATIN CAPITAL LETTER P
+0x0051, "Q"  # LATIN CAPITAL LETTER Q
+0x0052, "R"  # LATIN CAPITAL LETTER R
+0x0053, "S"  # LATIN CAPITAL LETTER S
+0x0054, "T"  # LATIN CAPITAL LETTER T
+0x0055, "U"  # LATIN CAPITAL LETTER U
+0x0056, "V"  # LATIN CAPITAL LETTER V
+0x0057, "W"  # LATIN CAPITAL LETTER W
+0x0058, "X"  # LATIN CAPITAL LETTER X
+0x0059, "Y"  # LATIN CAPITAL LETTER Y
+0x005A, "Z"  # LATIN CAPITAL LETTER Z
+0x005B, "bracketleft"  # LEFT SQUARE BRACKET
+0x005C, "backslash"  # REVERSE SOLIDUS
+0x005D, "bracketright"  # RIGHT SQUARE BRACKET
+0x005E, "asciicircum"  # CIRCUMFLEX ACCENT
+0x005F, "underscore"  # LOW LINE
+0x0060, "grave"  # GRAVE ACCENT
+0x0061, "a"  # LATIN SMALL LETTER A
+0x0062, "b"  # LATIN SMALL LETTER B
+0x0063, "c"  # LATIN SMALL LETTER C
+0x0064, "d"  # LATIN SMALL LETTER D
+0x0065, "e"  # LATIN SMALL LETTER E
+0x0066, "f"  # LATIN SMALL LETTER F
+0x0067, "g"  # LATIN SMALL LETTER G
+0x0068, "h"  # LATIN SMALL LETTER H
+0x0069, "i"  # LATIN SMALL LETTER I
+0x006A, "j"  # LATIN SMALL LETTER J
+0x006B, "k"  # LATIN SMALL LETTER K
+0x006C, "l"  # LATIN SMALL LETTER L
+0x006D, "m"  # LATIN SMALL LETTER M
+0x006E, "n"  # LATIN SMALL LETTER N
+0x006F, "o"  # LATIN SMALL LETTER O
+0x0070, "p"  # LATIN SMALL LETTER P
+0x0071, "q"  # LATIN SMALL LETTER Q
+0x0072, "r"  # LATIN SMALL LETTER R
+0x0073, "s"  # LATIN SMALL LETTER S
+0x0074, "t"  # LATIN SMALL LETTER T
+0x0075, "u"  # LATIN SMALL LETTER U
+0x0076, "v"  # LATIN SMALL LETTER V
+0x0077, "w"  # LATIN SMALL LETTER W
+0x0078, "x"  # LATIN SMALL LETTER X
+0x0079, "y"  # LATIN SMALL LETTER Y
+0x007A, "z"  # LATIN SMALL LETTER Z
+0x007B, "braceleft"  # LEFT CURLY BRACKET
+0x007C, "bar"  # VERTICAL LINE
+0x007D, "braceright"  # RIGHT CURLY BRACKET
+0x007E, "asciitilde"  # TILDE
+0x00A0, "space"  # NO-BREAK SPACE;Duplicate
+0x00A1, "exclamdown"  # INVERTED EXCLAMATION MARK
+0x00A2, "cent"  # CENT SIGN
+0x00A3, "sterling"  # POUND SIGN
+0x00A4, "currency"  # CURRENCY SIGN
+0x00A5, "yen"  # YEN SIGN
+0x00A6, "brokenbar"  # BROKEN BAR
+0x00A7, "section"  # SECTION SIGN
+0x00A8, "dieresis"  # DIAERESIS
+0x00A9, "copyright"  # COPYRIGHT SIGN
+0x00AA, "ordfeminine"  # FEMININE ORDINAL INDICATOR
+0x00AB, "guillemotleft"  # LEFT-POINTING DOUBLE ANGLE QUOTATION MARK
+0x00AC, "logicalnot"  # NOT SIGN
+0x00AD, "hyphen"  # SOFT HYPHEN;Duplicate
+0x00AE, "registered"  # REGISTERED SIGN
+0x00AF, "macron"  # MACRON
+0x00B0, "degree"  # DEGREE SIGN
+0x00B1, "plusminus"  # PLUS-MINUS SIGN
+0x00B2, "twosuperior"  # SUPERSCRIPT TWO
+0x00B3, "threesuperior"  # SUPERSCRIPT THREE
+0x00B4, "acute"  # ACUTE ACCENT
+0x00B5, "mu"  # MICRO SIGN
+0x00B6, "paragraph"  # PILCROW SIGN
+0x00B7, "periodcentered"  # MIDDLE DOT
+0x00B8, "cedilla"  # CEDILLA
+0x00B9, "onesuperior"  # SUPERSCRIPT ONE
+0x00BA, "ordmasculine"  # MASCULINE ORDINAL INDICATOR
+0x00BB, "guillemotright" # RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK
+0x00BC, "onequarter"  # VULGAR FRACTION ONE QUARTER
+0x00BD, "onehalf"  # VULGAR FRACTION ONE HALF
+0x00BE, "threequarters"  # VULGAR FRACTION THREE QUARTERS
+0x00BF, "questiondown"  # INVERTED QUESTION MARK
+0x00C0, "Agrave"  # LATIN CAPITAL LETTER A WITH GRAVE
+0x00C1, "Aacute"  # LATIN CAPITAL LETTER A WITH ACUTE
+0x00C2, "Acircumflex"  # LATIN CAPITAL LETTER A WITH CIRCUMFLEX
+0x00C3, "Atilde"  # LATIN CAPITAL LETTER A WITH TILDE
+0x00C4, "Adieresis"  # LATIN CAPITAL LETTER A WITH DIAERESIS
+0x00C5, "Aring"  # LATIN CAPITAL LETTER A WITH RING ABOVE
+0x00C6, "AE"  # LATIN CAPITAL LETTER AE
+0x00C7, "Ccedilla"  # LATIN CAPITAL LETTER C WITH CEDILLA
+0x00C8, "Egrave"  # LATIN CAPITAL LETTER E WITH GRAVE
+0x00C9, "Eacute"  # LATIN CAPITAL LETTER E WITH ACUTE
+0x00CA, "Ecircumflex"  # LATIN CAPITAL LETTER E WITH CIRCUMFLEX
+0x00CB, "Edieresis"  # LATIN CAPITAL LETTER E WITH DIAERESIS
+0x00CC, "Igrave"  # LATIN CAPITAL LETTER I WITH GRAVE
+0x00CD, "Iacute"  # LATIN CAPITAL LETTER I WITH ACUTE
+0x00CE, "Icircumflex"  # LATIN CAPITAL LETTER I WITH CIRCUMFLEX
+0x00CF, "Idieresis"  # LATIN CAPITAL LETTER I WITH DIAERESIS
+0x00D0, "Eth"  # LATIN CAPITAL LETTER ETH
+0x00D1, "Ntilde"  # LATIN CAPITAL LETTER N WITH TILDE
+0x00D2, "Ograve"  # LATIN CAPITAL LETTER O WITH GRAVE
+0x00D3, "Oacute"  # LATIN CAPITAL LETTER O WITH ACUTE
+0x00D4, "Ocircumflex"  # LATIN CAPITAL LETTER O WITH CIRCUMFLEX
+0x00D5, "Otilde"  # LATIN CAPITAL LETTER O WITH TILDE
+0x00D6, "Odieresis"  # LATIN CAPITAL LETTER O WITH DIAERESIS
+0x00D7, "multiply"  # MULTIPLICATION SIGN
+0x00D8, "Oslash"  # LATIN CAPITAL LETTER O WITH STROKE
+0x00D9, "Ugrave"  # LATIN CAPITAL LETTER U WITH GRAVE
+0x00DA, "Uacute"  # LATIN CAPITAL LETTER U WITH ACUTE
+0x00DB, "Ucircumflex"  # LATIN CAPITAL LETTER U WITH CIRCUMFLEX
+0x00DC, "Udieresis"  # LATIN CAPITAL LETTER U WITH DIAERESIS
+0x00DD, "Yacute"  # LATIN CAPITAL LETTER Y WITH ACUTE
+0x00DE, "Thorn"  # LATIN CAPITAL LETTER THORN
+0x00DF, "germandbls"  # LATIN SMALL LETTER SHARP S
+0x00E0, "agrave"  # LATIN SMALL LETTER A WITH GRAVE
+0x00E1, "aacute"  # LATIN SMALL LETTER A WITH ACUTE
+0x00E2, "acircumflex"  # LATIN SMALL LETTER A WITH CIRCUMFLEX
+0x00E3, "atilde"  # LATIN SMALL LETTER A WITH TILDE
+0x00E4, "adieresis"  # LATIN SMALL LETTER A WITH DIAERESIS
+0x00E5, "aring"  # LATIN SMALL LETTER A WITH RING ABOVE
+0x00E6, "ae"  # LATIN SMALL LETTER AE
+0x00E7, "ccedilla"  # LATIN SMALL LETTER C WITH CEDILLA
+0x00E8, "egrave"  # LATIN SMALL LETTER E WITH GRAVE
+0x00E9, "eacute"  # LATIN SMALL LETTER E WITH ACUTE
+0x00EA, "ecircumflex"  # LATIN SMALL LETTER E WITH CIRCUMFLEX
+0x00EB, "edieresis"  # LATIN SMALL LETTER E WITH DIAERESIS
+0x00EC, "igrave"  # LATIN SMALL LETTER I WITH GRAVE
+0x00ED, "iacute"  # LATIN SMALL LETTER I WITH ACUTE
+0x00EE, "icircumflex"  # LATIN SMALL LETTER I WITH CIRCUMFLEX
+0x00EF, "idieresis"  # LATIN SMALL LETTER I WITH DIAERESIS
+0x00F0, "eth"  # LATIN SMALL LETTER ETH
+0x00F1, "ntilde"  # LATIN SMALL LETTER N WITH TILDE
+0x00F2, "ograve"  # LATIN SMALL LETTER O WITH GRAVE
+0x00F3, "oacute"  # LATIN SMALL LETTER O WITH ACUTE
+0x00F4, "ocircumflex"  # LATIN SMALL LETTER O WITH CIRCUMFLEX
+0x00F5, "otilde"  # LATIN SMALL LETTER O WITH TILDE
+0x00F6, "odieresis"  # LATIN SMALL LETTER O WITH DIAERESIS
+0x00F7, "divide"  # DIVISION SIGN
+0x00F8, "oslash"  # LATIN SMALL LETTER O WITH STROKE
+0x00F9, "ugrave"  # LATIN SMALL LETTER U WITH GRAVE
+0x00FA, "uacute"  # LATIN SMALL LETTER U WITH ACUTE
+0x00FB, "ucircumflex"  # LATIN SMALL LETTER U WITH CIRCUMFLEX
+0x00FC, "udieresis"  # LATIN SMALL LETTER U WITH DIAERESIS
+0x00FD, "yacute"  # LATIN SMALL LETTER Y WITH ACUTE
+0x00FE, "thorn"  # LATIN SMALL LETTER THORN
+0x00FF, "ydieresis"  # LATIN SMALL LETTER Y WITH DIAERESIS
+0x0100, "Amacron"  # LATIN CAPITAL LETTER A WITH MACRON
+0x0101, "amacron"  # LATIN SMALL LETTER A WITH MACRON
+0x0102, "Abreve"  # LATIN CAPITAL LETTER A WITH BREVE
+0x0103, "abreve"  # LATIN SMALL LETTER A WITH BREVE
+0x0104, "Aogonek"  # LATIN CAPITAL LETTER A WITH OGONEK
+0x0105, "aogonek"  # LATIN SMALL LETTER A WITH OGONEK
+0x0106, "Cacute"  # LATIN CAPITAL LETTER C WITH ACUTE
+0x0107, "cacute"  # LATIN SMALL LETTER C WITH ACUTE
+0x0108, "Ccircumflex"  # LATIN CAPITAL LETTER C WITH CIRCUMFLEX
+0x0109, "ccircumflex"  # LATIN SMALL LETTER C WITH CIRCUMFLEX
+0x010A, "Cdotaccent"  # LATIN CAPITAL LETTER C WITH DOT ABOVE
+0x010B, "cdotaccent"  # LATIN SMALL LETTER C WITH DOT ABOVE
+0x010C, "Ccaron"  # LATIN CAPITAL LETTER C WITH CARON
+0x010D, "ccaron"  # LATIN SMALL LETTER C WITH CARON
+0x010E, "Dcaron"  # LATIN CAPITAL LETTER D WITH CARON
+0x010F, "dcaron"  # LATIN SMALL LETTER D WITH CARON
+0x0110, "Dcroat"  # LATIN CAPITAL LETTER D WITH STROKE
+0x0111, "dcroat"  # LATIN SMALL LETTER D WITH STROKE
+0x0112, "Emacron"  # LATIN CAPITAL LETTER E WITH MACRON
+0x0113, "emacron"  # LATIN SMALL LETTER E WITH MACRON
+0x0114, "Ebreve"  # LATIN CAPITAL LETTER E WITH BREVE
+0x0115, "ebreve"  # LATIN SMALL LETTER E WITH BREVE
+0x0116, "Edotaccent"  # LATIN CAPITAL LETTER E WITH DOT ABOVE
+0x0117, "edotaccent"  # LATIN SMALL LETTER E WITH DOT ABOVE
+0x0118, "Eogonek"  # LATIN CAPITAL LETTER E WITH OGONEK
+0x0119, "eogonek"  # LATIN SMALL LETTER E WITH OGONEK
+0x011A, "Ecaron"  # LATIN CAPITAL LETTER E WITH CARON
+0x011B, "ecaron"  # LATIN SMALL LETTER E WITH CARON
+0x011C, "Gcircumflex"  # LATIN CAPITAL LETTER G WITH CIRCUMFLEX
+0x011D, "gcircumflex"  # LATIN SMALL LETTER G WITH CIRCUMFLEX
+0x011E, "Gbreve"  # LATIN CAPITAL LETTER G WITH BREVE
+0x011F, "gbreve"  # LATIN SMALL LETTER G WITH BREVE
+0x0120, "Gdotaccent"  # LATIN CAPITAL LETTER G WITH DOT ABOVE
+0x0121, "gdotaccent"  # LATIN SMALL LETTER G WITH DOT ABOVE
+0x0122, "Gcommaaccent"  # LATIN CAPITAL LETTER G WITH CEDILLA
+0x0123, "gcommaaccent"  # LATIN SMALL LETTER G WITH CEDILLA
+0x0124, "Hcircumflex"  # LATIN CAPITAL LETTER H WITH CIRCUMFLEX
+0x0125, "hcircumflex"  # LATIN SMALL LETTER H WITH CIRCUMFLEX
+0x0126, "Hbar"  # LATIN CAPITAL LETTER H WITH STROKE
+0x0127, "hbar"  # LATIN SMALL LETTER H WITH STROKE
+0x0128, "Itilde"  # LATIN CAPITAL LETTER I WITH TILDE
+0x0129, "itilde"  # LATIN SMALL LETTER I WITH TILDE
+0x012A, "Imacron"  # LATIN CAPITAL LETTER I WITH MACRON
+0x012B, "imacron"  # LATIN SMALL LETTER I WITH MACRON
+0x012C, "Ibreve"  # LATIN CAPITAL LETTER I WITH BREVE
+0x012D, "ibreve"  # LATIN SMALL LETTER I WITH BREVE
+0x012E, "Iogonek"  # LATIN CAPITAL LETTER I WITH OGONEK
+0x012F, "iogonek"  # LATIN SMALL LETTER I WITH OGONEK
+0x0130, "Idotaccent"  # LATIN CAPITAL LETTER I WITH DOT ABOVE
+0x0131, "dotlessi"  # LATIN SMALL LETTER DOTLESS I
+0x0132, "IJ"  # LATIN CAPITAL LIGATURE IJ
+0x0133, "ij"  # LATIN SMALL LIGATURE IJ
+0x0134, "Jcircumflex"  # LATIN CAPITAL LETTER J WITH CIRCUMFLEX
+0x0135, "jcircumflex"  # LATIN SMALL LETTER J WITH CIRCUMFLEX
+0x0136, "Kcommaaccent"  # LATIN CAPITAL LETTER K WITH CEDILLA
+0x0137, "kcommaaccent"  # LATIN SMALL LETTER K WITH CEDILLA
+0x0138, "kgreenlandic"  # LATIN SMALL LETTER KRA
+0x0139, "Lacute"  # LATIN CAPITAL LETTER L WITH ACUTE
+0x013A, "lacute"  # LATIN SMALL LETTER L WITH ACUTE
+0x013B, "Lcommaaccent"  # LATIN CAPITAL LETTER L WITH CEDILLA
+0x013C, "lcommaaccent"  # LATIN SMALL LETTER L WITH CEDILLA
+0x013D, "Lcaron"  # LATIN CAPITAL LETTER L WITH CARON
+0x013E, "lcaron"  # LATIN SMALL LETTER L WITH CARON
+0x013F, "Ldot"  # LATIN CAPITAL LETTER L WITH MIDDLE DOT
+0x0140, "ldot"  # LATIN SMALL LETTER L WITH MIDDLE DOT
+0x0141, "Lslash"  # LATIN CAPITAL LETTER L WITH STROKE
+0x0142, "lslash"  # LATIN SMALL LETTER L WITH STROKE
+0x0143, "Nacute"  # LATIN CAPITAL LETTER N WITH ACUTE
+0x0144, "nacute"  # LATIN SMALL LETTER N WITH ACUTE
+0x0145, "Ncommaaccent"  # LATIN CAPITAL LETTER N WITH CEDILLA
+0x0146, "ncommaaccent"  # LATIN SMALL LETTER N WITH CEDILLA
+0x0147, "Ncaron"  # LATIN CAPITAL LETTER N WITH CARON
+0x0148, "ncaron"  # LATIN SMALL LETTER N WITH CARON
+0x0149, "napostrophe"  # LATIN SMALL LETTER N PRECEDED BY APOSTROPHE
+0x014A, "Eng"  # LATIN CAPITAL LETTER ENG
+0x014B, "eng"  # LATIN SMALL LETTER ENG
+0x014C, "Omacron"  # LATIN CAPITAL LETTER O WITH MACRON
+0x014D, "omacron"  # LATIN SMALL LETTER O WITH MACRON
+0x014E, "Obreve"  # LATIN CAPITAL LETTER O WITH BREVE
+0x014F, "obreve"  # LATIN SMALL LETTER O WITH BREVE
+0x0150, "Ohungarumlaut"  # LATIN CAPITAL LETTER O WITH DOUBLE ACUTE
+0x0151, "ohungarumlaut"  # LATIN SMALL LETTER O WITH DOUBLE ACUTE
+0x0152, "OE"  # LATIN CAPITAL LIGATURE OE
+0x0153, "oe"  # LATIN SMALL LIGATURE OE
+0x0154, "Racute"  # LATIN CAPITAL LETTER R WITH ACUTE
+0x0155, "racute"  # LATIN SMALL LETTER R WITH ACUTE
+0x0156, "Rcommaaccent"  # LATIN CAPITAL LETTER R WITH CEDILLA
+0x0157, "rcommaaccent"  # LATIN SMALL LETTER R WITH CEDILLA
+0x0158, "Rcaron"  # LATIN CAPITAL LETTER R WITH CARON
+0x0159, "rcaron"  # LATIN SMALL LETTER R WITH CARON
+0x015A, "Sacute"  # LATIN CAPITAL LETTER S WITH ACUTE
+0x015B, "sacute"  # LATIN SMALL LETTER S WITH ACUTE
+0x015C, "Scircumflex"  # LATIN CAPITAL LETTER S WITH CIRCUMFLEX
+0x015D, "scircumflex"  # LATIN SMALL LETTER S WITH CIRCUMFLEX
+0x015E, "Scedilla"  # LATIN CAPITAL LETTER S WITH CEDILLA
+0x015F, "scedilla"  # LATIN SMALL LETTER S WITH CEDILLA
+0x0160, "Scaron"  # LATIN CAPITAL LETTER S WITH CARON
+0x0161, "scaron"  # LATIN SMALL LETTER S WITH CARON
+0x0164, "Tcaron"  # LATIN CAPITAL LETTER T WITH CARON
+0x0165, "tcaron"  # LATIN SMALL LETTER T WITH CARON
+0x0166, "Tbar"  # LATIN CAPITAL LETTER T WITH STROKE
+0x0167, "tbar"  # LATIN SMALL LETTER T WITH STROKE
+0x0168, "Utilde"  # LATIN CAPITAL LETTER U WITH TILDE
+0x0169, "utilde"  # LATIN SMALL LETTER U WITH TILDE
+0x016A, "Umacron"  # LATIN CAPITAL LETTER U WITH MACRON
+0x016B, "umacron"  # LATIN SMALL LETTER U WITH MACRON
+0x016C, "Ubreve"  # LATIN CAPITAL LETTER U WITH BREVE
+0x016D, "ubreve"  # LATIN SMALL LETTER U WITH BREVE
+0x016E, "Uring"  # LATIN CAPITAL LETTER U WITH RING ABOVE
+0x016F, "uring"  # LATIN SMALL LETTER U WITH RING ABOVE
+0x0170, "Uhungarumlaut"  # LATIN CAPITAL LETTER U WITH DOUBLE ACUTE
+0x0171, "uhungarumlaut"  # LATIN SMALL LETTER U WITH DOUBLE ACUTE
+0x0172, "Uogonek"  # LATIN CAPITAL LETTER U WITH OGONEK
+0x0173, "uogonek"  # LATIN SMALL LETTER U WITH OGONEK
+0x0174, "Wcircumflex"  # LATIN CAPITAL LETTER W WITH CIRCUMFLEX
+0x0175, "wcircumflex"  # LATIN SMALL LETTER W WITH CIRCUMFLEX
+0x0176, "Ycircumflex"  # LATIN CAPITAL LETTER Y WITH CIRCUMFLEX
+0x0177, "ycircumflex"  # LATIN SMALL LETTER Y WITH CIRCUMFLEX
+0x0178, "Ydieresis"  # LATIN CAPITAL LETTER Y WITH DIAERESIS
+0x0179, "Zacute"  # LATIN CAPITAL LETTER Z WITH ACUTE
+0x017A, "zacute"  # LATIN SMALL LETTER Z WITH ACUTE
+0x017B, "Zdotaccent"  # LATIN CAPITAL LETTER Z WITH DOT ABOVE
+0x017C, "zdotaccent"  # LATIN SMALL LETTER Z WITH DOT ABOVE
+0x017D, "Zcaron"  # LATIN CAPITAL LETTER Z WITH CARON
+0x017E, "zcaron"  # LATIN SMALL LETTER Z WITH CARON
+0x017F, "longs"  # LATIN SMALL LETTER LONG S
+0x0192, "florin"  # LATIN SMALL LETTER F WITH HOOK
+0x01A0, "Ohorn"  # LATIN CAPITAL LETTER O WITH HORN
+0x01A1, "ohorn"  # LATIN SMALL LETTER O WITH HORN
+0x01AF, "Uhorn"  # LATIN CAPITAL LETTER U WITH HORN
+0x01B0, "uhorn"  # LATIN SMALL LETTER U WITH HORN
+0x01E6, "Gcaron"  # LATIN CAPITAL LETTER G WITH CARON
+0x01E7, "gcaron"  # LATIN SMALL LETTER G WITH CARON
+0x01FA, "Aringacute"  # LATIN CAPITAL LETTER A WITH RING ABOVE AND ACUTE
+0x01FB, "aringacute"  # LATIN SMALL LETTER A WITH RING ABOVE AND ACUTE
+0x01FC, "AEacute"  # LATIN CAPITAL LETTER AE WITH ACUTE
+0x01FD, "aeacute"  # LATIN SMALL LETTER AE WITH ACUTE
+0x01FE, "Oslashacute"  # LATIN CAPITAL LETTER O WITH STROKE AND ACUTE
+0x01FF, "oslashacute"  # LATIN SMALL LETTER O WITH STROKE AND ACUTE
+0x0218, "Scommaaccent"  # LATIN CAPITAL LETTER S WITH COMMA BELOW
+0x0219, "scommaaccent"  # LATIN SMALL LETTER S WITH COMMA BELOW
+0x021A, "Tcommaaccent"  # LATIN CAPITAL LETTER T WITH COMMA BELOW
+0x021B, "tcommaaccent"  # LATIN SMALL LETTER T WITH COMMA BELOW
+0x02BC, "afii57929"  # MODIFIER LETTER APOSTROPHE
+0x02BD, "afii64937"  # MODIFIER LETTER REVERSED COMMA
+0x02C6, "circumflex"  # MODIFIER LETTER CIRCUMFLEX ACCENT
+0x02C7, "caron"  # CARON
+0x02D8, "breve"  # BREVE
+0x02D9, "dotaccent"  # DOT ABOVE
+0x02DA, "ring"  # RING ABOVE
+0x02DB, "ogonek"  # OGONEK
+0x02DC, "tilde"  # SMALL TILDE
+0x02DD, "hungarumlaut"  # DOUBLE ACUTE ACCENT
+0x0300, "gravecomb"  # COMBINING GRAVE ACCENT
+0x0301, "acutecomb"  # COMBINING ACUTE ACCENT
+0x0303, "tildecomb"  # COMBINING TILDE
+0x0309, "hookabovecomb"  # COMBINING HOOK ABOVE
+0x0323, "dotbelowcomb"  # COMBINING DOT BELOW
+0x0384, "tonos"  # GREEK TONOS
+0x0385, "dieresistonos"  # GREEK DIALYTIKA TONOS
+0x0386, "Alphatonos"  # GREEK CAPITAL LETTER ALPHA WITH TONOS
+0x0387, "anoteleia"  # GREEK ANO TELEIA
+0x0388, "Epsilontonos"  # GREEK CAPITAL LETTER EPSILON WITH TONOS
+0x0389, "Etatonos"  # GREEK CAPITAL LETTER ETA WITH TONOS
+0x038A, "Iotatonos"  # GREEK CAPITAL LETTER IOTA WITH TONOS
+0x038C, "Omicrontonos"  # GREEK CAPITAL LETTER OMICRON WITH TONOS
+0x038E, "Upsilontonos"  # GREEK CAPITAL LETTER UPSILON WITH TONOS
+0x038F, "Omegatonos"  # GREEK CAPITAL LETTER OMEGA WITH TONOS
+0x0390, "iotadieresistonos"  # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS
+0x0391, "Alpha"  # GREEK CAPITAL LETTER ALPHA
+0x0392, "Beta"  # GREEK CAPITAL LETTER BETA
+0x0393, "Gamma"  # GREEK CAPITAL LETTER GAMMA
+0x0394, "Delta"  # GREEK CAPITAL LETTER DELTA
+0x0395, "Epsilon"  # GREEK CAPITAL LETTER EPSILON
+0x0396, "Zeta"  # GREEK CAPITAL LETTER ZETA
+0x0397, "Eta"  # GREEK CAPITAL LETTER ETA
+0x0398, "Theta"  # GREEK CAPITAL LETTER THETA
+0x0399, "Iota"  # GREEK CAPITAL LETTER IOTA
+0x039A, "Kappa"  # GREEK CAPITAL LETTER KAPPA
+0x039B, "Lambda"  # GREEK CAPITAL LETTER LAMDA
+0x039C, "Mu"  # GREEK CAPITAL LETTER MU
+0x039D, "Nu"  # GREEK CAPITAL LETTER NU
+0x039E, "Xi"  # GREEK CAPITAL LETTER XI
+0x039F, "Omicron"  # GREEK CAPITAL LETTER OMICRON
+0x03A0, "Pi"  # GREEK CAPITAL LETTER PI
+0x03A1, "Rho"  # GREEK CAPITAL LETTER RHO
+0x03A3, "Sigma"  # GREEK CAPITAL LETTER SIGMA
+0x03A4, "Tau"  # GREEK CAPITAL LETTER TAU
+0x03A5, "Upsilon"  # GREEK CAPITAL LETTER UPSILON
+0x03A6, "Phi"  # GREEK CAPITAL LETTER PHI
+0x03A7, "Chi"  # GREEK CAPITAL LETTER CHI
+0x03A8, "Psi"  # GREEK CAPITAL LETTER PSI
+0x03A9, "Omega"  # GREEK CAPITAL LETTER OMEGA
+0x03AA, "Iotadieresis"  # GREEK CAPITAL LETTER IOTA WITH DIALYTIKA
+0x03AB, "Upsilondieresis"  # GREEK CAPITAL LETTER UPSILON WITH DIALYTIKA
+0x03AC, "alphatonos"  # GREEK SMALL LETTER ALPHA WITH TONOS
+0x03AD, "epsilontonos"  # GREEK SMALL LETTER EPSILON WITH TONOS
+0x03AE, "etatonos"  # GREEK SMALL LETTER ETA WITH TONOS
+0x03AF, "iotatonos"  # GREEK SMALL LETTER IOTA WITH TONOS
+0x03B0, "upsilondieresistonos"  # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS
+0x03B1, "alpha"  # GREEK SMALL LETTER ALPHA
+0x03B2, "beta"  # GREEK SMALL LETTER BETA
+0x03B3, "gamma"  # GREEK SMALL LETTER GAMMA
+0x03B4, "delta"  # GREEK SMALL LETTER DELTA
+0x03B5, "epsilon"  # GREEK SMALL LETTER EPSILON
+0x03B6, "zeta"  # GREEK SMALL LETTER ZETA
+0x03B7, "eta"  # GREEK SMALL LETTER ETA
+0x03B8, "theta"  # GREEK SMALL LETTER THETA
+0x03B9, "iota"  # GREEK SMALL LETTER IOTA
+0x03BA, "kappa"  # GREEK SMALL LETTER KAPPA
+0x03BB, "lambda"  # GREEK SMALL LETTER LAMDA
+0x03BC, "mu"  # GREEK SMALL LETTER MU;Duplicate
+0x03BD, "nu"  # GREEK SMALL LETTER NU
+0x03BE, "xi"  # GREEK SMALL LETTER XI
+0x03BF, "omicron"  # GREEK SMALL LETTER OMICRON
+0x03C0, "pi"  # GREEK SMALL LETTER PI
+0x03C1, "rho"  # GREEK SMALL LETTER RHO
+0x03C2, "sigma1"  # GREEK SMALL LETTER FINAL SIGMA
+0x03C3, "sigma"  # GREEK SMALL LETTER SIGMA
+0x03C4, "tau"  # GREEK SMALL LETTER TAU
+0x03C5, "upsilon"  # GREEK SMALL LETTER UPSILON
+0x03C6, "phi"  # GREEK SMALL LETTER PHI
+0x03C7, "chi"  # GREEK SMALL LETTER CHI
+0x03C8, "psi"  # GREEK SMALL LETTER PSI
+0x03C9, "omega"  # GREEK SMALL LETTER OMEGA
+0x03CA, "iotadieresis"  # GREEK SMALL LETTER IOTA WITH DIALYTIKA
+0x03CB, "upsilondieresis"  # GREEK SMALL LETTER UPSILON WITH DIALYTIKA
+0x03CC, "omicrontonos"  # GREEK SMALL LETTER OMICRON WITH TONOS
+0x03CD, "upsilontonos"  # GREEK SMALL LETTER UPSILON WITH TONOS
+0x03CE, "omegatonos"  # GREEK SMALL LETTER OMEGA WITH TONOS
+0x03D1, "theta1"  # GREEK THETA SYMBOL
+0x03D2, "Upsilon1"  # GREEK UPSILON WITH HOOK SYMBOL
+0x03D5, "phi1"  # GREEK PHI SYMBOL
+0x03D6, "omega1"  # GREEK PI SYMBOL
+# end of stuff from glyphlist.txt
+0xFFFF, ""
diff --git a/src/gui/painting/qpsprinter.ps b/src/gui/painting/qpsprinter.ps
new file mode 100644
index 0000000000..ef3f42970b
--- /dev/null
+++ b/src/gui/painting/qpsprinter.ps
@@ -0,0 +1,449 @@
+% the postscript header we use for our qpsprinter in uncompressed and commented form.
+% use the makepsheader perl script to generate a compressed version of this header
+% you can then paste into qpsprinter.cpp
+%
+% some compression of the code is done by the makepsheader script, so we don't need to 
+% write too criptically here. 
+
+/BD  {bind def} bind def
+/d2 {dup dup} BD
+/ED {exch def} BD
+/D0 {0 ED} BD
+
+/F  {setfont} BD
+/RL {rlineto} BD
+/CM {currentmatrix} BD
+/SM {setmatrix} BD
+/TR {translate} BD
+/SD {setdash} BD
+/SC {aload pop setrgbcolor} BD
+/CR {currentfile read pop} BD
+/i  {index} BD
+/scs {setcolorspace} BD
+/DB {dict dup begin} BD
+/DE {end def} BD
+/ie {ifelse} BD
+/gs {gsave} BD
+/gr {grestore} BD
+
+% these use PDF syntax
+/w {setlinewidth} BD
+/d {setdash} BD
+/J {setlinecap} BD
+/j {setlinejoin} BD
+/scn {3 array astore /BCol exch def} BD
+/SCN {3 array astore /PCol exch def} BD
+/cm {6 array astore concat} BD
+
+/m  {moveto} BD
+/l  {lineto} BD
+/c  {curveto} BD
+/h  {closepath} BD
+
+/W  {clip} BD
+/W* {eoclip} BD
+/n {newpath} BD
+% ENDUNCOMPRESSED: Warning: leave this line in. 
+% Everything before this line will be left untouched by the compression
+
+/q  {gsave 10 dict begin} BD
+/Q  {end grestore} BD
+
+% PDF operators
+/re { % PDF re operator
+  4 2 roll  % w h x y
+  moveto % w h
+  dup % w h h
+  0 exch rlineto % w h
+  exch 0 rlineto % h
+  0 exch neg rlineto
+  closepath
+} bind def
+
+/S {
+  gsave
+    PCol SC stroke
+  grestore
+  newpath
+} BD
+
+% PDF text operators
+/BT {gsave 10 dict begin /_m matrix currentmatrix def BCol SC} BD
+/ET {end grestore} BD
+/Tf {
+  /_fs exch def
+  findfont
+  [ _fs 0 0 _fs 0 0 ]  
+  makefont
+  setfont
+} BD
+/Tm {6 array astore concat} BD
+/Td {translate} BD
+/Tj {0 0 moveto show} BD
+/BDC {pop pop} BD
+/EMC {} BD
+
+% old operators
+
+/BSt 0 def                             % brush style
+/WFi false def                 % winding fill
+
+/BCol  [ 1 1 1 ] def                   % brush color
+/PCol  [ 0 0 0 ] def                   % pen color
+/BDArr [                             % Brush dense patterns
+  0.94
+  0.88
+  0.63
+  0.50
+  0.37 
+  0.12 
+  0.06 
+] def
+
+% -- level3 true/false
+/level3 {
+  /languagelevel where {
+    pop
+    languagelevel 3 ge 
+  } { false } ifelse
+} bind def
+
+
+%% image drawing routines
+
+% defines for QCI
+/QCIgray D0 /QCIcolor D0 /QCIindex D0
+
+% this method prints color images if colorimage is available, otherwise
+% converts the string to a grayscale image and uses the reular postscript image
+% operator for printing.
+% Arguments are the same as for the image operator:
+% 
+%     width height bits/sample matrix datasrc QCI -
+/QCI {
+  /colorimage where {
+    pop
+    false 3 colorimage
+  }{  % the hard way, based on PD code by John Walker <kelvin@autodesk.com>
+    exec /QCIcolor exch def
+    /QCIgray QCIcolor length 3 idiv string def
+    0 1 QCIcolor length 3 idiv 1 sub
+    { /QCIindex exch def
+      /_x QCIindex 3 mul def
+      QCIgray QCIindex
+      QCIcolor _x       get 0.30 mul
+      QCIcolor _x 1 add get 0.59 mul
+      QCIcolor _x 2 add get 0.11 mul
+      add add cvi
+      put
+    } for
+    QCIgray image
+  } ifelse
+} bind def
+
+% general image drawing routine, used from the postscript driver
+%
+% Draws images with and without mask with 1, 8 and 24(rgb) bits depth.
+%
+%     width height matrix image 1|8|24 mask|false x y di
+%
+% width and height specify the width/height of the image,
+% matrix a transformation matrix, image a procedure holding the image data
+% (same for mask) and x/y an additional translation.
+%
+% ### should move the translation into the matrix!!!
+/di 
+{
+  gsave
+    translate
+    1 index 1 eq { % bitmap
+      pop pop % get rid of mask and depth
+      false 3 1 roll % width height false matrix image
+      BCol SC
+      imagemask
+    } { 
+      dup false ne { 
+	% have a mask, see if we can use it
+	level3
+      } { 
+	false 
+      } ifelse
+
+      {
+	% languagelevel3, we can use image mask and dicts
+
+	% store the image mask
+	/_ma exch def
+	% select colorspace according to 8|24 bit depth and set the decode array /dc
+	8 eq {
+	  /_dc [0 1] def
+	  /DeviceGray
+	} {
+	  /_dc [0 1 0 1 0 1] def
+	  /DeviceRGB
+	} ifelse
+	setcolorspace
+	% the image data
+	/_im exch def
+	% transformation matrix
+	/_mt exch def
+	% width and height
+	/_h exch def
+	/_w exch def
+	% and the combined image dict
+	<<
+	  /ImageType 3
+	  % the image dict
+	  /DataDict <<
+              /ImageType 1
+	      /Width _w
+	      /Height _h
+	      /ImageMatrix _mt
+	      /DataSource _im
+	      /BitsPerComponent 8
+	      /Decode _dc
+	  >> 
+	  % the mask dictionary
+	  /MaskDict <<
+             /ImageType 1
+	     /Width _w
+	     /Height _h
+	     /ImageMatrix _mt
+	     /DataSource _ma
+	     /BitsPerComponent 1
+	     /Decode [0 1]
+	  >> 
+	  /InterleaveType 3
+	>> 
+	image
+      } {
+	pop % no mask or can't use it, get rid of it
+	8 % width height image 8|24 8 matrix
+	4 1 roll
+	8 eq { % grayscale
+	  image
+	} { %color
+	  QCI
+	} ifelse
+      } ifelse
+    } ifelse
+  grestore    
+} bind def
+
+
+/BF {                                % brush fill
+  gsave
+    BSt 1 eq                          % solid brush?
+    {
+      BCol SC
+      WFi { fill } { eofill } ifelse
+    } if
+    BSt 2 ge BSt 8 le and             % dense pattern?
+    {
+      BDArr BSt 2 sub get /_sc exch def 
+      % the following line scales the brush color according to the pattern. the higher the pattern the lighter the color.
+      BCol 
+      { 
+	1. exch sub _sc mul 1. exch sub 
+      } forall 
+      3 array astore
+      SC 
+      WFi { fill } { eofill } ifelse
+    } if
+    BSt 9 ge BSt 14 le and            % brush pattern?
+    {
+      WFi { clip } { eoclip } ifelse
+      pathbbox                        % left upper right lower
+      3 index 3 index translate
+      4 2 roll                        % right lower left upper
+      3 2 roll                        % right left upper lower
+      exch                            % left right lower upper
+      sub /_h exch def
+      sub /_w exch def
+      BCol SC
+      0.3 setlinewidth
+      newpath
+      BSt 9 eq BSt 11 eq or           % horiz or cross pattern
+      { 0 4 _h
+	{ dup 0 exch moveto _w exch lineto } for
+      } if
+      BSt 10 eq BSt 11 eq or          % vert or cross pattern
+      { 0 4 _w
+	{ dup 0 moveto _h lineto } for
+      } if
+      BSt 12 eq BSt 14 eq or          % F-diag or diag cross
+      { _w _h gt
+	{ 0 6 _w _h add
+	  { dup 0 moveto _h sub _h lineto } for
+	} { 0 6 _w _h add
+	  { dup 0 exch moveto _w sub _w exch lineto } for
+	} ifelse
+      } if
+      BSt 13 eq BSt 14 eq or          % B-diag or diag cross
+      { _w _h gt
+	{ 0 6 _w _h add
+	  { dup _h moveto _h sub 0 lineto } for
+	} { 0 6 _w _h add
+	  { dup _w exch moveto _w sub 0 exch lineto } for
+	} ifelse
+      } if
+      stroke
+    } if
+    BSt 15 eq
+    {
+    } if
+    BSt 24 eq                         % TexturePattern
+    {
+    } if
+  grestore
+} bind def
+
+% more PDF operators
+/f { /WFi true def BF newpath } bind def
+/f* { /WFi false def BF newpath } bind def
+/B { /WFi true def BF S newpath } bind def
+/B* { /WFi false def BF S newpath } bind def
+
+%% start of page
+/QI {
+  /C save def
+  pageinit
+  q
+  newpath
+} bind def
+
+%% end of page
+/QP {
+  Q                                % show page
+  C restore
+  showpage
+} bind def
+
+% merges one key value pair into the page device dict
+%
+%    key value SPD -
+/SPD {
+  /setpagedevice where {
+    << 3 1 roll >>
+    setpagedevice
+  } { pop pop } ifelse
+} bind def
+
+
+% font handling
+
+/T1AddMapping { % basefont [glyphname ...] T1AddMapping -
+  10 dict begin
+    /glyphs exch def
+    /fnt exch def
+    /current fnt /NumGlyphs get def
+    /CMap fnt /CMap get def
+
+    0 1 glyphs length 1 sub % 0 1 (num glyphs - 1)
+    {
+      glyphs exch get /gn exch def
+
+      current dup                                 % glyph_index glyph_index
+      256 mod /min exch def                       % glyph_index
+      256 idiv /maj exch def                      % -
+      CMap dup maj get dup                        % cmap cmap_maj cmap_maj
+      null eq {
+	pop 256 array 
+	0 1 255 {1 index exch /.notdef put} for
+      } if
+      dup                                         % cmap cmap_maj cmap_maj
+      min gn put                                  % cmap cmap_maj
+      maj exch put                                % -
+
+      /current current 1 add def
+    } for
+
+    fnt /CMap CMap put
+    fnt /NumGlyphs current put
+  end 
+} def
+
+/T1AddGlyphs { % basefont [glyphname charstring ...] T1AddGlyphs -
+  10 dict begin
+    /glyphs exch def
+    /fnt exch def
+    /current fnt /NumGlyphs get def
+    /CMap fnt /CMap get def
+    /CharStrings fnt /CharStrings get def
+
+    0 1 glyphs length 2 idiv 1 sub % 0 1 (num glyphs - 1)
+    {
+      2 mul dup
+      glyphs exch get /gn exch def
+      1 add
+      glyphs exch get /cs exch def
+
+      current dup                                 % glyph_index glyph_index
+      256 mod /min exch def                       % glyph_index
+      256 idiv /maj exch def                      % -
+      CMap dup maj get dup                        % cmap cmap_maj cmap_maj
+      null eq {
+	pop 256 array 
+	0 1 255 {1 index exch /.notdef put} for
+      } if
+      dup                                         % cmap cmap_maj cmap_maj
+      min gn put                                  % cmap cmap_maj
+      maj exch put                                % -
+
+      CharStrings gn cs put
+      /current current 1 add def
+    } for
+
+    fnt /CharStrings CharStrings put
+    fnt /CMap CMap put
+    fnt /NumGlyphs current put
+  end 
+} def
+
+
+
+/StringAdd { % string1 string2 stringadd result
+  1 index length 1 index length add
+  string
+  3 1 roll
+  2 index 0 3 index putinterval
+  2 index 2 index length 2 index putinterval 
+  pop pop
+} def
+
+
+/T1Setup { % fontname T1Setup -
+10 dict begin
+  dup /FontName exch def
+  (-Base) StringAdd cvx cvn /Font exch def
+  /MaxPage Font /NumGlyphs get 1 sub 256 idiv def
+
+  /FDepVector MaxPage 1 add array def
+  /Encoding MaxPage 1 add array def
+
+  0 1 MaxPage {
+    dup Encoding exch dup put
+ 
+
+    dup /Page exch def
+    FontName (-) StringAdd 
+    exch 
+    20 string cvs StringAdd % page fontname
+    cvn
+
+    Font 0 dict copy dup dup /CMap get 
+    Page get 
+    /Encoding exch put definefont 
+    FDepVector exch Page exch put
+  } for 
+
+  FontName cvn <<
+    /FontType 0
+    /FMapType 2
+    /FontMatrix[1 0 0 1 0 0]
+    /Encoding Encoding
+    /FDepVector FDepVector
+    >> definefont pop
+  end
+} def
+
diff --git a/src/gui/painting/qrasterdefs_p.h b/src/gui/painting/qrasterdefs_p.h
new file mode 100644
index 0000000000..706064c305
--- /dev/null
+++ b/src/gui/painting/qrasterdefs_p.h
@@ -0,0 +1,1279 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/***************************************************************************/
+/*                                                                         */
+/*  ftimage.h                                                              */
+/*                                                                         */
+/*    FreeType glyph image formats and default raster interface            */
+/*    (specification).                                                     */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003, 2004 by                               */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Note: A `raster' is simply a scan-line converter, used to render      */
+  /*       QT_FT_Outlines into QT_FT_Bitmaps.                                    */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#ifndef __QT_FTIMAGE_H__
+#define __QT_FTIMAGE_H__
+
+/*
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+*/
+
+QT_FT_BEGIN_HEADER
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    basic_types                                                        */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    QT_FT_Pos                                                             */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The type QT_FT_Pos is a 32-bit integer used to store vectorial        */
+  /*    coordinates.  Depending on the context, these can represent        */
+  /*    distances in integer font units, or 16,16, or 26.6 fixed float     */
+  /*    pixel coordinates.                                                 */
+  /*                                                                       */
+  typedef signed int  QT_FT_Pos;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    QT_FT_Vector                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A simple structure used to store a 2D vector; coordinates are of   */
+  /*    the QT_FT_Pos type.                                                   */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    x :: The horizontal coordinate.                                    */
+  /*    y :: The vertical coordinate.                                      */
+  /*                                                                       */
+  typedef struct  QT_FT_Vector_
+  {
+    QT_FT_Pos  x;
+    QT_FT_Pos  y;
+
+  } QT_FT_Vector;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    QT_FT_BBox                                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to hold an outline's bounding box, i.e., the      */
+  /*    coordinates of its extrema in the horizontal and vertical          */
+  /*    directions.                                                        */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    xMin :: The horizontal minimum (left-most).                        */
+  /*                                                                       */
+  /*    yMin :: The vertical minimum (bottom-most).                        */
+  /*                                                                       */
+  /*    xMax :: The horizontal maximum (right-most).                       */
+  /*                                                                       */
+  /*    yMax :: The vertical maximum (top-most).                           */
+  /*                                                                       */
+  typedef struct  QT_FT_BBox_
+  {
+    QT_FT_Pos  xMin, yMin;
+    QT_FT_Pos  xMax, yMax;
+
+  } QT_FT_BBox;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Enum>                                                                */
+  /*    QT_FT_Pixel_Mode                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    An enumeration type used to describe the format of pixels in a     */
+  /*    given bitmap.  Note that additional formats may be added in the    */
+  /*    future.                                                            */
+  /*                                                                       */
+  /* <Values>                                                              */
+  /*    QT_FT_PIXEL_MODE_NONE ::                                              */
+  /*      Value 0 is reserved.                                             */
+  /*                                                                       */
+  /*    QT_FT_PIXEL_MODE_MONO ::                                              */
+  /*      A monochrome bitmap, using 1 bit per pixel.  Note that pixels    */
+  /*      are stored in most-significant order (MSB), which means that     */
+  /*      the left-most pixel in a byte has value 128.                     */
+  /*                                                                       */
+  /*    QT_FT_PIXEL_MODE_GRAY ::                                              */
+  /*      An 8-bit bitmap, generally used to represent anti-aliased glyph  */
+  /*      images.  Each pixel is stored in one byte.  Note that the number */
+  /*      of value "gray" levels is stored in the `num_bytes' field of     */
+  /*      the @QT_FT_Bitmap structure (it generally is 256).                  */
+  /*                                                                       */
+  /*    QT_FT_PIXEL_MODE_GRAY2 ::                                             */
+  /*      A 2-bit/pixel bitmap, used to represent embedded anti-aliased    */
+  /*      bitmaps in font files according to the OpenType specification.   */
+  /*      We haven't found a single font using this format, however.       */
+  /*                                                                       */
+  /*    QT_FT_PIXEL_MODE_GRAY4 ::                                             */
+  /*      A 4-bit/pixel bitmap, used to represent embedded anti-aliased    */
+  /*      bitmaps in font files according to the OpenType specification.   */
+  /*      We haven't found a single font using this format, however.       */
+  /*                                                                       */
+  /*    QT_FT_PIXEL_MODE_LCD ::                                               */
+  /*      An 8-bit bitmap, used to represent RGB or BGR decimated glyph    */
+  /*      images used for display on LCD displays; the bitmap's width is   */
+  /*      three times wider than the original glyph image.  See also       */
+  /*      @QT_FT_RENDER_MODE_LCD.                                             */
+  /*                                                                       */
+  /*    QT_FT_PIXEL_MODE_LCD_V ::                                             */
+  /*      An 8-bit bitmap, used to represent RGB or BGR decimated glyph    */
+  /*      images used for display on rotated LCD displays; the bitmap's    */
+  /*      height is three times taller than the original glyph image.      */
+  /*      See also @QT_FT_RENDER_MODE_LCD_V.                                  */
+  /*                                                                       */
+  typedef enum  QT_FT_Pixel_Mode_
+  {
+    QT_FT_PIXEL_MODE_NONE = 0,
+    QT_FT_PIXEL_MODE_MONO,
+    QT_FT_PIXEL_MODE_GRAY,
+    QT_FT_PIXEL_MODE_GRAY2,
+    QT_FT_PIXEL_MODE_GRAY4,
+    QT_FT_PIXEL_MODE_LCD,
+    QT_FT_PIXEL_MODE_LCD_V,
+
+    QT_FT_PIXEL_MODE_MAX      /* do not remove */
+
+  } QT_FT_Pixel_Mode;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Enum>                                                                */
+  /*    qt_ft_pixel_mode_xxx                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A list of deprecated constants.  Use the corresponding             */
+  /*    @QT_FT_Pixel_Mode values instead.                                     */
+  /*                                                                       */
+  /* <Values>                                                              */
+  /*    qt_ft_pixel_mode_none  :: see @QT_FT_PIXEL_MODE_NONE                     */
+  /*    qt_ft_pixel_mode_mono  :: see @QT_FT_PIXEL_MODE_MONO                     */
+  /*    qt_ft_pixel_mode_grays :: see @QT_FT_PIXEL_MODE_GRAY                     */
+  /*    qt_ft_pixel_mode_pal2  :: see @QT_FT_PIXEL_MODE_GRAY2                    */
+  /*    qt_ft_pixel_mode_pal4  :: see @QT_FT_PIXEL_MODE_GRAY4                    */
+  /*                                                                       */
+#define qt_ft_pixel_mode_none   QT_FT_PIXEL_MODE_NONE
+#define qt_ft_pixel_mode_mono   QT_FT_PIXEL_MODE_MONO
+#define qt_ft_pixel_mode_grays  QT_FT_PIXEL_MODE_GRAY
+#define qt_ft_pixel_mode_pal2   QT_FT_PIXEL_MODE_GRAY2
+#define qt_ft_pixel_mode_pal4   QT_FT_PIXEL_MODE_GRAY4
+
+ /* */
+
+#if 0
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Enum>                                                                */
+  /*    QT_FT_Palette_Mode                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    THIS TYPE IS DEPRECATED.  DO NOT USE IT!                           */
+  /*                                                                       */
+  /*    An enumeration type used to describe the format of a bitmap        */
+  /*    palette, used with qt_ft_pixel_mode_pal4 and qt_ft_pixel_mode_pal8.      */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    qt_ft_palette_mode_rgb  :: The palette is an array of 3-bytes RGB     */
+  /*                            records.                                   */
+  /*                                                                       */
+  /*    qt_ft_palette_mode_rgba :: The palette is an array of 4-bytes RGBA    */
+  /*                            records.                                   */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    As qt_ft_pixel_mode_pal2, pal4 and pal8 are currently unused by       */
+  /*    FreeType, these types are not handled by the library itself.       */
+  /*                                                                       */
+  typedef enum  QT_FT_Palette_Mode_
+  {
+    qt_ft_palette_mode_rgb = 0,
+    qt_ft_palette_mode_rgba,
+
+    qt_ft_palettte_mode_max   /* do not remove */
+
+  } QT_FT_Palette_Mode;
+
+  /* */
+
+#endif
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    QT_FT_Bitmap                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to describe a bitmap or pixmap to the raster.     */
+  /*    Note that we now manage pixmaps of various depths through the      */
+  /*    `pixel_mode' field.                                                */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    rows         :: The number of bitmap rows.                         */
+  /*                                                                       */
+  /*    width        :: The number of pixels in bitmap row.                */
+  /*                                                                       */
+  /*    pitch        :: The pitch's absolute value is the number of bytes  */
+  /*                    taken by one bitmap row, including padding.        */
+  /*                    However, the pitch is positive when the bitmap has */
+  /*                    a `down' flow, and negative when it has an `up'    */
+  /*                    flow.  In all cases, the pitch is an offset to add */
+  /*                    to a bitmap pointer in order to go down one row.   */
+  /*                                                                       */
+  /*    buffer       :: A typeless pointer to the bitmap buffer.  This     */
+  /*                    value should be aligned on 32-bit boundaries in    */
+  /*                    most cases.                                        */
+  /*                                                                       */
+  /*    num_grays    :: This field is only used with                       */
+  /*                    `QT_FT_PIXEL_MODE_GRAY'; it gives the number of gray  */
+  /*                    levels used in the bitmap.                         */
+  /*                                                                       */
+  /*    pixel_mode   :: The pixel mode, i.e., how pixel bits are stored.   */
+  /*                    See @QT_FT_Pixel_Mode for possible values.            */
+  /*                                                                       */
+  /*    palette_mode :: This field is only used with paletted pixel modes; */
+  /*                    it indicates how the palette is stored.            */
+  /*                                                                       */
+  /*    palette      :: A typeless pointer to the bitmap palette; only     */
+  /*                    used for paletted pixel modes.                     */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*   For now, the only pixel mode supported by FreeType are mono and     */
+  /*   grays.  However, drivers might be added in the future to support    */
+  /*   more `colorful' options.                                            */
+  /*                                                                       */
+  /*   When using pixel modes pal2, pal4 and pal8 with a void `palette'    */
+  /*   field, a gray pixmap with respectively 4, 16, and 256 levels of     */
+  /*   gray is assumed.  This, in order to be compatible with some         */
+  /*   embedded bitmap formats defined in the TrueType specification.      */
+  /*                                                                       */
+  /*   Note that no font was found presenting such embedded bitmaps, so    */
+  /*   this is currently completely unhandled by the library.              */
+  /*                                                                       */
+  typedef struct  QT_FT_Bitmap_
+  {
+    int             rows;
+    int             width;
+    int             pitch;
+    unsigned char*  buffer;
+    short           num_grays;
+    char            pixel_mode;
+    char            palette_mode;
+    void*           palette;
+
+  } QT_FT_Bitmap;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    outline_processing                                                 */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    QT_FT_Outline                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This structure is used to describe an outline to the scan-line     */
+  /*    converter.                                                         */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    n_contours :: The number of contours in the outline.               */
+  /*                                                                       */
+  /*    n_points   :: The number of points in the outline.                 */
+  /*                                                                       */
+  /*    points     :: A pointer to an array of `n_points' QT_FT_Vector        */
+  /*                  elements, giving the outline's point coordinates.    */
+  /*                                                                       */
+  /*    tags       :: A pointer to an array of `n_points' chars, giving    */
+  /*                  each outline point's type.  If bit 0 is unset, the   */
+  /*                  point is `off' the curve, i.e. a Bezier control      */
+  /*                  point, while it is `on' when set.                    */
+  /*                                                                       */
+  /*                  Bit 1 is meaningful for `off' points only.  If set,  */
+  /*                  it indicates a third-order Bezier arc control point; */
+  /*                  and a second-order control point if unset.           */
+  /*                                                                       */
+  /*    contours   :: An array of `n_contours' shorts, giving the end      */
+  /*                  point of each contour within the outline.  For       */
+  /*                  example, the first contour is defined by the points  */
+  /*                  `0' to `contours[0]', the second one is defined by   */
+  /*                  the points `contours[0]+1' to `contours[1]', etc.    */
+  /*                                                                       */
+  /*    flags      :: A set of bit flags used to characterize the outline  */
+  /*                  and give hints to the scan-converter and hinter on   */
+  /*                  how to convert/grid-fit it.  See QT_FT_Outline_Flags.   */
+  /*                                                                       */
+  typedef struct  QT_FT_Outline_
+  {
+    int       n_contours;      /* number of contours in glyph        */
+    int       n_points;        /* number of points in the glyph      */
+
+    QT_FT_Vector*  points;          /* the outline's points               */
+    char*       tags;            /* the points flags                   */
+    int*      contours;        /* the contour end points             */
+
+    int         flags;           /* outline masks                      */
+
+  } QT_FT_Outline;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Enum>                                                                */
+  /*   QT_FT_OUTLINE_FLAGS                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A list of bit-field constants use for the flags in an outline's    */
+  /*    `flags' field.                                                     */
+  /*                                                                       */
+  /* <Values>                                                              */
+  /*    QT_FT_OUTLINE_NONE           :: Value 0 is reserved.                  */
+  /*                                                                       */
+  /*    QT_FT_OUTLINE_OWNER          :: If set, this flag indicates that the  */
+  /*                                 outline's field arrays (i.e.          */
+  /*                                 `points', `flags' & `contours') are   */
+  /*                                 `owned' by the outline object, and    */
+  /*                                 should thus be freed when it is       */
+  /*                                 destroyed.                            */
+  /*                                                                       */
+  /*   QT_FT_OUTLINE_EVEN_ODD_FILL   :: By default, outlines are filled using */
+  /*                                 the non-zero winding rule.  If set to */
+  /*                                 1, the outline will be filled using   */
+  /*                                 the even-odd fill rule (only works    */
+  /*                                 with the smooth raster).              */
+  /*                                                                       */
+  /*   QT_FT_OUTLINE_REVERSE_FILL    :: By default, outside contours of an    */
+  /*                                 outline are oriented in clock-wise    */
+  /*                                 direction, as defined in the TrueType */
+  /*                                 specification.  This flag is set if   */
+  /*                                 the outline uses the opposite         */
+  /*                                 direction (typically for Type 1       */
+  /*                                 fonts).  This flag is ignored by the  */
+  /*                                 scan-converter.  However, it is very  */
+  /*                                 important for the auto-hinter.        */
+  /*                                                                       */
+  /*   QT_FT_OUTLINE_IGNORE_DROPOUTS :: By default, the scan converter will   */
+  /*                                 try to detect drop-outs in an outline */
+  /*                                 and correct the glyph bitmap to       */
+  /*                                 ensure consistent shape continuity.   */
+  /*                                 If set, this flag hints the scan-line */
+  /*                                 converter to ignore such cases.       */
+  /*                                                                       */
+  /*   QT_FT_OUTLINE_HIGH_PRECISION  :: This flag indicates that the          */
+  /*                                 scan-line converter should try to     */
+  /*                                 convert this outline to bitmaps with  */
+  /*                                 the highest possible quality.  It is  */
+  /*                                 typically set for small character     */
+  /*                                 sizes.  Note that this is only a      */
+  /*                                 hint, that might be completely        */
+  /*                                 ignored by a given scan-converter.    */
+  /*                                                                       */
+  /*   QT_FT_OUTLINE_SINGLE_PASS     :: This flag is set to force a given     */
+  /*                                 scan-converter to only use a single   */
+  /*                                 pass over the outline to render a     */
+  /*                                 bitmap glyph image.  Normally, it is  */
+  /*                                 set for very large character sizes.   */
+  /*                                 It is only a hint, that might be      */
+  /*                                 completely ignored by a given         */
+  /*                                 scan-converter.                       */
+  /*                                                                       */
+#define QT_FT_OUTLINE_NONE             0x0
+#define QT_FT_OUTLINE_OWNER            0x1
+#define QT_FT_OUTLINE_EVEN_ODD_FILL    0x2
+#define QT_FT_OUTLINE_REVERSE_FILL     0x4
+#define QT_FT_OUTLINE_IGNORE_DROPOUTS  0x8
+
+#define QT_FT_OUTLINE_HIGH_PRECISION   0x100
+#define QT_FT_OUTLINE_SINGLE_PASS      0x200
+
+
+ /*************************************************************************
+  *
+  * @enum:
+  *   qt_ft_outline_flags
+  *
+  * @description:
+  *   These constants are deprecated.  Please use the corresponding
+  *   @QT_FT_OUTLINE_FLAGS values.
+  *
+  * @values:
+  *   qt_ft_outline_none            :: See @QT_FT_OUTLINE_NONE.
+  *   qt_ft_outline_owner           :: See @QT_FT_OUTLINE_OWNER.
+  *   qt_ft_outline_even_odd_fill   :: See @QT_FT_OUTLINE_EVEN_ODD_FILL.
+  *   qt_ft_outline_reverse_fill    :: See @QT_FT_OUTLINE_REVERSE_FILL.
+  *   qt_ft_outline_ignore_dropouts :: See @QT_FT_OUTLINE_IGNORE_DROPOUTS.
+  *   qt_ft_outline_high_precision  :: See @QT_FT_OUTLINE_HIGH_PRECISION.
+  *   qt_ft_outline_single_pass     :: See @QT_FT_OUTLINE_SINGLE_PASS.
+  */
+#define qt_ft_outline_none             QT_FT_OUTLINE_NONE
+#define qt_ft_outline_owner            QT_FT_OUTLINE_OWNER
+#define qt_ft_outline_even_odd_fill    QT_FT_OUTLINE_EVEN_ODD_FILL
+#define qt_ft_outline_reverse_fill     QT_FT_OUTLINE_REVERSE_FILL
+#define qt_ft_outline_ignore_dropouts  QT_FT_OUTLINE_IGNORE_DROPOUTS
+#define qt_ft_outline_high_precision   QT_FT_OUTLINE_HIGH_PRECISION
+#define qt_ft_outline_single_pass      QT_FT_OUTLINE_SINGLE_PASS
+
+  /* */
+
+#define QT_FT_CURVE_TAG( flag )  ( flag & 3 )
+
+#define QT_FT_CURVE_TAG_ON           1
+#define QT_FT_CURVE_TAG_CONIC        0
+#define QT_FT_CURVE_TAG_CUBIC        2
+
+#define QT_FT_CURVE_TAG_TOUCH_X      8  /* reserved for the TrueType hinter */
+#define QT_FT_CURVE_TAG_TOUCH_Y     16  /* reserved for the TrueType hinter */
+
+#define QT_FT_CURVE_TAG_TOUCH_BOTH  ( QT_FT_CURVE_TAG_TOUCH_X | \
+                                   QT_FT_CURVE_TAG_TOUCH_Y )
+
+#define  QT_FT_Curve_Tag_On       QT_FT_CURVE_TAG_ON
+#define  QT_FT_Curve_Tag_Conic    QT_FT_CURVE_TAG_CONIC
+#define  QT_FT_Curve_Tag_Cubic    QT_FT_CURVE_TAG_CUBIC
+#define  QT_FT_Curve_Tag_Touch_X  QT_FT_CURVE_TAG_TOUCH_X
+#define  QT_FT_Curve_Tag_Touch_Y  QT_FT_CURVE_TAG_TOUCH_Y
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    QT_FT_Outline_MoveToFunc                                              */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A function pointer type used to describe the signature of a `move  */
+  /*    to' function during outline walking/decomposition.                 */
+  /*                                                                       */
+  /*    A `move to' is emitted to start a new contour in an outline.       */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    to   :: A pointer to the target point of the `move to'.            */
+  /*                                                                       */
+  /*    user :: A typeless pointer which is passed from the caller of the  */
+  /*            decomposition function.                                    */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Error code.  0 means success.                                      */
+  /*                                                                       */
+  typedef int
+  (*QT_FT_Outline_MoveToFunc)( QT_FT_Vector*  to,
+                            void*       user );
+
+#define QT_FT_Outline_MoveTo_Func  QT_FT_Outline_MoveToFunc
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    QT_FT_Outline_LineToFunc                                              */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A function pointer type used to describe the signature of a `line  */
+  /*    to' function during outline walking/decomposition.                 */
+  /*                                                                       */
+  /*    A `line to' is emitted to indicate a segment in the outline.       */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    to   :: A pointer to the target point of the `line to'.            */
+  /*                                                                       */
+  /*    user :: A typeless pointer which is passed from the caller of the  */
+  /*            decomposition function.                                    */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Error code.  0 means success.                                      */
+  /*                                                                       */
+  typedef int
+  (*QT_FT_Outline_LineToFunc)( QT_FT_Vector*  to,
+                            void*       user );
+
+#define  QT_FT_Outline_LineTo_Func  QT_FT_Outline_LineToFunc
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    QT_FT_Outline_ConicToFunc                                             */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A function pointer type use to describe the signature of a `conic  */
+  /*    to' function during outline walking/decomposition.                 */
+  /*                                                                       */
+  /*    A `conic to' is emitted to indicate a second-order Bezier arc in   */
+  /*    the outline.                                                       */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    control :: An intermediate control point between the last position */
+  /*               and the new target in `to'.                             */
+  /*                                                                       */
+  /*    to      :: A pointer to the target end point of the conic arc.     */
+  /*                                                                       */
+  /*    user    :: A typeless pointer which is passed from the caller of   */
+  /*               the decomposition function.                             */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Error code.  0 means success.                                      */
+  /*                                                                       */
+  typedef int
+  (*QT_FT_Outline_ConicToFunc)( QT_FT_Vector*  control,
+                             QT_FT_Vector*  to,
+                             void*       user );
+
+#define  QT_FT_Outline_ConicTo_Func  QT_FT_Outline_ConicToFunc
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    QT_FT_Outline_CubicToFunc                                             */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A function pointer type used to describe the signature of a `cubic */
+  /*    to' function during outline walking/decomposition.                 */
+  /*                                                                       */
+  /*    A `cubic to' is emitted to indicate a third-order Bezier arc.      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    control1 :: A pointer to the first Bezier control point.           */
+  /*                                                                       */
+  /*    control2 :: A pointer to the second Bezier control point.          */
+  /*                                                                       */
+  /*    to       :: A pointer to the target end point.                     */
+  /*                                                                       */
+  /*    user     :: A typeless pointer which is passed from the caller of  */
+  /*                the decomposition function.                            */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Error code.  0 means success.                                      */
+  /*                                                                       */
+  typedef int
+  (*QT_FT_Outline_CubicToFunc)( QT_FT_Vector*  control1,
+                             QT_FT_Vector*  control2,
+                             QT_FT_Vector*  to,
+                             void*       user );
+
+#define  QT_FT_Outline_CubicTo_Func  QT_FT_Outline_CubicToFunc
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    QT_FT_Outline_Funcs                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure to hold various function pointers used during outline  */
+  /*    decomposition in order to emit segments, conic, and cubic Beziers, */
+  /*    as well as `move to' and `close to' operations.                    */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    move_to  :: The `move to' emitter.                                 */
+  /*                                                                       */
+  /*    line_to  :: The segment emitter.                                   */
+  /*                                                                       */
+  /*    conic_to :: The second-order Bezier arc emitter.                   */
+  /*                                                                       */
+  /*    cubic_to :: The third-order Bezier arc emitter.                    */
+  /*                                                                       */
+  /*    shift    :: The shift that is applied to coordinates before they   */
+  /*                are sent to the emitter.                               */
+  /*                                                                       */
+  /*    delta    :: The delta that is applied to coordinates before they   */
+  /*                are sent to the emitter, but after the shift.          */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The point coordinates sent to the emitters are the transformed     */
+  /*    version of the original coordinates (this is important for high    */
+  /*    accuracy during scan-conversion).  The transformation is simple:   */
+  /*                                                                       */
+  /*      x' = (x << shift) - delta                                        */
+  /*      y' = (x << shift) - delta                                        */
+  /*                                                                       */
+  /*    Set the value of `shift' and `delta' to 0 to get the original      */
+  /*    point coordinates.                                                 */
+  /*                                                                       */
+  typedef struct  QT_FT_Outline_Funcs_
+  {
+    QT_FT_Outline_MoveToFunc   move_to;
+    QT_FT_Outline_LineToFunc   line_to;
+    QT_FT_Outline_ConicToFunc  conic_to;
+    QT_FT_Outline_CubicToFunc  cubic_to;
+
+    int                     shift;
+    QT_FT_Pos                  delta;
+
+  } QT_FT_Outline_Funcs;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    basic_types                                                        */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Macro>                                                               */
+  /*    QT_FT_IMAGE_TAG                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This macro converts four letter tags into an unsigned long.        */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Since many 16bit compilers don't like 32bit enumerations, you      */
+  /*    should redefine this macro in case of problems to something like   */
+  /*    this:                                                              */
+  /*                                                                       */
+  /*      #define QT_FT_IMAGE_TAG( value, _x1, _x2, _x3, _x4 )  value         */
+  /*                                                                       */
+  /*    to get a simple enumeration without assigning special numbers.     */
+  /*                                                                       */
+#ifndef QT_FT_IMAGE_TAG
+#define QT_FT_IMAGE_TAG( value, _x1, _x2, _x3, _x4 )  \
+          value = ( ( (unsigned long)_x1 << 24 ) | \
+                    ( (unsigned long)_x2 << 16 ) | \
+                    ( (unsigned long)_x3 << 8  ) | \
+                      (unsigned long)_x4         )
+#endif /* QT_FT_IMAGE_TAG */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Enum>                                                                */
+  /*    QT_FT_Glyph_Format                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    An enumeration type used to describe the format of a given glyph   */
+  /*    image.  Note that this version of FreeType only supports two image */
+  /*    formats, even though future font drivers will be able to register  */
+  /*    their own format.                                                  */
+  /*                                                                       */
+  /* <Values>                                                              */
+  /*    QT_FT_GLYPH_FORMAT_NONE ::                                            */
+  /*      The value 0 is reserved and does describe a glyph format.        */
+  /*                                                                       */
+  /*    QT_FT_GLYPH_FORMAT_COMPOSITE ::                                       */
+  /*      The glyph image is a composite of several other images.  This    */
+  /*      format is _only_ used with @QT_FT_LOAD_NO_RECURSE, and is used to   */
+  /*      report compound glyphs (like accented characters).               */
+  /*                                                                       */
+  /*    QT_FT_GLYPH_FORMAT_BITMAP ::                                          */
+  /*      The glyph image is a bitmap, and can be described as an          */
+  /*      @QT_FT_Bitmap.  You generally need to access the `bitmap' field of  */
+  /*      the @QT_FT_GlyphSlotRec structure to read it.                       */
+  /*                                                                       */
+  /*    QT_FT_GLYPH_FORMAT_OUTLINE ::                                         */
+  /*      The glyph image is a vertorial outline made of line segments     */
+  /*      and Bezier arcs; it can be described as an @QT_FT_Outline; you      */
+  /*      generally want to access the `outline' field of the              */
+  /*      @QT_FT_GlyphSlotRec structure to read it.                           */
+  /*                                                                       */
+  /*    QT_FT_GLYPH_FORMAT_PLOTTER ::                                         */
+  /*      The glyph image is a vectorial path with no inside/outside       */
+  /*      contours.  Some Type 1 fonts, like those in the Hershey family,  */
+  /*      contain glyphs in this format.  These are described as           */
+  /*      @QT_FT_Outline, but FreeType isn't currently capable of rendering   */
+  /*      them correctly.                                                  */
+  /*                                                                       */
+  typedef enum  QT_FT_Glyph_Format_
+  {
+    QT_FT_IMAGE_TAG( QT_FT_GLYPH_FORMAT_NONE, 0, 0, 0, 0 ),
+
+    QT_FT_IMAGE_TAG( QT_FT_GLYPH_FORMAT_COMPOSITE, 'c', 'o', 'm', 'p' ),
+    QT_FT_IMAGE_TAG( QT_FT_GLYPH_FORMAT_BITMAP,    'b', 'i', 't', 's' ),
+    QT_FT_IMAGE_TAG( QT_FT_GLYPH_FORMAT_OUTLINE,   'o', 'u', 't', 'l' ),
+    QT_FT_IMAGE_TAG( QT_FT_GLYPH_FORMAT_PLOTTER,   'p', 'l', 'o', 't' )
+
+  } QT_FT_Glyph_Format;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Enum>                                                                */
+  /*    qt_ft_glyph_format_xxx                                                */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A list of decprecated constants.  Use the corresponding            */
+  /*    @QT_FT_Glyph_Format values instead.                                   */
+  /*                                                                       */
+  /* <Values>                                                              */
+  /*    qt_ft_glyph_format_none      :: see @QT_FT_GLYPH_FORMAT_NONE             */
+  /*    qt_ft_glyph_format_composite :: see @QT_FT_GLYPH_FORMAT_COMPOSITE        */
+  /*    qt_ft_glyph_format_bitmap    :: see @QT_FT_GLYPH_FORMAT_BITMAP           */
+  /*    qt_ft_glyph_format_outline   :: see @QT_FT_GLYPH_FORMAT_OUTLINE          */
+  /*    qt_ft_glyph_format_plotter   :: see @QT_FT_GLYPH_FORMAT_PLOTTER          */
+  /*                                                                       */
+#define qt_ft_glyph_format_none       QT_FT_GLYPH_FORMAT_NONE
+#define qt_ft_glyph_format_composite  QT_FT_GLYPH_FORMAT_COMPOSITE
+#define qt_ft_glyph_format_bitmap     QT_FT_GLYPH_FORMAT_BITMAP
+#define qt_ft_glyph_format_outline    QT_FT_GLYPH_FORMAT_OUTLINE
+#define qt_ft_glyph_format_plotter    QT_FT_GLYPH_FORMAT_PLOTTER
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****            R A S T E R   D E F I N I T I O N S                *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* A raster is a scan converter, in charge of rendering an outline into  */
+  /* a a bitmap.  This section contains the public API for rasters.        */
+  /*                                                                       */
+  /* Note that in FreeType 2, all rasters are now encapsulated within      */
+  /* specific modules called `renderers'.  See `freetype/ftrender.h' for   */
+  /* more details on renderers.                                            */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    raster                                                             */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    Scanline converter                                                 */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    How vectorial outlines are converted into bitmaps and pixmaps.     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This section contains technical definitions.                       */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    QT_FT_Raster                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle (pointer) to a raster object.  Each object can be used    */
+  /*    independently to convert an outline into a bitmap or pixmap.       */
+  /*                                                                       */
+  typedef struct TRaster_ *QT_FT_Raster;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    QT_FT_Span                                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to model a single span of gray (or black) pixels  */
+  /*    when rendering a monochrome or anti-aliased bitmap.                */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    x        :: The span's horizontal start position.                  */
+  /*                                                                       */
+  /*    len      :: The span's length in pixels.                           */
+  /*                                                                       */
+  /*    coverage :: The span color/coverage, ranging from 0 (background)   */
+  /*                to 255 (foreground).  Only used for anti-aliased       */
+  /*                rendering.                                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    This structure is used by the span drawing callback type named     */
+  /*    QT_FT_SpanFunc which takes the y-coordinate of the span as a          */
+  /*    a parameter.                                                       */
+  /*                                                                       */
+  /*    The coverage value is always between 0 and 255, even if the number */
+  /*    of gray levels have been set through QT_FT_Set_Gray_Levels().         */
+  /*                                                                       */
+  typedef struct  QT_FT_Span_
+  {
+    short           x;
+    unsigned short  len;
+    short y;
+    unsigned char   coverage;
+  } QT_FT_Span;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    QT_FT_SpanFunc                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A function used as a call-back by the anti-aliased renderer in     */
+  /*    order to let client applications draw themselves the gray pixel    */
+  /*    spans on each scan line.                                           */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    y     :: The scanline's y-coordinate.                              */
+  /*                                                                       */
+  /*    count :: The number of spans to draw on this scanline.             */
+  /*                                                                       */
+  /*    spans :: A table of `count' spans to draw on the scanline.         */
+  /*                                                                       */
+  /*    user  :: User-supplied data that is passed to the callback.        */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    This callback allows client applications to directly render the    */
+  /*    gray spans of the anti-aliased bitmap to any kind of surfaces.     */
+  /*                                                                       */
+  /*    This can be used to write anti-aliased outlines directly to a      */
+  /*    given background bitmap, and even perform translucency.            */
+  /*                                                                       */
+  /*    Note that the `count' field cannot be greater than a fixed value   */
+  /*    defined by the QT_FT_MAX_GRAY_SPANS configuration macro in            */
+  /*    ftoption.h.  By default, this value is set to 32, which means that */
+  /*    if there are more than 32 spans on a given scanline, the callback  */
+  /*    will be called several times with the same `y' parameter in order  */
+  /*    to draw all callbacks.                                             */
+  /*                                                                       */
+  /*    Otherwise, the callback is only called once per scan-line, and     */
+  /*    only for those scanlines that do have `gray' pixels on them.       */
+  /*                                                                       */
+  typedef void
+  (*QT_FT_SpanFunc)(int        count,
+                    const QT_FT_Span*  spans,
+                    void*     worker);
+
+#define QT_FT_Raster_Span_Func   QT_FT_SpanFunc
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    QT_FT_Raster_BitTest_Func                                             */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    THIS TYPE IS DEPRECATED.  DO NOT USE IT.                           */
+  /*                                                                       */
+  /*    A function used as a call-back by the monochrome scan-converter    */
+  /*    to test whether a given target pixel is already set to the drawing */
+  /*    `color'.  These tests are crucial to implement drop-out control    */
+  /*    per-se the TrueType spec.                                          */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    y     :: The pixel's y-coordinate.                                 */
+  /*                                                                       */
+  /*    x     :: The pixel's x-coordinate.                                 */
+  /*                                                                       */
+  /*    user  :: User-supplied data that is passed to the callback.        */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*   1 if the pixel is `set', 0 otherwise.                               */
+  /*                                                                       */
+  typedef int
+  (*QT_FT_Raster_BitTest_Func)( int    y,
+                             int    x,
+                             void*  user );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    QT_FT_Raster_BitSet_Func                                              */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    THIS TYPE IS DEPRECATED.  DO NOT USE IT.                           */
+  /*                                                                       */
+  /*    A function used as a call-back by the monochrome scan-converter    */
+  /*    to set an individual target pixel.  This is crucial to implement   */
+  /*    drop-out control according to the TrueType specification.          */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    y     :: The pixel's y-coordinate.                                 */
+  /*                                                                       */
+  /*    x     :: The pixel's x-coordinate.                                 */
+  /*                                                                       */
+  /*    user  :: User-supplied data that is passed to the callback.        */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    1 if the pixel is `set', 0 otherwise.                              */
+  /*                                                                       */
+  typedef void
+  (*QT_FT_Raster_BitSet_Func)( int    y,
+                            int    x,
+                            void*  user );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Enum>                                                                */
+  /*    QT_FT_RASTER_FLAG_XXX                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A list of bit flag constants as used in the `flags' field of a     */
+  /*    @QT_FT_Raster_Params structure.                                       */
+  /*                                                                       */
+  /* <Values>                                                              */
+  /*    QT_FT_RASTER_FLAG_DEFAULT :: This value is 0.                         */
+  /*                                                                       */
+  /*    QT_FT_RASTER_FLAG_AA      :: This flag is set to indicate that an     */
+  /*                              anti-aliased glyph image should be       */
+  /*                              generated.  Otherwise, it will be        */
+  /*                              monochrome (1-bit).                      */
+  /*                                                                       */
+  /*    QT_FT_RASTER_FLAG_DIRECT  :: This flag is set to indicate direct      */
+  /*                              rendering.  In this mode, client         */
+  /*                              applications must provide their own span */
+  /*                              callback.  This lets them directly       */
+  /*                              draw or compose over an existing bitmap. */
+  /*                              If this bit is not set, the target       */
+  /*                              pixmap's buffer _must_ be zeroed before  */
+  /*                              rendering.                               */
+  /*                                                                       */
+  /*                              Note that for now, direct rendering is   */
+  /*                              only possible with anti-aliased glyphs.  */
+  /*                                                                       */
+  /*    QT_FT_RASTER_FLAG_CLIP    :: This flag is only used in direct         */
+  /*                              rendering mode.  If set, the output will */
+  /*                              be clipped to a box specified in the     */
+  /*                              "clip_box" field of the QT_FT_Raster_Params */
+  /*                              structure.                               */
+  /*                                                                       */
+  /*                              Note that by default, the glyph bitmap   */
+  /*                              is clipped to the target pixmap, except  */
+  /*                              in direct rendering mode where all spans */
+  /*                              are generated if no clipping box is set. */
+  /*                                                                       */
+#define QT_FT_RASTER_FLAG_DEFAULT  0x0
+#define QT_FT_RASTER_FLAG_AA       0x1
+#define QT_FT_RASTER_FLAG_DIRECT   0x2
+#define QT_FT_RASTER_FLAG_CLIP     0x4
+
+  /* deprecated */
+#define qt_ft_raster_flag_default  QT_FT_RASTER_FLAG_DEFAULT
+#define qt_ft_raster_flag_aa       QT_FT_RASTER_FLAG_AA
+#define qt_ft_raster_flag_direct   QT_FT_RASTER_FLAG_DIRECT
+#define qt_ft_raster_flag_clip     QT_FT_RASTER_FLAG_CLIP
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    QT_FT_Raster_Params                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure to hold the arguments used by a raster's render        */
+  /*    function.                                                          */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    target      :: The target bitmap.                                  */
+  /*                                                                       */
+  /*    source      :: A pointer to the source glyph image (e.g. an        */
+  /*                   QT_FT_Outline).                                        */
+  /*                                                                       */
+  /*    flags       :: The rendering flags.                                */
+  /*                                                                       */
+  /*    gray_spans  :: The gray span drawing callback.                     */
+  /*                                                                       */
+  /*    black_spans :: The black span drawing callback.                    */
+  /*                                                                       */
+  /*    bit_test    :: The bit test callback.  UNIMPLEMENTED!              */
+  /*                                                                       */
+  /*    bit_set     :: The bit set callback.  UNIMPLEMENTED!               */
+  /*                                                                       */
+  /*    user        :: User-supplied data that is passed to each drawing   */
+  /*                   callback.                                           */
+  /*                                                                       */
+  /*    clip_box    :: An optional clipping box.  It is only used in       */
+  /*                   direct rendering mode.  Note that coordinates here  */
+  /*                   should be expressed in _integer_ pixels (and not in */
+  /*                   26.6 fixed-point units).                            */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    An anti-aliased glyph bitmap is drawn if the QT_FT_RASTER_FLAG_AA bit */
+  /*    flag is set in the `flags' field, otherwise a monochrome bitmap    */
+  /*    will be generated.                                                 */
+  /*                                                                       */
+  /*    If the QT_FT_RASTER_FLAG_DIRECT bit flag is set in `flags', the       */
+  /*    raster will call the `gray_spans' callback to draw gray pixel      */
+  /*    spans, in the case of an aa glyph bitmap, it will call             */
+  /*    `black_spans', and `bit_test' and `bit_set' in the case of a       */
+  /*    monochrome bitmap.  This allows direct composition over a          */
+  /*    pre-existing bitmap through user-provided callbacks to perform the */
+  /*    span drawing/composition.                                          */
+  /*                                                                       */
+  /*    Note that the `bit_test' and `bit_set' callbacks are required when */
+  /*    rendering a monochrome bitmap, as they are crucial to implement    */
+  /*    correct drop-out control as defined in the TrueType specification. */
+  /*                                                                       */
+  typedef struct  QT_FT_Raster_Params_
+  {
+    QT_FT_Bitmap*              target;
+    void*                   source;
+    int                     flags;
+    QT_FT_SpanFunc             gray_spans;
+    QT_FT_SpanFunc             black_spans;
+    QT_FT_Raster_BitTest_Func  bit_test;     /* doesn't work! */
+    QT_FT_Raster_BitSet_Func   bit_set;      /* doesn't work! */
+    void*                   user;
+    QT_FT_BBox                 clip_box;
+    int                     skip_spans;
+
+  } QT_FT_Raster_Params;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    QT_FT_Raster_NewFunc                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A function used to create a new raster object.                     */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    memory :: A handle to the memory allocator.                        */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    raster :: A handle to the new raster object.                       */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Error code.  0 means success.                                      */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The `memory' parameter is a typeless pointer in order to avoid     */
+  /*    un-wanted dependencies on the rest of the FreeType code.  In       */
+  /*    practice, it is a QT_FT_Memory, i.e., a handle to the standard        */
+  /*    FreeType memory allocator.  However, this field can be completely  */
+  /*    ignored by a given raster implementation.                          */
+  /*                                                                       */
+  typedef int
+  (*QT_FT_Raster_NewFunc)( QT_FT_Raster*  raster );
+
+#define  QT_FT_Raster_New_Func    QT_FT_Raster_NewFunc
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    QT_FT_Raster_DoneFunc                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A function used to destroy a given raster object.                  */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    raster :: A handle to the raster object.                           */
+  /*                                                                       */
+  typedef void
+  (*QT_FT_Raster_DoneFunc)( QT_FT_Raster  raster );
+
+#define  QT_FT_Raster_Done_Func   QT_FT_Raster_DoneFunc
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    QT_FT_Raster_ResetFunc                                                */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    FreeType provides an area of memory called the `render pool',      */
+  /*    available to all registered rasters.  This pool can be freely used */
+  /*    during a given scan-conversion but is shared by all rasters.  Its  */
+  /*    content is thus transient.                                         */
+  /*                                                                       */
+  /*    This function is called each time the render pool changes, or just */
+  /*    after a new raster object is created.                              */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    raster    :: A handle to the new raster object.                    */
+  /*                                                                       */
+  /*    pool_base :: The address in memory of the render pool.             */
+  /*                                                                       */
+  /*    pool_size :: The size in bytes of the render pool.                 */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Rasters can ignore the render pool and rely on dynamic memory      */
+  /*    allocation if they want to (a handle to the memory allocator is    */
+  /*    passed to the raster constructor).  However, this is not           */
+  /*    recommended for efficiency purposes.                               */
+  /*                                                                       */
+  typedef void
+  (*QT_FT_Raster_ResetFunc)( QT_FT_Raster       raster,
+                          unsigned char*  pool_base,
+                          unsigned long   pool_size );
+
+#define  QT_FT_Raster_Reset_Func   QT_FT_Raster_ResetFunc
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    QT_FT_Raster_SetModeFunc                                              */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This function is a generic facility to change modes or attributes  */
+  /*    in a given raster.  This can be used for debugging purposes, or    */
+  /*    simply to allow implementation-specific `features' in a given      */
+  /*    raster module.                                                     */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    raster :: A handle to the new raster object.                       */
+  /*                                                                       */
+  /*    mode   :: A 4-byte tag used to name the mode or property.          */
+  /*                                                                       */
+  /*    args   :: A pointer to the new mode/property to use.               */
+  /*                                                                       */
+  typedef int
+  (*QT_FT_Raster_SetModeFunc)( QT_FT_Raster      raster,
+                            unsigned long  mode,
+                            void*          args );
+
+#define  QT_FT_Raster_Set_Mode_Func  QT_FT_Raster_SetModeFunc
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    QT_FT_Raster_RenderFunc                                               */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*   Invokes a given raster to scan-convert a given glyph image into a   */
+  /*   target bitmap.                                                      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    raster :: A handle to the raster object.                           */
+  /*                                                                       */
+  /*    params :: A pointer to a QT_FT_Raster_Params structure used to store  */
+  /*              the rendering parameters.                                */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Error code.  0 means success.                                      */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The exact format of the source image depends on the raster's glyph */
+  /*    format defined in its QT_FT_Raster_Funcs structure.  It can be an     */
+  /*    QT_FT_Outline or anything else in order to support a large array of   */
+  /*    glyph formats.                                                     */
+  /*                                                                       */
+  /*    Note also that the render function can fail and return a           */
+  /*    QT_FT_Err_Unimplemented_Feature error code if the raster used does    */
+  /*    not support direct composition.                                    */
+  /*                                                                       */
+  /*    XXX: For now, the standard raster doesn't support direct           */
+  /*         composition but this should change for the final release (see */
+  /*         the files demos/src/ftgrays.c and demos/src/ftgrays2.c for    */
+  /*         examples of distinct implementations which support direct     */
+  /*         composition).                                                 */
+  /*                                                                       */
+  typedef int
+  (*QT_FT_Raster_RenderFunc)( QT_FT_Raster          raster,
+                           QT_FT_Raster_Params*  params );
+
+#define  QT_FT_Raster_Render_Func    QT_FT_Raster_RenderFunc
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    QT_FT_Raster_Funcs                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*   A structure used to describe a given raster class to the library.   */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    glyph_format  :: The supported glyph format for this raster.       */
+  /*                                                                       */
+  /*    raster_new    :: The raster constructor.                           */
+  /*                                                                       */
+  /*    raster_reset  :: Used to reset the render pool within the raster.  */
+  /*                                                                       */
+  /*    raster_render :: A function to render a glyph into a given bitmap. */
+  /*                                                                       */
+  /*    raster_done   :: The raster destructor.                            */
+  /*                                                                       */
+  typedef struct  QT_FT_Raster_Funcs_
+  {
+    QT_FT_Glyph_Format         glyph_format;
+    QT_FT_Raster_NewFunc       raster_new;
+    QT_FT_Raster_ResetFunc     raster_reset;
+    QT_FT_Raster_SetModeFunc   raster_set_mode;
+    QT_FT_Raster_RenderFunc    raster_render;
+    QT_FT_Raster_DoneFunc      raster_done;
+
+  } QT_FT_Raster_Funcs;
+
+
+  /* */
+
+
+QT_FT_END_HEADER
+
+#endif /* __FTIMAGE_H__ */
+
+
+/* END */
diff --git a/src/gui/painting/qrasterizer.cpp b/src/gui/painting/qrasterizer.cpp
new file mode 100644
index 0000000000..75116c2420
--- /dev/null
+++ b/src/gui/painting/qrasterizer.cpp
@@ -0,0 +1,1270 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qrasterizer_p.h"
+
+#include <QPoint>
+#include <QRect>
+
+#include <private/qmath_p.h>
+#include <private/qdatabuffer_p.h>
+#include <private/qdrawhelper_p.h>
+
+QT_BEGIN_NAMESPACE
+
+typedef int Q16Dot16;
+#define Q16Dot16ToFloat(i) ((i)/65536.)
+#define FloatToQ16Dot16(i) (int)((i) * 65536.)
+#define IntToQ16Dot16(i) ((i) << 16)
+#define Q16Dot16ToInt(i) ((i) >> 16)
+#define Q16Dot16Factor 65536
+
+#define Q16Dot16Multiply(x, y) (int)((qlonglong(x) * qlonglong(y)) >> 16)
+#define Q16Dot16FastMultiply(x, y) (((x) * (y)) >> 16)
+
+#define SPAN_BUFFER_SIZE 256
+
+#define COORD_ROUNDING 0 // 0: round up, 1: round down
+#define COORD_OFFSET 0 // 26.6, 32 is half a pixel
+
+static inline QT_FT_Vector PointToVector(const QPointF &p)
+{
+    QT_FT_Vector result = { QT_FT_Pos(p.x() * 64), QT_FT_Pos(p.y() * 64) };
+    return result;
+}
+
+class QSpanBuffer {
+public:
+    QSpanBuffer(ProcessSpans blend, void *data, const QRect &clipRect)
+        : m_spanCount(0)
+        , m_blend(blend)
+        , m_data(data)
+        , m_clipRect(clipRect)
+    {
+    }
+
+    ~QSpanBuffer()
+    {
+        flushSpans();
+    }
+
+    void addSpan(int x, unsigned int len, int y, unsigned char coverage)
+    {
+        if (!coverage || !len)
+            return;
+
+        Q_ASSERT(y >= m_clipRect.top());
+        Q_ASSERT(y <= m_clipRect.bottom());
+        Q_ASSERT(x >= m_clipRect.left());
+        Q_ASSERT(x + int(len) - 1 <= m_clipRect.right());
+
+        m_spans[m_spanCount].x = x;
+        m_spans[m_spanCount].len = len;
+        m_spans[m_spanCount].y = y;
+        m_spans[m_spanCount].coverage = coverage;
+
+        if (++m_spanCount == SPAN_BUFFER_SIZE)
+            flushSpans();
+    }
+
+private:
+    void flushSpans()
+    {
+        m_blend(m_spanCount, m_spans, m_data);
+        m_spanCount = 0;
+    }
+
+    QT_FT_Span m_spans[SPAN_BUFFER_SIZE];
+    int m_spanCount;
+
+    ProcessSpans m_blend;
+    void *m_data;
+
+    QRect m_clipRect;
+};
+
+#define CHUNK_SIZE 64
+class QScanConverter
+{
+public:
+    QScanConverter();
+    ~QScanConverter();
+
+    void begin(int top, int bottom, int left, int right,
+               Qt::FillRule fillRule, QSpanBuffer *spanBuffer);
+    void end();
+
+    void mergeCurve(const QT_FT_Vector &a, const QT_FT_Vector &b,
+                    const QT_FT_Vector &c, const QT_FT_Vector &d);
+    void mergeLine(QT_FT_Vector a, QT_FT_Vector b);
+
+    struct Line
+    {
+        Q16Dot16 x;
+        Q16Dot16 delta;
+
+        int top, bottom;
+
+        int winding;
+    };
+
+private:
+    struct Intersection
+    {
+        int x;
+        int winding;
+
+        int left, right;
+    };
+
+    inline bool clip(Q16Dot16 &xFP, int &iTop, int &iBottom, Q16Dot16 slopeFP, Q16Dot16 edgeFP, int winding);
+    inline void mergeIntersection(Intersection *head, const Intersection &isect);
+
+    void prepareChunk();
+
+    void emitNode(const Intersection *node);
+    void emitSpans(int chunk);
+
+    inline void allocate(int size);
+
+    QDataBuffer<Line> m_lines;
+
+    int m_alloc;
+    int m_size;
+
+    int m_top;
+    int m_bottom;
+
+    Q16Dot16 m_leftFP;
+    Q16Dot16 m_rightFP;
+
+    int m_fillRuleMask;
+
+    int m_x;
+    int m_y;
+    int m_winding;
+
+    Intersection *m_intersections;
+
+    QSpanBuffer *m_spanBuffer;
+
+    QDataBuffer<Line *> m_active;
+
+    template <typename T>
+    friend void qScanConvert(QScanConverter &d, T allVertical);
+};
+
+class QRasterizerPrivate
+{
+public:
+    bool antialiased;
+    ProcessSpans blend;
+    void *data;
+    QRect clipRect;
+
+    QScanConverter scanConverter;
+};
+
+QScanConverter::QScanConverter()
+   : m_lines(0)
+   , m_alloc(0)
+   , m_size(0)
+   , m_intersections(0)
+   , m_active(0)
+{
+}
+
+QScanConverter::~QScanConverter()
+{
+    if (m_intersections)
+        free(m_intersections);
+}
+
+void QScanConverter::begin(int top, int bottom, int left, int right,
+                           Qt::FillRule fillRule, QSpanBuffer *spanBuffer)
+{
+    m_top = top;
+    m_bottom = bottom;
+    m_leftFP = IntToQ16Dot16(left);
+    m_rightFP = IntToQ16Dot16(right + 1);
+
+    m_lines.reset();
+
+    m_fillRuleMask = fillRule == Qt::WindingFill ? ~0x0 : 0x1;
+    m_spanBuffer = spanBuffer;
+}
+
+void QScanConverter::prepareChunk()
+{
+    m_size = CHUNK_SIZE;
+
+    allocate(CHUNK_SIZE);
+    memset(m_intersections, 0, CHUNK_SIZE * sizeof(Intersection));
+}
+
+void QScanConverter::emitNode(const Intersection *node)
+{
+tail_call:
+    if (node->left)
+        emitNode(node + node->left);
+
+    if (m_winding & m_fillRuleMask)
+        m_spanBuffer->addSpan(m_x, node->x - m_x, m_y, 0xff);
+
+    m_x = node->x;
+    m_winding += node->winding;
+
+    if (node->right) {
+        node += node->right;
+        goto tail_call;
+    }
+}
+
+void QScanConverter::emitSpans(int chunk)
+{
+    for (int dy = 0; dy < CHUNK_SIZE; ++dy) {
+        m_x = 0;
+        m_y = chunk + dy;
+        m_winding = 0;
+
+        emitNode(&m_intersections[dy]);
+    }
+}
+
+// split control points b[0] ... b[3] into
+// left (b[0] ... b[3]) and right (b[3] ... b[6])
+static void split(QT_FT_Vector *b)
+{
+    b[6] = b[3];
+
+    {
+        const QT_FT_Pos temp = (b[1].x + b[2].x)/2;
+
+        b[1].x = (b[0].x + b[1].x)/2;
+        b[5].x = (b[2].x + b[3].x)/2;
+        b[2].x = (b[1].x + temp)/2;
+        b[4].x = (b[5].x + temp)/2;
+        b[3].x = (b[2].x + b[4].x)/2;
+    }
+    {
+        const QT_FT_Pos temp = (b[1].y + b[2].y)/2;
+
+        b[1].y = (b[0].y + b[1].y)/2;
+        b[5].y = (b[2].y + b[3].y)/2;
+        b[2].y = (b[1].y + temp)/2;
+        b[4].y = (b[5].y + temp)/2;
+        b[3].y = (b[2].y + b[4].y)/2;
+    }
+}
+
+static inline bool topOrder(const QScanConverter::Line &a, const QScanConverter::Line &b)
+{
+    return a.top < b.top;
+}
+
+static inline bool xOrder(const QScanConverter::Line *a, const QScanConverter::Line *b)
+{
+    return a->x < b->x;
+}
+
+template <bool B>
+struct QBoolToType
+{
+    inline bool operator()() const
+    {
+        return B;
+    }
+};
+
+// should be a member function but VC6 doesn't support member template functions
+template <typename T>
+void qScanConvert(QScanConverter &d, T allVertical)
+{
+    if (!d.m_lines.size()) {
+        d.m_active.reset();
+        return;
+    }
+    qSort(d.m_lines.data(), d.m_lines.data() + d.m_lines.size(), QT_PREPEND_NAMESPACE(topOrder));
+    int line = 0;
+    for (int y = d.m_lines.first().top; y <= d.m_bottom; ++y) {
+        for (; line < d.m_lines.size() && d.m_lines.at(line).top == y; ++line) {
+            // add node to active list
+            if (allVertical()) {
+                QScanConverter::Line *l = &d.m_lines.at(line);
+                d.m_active.resize(d.m_active.size() + 1);
+                int j;
+                for (j = d.m_active.size() - 2; j >= 0 && QT_PREPEND_NAMESPACE(xOrder)(l, d.m_active.at(j)); --j)
+                    d.m_active.at(j+1) = d.m_active.at(j);
+                d.m_active.at(j+1) = l;
+            } else {
+                d.m_active << &d.m_lines.at(line);
+            }
+        }
+
+        int numActive = d.m_active.size();
+        if (!allVertical()) {
+        // use insertion sort instead of qSort, as the active edge list is quite small
+        // and in the average case already sorted
+            for (int i = 1; i < numActive; ++i) {
+                QScanConverter::Line *l = d.m_active.at(i);
+                int j;
+                for (j = i-1; j >= 0 && QT_PREPEND_NAMESPACE(xOrder)(l, d.m_active.at(j)); --j)
+                    d.m_active.at(j+1) = d.m_active.at(j);
+                d.m_active.at(j+1) = l;
+            }
+        }
+
+        int x = 0;
+        int winding = 0;
+        for (int i = 0; i < numActive; ++i) {
+            QScanConverter::Line *node = d.m_active.at(i);
+
+            const int current = Q16Dot16ToInt(node->x);
+            if (winding & d.m_fillRuleMask)
+                d.m_spanBuffer->addSpan(x, current - x, y, 0xff);
+
+            x = current;
+            winding += node->winding;
+
+            if (node->bottom == y) {
+                // remove node from active list
+                for (int j = i; j < numActive - 1; ++j)
+                    d.m_active.at(j) = d.m_active.at(j+1);
+
+                d.m_active.resize(--numActive);
+                --i;
+            } else if (!allVertical())
+                node->x += node->delta;
+        }
+    }
+    d.m_active.reset();
+}
+
+void QScanConverter::end()
+{
+    if (m_lines.isEmpty())
+        return;
+
+    if (m_lines.size() <= 32) {
+        bool allVertical = true;
+        for (int i = 0; i < m_lines.size(); ++i) {
+            if (m_lines.at(i).delta) {
+                allVertical = false;
+                break;
+            }
+        }
+        if (allVertical)
+            qScanConvert(*this, QBoolToType<true>());
+        else
+            qScanConvert(*this, QBoolToType<false>());
+    } else {
+        for (int chunkTop = m_top; chunkTop <= m_bottom; chunkTop += CHUNK_SIZE) {
+            prepareChunk();
+
+            Intersection isect = { 0, 0, 0, 0 };
+
+            const int chunkBottom = chunkTop + CHUNK_SIZE;
+            for (int i = 0; i < m_lines.size(); ++i) {
+                Line &line = m_lines.at(i);
+
+                if ((line.bottom < chunkTop) || (line.top > chunkBottom))
+                    continue;
+
+                const int top = qMax(0, line.top - chunkTop);
+                const int bottom = qMin(CHUNK_SIZE, line.bottom + 1 - chunkTop);
+                allocate(m_size + bottom - top);
+
+                isect.winding = line.winding;
+
+                Intersection *it = m_intersections + top;
+                Intersection *end = m_intersections + bottom;
+
+                if (line.delta) {
+                    for (; it != end; ++it) {
+                        isect.x = Q16Dot16ToInt(line.x);
+                        line.x += line.delta;
+                        mergeIntersection(it, isect);
+                    }
+                } else {
+                    isect.x = Q16Dot16ToInt(line.x);
+                    for (; it != end; ++it)
+                        mergeIntersection(it, isect);
+                }
+            }
+
+            emitSpans(chunkTop);
+        }
+    }
+
+    if (m_alloc > 1024) {
+        free(m_intersections);
+        m_alloc = 0;
+        m_size = 0;
+        m_intersections = 0;
+    }
+
+    if (m_lines.size() > 1024)
+        m_lines.shrink(1024);
+}
+
+inline void QScanConverter::allocate(int size)
+{
+    if (m_alloc < size) {
+        int newAlloc = qMax(size, 2 * m_alloc);
+        m_intersections = q_check_ptr((Intersection *)realloc(m_intersections, newAlloc * sizeof(Intersection)));
+        m_alloc = newAlloc;
+    }
+}
+
+inline void QScanConverter::mergeIntersection(Intersection *it, const Intersection &isect)
+{
+    Intersection *current = it;
+
+    while (isect.x != current->x) {
+        int &next = isect.x < current->x ? current->left : current->right;
+        if (next)
+            current += next;
+        else {
+            Intersection *last = m_intersections + m_size;
+            next = last - current;
+            *last = isect;
+            ++m_size;
+            return;
+        }
+    }
+
+    current->winding += isect.winding;
+}
+
+void QScanConverter::mergeCurve(const QT_FT_Vector &pa, const QT_FT_Vector &pb,
+                                const QT_FT_Vector &pc, const QT_FT_Vector &pd)
+{
+    // make room for 32 splits
+    QT_FT_Vector beziers[4 + 3 * 32];
+
+    QT_FT_Vector *b = beziers;
+
+    b[0] = pa;
+    b[1] = pb;
+    b[2] = pc;
+    b[3] = pd;
+
+    const QT_FT_Pos flatness = 16;
+
+    while (b >= beziers) {
+        QT_FT_Vector delta = { b[3].x - b[0].x, b[3].y - b[0].y };
+        QT_FT_Pos l = qAbs(delta.x) + qAbs(delta.y);
+
+        bool belowThreshold;
+        if (l > 64) {
+            qlonglong d2 = qAbs(qlonglong(b[1].x-b[0].x) * qlonglong(delta.y) -
+                                qlonglong(b[1].y-b[0].y) * qlonglong(delta.x));
+            qlonglong d3 = qAbs(qlonglong(b[2].x-b[0].x) * qlonglong(delta.y) -
+                                qlonglong(b[2].y-b[0].y) * qlonglong(delta.x));
+
+            qlonglong d = d2 + d3;
+
+            belowThreshold = (d <= qlonglong(flatness) * qlonglong(l));
+        } else {
+            QT_FT_Pos d = qAbs(b[0].x-b[1].x) + qAbs(b[0].y-b[1].y) +
+                          qAbs(b[0].x-b[2].x) + qAbs(b[0].y-b[2].y);
+
+            belowThreshold = (d <= flatness);
+        }
+
+        if (belowThreshold || b == beziers + 3 * 32) {
+            mergeLine(b[0], b[3]);
+            b -= 3;
+            continue;
+        }
+
+        split(b);
+        b += 3;
+    }
+}
+
+inline bool QScanConverter::clip(Q16Dot16 &xFP, int &iTop, int &iBottom, Q16Dot16 slopeFP, Q16Dot16 edgeFP, int winding)
+{
+    bool right = edgeFP == m_rightFP;
+
+    if (xFP == edgeFP) {
+        if ((slopeFP > 0) ^ right)
+            return false;
+        else {
+            Line line = { edgeFP, 0, iTop, iBottom, winding };
+            m_lines.add(line);
+            return true;
+        }
+    }
+
+    Q16Dot16 lastFP = xFP + slopeFP * (iBottom - iTop);
+
+    if (lastFP == edgeFP) {
+        if ((slopeFP < 0) ^ right)
+            return false;
+        else {
+            Line line = { edgeFP, 0, iTop, iBottom, winding };
+            m_lines.add(line);
+            return true;
+        }
+    }
+
+    // does line cross edge?
+    if ((lastFP < edgeFP) ^ (xFP < edgeFP)) {
+        Q16Dot16 deltaY = Q16Dot16((edgeFP - xFP) / Q16Dot16ToFloat(slopeFP));
+
+        if ((xFP < edgeFP) ^ right) {
+            // top segment needs to be clipped
+            int iHeight = Q16Dot16ToInt(deltaY + 1);
+            int iMiddle = iTop + iHeight;
+
+            Line line = { edgeFP, 0, iTop, iMiddle, winding };
+            m_lines.add(line);
+
+            if (iMiddle != iBottom) {
+                xFP += slopeFP * (iHeight + 1);
+                iTop = iMiddle + 1;
+            } else
+                return true;
+        } else {
+            // bottom segment needs to be clipped
+            int iHeight = Q16Dot16ToInt(deltaY);
+            int iMiddle = iTop + iHeight;
+
+            if (iMiddle != iBottom) {
+                Line line = { edgeFP, 0, iMiddle + 1, iBottom, winding };
+                m_lines.add(line);
+
+                iBottom = iMiddle;
+            }
+        }
+        return false;
+    } else if ((xFP < edgeFP) ^ right) {
+        Line line = { edgeFP, 0, iTop, iBottom, winding };
+        m_lines.add(line);
+        return true;
+    }
+
+    return false;
+}
+
+void QScanConverter::mergeLine(QT_FT_Vector a, QT_FT_Vector b)
+{
+    int winding = 1;
+
+    if (a.y > b.y) {
+        qSwap(a, b);
+        winding = -1;
+    }
+
+    a.x += COORD_OFFSET;
+    a.y += COORD_OFFSET;
+    b.x += COORD_OFFSET;
+    b.y += COORD_OFFSET;
+
+    int iTop = qMax(m_top, int((a.y + 32 - COORD_ROUNDING) >> 6));
+    int iBottom = qMin(m_bottom, int((b.y - 32 - COORD_ROUNDING) >> 6));
+
+    if (iTop <= iBottom) {
+        Q16Dot16 aFP = Q16Dot16Factor/2 + (a.x << 10) - COORD_ROUNDING;
+
+        if (b.x == a.x) {
+            Line line = { qBound(m_leftFP, aFP, m_rightFP), 0, iTop, iBottom, winding };
+            m_lines.add(line);
+        } else {
+            const qreal slope = (b.x - a.x) / qreal(b.y - a.y);
+
+            const Q16Dot16 slopeFP = FloatToQ16Dot16(slope);
+
+            Q16Dot16 xFP = aFP + Q16Dot16Multiply(slopeFP,
+                                                  IntToQ16Dot16(iTop)
+                                                  + Q16Dot16Factor/2 - (a.y << 10));
+
+            if (clip(xFP, iTop, iBottom, slopeFP, m_leftFP, winding))
+                return;
+
+            if (clip(xFP, iTop, iBottom, slopeFP, m_rightFP, winding))
+                return;
+
+            Q_ASSERT(xFP >= m_leftFP);
+
+            Line line = { xFP, slopeFP, iTop, iBottom, winding };
+            m_lines.add(line);
+        }
+    }
+}
+
+QRasterizer::QRasterizer()
+    : d(new QRasterizerPrivate)
+{
+}
+
+QRasterizer::~QRasterizer()
+{
+    delete d;
+}
+
+void QRasterizer::setAntialiased(bool antialiased)
+{
+    d->antialiased = antialiased;
+}
+
+void QRasterizer::initialize(ProcessSpans blend, void *data)
+{
+    d->blend = blend;
+    d->data = data;
+}
+
+void QRasterizer::setClipRect(const QRect &clipRect)
+{
+    d->clipRect = clipRect;
+}
+
+static Q16Dot16 intersectPixelFP(int x, Q16Dot16 top, Q16Dot16 bottom, Q16Dot16 leftIntersectX, Q16Dot16 rightIntersectX, Q16Dot16 slope, Q16Dot16 invSlope)
+{
+    Q16Dot16 leftX = IntToQ16Dot16(x);
+    Q16Dot16 rightX = IntToQ16Dot16(x) + Q16Dot16Factor;
+
+    Q16Dot16 leftIntersectY, rightIntersectY;
+    if (slope > 0) {
+        leftIntersectY = top + Q16Dot16Multiply(leftX - leftIntersectX, invSlope);
+        rightIntersectY = leftIntersectY + invSlope;
+    } else {
+        leftIntersectY = top + Q16Dot16Multiply(leftX - rightIntersectX, invSlope);
+        rightIntersectY = leftIntersectY + invSlope;
+    }
+
+    if (leftIntersectX >= leftX && rightIntersectX <= rightX) {
+        return Q16Dot16Multiply(bottom - top, leftIntersectX - leftX + ((rightIntersectX - leftIntersectX) >> 1));
+    } else if (leftIntersectX >= rightX) {
+        return bottom - top;
+    } else if (leftIntersectX >= leftX) {
+        if (slope > 0) {
+            return (bottom - top) - Q16Dot16FastMultiply((rightX - leftIntersectX) >> 1, rightIntersectY - top);
+        } else {
+            return (bottom - top) - Q16Dot16FastMultiply((rightX - leftIntersectX) >> 1, bottom - rightIntersectY);
+        }
+    } else if (rightIntersectX <= leftX) {
+        return 0;
+    } else if (rightIntersectX <= rightX) {
+        if (slope > 0) {
+            return Q16Dot16FastMultiply((rightIntersectX - leftX) >> 1, bottom - leftIntersectY);
+        } else {
+            return Q16Dot16FastMultiply((rightIntersectX - leftX) >> 1, leftIntersectY - top);
+        }
+    } else {
+        if (slope > 0) {
+            return (bottom - rightIntersectY) + ((rightIntersectY - leftIntersectY) >> 1);
+        } else {
+            return (rightIntersectY - top) + ((leftIntersectY - rightIntersectY) >> 1);
+        }
+    }
+}
+
+static inline bool q26Dot6Compare(qreal p1, qreal p2)
+{
+    return int((p2  - p1) * 64.) == 0;
+}
+
+static inline qreal qFloorF(qreal v)
+{
+#ifdef QT_USE_MATH_H_FLOATS
+    if (sizeof(qreal) == sizeof(float))
+        return floorf(v);
+    else
+#endif
+        return floor(v);
+}
+
+static inline QPointF snapTo26Dot6Grid(const QPointF &p)
+{
+    return QPointF(qFloorF(p.x() * 64) * (1 / qreal(64)),
+                   qFloorF(p.y() * 64) * (1 / qreal(64)));
+}
+
+void QRasterizer::rasterizeLine(const QPointF &a, const QPointF &b, qreal width, bool squareCap)
+{
+    if (a == b || width == 0 || d->clipRect.isEmpty())
+        return;
+
+    Q_ASSERT(width > 0.0);
+
+    QPointF pa = a;
+    QPointF pb = b;
+
+    if (squareCap) {
+        QPointF delta = pb - pa;
+        pa -= (0.5f * width) * delta;
+        pb += (0.5f * width) * delta;
+    }
+
+    QPointF offs = QPointF(qAbs(b.y() - a.y()), qAbs(b.x() - a.x())) * width * 0.5;
+    const QRectF clip(d->clipRect.topLeft() - offs, d->clipRect.bottomRight() + QPoint(1, 1) + offs);
+
+    if (!clip.contains(pa) || !clip.contains(pb)) {
+        qreal t1 = 0;
+        qreal t2 = 1;
+
+        const qreal o[2] = { pa.x(), pa.y() };
+        const qreal d[2] = { pb.x() - pa.x(), pb.y() - pa.y() };
+
+        const qreal low[2] = { clip.left(), clip.top() };
+        const qreal high[2] = { clip.right(), clip.bottom() };
+
+        for (int i = 0; i < 2; ++i) {
+            if (d[i] == 0) {
+                if (o[i] <= low[i] || o[i] >= high[i])
+                    return;
+                continue;
+            }
+            const qreal d_inv = 1 / d[i];
+            qreal t_low = (low[i] - o[i]) * d_inv;
+            qreal t_high = (high[i] - o[i]) * d_inv;
+            if (t_low > t_high)
+                qSwap(t_low, t_high);
+            if (t1 < t_low)
+                t1 = t_low;
+            if (t2 > t_high)
+                t2 = t_high;
+            if (t1 >= t2)
+                return;
+        }
+
+        QPointF npa = pa + (pb - pa) * t1;
+        QPointF npb = pa + (pb - pa) * t2;
+
+        pa = npa;
+        pb = npb;
+    }
+
+    if (!d->antialiased) {
+        pa.rx() += (COORD_OFFSET - COORD_ROUNDING)/64.;
+        pa.ry() += (COORD_OFFSET - COORD_ROUNDING)/64.;
+        pb.rx() += (COORD_OFFSET - COORD_ROUNDING)/64.;
+        pb.ry() += (COORD_OFFSET - COORD_ROUNDING)/64.;
+    }
+
+    {
+        // old delta
+        const QPointF d0 = a - b;
+        const qreal w0 = d0.x() * d0.x() + d0.y() * d0.y();
+
+        // new delta
+        const QPointF d = pa - pb;
+        const qreal w = d.x() * d.x() + d.y() * d.y();
+
+        if (w == 0)
+            return;
+
+        // adjust width which is given relative to |b - a|
+        width *= sqrt(w0 / w);
+    }
+
+    QSpanBuffer buffer(d->blend, d->data, d->clipRect);
+
+    if (q26Dot6Compare(pa.y(), pb.y())) {
+        const qreal x = (pa.x() + pb.x()) * 0.5f;
+        const qreal dx = qAbs(pb.x() - pa.x()) * 0.5f;
+
+        const qreal y = pa.y();
+        const qreal dy = width * dx;
+
+        pa = QPointF(x, y - dy);
+        pb = QPointF(x, y + dy);
+
+        width = 1 / width;
+    }
+
+    if (q26Dot6Compare(pa.x(), pb.x())) {
+        if (pa.y() > pb.y())
+            qSwap(pa, pb);
+
+        const qreal dy = pb.y() - pa.y();
+        const qreal halfWidth = 0.5f * width * dy;
+
+        qreal left = pa.x() - halfWidth;
+        qreal right = pa.x() + halfWidth;
+
+        left = qBound(qreal(d->clipRect.left()), left, qreal(d->clipRect.right() + 1));
+        right = qBound(qreal(d->clipRect.left()), right, qreal(d->clipRect.right() + 1));
+
+        pa.ry() = qBound(qreal(d->clipRect.top()), pa.y(), qreal(d->clipRect.bottom() + 1));
+        pb.ry() = qBound(qreal(d->clipRect.top()), pb.y(), qreal(d->clipRect.bottom() + 1));
+
+        if (q26Dot6Compare(left, right) || q26Dot6Compare(pa.y(), pb.y()))
+            return;
+
+        if (d->antialiased) {
+            const Q16Dot16 iLeft = int(left);
+            const Q16Dot16 iRight = int(right);
+            const Q16Dot16 leftWidth = IntToQ16Dot16(iLeft + 1)
+                                       - FloatToQ16Dot16(left);
+            const Q16Dot16 rightWidth = FloatToQ16Dot16(right)
+                                        - IntToQ16Dot16(iRight);
+
+            Q16Dot16 coverage[3];
+            int x[3];
+            int len[3];
+
+            int n = 1;
+            if (iLeft == iRight) {
+                coverage[0] = (leftWidth + rightWidth) * 255;
+                x[0] = iLeft;
+                len[0] = 1;
+            } else {
+                coverage[0] = leftWidth * 255;
+                x[0] = iLeft;
+                len[0] = 1;
+                if (leftWidth == Q16Dot16Factor) {
+                    len[0] = iRight - iLeft;
+                } else if (iRight - iLeft > 1) {
+                    coverage[1] = IntToQ16Dot16(255);
+                    x[1] = iLeft + 1;
+                    len[1] = iRight - iLeft - 1;
+                    ++n;
+                }
+                if (rightWidth) {
+                    coverage[n] = rightWidth * 255;
+                    x[n] = iRight;
+                    len[n] = 1;
+                    ++n;
+                }
+            }
+
+            const Q16Dot16 iTopFP = IntToQ16Dot16(int(pa.y()));
+            const Q16Dot16 iBottomFP = IntToQ16Dot16(int(pb.y()));
+            const Q16Dot16 yPa = FloatToQ16Dot16(pa.y());
+            const Q16Dot16 yPb = FloatToQ16Dot16(pb.y());
+            for (Q16Dot16 yFP = iTopFP; yFP <= iBottomFP; yFP += Q16Dot16Factor) {
+                const Q16Dot16 rowHeight = qMin(yFP + Q16Dot16Factor, yPb)
+                                           - qMax(yFP, yPa);
+                const int y = Q16Dot16ToInt(yFP);
+                for (int i = 0; i < n; ++i) {
+                    buffer.addSpan(x[i], len[i], y,
+                                   Q16Dot16ToInt(Q16Dot16Multiply(rowHeight, coverage[i])));
+                }
+            }
+        } else { // aliased
+            int iTop = int(pa.y() + 0.5f);
+            int iBottom = pb.y() < 0.5f ? -1 : int(pb.y() - 0.5f);
+            int iLeft = int(left + 0.5f);
+            int iRight = right < 0.5f ? -1 : int(right - 0.5f);
+
+            int iWidth = iRight - iLeft + 1;
+            for (int y = iTop; y <= iBottom; ++y)
+                buffer.addSpan(iLeft, iWidth, y, 255);
+        }
+    } else {
+        if (pa.y() > pb.y())
+            qSwap(pa, pb);
+
+        QPointF delta = pb - pa;
+        delta *= 0.5f * width;
+        const QPointF perp(delta.y(), -delta.x());
+
+        QPointF top;
+        QPointF left;
+        QPointF right;
+        QPointF bottom;
+
+        if (pa.x() < pb.x()) {
+            top = pa + perp;
+            left = pa - perp;
+            right = pb + perp;
+            bottom = pb - perp;
+        } else {
+            top = pa - perp;
+            left = pb - perp;
+            right = pa + perp;
+            bottom = pb + perp;
+        }
+
+        top = snapTo26Dot6Grid(top);
+        bottom = snapTo26Dot6Grid(bottom);
+        left = snapTo26Dot6Grid(left);
+        right = snapTo26Dot6Grid(right);
+
+        const qreal topBound = qBound(qreal(d->clipRect.top()), top.y(), qreal(d->clipRect.bottom()));
+        const qreal bottomBound = qBound(qreal(d->clipRect.top()), bottom.y(), qreal(d->clipRect.bottom()));
+
+        const QPointF topLeftEdge = left - top;
+        const QPointF topRightEdge = right - top;
+        const QPointF bottomLeftEdge = bottom - left;
+        const QPointF bottomRightEdge = bottom - right;
+
+        const qreal topLeftSlope = topLeftEdge.x() / topLeftEdge.y();
+        const qreal bottomLeftSlope = bottomLeftEdge.x() / bottomLeftEdge.y();
+
+        const qreal topRightSlope = topRightEdge.x() / topRightEdge.y();
+        const qreal bottomRightSlope = bottomRightEdge.x() / bottomRightEdge.y();
+
+        const Q16Dot16 topLeftSlopeFP = FloatToQ16Dot16(topLeftSlope);
+        const Q16Dot16 topRightSlopeFP = FloatToQ16Dot16(topRightSlope);
+
+        const Q16Dot16 bottomLeftSlopeFP = FloatToQ16Dot16(bottomLeftSlope);
+        const Q16Dot16 bottomRightSlopeFP = FloatToQ16Dot16(bottomRightSlope);
+
+        const Q16Dot16 invTopLeftSlopeFP = FloatToQ16Dot16(1 / topLeftSlope);
+        const Q16Dot16 invTopRightSlopeFP = FloatToQ16Dot16(1 / topRightSlope);
+
+        const Q16Dot16 invBottomLeftSlopeFP = FloatToQ16Dot16(1 / bottomLeftSlope);
+        const Q16Dot16 invBottomRightSlopeFP = FloatToQ16Dot16(1 / bottomRightSlope);
+
+        if (d->antialiased) {
+            const Q16Dot16 iTopFP = IntToQ16Dot16(int(topBound));
+            const Q16Dot16 iLeftFP = IntToQ16Dot16(int(left.y()));
+            const Q16Dot16 iRightFP = IntToQ16Dot16(int(right.y()));
+            const Q16Dot16 iBottomFP = IntToQ16Dot16(int(bottomBound));
+
+            Q16Dot16 leftIntersectAf = FloatToQ16Dot16(top.x() + (int(topBound) - top.y()) * topLeftSlope);
+            Q16Dot16 rightIntersectAf = FloatToQ16Dot16(top.x() + (int(topBound) - top.y()) * topRightSlope);
+            Q16Dot16 leftIntersectBf = 0;
+            Q16Dot16 rightIntersectBf = 0;
+
+            if (iLeftFP < iTopFP)
+                leftIntersectBf = FloatToQ16Dot16(left.x() + (int(topBound) - left.y()) * bottomLeftSlope);
+
+            if (iRightFP < iTopFP)
+                rightIntersectBf = FloatToQ16Dot16(right.x() + (int(topBound) - right.y()) * bottomRightSlope);
+
+            Q16Dot16 rowTop, rowBottomLeft, rowBottomRight, rowTopLeft, rowTopRight, rowBottom;
+            Q16Dot16 topLeftIntersectAf, topLeftIntersectBf, topRightIntersectAf, topRightIntersectBf;
+            Q16Dot16 bottomLeftIntersectAf, bottomLeftIntersectBf, bottomRightIntersectAf, bottomRightIntersectBf;
+
+            int leftMin, leftMax, rightMin, rightMax;
+
+            const Q16Dot16 yTopFP = FloatToQ16Dot16(top.y());
+            const Q16Dot16 yLeftFP = FloatToQ16Dot16(left.y());
+            const Q16Dot16 yRightFP = FloatToQ16Dot16(right.y());
+            const Q16Dot16 yBottomFP = FloatToQ16Dot16(bottom.y());
+
+            rowTop = qMax(iTopFP, yTopFP);
+            topLeftIntersectAf = leftIntersectAf +
+                                 Q16Dot16Multiply(topLeftSlopeFP, rowTop - iTopFP);
+            topRightIntersectAf = rightIntersectAf +
+                                  Q16Dot16Multiply(topRightSlopeFP, rowTop - iTopFP);
+
+            Q16Dot16 yFP = iTopFP;
+            while (yFP <= iBottomFP) {
+                rowBottomLeft = qMin(yFP + Q16Dot16Factor, yLeftFP);
+                rowBottomRight = qMin(yFP + Q16Dot16Factor, yRightFP);
+                rowTopLeft = qMax(yFP, yLeftFP);
+                rowTopRight = qMax(yFP, yRightFP);
+                rowBottom = qMin(yFP + Q16Dot16Factor, yBottomFP);
+
+                if (yFP == iLeftFP) {
+                    const int y = Q16Dot16ToInt(yFP);
+                    leftIntersectBf = FloatToQ16Dot16(left.x() + (y - left.y()) * bottomLeftSlope);
+                    topLeftIntersectBf = leftIntersectBf + Q16Dot16Multiply(bottomLeftSlopeFP, rowTopLeft - yFP);
+                    bottomLeftIntersectAf = leftIntersectAf + Q16Dot16Multiply(topLeftSlopeFP, rowBottomLeft - yFP);
+                } else {
+                    topLeftIntersectBf = leftIntersectBf;
+                    bottomLeftIntersectAf = leftIntersectAf + topLeftSlopeFP;
+                }
+
+                if (yFP == iRightFP) {
+                    const int y = Q16Dot16ToInt(yFP);
+                    rightIntersectBf = FloatToQ16Dot16(right.x() + (y - right.y()) * bottomRightSlope);
+                    topRightIntersectBf = rightIntersectBf + Q16Dot16Multiply(bottomRightSlopeFP, rowTopRight - yFP);
+                    bottomRightIntersectAf = rightIntersectAf + Q16Dot16Multiply(topRightSlopeFP, rowBottomRight - yFP);
+                } else {
+                    topRightIntersectBf = rightIntersectBf;
+                    bottomRightIntersectAf = rightIntersectAf + topRightSlopeFP;
+                }
+
+                if (yFP == iBottomFP) {
+                    bottomLeftIntersectBf = leftIntersectBf + Q16Dot16Multiply(bottomLeftSlopeFP, rowBottom - yFP);
+                    bottomRightIntersectBf = rightIntersectBf + Q16Dot16Multiply(bottomRightSlopeFP, rowBottom - yFP);
+                } else {
+                    bottomLeftIntersectBf = leftIntersectBf + bottomLeftSlopeFP;
+                    bottomRightIntersectBf = rightIntersectBf + bottomRightSlopeFP;
+                }
+
+                if (yFP < iLeftFP) {
+                    leftMin = Q16Dot16ToInt(bottomLeftIntersectAf);
+                    leftMax = Q16Dot16ToInt(topLeftIntersectAf);
+                } else if (yFP == iLeftFP) {
+                    leftMin = Q16Dot16ToInt(qMax(bottomLeftIntersectAf, topLeftIntersectBf));
+                    leftMax = Q16Dot16ToInt(qMax(topLeftIntersectAf, bottomLeftIntersectBf));
+                } else {
+                    leftMin = Q16Dot16ToInt(topLeftIntersectBf);
+                    leftMax = Q16Dot16ToInt(bottomLeftIntersectBf);
+                }
+
+                leftMin = qBound(d->clipRect.left(), leftMin, d->clipRect.right());
+                leftMax = qBound(d->clipRect.left(), leftMax, d->clipRect.right());
+
+                if (yFP < iRightFP) {
+                    rightMin = Q16Dot16ToInt(topRightIntersectAf);
+                    rightMax = Q16Dot16ToInt(bottomRightIntersectAf);
+                } else if (yFP == iRightFP) {
+                    rightMin = Q16Dot16ToInt(qMin(topRightIntersectAf, bottomRightIntersectBf));
+                    rightMax = Q16Dot16ToInt(qMin(bottomRightIntersectAf, topRightIntersectBf));
+                } else {
+                    rightMin = Q16Dot16ToInt(bottomRightIntersectBf);
+                    rightMax = Q16Dot16ToInt(topRightIntersectBf);
+                }
+
+                rightMin = qBound(d->clipRect.left(), rightMin, d->clipRect.right());
+                rightMax = qBound(d->clipRect.left(), rightMax, d->clipRect.right());
+
+                if (leftMax > rightMax)
+                    leftMax = rightMax;
+                if (rightMin < leftMin)
+                    rightMin = leftMin;
+
+                Q16Dot16 rowHeight = rowBottom - rowTop;
+
+                int x = leftMin;
+                while (x <= leftMax) {
+                    Q16Dot16 excluded = 0;
+
+                    if (yFP <= iLeftFP)
+                        excluded += intersectPixelFP(x, rowTop, rowBottomLeft,
+                                                     bottomLeftIntersectAf, topLeftIntersectAf,
+                                                     topLeftSlopeFP, invTopLeftSlopeFP);
+                    if (yFP >= iLeftFP)
+                        excluded += intersectPixelFP(x, rowTopLeft, rowBottom,
+                                                     topLeftIntersectBf, bottomLeftIntersectBf,
+                                                     bottomLeftSlopeFP, invBottomLeftSlopeFP);
+
+                    if (x >= rightMin) {
+                        if (yFP <= iRightFP)
+                            excluded += (rowBottomRight - rowTop) - intersectPixelFP(x, rowTop, rowBottomRight,
+                                                                                     topRightIntersectAf, bottomRightIntersectAf,
+                                                                                     topRightSlopeFP, invTopRightSlopeFP);
+                        if (yFP >= iRightFP)
+                            excluded += (rowBottom - rowTopRight) - intersectPixelFP(x, rowTopRight, rowBottom,
+                                                                                     bottomRightIntersectBf, topRightIntersectBf,
+                                                                                     bottomRightSlopeFP, invBottomRightSlopeFP);
+                    }
+
+                    Q16Dot16 coverage = rowHeight - excluded;
+                    buffer.addSpan(x, 1, Q16Dot16ToInt(yFP),
+                                   Q16Dot16ToInt(255 * coverage));
+                    ++x;
+                }
+                if (x < rightMin) {
+                    buffer.addSpan(x, rightMin - x, Q16Dot16ToInt(yFP),
+                                   Q16Dot16ToInt(255 * rowHeight));
+                    x = rightMin;
+                }
+                while (x <= rightMax) {
+                    Q16Dot16 excluded = 0;
+                    if (yFP <= iRightFP)
+                        excluded += (rowBottomRight - rowTop) - intersectPixelFP(x, rowTop, rowBottomRight,
+                                                                                 topRightIntersectAf, bottomRightIntersectAf,
+                                                                                 topRightSlopeFP, invTopRightSlopeFP);
+                    if (yFP >= iRightFP)
+                        excluded += (rowBottom - rowTopRight) - intersectPixelFP(x, rowTopRight, rowBottom,
+                                                                                 bottomRightIntersectBf, topRightIntersectBf,
+                                                                                 bottomRightSlopeFP, invBottomRightSlopeFP);
+
+                    Q16Dot16 coverage = rowHeight - excluded;
+                    buffer.addSpan(x, 1, Q16Dot16ToInt(yFP),
+                                   Q16Dot16ToInt(255 * coverage));
+                    ++x;
+                }
+
+                leftIntersectAf += topLeftSlopeFP;
+                leftIntersectBf += bottomLeftSlopeFP;
+                rightIntersectAf += topRightSlopeFP;
+                rightIntersectBf += bottomRightSlopeFP;
+                topLeftIntersectAf = leftIntersectAf;
+                topRightIntersectAf = rightIntersectAf;
+
+                yFP += Q16Dot16Factor;
+                rowTop = yFP;
+            }
+        } else { // aliased
+            int iTop = int(top.y() + 0.5f);
+            int iLeft = left.y() < 0.5f ? -1 : int(left.y() - 0.5f);
+            int iRight = right.y() < 0.5f ? -1 : int(right.y() - 0.5f);
+            int iBottom = bottom.y() < 0.5f? -1 : int(bottom.y() - 0.5f);
+            int iMiddle = qMin(iLeft, iRight);
+
+            Q16Dot16 leftIntersectAf = FloatToQ16Dot16(top.x() + 0.5f + (iTop + 0.5f - top.y()) * topLeftSlope);
+            Q16Dot16 leftIntersectBf = FloatToQ16Dot16(left.x() + 0.5f + (iLeft + 1.5f - left.y()) * bottomLeftSlope);
+            Q16Dot16 rightIntersectAf = FloatToQ16Dot16(top.x() - 0.5f + (iTop + 0.5f - top.y()) * topRightSlope);
+            Q16Dot16 rightIntersectBf = FloatToQ16Dot16(right.x() - 0.5f + (iRight + 1.5f - right.y()) * bottomRightSlope);
+
+            int ny;
+            int y = iTop;
+#define DO_SEGMENT(next, li, ri, ls, rs) \
+            ny = qMin(next + 1, d->clipRect.top()); \
+            if (y < ny) { \
+                li += ls * (ny - y); \
+                ri += rs * (ny - y); \
+                y = ny; \
+            } \
+            if (next > d->clipRect.bottom()) \
+                next = d->clipRect.bottom(); \
+            for (; y <= next; ++y) { \
+                const int x1 = qMax(Q16Dot16ToInt(li), d->clipRect.left()); \
+                const int x2 = qMin(Q16Dot16ToInt(ri), d->clipRect.right()); \
+                if (x2 >= x1) \
+                    buffer.addSpan(x1, x2 - x1 + 1, y, 255); \
+                li += ls; \
+                ri += rs; \
+             }
+
+            DO_SEGMENT(iMiddle, leftIntersectAf, rightIntersectAf, topLeftSlopeFP, topRightSlopeFP)
+            DO_SEGMENT(iRight, leftIntersectBf, rightIntersectAf, bottomLeftSlopeFP, topRightSlopeFP)
+            DO_SEGMENT(iLeft, leftIntersectAf, rightIntersectBf, topLeftSlopeFP, bottomRightSlopeFP);
+            DO_SEGMENT(iBottom, leftIntersectBf, rightIntersectBf, bottomLeftSlopeFP, bottomRightSlopeFP);
+#undef DO_SEGMENT
+        }
+    }
+}
+
+void QRasterizer::rasterize(const QT_FT_Outline *outline, Qt::FillRule fillRule)
+{
+    if (outline->n_points < 3 || outline->n_contours == 0)
+        return;
+
+    const QT_FT_Vector *points = outline->points;
+
+    QSpanBuffer buffer(d->blend, d->data, d->clipRect);
+
+    // ### QT_FT_Outline already has a bounding rect which is
+    // ### precomputed at this point, so we should probably just be
+    // ### using that instead...
+    QT_FT_Pos min_y = points[0].y, max_y = points[0].y;
+    for (int i = 1; i < outline->n_points; ++i) {
+        const QT_FT_Vector &p = points[i];
+        min_y = qMin(p.y, min_y);
+        max_y = qMax(p.y, max_y);
+    }
+
+    int iTopBound = qMax(d->clipRect.top(), int((min_y + 32 + COORD_OFFSET - COORD_ROUNDING) >> 6));
+    int iBottomBound = qMin(d->clipRect.bottom(), int((max_y - 32 + COORD_OFFSET - COORD_ROUNDING) >> 6));
+
+    if (iTopBound > iBottomBound)
+        return;
+
+    d->scanConverter.begin(iTopBound, iBottomBound, d->clipRect.left(), d->clipRect.right(), fillRule, &buffer);
+
+    int first = 0;
+    for (int i = 0; i < outline->n_contours; ++i) {
+        const int last = outline->contours[i];
+        for (int j = first; j < last; ++j) {
+            if (outline->tags[j+1] == QT_FT_CURVE_TAG_CUBIC) {
+                Q_ASSERT(outline->tags[j+2] == QT_FT_CURVE_TAG_CUBIC);
+                d->scanConverter.mergeCurve(points[j], points[j+1], points[j+2], points[j+3]);
+                j += 2;
+            } else {
+                d->scanConverter.mergeLine(points[j], points[j+1]);
+            }
+        }
+
+        first = last + 1;
+    }
+
+    d->scanConverter.end();
+}
+
+void QRasterizer::rasterize(const QPainterPath &path, Qt::FillRule fillRule)
+{
+    if (path.isEmpty())
+        return;
+
+    QSpanBuffer buffer(d->blend, d->data, d->clipRect);
+
+    QRectF bounds = path.controlPointRect();
+
+    int iTopBound = qMax(d->clipRect.top(), int(bounds.top() + 0.5 + (COORD_OFFSET - COORD_ROUNDING)/64.));
+    int iBottomBound = qMin(d->clipRect.bottom(), int(bounds.bottom() - 0.5 + (COORD_OFFSET - COORD_ROUNDING)/64.));
+
+    if (iTopBound > iBottomBound)
+        return;
+
+    d->scanConverter.begin(iTopBound, iBottomBound, d->clipRect.left(), d->clipRect.right(), fillRule, &buffer);
+
+    int subpathStart = 0;
+    QT_FT_Vector last = { 0, 0 };
+    for (int i = 0; i < path.elementCount(); ++i) {
+        switch (path.elementAt(i).type) {
+        case QPainterPath::LineToElement:
+            {
+                QT_FT_Vector p1 = last;
+                QT_FT_Vector p2 = PointToVector(path.elementAt(i));
+                d->scanConverter.mergeLine(p1, p2);
+                last = p2;
+                break;
+            }
+        case QPainterPath::MoveToElement:
+            {
+                if (i != 0) {
+                    QT_FT_Vector first = PointToVector(path.elementAt(subpathStart));
+                    // close previous subpath
+                    if (first.x != last.x || first.y != last.y)
+                        d->scanConverter.mergeLine(last, first);
+                }
+                subpathStart = i;
+                last = PointToVector(path.elementAt(i));
+                break;
+            }
+        case QPainterPath::CurveToElement:
+            {
+                QT_FT_Vector p1 = last;
+                QT_FT_Vector p2 = PointToVector(path.elementAt(i));
+                QT_FT_Vector p3 = PointToVector(path.elementAt(++i));
+                QT_FT_Vector p4 = PointToVector(path.elementAt(++i));
+                d->scanConverter.mergeCurve(p1, p2, p3, p4);
+                last = p4;
+                break;
+            }
+        default:
+            Q_ASSERT(false);
+            break;
+        }
+    }
+
+    QT_FT_Vector first = PointToVector(path.elementAt(subpathStart));
+
+    // close path
+    if (first.x != last.x || first.y != last.y)
+        d->scanConverter.mergeLine(last, first);
+
+    d->scanConverter.end();
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qrasterizer_p.h b/src/gui/painting/qrasterizer_p.h
new file mode 100644
index 0000000000..d640600172
--- /dev/null
+++ b/src/gui/painting/qrasterizer_p.h
@@ -0,0 +1,95 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QRASTERIZER_P_H
+#define QRASTERIZER_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "QtCore/qglobal.h"
+#include "QtGui/qpainter.h"
+
+#include <private/qdrawhelper_p.h>
+#include <private/qrasterdefs_p.h>
+
+QT_BEGIN_NAMESPACE
+
+struct QSpanData;
+class QRasterBuffer;
+class QRasterizerPrivate;
+
+class
+#ifdef Q_WS_QWS
+Q_GUI_EXPORT
+#endif
+QRasterizer
+{
+public:
+    QRasterizer();
+    ~QRasterizer();
+
+    void setAntialiased(bool antialiased);
+    void setClipRect(const QRect &clipRect);
+
+    void initialize(ProcessSpans blend, void *data);
+
+    void rasterize(const QT_FT_Outline *outline, Qt::FillRule fillRule);
+    void rasterize(const QPainterPath &path, Qt::FillRule fillRule);
+
+    // width should be in units of |a-b|
+    void rasterizeLine(const QPointF &a, const QPointF &b, qreal width, bool squareCap = false);
+
+private:
+    QRasterizerPrivate *d;
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/gui/painting/qregion.cpp b/src/gui/painting/qregion.cpp
new file mode 100644
index 0000000000..d713346902
--- /dev/null
+++ b/src/gui/painting/qregion.cpp
@@ -0,0 +1,4365 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qregion.h"
+#include "qpainterpath.h"
+#include "qpolygon.h"
+#include "qbuffer.h"
+#include "qdatastream.h"
+#include "qvariant.h"
+#include "qvarlengtharray.h"
+
+#include <qdebug.h>
+
+#if defined(Q_OS_UNIX) || defined(Q_WS_WIN)
+#include "qimage.h"
+#include "qbitmap.h"
+#include <stdlib.h>
+#endif
+
+QT_BEGIN_NAMESPACE
+
+/*!
+    \class QRegion
+    \brief The QRegion class specifies a clip region for a painter.
+
+    \ingroup painting
+    \ingroup shared
+
+    QRegion is used with QPainter::setClipRegion() to limit the paint
+    area to what needs to be painted. There is also a QWidget::repaint()
+    function that takes a QRegion parameter. QRegion is the best tool for
+    minimizing the amount of screen area to be updated by a repaint.
+
+    This class is not suitable for constructing shapes for rendering, especially
+    as outlines. Use QPainterPath to create paths and shapes for use with
+    QPainter.
+
+    QRegion is an \l{implicitly shared} class.
+
+    \section1 Creating and Using Regions
+
+    A region can be created from a rectangle, an ellipse, a polygon or
+    a bitmap. Complex regions may be created by combining simple
+    regions using united(), intersected(), subtracted(), or xored() (exclusive
+    or). You can move a region using translate().
+
+    You can test whether a region isEmpty() or if it
+    contains() a QPoint or QRect. The bounding rectangle can be found
+    with boundingRect().
+
+    The function rects() gives a decomposition of the region into
+    rectangles.
+
+    Example of using complex regions:
+    \snippet doc/src/snippets/code/src_gui_painting_qregion.cpp 0
+
+    \section1 Additional License Information
+
+    On Embedded Linux, Windows CE and X11 platforms, parts of this class rely on
+    code obtained under the following licenses:
+
+    \legalese
+    Copyright (c) 1987  X Consortium
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in
+    all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+    X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+    AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+    CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+    Except as contained in this notice, the name of the X Consortium shall not be
+    used in advertising or otherwise to promote the sale, use or other dealings
+    in this Software without prior written authorization from the X Consortium.
+    \endlegalese
+
+    \br
+
+    \legalese
+    Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
+
+                            All Rights Reserved
+
+    Permission to use, copy, modify, and distribute this software and its
+    documentation for any purpose and without fee is hereby granted,
+    provided that the above copyright notice appear in all copies and that
+    both that copyright notice and this permission notice appear in
+    supporting documentation, and that the name of Digital not be
+    used in advertising or publicity pertaining to distribution of the
+    software without specific, written prior permission.
+
+    DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+    ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+    DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+    ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+    WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+    ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+    SOFTWARE.
+    \endlegalese
+
+    \sa QPainter::setClipRegion(), QPainter::setClipRect(), QPainterPath
+*/
+
+
+/*!
+    \enum QRegion::RegionType
+
+    Specifies the shape of the region to be created.
+
+    \value Rectangle  the region covers the entire rectangle.
+    \value Ellipse  the region is an ellipse inside the rectangle.
+*/
+
+/*!
+    \fn void QRegion::translate(const QPoint &point)
+
+    \overload
+
+    Translates the region \a{point}\e{.x()} along the x axis and
+    \a{point}\e{.y()} along the y axis, relative to the current
+    position. Positive values move the region to the right and down.
+
+    Translates to the given \a point.
+*/
+
+/*!
+    \fn Handle QRegion::handle() const
+
+    Returns a platform-specific region handle. The \c Handle type is
+    \c HRGN on Windows, \c Region on X11, and \c RgnHandle on Mac OS
+    X. On \l{Qt for Embedded Linux} it is \c {void *}.
+
+    \warning This function is not portable.
+*/
+
+/*****************************************************************************
+  QRegion member functions
+ *****************************************************************************/
+
+/*!
+    \fn QRegion::QRegion()
+
+    Constructs an empty region.
+
+    \sa isEmpty()
+*/
+
+/*!
+    \fn QRegion::QRegion(const QRect &r, RegionType t)
+    \overload
+
+    Create a region based on the rectange \a r with region type \a t.
+
+    If the rectangle is invalid a null region will be created.
+
+    \sa QRegion::RegionType
+*/
+
+/*!
+    \fn QRegion::QRegion(const QPolygon &a, Qt::FillRule fillRule)
+
+    Constructs a polygon region from the point array \a a with the fill rule
+    specified by \a fillRule.
+
+    If \a fillRule is \l{Qt::WindingFill}, the polygon region is defined
+    using the winding algorithm; if it is \l{Qt::OddEvenFill}, the odd-even fill
+    algorithm is used.
+
+    \warning This constructor can be used to create complex regions that will
+    slow down painting when used.
+*/
+
+/*!
+    \fn QRegion::QRegion(const QRegion &r)
+
+    Constructs a new region which is equal to region \a r.
+*/
+
+/*!
+    \fn QRegion::QRegion(const QBitmap &bm)
+
+    Constructs a region from the bitmap \a bm.
+
+    The resulting region consists of the pixels in bitmap \a bm that
+    are Qt::color1, as if each pixel was a 1 by 1 rectangle.
+
+    This constructor may create complex regions that will slow down
+    painting when used. Note that drawing masked pixmaps can be done
+    much faster using QPixmap::setMask().
+*/
+
+/*!
+    Constructs a rectangular or elliptic region.
+
+    If \a t is \c Rectangle, the region is the filled rectangle (\a x,
+    \a y, \a w, \a h). If \a t is \c Ellipse, the region is the filled
+    ellipse with center at (\a x + \a w / 2, \a y + \a h / 2) and size
+    (\a w ,\a h).
+*/
+QRegion::QRegion(int x, int y, int w, int h, RegionType t)
+{
+    QRegion tmp(QRect(x, y, w, h), t);
+    tmp.d->ref.ref();
+    d = tmp.d;
+}
+
+#ifdef QT3_SUPPORT
+/*!
+    Use the constructor tha takes a Qt::FillRule as the second
+    argument instead.
+*/
+QRegion::QRegion(const QPolygon &pa, bool winding)
+{
+    new (this) QRegion(pa, winding ? Qt::WindingFill : Qt::OddEvenFill);
+}
+#endif
+
+/*!
+    \fn QRegion::~QRegion()
+    \internal
+
+    Destroys the region.
+*/
+
+void QRegion::detach()
+{
+    if (d->ref != 1)
+        *this = copy();
+#if defined(Q_WS_X11)
+    else if (d->xrectangles) {
+        free(d->xrectangles);
+        d->xrectangles = 0;
+    }
+#endif
+}
+
+// duplicates in qregion_win.cpp and qregion_wce.cpp
+#define QRGN_SETRECT          1                // region stream commands
+#define QRGN_SETELLIPSE       2                //  (these are internal)
+#define QRGN_SETPTARRAY_ALT   3
+#define QRGN_SETPTARRAY_WIND  4
+#define QRGN_TRANSLATE        5
+#define QRGN_OR               6
+#define QRGN_AND              7
+#define QRGN_SUB              8
+#define QRGN_XOR              9
+#define QRGN_RECTS            10
+
+
+#ifndef QT_NO_DATASTREAM
+
+/*
+    Executes region commands in the internal buffer and rebuilds the
+    original region.
+
+    We do this when we read a region from the data stream.
+
+    If \a ver is non-0, uses the format version \a ver on reading the
+    byte array.
+*/
+void QRegion::exec(const QByteArray &buffer, int ver, QDataStream::ByteOrder byteOrder)
+{
+    QByteArray copy = buffer;
+    QDataStream s(&copy, QIODevice::ReadOnly);
+    if (ver)
+        s.setVersion(ver);
+    s.setByteOrder(byteOrder);
+    QRegion rgn;
+#ifndef QT_NO_DEBUG
+    int test_cnt = 0;
+#endif
+    while (!s.atEnd()) {
+        qint32 id;
+        if (s.version() == 1) {
+            int id_int;
+            s >> id_int;
+            id = id_int;
+        } else {
+            s >> id;
+        }
+#ifndef QT_NO_DEBUG
+        if (test_cnt > 0 && id != QRGN_TRANSLATE)
+            qWarning("QRegion::exec: Internal error");
+        test_cnt++;
+#endif
+        if (id == QRGN_SETRECT || id == QRGN_SETELLIPSE) {
+            QRect r;
+            s >> r;
+            rgn = QRegion(r, id == QRGN_SETRECT ? Rectangle : Ellipse);
+        } else if (id == QRGN_SETPTARRAY_ALT || id == QRGN_SETPTARRAY_WIND) {
+            QPolygon a;
+            s >> a;
+            rgn = QRegion(a, id == QRGN_SETPTARRAY_WIND ? Qt::WindingFill : Qt::OddEvenFill);
+        } else if (id == QRGN_TRANSLATE) {
+            QPoint p;
+            s >> p;
+            rgn.translate(p.x(), p.y());
+        } else if (id >= QRGN_OR && id <= QRGN_XOR) {
+            QByteArray bop1, bop2;
+            QRegion r1, r2;
+            s >> bop1;
+            r1.exec(bop1);
+            s >> bop2;
+            r2.exec(bop2);
+
+            switch (id) {
+                case QRGN_OR:
+                    rgn = r1.united(r2);
+                    break;
+                case QRGN_AND:
+                    rgn = r1.intersected(r2);
+                    break;
+                case QRGN_SUB:
+                    rgn = r1.subtracted(r2);
+                    break;
+                case QRGN_XOR:
+                    rgn = r1.xored(r2);
+                    break;
+            }
+        } else if (id == QRGN_RECTS) {
+            // (This is the only form used in Qt 2.0)
+            quint32 n;
+            s >> n;
+            QRect r;
+            for (int i=0; i<(int)n; i++) {
+                s >> r;
+                rgn = rgn.united(QRegion(r));
+            }
+        }
+    }
+    *this = rgn;
+}
+
+
+/*****************************************************************************
+  QRegion stream functions
+ *****************************************************************************/
+
+/*!
+    \fn QRegion &QRegion::operator=(const QRegion &r)
+
+    Assigns \a r to this region and returns a reference to the region.
+*/
+
+/*!
+    \fn void QRegion::swap(QRegion &other)
+    \since 4.8
+
+    Swaps region \a other with this region. This operation is very
+    fast and never fails.
+*/
+
+/*!
+    \relates QRegion
+
+    Writes the region \a r to the stream \a s and returns a reference
+    to the stream.
+
+    \sa \link datastreamformat.html Format of the QDataStream operators \endlink
+*/
+
+QDataStream &operator<<(QDataStream &s, const QRegion &r)
+{
+    QVector<QRect> a = r.rects();
+    if (a.isEmpty()) {
+        s << (quint32)0;
+    } else {
+        if (s.version() == 1) {
+            int i;
+            for (i = a.size() - 1; i > 0; --i) {
+                s << (quint32)(12 + i * 24);
+                s << (int)QRGN_OR;
+            }
+            for (i = 0; i < a.size(); ++i) {
+                s << (quint32)(4+8) << (int)QRGN_SETRECT << a[i];
+            }
+        } else {
+            s << (quint32)(4 + 4 + 16 * a.size()); // 16: storage size of QRect
+            s << (qint32)QRGN_RECTS;
+            s << a;
+        }
+    }
+    return s;
+}
+
+/*!
+    \relates QRegion
+
+    Reads a region from the stream \a s into \a r and returns a
+    reference to the stream.
+
+    \sa \link datastreamformat.html Format of the QDataStream operators \endlink
+*/
+
+QDataStream &operator>>(QDataStream &s, QRegion &r)
+{
+    QByteArray b;
+    s >> b;
+    r.exec(b, s.version(), s.byteOrder());
+    return s;
+}
+#endif //QT_NO_DATASTREAM
+
+#ifndef QT_NO_DEBUG_STREAM
+QDebug operator<<(QDebug s, const QRegion &r)
+{
+    QVector<QRect> rects = r.rects();
+    s.nospace() << "QRegion(size=" << rects.size() << "), "
+                << "bounds = " << r.boundingRect() << '\n';
+    for (int i=0; i<rects.size(); ++i)
+        s << "- " << i << rects.at(i) << '\n';
+    return s;
+}
+#endif
+
+
+// These are not inline - they can be implemented better on some platforms
+//  (eg. Windows at least provides 3-variable operations).  For now, simple.
+
+
+/*!
+    Applies the united() function to this region and \a r. \c r1|r2 is
+    equivalent to \c r1.united(r2).
+
+    \sa united(), operator+()
+*/
+const QRegion QRegion::operator|(const QRegion &r) const
+    { return united(r); }
+
+/*!
+    Applies the united() function to this region and \a r. \c r1+r2 is
+    equivalent to \c r1.united(r2).
+
+    \sa united(), operator|()
+*/
+const QRegion QRegion::operator+(const QRegion &r) const
+    { return united(r); }
+
+/*!
+   \overload
+   \since 4.4
+ */
+const QRegion QRegion::operator+(const QRect &r) const
+    { return united(r); }
+
+/*!
+    Applies the intersected() function to this region and \a r. \c r1&r2
+    is equivalent to \c r1.intersected(r2).
+
+    \sa intersected()
+*/
+const QRegion QRegion::operator&(const QRegion &r) const
+    { return intersected(r); }
+
+/*!
+   \overload
+   \since 4.4
+ */
+const QRegion QRegion::operator&(const QRect &r) const
+{
+    return intersected(r);
+}
+
+/*!
+    Applies the subtracted() function to this region and \a r. \c r1-r2
+    is equivalent to \c r1.subtracted(r2).
+
+    \sa subtracted()
+*/
+const QRegion QRegion::operator-(const QRegion &r) const
+    { return subtracted(r); }
+
+/*!
+    Applies the xored() function to this region and \a r. \c r1^r2 is
+    equivalent to \c r1.xored(r2).
+
+    \sa xored()
+*/
+const QRegion QRegion::operator^(const QRegion &r) const
+    { return xored(r); }
+
+/*!
+    Applies the united() function to this region and \a r and assigns
+    the result to this region. \c r1|=r2 is equivalent to \c
+    {r1 = r1.united(r2)}.
+
+    \sa united()
+*/
+QRegion& QRegion::operator|=(const QRegion &r)
+    { return *this = *this | r; }
+
+/*!
+    \fn QRegion& QRegion::operator+=(const QRect &rect)
+
+    Returns a region that is the union of this region with the specified \a rect.
+
+    \sa united()
+*/
+/*!
+    \fn QRegion& QRegion::operator+=(const QRegion &r)
+
+    Applies the united() function to this region and \a r and assigns
+    the result to this region. \c r1+=r2 is equivalent to \c
+    {r1 = r1.united(r2)}.
+
+    \sa intersected()
+*/
+#if !defined (Q_OS_UNIX) && !defined (Q_WS_WIN)
+QRegion& QRegion::operator+=(const QRect &r)
+{
+    return operator+=(QRegion(r));
+}
+#endif
+
+/*!
+  \fn QRegion& QRegion::operator&=(const QRegion &r)
+
+  Applies the intersected() function to this region and \a r and
+  assigns the result to this region. \c r1&=r2 is equivalent to \c
+  r1 = r1.intersected(r2).
+
+  \sa intersected()
+*/
+QRegion& QRegion::operator&=(const QRegion &r)
+    { return *this = *this & r; }
+
+/*!
+   \overload
+   \since 4.4
+ */
+#if defined (Q_OS_UNIX) || defined (Q_WS_WIN)
+QRegion& QRegion::operator&=(const QRect &r)
+{
+    return *this = *this & r;
+}
+#else
+QRegion& QRegion::operator&=(const QRect &r)
+{
+    return *this &= (QRegion(r));
+}
+#endif
+
+/*!
+  \fn QRegion& QRegion::operator-=(const QRegion &r)
+
+  Applies the subtracted() function to this region and \a r and
+  assigns the result to this region. \c r1-=r2 is equivalent to \c
+  {r1 = r1.subtracted(r2)}.
+
+  \sa subtracted()
+*/
+QRegion& QRegion::operator-=(const QRegion &r)
+    { return *this = *this - r; }
+
+/*!
+    Applies the xored() function to this region and \a r and
+    assigns the result to this region. \c r1^=r2 is equivalent to \c
+    {r1 = r1.xored(r2)}.
+
+    \sa xored()
+*/
+QRegion& QRegion::operator^=(const QRegion &r)
+    { return *this = *this ^ r; }
+
+/*!
+    \fn bool QRegion::operator!=(const QRegion &other) const
+
+    Returns true if this region is different from the \a other region;
+    otherwise returns false.
+*/
+
+/*!
+   Returns the region as a QVariant
+*/
+QRegion::operator QVariant() const
+{
+    return QVariant(QVariant::Region, this);
+}
+
+/*!
+    \fn bool QRegion::operator==(const QRegion &r) const
+
+    Returns true if the region is equal to \a r; otherwise returns
+    false.
+*/
+
+/*!
+    \fn bool QRegion::isNull() const
+
+    Use isEmpty() instead.
+*/
+
+
+/*!
+    \fn void QRegion::translate(int dx, int dy)
+
+    Translates (moves) the region \a dx along the X axis and \a dy
+    along the Y axis.
+*/
+
+/*!
+    \fn QRegion QRegion::translated(const QPoint &p) const
+    \overload
+    \since 4.1
+
+    Returns a copy of the regtion that is translated \a{p}\e{.x()}
+    along the x axis and \a{p}\e{.y()} along the y axis, relative to
+    the current position.  Positive values move the rectangle to the
+    right and down.
+
+    \sa translate()
+*/
+
+/*!
+    \since 4.1
+
+    Returns a copy of the region that is translated \a dx along the
+    x axis and \a dy along the y axis, relative to the current
+    position. Positive values move the region to the right and
+    down.
+
+    \sa translate()
+*/
+
+QRegion
+QRegion::translated(int dx, int dy) const
+{
+    QRegion ret(*this);
+    ret.translate(dx, dy);
+    return ret;
+}
+
+
+inline bool rect_intersects(const QRect &r1, const QRect &r2)
+{
+    return (r1.right() >= r2.left() && r1.left() <= r2.right() &&
+            r1.bottom() >= r2.top() && r1.top() <= r2.bottom());
+}
+
+/*!
+    \since 4.2
+
+    Returns true if this region intersects with \a region, otherwise
+    returns false.
+*/
+bool QRegion::intersects(const QRegion &region) const
+{
+    if (isEmpty() || region.isEmpty())
+        return false;
+
+    if (!rect_intersects(boundingRect(), region.boundingRect()))
+        return false;
+    if (rectCount() == 1 && region.rectCount() == 1)
+        return true;
+
+    const QVector<QRect> myRects = rects();
+    const QVector<QRect> otherRects = region.rects();
+
+    for (QVector<QRect>::const_iterator i1 = myRects.constBegin(); i1 < myRects.constEnd(); ++i1)
+        for (QVector<QRect>::const_iterator i2 = otherRects.constBegin(); i2 < otherRects.constEnd(); ++i2)
+            if (rect_intersects(*i1, *i2))
+                return true;
+    return false;
+}
+
+/*!
+    \fn bool QRegion::intersects(const QRect &rect) const
+    \since 4.2
+
+    Returns true if this region intersects with \a rect, otherwise
+    returns false.
+*/
+
+
+#if !defined (Q_OS_UNIX) && !defined (Q_WS_WIN)
+/*!
+    \overload
+    \since 4.4
+*/
+QRegion QRegion::intersect(const QRect &r) const
+{
+    return intersect(QRegion(r));
+}
+#endif
+
+/*!
+    \obsolete
+    \fn int QRegion::numRects() const
+    \since 4.4
+
+    Returns the number of rectangles that will be returned in rects().
+*/
+
+/*!
+    \fn int QRegion::rectCount() const
+    \since 4.6
+
+    Returns the number of rectangles that will be returned in rects().
+*/
+
+/*!
+    \fn bool QRegion::isEmpty() const
+
+    Returns true if the region is empty; otherwise returns false. An
+    empty region is a region that contains no points.
+
+    Example:
+    \snippet doc/src/snippets/code/src_gui_painting_qregion_unix.cpp 0
+*/
+
+/*!
+    \fn bool QRegion::contains(const QPoint &p) const
+
+    Returns true if the region contains the point \a p; otherwise
+    returns false.
+*/
+
+/*!
+    \fn bool QRegion::contains(const QRect &r) const
+    \overload
+
+    Returns true if the region overlaps the rectangle \a r; otherwise
+    returns false.
+*/
+
+/*!
+    \fn QRegion QRegion::unite(const QRegion &r) const
+    \obsolete
+
+    Use united(\a r) instead.
+*/
+
+/*!
+    \fn QRegion QRegion::unite(const QRect &rect) const
+    \since 4.4
+    \obsolete
+
+    Use united(\a rect) instead.
+*/
+
+/*!
+    \fn QRegion QRegion::united(const QRect &rect) const
+    \since 4.4
+
+    Returns a region which is the union of this region and the given \a rect.
+
+    \sa intersected(), subtracted(), xored()
+*/
+
+/*!
+    \fn QRegion QRegion::united(const QRegion &r) const
+    \since 4.2
+
+    Returns a region which is the union of this region and \a r.
+
+    \img runion.png Region Union
+
+    The figure shows the union of two elliptical regions.
+
+    \sa intersected(), subtracted(), xored()
+*/
+
+/*!
+    \fn QRegion QRegion::intersect(const QRegion &r) const
+    \obsolete
+
+    Use intersected(\a r) instead.
+*/
+
+/*!
+    \fn QRegion QRegion::intersect(const QRect &rect) const
+    \since 4.4
+    \obsolete
+
+    Use intersected(\a rect) instead.
+*/
+
+/*!
+    \fn QRegion QRegion::intersected(const QRect &rect) const
+    \since 4.4
+
+    Returns a region which is the intersection of this region and the given \a rect.
+
+    \sa subtracted(), united(), xored()
+*/
+
+/*!
+    \fn QRegion QRegion::intersected(const QRegion &r) const
+    \since 4.2
+
+    Returns a region which is the intersection of this region and \a r.
+
+    \img rintersect.png Region Intersection
+
+    The figure shows the intersection of two elliptical regions.
+
+    \sa subtracted(), united(), xored()
+*/
+
+/*!
+    \fn QRegion QRegion::subtract(const QRegion &r) const
+    \obsolete
+
+    Use subtracted(\a r) instead.
+*/
+
+/*!
+    \fn QRegion QRegion::subtracted(const QRegion &r) const
+    \since 4.2
+
+    Returns a region which is \a r subtracted from this region.
+
+    \img rsubtract.png Region Subtraction
+
+    The figure shows the result when the ellipse on the right is
+    subtracted from the ellipse on the left (\c {left - right}).
+
+    \sa intersected(), united(), xored()
+*/
+
+/*!
+    \fn QRegion QRegion::eor(const QRegion &r) const
+    \obsolete
+
+    Use xored(\a r) instead.
+*/
+
+/*!
+    \fn QRegion QRegion::xored(const QRegion &r) const
+    \since 4.2
+
+    Returns a region which is the exclusive or (XOR) of this region
+    and \a r.
+
+    \img rxor.png Region XORed
+
+    The figure shows the exclusive or of two elliptical regions.
+
+    \sa intersected(), united(), subtracted()
+*/
+
+/*!
+    \fn QRect QRegion::boundingRect() const
+
+    Returns the bounding rectangle of this region. An empty region
+    gives a rectangle that is QRect::isNull().
+*/
+
+/*!
+    \fn QVector<QRect> QRegion::rects() const
+
+    Returns an array of non-overlapping rectangles that make up the
+    region.
+
+    The union of all the rectangles is equal to the original region.
+*/
+
+/*!
+    \fn void QRegion::setRects(const QRect *rects, int number)
+
+    Sets the region using the array of rectangles specified by \a rects and
+    \a number.
+    The rectangles \e must be optimally Y-X sorted and follow these restrictions:
+
+    \list
+    \o The rectangles must not intersect.
+    \o All rectangles with a given top coordinate must have the same height.
+    \o No two rectangles may abut horizontally (they should be combined
+       into a single wider rectangle in that case).
+    \o The rectangles must be sorted in ascending order, with Y as the major
+       sort key and X as the minor sort key.
+    \endlist
+    \omit
+    Only some platforms have these restrictions (Qt for Embedded Linux, X11 and Mac OS X).
+    \endomit
+*/
+
+namespace {
+
+struct Segment
+{
+    Segment() {}
+    Segment(const QPoint &p)
+        : added(false)
+        , point(p)
+    {
+    }
+
+    int left() const
+    {
+        return qMin(point.x(), next->point.x());
+    }
+
+    int right() const
+    {
+        return qMax(point.x(), next->point.x());
+    }
+
+    bool overlaps(const Segment &other) const
+    {
+        return left() < other.right() && other.left() < right();
+    }
+
+    void connect(Segment &other)
+    {
+        next = &other;
+        other.prev = this;
+
+        horizontal = (point.y() == other.point.y());
+    }
+
+    void merge(Segment &other)
+    {
+        if (right() <= other.right()) {
+            QPoint p = other.point;
+            Segment *oprev = other.prev;
+
+            other.point = point;
+            other.prev = prev;
+            prev->next = &other;
+
+            point = p;
+            prev = oprev;
+            oprev->next = this;
+        } else {
+            Segment *onext = other.next;
+            other.next = next;
+            next->prev = &other;
+
+            next = onext;
+            next->prev = this;
+        }
+    }
+
+    int horizontal : 1;
+    int added : 1;
+
+    QPoint point;
+    Segment *prev;
+    Segment *next;
+};
+
+void mergeSegments(Segment *a, int na, Segment *b, int nb)
+{
+    int i = 0;
+    int j = 0;
+
+    while (i != na && j != nb) {
+        Segment &sa = a[i];
+        Segment &sb = b[j];
+        const int ra = sa.right();
+        const int rb = sb.right();
+        if (sa.overlaps(sb))
+            sa.merge(sb);
+        i += (rb >= ra);
+        j += (ra >= rb);
+    }
+}
+
+void addSegmentsToPath(Segment *segment, QPainterPath &path)
+{
+    Segment *current = segment;
+    path.moveTo(current->point);
+
+    current->added = true;
+
+    Segment *last = current;
+    current = current->next;
+    while (current != segment) {
+        if (current->horizontal != last->horizontal)
+            path.lineTo(current->point);
+        current->added = true;
+        last = current;
+        current = current->next;
+    }
+}
+
+}
+
+Q_AUTOTEST_EXPORT QPainterPath qt_regionToPath(const QRegion &region)
+{
+    QPainterPath result;
+    if (region.rectCount() == 1) {
+        result.addRect(region.boundingRect());
+        return result;
+    }
+
+    const QVector<QRect> rects = region.rects();
+
+    QVarLengthArray<Segment> segments;
+    segments.resize(4 * rects.size());
+
+    const QRect *rect = rects.constData();
+    const QRect *end = rect + rects.size();
+
+    int lastRowSegmentCount = 0;
+    Segment *lastRowSegments = 0;
+
+    int lastSegment = 0;
+    int lastY = 0;
+    while (rect != end) {
+        const int y = rect[0].y();
+        int count = 0;
+        while (&rect[count] != end && rect[count].y() == y)
+            ++count;
+
+        for (int i = 0; i < count; ++i) {
+            int offset = lastSegment + i;
+            segments[offset] = Segment(rect[i].topLeft());
+            segments[offset += count] = Segment(rect[i].topRight() + QPoint(1, 0));
+            segments[offset += count] = Segment(rect[i].bottomRight() + QPoint(1, 1));
+            segments[offset += count] = Segment(rect[i].bottomLeft() + QPoint(0, 1));
+
+            offset = lastSegment + i;
+            for (int j = 0; j < 4; ++j)
+                segments[offset + j * count].connect(segments[offset + ((j + 1) % 4) * count]);
+        }
+
+        if (lastRowSegments && lastY == y)
+            mergeSegments(lastRowSegments, lastRowSegmentCount, &segments[lastSegment], count);
+
+        lastRowSegments = &segments[lastSegment + 2 * count];
+        lastRowSegmentCount = count;
+        lastSegment += 4 * count;
+        lastY = y + rect[0].height();
+        rect += count;
+    }
+
+    for (int i = 0; i < lastSegment; ++i) {
+        Segment *segment = &segments[i];
+        if (!segment->added)
+            addSegmentsToPath(segment, result);
+    }
+
+    return result;
+}
+
+#if defined(Q_OS_UNIX) || defined(Q_WS_WIN)
+
+//#define QT_REGION_DEBUG
+/*
+ *   clip region
+ */
+
+struct QRegionPrivate {
+    int numRects;
+    QVector<QRect> rects;
+    QRect extents;
+    QRect innerRect;
+    int innerArea;
+
+    inline QRegionPrivate() : numRects(0), innerArea(-1) {}
+    inline QRegionPrivate(const QRect &r) {
+        numRects = 1;
+        extents = r;
+        innerRect = r;
+        innerArea = r.width() * r.height();
+    }
+
+    inline QRegionPrivate(const QRegionPrivate &r) {
+        rects = r.rects;
+        numRects = r.numRects;
+        extents = r.extents;
+        innerRect = r.innerRect;
+        innerArea = r.innerArea;
+    }
+
+    inline QRegionPrivate &operator=(const QRegionPrivate &r) {
+        rects = r.rects;
+        numRects = r.numRects;
+        extents = r.extents;
+        innerRect = r.innerRect;
+        innerArea = r.innerArea;
+        return *this;
+    }
+
+    void intersect(const QRect &r);
+
+    /*
+     * Returns true if r is guaranteed to be fully contained in this region.
+     * A false return value does not guarantee the opposite.
+     */
+    inline bool contains(const QRegionPrivate &r) const {
+        return contains(r.extents);
+    }
+
+    inline bool contains(const QRect &r2) const {
+        const QRect &r1 = innerRect;
+        return r2.left() >= r1.left() && r2.right() <= r1.right()
+            && r2.top() >= r1.top() && r2.bottom() <= r1.bottom();
+    }
+
+    /*
+     * Returns true if this region is guaranteed to be fully contained in r.
+     */
+    inline bool within(const QRect &r1) const {
+        const QRect &r2 = extents;
+        return r2.left() >= r1.left() && r2.right() <= r1.right()
+            && r2.top() >= r1.top() && r2.bottom() <= r1.bottom();
+    }
+
+    inline void updateInnerRect(const QRect &rect) {
+        const int area = rect.width() * rect.height();
+        if (area > innerArea) {
+            innerArea = area;
+            innerRect = rect;
+        }
+    }
+
+    inline void vectorize() {
+        if (numRects == 1) {
+            if (!rects.size())
+                rects.resize(1);
+            rects[0] = extents;
+        }
+    }
+
+    inline void append(const QRect *r);
+    void append(const QRegionPrivate *r);
+    void prepend(const QRect *r);
+    void prepend(const QRegionPrivate *r);
+    inline bool canAppend(const QRect *r) const;
+    inline bool canAppend(const QRegionPrivate *r) const;
+    inline bool canPrepend(const QRect *r) const;
+    inline bool canPrepend(const QRegionPrivate *r) const;
+
+    inline bool mergeFromRight(QRect *left, const QRect *right);
+    inline bool mergeFromLeft(QRect *left, const QRect *right);
+    inline bool mergeFromBelow(QRect *top, const QRect *bottom,
+                               const QRect *nextToTop,
+                               const QRect *nextToBottom);
+    inline bool mergeFromAbove(QRect *bottom, const QRect *top,
+                               const QRect *nextToBottom,
+                               const QRect *nextToTop);
+
+#ifdef QT_REGION_DEBUG
+    void selfTest() const;
+#endif
+};
+
+static inline bool isEmptyHelper(const QRegionPrivate *preg)
+{
+    return !preg || preg->numRects == 0;
+}
+
+static inline bool canMergeFromRight(const QRect *left, const QRect *right)
+{
+    return (right->top() == left->top()
+            && right->bottom() == left->bottom()
+            && right->left() <= (left->right() + 1));
+}
+
+static inline bool canMergeFromLeft(const QRect *right, const QRect *left)
+{
+    return canMergeFromRight(left, right);
+}
+
+bool QRegionPrivate::mergeFromRight(QRect *left, const QRect *right)
+{
+    if (canMergeFromRight(left, right)) {
+        left->setRight(right->right());
+        updateInnerRect(*left);
+        return true;
+    }
+    return false;
+}
+
+bool QRegionPrivate::mergeFromLeft(QRect *right, const QRect *left)
+{
+    if (canMergeFromLeft(right, left)) {
+        right->setLeft(left->left());
+        updateInnerRect(*right);
+        return true;
+    }
+    return false;
+}
+
+static inline bool canMergeFromBelow(const QRect *top, const QRect *bottom,
+                                     const QRect *nextToTop,
+                                     const QRect *nextToBottom)
+{
+    if (nextToTop && nextToTop->y() == top->y())
+        return false;
+    if (nextToBottom && nextToBottom->y() == bottom->y())
+        return false;
+
+    return ((top->bottom() >= (bottom->top() - 1))
+            && top->left() == bottom->left()
+            && top->right() == bottom->right());
+}
+
+bool QRegionPrivate::mergeFromBelow(QRect *top, const QRect *bottom,
+                                    const QRect *nextToTop,
+                                    const QRect *nextToBottom)
+{
+    if (canMergeFromBelow(top, bottom, nextToTop, nextToBottom)) {
+        top->setBottom(bottom->bottom());
+        updateInnerRect(*top);
+        return true;
+    }
+    return false;
+}
+
+bool QRegionPrivate::mergeFromAbove(QRect *bottom, const QRect *top,
+                                    const QRect *nextToBottom,
+                                    const QRect *nextToTop)
+{
+    if (canMergeFromBelow(top, bottom, nextToTop, nextToBottom)) {
+        bottom->setTop(top->top());
+        updateInnerRect(*bottom);
+        return true;
+    }
+    return false;
+}
+
+static inline QRect qt_rect_intersect_normalized(const QRect &r1,
+                                                 const QRect &r2)
+{
+    QRect r;
+    r.setLeft(qMax(r1.left(), r2.left()));
+    r.setRight(qMin(r1.right(), r2.right()));
+    r.setTop(qMax(r1.top(), r2.top()));
+    r.setBottom(qMin(r1.bottom(), r2.bottom()));
+    return r;
+}
+
+void QRegionPrivate::intersect(const QRect &rect)
+{
+    Q_ASSERT(extents.intersects(rect));
+    Q_ASSERT(numRects > 1);
+
+#ifdef QT_REGION_DEBUG
+    selfTest();
+#endif
+
+    const QRect r = rect.normalized();
+    extents = QRect();
+    innerRect = QRect();
+    innerArea = -1;
+
+    QRect *dest = rects.data();
+    const QRect *src = dest;
+    int n = numRects;
+    numRects = 0;
+    while (n--) {
+        *dest = qt_rect_intersect_normalized(*src++, r);
+        if (dest->isEmpty())
+            continue;
+
+        if (numRects == 0) {
+            extents = *dest;
+        } else {
+            extents.setLeft(qMin(extents.left(), dest->left()));
+            // hw: extents.top() will never change after initialization
+            //extents.setTop(qMin(extents.top(), dest->top()));
+            extents.setRight(qMax(extents.right(), dest->right()));
+            extents.setBottom(qMax(extents.bottom(), dest->bottom()));
+
+            const QRect *nextToLast = (numRects > 1 ? dest - 2 : 0);
+
+            // mergeFromBelow inlined and optimized
+            if (canMergeFromBelow(dest - 1, dest, nextToLast, 0)) {
+                if (!n || src->y() != dest->y() || src->left() > r.right()) {
+                    QRect *prev = dest - 1;
+                    prev->setBottom(dest->bottom());
+                    updateInnerRect(*prev);
+                    continue;
+                }
+            }
+        }
+        updateInnerRect(*dest);
+        ++dest;
+        ++numRects;
+    }
+#ifdef QT_REGION_DEBUG
+    selfTest();
+#endif
+}
+
+void QRegionPrivate::append(const QRect *r)
+{
+    Q_ASSERT(!r->isEmpty());
+
+    QRect *myLast = (numRects == 1 ? &extents : rects.data() + (numRects - 1));
+    if (mergeFromRight(myLast, r)) {
+        if (numRects > 1) {
+            const QRect *nextToTop = (numRects > 2 ? myLast - 2 : 0);
+            if (mergeFromBelow(myLast - 1, myLast, nextToTop, 0))
+                --numRects;
+        }
+    } else if (mergeFromBelow(myLast, r, (numRects > 1 ? myLast - 1 : 0), 0)) {
+        // nothing
+    } else {
+        vectorize();
+        ++numRects;
+        updateInnerRect(*r);
+        if (rects.size() < numRects)
+            rects.resize(numRects);
+        rects[numRects - 1] = *r;
+    }
+    extents.setCoords(qMin(extents.left(), r->left()),
+                      qMin(extents.top(), r->top()),
+                      qMax(extents.right(), r->right()),
+                      qMax(extents.bottom(), r->bottom()));
+
+#ifdef QT_REGION_DEBUG
+    selfTest();
+#endif
+}
+
+void QRegionPrivate::append(const QRegionPrivate *r)
+{
+    Q_ASSERT(!isEmptyHelper(r));
+
+    if (r->numRects == 1) {
+        append(&r->extents);
+        return;
+    }
+
+    vectorize();
+
+    QRect *destRect = rects.data() + numRects;
+    const QRect *srcRect = r->rects.constData();
+    int numAppend = r->numRects;
+
+    // try merging
+    {
+        const QRect *rFirst = srcRect;
+        QRect *myLast = destRect - 1;
+        const QRect *nextToLast = (numRects > 1 ? myLast - 1 : 0);
+        if (mergeFromRight(myLast, rFirst)) {
+            ++srcRect;
+            --numAppend;
+            const QRect *rNextToFirst = (numAppend > 1 ? rFirst + 2 : 0);
+            if (mergeFromBelow(myLast, rFirst + 1, nextToLast, rNextToFirst)) {
+                ++srcRect;
+                --numAppend;
+            }
+            if (numRects  > 1) {
+                nextToLast = (numRects > 2 ? myLast - 2 : 0);
+                rNextToFirst = (numAppend > 0 ? srcRect : 0);
+                if (mergeFromBelow(myLast - 1, myLast, nextToLast, rNextToFirst)) {
+                    --destRect;
+                    --numRects;
+                }
+            }
+        } else if (mergeFromBelow(myLast, rFirst, nextToLast, rFirst + 1)) {
+            ++srcRect;
+            --numAppend;
+        }
+    }
+
+    // append rectangles
+    if (numAppend > 0) {
+        const int newNumRects = numRects + numAppend;
+        if (newNumRects > rects.size()) {
+            rects.resize(newNumRects);
+            destRect = rects.data() + numRects;
+        }
+        memcpy(destRect, srcRect, numAppend * sizeof(QRect));
+
+        numRects = newNumRects;
+    }
+
+    // update inner rectangle
+    if (innerArea < r->innerArea) {
+        innerArea = r->innerArea;
+        innerRect = r->innerRect;
+    }
+
+    // update extents
+    destRect = &extents;
+    srcRect = &r->extents;
+    extents.setCoords(qMin(destRect->left(), srcRect->left()),
+                      qMin(destRect->top(), srcRect->top()),
+                      qMax(destRect->right(), srcRect->right()),
+                      qMax(destRect->bottom(), srcRect->bottom()));
+
+#ifdef QT_REGION_DEBUG
+    selfTest();
+#endif
+}
+
+void QRegionPrivate::prepend(const QRegionPrivate *r)
+{
+    Q_ASSERT(!isEmptyHelper(r));
+
+    if (r->numRects == 1) {
+        prepend(&r->extents);
+        return;
+    }
+
+    vectorize();
+
+    int numPrepend = r->numRects;
+    int numSkip = 0;
+
+    // try merging
+    {
+        QRect *myFirst = rects.data();
+        const QRect *nextToFirst = (numRects > 1 ? myFirst + 1 : 0);
+        const QRect *rLast = r->rects.constData() + r->numRects - 1;
+        const QRect *rNextToLast = (r->numRects > 1 ? rLast - 1 : 0);
+        if (mergeFromLeft(myFirst, rLast)) {
+            --numPrepend;
+            --rLast;
+            rNextToLast = (numPrepend > 1 ? rLast - 1 : 0);
+            if (mergeFromAbove(myFirst, rLast, nextToFirst, rNextToLast)) {
+                --numPrepend;
+                --rLast;
+            }
+            if (numRects  > 1) {
+                nextToFirst = (numRects > 2? myFirst + 2 : 0);
+                rNextToLast = (numPrepend > 0 ? rLast : 0);
+                if (mergeFromAbove(myFirst + 1, myFirst, nextToFirst, rNextToLast)) {
+                    --numRects;
+                    ++numSkip;
+                }
+            }
+        } else if (mergeFromAbove(myFirst, rLast, nextToFirst, rNextToLast)) {
+            --numPrepend;
+        }
+    }
+
+    if (numPrepend > 0) {
+        const int newNumRects = numRects + numPrepend;
+        if (newNumRects > rects.size())
+            rects.resize(newNumRects);
+
+        // move existing rectangles
+        memmove(rects.data() + numPrepend, rects.constData() + numSkip,
+                numRects * sizeof(QRect));
+
+        // prepend new rectangles
+        memcpy(rects.data(), r->rects.constData(), numPrepend * sizeof(QRect));
+
+        numRects = newNumRects;
+    }
+
+    // update inner rectangle
+    if (innerArea < r->innerArea) {
+        innerArea = r->innerArea;
+        innerRect = r->innerRect;
+    }
+
+    // update extents
+    extents.setCoords(qMin(extents.left(), r->extents.left()),
+                      qMin(extents.top(), r->extents.top()),
+                      qMax(extents.right(), r->extents.right()),
+                      qMax(extents.bottom(), r->extents.bottom()));
+
+#ifdef QT_REGION_DEBUG
+    selfTest();
+#endif
+}
+
+void QRegionPrivate::prepend(const QRect *r)
+{
+    Q_ASSERT(!r->isEmpty());
+
+    QRect *myFirst = (numRects == 1 ? &extents : rects.data());
+    if (mergeFromLeft(myFirst, r)) {
+        if (numRects > 1) {
+            const QRect *nextToFirst = (numRects > 2 ? myFirst + 2 : 0);
+            if (mergeFromAbove(myFirst + 1, myFirst, nextToFirst, 0)) {
+                --numRects;
+                memmove(rects.data(), rects.constData() + 1,
+                        numRects * sizeof(QRect));
+            }
+        }
+    } else if (mergeFromAbove(myFirst, r, (numRects > 1 ? myFirst + 1 : 0), 0)) {
+        // nothing
+    } else {
+        vectorize();
+        ++numRects;
+        updateInnerRect(*r);
+        rects.prepend(*r);
+    }
+    extents.setCoords(qMin(extents.left(), r->left()),
+                      qMin(extents.top(), r->top()),
+                      qMax(extents.right(), r->right()),
+                      qMax(extents.bottom(), r->bottom()));
+
+#ifdef QT_REGION_DEBUG
+    selfTest();
+#endif
+}
+
+bool QRegionPrivate::canAppend(const QRect *r) const
+{
+    Q_ASSERT(!r->isEmpty());
+
+    const QRect *myLast = (numRects == 1) ? &extents : (rects.constData() + (numRects - 1));
+    if (r->top() > myLast->bottom())
+        return true;
+    if (r->top() == myLast->top()
+        && r->height() == myLast->height()
+        && r->left() > myLast->right())
+    {
+        return true;
+    }
+
+    return false;
+}
+
+bool QRegionPrivate::canAppend(const QRegionPrivate *r) const
+{
+    return canAppend(r->numRects == 1 ? &r->extents : r->rects.constData());
+}
+
+bool QRegionPrivate::canPrepend(const QRect *r) const
+{
+    Q_ASSERT(!r->isEmpty());
+
+    const QRect *myFirst = (numRects == 1) ? &extents : rects.constData();
+    if (r->bottom() < myFirst->top()) // not overlapping
+        return true;
+    if (r->top() == myFirst->top()
+        && r->height() == myFirst->height()
+        && r->right() < myFirst->left())
+    {
+        return true;
+    }
+
+    return false;
+}
+
+bool QRegionPrivate::canPrepend(const QRegionPrivate *r) const
+{
+    return canPrepend(r->numRects == 1 ? &r->extents : r->rects.constData() + r->numRects - 1);
+}
+
+#ifdef QT_REGION_DEBUG
+void QRegionPrivate::selfTest() const
+{
+    if (numRects == 0) {
+        Q_ASSERT(extents.isEmpty());
+        Q_ASSERT(innerRect.isEmpty());
+        return;
+    }
+
+    Q_ASSERT(innerArea == (innerRect.width() * innerRect.height()));
+
+    if (numRects == 1) {
+        Q_ASSERT(innerRect == extents);
+        Q_ASSERT(!innerRect.isEmpty());
+        return;
+    }
+
+    for (int i = 0; i < numRects; ++i) {
+        const QRect r = rects.at(i);
+        if ((r.width() * r.height()) > innerArea)
+            qDebug() << "selfTest(): innerRect" << innerRect << '<' << r;
+    }
+
+    QRect r = rects.first();
+    for (int i = 1; i < numRects; ++i) {
+        const QRect r2 = rects.at(i);
+        Q_ASSERT(!r2.isEmpty());
+        if (r2.y() == r.y()) {
+            Q_ASSERT(r.bottom() == r2.bottom());
+            Q_ASSERT(r.right() < (r2.left() + 1));
+        } else {
+            Q_ASSERT(r2.y() >= r.bottom());
+        }
+        r = r2;
+    }
+}
+#endif // QT_REGION_DEBUG
+
+#if defined(Q_WS_X11)
+QT_BEGIN_INCLUDE_NAMESPACE
+# include "qregion_x11.cpp"
+QT_END_INCLUDE_NAMESPACE
+#elif defined(Q_WS_MAC)
+QT_BEGIN_INCLUDE_NAMESPACE
+# include "qregion_mac.cpp"
+QT_END_INCLUDE_NAMESPACE
+#elif defined(Q_WS_WIN)
+QT_BEGIN_INCLUDE_NAMESPACE
+# include "qregion_win.cpp"
+QT_END_INCLUDE_NAMESPACE
+#elif defined(Q_WS_QWS) || defined(Q_WS_QPA)
+static QRegionPrivate qrp;
+QRegion::QRegionData QRegion::shared_empty = {Q_BASIC_ATOMIC_INITIALIZER(1), &qrp};
+#endif
+
+typedef void (*OverlapFunc)(register QRegionPrivate &dest, register const QRect *r1, const QRect *r1End,
+                            register const QRect *r2, const QRect *r2End, register int y1, register int y2);
+typedef void (*NonOverlapFunc)(register QRegionPrivate &dest, register const QRect *r, const QRect *rEnd,
+                               register int y1, register int y2);
+
+static bool EqualRegion(const QRegionPrivate *r1, const QRegionPrivate *r2);
+static void UnionRegion(const QRegionPrivate *reg1, const QRegionPrivate *reg2, QRegionPrivate &dest);
+static void miRegionOp(register QRegionPrivate &dest, const QRegionPrivate *reg1, const QRegionPrivate *reg2,
+                       OverlapFunc overlapFunc, NonOverlapFunc nonOverlap1Func,
+                       NonOverlapFunc nonOverlap2Func);
+
+#define RectangleOut 0
+#define RectangleIn 1
+#define RectanglePart 2
+#define EvenOddRule 0
+#define WindingRule 1
+
+// START OF region.h extract
+/* $XConsortium: region.h,v 11.14 94/04/17 20:22:20 rws Exp $ */
+/************************************************************************
+
+Copyright (c) 1987  X Consortium
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of the X Consortium shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from the X Consortium.
+
+
+Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+************************************************************************/
+
+#ifndef _XREGION_H
+#define _XREGION_H
+
+QT_BEGIN_INCLUDE_NAMESPACE
+#include <limits.h>
+QT_END_INCLUDE_NAMESPACE
+
+/*  1 if two BOXes overlap.
+ *  0 if two BOXes do not overlap.
+ *  Remember, x2 and y2 are not in the region
+ */
+#define EXTENTCHECK(r1, r2) \
+        ((r1)->right() >= (r2)->left() && \
+         (r1)->left() <= (r2)->right() && \
+         (r1)->bottom() >= (r2)->top() && \
+         (r1)->top() <= (r2)->bottom())
+
+/*
+ *  update region extents
+ */
+#define EXTENTS(r,idRect){\
+            if((r)->left() < (idRect)->extents.left())\
+              (idRect)->extents.setLeft((r)->left());\
+            if((r)->top() < (idRect)->extents.top())\
+              (idRect)->extents.setTop((r)->top());\
+            if((r)->right() > (idRect)->extents.right())\
+              (idRect)->extents.setRight((r)->right());\
+            if((r)->bottom() > (idRect)->extents.bottom())\
+              (idRect)->extents.setBottom((r)->bottom());\
+        }
+
+/*
+ *   Check to see if there is enough memory in the present region.
+ */
+#define MEMCHECK(dest, rect, firstrect){\
+        if ((dest).numRects >= ((dest).rects.size()-1)){\
+          firstrect.resize(firstrect.size() * 2); \
+          (rect) = (firstrect).data() + (dest).numRects;\
+        }\
+      }
+
+
+/*
+ * number of points to buffer before sending them off
+ * to scanlines(): Must be an even number
+ */
+#define NUMPTSTOBUFFER 200
+
+/*
+ * used to allocate buffers for points and link
+ * the buffers together
+ */
+typedef struct _POINTBLOCK {
+    int data[NUMPTSTOBUFFER * sizeof(QPoint)];
+    QPoint *pts;
+    struct _POINTBLOCK *next;
+} POINTBLOCK;
+
+#endif
+// END OF region.h extract
+
+// START OF Region.c extract
+/* $XConsortium: Region.c /main/30 1996/10/22 14:21:24 kaleb $ */
+/************************************************************************
+
+Copyright (c) 1987, 1988  X Consortium
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of the X Consortium shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from the X Consortium.
+
+
+Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+************************************************************************/
+/*
+ * The functions in this file implement the Region abstraction, similar to one
+ * used in the X11 sample server. A Region is simply an area, as the name
+ * implies, and is implemented as a "y-x-banded" array of rectangles. To
+ * explain: Each Region is made up of a certain number of rectangles sorted
+ * by y coordinate first, and then by x coordinate.
+ *
+ * Furthermore, the rectangles are banded such that every rectangle with a
+ * given upper-left y coordinate (y1) will have the same lower-right y
+ * coordinate (y2) and vice versa. If a rectangle has scanlines in a band, it
+ * will span the entire vertical distance of the band. This means that some
+ * areas that could be merged into a taller rectangle will be represented as
+ * several shorter rectangles to account for shorter rectangles to its left
+ * or right but within its "vertical scope".
+ *
+ * An added constraint on the rectangles is that they must cover as much
+ * horizontal area as possible. E.g. no two rectangles in a band are allowed
+ * to touch.
+ *
+ * Whenever possible, bands will be merged together to cover a greater vertical
+ * distance (and thus reduce the number of rectangles). Two bands can be merged
+ * only if the bottom of one touches the top of the other and they have
+ * rectangles in the same places (of the same width, of course). This maintains
+ * the y-x-banding that's so nice to have...
+ */
+/* $XFree86: xc/lib/X11/Region.c,v 1.1.1.2.2.2 1998/10/04 15:22:50 hohndel Exp $ */
+
+static void UnionRectWithRegion(register const QRect *rect, const QRegionPrivate *source,
+                                QRegionPrivate &dest)
+{
+    if (rect->isEmpty())
+        return;
+
+    Q_ASSERT(EqualRegion(source, &dest));
+
+    if (dest.numRects == 0) {
+        dest = QRegionPrivate(*rect);
+    } else if (dest.canAppend(rect)) {
+        dest.append(rect);
+    } else {
+        QRegionPrivate p(*rect);
+        UnionRegion(&p, source, dest);
+    }
+}
+
+/*-
+ *-----------------------------------------------------------------------
+ * miSetExtents --
+ *      Reset the extents and innerRect of a region to what they should be.
+ *      Called by miSubtract and miIntersect b/c they can't figure it out
+ *      along the way or do so easily, as miUnion can.
+ *
+ * Results:
+ *      None.
+ *
+ * Side Effects:
+ *      The region's 'extents' and 'innerRect' structure is overwritten.
+ *
+ *-----------------------------------------------------------------------
+ */
+static void miSetExtents(QRegionPrivate &dest)
+{
+    register const QRect *pBox,
+                         *pBoxEnd;
+    register QRect *pExtents;
+
+    dest.innerRect.setCoords(0, 0, -1, -1);
+    dest.innerArea = -1;
+    if (dest.numRects == 0) {
+        dest.extents.setCoords(0, 0, -1, -1);
+        return;
+    }
+
+    pExtents = &dest.extents;
+    if (dest.rects.isEmpty())
+        pBox = &dest.extents;
+    else
+        pBox = dest.rects.constData();
+    pBoxEnd = pBox + dest.numRects - 1;
+
+    /*
+     * Since pBox is the first rectangle in the region, it must have the
+     * smallest y1 and since pBoxEnd is the last rectangle in the region,
+     * it must have the largest y2, because of banding. Initialize x1 and
+     * x2 from  pBox and pBoxEnd, resp., as good things to initialize them
+     * to...
+     */
+    pExtents->setLeft(pBox->left());
+    pExtents->setTop(pBox->top());
+    pExtents->setRight(pBoxEnd->right());
+    pExtents->setBottom(pBoxEnd->bottom());
+
+    Q_ASSERT(pExtents->top() <= pExtents->bottom());
+    while (pBox <= pBoxEnd) {
+        if (pBox->left() < pExtents->left())
+            pExtents->setLeft(pBox->left());
+        if (pBox->right() > pExtents->right())
+            pExtents->setRight(pBox->right());
+        dest.updateInnerRect(*pBox);
+        ++pBox;
+    }
+    Q_ASSERT(pExtents->left() <= pExtents->right());
+}
+
+/* TranslateRegion(pRegion, x, y)
+   translates in place
+   added by raymond
+*/
+
+static void OffsetRegion(register QRegionPrivate &region, register int x, register int y)
+{
+    if (region.rects.size()) {
+        register QRect *pbox = region.rects.data();
+        register int nbox = region.numRects;
+
+        while (nbox--) {
+            pbox->translate(x, y);
+            ++pbox;
+        }
+    }
+    region.extents.translate(x, y);
+    region.innerRect.translate(x, y);
+}
+
+/*======================================================================
+ *          Region Intersection
+ *====================================================================*/
+/*-
+ *-----------------------------------------------------------------------
+ * miIntersectO --
+ *      Handle an overlapping band for miIntersect.
+ *
+ * Results:
+ *      None.
+ *
+ * Side Effects:
+ *      Rectangles may be added to the region.
+ *
+ *-----------------------------------------------------------------------
+ */
+static void miIntersectO(register QRegionPrivate &dest, register const QRect *r1, const QRect *r1End,
+                         register const QRect *r2, const QRect *r2End, int y1, int y2)
+{
+    register int x1;
+    register int x2;
+    register QRect *pNextRect;
+
+    pNextRect = dest.rects.data() + dest.numRects;
+
+    while (r1 != r1End && r2 != r2End) {
+        x1 = qMax(r1->left(), r2->left());
+        x2 = qMin(r1->right(), r2->right());
+
+        /*
+         * If there's any overlap between the two rectangles, add that
+         * overlap to the new region.
+         * There's no need to check for subsumption because the only way
+         * such a need could arise is if some region has two rectangles
+         * right next to each other. Since that should never happen...
+         */
+        if (x1 <= x2) {
+            Q_ASSERT(y1 <= y2);
+            MEMCHECK(dest, pNextRect, dest.rects)
+            pNextRect->setCoords(x1, y1, x2, y2);
+            ++dest.numRects;
+            ++pNextRect;
+        }
+
+        /*
+         * Need to advance the pointers. Shift the one that extends
+         * to the right the least, since the other still has a chance to
+         * overlap with that region's next rectangle, if you see what I mean.
+         */
+        if (r1->right() < r2->right()) {
+            ++r1;
+        } else if (r2->right() < r1->right()) {
+            ++r2;
+        } else {
+            ++r1;
+            ++r2;
+        }
+    }
+}
+
+/*======================================================================
+ *          Generic Region Operator
+ *====================================================================*/
+
+/*-
+ *-----------------------------------------------------------------------
+ * miCoalesce --
+ *      Attempt to merge the boxes in the current band with those in the
+ *      previous one. Used only by miRegionOp.
+ *
+ * Results:
+ *      The new index for the previous band.
+ *
+ * Side Effects:
+ *      If coalescing takes place:
+ *          - rectangles in the previous band will have their y2 fields
+ *            altered.
+ *          - dest.numRects will be decreased.
+ *
+ *-----------------------------------------------------------------------
+ */
+static int miCoalesce(register QRegionPrivate &dest, int prevStart, int curStart)
+{
+    register QRect *pPrevBox;   /* Current box in previous band */
+    register QRect *pCurBox;    /* Current box in current band */
+    register QRect *pRegEnd;    /* End of region */
+    int curNumRects;    /* Number of rectangles in current band */
+    int prevNumRects;   /* Number of rectangles in previous band */
+    int bandY1;         /* Y1 coordinate for current band */
+    QRect *rData = dest.rects.data();
+
+    pRegEnd = rData + dest.numRects;
+
+    pPrevBox = rData + prevStart;
+    prevNumRects = curStart - prevStart;
+
+    /*
+     * Figure out how many rectangles are in the current band. Have to do
+     * this because multiple bands could have been added in miRegionOp
+     * at the end when one region has been exhausted.
+     */
+    pCurBox = rData + curStart;
+    bandY1 = pCurBox->top();
+    for (curNumRects = 0; pCurBox != pRegEnd && pCurBox->top() == bandY1; ++curNumRects) {
+        ++pCurBox;
+    }
+
+    if (pCurBox != pRegEnd) {
+        /*
+         * If more than one band was added, we have to find the start
+         * of the last band added so the next coalescing job can start
+         * at the right place... (given when multiple bands are added,
+         * this may be pointless -- see above).
+         */
+        --pRegEnd;
+        while ((pRegEnd - 1)->top() == pRegEnd->top())
+            --pRegEnd;
+        curStart = pRegEnd - rData;
+        pRegEnd = rData + dest.numRects;
+    }
+
+    if (curNumRects == prevNumRects && curNumRects != 0) {
+        pCurBox -= curNumRects;
+        /*
+         * The bands may only be coalesced if the bottom of the previous
+         * matches the top scanline of the current.
+         */
+        if (pPrevBox->bottom() == pCurBox->top() - 1) {
+            /*
+             * Make sure the bands have boxes in the same places. This
+             * assumes that boxes have been added in such a way that they
+             * cover the most area possible. I.e. two boxes in a band must
+             * have some horizontal space between them.
+             */
+            do {
+                if (pPrevBox->left() != pCurBox->left() || pPrevBox->right() != pCurBox->right()) {
+                     // The bands don't line up so they can't be coalesced.
+                    return curStart;
+                }
+                ++pPrevBox;
+                ++pCurBox;
+                --prevNumRects;
+            } while (prevNumRects != 0);
+
+            dest.numRects -= curNumRects;
+            pCurBox -= curNumRects;
+            pPrevBox -= curNumRects;
+
+            /*
+             * The bands may be merged, so set the bottom y of each box
+             * in the previous band to that of the corresponding box in
+             * the current band.
+             */
+            do {
+                pPrevBox->setBottom(pCurBox->bottom());
+                dest.updateInnerRect(*pPrevBox);
+                ++pPrevBox;
+                ++pCurBox;
+                curNumRects -= 1;
+            } while (curNumRects != 0);
+
+            /*
+             * If only one band was added to the region, we have to backup
+             * curStart to the start of the previous band.
+             *
+             * If more than one band was added to the region, copy the
+             * other bands down. The assumption here is that the other bands
+             * came from the same region as the current one and no further
+             * coalescing can be done on them since it's all been done
+             * already... curStart is already in the right place.
+             */
+            if (pCurBox == pRegEnd) {
+                curStart = prevStart;
+            } else {
+                do {
+                    *pPrevBox++ = *pCurBox++;
+                    dest.updateInnerRect(*pPrevBox);
+                } while (pCurBox != pRegEnd);
+            }
+        }
+    }
+    return curStart;
+}
+
+/*-
+ *-----------------------------------------------------------------------
+ * miRegionOp --
+ *      Apply an operation to two regions. Called by miUnion, miInverse,
+ *      miSubtract, miIntersect...
+ *
+ * Results:
+ *      None.
+ *
+ * Side Effects:
+ *      The new region is overwritten.
+ *
+ * Notes:
+ *      The idea behind this function is to view the two regions as sets.
+ *      Together they cover a rectangle of area that this function divides
+ *      into horizontal bands where points are covered only by one region
+ *      or by both. For the first case, the nonOverlapFunc is called with
+ *      each the band and the band's upper and lower extents. For the
+ *      second, the overlapFunc is called to process the entire band. It
+ *      is responsible for clipping the rectangles in the band, though
+ *      this function provides the boundaries.
+ *      At the end of each band, the new region is coalesced, if possible,
+ *      to reduce the number of rectangles in the region.
+ *
+ *-----------------------------------------------------------------------
+ */
+static void miRegionOp(register QRegionPrivate &dest,
+                       const QRegionPrivate *reg1, const QRegionPrivate *reg2,
+                       OverlapFunc overlapFunc, NonOverlapFunc nonOverlap1Func,
+                       NonOverlapFunc nonOverlap2Func)
+{
+    register const QRect *r1;         // Pointer into first region
+    register const QRect *r2;         // Pointer into 2d region
+    const QRect *r1End;               // End of 1st region
+    const QRect *r2End;               // End of 2d region
+    register int ybot;          // Bottom of intersection
+    register int ytop;          // Top of intersection
+    int prevBand;               // Index of start of previous band in dest
+    int curBand;                // Index of start of current band in dest
+    register const QRect *r1BandEnd;  // End of current band in r1
+    register const QRect *r2BandEnd;  // End of current band in r2
+    int top;                    // Top of non-overlapping band
+    int bot;                    // Bottom of non-overlapping band
+
+    /*
+     * Initialization:
+     *  set r1, r2, r1End and r2End appropriately, preserve the important
+     * parts of the destination region until the end in case it's one of
+     * the two source regions, then mark the "new" region empty, allocating
+     * another array of rectangles for it to use.
+     */
+    if (reg1->numRects == 1)
+        r1 = &reg1->extents;
+    else
+        r1 = reg1->rects.constData();
+    if (reg2->numRects == 1)
+        r2 = &reg2->extents;
+    else
+        r2 = reg2->rects.constData();
+
+    r1End = r1 + reg1->numRects;
+    r2End = r2 + reg2->numRects;
+
+    dest.vectorize();
+
+    QVector<QRect> oldRects = dest.rects;
+
+    dest.numRects = 0;
+
+    /*
+     * Allocate a reasonable number of rectangles for the new region. The idea
+     * is to allocate enough so the individual functions don't need to
+     * reallocate and copy the array, which is time consuming, yet we don't
+     * have to worry about using too much memory. I hope to be able to
+     * nuke the realloc() at the end of this function eventually.
+     */
+    dest.rects.resize(qMax(reg1->numRects,reg2->numRects) * 2);
+
+    /*
+     * Initialize ybot and ytop.
+     * In the upcoming loop, ybot and ytop serve different functions depending
+     * on whether the band being handled is an overlapping or non-overlapping
+     * band.
+     *  In the case of a non-overlapping band (only one of the regions
+     * has points in the band), ybot is the bottom of the most recent
+     * intersection and thus clips the top of the rectangles in that band.
+     * ytop is the top of the next intersection between the two regions and
+     * serves to clip the bottom of the rectangles in the current band.
+     *  For an overlapping band (where the two regions intersect), ytop clips
+     * the top of the rectangles of both regions and ybot clips the bottoms.
+     */
+    if (reg1->extents.top() < reg2->extents.top())
+        ybot = reg1->extents.top() - 1;
+    else
+        ybot = reg2->extents.top() - 1;
+
+    /*
+     * prevBand serves to mark the start of the previous band so rectangles
+     * can be coalesced into larger rectangles. qv. miCoalesce, above.
+     * In the beginning, there is no previous band, so prevBand == curBand
+     * (curBand is set later on, of course, but the first band will always
+     * start at index 0). prevBand and curBand must be indices because of
+     * the possible expansion, and resultant moving, of the new region's
+     * array of rectangles.
+     */
+    prevBand = 0;
+
+    do {
+        curBand = dest.numRects;
+
+        /*
+         * This algorithm proceeds one source-band (as opposed to a
+         * destination band, which is determined by where the two regions
+         * intersect) at a time. r1BandEnd and r2BandEnd serve to mark the
+         * rectangle after the last one in the current band for their
+         * respective regions.
+         */
+        r1BandEnd = r1;
+        while (r1BandEnd != r1End && r1BandEnd->top() == r1->top())
+            ++r1BandEnd;
+
+        r2BandEnd = r2;
+        while (r2BandEnd != r2End && r2BandEnd->top() == r2->top())
+            ++r2BandEnd;
+
+        /*
+         * First handle the band that doesn't intersect, if any.
+         *
+         * Note that attention is restricted to one band in the
+         * non-intersecting region at once, so if a region has n
+         * bands between the current position and the next place it overlaps
+         * the other, this entire loop will be passed through n times.
+         */
+        if (r1->top() < r2->top()) {
+            top = qMax(r1->top(), ybot + 1);
+            bot = qMin(r1->bottom(), r2->top() - 1);
+
+            if (nonOverlap1Func != 0 && bot >= top)
+                (*nonOverlap1Func)(dest, r1, r1BandEnd, top, bot);
+            ytop = r2->top();
+        } else if (r2->top() < r1->top()) {
+            top = qMax(r2->top(), ybot + 1);
+            bot = qMin(r2->bottom(), r1->top() - 1);
+
+            if (nonOverlap2Func != 0 && bot >= top)
+                (*nonOverlap2Func)(dest, r2, r2BandEnd, top, bot);
+            ytop = r1->top();
+        } else {
+            ytop = r1->top();
+        }
+
+        /*
+         * If any rectangles got added to the region, try and coalesce them
+         * with rectangles from the previous band. Note we could just do
+         * this test in miCoalesce, but some machines incur a not
+         * inconsiderable cost for function calls, so...
+         */
+        if (dest.numRects != curBand)
+            prevBand = miCoalesce(dest, prevBand, curBand);
+
+        /*
+         * Now see if we've hit an intersecting band. The two bands only
+         * intersect if ybot >= ytop
+         */
+        ybot = qMin(r1->bottom(), r2->bottom());
+        curBand = dest.numRects;
+        if (ybot >= ytop)
+            (*overlapFunc)(dest, r1, r1BandEnd, r2, r2BandEnd, ytop, ybot);
+
+        if (dest.numRects != curBand)
+            prevBand = miCoalesce(dest, prevBand, curBand);
+
+        /*
+         * If we've finished with a band (y2 == ybot) we skip forward
+         * in the region to the next band.
+         */
+        if (r1->bottom() == ybot)
+            r1 = r1BandEnd;
+        if (r2->bottom() == ybot)
+            r2 = r2BandEnd;
+    } while (r1 != r1End && r2 != r2End);
+
+    /*
+     * Deal with whichever region still has rectangles left.
+     */
+    curBand = dest.numRects;
+    if (r1 != r1End) {
+        if (nonOverlap1Func != 0) {
+            do {
+                r1BandEnd = r1;
+                while (r1BandEnd < r1End && r1BandEnd->top() == r1->top())
+                    ++r1BandEnd;
+                (*nonOverlap1Func)(dest, r1, r1BandEnd, qMax(r1->top(), ybot + 1), r1->bottom());
+                r1 = r1BandEnd;
+            } while (r1 != r1End);
+        }
+    } else if ((r2 != r2End) && (nonOverlap2Func != 0)) {
+        do {
+            r2BandEnd = r2;
+            while (r2BandEnd < r2End && r2BandEnd->top() == r2->top())
+                 ++r2BandEnd;
+            (*nonOverlap2Func)(dest, r2, r2BandEnd, qMax(r2->top(), ybot + 1), r2->bottom());
+            r2 = r2BandEnd;
+        } while (r2 != r2End);
+    }
+
+    if (dest.numRects != curBand)
+        (void)miCoalesce(dest, prevBand, curBand);
+
+    /*
+     * A bit of cleanup. To keep regions from growing without bound,
+     * we shrink the array of rectangles to match the new number of
+     * rectangles in the region.
+     *
+     * Only do this stuff if the number of rectangles allocated is more than
+     * twice the number of rectangles in the region (a simple optimization).
+     */
+    if (qMax(4, dest.numRects) < (dest.rects.size() >> 1))
+        dest.rects.resize(dest.numRects);
+}
+
+/*======================================================================
+ *          Region Union
+ *====================================================================*/
+
+/*-
+ *-----------------------------------------------------------------------
+ * miUnionNonO --
+ *      Handle a non-overlapping band for the union operation. Just
+ *      Adds the rectangles into the region. Doesn't have to check for
+ *      subsumption or anything.
+ *
+ * Results:
+ *      None.
+ *
+ * Side Effects:
+ *      dest.numRects is incremented and the final rectangles overwritten
+ *      with the rectangles we're passed.
+ *
+ *-----------------------------------------------------------------------
+ */
+
+static void miUnionNonO(register QRegionPrivate &dest, register const QRect *r, const QRect *rEnd,
+                        register int y1, register int y2)
+{
+    register QRect *pNextRect;
+
+    pNextRect = dest.rects.data() + dest.numRects;
+
+    Q_ASSERT(y1 <= y2);
+
+    while (r != rEnd) {
+        Q_ASSERT(r->left() <= r->right());
+        MEMCHECK(dest, pNextRect, dest.rects)
+        pNextRect->setCoords(r->left(), y1, r->right(), y2);
+        dest.numRects++;
+        ++pNextRect;
+        ++r;
+    }
+}
+
+
+/*-
+ *-----------------------------------------------------------------------
+ * miUnionO --
+ *      Handle an overlapping band for the union operation. Picks the
+ *      left-most rectangle each time and merges it into the region.
+ *
+ * Results:
+ *      None.
+ *
+ * Side Effects:
+ *      Rectangles are overwritten in dest.rects and dest.numRects will
+ *      be changed.
+ *
+ *-----------------------------------------------------------------------
+ */
+
+static void miUnionO(register QRegionPrivate &dest, register const QRect *r1, const QRect *r1End,
+                     register const QRect *r2, const QRect *r2End, register int y1, register int y2)
+{
+    register QRect *pNextRect;
+
+    pNextRect = dest.rects.data() + dest.numRects;
+
+#define MERGERECT(r)             \
+    if ((dest.numRects != 0) &&  \
+        (pNextRect[-1].top() == y1) &&  \
+        (pNextRect[-1].bottom() == y2) &&  \
+        (pNextRect[-1].right() >= r->left()-1)) { \
+        if (pNextRect[-1].right() < r->right()) { \
+            pNextRect[-1].setRight(r->right());  \
+            dest.updateInnerRect(pNextRect[-1]); \
+            Q_ASSERT(pNextRect[-1].left() <= pNextRect[-1].right()); \
+        }  \
+    } else { \
+        MEMCHECK(dest, pNextRect, dest.rects)  \
+        pNextRect->setCoords(r->left(), y1, r->right(), y2); \
+        dest.updateInnerRect(*pNextRect); \
+        dest.numRects++;  \
+        pNextRect++;  \
+    }  \
+    r++;
+
+    Q_ASSERT(y1 <= y2);
+    while (r1 != r1End && r2 != r2End) {
+        if (r1->left() < r2->left()) {
+            MERGERECT(r1)
+        } else {
+            MERGERECT(r2)
+        }
+    }
+
+    if (r1 != r1End) {
+        do {
+            MERGERECT(r1)
+        } while (r1 != r1End);
+    } else {
+        while (r2 != r2End) {
+            MERGERECT(r2)
+        }
+    }
+}
+
+static void UnionRegion(const QRegionPrivate *reg1, const QRegionPrivate *reg2, QRegionPrivate &dest)
+{
+    Q_ASSERT(!isEmptyHelper(reg1) && !isEmptyHelper(reg2));
+    Q_ASSERT(!reg1->contains(*reg2));
+    Q_ASSERT(!reg2->contains(*reg1));
+    Q_ASSERT(!EqualRegion(reg1, reg2));
+    Q_ASSERT(!reg1->canAppend(reg2));
+    Q_ASSERT(!reg2->canAppend(reg1));
+
+    if (reg1->innerArea > reg2->innerArea) {
+        dest.innerArea = reg1->innerArea;
+        dest.innerRect = reg1->innerRect;
+    } else {
+        dest.innerArea = reg2->innerArea;
+        dest.innerRect = reg2->innerRect;
+    }
+    miRegionOp(dest, reg1, reg2, miUnionO, miUnionNonO, miUnionNonO);
+
+    dest.extents.setCoords(qMin(reg1->extents.left(), reg2->extents.left()),
+                           qMin(reg1->extents.top(), reg2->extents.top()),
+                           qMax(reg1->extents.right(), reg2->extents.right()),
+                           qMax(reg1->extents.bottom(), reg2->extents.bottom()));
+}
+
+/*======================================================================
+ *        Region Subtraction
+ *====================================================================*/
+
+/*-
+ *-----------------------------------------------------------------------
+ * miSubtractNonO --
+ *      Deal with non-overlapping band for subtraction. Any parts from
+ *      region 2 we discard. Anything from region 1 we add to the region.
+ *
+ * Results:
+ *      None.
+ *
+ * Side Effects:
+ *      dest may be affected.
+ *
+ *-----------------------------------------------------------------------
+ */
+
+static void miSubtractNonO1(register QRegionPrivate &dest, register const QRect *r,
+                            const QRect *rEnd, register int y1, register int y2)
+{
+    register QRect *pNextRect;
+
+    pNextRect = dest.rects.data() + dest.numRects;
+
+    Q_ASSERT(y1<=y2);
+
+    while (r != rEnd) {
+        Q_ASSERT(r->left() <= r->right());
+        MEMCHECK(dest, pNextRect, dest.rects)
+        pNextRect->setCoords(r->left(), y1, r->right(), y2);
+        ++dest.numRects;
+        ++pNextRect;
+        ++r;
+    }
+}
+
+/*-
+ *-----------------------------------------------------------------------
+ * miSubtractO --
+ *      Overlapping band subtraction. x1 is the left-most point not yet
+ *      checked.
+ *
+ * Results:
+ *      None.
+ *
+ * Side Effects:
+ *      dest may have rectangles added to it.
+ *
+ *-----------------------------------------------------------------------
+ */
+
+static void miSubtractO(register QRegionPrivate &dest, register const QRect *r1, const QRect *r1End,
+                        register const QRect *r2, const QRect *r2End, register int y1, register int y2)
+{
+    register QRect *pNextRect;
+    register int x1;
+
+    x1 = r1->left();
+
+    Q_ASSERT(y1 <= y2);
+    pNextRect = dest.rects.data() + dest.numRects;
+
+    while (r1 != r1End && r2 != r2End) {
+        if (r2->right() < x1) {
+            /*
+             * Subtrahend missed the boat: go to next subtrahend.
+             */
+            ++r2;
+        } else if (r2->left() <= x1) {
+            /*
+             * Subtrahend precedes minuend: nuke left edge of minuend.
+             */
+            x1 = r2->right() + 1;
+            if (x1 > r1->right()) {
+                /*
+                 * Minuend completely covered: advance to next minuend and
+                 * reset left fence to edge of new minuend.
+                 */
+                ++r1;
+                if (r1 != r1End)
+                    x1 = r1->left();
+            } else {
+                // Subtrahend now used up since it doesn't extend beyond minuend
+                ++r2;
+            }
+        } else if (r2->left() <= r1->right()) {
+            /*
+             * Left part of subtrahend covers part of minuend: add uncovered
+             * part of minuend to region and skip to next subtrahend.
+             */
+            Q_ASSERT(x1 < r2->left());
+            MEMCHECK(dest, pNextRect, dest.rects)
+            pNextRect->setCoords(x1, y1, r2->left() - 1, y2);
+            ++dest.numRects;
+            ++pNextRect;
+
+            x1 = r2->right() + 1;
+            if (x1 > r1->right()) {
+                /*
+                 * Minuend used up: advance to new...
+                 */
+                ++r1;
+                if (r1 != r1End)
+                    x1 = r1->left();
+            } else {
+                // Subtrahend used up
+                ++r2;
+            }
+        } else {
+            /*
+             * Minuend used up: add any remaining piece before advancing.
+             */
+            if (r1->right() >= x1) {
+                MEMCHECK(dest, pNextRect, dest.rects)
+                pNextRect->setCoords(x1, y1, r1->right(), y2);
+                ++dest.numRects;
+                ++pNextRect;
+            }
+            ++r1;
+            if (r1 != r1End)
+                x1 = r1->left();
+        }
+    }
+
+    /*
+     * Add remaining minuend rectangles to region.
+     */
+    while (r1 != r1End) {
+        Q_ASSERT(x1 <= r1->right());
+        MEMCHECK(dest, pNextRect, dest.rects)
+        pNextRect->setCoords(x1, y1, r1->right(), y2);
+        ++dest.numRects;
+        ++pNextRect;
+
+        ++r1;
+        if (r1 != r1End)
+            x1 = r1->left();
+    }
+}
+
+/*-
+ *-----------------------------------------------------------------------
+ * miSubtract --
+ *      Subtract regS from regM and leave the result in regD.
+ *      S stands for subtrahend, M for minuend and D for difference.
+ *
+ * Side Effects:
+ *      regD is overwritten.
+ *
+ *-----------------------------------------------------------------------
+ */
+
+static void SubtractRegion(QRegionPrivate *regM, QRegionPrivate *regS,
+                           register QRegionPrivate &dest)
+{
+    Q_ASSERT(!isEmptyHelper(regM));
+    Q_ASSERT(!isEmptyHelper(regS));
+    Q_ASSERT(EXTENTCHECK(&regM->extents, &regS->extents));
+    Q_ASSERT(!regS->contains(*regM));
+    Q_ASSERT(!EqualRegion(regM, regS));
+
+    miRegionOp(dest, regM, regS, miSubtractO, miSubtractNonO1, 0);
+
+    /*
+     * Can't alter dest's extents before we call miRegionOp because
+     * it might be one of the source regions and miRegionOp depends
+     * on the extents of those regions being the unaltered. Besides, this
+     * way there's no checking against rectangles that will be nuked
+     * due to coalescing, so we have to examine fewer rectangles.
+     */
+    miSetExtents(dest);
+}
+
+static void XorRegion(QRegionPrivate *sra, QRegionPrivate *srb, QRegionPrivate &dest)
+{
+    Q_ASSERT(!isEmptyHelper(sra) && !isEmptyHelper(srb));
+    Q_ASSERT(EXTENTCHECK(&sra->extents, &srb->extents));
+    Q_ASSERT(!EqualRegion(sra, srb));
+
+    QRegionPrivate tra, trb;
+
+    if (!srb->contains(*sra))
+        SubtractRegion(sra, srb, tra);
+    if (!sra->contains(*srb))
+        SubtractRegion(srb, sra, trb);
+
+    Q_ASSERT(isEmptyHelper(&trb) || !tra.contains(trb));
+    Q_ASSERT(isEmptyHelper(&tra) || !trb.contains(tra));
+
+    if (isEmptyHelper(&tra)) {
+        dest = trb;
+    } else if (isEmptyHelper(&trb)) {
+        dest = tra;
+    } else if (tra.canAppend(&trb)) {
+        dest = tra;
+        dest.append(&trb);
+    } else if (trb.canAppend(&tra)) {
+        dest = trb;
+        dest.append(&tra);
+    } else {
+        UnionRegion(&tra, &trb, dest);
+    }
+}
+
+/*
+ *      Check to see if two regions are equal
+ */
+static bool EqualRegion(const QRegionPrivate *r1, const QRegionPrivate *r2)
+{
+    if (r1->numRects != r2->numRects) {
+        return false;
+    } else if (r1->numRects == 0) {
+        return true;
+    } else if (r1->extents != r2->extents) {
+        return false;
+    } else if (r1->numRects == 1 && r2->numRects == 1) {
+        return true; // equality tested in previous if-statement
+    } else {
+        const QRect *rr1 = (r1->numRects == 1) ? &r1->extents : r1->rects.constData();
+        const QRect *rr2 = (r2->numRects == 1) ? &r2->extents : r2->rects.constData();
+        for (int i = 0; i < r1->numRects; ++i, ++rr1, ++rr2) {
+            if (*rr1 != *rr2)
+                return false;
+        }
+    }
+
+    return true;
+}
+
+static bool PointInRegion(QRegionPrivate *pRegion, int x, int y)
+{
+    int i;
+
+    if (isEmptyHelper(pRegion))
+        return false;
+    if (!pRegion->extents.contains(x, y))
+        return false;
+    if (pRegion->numRects == 1)
+        return pRegion->extents.contains(x, y);
+    if (pRegion->innerRect.contains(x, y))
+        return true;
+    for (i = 0; i < pRegion->numRects; ++i) {
+        if (pRegion->rects[i].contains(x, y))
+            return true;
+    }
+    return false;
+}
+
+static bool RectInRegion(register QRegionPrivate *region, int rx, int ry, uint rwidth, uint rheight)
+{
+    register const QRect *pbox;
+    register const QRect *pboxEnd;
+    QRect rect(rx, ry, rwidth, rheight);
+    register QRect *prect = &rect;
+    int partIn, partOut;
+
+    if (!region || region->numRects == 0 || !EXTENTCHECK(&region->extents, prect))
+        return RectangleOut;
+
+    partOut = false;
+    partIn = false;
+
+    /* can stop when both partOut and partIn are true, or we reach prect->y2 */
+    pbox = (region->numRects == 1) ? &region->extents : region->rects.constData();
+    pboxEnd = pbox + region->numRects;
+    for (; pbox < pboxEnd; ++pbox) {
+        if (pbox->bottom() < ry)
+           continue;
+
+        if (pbox->top() > ry) {
+           partOut = true;
+           if (partIn || pbox->top() > prect->bottom())
+              break;
+           ry = pbox->top();
+        }
+
+        if (pbox->right() < rx)
+           continue;            /* not far enough over yet */
+
+        if (pbox->left() > rx) {
+           partOut = true;      /* missed part of rectangle to left */
+           if (partIn)
+              break;
+        }
+
+        if (pbox->left() <= prect->right()) {
+            partIn = true;      /* definitely overlap */
+            if (partOut)
+               break;
+        }
+
+        if (pbox->right() >= prect->right()) {
+           ry = pbox->bottom() + 1;     /* finished with this band */
+           if (ry > prect->bottom())
+              break;
+           rx = prect->left();  /* reset x out to left again */
+        } else {
+            /*
+             * Because boxes in a band are maximal width, if the first box
+             * to overlap the rectangle doesn't completely cover it in that
+             * band, the rectangle must be partially out, since some of it
+             * will be uncovered in that band. partIn will have been set true
+             * by now...
+             */
+            break;
+        }
+    }
+    return partIn ? ((ry <= prect->bottom()) ? RectanglePart : RectangleIn) : RectangleOut;
+}
+// END OF Region.c extract
+// START OF poly.h extract
+/* $XConsortium: poly.h,v 1.4 94/04/17 20:22:19 rws Exp $ */
+/************************************************************************
+
+Copyright (c) 1987  X Consortium
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of the X Consortium shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from the X Consortium.
+
+
+Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+************************************************************************/
+
+/*
+ *     This file contains a few macros to help track
+ *     the edge of a filled object.  The object is assumed
+ *     to be filled in scanline order, and thus the
+ *     algorithm used is an extension of Bresenham's line
+ *     drawing algorithm which assumes that y is always the
+ *     major axis.
+ *     Since these pieces of code are the same for any filled shape,
+ *     it is more convenient to gather the library in one
+ *     place, but since these pieces of code are also in
+ *     the inner loops of output primitives, procedure call
+ *     overhead is out of the question.
+ *     See the author for a derivation if needed.
+ */
+
+
+/*
+ *  In scan converting polygons, we want to choose those pixels
+ *  which are inside the polygon.  Thus, we add .5 to the starting
+ *  x coordinate for both left and right edges.  Now we choose the
+ *  first pixel which is inside the pgon for the left edge and the
+ *  first pixel which is outside the pgon for the right edge.
+ *  Draw the left pixel, but not the right.
+ *
+ *  How to add .5 to the starting x coordinate:
+ *      If the edge is moving to the right, then subtract dy from the
+ *  error term from the general form of the algorithm.
+ *      If the edge is moving to the left, then add dy to the error term.
+ *
+ *  The reason for the difference between edges moving to the left
+ *  and edges moving to the right is simple:  If an edge is moving
+ *  to the right, then we want the algorithm to flip immediately.
+ *  If it is moving to the left, then we don't want it to flip until
+ *  we traverse an entire pixel.
+ */
+#define BRESINITPGON(dy, x1, x2, xStart, d, m, m1, incr1, incr2) { \
+    int dx;      /* local storage */ \
+\
+    /* \
+     *  if the edge is horizontal, then it is ignored \
+     *  and assumed not to be processed.  Otherwise, do this stuff. \
+     */ \
+    if ((dy) != 0) { \
+        xStart = (x1); \
+        dx = (x2) - xStart; \
+        if (dx < 0) { \
+            m = dx / (dy); \
+            m1 = m - 1; \
+            incr1 = -2 * dx + 2 * (dy) * m1; \
+            incr2 = -2 * dx + 2 * (dy) * m; \
+            d = 2 * m * (dy) - 2 * dx - 2 * (dy); \
+        } else { \
+            m = dx / (dy); \
+            m1 = m + 1; \
+            incr1 = 2 * dx - 2 * (dy) * m1; \
+            incr2 = 2 * dx - 2 * (dy) * m; \
+            d = -2 * m * (dy) + 2 * dx; \
+        } \
+    } \
+}
+
+#define BRESINCRPGON(d, minval, m, m1, incr1, incr2) { \
+    if (m1 > 0) { \
+        if (d > 0) { \
+            minval += m1; \
+            d += incr1; \
+        } \
+        else { \
+            minval += m; \
+            d += incr2; \
+        } \
+    } else {\
+        if (d >= 0) { \
+            minval += m1; \
+            d += incr1; \
+        } \
+        else { \
+            minval += m; \
+            d += incr2; \
+        } \
+    } \
+}
+
+
+/*
+ *     This structure contains all of the information needed
+ *     to run the bresenham algorithm.
+ *     The variables may be hardcoded into the declarations
+ *     instead of using this structure to make use of
+ *     register declarations.
+ */
+typedef struct {
+    int minor_axis;     /* minor axis        */
+    int d;              /* decision variable */
+    int m, m1;          /* slope and slope+1 */
+    int incr1, incr2;   /* error increments */
+} BRESINFO;
+
+
+#define BRESINITPGONSTRUCT(dmaj, min1, min2, bres) \
+        BRESINITPGON(dmaj, min1, min2, bres.minor_axis, bres.d, \
+                     bres.m, bres.m1, bres.incr1, bres.incr2)
+
+#define BRESINCRPGONSTRUCT(bres) \
+        BRESINCRPGON(bres.d, bres.minor_axis, bres.m, bres.m1, bres.incr1, bres.incr2)
+
+
+
+/*
+ *     These are the data structures needed to scan
+ *     convert regions.  Two different scan conversion
+ *     methods are available -- the even-odd method, and
+ *     the winding number method.
+ *     The even-odd rule states that a point is inside
+ *     the polygon if a ray drawn from that point in any
+ *     direction will pass through an odd number of
+ *     path segments.
+ *     By the winding number rule, a point is decided
+ *     to be inside the polygon if a ray drawn from that
+ *     point in any direction passes through a different
+ *     number of clockwise and counter-clockwise path
+ *     segments.
+ *
+ *     These data structures are adapted somewhat from
+ *     the algorithm in (Foley/Van Dam) for scan converting
+ *     polygons.
+ *     The basic algorithm is to start at the top (smallest y)
+ *     of the polygon, stepping down to the bottom of
+ *     the polygon by incrementing the y coordinate.  We
+ *     keep a list of edges which the current scanline crosses,
+ *     sorted by x.  This list is called the Active Edge Table (AET)
+ *     As we change the y-coordinate, we update each entry in
+ *     in the active edge table to reflect the edges new xcoord.
+ *     This list must be sorted at each scanline in case
+ *     two edges intersect.
+ *     We also keep a data structure known as the Edge Table (ET),
+ *     which keeps track of all the edges which the current
+ *     scanline has not yet reached.  The ET is basically a
+ *     list of ScanLineList structures containing a list of
+ *     edges which are entered at a given scanline.  There is one
+ *     ScanLineList per scanline at which an edge is entered.
+ *     When we enter a new edge, we move it from the ET to the AET.
+ *
+ *     From the AET, we can implement the even-odd rule as in
+ *     (Foley/Van Dam).
+ *     The winding number rule is a little trickier.  We also
+ *     keep the EdgeTableEntries in the AET linked by the
+ *     nextWETE (winding EdgeTableEntry) link.  This allows
+ *     the edges to be linked just as before for updating
+ *     purposes, but only uses the edges linked by the nextWETE
+ *     link as edges representing spans of the polygon to
+ *     drawn (as with the even-odd rule).
+ */
+
+/*
+ * for the winding number rule
+ */
+#define CLOCKWISE          1
+#define COUNTERCLOCKWISE  -1
+
+typedef struct _EdgeTableEntry {
+     int ymax;             /* ycoord at which we exit this edge. */
+     BRESINFO bres;        /* Bresenham info to run the edge     */
+     struct _EdgeTableEntry *next;       /* next in the list     */
+     struct _EdgeTableEntry *back;       /* for insertion sort   */
+     struct _EdgeTableEntry *nextWETE;   /* for winding num rule */
+     int ClockWise;        /* flag for winding number rule       */
+} EdgeTableEntry;
+
+
+typedef struct _ScanLineList{
+     int scanline;              /* the scanline represented */
+     EdgeTableEntry *edgelist;  /* header node              */
+     struct _ScanLineList *next;  /* next in the list       */
+} ScanLineList;
+
+
+typedef struct {
+     int ymax;                 /* ymax for the polygon     */
+     int ymin;                 /* ymin for the polygon     */
+     ScanLineList scanlines;   /* header node              */
+} EdgeTable;
+
+
+/*
+ * Here is a struct to help with storage allocation
+ * so we can allocate a big chunk at a time, and then take
+ * pieces from this heap when we need to.
+ */
+#define SLLSPERBLOCK 25
+
+typedef struct _ScanLineListBlock {
+     ScanLineList SLLs[SLLSPERBLOCK];
+     struct _ScanLineListBlock *next;
+} ScanLineListBlock;
+
+
+
+/*
+ *
+ *     a few macros for the inner loops of the fill code where
+ *     performance considerations don't allow a procedure call.
+ *
+ *     Evaluate the given edge at the given scanline.
+ *     If the edge has expired, then we leave it and fix up
+ *     the active edge table; otherwise, we increment the
+ *     x value to be ready for the next scanline.
+ *     The winding number rule is in effect, so we must notify
+ *     the caller when the edge has been removed so he
+ *     can reorder the Winding Active Edge Table.
+ */
+#define EVALUATEEDGEWINDING(pAET, pPrevAET, y, fixWAET) { \
+   if (pAET->ymax == y) {          /* leaving this edge */ \
+      pPrevAET->next = pAET->next; \
+      pAET = pPrevAET->next; \
+      fixWAET = 1; \
+      if (pAET) \
+         pAET->back = pPrevAET; \
+   } \
+   else { \
+      BRESINCRPGONSTRUCT(pAET->bres) \
+      pPrevAET = pAET; \
+      pAET = pAET->next; \
+   } \
+}
+
+
+/*
+ *     Evaluate the given edge at the given scanline.
+ *     If the edge has expired, then we leave it and fix up
+ *     the active edge table; otherwise, we increment the
+ *     x value to be ready for the next scanline.
+ *     The even-odd rule is in effect.
+ */
+#define EVALUATEEDGEEVENODD(pAET, pPrevAET, y) { \
+   if (pAET->ymax == y) {          /* leaving this edge */ \
+      pPrevAET->next = pAET->next; \
+      pAET = pPrevAET->next; \
+      if (pAET) \
+         pAET->back = pPrevAET; \
+   } \
+   else { \
+      BRESINCRPGONSTRUCT(pAET->bres) \
+      pPrevAET = pAET; \
+      pAET = pAET->next; \
+   } \
+}
+// END OF poly.h extract
+// START OF PolyReg.c extract
+/* $XConsortium: PolyReg.c,v 11.23 94/11/17 21:59:37 converse Exp $ */
+/************************************************************************
+
+Copyright (c) 1987  X Consortium
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of the X Consortium shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from the X Consortium.
+
+
+Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+************************************************************************/
+/* $XFree86: xc/lib/X11/PolyReg.c,v 1.1.1.2.8.2 1998/10/04 15:22:49 hohndel Exp $ */
+
+#define LARGE_COORDINATE INT_MAX
+#define SMALL_COORDINATE INT_MIN
+
+/*
+ *     InsertEdgeInET
+ *
+ *     Insert the given edge into the edge table.
+ *     First we must find the correct bucket in the
+ *     Edge table, then find the right slot in the
+ *     bucket.  Finally, we can insert it.
+ *
+ */
+static void InsertEdgeInET(EdgeTable *ET, EdgeTableEntry *ETE, int scanline,
+                           ScanLineListBlock **SLLBlock, int *iSLLBlock)
+{
+    register EdgeTableEntry *start, *prev;
+    register ScanLineList *pSLL, *pPrevSLL;
+    ScanLineListBlock *tmpSLLBlock;
+
+    /*
+     * find the right bucket to put the edge into
+     */
+    pPrevSLL = &ET->scanlines;
+    pSLL = pPrevSLL->next;
+    while (pSLL && (pSLL->scanline < scanline)) {
+        pPrevSLL = pSLL;
+        pSLL = pSLL->next;
+    }
+
+    /*
+     * reassign pSLL (pointer to ScanLineList) if necessary
+     */
+    if ((!pSLL) || (pSLL->scanline > scanline)) {
+        if (*iSLLBlock > SLLSPERBLOCK-1)
+        {
+            tmpSLLBlock =
+                  (ScanLineListBlock *)malloc(sizeof(ScanLineListBlock));
+            Q_CHECK_PTR(tmpSLLBlock);
+            (*SLLBlock)->next = tmpSLLBlock;
+            tmpSLLBlock->next = (ScanLineListBlock *)NULL;
+            *SLLBlock = tmpSLLBlock;
+            *iSLLBlock = 0;
+        }
+        pSLL = &((*SLLBlock)->SLLs[(*iSLLBlock)++]);
+
+        pSLL->next = pPrevSLL->next;
+        pSLL->edgelist = (EdgeTableEntry *)NULL;
+        pPrevSLL->next = pSLL;
+    }
+    pSLL->scanline = scanline;
+
+    /*
+     * now insert the edge in the right bucket
+     */
+    prev = 0;
+    start = pSLL->edgelist;
+    while (start && (start->bres.minor_axis < ETE->bres.minor_axis)) {
+        prev = start;
+        start = start->next;
+    }
+    ETE->next = start;
+
+    if (prev)
+        prev->next = ETE;
+    else
+        pSLL->edgelist = ETE;
+}
+
+/*
+ *     CreateEdgeTable
+ *
+ *     This routine creates the edge table for
+ *     scan converting polygons.
+ *     The Edge Table (ET) looks like:
+ *
+ *    EdgeTable
+ *     --------
+ *    |  ymax  |        ScanLineLists
+ *    |scanline|-->------------>-------------->...
+ *     --------   |scanline|   |scanline|
+ *                |edgelist|   |edgelist|
+ *                ---------    ---------
+ *                    |             |
+ *                    |             |
+ *                    V             V
+ *              list of ETEs   list of ETEs
+ *
+ *     where ETE is an EdgeTableEntry data structure,
+ *     and there is one ScanLineList per scanline at
+ *     which an edge is initially entered.
+ *
+ */
+
+static void CreateETandAET(register int count, register const QPoint *pts,
+                           EdgeTable *ET, EdgeTableEntry *AET, register EdgeTableEntry *pETEs,
+                           ScanLineListBlock *pSLLBlock)
+{
+    register const QPoint *top,
+                          *bottom,
+                          *PrevPt,
+                          *CurrPt;
+    int iSLLBlock = 0;
+    int dy;
+
+    if (count < 2)
+        return;
+
+    /*
+     *  initialize the Active Edge Table
+     */
+    AET->next = 0;
+    AET->back = 0;
+    AET->nextWETE = 0;
+    AET->bres.minor_axis = SMALL_COORDINATE;
+
+    /*
+     *  initialize the Edge Table.
+     */
+    ET->scanlines.next = 0;
+    ET->ymax = SMALL_COORDINATE;
+    ET->ymin = LARGE_COORDINATE;
+    pSLLBlock->next = 0;
+
+    PrevPt = &pts[count - 1];
+
+    /*
+     *  for each vertex in the array of points.
+     *  In this loop we are dealing with two vertices at
+     *  a time -- these make up one edge of the polygon.
+     */
+    while (count--) {
+        CurrPt = pts++;
+
+        /*
+         *  find out which point is above and which is below.
+         */
+        if (PrevPt->y() > CurrPt->y()) {
+            bottom = PrevPt;
+            top = CurrPt;
+            pETEs->ClockWise = 0;
+        } else {
+            bottom = CurrPt;
+            top = PrevPt;
+            pETEs->ClockWise = 1;
+        }
+
+        /*
+         * don't add horizontal edges to the Edge table.
+         */
+        if (bottom->y() != top->y()) {
+            pETEs->ymax = bottom->y() - 1;  /* -1 so we don't get last scanline */
+
+            /*
+             *  initialize integer edge algorithm
+             */
+            dy = bottom->y() - top->y();
+            BRESINITPGONSTRUCT(dy, top->x(), bottom->x(), pETEs->bres)
+
+            InsertEdgeInET(ET, pETEs, top->y(), &pSLLBlock, &iSLLBlock);
+
+            if (PrevPt->y() > ET->ymax)
+                ET->ymax = PrevPt->y();
+            if (PrevPt->y() < ET->ymin)
+                ET->ymin = PrevPt->y();
+            ++pETEs;
+        }
+
+        PrevPt = CurrPt;
+    }
+}
+
+/*
+ *     loadAET
+ *
+ *     This routine moves EdgeTableEntries from the
+ *     EdgeTable into the Active Edge Table,
+ *     leaving them sorted by smaller x coordinate.
+ *
+ */
+
+static void loadAET(register EdgeTableEntry *AET, register EdgeTableEntry *ETEs)
+{
+    register EdgeTableEntry *pPrevAET;
+    register EdgeTableEntry *tmp;
+
+    pPrevAET = AET;
+    AET = AET->next;
+    while (ETEs) {
+        while (AET && AET->bres.minor_axis < ETEs->bres.minor_axis) {
+            pPrevAET = AET;
+            AET = AET->next;
+        }
+        tmp = ETEs->next;
+        ETEs->next = AET;
+        if (AET)
+            AET->back = ETEs;
+        ETEs->back = pPrevAET;
+        pPrevAET->next = ETEs;
+        pPrevAET = ETEs;
+
+        ETEs = tmp;
+    }
+}
+
+/*
+ *     computeWAET
+ *
+ *     This routine links the AET by the
+ *     nextWETE (winding EdgeTableEntry) link for
+ *     use by the winding number rule.  The final
+ *     Active Edge Table (AET) might look something
+ *     like:
+ *
+ *     AET
+ *     ----------  ---------   ---------
+ *     |ymax    |  |ymax    |  |ymax    |
+ *     | ...    |  |...     |  |...     |
+ *     |next    |->|next    |->|next    |->...
+ *     |nextWETE|  |nextWETE|  |nextWETE|
+ *     ---------   ---------   ^--------
+ *         |                   |       |
+ *         V------------------->       V---> ...
+ *
+ */
+static void computeWAET(register EdgeTableEntry *AET)
+{
+    register EdgeTableEntry *pWETE;
+    register int inside = 1;
+    register int isInside = 0;
+
+    AET->nextWETE = 0;
+    pWETE = AET;
+    AET = AET->next;
+    while (AET) {
+        if (AET->ClockWise)
+            ++isInside;
+        else
+            --isInside;
+
+        if ((!inside && !isInside) || (inside && isInside)) {
+            pWETE->nextWETE = AET;
+            pWETE = AET;
+            inside = !inside;
+        }
+        AET = AET->next;
+    }
+    pWETE->nextWETE = 0;
+}
+
+/*
+ *     InsertionSort
+ *
+ *     Just a simple insertion sort using
+ *     pointers and back pointers to sort the Active
+ *     Edge Table.
+ *
+ */
+
+static int InsertionSort(register EdgeTableEntry *AET)
+{
+    register EdgeTableEntry *pETEchase;
+    register EdgeTableEntry *pETEinsert;
+    register EdgeTableEntry *pETEchaseBackTMP;
+    register int changed = 0;
+
+    AET = AET->next;
+    while (AET) {
+        pETEinsert = AET;
+        pETEchase = AET;
+        while (pETEchase->back->bres.minor_axis > AET->bres.minor_axis)
+            pETEchase = pETEchase->back;
+
+        AET = AET->next;
+        if (pETEchase != pETEinsert) {
+            pETEchaseBackTMP = pETEchase->back;
+            pETEinsert->back->next = AET;
+            if (AET)
+                AET->back = pETEinsert->back;
+            pETEinsert->next = pETEchase;
+            pETEchase->back->next = pETEinsert;
+            pETEchase->back = pETEinsert;
+            pETEinsert->back = pETEchaseBackTMP;
+            changed = 1;
+        }
+    }
+    return changed;
+}
+
+/*
+ *     Clean up our act.
+ */
+static void FreeStorage(register ScanLineListBlock *pSLLBlock)
+{
+    register ScanLineListBlock *tmpSLLBlock;
+
+    while (pSLLBlock) {
+        tmpSLLBlock = pSLLBlock->next;
+        free(pSLLBlock);
+        pSLLBlock = tmpSLLBlock;
+    }
+}
+
+struct QRegionSpan {
+    QRegionSpan() {}
+    QRegionSpan(int x1_, int x2_) : x1(x1_), x2(x2_) {}
+
+    int x1;
+    int x2;
+    int width() const { return x2 - x1; }
+};
+
+Q_DECLARE_TYPEINFO(QRegionSpan, Q_PRIMITIVE_TYPE);
+
+static inline void flushRow(const QRegionSpan *spans, int y, int numSpans, QRegionPrivate *reg, int *lastRow, int *extendTo, bool *needsExtend)
+{
+    QRect *regRects = reg->rects.data() + *lastRow;
+    bool canExtend = reg->rects.size() - *lastRow == numSpans
+        && !(*needsExtend && *extendTo + 1 != y)
+        && (*needsExtend || regRects[0].y() + regRects[0].height() == y);
+
+    for (int i = 0; i < numSpans && canExtend; ++i) {
+        if (regRects[i].x() != spans[i].x1 || regRects[i].right() != spans[i].x2 - 1)
+            canExtend = false;
+    }
+
+    if (canExtend) {
+        *extendTo = y;
+        *needsExtend = true;
+    } else {
+        if (*needsExtend) {
+            for (int i = 0; i < reg->rects.size() - *lastRow; ++i)
+                regRects[i].setBottom(*extendTo);
+        }
+
+        *lastRow = reg->rects.size();
+        reg->rects.reserve(*lastRow + numSpans);
+        for (int i = 0; i < numSpans; ++i)
+            reg->rects << QRect(spans[i].x1, y, spans[i].width(), 1);
+
+        if (spans[0].x1 < reg->extents.left())
+            reg->extents.setLeft(spans[0].x1);
+
+        if (spans[numSpans-1].x2 - 1 > reg->extents.right())
+            reg->extents.setRight(spans[numSpans-1].x2 - 1);
+
+        *needsExtend = false;
+    }
+}
+
+/*
+ *     Create an array of rectangles from a list of points.
+ *     If indeed these things (POINTS, RECTS) are the same,
+ *     then this proc is still needed, because it allocates
+ *     storage for the array, which was allocated on the
+ *     stack by the calling procedure.
+ *
+ */
+static void PtsToRegion(register int numFullPtBlocks, register int iCurPtBlock,
+                       POINTBLOCK *FirstPtBlock, QRegionPrivate *reg)
+{
+    int lastRow = 0;
+    int extendTo = 0;
+    bool needsExtend = false;
+    QVarLengthArray<QRegionSpan> row;
+    int rowSize = 0;
+
+    reg->extents.setLeft(INT_MAX);
+    reg->extents.setRight(INT_MIN);
+    reg->innerArea = -1;
+
+    POINTBLOCK *CurPtBlock = FirstPtBlock;
+    for (; numFullPtBlocks >= 0; --numFullPtBlocks) {
+        /* the loop uses 2 points per iteration */
+        int i = NUMPTSTOBUFFER >> 1;
+        if (!numFullPtBlocks)
+            i = iCurPtBlock >> 1;
+        if(i) {
+            row.resize(qMax(row.size(), rowSize + i));
+            for (QPoint *pts = CurPtBlock->pts; i--; pts += 2) {
+                const int width = pts[1].x() - pts[0].x();
+                if (width) {
+                    if (rowSize && row[rowSize-1].x2 == pts[0].x())
+                        row[rowSize-1].x2 = pts[1].x();
+                    else
+                        row[rowSize++] = QRegionSpan(pts[0].x(), pts[1].x());
+                }
+
+                if (rowSize) {
+                    QPoint *next = i ? &pts[2] : (numFullPtBlocks ? CurPtBlock->next->pts : 0);
+
+                    if (!next || next->y() != pts[0].y()) {
+                        flushRow(row.data(), pts[0].y(), rowSize, reg, &lastRow, &extendTo, &needsExtend);
+                        rowSize = 0;
+                    }
+                }
+            }
+        }
+        CurPtBlock = CurPtBlock->next;
+    }
+
+    if (needsExtend) {
+        for (int i = lastRow; i < reg->rects.size(); ++i)
+            reg->rects[i].setBottom(extendTo);
+    }
+
+    reg->numRects = reg->rects.size();
+
+    if (reg->numRects) {
+        reg->extents.setTop(reg->rects[0].top());
+        reg->extents.setBottom(reg->rects[lastRow].bottom());
+
+        for (int i = 0; i < reg->rects.size(); ++i)
+            reg->updateInnerRect(reg->rects[i]);
+    } else {
+        reg->extents.setCoords(0, 0, 0, 0);
+    }
+}
+
+/*
+ *     polytoregion
+ *
+ *     Scan converts a polygon by returning a run-length
+ *     encoding of the resultant bitmap -- the run-length
+ *     encoding is in the form of an array of rectangles.
+ *
+ *     Can return 0 in case of errors.
+ */
+static QRegionPrivate *PolygonRegion(const QPoint *Pts, int Count, int rule)
+    //Point     *Pts;                /* the pts                 */
+    //int       Count;                 /* number of pts           */
+    //int       rule;                        /* winding rule */
+{
+    QRegionPrivate *region;
+    register EdgeTableEntry *pAET;   /* Active Edge Table       */
+    register int y;                  /* current scanline        */
+    register int iPts = 0;           /* number of pts in buffer */
+    register EdgeTableEntry *pWETE;  /* Winding Edge Table Entry*/
+    register ScanLineList *pSLL;     /* current scanLineList    */
+    register QPoint *pts;             /* output buffer           */
+    EdgeTableEntry *pPrevAET;        /* ptr to previous AET     */
+    EdgeTable ET;                    /* header node for ET      */
+    EdgeTableEntry AET;              /* header node for AET     */
+    EdgeTableEntry *pETEs;           /* EdgeTableEntries pool   */
+    ScanLineListBlock SLLBlock;      /* header for scanlinelist */
+    int fixWAET = false;
+    POINTBLOCK FirstPtBlock, *curPtBlock; /* PtBlock buffers    */
+    FirstPtBlock.pts = reinterpret_cast<QPoint *>(FirstPtBlock.data);
+    POINTBLOCK *tmpPtBlock;
+    int numFullPtBlocks = 0;
+
+    if (!(region = new QRegionPrivate))
+        return 0;
+
+        /* special case a rectangle */
+    if (((Count == 4) ||
+         ((Count == 5) && (Pts[4].x() == Pts[0].x()) && (Pts[4].y() == Pts[0].y())))
+         && (((Pts[0].y() == Pts[1].y()) && (Pts[1].x() == Pts[2].x()) && (Pts[2].y() == Pts[3].y())
+               && (Pts[3].x() == Pts[0].x())) || ((Pts[0].x() == Pts[1].x())
+               && (Pts[1].y() == Pts[2].y()) && (Pts[2].x() == Pts[3].x())
+               && (Pts[3].y() == Pts[0].y())))) {
+        int x = qMin(Pts[0].x(), Pts[2].x());
+        region->extents.setLeft(x);
+        int y = qMin(Pts[0].y(), Pts[2].y());
+        region->extents.setTop(y);
+        region->extents.setWidth(qMax(Pts[0].x(), Pts[2].x()) - x);
+        region->extents.setHeight(qMax(Pts[0].y(), Pts[2].y()) - y);
+        if ((region->extents.left() <= region->extents.right()) &&
+            (region->extents.top() <= region->extents.bottom())) {
+            region->numRects = 1;
+            region->innerRect = region->extents;
+            region->innerArea = region->innerRect.width() * region->innerRect.height();
+        }
+        return region;
+    }
+
+    if (!(pETEs = static_cast<EdgeTableEntry *>(malloc(sizeof(EdgeTableEntry) * Count))))
+        return 0;
+
+    region->vectorize();
+
+    pts = FirstPtBlock.pts;
+    CreateETandAET(Count, Pts, &ET, &AET, pETEs, &SLLBlock);
+
+    pSLL = ET.scanlines.next;
+    curPtBlock = &FirstPtBlock;
+
+    // sanity check that the region won't become too big...
+    if (ET.ymax - ET.ymin > 100000) {
+        // clean up region ptr
+#ifndef QT_NO_DEBUG
+        qWarning("QRegion: creating region from big polygon failed...!");
+#endif
+        delete region;
+        return 0;
+    }
+
+
+    QT_TRY {
+        if (rule == EvenOddRule) {
+            /*
+             *  for each scanline
+             */
+            for (y = ET.ymin; y < ET.ymax; ++y) {
+
+                /*
+                 *  Add a new edge to the active edge table when we
+                 *  get to the next edge.
+                 */
+                if (pSLL && y == pSLL->scanline) {
+                    loadAET(&AET, pSLL->edgelist);
+                    pSLL = pSLL->next;
+                }
+                pPrevAET = &AET;
+                pAET = AET.next;
+
+                /*
+                 *  for each active edge
+                 */
+                while (pAET) {
+                    pts->setX(pAET->bres.minor_axis);
+                    pts->setY(y);
+                    ++pts;
+                    ++iPts;
+
+                    /*
+                     *  send out the buffer
+                     */
+                    if (iPts == NUMPTSTOBUFFER) {
+                        tmpPtBlock = (POINTBLOCK *)malloc(sizeof(POINTBLOCK));
+                        Q_CHECK_PTR(tmpPtBlock);
+                        tmpPtBlock->pts = reinterpret_cast<QPoint *>(tmpPtBlock->data);
+                        curPtBlock->next = tmpPtBlock;
+                        curPtBlock = tmpPtBlock;
+                        pts = curPtBlock->pts;
+                        ++numFullPtBlocks;
+                        iPts = 0;
+                    }
+                    EVALUATEEDGEEVENODD(pAET, pPrevAET, y)
+                }
+                InsertionSort(&AET);
+            }
+        } else {
+            /*
+             *  for each scanline
+             */
+            for (y = ET.ymin; y < ET.ymax; ++y) {
+                /*
+                 *  Add a new edge to the active edge table when we
+                 *  get to the next edge.
+                 */
+                if (pSLL && y == pSLL->scanline) {
+                    loadAET(&AET, pSLL->edgelist);
+                    computeWAET(&AET);
+                    pSLL = pSLL->next;
+                }
+                pPrevAET = &AET;
+                pAET = AET.next;
+                pWETE = pAET;
+
+                /*
+                 *  for each active edge
+                 */
+                while (pAET) {
+                    /*
+                     *  add to the buffer only those edges that
+                     *  are in the Winding active edge table.
+                     */
+                    if (pWETE == pAET) {
+                        pts->setX(pAET->bres.minor_axis);
+                        pts->setY(y);
+                        ++pts;
+                        ++iPts;
+
+                        /*
+                         *  send out the buffer
+                         */
+                        if (iPts == NUMPTSTOBUFFER) {
+                            tmpPtBlock = static_cast<POINTBLOCK *>(malloc(sizeof(POINTBLOCK)));
+                            tmpPtBlock->pts = reinterpret_cast<QPoint *>(tmpPtBlock->data);
+                            curPtBlock->next = tmpPtBlock;
+                            curPtBlock = tmpPtBlock;
+                            pts = curPtBlock->pts;
+                            ++numFullPtBlocks;
+                            iPts = 0;
+                        }
+                        pWETE = pWETE->nextWETE;
+                    }
+                    EVALUATEEDGEWINDING(pAET, pPrevAET, y, fixWAET)
+                }
+
+                /*
+                 *  recompute the winding active edge table if
+                 *  we just resorted or have exited an edge.
+                 */
+                if (InsertionSort(&AET) || fixWAET) {
+                    computeWAET(&AET);
+                    fixWAET = false;
+                }
+            }
+        }
+    } QT_CATCH(...) {
+        FreeStorage(SLLBlock.next);
+        PtsToRegion(numFullPtBlocks, iPts, &FirstPtBlock, region);
+        for (curPtBlock = FirstPtBlock.next; --numFullPtBlocks >= 0;) {
+            tmpPtBlock = curPtBlock->next;
+            free(curPtBlock);
+            curPtBlock = tmpPtBlock;
+        }
+        free(pETEs);
+        return 0; // this function returns 0 in case of an error
+    }
+
+    FreeStorage(SLLBlock.next);
+    PtsToRegion(numFullPtBlocks, iPts, &FirstPtBlock, region);
+    for (curPtBlock = FirstPtBlock.next; --numFullPtBlocks >= 0;) {
+        tmpPtBlock = curPtBlock->next;
+        free(curPtBlock);
+        curPtBlock = tmpPtBlock;
+    }
+    free(pETEs);
+    return region;
+}
+// END OF PolyReg.c extract
+
+QRegionPrivate *qt_bitmapToRegion(const QBitmap& bitmap)
+{
+    QImage image = bitmap.toImage();
+
+    QRegionPrivate *region = new QRegionPrivate;
+
+    QRect xr;
+
+#define AddSpan \
+        { \
+            xr.setCoords(prev1, y, x-1, y); \
+            UnionRectWithRegion(&xr, region, *region); \
+        }
+
+    const uchar zero = 0;
+    bool little = image.format() == QImage::Format_MonoLSB;
+
+    int x,
+        y;
+    for (y = 0; y < image.height(); ++y) {
+        uchar *line = image.scanLine(y);
+        int w = image.width();
+        uchar all = zero;
+        int prev1 = -1;
+        for (x = 0; x < w;) {
+            uchar byte = line[x / 8];
+            if (x > w - 8 || byte!=all) {
+                if (little) {
+                    for (int b = 8; b > 0 && x < w; --b) {
+                        if (!(byte & 0x01) == !all) {
+                            // More of the same
+                        } else {
+                            // A change.
+                            if (all!=zero) {
+                                AddSpan
+                                all = zero;
+                            } else {
+                                prev1 = x;
+                                all = ~zero;
+                            }
+                        }
+                        byte >>= 1;
+                        ++x;
+                    }
+                } else {
+                    for (int b = 8; b > 0 && x < w; --b) {
+                        if (!(byte & 0x80) == !all) {
+                            // More of the same
+                        } else {
+                            // A change.
+                            if (all != zero) {
+                                AddSpan
+                                all = zero;
+                            } else {
+                                prev1 = x;
+                                all = ~zero;
+                            }
+                        }
+                        byte <<= 1;
+                        ++x;
+                    }
+                }
+            } else {
+                x += 8;
+            }
+        }
+        if (all != zero) {
+            AddSpan
+        }
+    }
+#undef AddSpan
+
+    return region;
+}
+
+QRegion::QRegion()
+    : d(&shared_empty)
+{
+    d->ref.ref();
+}
+
+QRegion::QRegion(const QRect &r, RegionType t)
+{
+    if (r.isEmpty()) {
+        d = &shared_empty;
+        d->ref.ref();
+    } else {
+        d = new QRegionData;
+        d->ref = 1;
+#if defined(Q_WS_X11)
+        d->rgn = 0;
+        d->xrectangles = 0;
+#elif defined(Q_WS_WIN)
+        d->rgn = 0;
+#endif
+        if (t == Rectangle) {
+            d->qt_rgn = new QRegionPrivate(r);
+        } else if (t == Ellipse) {
+            QPainterPath path;
+            path.addEllipse(r.x(), r.y(), r.width(), r.height());
+            QPolygon a = path.toSubpathPolygons().at(0).toPolygon();
+            d->qt_rgn = PolygonRegion(a.constData(), a.size(), EvenOddRule);
+        }
+    }
+}
+
+QRegion::QRegion(const QPolygon &a, Qt::FillRule fillRule)
+{
+    if (a.count() > 2) {
+        QRegionPrivate *qt_rgn = PolygonRegion(a.constData(), a.size(),
+                                               fillRule == Qt::WindingFill ? WindingRule : EvenOddRule);
+        if (qt_rgn) {
+            d =  new QRegionData;
+            d->ref = 1;
+#if defined(Q_WS_X11)
+            d->rgn = 0;
+            d->xrectangles = 0;
+#elif defined(Q_WS_WIN)
+            d->rgn = 0;
+#endif
+            d->qt_rgn = qt_rgn;
+        } else {
+            d = &shared_empty;
+            d->ref.ref();
+        }
+    } else {
+        d = &shared_empty;
+        d->ref.ref();
+    }
+}
+
+QRegion::QRegion(const QRegion &r)
+{
+    d = r.d;
+    d->ref.ref();
+}
+
+
+QRegion::QRegion(const QBitmap &bm)
+{
+    if (bm.isNull()) {
+        d = &shared_empty;
+        d->ref.ref();
+    } else {
+        d = new QRegionData;
+        d->ref = 1;
+#if defined(Q_WS_X11)
+        d->rgn = 0;
+        d->xrectangles = 0;
+#elif defined(Q_WS_WIN)
+        d->rgn = 0;
+#endif
+        d->qt_rgn = qt_bitmapToRegion(bm);
+    }
+}
+
+void QRegion::cleanUp(QRegion::QRegionData *x)
+{
+    delete x->qt_rgn;
+#if defined(Q_WS_X11)
+    if (x->rgn)
+        XDestroyRegion(x->rgn);
+    if (x->xrectangles)
+        free(x->xrectangles);
+#elif defined(Q_WS_WIN)
+    if (x->rgn)
+        qt_win_dispose_rgn(x->rgn);
+#endif
+    delete x;
+}
+
+QRegion::~QRegion()
+{
+    if (!d->ref.deref())
+        cleanUp(d);
+}
+
+
+QRegion &QRegion::operator=(const QRegion &r)
+{
+    r.d->ref.ref();
+    if (!d->ref.deref())
+        cleanUp(d);
+    d = r.d;
+    return *this;
+}
+
+
+/*!
+    \internal
+*/
+QRegion QRegion::copy() const
+{
+    QRegion r;
+    QScopedPointer<QRegionData> x(new QRegionData);
+    x->ref = 1;
+#if defined(Q_WS_X11)
+    x->rgn = 0;
+    x->xrectangles = 0;
+#elif defined(Q_WS_WIN)
+    x->rgn = 0;
+#endif
+    if (d->qt_rgn)
+        x->qt_rgn = new QRegionPrivate(*d->qt_rgn);
+    else
+        x->qt_rgn = new QRegionPrivate;
+    if (!r.d->ref.deref())
+        cleanUp(r.d);
+    r.d = x.take();
+    return r;
+}
+
+bool QRegion::isEmpty() const
+{
+    return d == &shared_empty || d->qt_rgn->numRects == 0;
+}
+
+
+bool QRegion::contains(const QPoint &p) const
+{
+    return PointInRegion(d->qt_rgn, p.x(), p.y());
+}
+
+bool QRegion::contains(const QRect &r) const
+{
+    return RectInRegion(d->qt_rgn, r.left(), r.top(), r.width(), r.height()) != RectangleOut;
+}
+
+
+
+void QRegion::translate(int dx, int dy)
+{
+    if ((dx == 0 && dy == 0) || isEmptyHelper(d->qt_rgn))
+        return;
+
+    detach();
+    OffsetRegion(*d->qt_rgn, dx, dy);
+}
+
+QRegion QRegion::unite(const QRegion &r) const
+{
+    if (isEmptyHelper(d->qt_rgn))
+        return r;
+    if (isEmptyHelper(r.d->qt_rgn))
+        return *this;
+    if (d == r.d)
+        return *this;
+
+    if (d->qt_rgn->contains(*r.d->qt_rgn)) {
+        return *this;
+    } else if (r.d->qt_rgn->contains(*d->qt_rgn)) {
+        return r;
+    } else if (d->qt_rgn->canAppend(r.d->qt_rgn)) {
+        QRegion result(*this);
+        result.detach();
+        result.d->qt_rgn->append(r.d->qt_rgn);
+        return result;
+    } else if (d->qt_rgn->canPrepend(r.d->qt_rgn)) {
+        QRegion result(*this);
+        result.detach();
+        result.d->qt_rgn->prepend(r.d->qt_rgn);
+        return result;
+    } else if (EqualRegion(d->qt_rgn, r.d->qt_rgn)) {
+        return *this;
+    } else {
+        QRegion result;
+        result.detach();
+        UnionRegion(d->qt_rgn, r.d->qt_rgn, *result.d->qt_rgn);
+        return result;
+    }
+}
+
+QRegion& QRegion::operator+=(const QRegion &r)
+{
+    if (isEmptyHelper(d->qt_rgn))
+        return *this = r;
+    if (isEmptyHelper(r.d->qt_rgn))
+        return *this;
+    if (d == r.d)
+        return *this;
+
+    if (d->qt_rgn->contains(*r.d->qt_rgn)) {
+        return *this;
+    } else if (r.d->qt_rgn->contains(*d->qt_rgn)) {
+        return *this = r;
+    } else if (d->qt_rgn->canAppend(r.d->qt_rgn)) {
+        detach();
+        d->qt_rgn->append(r.d->qt_rgn);
+        return *this;
+    } else if (d->qt_rgn->canPrepend(r.d->qt_rgn)) {
+        detach();
+        d->qt_rgn->prepend(r.d->qt_rgn);
+        return *this;
+    } else if (EqualRegion(d->qt_rgn, r.d->qt_rgn)) {
+        return *this;
+    } else {
+        detach();
+        UnionRegion(d->qt_rgn, r.d->qt_rgn, *d->qt_rgn);
+        return *this;
+    }
+}
+
+QRegion QRegion::unite(const QRect &r) const
+{
+    if (isEmptyHelper(d->qt_rgn))
+        return r;
+    if (r.isEmpty())
+        return *this;
+
+    if (d->qt_rgn->contains(r)) {
+        return *this;
+    } else if (d->qt_rgn->within(r)) {
+        return r;
+    } else if (d->qt_rgn->numRects == 1 && d->qt_rgn->extents == r) {
+        return *this;
+    } else if (d->qt_rgn->canAppend(&r)) {
+        QRegion result(*this);
+        result.detach();
+        result.d->qt_rgn->append(&r);
+        return result;
+    } else if (d->qt_rgn->canPrepend(&r)) {
+        QRegion result(*this);
+        result.detach();
+        result.d->qt_rgn->prepend(&r);
+        return result;
+    } else {
+        QRegion result;
+        result.detach();
+        QRegionPrivate rp(r);
+        UnionRegion(d->qt_rgn, &rp, *result.d->qt_rgn);
+        return result;
+    }
+}
+
+QRegion& QRegion::operator+=(const QRect &r)
+{
+    if (isEmptyHelper(d->qt_rgn))
+        return *this = r;
+    if (r.isEmpty())
+        return *this;
+
+    if (d->qt_rgn->contains(r)) {
+        return *this;
+    } else if (d->qt_rgn->within(r)) {
+        return *this = r;
+    } else if (d->qt_rgn->canAppend(&r)) {
+        detach();
+        d->qt_rgn->append(&r);
+        return *this;
+    } else if (d->qt_rgn->canPrepend(&r)) {
+        detach();
+        d->qt_rgn->prepend(&r);
+        return *this;
+    } else if (d->qt_rgn->numRects == 1 && d->qt_rgn->extents == r) {
+        return *this;
+    } else {
+        detach();
+        QRegionPrivate p(r);
+        UnionRegion(d->qt_rgn, &p, *d->qt_rgn);
+        return *this;
+    }
+}
+
+QRegion QRegion::intersect(const QRegion &r) const
+{
+    if (isEmptyHelper(d->qt_rgn) || isEmptyHelper(r.d->qt_rgn)
+        || !EXTENTCHECK(&d->qt_rgn->extents, &r.d->qt_rgn->extents))
+        return QRegion();
+
+    /* this is fully contained in r */
+    if (r.d->qt_rgn->contains(*d->qt_rgn))
+        return *this;
+
+    /* r is fully contained in this */
+    if (d->qt_rgn->contains(*r.d->qt_rgn))
+        return r;
+
+    if (r.d->qt_rgn->numRects == 1 && d->qt_rgn->numRects == 1) {
+        const QRect rect = qt_rect_intersect_normalized(r.d->qt_rgn->extents,
+                                                        d->qt_rgn->extents);
+        return QRegion(rect);
+    } else if (r.d->qt_rgn->numRects == 1) {
+        QRegion result(*this);
+        result.detach();
+        result.d->qt_rgn->intersect(r.d->qt_rgn->extents);
+        return result;
+    } else if (d->qt_rgn->numRects == 1) {
+        QRegion result(r);
+        result.detach();
+        result.d->qt_rgn->intersect(d->qt_rgn->extents);
+        return result;
+    }
+
+    QRegion result;
+    result.detach();
+    miRegionOp(*result.d->qt_rgn, d->qt_rgn, r.d->qt_rgn, miIntersectO, 0, 0);
+
+    /*
+     * Can't alter dest's extents before we call miRegionOp because
+     * it might be one of the source regions and miRegionOp depends
+     * on the extents of those regions being the same. Besides, this
+     * way there's no checking against rectangles that will be nuked
+     * due to coalescing, so we have to examine fewer rectangles.
+     */
+    miSetExtents(*result.d->qt_rgn);
+    return result;
+}
+
+QRegion QRegion::intersect(const QRect &r) const
+{
+    if (isEmptyHelper(d->qt_rgn) || r.isEmpty()
+        || !EXTENTCHECK(&d->qt_rgn->extents, &r))
+        return QRegion();
+
+    /* this is fully contained in r */
+    if (d->qt_rgn->within(r))
+        return *this;
+
+    /* r is fully contained in this */
+    if (d->qt_rgn->contains(r))
+        return r;
+
+    if (d->qt_rgn->numRects == 1) {
+        const QRect rect = qt_rect_intersect_normalized(d->qt_rgn->extents,
+                                                        r.normalized());
+        return QRegion(rect);
+    }
+
+    QRegion result(*this);
+    result.detach();
+    result.d->qt_rgn->intersect(r);
+    return result;
+}
+
+QRegion QRegion::subtract(const QRegion &r) const
+{
+    if (isEmptyHelper(d->qt_rgn) || isEmptyHelper(r.d->qt_rgn))
+        return *this;
+    if (r.d->qt_rgn->contains(*d->qt_rgn))
+        return QRegion();
+    if (!EXTENTCHECK(&d->qt_rgn->extents, &r.d->qt_rgn->extents))
+        return *this;
+    if (d == r.d || EqualRegion(d->qt_rgn, r.d->qt_rgn))
+        return QRegion();
+
+#ifdef QT_REGION_DEBUG
+    d->qt_rgn->selfTest();
+    r.d->qt_rgn->selfTest();
+#endif
+
+    QRegion result;
+    result.detach();
+    SubtractRegion(d->qt_rgn, r.d->qt_rgn, *result.d->qt_rgn);
+#ifdef QT_REGION_DEBUG
+    result.d->qt_rgn->selfTest();
+#endif
+    return result;
+}
+
+QRegion QRegion::eor(const QRegion &r) const
+{
+    if (isEmptyHelper(d->qt_rgn)) {
+        return r;
+    } else if (isEmptyHelper(r.d->qt_rgn)) {
+        return *this;
+    } else if (!EXTENTCHECK(&d->qt_rgn->extents, &r.d->qt_rgn->extents)) {
+        return (*this + r);
+    } else if (d == r.d || EqualRegion(d->qt_rgn, r.d->qt_rgn)) {
+        return QRegion();
+    } else {
+        QRegion result;
+        result.detach();
+        XorRegion(d->qt_rgn, r.d->qt_rgn, *result.d->qt_rgn);
+        return result;
+    }
+}
+
+QRect QRegion::boundingRect() const
+{
+    if (isEmpty())
+        return QRect();
+    return d->qt_rgn->extents;
+}
+
+/*! \internal
+    Returns true if \a rect is guaranteed to be fully contained in \a region.
+    A false return value does not guarantee the opposite.
+*/
+#if defined(Q_WS_QWS) || defined(Q_WS_QPA)
+Q_GUI_EXPORT
+#endif
+bool qt_region_strictContains(const QRegion &region, const QRect &rect)
+{
+    if (isEmptyHelper(region.d->qt_rgn) || !rect.isValid())
+        return false;
+
+#if 0 // TEST_INNERRECT
+    static bool guard = false;
+    if (guard)
+        return false;
+    guard = true;
+    QRegion inner = region.d->qt_rgn->innerRect;
+    Q_ASSERT((inner - region).isEmpty());
+    guard = false;
+
+    int maxArea = 0;
+    for (int i = 0; i < region.d->qt_rgn->numRects; ++i) {
+        const QRect r = region.d->qt_rgn->rects.at(i);
+        if (r.width() * r.height() > maxArea)
+            maxArea = r.width() * r.height();
+    }
+
+    if (maxArea > region.d->qt_rgn->innerArea) {
+        qDebug() << "not largest rectangle" << region << region.d->qt_rgn->innerRect;
+    }
+    Q_ASSERT(maxArea <= region.d->qt_rgn->innerArea);
+#endif
+
+    const QRect r1 = region.d->qt_rgn->innerRect;
+    return (rect.left() >= r1.left() && rect.right() <= r1.right()
+            && rect.top() >= r1.top() && rect.bottom() <= r1.bottom());
+}
+
+QVector<QRect> QRegion::rects() const
+{
+    if (d->qt_rgn) {
+        d->qt_rgn->vectorize();
+        // hw: modify the vector size directly to avoid reallocation
+        d->qt_rgn->rects.d->size = d->qt_rgn->numRects;
+        return d->qt_rgn->rects;
+    } else {
+        return QVector<QRect>();
+    }
+}
+
+void QRegion::setRects(const QRect *rects, int num)
+{
+    *this = QRegion();
+    if (!rects || num == 0 || (num == 1 && rects->isEmpty()))
+        return;
+
+    detach();
+
+    d->qt_rgn->numRects = num;
+    if (num == 1) {
+        d->qt_rgn->extents = *rects;
+        d->qt_rgn->innerRect = *rects;
+    } else {
+        d->qt_rgn->rects.resize(num);
+
+        int left = INT_MAX,
+            right = INT_MIN,
+            top = INT_MAX,
+            bottom = INT_MIN;
+        for (int i = 0; i < num; ++i) {
+            const QRect &rect = rects[i];
+            d->qt_rgn->rects[i] = rect;
+            left = qMin(rect.left(), left);
+            right = qMax(rect.right(), right);
+            top = qMin(rect.top(), top);
+            bottom = qMax(rect.bottom(), bottom);
+            d->qt_rgn->updateInnerRect(rect);
+        }
+        d->qt_rgn->extents = QRect(QPoint(left, top), QPoint(right, bottom));
+    }
+}
+
+int QRegion::numRects() const
+{
+    return (d->qt_rgn ? d->qt_rgn->numRects : 0);
+}
+
+int QRegion::rectCount() const
+{
+    return (d->qt_rgn ? d->qt_rgn->numRects : 0);
+}
+
+
+bool QRegion::operator==(const QRegion &r) const
+{
+    if (!d->qt_rgn)
+        return r.isEmpty();
+    if (!r.d->qt_rgn)
+        return isEmpty();
+
+    if (d == r.d)
+        return true;
+    else
+        return EqualRegion(d->qt_rgn, r.d->qt_rgn);
+}
+
+bool QRegion::intersects(const QRect &rect) const
+{
+    if (isEmptyHelper(d->qt_rgn) || rect.isNull())
+        return false;
+
+    const QRect r = rect.normalized();
+    if (!rect_intersects(d->qt_rgn->extents, r))
+        return false;
+    if (d->qt_rgn->numRects == 1)
+        return true;
+
+    const QVector<QRect> myRects = rects();
+    for (QVector<QRect>::const_iterator it = myRects.constBegin(); it < myRects.constEnd(); ++it)
+        if (rect_intersects(r, *it))
+            return true;
+    return false;
+}
+
+
+#endif
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qregion.h b/src/gui/painting/qregion.h
new file mode 100644
index 0000000000..1cd38d41b8
--- /dev/null
+++ b/src/gui/painting/qregion.h
@@ -0,0 +1,239 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QREGION_H
+#define QREGION_H
+
+#include <QtCore/qatomic.h>
+#include <QtCore/qrect.h>
+#include <QtGui/qwindowdefs.h>
+
+#ifndef QT_NO_DATASTREAM
+#include <QtCore/qdatastream.h>
+#endif
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+template <class T> class QVector;
+class QVariant;
+
+#if defined(Q_WS_QWS) || defined(Q_WS_QPA) || defined(Q_WS_X11) || defined(Q_WS_MAC) || defined(Q_WS_WIN) || defined(Q_OS_SYMBIAN)
+struct QRegionPrivate;
+#endif
+
+class QBitmap;
+
+class Q_GUI_EXPORT QRegion
+{
+public:
+    enum RegionType { Rectangle, Ellipse };
+
+    QRegion();
+    QRegion(int x, int y, int w, int h, RegionType t = Rectangle);
+    QRegion(const QRect &r, RegionType t = Rectangle);
+    QRegion(const QPolygon &pa, Qt::FillRule fillRule = Qt::OddEvenFill);
+#ifdef QT3_SUPPORT
+    QT3_SUPPORT_CONSTRUCTOR QRegion(const QPolygon &pa, bool winding);
+#endif
+    QRegion(const QRegion &region);
+    QRegion(const QBitmap &bitmap);
+    ~QRegion();
+    QRegion &operator=(const QRegion &);
+#ifdef Q_COMPILER_RVALUE_REFS
+    inline QRegion &operator=(QRegion &&other)
+    { qSwap(d, other.d); return *this; }
+#endif
+    inline void swap(QRegion &other) { qSwap(d, other.d); }
+#ifdef QT3_SUPPORT
+    inline QT3_SUPPORT bool isNull() const { return isEmpty(); }
+#endif
+    bool isEmpty() const;
+
+    bool contains(const QPoint &p) const;
+    bool contains(const QRect &r) const;
+
+    void translate(int dx, int dy);
+    inline void translate(const QPoint &p) { translate(p.x(), p.y()); }
+    QRegion translated(int dx, int dy) const;
+    inline QRegion translated(const QPoint &p) const { return translated(p.x(), p.y()); }
+
+    // ### Qt 5: make these four functions QT4_SUPPORT
+    QRegion unite(const QRegion &r) const;
+    QRegion unite(const QRect &r) const;
+    QRegion intersect(const QRegion &r) const;
+    QRegion intersect(const QRect &r) const;
+    QRegion subtract(const QRegion &r) const;
+    QRegion eor(const QRegion &r) const;
+
+    inline QRegion united(const QRegion &r) const { return unite(r); }
+    inline QRegion united(const QRect &r) const { return unite(r); }
+    inline QRegion intersected(const QRegion &r) const { return intersect(r); }
+    inline QRegion intersected(const QRect &r) const { return intersect(r); }
+    inline QRegion subtracted(const QRegion &r) const { return subtract(r); }
+    inline QRegion xored(const QRegion &r) const { return eor(r); }
+
+    bool intersects(const QRegion &r) const;
+    bool intersects(const QRect &r) const;
+
+    QRect boundingRect() const;
+    QVector<QRect> rects() const;
+    void setRects(const QRect *rect, int num);
+#ifdef QT_DEPRECATED
+    QT_DEPRECATED int numRects() const;
+#endif
+    int rectCount() const;
+
+    const QRegion operator|(const QRegion &r) const;
+    const QRegion operator+(const QRegion &r) const;
+    const QRegion operator+(const QRect &r) const;
+    const QRegion operator&(const QRegion &r) const;
+    const QRegion operator&(const QRect &r) const;
+    const QRegion operator-(const QRegion &r) const;
+    const QRegion operator^(const QRegion &r) const;
+    QRegion& operator|=(const QRegion &r);
+    QRegion& operator+=(const QRegion &r);
+    QRegion& operator+=(const QRect &r);
+    QRegion& operator&=(const QRegion &r);
+    QRegion& operator&=(const QRect &r);
+    QRegion& operator-=(const QRegion &r);
+    QRegion& operator^=(const QRegion &r);
+
+    bool operator==(const QRegion &r) const;
+    inline bool operator!=(const QRegion &r) const { return !(operator==(r)); }
+    operator QVariant() const;
+
+#ifdef qdoc
+    Handle handle() const;
+#endif
+#ifndef qdoc
+#if defined(Q_WS_WIN)
+    inline HRGN    handle() const { ensureHandle(); return d->rgn; }
+#elif defined(Q_WS_X11)
+    inline Region handle() const { if(!d->rgn) updateX11Region(); return d->rgn; }
+#elif defined(Q_WS_MAC)
+#if defined Q_WS_MAC32
+    RgnHandle toQDRgn() const;
+    RgnHandle toQDRgnForUpdate_sys() const;
+    static QRegion fromQDRgn(RgnHandle shape);
+#endif
+#ifdef QT_MAC_USE_COCOA
+    inline HIMutableShapeRef handle(bool unused = false) const
+    { Q_UNUSED(unused); return toHIMutableShape(); }
+#else
+    inline RgnHandle handle() const { return handle(false); }
+    inline RgnHandle handle(bool) const { return toQDRgn(); }
+#endif
+    HIMutableShapeRef toHIMutableShape() const;
+    static QRegion fromHIShapeRef(HIShapeRef shape);
+#elif defined(Q_WS_QWS) || defined(Q_WS_QPA)
+    inline void *handle() const { return d->qt_rgn; }
+#endif
+#endif
+
+#ifndef QT_NO_DATASTREAM
+    friend Q_GUI_EXPORT QDataStream &operator<<(QDataStream &, const QRegion &);
+    friend Q_GUI_EXPORT QDataStream &operator>>(QDataStream &, QRegion &);
+#endif
+private:
+    QRegion copy() const;   // helper of detach.
+    void detach();
+#if defined(Q_WS_WIN)
+    void ensureHandle() const;
+    QRegion winCombine(const QRegion &r, int num) const;
+#elif defined(Q_WS_X11)
+    void updateX11Region() const;
+    void *clipRectangles(int &num) const;
+    friend void *qt_getClipRects(const QRegion &r, int &num);
+#elif defined(Q_WS_MAC)
+    static OSStatus shape2QRegionHelper(int inMessage, HIShapeRef inShape,
+                                        const CGRect *inRect, void *inRefcon);
+#endif
+    friend bool qt_region_strictContains(const QRegion &region,
+                                         const QRect &rect);
+    friend struct QRegionPrivate;
+
+#ifndef QT_NO_DATASTREAM
+    void exec(const QByteArray &ba, int ver = 0, QDataStream::ByteOrder byteOrder = QDataStream::BigEndian);
+#endif
+    struct QRegionData {
+        QBasicAtomicInt ref;
+#if defined(Q_WS_WIN)
+        HRGN   rgn;
+#elif defined(Q_WS_X11)
+        Region rgn;
+        void *xrectangles;
+#elif defined(Q_WS_MAC) && !defined(QT_MAC_USE_COCOA)
+        mutable RgnHandle unused; // Here for binary compatibility reasons. ### Qt 5 remove.
+#endif
+#if defined(Q_WS_QWS) || defined(Q_WS_QPA) || defined(Q_WS_X11) || defined(Q_WS_MAC) || defined(Q_WS_WIN) || defined(Q_OS_SYMBIAN)
+        QRegionPrivate *qt_rgn;
+#endif
+    };
+#if defined(Q_WS_WIN)
+    friend class QETWidget;
+#endif
+    struct QRegionData *d;
+    static struct QRegionData shared_empty;
+    static void cleanUp(QRegionData *x);
+};
+
+/*****************************************************************************
+  QRegion stream functions
+ *****************************************************************************/
+
+#ifndef QT_NO_DATASTREAM
+Q_GUI_EXPORT QDataStream &operator<<(QDataStream &, const QRegion &);
+Q_GUI_EXPORT QDataStream &operator>>(QDataStream &, QRegion &);
+#endif
+
+#ifndef QT_NO_DEBUG_STREAM
+Q_GUI_EXPORT QDebug operator<<(QDebug, const QRegion &);
+#endif
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QREGION_H
diff --git a/src/gui/painting/qregion_mac.cpp b/src/gui/painting/qregion_mac.cpp
new file mode 100644
index 0000000000..50fd783df4
--- /dev/null
+++ b/src/gui/painting/qregion_mac.cpp
@@ -0,0 +1,286 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <private/qt_mac_p.h>
+#include "qcoreapplication.h"
+#include <qlibrary.h>
+
+QT_BEGIN_NAMESPACE
+
+QRegion::QRegionData QRegion::shared_empty = { Q_BASIC_ATOMIC_INITIALIZER(1), 0 };
+
+#if defined(Q_WS_MAC32) && !defined(QT_MAC_USE_COCOA)
+#define RGN_CACHE_SIZE 200
+#ifdef RGN_CACHE_SIZE
+static bool rgncache_init = false;
+static int rgncache_used;
+static RgnHandle rgncache[RGN_CACHE_SIZE];
+static void qt_mac_cleanup_rgncache()
+{
+    rgncache_init = false;
+    for(int i = 0; i < RGN_CACHE_SIZE; ++i) {
+        if(rgncache[i]) {
+            --rgncache_used;
+            DisposeRgn(rgncache[i]);
+            rgncache[i] = 0;
+        }
+    }
+}
+#endif
+
+Q_GUI_EXPORT RgnHandle qt_mac_get_rgn()
+{
+#ifdef RGN_CACHE_SIZE
+    if(!rgncache_init) {
+        rgncache_used = 0;
+        rgncache_init = true;
+        for(int i = 0; i < RGN_CACHE_SIZE; ++i)
+            rgncache[i] = 0;
+        qAddPostRoutine(qt_mac_cleanup_rgncache);
+    } else if(rgncache_used) {
+        for(int i = 0; i < RGN_CACHE_SIZE; ++i) {
+            if(rgncache[i]) {
+                RgnHandle ret = rgncache[i];
+                SetEmptyRgn(ret);
+                rgncache[i] = 0;
+                --rgncache_used;
+                return ret;
+            }
+        }
+    }
+#endif
+    return NewRgn();
+}
+
+Q_GUI_EXPORT void qt_mac_dispose_rgn(RgnHandle r)
+{
+#ifdef RGN_CACHE_SIZE
+    if(rgncache_init && rgncache_used < RGN_CACHE_SIZE) {
+        for(int i = 0; i < RGN_CACHE_SIZE; ++i) {
+            if(!rgncache[i]) {
+                ++rgncache_used;
+                rgncache[i] = r;
+                return;
+            }
+        }
+    }
+#endif
+    DisposeRgn(r);
+}
+
+static OSStatus qt_mac_get_rgn_rect(UInt16 msg, RgnHandle, const Rect *rect, void *reg)
+{
+    if(msg == kQDRegionToRectsMsgParse) {
+        QRect rct(rect->left, rect->top, (rect->right - rect->left), (rect->bottom - rect->top));
+        if(!rct.isEmpty())
+            *((QRegion *)reg) += rct;
+    }
+    return noErr;
+}
+
+Q_GUI_EXPORT QRegion qt_mac_convert_mac_region(RgnHandle rgn)
+{
+    return QRegion::fromQDRgn(rgn);
+}
+
+QRegion QRegion::fromQDRgn(RgnHandle rgn)
+{
+    QRegion ret;
+    ret.detach();
+    OSStatus oss = QDRegionToRects(rgn, kQDParseRegionFromTopLeft, qt_mac_get_rgn_rect, (void *)&ret);
+    if(oss != noErr)
+        return QRegion();
+    return ret;
+}
+
+/*!
+    \internal
+     Create's a RegionHandle, it's the caller's responsibility to release.
+*/
+RgnHandle QRegion::toQDRgn() const
+{
+    RgnHandle rgnHandle = qt_mac_get_rgn();
+    if(d->qt_rgn && d->qt_rgn->numRects) {
+        RgnHandle tmp_rgn = qt_mac_get_rgn();
+        int n = d->qt_rgn->numRects;
+        const QRect *qt_r = (n == 1) ? &d->qt_rgn->extents : d->qt_rgn->rects.constData();
+        while (n--) {
+            SetRectRgn(tmp_rgn,
+                       qMax(SHRT_MIN, qt_r->x()),
+                       qMax(SHRT_MIN, qt_r->y()),
+                       qMin(SHRT_MAX, qt_r->right() + 1),
+                       qMin(SHRT_MAX, qt_r->bottom() + 1));
+            UnionRgn(rgnHandle, tmp_rgn, rgnHandle);
+            ++qt_r;
+        }
+        qt_mac_dispose_rgn(tmp_rgn);
+    }
+    return rgnHandle;
+}
+
+/*!
+    \internal
+     Create's a RegionHandle, it's the caller's responsibility to release.
+     Returns 0 if the QRegion overflows.
+*/
+RgnHandle QRegion::toQDRgnForUpdate_sys() const
+{
+    RgnHandle rgnHandle = qt_mac_get_rgn();
+    if(d->qt_rgn && d->qt_rgn->numRects) {
+        RgnHandle tmp_rgn = qt_mac_get_rgn();
+        int n = d->qt_rgn->numRects;
+        const QRect *qt_r = (n == 1) ? &d->qt_rgn->extents : d->qt_rgn->rects.constData();
+        while (n--) {
+
+            // detect overflow. Tested for use with HIViewSetNeedsDisplayInRegion
+            // in QWidgetPrivate::update_sys().
+            enum { HIViewSetNeedsDisplayInRegionOverflow = 10000 }; // empirically determined conservative value
+            if (qt_r->right() > HIViewSetNeedsDisplayInRegionOverflow || qt_r->bottom() > HIViewSetNeedsDisplayInRegionOverflow) {
+                qt_mac_dispose_rgn(tmp_rgn);
+                qt_mac_dispose_rgn(rgnHandle);
+                return 0;
+            }
+
+            SetRectRgn(tmp_rgn,
+                       qMax(SHRT_MIN, qt_r->x()),
+                       qMax(SHRT_MIN, qt_r->y()),
+                       qMin(SHRT_MAX, qt_r->right() + 1),
+                       qMin(SHRT_MAX, qt_r->bottom() + 1));
+            UnionRgn(rgnHandle, tmp_rgn, rgnHandle);
+            ++qt_r;
+        }
+        qt_mac_dispose_rgn(tmp_rgn);
+    }
+    return rgnHandle;
+}
+
+#endif
+
+#if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5)
+OSStatus QRegion::shape2QRegionHelper(int inMessage, HIShapeRef,
+                                      const CGRect *inRect, void *inRefcon)
+{
+    QRegion *region = static_cast<QRegion *>(inRefcon);
+    if (!region)
+        return paramErr;
+
+    switch (inMessage) {
+    case kHIShapeEnumerateRect:
+        *region += QRect(inRect->origin.x, inRect->origin.y,
+                         inRect->size.width, inRect->size.height);
+        break;
+    case kHIShapeEnumerateInit:
+        // Assume the region is already setup correctly
+    case kHIShapeEnumerateTerminate:
+    default:
+        break;
+    }
+    return noErr;
+}
+#endif
+
+/*!
+    \internal
+     Create's a mutable shape, it's the caller's responsibility to release.
+     WARNING: this function clamps the coordinates to SHRT_MIN/MAX on 10.4 and below.
+*/
+HIMutableShapeRef QRegion::toHIMutableShape() const
+{
+    HIMutableShapeRef shape = HIShapeCreateMutable();
+#if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5)
+    if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_5) {
+        if (d->qt_rgn && d->qt_rgn->numRects) {
+            int n = d->qt_rgn->numRects;
+            const QRect *qt_r = (n == 1) ? &d->qt_rgn->extents : d->qt_rgn->rects.constData();
+            while (n--) {
+                CGRect cgRect = CGRectMake(qt_r->x(), qt_r->y(), qt_r->width(), qt_r->height());
+                HIShapeUnionWithRect(shape, &cgRect);
+                ++qt_r;
+            }
+        }
+    } else
+#endif
+    {
+#ifndef QT_MAC_USE_COCOA
+        QCFType<HIShapeRef> qdShape = HIShapeCreateWithQDRgn(QMacSmartQuickDrawRegion(toQDRgn()));
+        HIShapeUnion(qdShape, shape, shape);
+#endif
+    }
+    return shape;
+}
+
+#if !defined(Q_WS_MAC64) && !defined(QT_MAC_USE_COCOA)
+typedef OSStatus (*PtrHIShapeGetAsQDRgn)(HIShapeRef, RgnHandle);
+static PtrHIShapeGetAsQDRgn ptrHIShapeGetAsQDRgn = 0;
+#endif
+
+
+QRegion QRegion::fromHIShapeRef(HIShapeRef shape)
+{
+    QRegion returnRegion;
+    returnRegion.detach();
+    // Begin gratuitous #if-defery
+#if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5)
+# ifndef Q_WS_MAC64
+    if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_5) {
+# endif
+        HIShapeEnumerate(shape, kHIShapeParseFromTopLeft, shape2QRegionHelper, &returnRegion);
+# ifndef Q_WS_MAC64
+    } else
+# endif
+#endif
+    {
+#if !defined(Q_WS_MAC64) && !defined(QT_MAC_USE_COCOA)
+        if (ptrHIShapeGetAsQDRgn == 0) {
+            QLibrary library(QLatin1String("/System/Library/Frameworks/Carbon.framework/Carbon"));
+            library.setLoadHints(QLibrary::ExportExternalSymbolsHint);
+                    ptrHIShapeGetAsQDRgn = reinterpret_cast<PtrHIShapeGetAsQDRgn>(library.resolve("HIShapeGetAsQDRgn"));
+        }
+        RgnHandle rgn = qt_mac_get_rgn();
+        ptrHIShapeGetAsQDRgn(shape, rgn);
+        returnRegion = QRegion::fromQDRgn(rgn);
+        qt_mac_dispose_rgn(rgn);
+#endif
+    }
+    return returnRegion;
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qregion_qws.cpp b/src/gui/painting/qregion_qws.cpp
new file mode 100644
index 0000000000..dca46d3ec0
--- /dev/null
+++ b/src/gui/painting/qregion_qws.cpp
@@ -0,0 +1,3183 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+// XXX - add appropriate friendship relationships
+#define private public
+#include "qregion.h"
+#undef private
+#include "qpainterpath.h"
+#include "qpolygon.h"
+#include "qbuffer.h"
+#include "qimage.h"
+#include <qdebug.h>
+#include "qbitmap.h"
+#include <stdlib.h>
+#include <qatomic.h>
+#include <qsemaphore.h>
+
+QT_BEGIN_NAMESPACE
+
+class QFastMutex
+{
+    QAtomicInt contenders;
+    QSemaphore semaphore;
+public:
+    inline QFastMutex()
+        : contenders(0), semaphore(0)
+    { }
+    inline void lock()
+    {
+        if (contenders.fetchAndAddAcquire(1) != 0) {
+            semaphore.acquire();
+            contenders.deref();
+        }
+    }
+    inline bool tryLock()
+    {
+        return contenders.testAndSetAcquire(0, 1);
+    }
+    inline void unlock()
+    {
+        if (!contenders.testAndSetRelease(1, 0))
+            semaphore.release();
+    }
+};
+
+
+/*
+ *  1 if r1 contains r2
+ *  0 if r1 does not completely contain r2
+ */ 
+#define CONTAINSCHECK(r1, r2) \
+    ((r2).left() >= (r1).left() && (r2).right() <= (r1).right() && \
+     (r2).top() >= (r1).top() && (r2).bottom() <= (r1).bottom())
+
+/*
+ *   clip region
+ */
+struct QRegionPrivate : public QRegion::QRegionData {
+    enum { Single, Vector } mode;
+    int numRects;
+    QVector<QRect> rects;
+    QRect single;
+    QRect extents;
+    QRect innerRect;
+    union {
+        int innerArea;
+        QRegionPrivate *next;
+    };
+
+    inline void vector()
+    {
+        if(mode != Vector && numRects) {
+            if(rects.size() < 1) rects.resize(1);
+            rects[0] = single;
+        }
+        mode = Vector;
+    }
+
+    inline QRegionPrivate() : mode(Single), numRects(0), innerArea(-1) {}
+    inline QRegionPrivate(const QRect &r) : mode(Single) {
+        numRects = 1;
+//        rects[0] = r;
+        single = r;
+        extents = r;
+        innerRect = r;
+        innerArea = r.width() * r.height();
+    }
+
+    inline QRegionPrivate(const QRegionPrivate &r) {
+        mode = r.mode;
+        rects = r.rects;
+        single = r.single;
+        numRects = r.numRects;
+        extents = r.extents;
+        innerRect = r.innerRect;
+        innerArea = r.innerArea;
+    }
+
+    inline QRegionPrivate &operator=(const QRegionPrivate &r) {
+        mode = r.mode;
+        rects = r.rects;
+        single = r.single;
+        numRects = r.numRects;
+        extents = r.extents;
+        innerRect = r.innerRect;
+        innerArea = r.innerArea;
+        return *this;
+    }
+
+    /*
+     * Returns true if r is guaranteed to be fully contained in this region.
+     * A false return value does not guarantee the opposite.
+     */
+    inline bool contains(const QRegionPrivate &r) const {
+        const QRect &r1 = innerRect;
+        const QRect &r2 = r.extents;
+        return CONTAINSCHECK(r1, r2);
+    }
+
+    inline void updateInnerRect(const QRect &rect) {
+        const int area = rect.width() * rect.height();
+        if (area > innerArea) {
+            innerArea = area;
+            innerRect = rect;
+        }
+    }
+
+    void append(const QRegionPrivate *r);
+    void prepend(const QRegionPrivate *r);
+    inline bool canAppend(const QRegionPrivate *r) const;
+    inline bool canPrepend(const QRegionPrivate *r) const;
+};
+
+static QRegionPrivate *qt_nextRegionPtr = 0;
+static QFastMutex qt_nextRegionLock;
+
+static QRegionPrivate *qt_allocRegionMemory()
+{
+    QRegionPrivate *rv = 0;
+    qt_nextRegionLock.lock();
+
+    if(qt_nextRegionPtr) {
+        rv = qt_nextRegionPtr;
+        qt_nextRegionPtr = rv->next;
+    } else {
+        qt_nextRegionPtr = 
+            (QRegionPrivate *)malloc(256 * sizeof(QRegionPrivate));
+        for(int ii = 0; ii < 256; ++ii) {
+            if(ii == 255) {
+                qt_nextRegionPtr[ii].next = 0;
+            } else {
+                qt_nextRegionPtr[ii].next = &qt_nextRegionPtr[ii + 1];
+            }
+        }
+
+        rv = qt_nextRegionPtr;
+        qt_nextRegionPtr = rv->next;
+    }
+
+    qt_nextRegionLock.unlock();
+    return rv;
+}
+
+static void qt_freeRegionMemory(QRegionPrivate *rp)
+{
+    qt_nextRegionLock.lock();
+    rp->next = qt_nextRegionPtr;
+    qt_nextRegionPtr = rp;
+    qt_nextRegionLock.unlock();
+}
+
+static QRegionPrivate *qt_allocRegion()
+{
+    QRegionPrivate *mem = qt_allocRegionMemory();
+    return new (mem) QRegionPrivate;
+}
+
+static QRegionPrivate *qt_allocRegion(const QRect &r)
+{
+    QRegionPrivate *mem = qt_allocRegionMemory();
+    return new (mem) QRegionPrivate(r);
+}
+
+static QRegionPrivate *qt_allocRegion(const QRegionPrivate &r)
+{
+    QRegionPrivate *mem = qt_allocRegionMemory();
+    return new (mem) QRegionPrivate(r);
+}
+
+void qt_freeRegion(QRegionPrivate *rp)
+{
+    rp->~QRegionPrivate();
+    qt_freeRegionMemory(rp);
+//    delete rp;
+}
+
+static inline bool isEmptyHelper(const QRegionPrivate *preg)
+{
+    return !preg || preg->numRects == 0;
+}
+
+void QRegionPrivate::append(const QRegionPrivate *r)
+{
+    Q_ASSERT(!isEmptyHelper(r));
+
+    vector();
+    QRect *destRect = rects.data() + numRects;
+    const QRect *srcRect = (r->mode==Vector)?r->rects.constData():&r->single;
+    int numAppend = r->numRects;
+
+    // test for merge in x direction
+    {
+        const QRect *rFirst = srcRect;
+        QRect *myLast = rects.data() + (numRects - 1);
+        if (rFirst->top() == myLast->top()
+            && rFirst->height() == myLast->height()
+            && rFirst->left() == (myLast->right() + 1))
+        {
+            myLast->setWidth(myLast->width() + rFirst->width());
+            updateInnerRect(*myLast);
+            ++srcRect;
+            --numAppend;
+        }
+    }
+
+    // append rectangles
+    const int newNumRects = numRects + numAppend;
+    if (newNumRects > rects.size()) {
+        rects.resize(newNumRects);
+        destRect = rects.data() + numRects;
+    }
+    memcpy(destRect, srcRect, numAppend * sizeof(QRect));
+
+    // update inner rectangle
+    if (innerArea < r->innerArea) {
+        innerArea = r->innerArea;
+        innerRect = r->innerRect;
+    }
+
+    // update extents
+    destRect = &extents;
+    srcRect = &r->extents;
+    extents.setCoords(qMin(destRect->left(), srcRect->left()),
+                      qMin(destRect->top(), srcRect->top()),
+                      qMax(destRect->right(), srcRect->right()),
+                      qMax(destRect->bottom(), srcRect->bottom()));
+
+    numRects = newNumRects;
+}
+
+void QRegionPrivate::prepend(const QRegionPrivate *r)
+{
+#if 1
+    Q_UNUSED(r);
+#else
+    // XXX ak: does not respect vectorization of region
+
+    Q_ASSERT(!isEmpty(r));
+
+    // move existing rectangles
+    memmove(rects.data() + r->numRects, rects.constData(),
+            numRects * sizeof(QRect));
+
+    // prepend new rectangles
+    memcpy(rects.data(), r->rects.constData(), r->numRects * sizeof(QRect));
+
+    // update inner rectangle
+    if (innerArea < r->innerArea) {
+        innerArea = r->innerArea;
+        innerRect = r->innerRect;
+    }
+
+    // update extents
+    destRect = &extents;
+    srcRect = &r->extents;
+    extents.setCoords(qMin(destRect->left(), srcRect->left()),
+                      qMin(destRect->top(), srcRect->top()),
+                      qMax(destRect->right(), srcRect->right()),
+                      qMax(destRect->bottom(), srcRect->bottom()));
+
+    numRects = newNumRects;
+#endif
+}
+
+bool QRegionPrivate::canAppend(const QRegionPrivate *r) const
+{
+    Q_ASSERT(!isEmptyHelper(r));
+
+    const QRect *rFirst = (r->mode==Vector)?r->rects.constData():&r->single;
+    const QRect *myLast = (mode==Vector)?(rects.constData() + (numRects - 1)):&single;
+    // XXX: possible improvements:
+    //   - nFirst->top() == myLast->bottom() + 1, must possibly merge bands
+    if (rFirst->top() > (myLast->bottom() + 1)
+        || (rFirst->top() == myLast->top()
+            && rFirst->height() == myLast->height()
+            && rFirst->left() > myLast->right()))
+    {
+        return true;
+    }
+
+    return false;
+}
+
+bool QRegionPrivate::canPrepend(const QRegionPrivate *r) const
+{
+#if 1
+    Q_UNUSED(r);
+    return false;
+#else
+    return r->canAppend(this);
+#endif
+}
+
+#if defined(Q_WS_X11)
+QT_BEGIN_INCLUDE_NAMESPACE
+# include "qregion_x11.cpp"
+QT_END_INCLUDE_NAMESPACE
+#elif defined(Q_WS_MAC)
+QT_BEGIN_INCLUDE_NAMESPACE
+# include "qregion_mac.cpp"
+QT_END_INCLUDE_NAMESPACE
+#elif defined(Q_WS_QWS)
+static QRegionPrivate qrp;
+QRegion::QRegionData QRegion::shared_empty = {Q_BASIC_ATOMIC_INITIALIZER(1), &qrp};
+#endif
+
+typedef void (*OverlapFunc)(register QRegionPrivate &dest, register const QRect *r1, const QRect *r1End,
+                            register const QRect *r2, const QRect *r2End, register int y1, register int y2);
+typedef void (*NonOverlapFunc)(register QRegionPrivate &dest, register const QRect *r, const QRect *rEnd,
+                               register int y1, register int y2);
+
+static bool EqualRegion(const QRegionPrivate *r1, const QRegionPrivate *r2);
+static void UnionRegion(const QRegionPrivate *reg1, const QRegionPrivate *reg2, QRegionPrivate &dest);
+static void miRegionOp(register QRegionPrivate &dest, const QRegionPrivate *reg1, const QRegionPrivate *reg2,
+                       OverlapFunc overlapFunc, NonOverlapFunc nonOverlap1Func,
+                       NonOverlapFunc nonOverlap2Func);
+
+#define RectangleOut 0
+#define RectangleIn 1
+#define RectanglePart 2
+#define EvenOddRule 0
+#define WindingRule 1
+
+// START OF region.h extract
+/* $XConsortium: region.h,v 11.14 94/04/17 20:22:20 rws Exp $ */
+/************************************************************************
+
+Copyright (c) 1987  X Consortium
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of the X Consortium shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from the X Consortium.
+
+
+Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+************************************************************************/
+
+#ifndef _XREGION_H
+#define _XREGION_H
+
+QT_BEGIN_INCLUDE_NAMESPACE
+#include <limits.h>
+QT_END_INCLUDE_NAMESPACE
+
+/*  1 if two BOXs overlap.
+ *  0 if two BOXs do not overlap.
+ *  Remember, x2 and y2 are not in the region
+ */
+#define EXTENTCHECK(r1, r2) \
+        ((r1)->right() >= (r2)->left() && \
+         (r1)->left() <= (r2)->right() && \
+         (r1)->bottom() >= (r2)->top() && \
+         (r1)->top() <= (r2)->bottom())
+
+/*
+ *  update region extents
+ */
+#define EXTENTS(r,idRect){\
+            if((r)->left() < (idRect)->extents.left())\
+              (idRect)->extents.setLeft((r)->left());\
+            if((r)->top() < (idRect)->extents.top())\
+              (idRect)->extents.setTop((r)->top());\
+            if((r)->right() > (idRect)->extents.right())\
+              (idRect)->extents.setRight((r)->right());\
+            if((r)->bottom() > (idRect)->extents.bottom())\
+              (idRect)->extents.setBottom((r)->bottom());\
+        }
+
+/*
+ *   Check to see if there is enough memory in the present region.
+ */
+#define MEMCHECK(dest, rect, firstrect){\
+        if ((dest).numRects >= ((dest).rects.size()-1)){\
+          firstrect.resize(firstrect.size() * 2); \
+          (rect) = (firstrect).data() + (dest).numRects;\
+        }\
+      }
+
+
+/*
+ * number of points to buffer before sending them off
+ * to scanlines(): Must be an even number
+ */
+#define NUMPTSTOBUFFER 200
+
+/*
+ * used to allocate buffers for points and link
+ * the buffers together
+ */
+typedef struct _POINTBLOCK {
+    QPoint pts[NUMPTSTOBUFFER];
+    struct _POINTBLOCK *next;
+} POINTBLOCK;
+
+#endif
+// END OF region.h extract
+
+// START OF Region.c extract
+/* $XConsortium: Region.c /main/30 1996/10/22 14:21:24 kaleb $ */
+/************************************************************************
+
+Copyright (c) 1987, 1988  X Consortium
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of the X Consortium shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from the X Consortium.
+
+
+Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+************************************************************************/
+/*
+ * The functions in this file implement the Region abstraction, similar to one
+ * used in the X11 sample server. A Region is simply an area, as the name
+ * implies, and is implemented as a "y-x-banded" array of rectangles. To
+ * explain: Each Region is made up of a certain number of rectangles sorted
+ * by y coordinate first, and then by x coordinate.
+ *
+ * Furthermore, the rectangles are banded such that every rectangle with a
+ * given upper-left y coordinate (y1) will have the same lower-right y
+ * coordinate (y2) and vice versa. If a rectangle has scanlines in a band, it
+ * will span the entire vertical distance of the band. This means that some
+ * areas that could be merged into a taller rectangle will be represented as
+ * several shorter rectangles to account for shorter rectangles to its left
+ * or right but within its "vertical scope".
+ *
+ * An added constraint on the rectangles is that they must cover as much
+ * horizontal area as possible. E.g. no two rectangles in a band are allowed
+ * to touch.
+ *
+ * Whenever possible, bands will be merged together to cover a greater vertical
+ * distance (and thus reduce the number of rectangles). Two bands can be merged
+ * only if the bottom of one touches the top of the other and they have
+ * rectangles in the same places (of the same width, of course). This maintains
+ * the y-x-banding that's so nice to have...
+ */
+/* $XFree86: xc/lib/X11/Region.c,v 1.1.1.2.2.2 1998/10/04 15:22:50 hohndel Exp $ */
+
+static void UnionRectWithRegion(register const QRect *rect, const QRegionPrivate *source,
+                                QRegionPrivate &dest)
+{
+    if (!rect->width() || !rect->height())
+        return;
+
+    QRegionPrivate region(*rect);
+
+    Q_ASSERT(EqualRegion(source, &dest));
+    Q_ASSERT(!isEmptyHelper(&region));
+
+    if (dest.numRects == 0)
+        dest = region;
+    else if (dest.canAppend(&region))
+        dest.append(&region);
+    else
+        UnionRegion(&region, source, dest);
+}
+
+/*-
+ *-----------------------------------------------------------------------
+ * miSetExtents --
+ *      Reset the extents and innerRect of a region to what they should be.
+ *      Called by miSubtract and miIntersect b/c they can't figure it out
+ *      along the way or do so easily, as miUnion can.
+ *
+ * Results:
+ *      None.
+ *
+ * Side Effects:
+ *      The region's 'extents' and 'innerRect' structure is overwritten.
+ *
+ *-----------------------------------------------------------------------
+ */
+static void miSetExtents(QRegionPrivate &dest)
+{
+    register const QRect *pBox,
+                         *pBoxEnd;
+    register QRect *pExtents;
+
+    dest.innerRect.setCoords(0, 0, -1, -1);
+    dest.innerArea = -1;
+    if (dest.numRects == 0) {
+        dest.extents.setCoords(0, 0, 0, 0);
+        return;
+    }
+
+    pExtents = &dest.extents;
+    pBox = (dest.mode==QRegionPrivate::Vector)?(dest.rects.constData()):(&dest.single);
+    pBoxEnd = (dest.mode==QRegionPrivate::Vector)?(&pBox[dest.numRects - 1]):(&dest.single);
+
+    /*
+     * Since pBox is the first rectangle in the region, it must have the
+     * smallest y1 and since pBoxEnd is the last rectangle in the region,
+     * it must have the largest y2, because of banding. Initialize x1 and
+     * x2 from  pBox and pBoxEnd, resp., as good things to initialize them
+     * to...
+     */
+    pExtents->setLeft(pBox->left());
+    pExtents->setTop(pBox->top());
+    pExtents->setRight(pBoxEnd->right());
+    pExtents->setBottom(pBoxEnd->bottom());
+
+    Q_ASSERT(pExtents->top() <= pExtents->bottom());
+    while (pBox <= pBoxEnd) {
+        if (pBox->left() < pExtents->left())
+            pExtents->setLeft(pBox->left());
+        if (pBox->right() > pExtents->right())
+            pExtents->setRight(pBox->right());
+        dest.updateInnerRect(*pBox);
+        ++pBox;
+    }
+    Q_ASSERT(pExtents->left() <= pExtents->right());
+}
+
+/* TranslateRegion(pRegion, x, y)
+   translates in place
+   added by raymond
+*/
+
+static void OffsetRegion(register QRegionPrivate &region, register int x, register int y)
+{
+    register int nbox;
+    register QRect *pbox;
+
+    if(region.mode == QRegionPrivate::Single) {
+        region.single.translate(x, y);
+    } else {
+        pbox = region.rects.data();
+        nbox = region.numRects;
+
+        while (nbox--) {
+            pbox->translate(x, y);
+            ++pbox;
+        }
+    } 
+    region.extents.translate(x, y);
+    region.innerRect.translate(x, y);
+}
+
+/*======================================================================
+ *          Region Intersection
+ *====================================================================*/
+/*-
+ *-----------------------------------------------------------------------
+ * miIntersectO --
+ *      Handle an overlapping band for miIntersect.
+ *
+ * Results:
+ *      None.
+ *
+ * Side Effects:
+ *      Rectangles may be added to the region.
+ *
+ *-----------------------------------------------------------------------
+ */
+static void miIntersectO(register QRegionPrivate &dest, register const QRect *r1, const QRect *r1End,
+                         register const QRect *r2, const QRect *r2End, int y1, int y2)
+{
+    register int x1;
+    register int x2;
+    register QRect *pNextRect;
+
+    pNextRect = dest.rects.data() + dest.numRects;
+
+    while (r1 != r1End && r2 != r2End) {
+        x1 = qMax(r1->left(), r2->left());
+        x2 = qMin(r1->right(), r2->right());
+
+        /*
+         * If there's any overlap between the two rectangles, add that
+         * overlap to the new region.
+         * There's no need to check for subsumption because the only way
+         * such a need could arise is if some region has two rectangles
+         * right next to each other. Since that should never happen...
+         */
+        if (x1 <= x2) {
+            Q_ASSERT(y1 <= y2);
+            MEMCHECK(dest, pNextRect, dest.rects)
+            pNextRect->setCoords(x1, y1, x2, y2);
+            ++dest.numRects;
+            ++pNextRect;
+        }
+
+        /*
+         * Need to advance the pointers. Shift the one that extends
+         * to the right the least, since the other still has a chance to
+         * overlap with that region's next rectangle, if you see what I mean.
+         */
+        if (r1->right() < r2->right()) {
+            ++r1;
+        } else if (r2->right() < r1->right()) {
+            ++r2;
+        } else {
+            ++r1;
+            ++r2;
+        }
+    }
+}
+
+/*======================================================================
+ *          Generic Region Operator
+ *====================================================================*/
+
+/*-
+ *-----------------------------------------------------------------------
+ * miCoalesce --
+ *      Attempt to merge the boxes in the current band with those in the
+ *      previous one. Used only by miRegionOp.
+ *
+ * Results:
+ *      The new index for the previous band.
+ *
+ * Side Effects:
+ *      If coalescing takes place:
+ *          - rectangles in the previous band will have their y2 fields
+ *            altered.
+ *          - dest.numRects will be decreased.
+ *
+ *-----------------------------------------------------------------------
+ */
+static int miCoalesce(register QRegionPrivate &dest, int prevStart, int curStart)
+{
+    register QRect *pPrevBox;   /* Current box in previous band */
+    register QRect *pCurBox;    /* Current box in current band */
+    register QRect *pRegEnd;    /* End of region */
+    int curNumRects;    /* Number of rectangles in current band */
+    int prevNumRects;   /* Number of rectangles in previous band */
+    int bandY1;         /* Y1 coordinate for current band */
+    QRect *rData = dest.rects.data();
+
+    pRegEnd = rData + dest.numRects;
+
+    pPrevBox = rData + prevStart;
+    prevNumRects = curStart - prevStart;
+
+    /*
+     * Figure out how many rectangles are in the current band. Have to do
+     * this because multiple bands could have been added in miRegionOp
+     * at the end when one region has been exhausted.
+     */
+    pCurBox = rData + curStart;
+    bandY1 = pCurBox->top();
+    for (curNumRects = 0; pCurBox != pRegEnd && pCurBox->top() == bandY1; ++curNumRects) {
+        ++pCurBox;
+    }
+
+    if (pCurBox != pRegEnd) {
+        /*
+         * If more than one band was added, we have to find the start
+         * of the last band added so the next coalescing job can start
+         * at the right place... (given when multiple bands are added,
+         * this may be pointless -- see above).
+         */
+        --pRegEnd;
+        while ((pRegEnd - 1)->top() == pRegEnd->top())
+            --pRegEnd;
+        curStart = pRegEnd - rData;
+        pRegEnd = rData + dest.numRects;
+    }
+
+    if (curNumRects == prevNumRects && curNumRects != 0) {
+        pCurBox -= curNumRects;
+        /*
+         * The bands may only be coalesced if the bottom of the previous
+         * matches the top scanline of the current.
+         */
+        if (pPrevBox->bottom() == pCurBox->top() - 1) {
+            /*
+             * Make sure the bands have boxes in the same places. This
+             * assumes that boxes have been added in such a way that they
+             * cover the most area possible. I.e. two boxes in a band must
+             * have some horizontal space between them.
+             */
+            do {
+                if (pPrevBox->left() != pCurBox->left() || pPrevBox->right() != pCurBox->right()) {
+                     // The bands don't line up so they can't be coalesced.
+                    return curStart;
+                }
+                ++pPrevBox;
+                ++pCurBox;
+                --prevNumRects;
+            } while (prevNumRects != 0);
+
+            dest.numRects -= curNumRects;
+            pCurBox -= curNumRects;
+            pPrevBox -= curNumRects;
+
+            /*
+             * The bands may be merged, so set the bottom y of each box
+             * in the previous band to that of the corresponding box in
+             * the current band.
+             */
+            do {
+                pPrevBox->setBottom(pCurBox->bottom());
+                dest.updateInnerRect(*pPrevBox);
+                ++pPrevBox;
+                ++pCurBox;
+                curNumRects -= 1;
+            } while (curNumRects != 0);
+
+            /*
+             * If only one band was added to the region, we have to backup
+             * curStart to the start of the previous band.
+             *
+             * If more than one band was added to the region, copy the
+             * other bands down. The assumption here is that the other bands
+             * came from the same region as the current one and no further
+             * coalescing can be done on them since it's all been done
+             * already... curStart is already in the right place.
+             */
+            if (pCurBox == pRegEnd) {
+                curStart = prevStart;
+            } else {
+                do {
+                    *pPrevBox++ = *pCurBox++;
+                    dest.updateInnerRect(*pPrevBox);
+                } while (pCurBox != pRegEnd);
+            }
+        }
+    }
+    return curStart;
+}
+
+/*-
+ *-----------------------------------------------------------------------
+ * miRegionOp --
+ *      Apply an operation to two regions. Called by miUnion, miInverse,
+ *      miSubtract, miIntersect...
+ *
+ * Results:
+ *      None.
+ *
+ * Side Effects:
+ *      The new region is overwritten.
+ *
+ * Notes:
+ *      The idea behind this function is to view the two regions as sets.
+ *      Together they cover a rectangle of area that this function divides
+ *      into horizontal bands where points are covered only by one region
+ *      or by both. For the first case, the nonOverlapFunc is called with
+ *      each the band and the band's upper and lower extents. For the
+ *      second, the overlapFunc is called to process the entire band. It
+ *      is responsible for clipping the rectangles in the band, though
+ *      this function provides the boundaries.
+ *      At the end of each band, the new region is coalesced, if possible,
+ *      to reduce the number of rectangles in the region.
+ *
+ *-----------------------------------------------------------------------
+ */
+static void miRegionOp(register QRegionPrivate &dest, const QRegionPrivate *reg1, const QRegionPrivate *reg2,
+                       OverlapFunc overlapFunc, NonOverlapFunc nonOverlap1Func,
+                       NonOverlapFunc nonOverlap2Func)
+{
+    register const QRect *r1;         // Pointer into first region
+    register const QRect *r2;         // Pointer into 2d region
+    const QRect *r1End;               // End of 1st region
+    const QRect *r2End;               // End of 2d region
+    register int ybot;          // Bottom of intersection
+    register int ytop;          // Top of intersection
+    int prevBand;               // Index of start of previous band in dest
+    int curBand;                // Index of start of current band in dest
+    register const QRect *r1BandEnd;  // End of current band in r1
+    register const QRect *r2BandEnd;  // End of current band in r2
+    int top;                    // Top of non-overlapping band
+    int bot;                    // Bottom of non-overlapping band
+
+    /*
+     * Initialization:
+     *  set r1, r2, r1End and r2End appropriately, preserve the important
+     * parts of the destination region until the end in case it's one of
+     * the two source regions, then mark the "new" region empty, allocating
+     * another array of rectangles for it to use.
+     */
+    r1 = (reg1->mode==QRegionPrivate::Vector)?reg1->rects.data():&reg1->single;
+    r2 = (reg2->mode==QRegionPrivate::Vector)?reg2->rects.data():&reg2->single;
+    r1End = r1 + reg1->numRects;
+    r2End = r2 + reg2->numRects;
+
+    dest.vector();
+    QVector<QRect> oldRects = dest.rects;
+
+    dest.numRects = 0;
+
+    /*
+     * Allocate a reasonable number of rectangles for the new region. The idea
+     * is to allocate enough so the individual functions don't need to
+     * reallocate and copy the array, which is time consuming, yet we don't
+     * have to worry about using too much memory. I hope to be able to
+     * nuke the realloc() at the end of this function eventually.
+     */
+    dest.rects.resize(qMax(reg1->numRects,reg2->numRects) * 2);
+
+    /*
+     * Initialize ybot and ytop.
+     * In the upcoming loop, ybot and ytop serve different functions depending
+     * on whether the band being handled is an overlapping or non-overlapping
+     * band.
+     *  In the case of a non-overlapping band (only one of the regions
+     * has points in the band), ybot is the bottom of the most recent
+     * intersection and thus clips the top of the rectangles in that band.
+     * ytop is the top of the next intersection between the two regions and
+     * serves to clip the bottom of the rectangles in the current band.
+     *  For an overlapping band (where the two regions intersect), ytop clips
+     * the top of the rectangles of both regions and ybot clips the bottoms.
+     */
+    if (reg1->extents.top() < reg2->extents.top())
+        ybot = reg1->extents.top() - 1;
+    else
+        ybot = reg2->extents.top() - 1;
+
+    /*
+     * prevBand serves to mark the start of the previous band so rectangles
+     * can be coalesced into larger rectangles. qv. miCoalesce, above.
+     * In the beginning, there is no previous band, so prevBand == curBand
+     * (curBand is set later on, of course, but the first band will always
+     * start at index 0). prevBand and curBand must be indices because of
+     * the possible expansion, and resultant moving, of the new region's
+     * array of rectangles.
+     */
+    prevBand = 0;
+
+    do {
+        curBand = dest.numRects;
+
+        /*
+         * This algorithm proceeds one source-band (as opposed to a
+         * destination band, which is determined by where the two regions
+         * intersect) at a time. r1BandEnd and r2BandEnd serve to mark the
+         * rectangle after the last one in the current band for their
+         * respective regions.
+         */
+        r1BandEnd = r1;
+        while (r1BandEnd != r1End && r1BandEnd->top() == r1->top())
+            ++r1BandEnd;
+
+        r2BandEnd = r2;
+        while (r2BandEnd != r2End && r2BandEnd->top() == r2->top())
+            ++r2BandEnd;
+
+        /*
+         * First handle the band that doesn't intersect, if any.
+         *
+         * Note that attention is restricted to one band in the
+         * non-intersecting region at once, so if a region has n
+         * bands between the current position and the next place it overlaps
+         * the other, this entire loop will be passed through n times.
+         */
+        if (r1->top() < r2->top()) {
+            top = qMax(r1->top(), ybot + 1);
+            bot = qMin(r1->bottom(), r2->top() - 1);
+
+            if (nonOverlap1Func != 0 && bot >= top)
+                (*nonOverlap1Func)(dest, r1, r1BandEnd, top, bot);
+            ytop = r2->top();
+        } else if (r2->top() < r1->top()) {
+            top = qMax(r2->top(), ybot + 1);
+            bot = qMin(r2->bottom(), r1->top() - 1);
+
+            if (nonOverlap2Func != 0 && bot >= top)
+                (*nonOverlap2Func)(dest, r2, r2BandEnd, top, bot);
+            ytop = r1->top();
+        } else {
+            ytop = r1->top();
+        }
+
+        /*
+         * If any rectangles got added to the region, try and coalesce them
+         * with rectangles from the previous band. Note we could just do
+         * this test in miCoalesce, but some machines incur a not
+         * inconsiderable cost for function calls, so...
+         */
+        if (dest.numRects != curBand)
+            prevBand = miCoalesce(dest, prevBand, curBand);
+
+        /*
+         * Now see if we've hit an intersecting band. The two bands only
+         * intersect if ybot >= ytop
+         */
+        ybot = qMin(r1->bottom(), r2->bottom());
+        curBand = dest.numRects;
+        if (ybot >= ytop)
+            (*overlapFunc)(dest, r1, r1BandEnd, r2, r2BandEnd, ytop, ybot);
+
+        if (dest.numRects != curBand)
+            prevBand = miCoalesce(dest, prevBand, curBand);
+
+        /*
+         * If we've finished with a band (y2 == ybot) we skip forward
+         * in the region to the next band.
+         */
+        if (r1->bottom() == ybot)
+            r1 = r1BandEnd;
+        if (r2->bottom() == ybot)
+            r2 = r2BandEnd;
+    } while (r1 != r1End && r2 != r2End);
+
+    /*
+     * Deal with whichever region still has rectangles left.
+     */
+    curBand = dest.numRects;
+    if (r1 != r1End) {
+        if (nonOverlap1Func != 0) {
+            do {
+                r1BandEnd = r1;
+                while (r1BandEnd < r1End && r1BandEnd->top() == r1->top())
+                    ++r1BandEnd;
+                (*nonOverlap1Func)(dest, r1, r1BandEnd, qMax(r1->top(), ybot + 1), r1->bottom());
+                r1 = r1BandEnd;
+            } while (r1 != r1End);
+        }
+    } else if ((r2 != r2End) && (nonOverlap2Func != 0)) {
+        do {
+            r2BandEnd = r2;
+            while (r2BandEnd < r2End && r2BandEnd->top() == r2->top())
+                 ++r2BandEnd;
+            (*nonOverlap2Func)(dest, r2, r2BandEnd, qMax(r2->top(), ybot + 1), r2->bottom());
+            r2 = r2BandEnd;
+        } while (r2 != r2End);
+    }
+
+    if (dest.numRects != curBand)
+        (void)miCoalesce(dest, prevBand, curBand);
+
+    /*
+     * A bit of cleanup. To keep regions from growing without bound,
+     * we shrink the array of rectangles to match the new number of
+     * rectangles in the region.
+     *
+     * Only do this stuff if the number of rectangles allocated is more than
+     * twice the number of rectangles in the region (a simple optimization).
+     */
+    if (qMax(4, dest.numRects) < (dest.rects.size() >> 1))
+        dest.rects.resize(dest.numRects);
+}
+
+/*======================================================================
+ *          Region Union
+ *====================================================================*/
+
+/*-
+ *-----------------------------------------------------------------------
+ * miUnionNonO --
+ *      Handle a non-overlapping band for the union operation. Just
+ *      Adds the rectangles into the region. Doesn't have to check for
+ *      subsumption or anything.
+ *
+ * Results:
+ *      None.
+ *
+ * Side Effects:
+ *      dest.numRects is incremented and the final rectangles overwritten
+ *      with the rectangles we're passed.
+ *
+ *-----------------------------------------------------------------------
+ */
+
+static void miUnionNonO(register QRegionPrivate &dest, register const QRect *r, const QRect *rEnd,
+                        register int y1, register int y2)
+{
+    register QRect *pNextRect;
+
+    pNextRect = dest.rects.data() + dest.numRects;
+
+    Q_ASSERT(y1 <= y2);
+
+    while (r != rEnd) {
+        Q_ASSERT(r->left() <= r->right());
+        MEMCHECK(dest, pNextRect, dest.rects)
+        pNextRect->setCoords(r->left(), y1, r->right(), y2);
+        dest.numRects++;
+        ++pNextRect;
+        ++r;
+    }
+}
+
+
+/*-
+ *-----------------------------------------------------------------------
+ * miUnionO --
+ *      Handle an overlapping band for the union operation. Picks the
+ *      left-most rectangle each time and merges it into the region.
+ *
+ * Results:
+ *      None.
+ *
+ * Side Effects:
+ *      Rectangles are overwritten in dest.rects and dest.numRects will
+ *      be changed.
+ *
+ *-----------------------------------------------------------------------
+ */
+
+static void miUnionO(register QRegionPrivate &dest, register const QRect *r1, const QRect *r1End,
+                     register const QRect *r2, const QRect *r2End, register int y1, register int y2)
+{
+    register QRect *pNextRect;
+
+    pNextRect = dest.rects.data() + dest.numRects;
+
+#define MERGERECT(r)             \
+    if ((dest.numRects != 0) &&  \
+        (pNextRect[-1].top() == y1) &&  \
+        (pNextRect[-1].bottom() == y2) &&  \
+        (pNextRect[-1].right() >= r->left()-1)) { \
+        if (pNextRect[-1].right() < r->right()) { \
+            pNextRect[-1].setRight(r->right());  \
+            dest.updateInnerRect(pNextRect[-1]); \
+            Q_ASSERT(pNextRect[-1].left() <= pNextRect[-1].right()); \
+        }  \
+    } else { \
+        MEMCHECK(dest, pNextRect, dest.rects)  \
+        pNextRect->setCoords(r->left(), y1, r->right(), y2); \
+        dest.updateInnerRect(*pNextRect); \
+        dest.numRects++;  \
+        pNextRect++;  \
+    }  \
+    r++;
+
+    Q_ASSERT(y1 <= y2);
+    while (r1 != r1End && r2 != r2End) {
+        if (r1->left() < r2->left()) {
+            MERGERECT(r1)
+        } else {
+            MERGERECT(r2)
+        }
+    }
+
+    if (r1 != r1End) {
+        do {
+            MERGERECT(r1)
+        } while (r1 != r1End);
+    } else {
+        while (r2 != r2End) {
+            MERGERECT(r2)
+        }
+    }
+}
+
+static void UnionRegion(const QRegionPrivate *reg1, const QRegionPrivate *reg2, QRegionPrivate &dest)
+{
+    Q_ASSERT(!isEmptyHelper(reg1) && !isEmptyHelper(reg2));
+    Q_ASSERT(!reg1->contains(*reg2));
+    Q_ASSERT(!reg2->contains(*reg1));
+    Q_ASSERT(!EqualRegion(reg1, reg2));
+    Q_ASSERT(!reg1->canAppend(reg2));
+    Q_ASSERT(!reg2->canAppend(reg1));
+
+    if (reg1->innerArea > reg2->innerArea) {
+        dest.innerArea = reg1->innerArea;
+        dest.innerRect = reg1->innerRect;
+    } else {
+        dest.innerArea = reg2->innerArea;
+        dest.innerRect = reg2->innerRect;
+    }
+    miRegionOp(dest, reg1, reg2, miUnionO, miUnionNonO, miUnionNonO);
+
+    dest.extents.setCoords(qMin(reg1->extents.left(), reg2->extents.left()),
+                           qMin(reg1->extents.top(), reg2->extents.top()),
+                           qMax(reg1->extents.right(), reg2->extents.right()),
+                           qMax(reg1->extents.bottom(), reg2->extents.bottom()));
+}
+
+/*======================================================================
+ *        Region Subtraction
+ *====================================================================*/
+
+/*-
+ *-----------------------------------------------------------------------
+ * miSubtractNonO --
+ *      Deal with non-overlapping band for subtraction. Any parts from
+ *      region 2 we discard. Anything from region 1 we add to the region.
+ *
+ * Results:
+ *      None.
+ *
+ * Side Effects:
+ *      dest may be affected.
+ *
+ *-----------------------------------------------------------------------
+ */
+
+static void miSubtractNonO1(register QRegionPrivate &dest, register const QRect *r,
+                            const QRect *rEnd, register int y1, register int y2)
+{
+    register QRect *pNextRect;
+
+    pNextRect = dest.rects.data() + dest.numRects;
+
+    Q_ASSERT(y1<=y2);
+
+    while (r != rEnd) {
+        Q_ASSERT(r->left() <= r->right());
+        MEMCHECK(dest, pNextRect, dest.rects)
+        pNextRect->setCoords(r->left(), y1, r->right(), y2);
+        ++dest.numRects;
+        ++pNextRect;
+        ++r;
+    }
+}
+
+/*-
+ *-----------------------------------------------------------------------
+ * miSubtractO --
+ *      Overlapping band subtraction. x1 is the left-most point not yet
+ *      checked.
+ *
+ * Results:
+ *      None.
+ *
+ * Side Effects:
+ *      dest may have rectangles added to it.
+ *
+ *-----------------------------------------------------------------------
+ */
+
+static void miSubtractO(register QRegionPrivate &dest, register const QRect *r1, const QRect *r1End,
+                        register const QRect *r2, const QRect *r2End, register int y1, register int y2)
+{
+    register QRect *pNextRect;
+    register int x1;
+
+    x1 = r1->left();
+
+    Q_ASSERT(y1 <= y2);
+    pNextRect = dest.rects.data() + dest.numRects;
+
+    while (r1 != r1End && r2 != r2End) {
+        if (r2->right() < x1) {
+            /*
+             * Subtrahend missed the boat: go to next subtrahend.
+             */
+            ++r2;
+        } else if (r2->left() <= x1) {
+            /*
+             * Subtrahend precedes minuend: nuke left edge of minuend.
+             */
+            x1 = r2->right() + 1;
+            if (x1 > r1->right()) {
+                /*
+                 * Minuend completely covered: advance to next minuend and
+                 * reset left fence to edge of new minuend.
+                 */
+                ++r1;
+                if (r1 != r1End)
+                    x1 = r1->left();
+            } else {
+                // Subtrahend now used up since it doesn't extend beyond minuend
+                ++r2;
+            }
+        } else if (r2->left() <= r1->right()) {
+            /*
+             * Left part of subtrahend covers part of minuend: add uncovered
+             * part of minuend to region and skip to next subtrahend.
+             */
+            Q_ASSERT(x1 < r2->left());
+            MEMCHECK(dest, pNextRect, dest.rects)
+            pNextRect->setCoords(x1, y1, r2->left() - 1, y2);
+            ++dest.numRects;
+            ++pNextRect;
+
+            x1 = r2->right() + 1;
+            if (x1 > r1->right()) {
+                /*
+                 * Minuend used up: advance to new...
+                 */
+                ++r1;
+                if (r1 != r1End)
+                    x1 = r1->left();
+            } else {
+                // Subtrahend used up
+                ++r2;
+            }
+        } else {
+            /*
+             * Minuend used up: add any remaining piece before advancing.
+             */
+            if (r1->right() >= x1) {
+                MEMCHECK(dest, pNextRect, dest.rects)
+                pNextRect->setCoords(x1, y1, r1->right(), y2);
+                ++dest.numRects;
+                ++pNextRect;
+            }
+            ++r1;
+            if (r1 != r1End)
+                x1 = r1->left();
+        }
+    }
+
+    /*
+     * Add remaining minuend rectangles to region.
+     */
+    while (r1 != r1End) {
+        Q_ASSERT(x1 <= r1->right());
+        MEMCHECK(dest, pNextRect, dest.rects)
+        pNextRect->setCoords(x1, y1, r1->right(), y2);
+        ++dest.numRects;
+        ++pNextRect;
+
+        ++r1;
+        if (r1 != r1End)
+            x1 = r1->left();
+    }
+}
+
+/*-
+ *-----------------------------------------------------------------------
+ * miSubtract --
+ *      Subtract regS from regM and leave the result in regD.
+ *      S stands for subtrahend, M for minuend and D for difference.
+ *
+ * Side Effects:
+ *      regD is overwritten.
+ *
+ *-----------------------------------------------------------------------
+ */
+
+static void SubtractRegion(QRegionPrivate *regM, QRegionPrivate *regS,
+                           register QRegionPrivate &dest)
+{
+    Q_ASSERT(!isEmptyHelper(regM));
+    Q_ASSERT(!isEmptyHelper(regS));
+    Q_ASSERT(EXTENTCHECK(&regM->extents, &regS->extents));
+    Q_ASSERT(!regS->contains(*regM));
+    Q_ASSERT(!EqualRegion(regM, regS));
+
+    miRegionOp(dest, regM, regS, miSubtractO, miSubtractNonO1, 0);
+
+    /*
+     * Can't alter dest's extents before we call miRegionOp because
+     * it might be one of the source regions and miRegionOp depends
+     * on the extents of those regions being the unaltered. Besides, this
+     * way there's no checking against rectangles that will be nuked
+     * due to coalescing, so we have to examine fewer rectangles.
+     */
+    miSetExtents(dest);
+}
+
+static void XorRegion(QRegionPrivate *sra, QRegionPrivate *srb, QRegionPrivate &dest)
+{
+    Q_ASSERT(!isEmptyHelper(sra) && !isEmptyHelper(srb));
+    Q_ASSERT(EXTENTCHECK(&sra->extents, &srb->extents));
+    Q_ASSERT(!EqualRegion(sra, srb));
+
+    QRegionPrivate tra, trb;
+
+    if (!srb->contains(*sra))
+        SubtractRegion(sra, srb, tra);
+    if (!sra->contains(*srb))
+        SubtractRegion(srb, sra, trb);
+
+    Q_ASSERT(isEmptyHelper(&trb) || !tra.contains(trb));
+    Q_ASSERT(isEmptyHelper(&tra) || !trb.contains(tra));
+
+    if (isEmptyHelper(&tra)) {
+        dest = trb;
+    } else if (isEmptyHelper(&trb)) {
+        dest = tra;
+    } else if (tra.canAppend(&trb)) {
+        dest = tra;
+        dest.append(&trb);
+    } else if (trb.canAppend(&tra)) {
+        dest = trb;
+        dest.append(&tra);
+    } else {
+        UnionRegion(&tra, &trb, dest);
+    }
+}
+
+/*
+ *      Check to see if two regions are equal
+ */
+static bool EqualRegion(const QRegionPrivate *r1, const QRegionPrivate *r2)
+{
+    if (r1->numRects != r2->numRects) {
+        return false;
+    } else if (r1->numRects == 0) {
+        return true;
+    } else if (r1->extents != r2->extents) {
+        return false;
+    } else if (r1->mode == QRegionPrivate::Single && r2->mode == QRegionPrivate::Single) {
+        return r1->single == r2->single;
+    } else {
+        const QRect *rr1 = (r1->mode==QRegionPrivate::Vector)?r1->rects.constData():&r1->single;
+        const QRect *rr2 = (r2->mode==QRegionPrivate::Vector)?r2->rects.constData():&r2->single;
+        for (int i = 0; i < r1->numRects; ++i, ++rr1, ++rr2) {
+            if (*rr1 != *rr2)
+                return false;
+        }
+    }
+
+    return true;
+}
+
+static bool PointInRegion(QRegionPrivate *pRegion, int x, int y)
+{
+    int i;
+
+    if (pRegion->mode == QRegionPrivate::Single)
+        return pRegion->single.contains(x, y);
+    if (isEmptyHelper(pRegion))
+        return false;
+    if (!pRegion->extents.contains(x, y))
+        return false;
+    if (pRegion->innerRect.contains(x, y))
+        return true;
+    for (i = 0; i < pRegion->numRects; ++i) {
+        if (pRegion->rects[i].contains(x, y))
+            return true;
+    }
+    return false;
+}
+
+static bool RectInRegion(register QRegionPrivate *region, int rx, int ry, uint rwidth, uint rheight)
+{
+    register const QRect *pbox;
+    register const QRect *pboxEnd;
+    QRect rect(rx, ry, rwidth, rheight);
+    register QRect *prect = &rect;
+    int partIn, partOut;
+
+    if (!region || region->numRects == 0 || !EXTENTCHECK(&region->extents, prect))
+        return RectangleOut;
+
+    partOut = false;
+    partIn = false;
+
+    /* can stop when both partOut and partIn are true, or we reach prect->y2 */
+    for (pbox = (region->mode==QRegionPrivate::Vector)?region->rects.constData():&region->single, pboxEnd = pbox + region->numRects;
+         pbox < pboxEnd; ++pbox) {
+        if (pbox->bottom() < ry)
+           continue;
+
+        if (pbox->top() > ry) {
+           partOut = true;
+           if (partIn || pbox->top() > prect->bottom())
+              break;
+           ry = pbox->top();
+        }
+
+        if (pbox->right() < rx)
+           continue;            /* not far enough over yet */
+
+        if (pbox->left() > rx) {
+           partOut = true;      /* missed part of rectangle to left */
+           if (partIn)
+              break;
+        }
+
+        if (pbox->left() <= prect->right()) {
+            partIn = true;      /* definitely overlap */
+            if (partOut)
+               break;
+        }
+
+        if (pbox->right() >= prect->right()) {
+           ry = pbox->bottom() + 1;     /* finished with this band */
+           if (ry > prect->bottom())
+              break;
+           rx = prect->left();  /* reset x out to left again */
+        } else {
+            /*
+             * Because boxes in a band are maximal width, if the first box
+             * to overlap the rectangle doesn't completely cover it in that
+             * band, the rectangle must be partially out, since some of it
+             * will be uncovered in that band. partIn will have been set true
+             * by now...
+             */
+            break;
+        }
+    }
+    return partIn ? ((ry <= prect->bottom()) ? RectanglePart : RectangleIn) : RectangleOut;
+}
+// END OF Region.c extract
+// START OF poly.h extract
+/* $XConsortium: poly.h,v 1.4 94/04/17 20:22:19 rws Exp $ */
+/************************************************************************
+
+Copyright (c) 1987  X Consortium
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of the X Consortium shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from the X Consortium.
+
+
+Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+************************************************************************/
+
+/*
+ *     This file contains a few macros to help track
+ *     the edge of a filled object.  The object is assumed
+ *     to be filled in scanline order, and thus the
+ *     algorithm used is an extension of Bresenham's line
+ *     drawing algorithm which assumes that y is always the
+ *     major axis.
+ *     Since these pieces of code are the same for any filled shape,
+ *     it is more convenient to gather the library in one
+ *     place, but since these pieces of code are also in
+ *     the inner loops of output primitives, procedure call
+ *     overhead is out of the question.
+ *     See the author for a derivation if needed.
+ */
+
+
+/*
+ *  In scan converting polygons, we want to choose those pixels
+ *  which are inside the polygon.  Thus, we add .5 to the starting
+ *  x coordinate for both left and right edges.  Now we choose the
+ *  first pixel which is inside the pgon for the left edge and the
+ *  first pixel which is outside the pgon for the right edge.
+ *  Draw the left pixel, but not the right.
+ *
+ *  How to add .5 to the starting x coordinate:
+ *      If the edge is moving to the right, then subtract dy from the
+ *  error term from the general form of the algorithm.
+ *      If the edge is moving to the left, then add dy to the error term.
+ *
+ *  The reason for the difference between edges moving to the left
+ *  and edges moving to the right is simple:  If an edge is moving
+ *  to the right, then we want the algorithm to flip immediately.
+ *  If it is moving to the left, then we don't want it to flip until
+ *  we traverse an entire pixel.
+ */
+#define BRESINITPGON(dy, x1, x2, xStart, d, m, m1, incr1, incr2) { \
+    int dx;      /* local storage */ \
+\
+    /* \
+     *  if the edge is horizontal, then it is ignored \
+     *  and assumed not to be processed.  Otherwise, do this stuff. \
+     */ \
+    if ((dy) != 0) { \
+        xStart = (x1); \
+        dx = (x2) - xStart; \
+        if (dx < 0) { \
+            m = dx / (dy); \
+            m1 = m - 1; \
+            incr1 = -2 * dx + 2 * (dy) * m1; \
+            incr2 = -2 * dx + 2 * (dy) * m; \
+            d = 2 * m * (dy) - 2 * dx - 2 * (dy); \
+        } else { \
+            m = dx / (dy); \
+            m1 = m + 1; \
+            incr1 = 2 * dx - 2 * (dy) * m1; \
+            incr2 = 2 * dx - 2 * (dy) * m; \
+            d = -2 * m * (dy) + 2 * dx; \
+        } \
+    } \
+}
+
+#define BRESINCRPGON(d, minval, m, m1, incr1, incr2) { \
+    if (m1 > 0) { \
+        if (d > 0) { \
+            minval += m1; \
+            d += incr1; \
+        } \
+        else { \
+            minval += m; \
+            d += incr2; \
+        } \
+    } else {\
+        if (d >= 0) { \
+            minval += m1; \
+            d += incr1; \
+        } \
+        else { \
+            minval += m; \
+            d += incr2; \
+        } \
+    } \
+}
+
+
+/*
+ *     This structure contains all of the information needed
+ *     to run the bresenham algorithm.
+ *     The variables may be hardcoded into the declarations
+ *     instead of using this structure to make use of
+ *     register declarations.
+ */
+typedef struct {
+    int minor_axis;     /* minor axis        */
+    int d;              /* decision variable */
+    int m, m1;          /* slope and slope+1 */
+    int incr1, incr2;   /* error increments */
+} BRESINFO;
+
+
+#define BRESINITPGONSTRUCT(dmaj, min1, min2, bres) \
+        BRESINITPGON(dmaj, min1, min2, bres.minor_axis, bres.d, \
+                     bres.m, bres.m1, bres.incr1, bres.incr2)
+
+#define BRESINCRPGONSTRUCT(bres) \
+        BRESINCRPGON(bres.d, bres.minor_axis, bres.m, bres.m1, bres.incr1, bres.incr2)
+
+
+
+/*
+ *     These are the data structures needed to scan
+ *     convert regions.  Two different scan conversion
+ *     methods are available -- the even-odd method, and
+ *     the winding number method.
+ *     The even-odd rule states that a point is inside
+ *     the polygon if a ray drawn from that point in any
+ *     direction will pass through an odd number of
+ *     path segments.
+ *     By the winding number rule, a point is decided
+ *     to be inside the polygon if a ray drawn from that
+ *     point in any direction passes through a different
+ *     number of clockwise and counter-clockwise path
+ *     segments.
+ *
+ *     These data structures are adapted somewhat from
+ *     the algorithm in (Foley/Van Dam) for scan converting
+ *     polygons.
+ *     The basic algorithm is to start at the top (smallest y)
+ *     of the polygon, stepping down to the bottom of
+ *     the polygon by incrementing the y coordinate.  We
+ *     keep a list of edges which the current scanline crosses,
+ *     sorted by x.  This list is called the Active Edge Table (AET)
+ *     As we change the y-coordinate, we update each entry in
+ *     in the active edge table to reflect the edges new xcoord.
+ *     This list must be sorted at each scanline in case
+ *     two edges intersect.
+ *     We also keep a data structure known as the Edge Table (ET),
+ *     which keeps track of all the edges which the current
+ *     scanline has not yet reached.  The ET is basically a
+ *     list of ScanLineList structures containing a list of
+ *     edges which are entered at a given scanline.  There is one
+ *     ScanLineList per scanline at which an edge is entered.
+ *     When we enter a new edge, we move it from the ET to the AET.
+ *
+ *     From the AET, we can implement the even-odd rule as in
+ *     (Foley/Van Dam).
+ *     The winding number rule is a little trickier.  We also
+ *     keep the EdgeTableEntries in the AET linked by the
+ *     nextWETE (winding EdgeTableEntry) link.  This allows
+ *     the edges to be linked just as before for updating
+ *     purposes, but only uses the edges linked by the nextWETE
+ *     link as edges representing spans of the polygon to
+ *     drawn (as with the even-odd rule).
+ */
+
+/*
+ * for the winding number rule
+ */
+#define CLOCKWISE          1
+#define COUNTERCLOCKWISE  -1
+
+typedef struct _EdgeTableEntry {
+     int ymax;             /* ycoord at which we exit this edge. */
+     BRESINFO bres;        /* Bresenham info to run the edge     */
+     struct _EdgeTableEntry *next;       /* next in the list     */
+     struct _EdgeTableEntry *back;       /* for insertion sort   */
+     struct _EdgeTableEntry *nextWETE;   /* for winding num rule */
+     int ClockWise;        /* flag for winding number rule       */
+} EdgeTableEntry;
+
+
+typedef struct _ScanLineList{
+     int scanline;              /* the scanline represented */
+     EdgeTableEntry *edgelist;  /* header node              */
+     struct _ScanLineList *next;  /* next in the list       */
+} ScanLineList;
+
+
+typedef struct {
+     int ymax;                 /* ymax for the polygon     */
+     int ymin;                 /* ymin for the polygon     */
+     ScanLineList scanlines;   /* header node              */
+} EdgeTable;
+
+
+/*
+ * Here is a struct to help with storage allocation
+ * so we can allocate a big chunk at a time, and then take
+ * pieces from this heap when we need to.
+ */
+#define SLLSPERBLOCK 25
+
+typedef struct _ScanLineListBlock {
+     ScanLineList SLLs[SLLSPERBLOCK];
+     struct _ScanLineListBlock *next;
+} ScanLineListBlock;
+
+
+
+/*
+ *
+ *     a few macros for the inner loops of the fill code where
+ *     performance considerations don't allow a procedure call.
+ *
+ *     Evaluate the given edge at the given scanline.
+ *     If the edge has expired, then we leave it and fix up
+ *     the active edge table; otherwise, we increment the
+ *     x value to be ready for the next scanline.
+ *     The winding number rule is in effect, so we must notify
+ *     the caller when the edge has been removed so he
+ *     can reorder the Winding Active Edge Table.
+ */
+#define EVALUATEEDGEWINDING(pAET, pPrevAET, y, fixWAET) { \
+   if (pAET->ymax == y) {          /* leaving this edge */ \
+      pPrevAET->next = pAET->next; \
+      pAET = pPrevAET->next; \
+      fixWAET = 1; \
+      if (pAET) \
+         pAET->back = pPrevAET; \
+   } \
+   else { \
+      BRESINCRPGONSTRUCT(pAET->bres) \
+      pPrevAET = pAET; \
+      pAET = pAET->next; \
+   } \
+}
+
+
+/*
+ *     Evaluate the given edge at the given scanline.
+ *     If the edge has expired, then we leave it and fix up
+ *     the active edge table; otherwise, we increment the
+ *     x value to be ready for the next scanline.
+ *     The even-odd rule is in effect.
+ */
+#define EVALUATEEDGEEVENODD(pAET, pPrevAET, y) { \
+   if (pAET->ymax == y) {          /* leaving this edge */ \
+      pPrevAET->next = pAET->next; \
+      pAET = pPrevAET->next; \
+      if (pAET) \
+         pAET->back = pPrevAET; \
+   } \
+   else { \
+      BRESINCRPGONSTRUCT(pAET->bres) \
+      pPrevAET = pAET; \
+      pAET = pAET->next; \
+   } \
+}
+// END OF poly.h extract
+// START OF PolyReg.c extract
+/* $XConsortium: PolyReg.c,v 11.23 94/11/17 21:59:37 converse Exp $ */
+/************************************************************************
+
+Copyright (c) 1987  X Consortium
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of the X Consortium shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from the X Consortium.
+
+
+Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+************************************************************************/
+/* $XFree86: xc/lib/X11/PolyReg.c,v 1.1.1.2.8.2 1998/10/04 15:22:49 hohndel Exp $ */
+
+#define LARGE_COORDINATE 1000000
+#define SMALL_COORDINATE -LARGE_COORDINATE
+
+/*
+ *     InsertEdgeInET
+ *
+ *     Insert the given edge into the edge table.
+ *     First we must find the correct bucket in the
+ *     Edge table, then find the right slot in the
+ *     bucket.  Finally, we can insert it.
+ *
+ */
+static void InsertEdgeInET(EdgeTable *ET, EdgeTableEntry *ETE, int scanline,
+                           ScanLineListBlock **SLLBlock, int *iSLLBlock)
+{
+    register EdgeTableEntry *start, *prev;
+    register ScanLineList *pSLL, *pPrevSLL;
+    ScanLineListBlock *tmpSLLBlock;
+
+    /*
+     * find the right bucket to put the edge into
+     */
+    pPrevSLL = &ET->scanlines;
+    pSLL = pPrevSLL->next;
+    while (pSLL && (pSLL->scanline < scanline)) {
+        pPrevSLL = pSLL;
+        pSLL = pSLL->next;
+    }
+
+    /*
+     * reassign pSLL (pointer to ScanLineList) if necessary
+     */
+    if ((!pSLL) || (pSLL->scanline > scanline)) {
+        if (*iSLLBlock > SLLSPERBLOCK-1)
+        {
+            tmpSLLBlock =
+                  (ScanLineListBlock *)malloc(sizeof(ScanLineListBlock));
+            (*SLLBlock)->next = tmpSLLBlock;
+            tmpSLLBlock->next = (ScanLineListBlock *)NULL;
+            *SLLBlock = tmpSLLBlock;
+            *iSLLBlock = 0;
+        }
+        pSLL = &((*SLLBlock)->SLLs[(*iSLLBlock)++]);
+
+        pSLL->next = pPrevSLL->next;
+        pSLL->edgelist = (EdgeTableEntry *)NULL;
+        pPrevSLL->next = pSLL;
+    }
+    pSLL->scanline = scanline;
+
+    /*
+     * now insert the edge in the right bucket
+     */
+    prev = 0;
+    start = pSLL->edgelist;
+    while (start && (start->bres.minor_axis < ETE->bres.minor_axis)) {
+        prev = start;
+        start = start->next;
+    }
+    ETE->next = start;
+
+    if (prev)
+        prev->next = ETE;
+    else
+        pSLL->edgelist = ETE;
+}
+
+/*
+ *     CreateEdgeTable
+ *
+ *     This routine creates the edge table for
+ *     scan converting polygons.
+ *     The Edge Table (ET) looks like:
+ *
+ *    EdgeTable
+ *     --------
+ *    |  ymax  |        ScanLineLists
+ *    |scanline|-->------------>-------------->...
+ *     --------   |scanline|   |scanline|
+ *                |edgelist|   |edgelist|
+ *                ---------    ---------
+ *                    |             |
+ *                    |             |
+ *                    V             V
+ *              list of ETEs   list of ETEs
+ *
+ *     where ETE is an EdgeTableEntry data structure,
+ *     and there is one ScanLineList per scanline at
+ *     which an edge is initially entered.
+ *
+ */
+
+static void CreateETandAET(register int count, register const QPoint *pts,
+                           EdgeTable *ET, EdgeTableEntry *AET, register EdgeTableEntry *pETEs,
+                           ScanLineListBlock *pSLLBlock)
+{
+    register const QPoint *top,
+                          *bottom,
+                          *PrevPt,
+                          *CurrPt;
+    int iSLLBlock = 0;
+    int dy;
+
+    if (count < 2)
+        return;
+
+    /*
+     *  initialize the Active Edge Table
+     */
+    AET->next = 0;
+    AET->back = 0;
+    AET->nextWETE = 0;
+    AET->bres.minor_axis = SMALL_COORDINATE;
+
+    /*
+     *  initialize the Edge Table.
+     */
+    ET->scanlines.next = 0;
+    ET->ymax = SMALL_COORDINATE;
+    ET->ymin = LARGE_COORDINATE;
+    pSLLBlock->next = 0;
+
+    PrevPt = &pts[count - 1];
+
+    /*
+     *  for each vertex in the array of points.
+     *  In this loop we are dealing with two vertices at
+     *  a time -- these make up one edge of the polygon.
+     */
+    while (count--) {
+        CurrPt = pts++;
+
+        /*
+         *  find out which point is above and which is below.
+         */
+        if (PrevPt->y() > CurrPt->y()) {
+            bottom = PrevPt;
+            top = CurrPt;
+            pETEs->ClockWise = 0;
+        } else {
+            bottom = CurrPt;
+            top = PrevPt;
+            pETEs->ClockWise = 1;
+        }
+
+        /*
+         * don't add horizontal edges to the Edge table.
+         */
+        if (bottom->y() != top->y()) {
+            pETEs->ymax = bottom->y() - 1;  /* -1 so we don't get last scanline */
+
+            /*
+             *  initialize integer edge algorithm
+             */
+            dy = bottom->y() - top->y();
+            BRESINITPGONSTRUCT(dy, top->x(), bottom->x(), pETEs->bres)
+
+            InsertEdgeInET(ET, pETEs, top->y(), &pSLLBlock, &iSLLBlock);
+
+            if (PrevPt->y() > ET->ymax)
+                ET->ymax = PrevPt->y();
+            if (PrevPt->y() < ET->ymin)
+                ET->ymin = PrevPt->y();
+            ++pETEs;
+        }
+
+        PrevPt = CurrPt;
+    }
+}
+
+/*
+ *     loadAET
+ *
+ *     This routine moves EdgeTableEntries from the
+ *     EdgeTable into the Active Edge Table,
+ *     leaving them sorted by smaller x coordinate.
+ *
+ */
+
+static void loadAET(register EdgeTableEntry *AET, register EdgeTableEntry *ETEs)
+{
+    register EdgeTableEntry *pPrevAET;
+    register EdgeTableEntry *tmp;
+
+    pPrevAET = AET;
+    AET = AET->next;
+    while (ETEs) {
+        while (AET && AET->bres.minor_axis < ETEs->bres.minor_axis) {
+            pPrevAET = AET;
+            AET = AET->next;
+        }
+        tmp = ETEs->next;
+        ETEs->next = AET;
+        if (AET)
+            AET->back = ETEs;
+        ETEs->back = pPrevAET;
+        pPrevAET->next = ETEs;
+        pPrevAET = ETEs;
+
+        ETEs = tmp;
+    }
+}
+
+/*
+ *     computeWAET
+ *
+ *     This routine links the AET by the
+ *     nextWETE (winding EdgeTableEntry) link for
+ *     use by the winding number rule.  The final
+ *     Active Edge Table (AET) might look something
+ *     like:
+ *
+ *     AET
+ *     ----------  ---------   ---------
+ *     |ymax    |  |ymax    |  |ymax    |
+ *     | ...    |  |...     |  |...     |
+ *     |next    |->|next    |->|next    |->...
+ *     |nextWETE|  |nextWETE|  |nextWETE|
+ *     ---------   ---------   ^--------
+ *         |                   |       |
+ *         V------------------->       V---> ...
+ *
+ */
+static void computeWAET(register EdgeTableEntry *AET)
+{
+    register EdgeTableEntry *pWETE;
+    register int inside = 1;
+    register int isInside = 0;
+
+    AET->nextWETE = 0;
+    pWETE = AET;
+    AET = AET->next;
+    while (AET) {
+        if (AET->ClockWise)
+            ++isInside;
+        else
+            --isInside;
+
+        if (!inside && !isInside || inside && isInside) {
+            pWETE->nextWETE = AET;
+            pWETE = AET;
+            inside = !inside;
+        }
+        AET = AET->next;
+    }
+    pWETE->nextWETE = 0;
+}
+
+/*
+ *     InsertionSort
+ *
+ *     Just a simple insertion sort using
+ *     pointers and back pointers to sort the Active
+ *     Edge Table.
+ *
+ */
+
+static int InsertionSort(register EdgeTableEntry *AET)
+{
+    register EdgeTableEntry *pETEchase;
+    register EdgeTableEntry *pETEinsert;
+    register EdgeTableEntry *pETEchaseBackTMP;
+    register int changed = 0;
+
+    AET = AET->next;
+    while (AET) {
+        pETEinsert = AET;
+        pETEchase = AET;
+        while (pETEchase->back->bres.minor_axis > AET->bres.minor_axis)
+            pETEchase = pETEchase->back;
+
+        AET = AET->next;
+        if (pETEchase != pETEinsert) {
+            pETEchaseBackTMP = pETEchase->back;
+            pETEinsert->back->next = AET;
+            if (AET)
+                AET->back = pETEinsert->back;
+            pETEinsert->next = pETEchase;
+            pETEchase->back->next = pETEinsert;
+            pETEchase->back = pETEinsert;
+            pETEinsert->back = pETEchaseBackTMP;
+            changed = 1;
+        }
+    }
+    return changed;
+}
+
+/*
+ *     Clean up our act.
+ */
+static void FreeStorage(register ScanLineListBlock *pSLLBlock)
+{
+    register ScanLineListBlock *tmpSLLBlock;
+
+    while (pSLLBlock) {
+        tmpSLLBlock = pSLLBlock->next;
+        free(pSLLBlock);
+        pSLLBlock = tmpSLLBlock;
+    }
+}
+
+/*
+ *     Create an array of rectangles from a list of points.
+ *     If indeed these things (POINTS, RECTS) are the same,
+ *     then this proc is still needed, because it allocates
+ *     storage for the array, which was allocated on the
+ *     stack by the calling procedure.
+ *
+ */
+static void PtsToRegion(register int numFullPtBlocks, register int iCurPtBlock,
+                       POINTBLOCK *FirstPtBlock, QRegionPrivate *reg)
+{
+    register QRect *rects;
+    register QPoint *pts;
+    register POINTBLOCK *CurPtBlock;
+    register int i;
+    register QRect *extents;
+    register int numRects;
+
+    extents = &reg->extents;
+    numRects = ((numFullPtBlocks * NUMPTSTOBUFFER) + iCurPtBlock) >> 1;
+
+    reg->rects.resize(numRects);
+
+    CurPtBlock = FirstPtBlock;
+    rects = reg->rects.data() - 1;
+    numRects = 0;
+    extents->setLeft(INT_MAX);
+    extents->setRight(INT_MIN);
+    reg->innerArea = -1;
+
+    for (; numFullPtBlocks >= 0; --numFullPtBlocks) {
+        /* the loop uses 2 points per iteration */
+        i = NUMPTSTOBUFFER >> 1;
+        if (!numFullPtBlocks)
+            i = iCurPtBlock >> 1;
+        if(i) {
+            for (pts = CurPtBlock->pts; i--; pts += 2) {
+                if (pts->x() == pts[1].x())
+                    continue;
+                if (numRects && pts->x() == rects->left() && pts->y() == rects->bottom() + 1
+                    && pts[1].x() == rects->right()+1 && (numRects == 1 || rects[-1].top() != rects->top())
+                                                          && (i && pts[2].y() > pts[1].y())) {
+                        rects->setBottom(pts[1].y());
+                        reg->updateInnerRect(*rects);
+                        continue;
+                }
+                ++numRects;
+                ++rects;
+                rects->setCoords(pts->x(), pts->y(), pts[1].x() - 1, pts[1].y());
+                if (rects->left() < extents->left())
+                    extents->setLeft(rects->left());
+                if (rects->right() > extents->right())
+                    extents->setRight(rects->right());
+                reg->updateInnerRect(*rects);
+            }
+        }
+        CurPtBlock = CurPtBlock->next;
+    }
+
+    if (numRects) {
+        extents->setTop(reg->rects[0].top());
+        extents->setBottom(rects->bottom());
+    } else {
+        extents->setCoords(0, 0, 0, 0);
+    }
+    reg->numRects = numRects;
+}
+
+/*
+ *     polytoregion
+ *
+ *     Scan converts a polygon by returning a run-length
+ *     encoding of the resultant bitmap -- the run-length
+ *     encoding is in the form of an array of rectangles.
+ */
+static QRegionPrivate *PolygonRegion(const QPoint *Pts, int Count, int rule,
+                                     QRegionPrivate *region)
+    //Point     *Pts;                /* the pts                 */
+    //int       Count;                 /* number of pts           */
+    //int       rule;                        /* winding rule */
+{
+    register EdgeTableEntry *pAET;   /* Active Edge Table       */
+    register int y;                  /* current scanline        */
+    register int iPts = 0;           /* number of pts in buffer */
+    register EdgeTableEntry *pWETE;  /* Winding Edge Table Entry*/
+    register ScanLineList *pSLL;     /* current scanLineList    */
+    register QPoint *pts;             /* output buffer           */
+    EdgeTableEntry *pPrevAET;        /* ptr to previous AET     */
+    EdgeTable ET;                    /* header node for ET      */
+    EdgeTableEntry AET;              /* header node for AET     */
+    EdgeTableEntry *pETEs;           /* EdgeTableEntries pool   */
+    ScanLineListBlock SLLBlock;      /* header for scanlinelist */
+    int fixWAET = false;
+    POINTBLOCK FirstPtBlock, *curPtBlock; /* PtBlock buffers    */
+    POINTBLOCK *tmpPtBlock;
+    int numFullPtBlocks = 0;
+
+    region->vector();
+
+    /* special case a rectangle */
+    if (((Count == 4) ||
+         ((Count == 5) && (Pts[4].x() == Pts[0].x()) && (Pts[4].y() == Pts[0].y())))
+         && (((Pts[0].y() == Pts[1].y()) && (Pts[1].x() == Pts[2].x()) && (Pts[2].y() == Pts[3].y())
+               && (Pts[3].x() == Pts[0].x())) || ((Pts[0].x() == Pts[1].x())
+               && (Pts[1].y() == Pts[2].y()) && (Pts[2].x() == Pts[3].x())
+               && (Pts[3].y() == Pts[0].y())))) {
+        int x = qMin(Pts[0].x(), Pts[2].x());
+        region->extents.setLeft(x);
+        int y = qMin(Pts[0].y(), Pts[2].y());
+        region->extents.setTop(y);
+        region->extents.setWidth(qMax(Pts[0].x(), Pts[2].x()) - x);
+        region->extents.setHeight(qMax(Pts[0].y(), Pts[2].y()) - y);
+        if ((region->extents.left() <= region->extents.right()) &&
+            (region->extents.top() <= region->extents.bottom())) {
+            region->numRects = 1;
+            region->rects.resize(1);
+            region->rects[0] = region->extents;
+            region->innerRect = region->extents;
+            region->innerArea = region->innerRect.width() * region->innerRect.height();
+        }
+        return region;
+    }
+
+    if (!(pETEs = static_cast<EdgeTableEntry *>(malloc(sizeof(EdgeTableEntry) * Count))))
+        return 0;
+
+    pts = FirstPtBlock.pts;
+    CreateETandAET(Count, Pts, &ET, &AET, pETEs, &SLLBlock);
+    pSLL = ET.scanlines.next;
+    curPtBlock = &FirstPtBlock;
+
+    if (rule == EvenOddRule) {
+        /*
+         *  for each scanline
+         */
+        for (y = ET.ymin; y < ET.ymax; ++y) {
+            /*
+             *  Add a new edge to the active edge table when we
+             *  get to the next edge.
+             */
+            if (pSLL && y == pSLL->scanline) {
+                loadAET(&AET, pSLL->edgelist);
+                pSLL = pSLL->next;
+            }
+            pPrevAET = &AET;
+            pAET = AET.next;
+
+            /*
+             *  for each active edge
+             */
+            while (pAET) {
+                pts->setX(pAET->bres.minor_axis);
+                pts->setY(y);
+                ++pts;
+                ++iPts;
+
+                /*
+                 *  send out the buffer
+                 */
+                if (iPts == NUMPTSTOBUFFER) {
+                    tmpPtBlock = (POINTBLOCK *)malloc(sizeof(POINTBLOCK));
+                    curPtBlock->next = tmpPtBlock;
+                    curPtBlock = tmpPtBlock;
+                    pts = curPtBlock->pts;
+                    ++numFullPtBlocks;
+                    iPts = 0;
+                }
+                EVALUATEEDGEEVENODD(pAET, pPrevAET, y)
+            }
+            InsertionSort(&AET);
+        }
+    } else {
+        /*
+         *  for each scanline
+         */
+        for (y = ET.ymin; y < ET.ymax; ++y) {
+            /*
+             *  Add a new edge to the active edge table when we
+             *  get to the next edge.
+             */
+            if (pSLL && y == pSLL->scanline) {
+                loadAET(&AET, pSLL->edgelist);
+                computeWAET(&AET);
+                pSLL = pSLL->next;
+            }
+            pPrevAET = &AET;
+            pAET = AET.next;
+            pWETE = pAET;
+
+            /*
+             *  for each active edge
+             */
+            while (pAET) {
+                /*
+                 *  add to the buffer only those edges that
+                 *  are in the Winding active edge table.
+                 */
+                if (pWETE == pAET) {
+                    pts->setX(pAET->bres.minor_axis);
+                    pts->setY(y);
+                    ++pts;
+                    ++iPts;
+
+                    /*
+                     *  send out the buffer
+                     */
+                    if (iPts == NUMPTSTOBUFFER) {
+                        tmpPtBlock = static_cast<POINTBLOCK *>(malloc(sizeof(POINTBLOCK)));
+                        curPtBlock->next = tmpPtBlock;
+                        curPtBlock = tmpPtBlock;
+                        pts = curPtBlock->pts;
+                        ++numFullPtBlocks;
+                        iPts = 0;
+                    }
+                    pWETE = pWETE->nextWETE;
+                }
+                EVALUATEEDGEWINDING(pAET, pPrevAET, y, fixWAET)
+            }
+
+            /*
+             *  recompute the winding active edge table if
+             *  we just resorted or have exited an edge.
+             */
+            if (InsertionSort(&AET) || fixWAET) {
+                computeWAET(&AET);
+                fixWAET = false;
+            }
+        }
+    }
+    FreeStorage(SLLBlock.next);
+    PtsToRegion(numFullPtBlocks, iPts, &FirstPtBlock, region);
+    for (curPtBlock = FirstPtBlock.next; --numFullPtBlocks >= 0;) {
+        tmpPtBlock = curPtBlock->next;
+        free(curPtBlock);
+        curPtBlock = tmpPtBlock;
+    }
+    free(pETEs);
+    return region;
+}
+// END OF PolyReg.c extract
+
+QRegionPrivate *qt_bitmapToRegion(const QBitmap& bitmap, QRegionPrivate *region)
+{
+    region->vector();
+
+    QImage image = bitmap.toImage();
+
+    QRect xr;
+
+#define AddSpan \
+        { \
+            xr.setCoords(prev1, y, x-1, y); \
+            UnionRectWithRegion(&xr, region, *region); \
+        }
+
+    const uchar zero = 0;
+    bool little = image.format() == QImage::Format_MonoLSB;
+
+    int x,
+        y;
+    for (y = 0; y < image.height(); ++y) {
+        uchar *line = image.scanLine(y);
+        int w = image.width();
+        uchar all = zero;
+        int prev1 = -1;
+        for (x = 0; x < w;) {
+            uchar byte = line[x / 8];
+            if (x > w - 8 || byte!=all) {
+                if (little) {
+                    for (int b = 8; b > 0 && x < w; --b) {
+                        if (!(byte & 0x01) == !all) {
+                            // More of the same
+                        } else {
+                            // A change.
+                            if (all!=zero) {
+                                AddSpan
+                                all = zero;
+                            } else {
+                                prev1 = x;
+                                all = ~zero;
+                            }
+                        }
+                        byte >>= 1;
+                        ++x;
+                    }
+                } else {
+                    for (int b = 8; b > 0 && x < w; --b) {
+                        if (!(byte & 0x80) == !all) {
+                            // More of the same
+                        } else {
+                            // A change.
+                            if (all != zero) {
+                                AddSpan
+                                all = zero;
+                            } else {
+                                prev1 = x;
+                                all = ~zero;
+                            }
+                        }
+                        byte <<= 1;
+                        ++x;
+                    }
+                }
+            } else {
+                x += 8;
+            }
+        }
+        if (all != zero) {
+            AddSpan
+        }
+    }
+#undef AddSpan
+
+    return region;
+}
+
+/*
+    Constructs an empty region.
+
+    \sa isEmpty()
+*/
+
+QRegion::QRegion()
+    : d(&shared_empty)
+{
+    d->ref.ref();
+}
+
+/*
+    \overload
+
+    Create a region based on the rectange \a r with region type \a t.
+
+    If the rectangle is invalid a null region will be created.
+
+    \sa QRegion::RegionType
+*/
+
+QRegion::QRegion(const QRect &r, RegionType t)
+{
+    if (r.isEmpty()) {
+        d = &shared_empty;
+        d->ref.ref();
+    } else {
+//        d = new QRegionData;
+        QRegionPrivate *rp = 0;
+        if (t == Rectangle) {
+//            rp = new QRegionPrivate(r);
+            rp = qt_allocRegion(r);
+        } else if (t == Ellipse) {
+            QPainterPath path;
+            path.addEllipse(r.x(), r.y(), r.width(), r.height());
+            QPolygon a = path.toSubpathPolygons().at(0).toPolygon();
+            rp = qt_allocRegion();
+//            rp = new QRegionPrivate;
+            PolygonRegion(a.constData(), a.size(), EvenOddRule, rp);
+        }
+        d = rp;
+        d->ref = 1;
+#if defined(Q_WS_X11)
+        d->rgn = 0;
+        d->xrectangles = 0;
+#elif defined(Q_WS_MAC)
+        d->rgn = 0;
+#endif
+        d->qt_rgn = rp;
+    }
+}
+
+/*
+    Constructs a polygon region from the point array \a a with the fill rule
+    specified by \a fillRule.
+
+    If \a fillRule is \l{Qt::WindingFill}, the polygon region is defined
+    using the winding algorithm; if it is \l{Qt::OddEvenFill}, the odd-even fill
+    algorithm is used.
+
+    \warning This constructor can be used to create complex regions that will
+    slow down painting when used.
+*/
+
+QRegion::QRegion(const QPolygon &a, Qt::FillRule fillRule)
+{
+    if (a.count() > 2) {
+        //d =  new QRegionData;
+        // QRegionPrivate *rp = new QRegionPrivate;
+        QRegionPrivate *rp = qt_allocRegion();
+        PolygonRegion(a.constData(), a.size(),
+                fillRule == Qt::WindingFill ? WindingRule : EvenOddRule, rp);
+        d = rp;
+        d->ref = 1;
+#if defined(Q_WS_X11)
+        d->rgn = 0;
+        d->xrectangles = 0;
+#elif defined(Q_WS_MAC)
+        d->rgn = 0;
+#endif
+        d->qt_rgn = rp;
+    } else {
+        d = &shared_empty;
+        d->ref.ref();
+    }
+}
+
+
+/*
+    Constructs a new region which is equal to region \a r.
+*/
+
+QRegion::QRegion(const QRegion &r)
+{
+    d = r.d;
+    d->ref.ref();
+}
+
+
+/*
+    Constructs a region from the bitmap \a bm.
+
+    The resulting region consists of the pixels in bitmap \a bm that
+    are Qt::color1, as if each pixel was a 1 by 1 rectangle.
+
+    This constructor may create complex regions that will slow down
+    painting when used. Note that drawing masked pixmaps can be done
+    much faster using QPixmap::setMask().
+*/
+QRegion::QRegion(const QBitmap &bm)
+{
+    if (bm.isNull()) {
+        d = &shared_empty;
+        d->ref.ref();
+    } else {
+        // d = new QRegionData;
+//        QRegionPrivate *rp = new QRegionPrivate;
+        QRegionPrivate *rp = qt_allocRegion();
+
+        qt_bitmapToRegion(bm, rp);
+        d = rp;
+        d->ref = 1;
+#if defined(Q_WS_X11)
+        d->rgn = 0;
+        d->xrectangles = 0;
+#elif defined(Q_WS_MAC)
+        d->rgn = 0;
+#endif
+        d->qt_rgn = rp;
+    }
+}
+
+void QRegion::cleanUp(QRegion::QRegionData *x)
+{
+    // delete x->qt_rgn;
+#if defined(Q_WS_X11)
+    if (x->rgn)
+        XDestroyRegion(x->rgn);
+    if (x->xrectangles)
+        free(x->xrectangles);
+#elif defined(Q_WS_MAC)
+    if (x->rgn)
+        qt_mac_dispose_rgn(x->rgn);
+#endif
+    if(x->qt_rgn) {
+//        delete x->qt_rgn;
+        qt_freeRegion(x->qt_rgn);
+    } else {
+        delete x;
+    }
+}
+
+/*
+    Destroys the region.
+*/
+
+QRegion::~QRegion()
+{
+    if (!d->ref.deref())
+        cleanUp(d);
+}
+
+
+/*
+    Assigns \a r to this region and returns a reference to the region.
+*/
+
+QRegion &QRegion::operator=(const QRegion &r)
+{
+    r.d->ref.ref();
+    if (!d->ref.deref()) 
+        cleanUp(d);
+    d = r.d;
+    return *this;
+}
+
+
+/*
+    \internal
+*/
+
+QRegion QRegion::copy() const
+{
+    QRegion r;
+    QRegionData *x = 0; // new QRegionData;
+    QRegionPrivate *rp = 0;
+    if (d->qt_rgn)
+//        rp = new QRegionPrivate(*d->qt_rgn);
+        rp = qt_allocRegion(*d->qt_rgn);
+    else
+        rp = qt_allocRegion();
+    x = rp;
+    x->qt_rgn = rp;
+    x->ref = 1;
+#if defined(Q_WS_X11)
+    x->rgn = 0;
+    x->xrectangles = 0;
+#elif defined(Q_WS_MAC)
+    x->rgn = 0;
+#endif
+
+    if (!r.d->ref.deref())
+        cleanUp(r.d);
+    r.d = x;
+    return r;
+}
+
+/*
+    Returns true if the region is empty; otherwise returns false. An
+    empty region is a region that contains no points.
+
+    Example:
+    \snippet doc/src/snippets/code/src.gui.painting.qregion_qws.cpp 0
+*/
+
+bool QRegion::isEmpty() const
+{
+    return d == &shared_empty || d->qt_rgn->numRects == 0;
+}
+
+
+/*
+    Returns true if the region contains the point \a p; otherwise
+    returns false.
+*/
+
+bool QRegion::contains(const QPoint &p) const
+{
+    return PointInRegion(d->qt_rgn, p.x(), p.y());
+}
+
+/*
+    \overload
+
+    Returns true if the region overlaps the rectangle \a r; otherwise
+    returns false.
+*/
+
+bool QRegion::contains(const QRect &r) const
+{
+    if(!d->qt_rgn)
+        return false;
+    if(d->qt_rgn->mode == QRegionPrivate::Single)
+        return d->qt_rgn->single.contains(r);
+
+    return RectInRegion(d->qt_rgn, r.left(), r.top(), r.width(), r.height()) != RectangleOut;
+}
+
+
+
+/*
+    Translates (moves) the region \a dx along the X axis and \a dy
+    along the Y axis.
+*/
+
+void QRegion::translate(int dx, int dy)
+{
+    if ((dx == 0 && dy == 0) || isEmptyHelper(d->qt_rgn))
+        return;
+
+    detach();
+    OffsetRegion(*d->qt_rgn, dx, dy);
+#if defined(Q_WS_X11)
+    if (d->xrectangles) {
+        free(d->xrectangles);
+        d->xrectangles = 0;
+    }
+#elif defined(Q_WS_MAC)
+    if(d->rgn) {
+        qt_mac_dispose_rgn(d->rgn);
+        d->rgn = 0;
+    }
+#endif
+}
+
+/*
+    \fn QRegion QRegion::unite(const QRegion &r) const
+    \obsolete
+
+    Use united(\a r) instead.
+*/
+
+/*
+    \fn QRegion QRegion::united(const QRegion &r) const
+    \since 4.2
+
+    Returns a region which is the union of this region and \a r.
+
+    \img runion.png Region Union
+
+    The figure shows the union of two elliptical regions.
+
+    \sa intersected(), subtracted(), xored()
+*/
+
+QRegion QRegion::unite(const QRegion &r) const
+{
+    if (isEmptyHelper(d->qt_rgn))
+        return r;
+    if (isEmptyHelper(r.d->qt_rgn))
+        return *this;
+
+    if (d->qt_rgn->contains(*r.d->qt_rgn)) {
+        return *this;
+    } else if (r.d->qt_rgn->contains(*d->qt_rgn)) {
+        return r;
+    } else if (d->qt_rgn->canAppend(r.d->qt_rgn)) {
+        QRegion result(*this);
+        result.detach();
+        result.d->qt_rgn->append(r.d->qt_rgn);
+        return result;
+    } else if (r.d->qt_rgn->canAppend(d->qt_rgn)) {
+        QRegion result(r);
+        result.detach();
+        result.d->qt_rgn->append(d->qt_rgn);
+        return result;
+    } else if (EqualRegion(d->qt_rgn, r.d->qt_rgn)) {
+        return *this;
+    } else {
+        QRegion result;
+        result.detach();
+        UnionRegion(d->qt_rgn, r.d->qt_rgn, *result.d->qt_rgn);
+        return result;
+    }
+}
+
+QRegion& QRegion::operator+=(const QRegion &r)
+{
+    if (isEmptyHelper(d->qt_rgn))
+        return *this = r;
+    if (isEmptyHelper(r.d->qt_rgn))
+        return *this;
+
+    if (d->qt_rgn->contains(*r.d->qt_rgn)) {
+        return *this;
+    } else if (r.d->qt_rgn->contains(*d->qt_rgn)) {
+        return *this = r;
+    } else if (d->qt_rgn->canAppend(r.d->qt_rgn)) {
+        detach();
+        d->qt_rgn->append(r.d->qt_rgn);
+        return *this;
+    } else if (d->qt_rgn->canPrepend(r.d->qt_rgn)) {
+        detach();
+        d->qt_rgn->prepend(r.d->qt_rgn);
+        return *this;
+    } else if (EqualRegion(d->qt_rgn, r.d->qt_rgn)) {
+        return *this;
+    }
+
+    return *this = unite(r);
+}
+
+/*
+    \fn QRegion QRegion::intersect(const QRegion &r) const
+    \obsolete
+
+    Use intersected(\a r) instead.
+*/
+
+/*
+    \fn QRegion QRegion::intersected(const QRegion &r) const
+    \since 4.2
+
+    Returns a region which is the intersection of this region and \a r.
+
+    \img rintersect.png Region Intersection
+
+    The figure shows the intersection of two elliptical regions.
+*/
+
+QRegion QRegion::intersect(const QRegion &r) const
+{
+    if (isEmptyHelper(d->qt_rgn) || isEmptyHelper(r.d->qt_rgn)
+        || !EXTENTCHECK(&d->qt_rgn->extents, &r.d->qt_rgn->extents))
+        return QRegion();
+
+    /* this is fully contained in r */
+    if (r.d->qt_rgn->contains(*d->qt_rgn))
+        return *this;
+
+    /* r is fully contained in this */
+    if (d->qt_rgn->contains(*r.d->qt_rgn))
+        return r;
+
+    if(r.d->qt_rgn->mode == QRegionPrivate::Single && 
+       d->qt_rgn->mode == QRegionPrivate::Single)
+        return QRegion(r.d->qt_rgn->single.intersected(d->qt_rgn->single));
+#ifdef QT_GREENPHONE_OPT
+    else if(r.d->qt_rgn->mode == QRegionPrivate::Single) 
+        return intersect(r.d->qt_rgn->single);
+    else if(d->qt_rgn->mode == QRegionPrivate::Single)
+        return r.intersect(d->qt_rgn->single);
+#endif
+
+    QRegion result;
+    result.detach();
+    miRegionOp(*result.d->qt_rgn, d->qt_rgn, r.d->qt_rgn, miIntersectO, 0, 0);
+
+    /*
+     * Can't alter dest's extents before we call miRegionOp because
+     * it might be one of the source regions and miRegionOp depends
+     * on the extents of those regions being the same. Besides, this
+     * way there's no checking against rectangles that will be nuked
+     * due to coalescing, so we have to examine fewer rectangles.
+     */
+    miSetExtents(*result.d->qt_rgn);
+    return result;
+}
+
+#ifdef QT_GREENPHONE_OPT
+/*
+  \overload
+  */
+QRegion QRegion::intersect(const QRect &r) const
+{
+    // No intersection
+    if(r.isEmpty() || isEmpty() || !EXTENTCHECK(&r, &d->qt_rgn->extents))
+        return QRegion();
+
+    // This is fully contained in r
+    if(CONTAINSCHECK(r, d->qt_rgn->extents))
+        return *this;
+
+    // r is fully contained in this
+    if(CONTAINSCHECK(d->qt_rgn->innerRect, r))
+        return QRegion(r);
+
+    if(d->qt_rgn->mode == QRegionPrivate::Single) {
+        return QRegion(d->qt_rgn->single & r);
+    } else {
+        QRegion rv(*this);
+        rv.detach();
+
+        rv.d->qt_rgn->extents &= r;
+        rv.d->qt_rgn->innerRect &= r;
+        rv.d->qt_rgn->innerArea = rv.d->qt_rgn->innerRect.height() * 
+                                  rv.d->qt_rgn->innerRect.width();
+
+        int numRects = 0;
+        for(int ii = 0; ii < rv.d->qt_rgn->numRects; ++ii) {
+            QRect result = rv.d->qt_rgn->rects[ii] & r;
+            if(!result.isEmpty())
+                rv.d->qt_rgn->rects[numRects++] = result;
+        }
+        rv.d->qt_rgn->numRects = numRects;
+        return rv;
+    }
+}
+
+/*
+   \overload
+ */
+const QRegion QRegion::operator&(const QRect &r) const
+{
+    return intersect(r);
+}
+
+/*
+   \overload
+ */
+QRegion& QRegion::operator&=(const QRect &r)
+{
+    if(isEmpty() || CONTAINSCHECK(r, d->qt_rgn->extents)) {
+        // Do nothing
+    } else if(r.isEmpty() || !EXTENTCHECK(&r, &d->qt_rgn->extents)) {
+        *this = QRegion();
+    } else if(CONTAINSCHECK(d->qt_rgn->innerRect, r)) {
+        *this = QRegion(r);
+    } else {
+        detach();
+        if(d->qt_rgn->mode == QRegionPrivate::Single) {
+            QRect result = d->qt_rgn->single & r;
+            d->qt_rgn->single = result;
+            d->qt_rgn->extents = result;
+            d->qt_rgn->innerRect = result;
+            d->qt_rgn->innerArea = result.height() * result.width();
+        } else {
+            d->qt_rgn->extents &= r;
+            d->qt_rgn->innerRect &= r;
+            d->qt_rgn->innerArea = d->qt_rgn->innerRect.height() *
+                                   d->qt_rgn->innerRect.width();
+
+            int numRects = 0;
+            for(int ii = 0; ii < d->qt_rgn->numRects; ++ii) {
+                QRect result = d->qt_rgn->rects[ii] & r;
+                if(!result.isEmpty())
+                    d->qt_rgn->rects[numRects++] = result;
+            }
+            d->qt_rgn->numRects = numRects;
+        }
+    }
+    return *this;
+}
+#endif
+
+/*
+    \fn QRegion QRegion::subtract(const QRegion &r) const
+    \obsolete
+
+    Use subtracted(\a r) instead.
+*/
+
+/*
+    \fn QRegion QRegion::subtracted(const QRegion &r) const
+    \since 4.2
+
+    Returns a region which is \a r subtracted from this region.
+
+    \img rsubtract.png Region Subtraction
+
+    The figure shows the result when the ellipse on the right is
+    subtracted from the ellipse on the left (\c {left - right}).
+
+    \sa intersected(), united(), xored()
+*/
+
+QRegion QRegion::subtract(const QRegion &r) const
+{
+    if (isEmptyHelper(d->qt_rgn) || isEmptyHelper(r.d->qt_rgn))
+        return *this;
+    if (r.d->qt_rgn->contains(*d->qt_rgn))
+        return QRegion();
+    if (!EXTENTCHECK(&d->qt_rgn->extents, &r.d->qt_rgn->extents))
+        return *this;
+    if (EqualRegion(d->qt_rgn, r.d->qt_rgn))
+        return QRegion();
+
+    QRegion result;
+    result.detach();
+    SubtractRegion(d->qt_rgn, r.d->qt_rgn, *result.d->qt_rgn);
+    return result;
+}
+
+/*
+    \fn QRegion QRegion::eor(const QRegion &r) const
+    \obsolete
+
+    Use xored(\a r) instead.
+*/
+
+/*
+    \fn QRegion QRegion::xored(const QRegion &r) const
+    \since 4.2
+
+    Returns a region which is the exclusive or (XOR) of this region
+    and \a r.
+
+    \img rxor.png Region XORed
+
+    The figure shows the exclusive or of two elliptical regions.
+
+    \sa intersected(), united(), subtracted()
+*/
+
+QRegion QRegion::eor(const QRegion &r) const
+{
+    if (isEmptyHelper(d->qt_rgn)) {
+        return r;
+    } else if (isEmptyHelper(r.d->qt_rgn)) {
+        return *this;
+    } else if (!EXTENTCHECK(&d->qt_rgn->extents, &r.d->qt_rgn->extents)) {
+        return (*this + r);
+    } else if (EqualRegion(d->qt_rgn, r.d->qt_rgn)) {
+        return QRegion();
+    } else {
+        QRegion result;
+        result.detach();
+        XorRegion(d->qt_rgn, r.d->qt_rgn, *result.d->qt_rgn);
+        return result;
+    }
+}
+
+/*
+    Returns the bounding rectangle of this region. An empty region
+    gives a rectangle that is QRect::isNull().
+*/
+
+QRect QRegion::boundingRect() const
+{
+    if (isEmpty())
+        return QRect();
+    return d->qt_rgn->extents;
+}
+
+/* \internal
+    Returns true if \a rect is guaranteed to be fully contained in \a region.
+    A false return value does not guarantee the opposite.
+*/
+bool qt_region_strictContains(const QRegion &region, const QRect &rect)
+{
+    if (isEmptyHelper(region.d->qt_rgn) || !rect.isValid())
+        return false;
+
+#if 0 // TEST_INNERRECT
+    static bool guard = false;
+    if (guard)
+        return QRect();
+    guard = true;
+    QRegion inner = region.d->qt_rgn->innerRect;
+    Q_ASSERT((inner - region).isEmpty());
+    guard = false;
+
+    int maxArea = 0;
+    for (int i = 0; i < region.d->qt_rgn->numRects; ++i) {
+        const QRect r = region.d->qt_rgn->rects.at(i);
+        if (r.width() * r.height() > maxArea)
+            maxArea = r.width() * r.height();
+    }
+
+    if (maxArea > region.d->qt_rgn->innerArea) {
+        qDebug() << "not largest rectangle" << region << region.d->qt_rgn->innerRect;
+    }
+    Q_ASSERT(maxArea <= region.d->qt_rgn->innerArea);
+#endif
+
+    const QRect r1 = region.d->qt_rgn->innerRect;
+    return (rect.left() >= r1.left() && rect.right() <= r1.right()
+            && rect.top() >= r1.top() && rect.bottom() <= r1.bottom());
+}
+
+/*
+    Returns an array of non-overlapping rectangles that make up the
+    region.
+
+    The union of all the rectangles is equal to the original region.
+*/
+QVector<QRect> QRegion::rects() const
+{
+    if (d->qt_rgn) {
+        d->qt_rgn->vector();
+        d->qt_rgn->rects.resize(d->qt_rgn->numRects);
+        return d->qt_rgn->rects;
+    } else {
+        return QVector<QRect>();
+    }
+}
+
+/*
+  \fn void QRegion::setRects(const QRect *rects, int number)
+
+  Sets the region using the array of rectangles specified by \a rects and
+  \a number.
+  The rectangles \e must be optimally Y-X sorted and follow these restrictions:
+
+  \list
+  \o The rectangles must not intersect.
+  \o All rectangles with a given top coordinate must have the same height.
+  \o No two rectangles may abut horizontally (they should be combined
+     into a single wider rectangle in that case).
+  \o The rectangles must be sorted in ascending order, with Y as the major
+     sort key and X as the minor sort key.
+  \endlist
+  \omit
+  Only some platforms have these restrictions (Qt for Embedded Linux, X11 and Mac OS X).
+  \endomit
+*/
+void QRegion::setRects(const QRect *rects, int num)
+{
+    *this = QRegion();
+    if (!rects || num == 0 || (num == 1 && rects->isEmpty()))
+        return;
+
+    detach();
+
+    if(num == 1) {
+        d->qt_rgn->single = *rects;
+        d->qt_rgn->mode = QRegionPrivate::Single;
+        d->qt_rgn->numRects = num;
+        d->qt_rgn->extents = *rects;
+        d->qt_rgn->innerRect = *rects;
+    } else {
+        d->qt_rgn->mode = QRegionPrivate::Vector;
+        d->qt_rgn->rects.resize(num);
+        d->qt_rgn->numRects = num;
+        int left = INT_MAX,
+            right = INT_MIN,
+            top = INT_MAX,
+            bottom = INT_MIN;
+        for (int i = 0; i < num; ++i) {
+            const QRect &rect = rects[i];
+            d->qt_rgn->rects[i] = rect;
+            left = qMin(rect.left(), left);
+            right = qMax(rect.right(), right);
+            top = qMin(rect.top(), top);
+            bottom = qMax(rect.bottom(), bottom);
+            d->qt_rgn->updateInnerRect(rect);
+        }
+        d->qt_rgn->extents = QRect(QPoint(left, top), QPoint(right, bottom));
+    }
+}
+
+/*
+    Returns true if the region is equal to \a r; otherwise returns
+    false.
+*/
+
+bool QRegion::operator==(const QRegion &r) const
+{
+    if (!d->qt_rgn || !r.d->qt_rgn)
+        return r.d->qt_rgn == d->qt_rgn;
+
+    if (d == r.d)
+        return true;
+    else
+        return EqualRegion(d->qt_rgn, r.d->qt_rgn);
+}
+
+#ifdef QT_GREENPHONE_OPT
+bool QRegion::isRect() const
+{
+    return d->qt_rgn && d->qt_rgn->mode == QRegionPrivate::Single;
+}
+#endif
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qregion_s60.cpp b/src/gui/painting/qregion_s60.cpp
new file mode 100644
index 0000000000..eafff1b965
--- /dev/null
+++ b/src/gui/painting/qregion_s60.cpp
@@ -0,0 +1,52 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qbitmap.h"
+#include "qbuffer.h"
+#include "qimage.h"
+#include "qpolygon.h"
+#include "qregion.h"
+
+QT_BEGIN_NAMESPACE
+
+QRegion::QRegionData QRegion::shared_empty = { Q_BASIC_ATOMIC_INITIALIZER(1), 0 };
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qregion_win.cpp b/src/gui/painting/qregion_win.cpp
new file mode 100644
index 0000000000..3466b62cbd
--- /dev/null
+++ b/src/gui/painting/qregion_win.cpp
@@ -0,0 +1,149 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qatomic.h"
+#include "qbitmap.h"
+#include "qbuffer.h"
+#include "qimage.h"
+#include "qpolygon.h"
+#include "qregion.h"
+#include "qt_windows.h"
+#include "qpainterpath.h"
+
+QT_BEGIN_NAMESPACE
+
+QRegion::QRegionData QRegion::shared_empty = { Q_BASIC_ATOMIC_INITIALIZER(1), 0, 0 };
+
+HRGN qt_tryCreateRegion(QRegion::RegionType type, int left, int top, int right, int bottom)
+{
+    const int tries = 10;
+    for (int i = 0; i < tries; ++i) {
+        HRGN region = 0;
+        switch (type) {
+        case QRegion::Rectangle:
+            region = CreateRectRgn(left, top, right, bottom);
+            break;
+        case QRegion::Ellipse:
+#ifndef Q_OS_WINCE
+            region = CreateEllipticRgn(left, top, right, bottom);
+#endif
+            break;
+        }
+        if (region) {
+            if (GetRegionData(region, 0, 0))
+                return region;
+            else
+                DeleteObject(region);
+        }
+    }
+    return 0;
+}
+
+QRegion qt_region_from_HRGN(HRGN rgn)
+{
+    int numBytes = GetRegionData(rgn, 0, 0);
+    if (numBytes == 0)
+        return QRegion();
+
+    char *buf = new char[numBytes];
+    if (buf == 0)
+        return QRegion();
+
+    RGNDATA *rd = reinterpret_cast<RGNDATA*>(buf);
+    if (GetRegionData(rgn, numBytes, rd) == 0) {
+        delete [] buf;
+        return QRegion();
+    }
+
+    QRegion region;
+    RECT *r = reinterpret_cast<RECT*>(rd->Buffer);
+    for (uint i = 0; i < rd->rdh.nCount; ++i) {
+        QRect rect;
+        rect.setCoords(r->left, r->top, r->right - 1, r->bottom - 1);
+        ++r;
+        region |= rect;
+    }
+
+    delete [] buf;
+
+    return region;
+}
+
+void qt_win_dispose_rgn(HRGN r)
+{
+    if (r)
+        DeleteObject(r);
+}
+
+static void qt_add_rect(HRGN &winRegion, QRect r)
+{
+    HRGN rgn = CreateRectRgn(r.left(), r.top(), r.x() + r.width(), r.y() + r.height());
+    if (rgn) {
+        HRGN dest = CreateRectRgn(0,0,0,0);
+        int result = CombineRgn(dest, winRegion, rgn, RGN_OR);
+        if (result) {
+            DeleteObject(winRegion);
+            winRegion = dest;
+        }
+        DeleteObject(rgn);
+    }
+}
+
+void QRegion::ensureHandle() const
+{
+    if (d->rgn)
+        DeleteObject(d->rgn);
+    d->rgn = CreateRectRgn(0,0,0,0);
+    if (d->qt_rgn) {
+        if (d->qt_rgn->numRects == 1) {
+            QRect r = d->qt_rgn->extents;
+            qt_add_rect(d->rgn, r);
+            return;
+        }
+        for (int i = 0;i < d->qt_rgn->numRects;i++) {
+            QRect r = d->qt_rgn->rects.at(i);
+            qt_add_rect(d->rgn, r);
+        }
+    }
+}
+
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qregion_x11.cpp b/src/gui/painting/qregion_x11.cpp
new file mode 100644
index 0000000000..ef4e844bfa
--- /dev/null
+++ b/src/gui/painting/qregion_x11.cpp
@@ -0,0 +1,92 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <private/qt_x11_p.h>
+
+#include <limits.h>
+
+QT_BEGIN_NAMESPACE
+
+QRegion::QRegionData QRegion::shared_empty = {Q_BASIC_ATOMIC_INITIALIZER(1), 0, 0, 0};
+
+void QRegion::updateX11Region() const
+{
+    d->rgn = XCreateRegion();
+    if (!d->qt_rgn)
+        return;
+
+    int n = d->qt_rgn->numRects;
+    const QRect *rect = (n == 1 ? &d->qt_rgn->extents : d->qt_rgn->rects.constData());
+    while (n--) {
+        XRectangle r;
+        r.x = qMax(SHRT_MIN, rect->x());
+        r.y = qMax(SHRT_MIN, rect->y());
+        r.width = qMin((int)USHRT_MAX, rect->width());
+        r.height = qMin((int)USHRT_MAX, rect->height());
+        XUnionRectWithRegion(&r, d->rgn, d->rgn);
+        ++rect;
+    }
+}
+
+void *QRegion::clipRectangles(int &num) const
+{
+    if (!d->xrectangles && !(d == &shared_empty || d->qt_rgn->numRects == 0)) {
+        XRectangle *r = static_cast<XRectangle*>(malloc(d->qt_rgn->numRects * sizeof(XRectangle)));
+        d->xrectangles = r;
+        int n = d->qt_rgn->numRects;
+        const QRect *rect = (n == 1 ? &d->qt_rgn->extents : d->qt_rgn->rects.constData());
+        while (n--) {
+            r->x = qMax(SHRT_MIN, rect->x());
+            r->y = qMax(SHRT_MIN, rect->y());
+            r->width = qMin((int)USHRT_MAX, rect->width());
+            r->height = qMin((int)USHRT_MAX, rect->height());
+            ++r;
+            ++rect;
+        }
+    }
+    if (d == &shared_empty || d->qt_rgn->numRects == 0)
+        num = 0;
+    else
+        num = d->qt_rgn->numRects;
+    return d->xrectangles;
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qrgb.h b/src/gui/painting/qrgb.h
new file mode 100644
index 0000000000..df6a920e80
--- /dev/null
+++ b/src/gui/painting/qrgb.h
@@ -0,0 +1,88 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QRGB_H
+#define QRGB_H
+
+#include <QtCore/qglobal.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+typedef unsigned int QRgb;                        // RGB triplet
+
+const QRgb  RGB_MASK    = 0x00ffffff;                // masks RGB values
+
+Q_GUI_EXPORT_INLINE int qRed(QRgb rgb)                // get red part of RGB
+{ return ((rgb >> 16) & 0xff); }
+
+Q_GUI_EXPORT_INLINE int qGreen(QRgb rgb)                // get green part of RGB
+{ return ((rgb >> 8) & 0xff); }
+
+Q_GUI_EXPORT_INLINE int qBlue(QRgb rgb)                // get blue part of RGB
+{ return (rgb & 0xff); }
+
+Q_GUI_EXPORT_INLINE int qAlpha(QRgb rgb)                // get alpha part of RGBA
+{ return rgb >> 24; }
+
+Q_GUI_EXPORT_INLINE QRgb qRgb(int r, int g, int b)// set RGB value
+{ return (0xffu << 24) | ((r & 0xff) << 16) | ((g & 0xff) << 8) | (b & 0xff); }
+
+Q_GUI_EXPORT_INLINE QRgb qRgba(int r, int g, int b, int a)// set RGBA value
+{ return ((a & 0xff) << 24) | ((r & 0xff) << 16) | ((g & 0xff) << 8) | (b & 0xff); }
+
+Q_GUI_EXPORT_INLINE int qGray(int r, int g, int b)// convert R,G,B to gray 0..255
+{ return (r*11+g*16+b*5)/32; }
+
+Q_GUI_EXPORT_INLINE int qGray(QRgb rgb)                // convert RGB to gray 0..255
+{ return qGray(qRed(rgb), qGreen(rgb), qBlue(rgb)); }
+
+Q_GUI_EXPORT_INLINE bool qIsGray(QRgb rgb)
+{ return qRed(rgb) == qGreen(rgb) && qRed(rgb) == qBlue(rgb); }
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QRGB_H
diff --git a/src/gui/painting/qstroker.cpp b/src/gui/painting/qstroker.cpp
new file mode 100644
index 0000000000..fca46b45f7
--- /dev/null
+++ b/src/gui/painting/qstroker.cpp
@@ -0,0 +1,1263 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "private/qstroker_p.h"
+#include "private/qbezier_p.h"
+#include "private/qmath_p.h"
+#include "qline.h"
+#include "qtransform.h"
+#include <qmath.h>
+
+QT_BEGIN_NAMESPACE
+
+// #define QPP_STROKE_DEBUG
+
+class QSubpathForwardIterator
+{
+public:
+    QSubpathForwardIterator(const QDataBuffer<QStrokerOps::Element> *path)
+        : m_path(path), m_pos(0) { }
+    inline int position() const { return m_pos; }
+    inline bool hasNext() const { return m_pos < m_path->size(); }
+    inline QStrokerOps::Element next() { Q_ASSERT(hasNext()); return m_path->at(m_pos++); }
+
+private:
+    const QDataBuffer<QStrokerOps::Element> *m_path;
+    int m_pos;
+};
+
+class QSubpathBackwardIterator
+{
+public:
+    QSubpathBackwardIterator(const QDataBuffer<QStrokerOps::Element> *path)
+        : m_path(path), m_pos(path->size() - 1) { }
+
+    inline int position() const { return m_pos; }
+
+    inline bool hasNext() const { return m_pos >= 0; }
+
+    inline QStrokerOps::Element next()
+    {
+        Q_ASSERT(hasNext());
+
+        QStrokerOps::Element ce = m_path->at(m_pos);   // current element
+
+        if (m_pos == m_path->size() - 1) {
+            --m_pos;
+            ce.type = QPainterPath::MoveToElement;
+            return ce;
+        }
+
+        const QStrokerOps::Element &pe = m_path->at(m_pos + 1); // previous element
+
+        switch (pe.type) {
+        case QPainterPath::LineToElement:
+            ce.type = QPainterPath::LineToElement;
+            break;
+        case QPainterPath::CurveToDataElement:
+            // First control point?
+            if (ce.type == QPainterPath::CurveToElement) {
+                ce.type = QPainterPath::CurveToDataElement;
+            } else { // Second control point then
+                ce.type = QPainterPath::CurveToElement;
+            }
+            break;
+        case QPainterPath::CurveToElement:
+            ce.type = QPainterPath::CurveToDataElement;
+            break;
+        default:
+            qWarning("QSubpathReverseIterator::next: Case %d unhandled", ce.type);
+            break;
+        }
+        --m_pos;
+
+        return ce;
+    }
+
+private:
+    const QDataBuffer<QStrokerOps::Element> *m_path;
+    int m_pos;
+};
+
+class QSubpathFlatIterator
+{
+public:
+    QSubpathFlatIterator(const QDataBuffer<QStrokerOps::Element> *path, qreal threshold)
+        : m_path(path), m_pos(0), m_curve_index(-1), m_curve_threshold(threshold) { }
+
+    inline bool hasNext() const { return m_curve_index >= 0 || m_pos < m_path->size(); }
+
+    QStrokerOps::Element next()
+    {
+        Q_ASSERT(hasNext());
+
+        if (m_curve_index >= 0) {
+            QStrokerOps::Element e = { QPainterPath::LineToElement,
+                                       qt_real_to_fixed(m_curve.at(m_curve_index).x()),
+                                       qt_real_to_fixed(m_curve.at(m_curve_index).y())
+                                       };
+            ++m_curve_index;
+            if (m_curve_index >= m_curve.size())
+                m_curve_index = -1;
+            return e;
+        }
+
+        QStrokerOps::Element e = m_path->at(m_pos);
+        if (e.isCurveTo()) {
+            Q_ASSERT(m_pos > 0);
+            Q_ASSERT(m_pos < m_path->size());
+
+            m_curve = QBezier::fromPoints(QPointF(qt_fixed_to_real(m_path->at(m_pos-1).x),
+                                                  qt_fixed_to_real(m_path->at(m_pos-1).y)),
+                                          QPointF(qt_fixed_to_real(e.x),
+                                                  qt_fixed_to_real(e.y)),
+                                          QPointF(qt_fixed_to_real(m_path->at(m_pos+1).x),
+                                                  qt_fixed_to_real(m_path->at(m_pos+1).y)),
+                                          QPointF(qt_fixed_to_real(m_path->at(m_pos+2).x),
+                                                  qt_fixed_to_real(m_path->at(m_pos+2).y))).toPolygon(m_curve_threshold);
+            m_curve_index = 1;
+            e.type = QPainterPath::LineToElement;
+            e.x = m_curve.at(0).x();
+            e.y = m_curve.at(0).y();
+            m_pos += 2;
+        }
+        Q_ASSERT(e.isLineTo() || e.isMoveTo());
+        ++m_pos;
+        return e;
+    }
+
+private:
+    const QDataBuffer<QStrokerOps::Element> *m_path;
+    int m_pos;
+    QPolygonF m_curve;
+    int m_curve_index;
+    qreal m_curve_threshold;
+};
+
+template <class Iterator> bool qt_stroke_side(Iterator *it, QStroker *stroker,
+                                              bool capFirst, QLineF *startTangent);
+
+/*******************************************************************************
+ * QLineF::angle gives us the smalles angle between two lines. Here we
+ * want to identify the line's angle direction on the unit circle.
+ */
+static inline qreal adapted_angle_on_x(const QLineF &line)
+{
+    qreal angle = line.angle(QLineF(0, 0, 1, 0));
+    if (line.dy() > 0)
+        angle = 360 - angle;
+    return angle;
+}
+
+QStrokerOps::QStrokerOps()
+    : m_elements(0)
+    , m_curveThreshold(qt_real_to_fixed(0.25))
+    , m_dashThreshold(qt_real_to_fixed(0.25))
+    , m_customData(0)
+    , m_moveTo(0)
+    , m_lineTo(0)
+    , m_cubicTo(0)
+{
+}
+
+QStrokerOps::~QStrokerOps()
+{
+}
+
+/*!
+    Prepares the stroker. Call this function once before starting a
+    stroke by calling moveTo, lineTo or cubicTo.
+
+    The \a customData is passed back through that callback functions
+    and can be used by the user to for instance maintain state
+    information.
+*/
+void QStrokerOps::begin(void *customData)
+{
+    m_customData = customData;
+    m_elements.reset();
+}
+
+
+/*!
+    Finishes the stroke. Call this function once when an entire
+    primitive has been stroked.
+*/
+void QStrokerOps::end()
+{
+    if (m_elements.size() > 1)
+        processCurrentSubpath();
+    m_customData = 0;
+}
+
+/*!
+    Convenience function that decomposes \a path into begin(),
+    moveTo(), lineTo(), curevTo() and end() calls.
+
+    The \a customData parameter is used in the callback functions
+
+    The \a matrix is used to transform the points before input to the
+    stroker.
+
+    \sa begin()
+*/
+void QStrokerOps::strokePath(const QPainterPath &path, void *customData, const QTransform &matrix)
+{
+    if (path.isEmpty())
+        return;
+
+    setCurveThresholdFromTransform(QTransform());
+    begin(customData);
+    int count = path.elementCount();
+    if (matrix.isIdentity()) {
+        for (int i=0; i<count; ++i) {
+            const QPainterPath::Element &e = path.elementAt(i);
+            switch (e.type) {
+            case QPainterPath::MoveToElement:
+                moveTo(qt_real_to_fixed(e.x), qt_real_to_fixed(e.y));
+                break;
+            case QPainterPath::LineToElement:
+                lineTo(qt_real_to_fixed(e.x), qt_real_to_fixed(e.y));
+                break;
+            case QPainterPath::CurveToElement:
+                {
+                    const QPainterPath::Element &cp2 = path.elementAt(++i);
+                    const QPainterPath::Element &ep = path.elementAt(++i);
+                    cubicTo(qt_real_to_fixed(e.x), qt_real_to_fixed(e.y),
+                            qt_real_to_fixed(cp2.x), qt_real_to_fixed(cp2.y),
+                            qt_real_to_fixed(ep.x), qt_real_to_fixed(ep.y));
+                }
+                break;
+            default:
+                break;
+            }
+        }
+    } else {
+        for (int i=0; i<count; ++i) {
+            const QPainterPath::Element &e = path.elementAt(i);
+            QPointF pt = QPointF(e.x, e.y) * matrix;
+            switch (e.type) {
+            case QPainterPath::MoveToElement:
+                moveTo(qt_real_to_fixed(pt.x()), qt_real_to_fixed(pt.y()));
+                break;
+            case QPainterPath::LineToElement:
+                lineTo(qt_real_to_fixed(pt.x()), qt_real_to_fixed(pt.y()));
+                break;
+            case QPainterPath::CurveToElement:
+                {
+                    QPointF cp2 = ((QPointF) path.elementAt(++i)) * matrix;
+                    QPointF ep = ((QPointF) path.elementAt(++i)) * matrix;
+                    cubicTo(qt_real_to_fixed(pt.x()), qt_real_to_fixed(pt.y()),
+                            qt_real_to_fixed(cp2.x()), qt_real_to_fixed(cp2.y()),
+                            qt_real_to_fixed(ep.x()), qt_real_to_fixed(ep.y()));
+                }
+                break;
+            default:
+                break;
+            }
+        }
+    }
+    end();
+}
+
+/*!
+    Convenience function for stroking a polygon of the \a pointCount
+    first points in \a points. If \a implicit_close is set to true a
+    line is implictly drawn between the first and last point in the
+    polygon. Typically true for polygons and false for polylines.
+
+    The \a matrix is used to transform the points before they enter the
+    stroker.
+
+    \sa begin()
+*/
+
+void QStrokerOps::strokePolygon(const QPointF *points, int pointCount, bool implicit_close,
+                                void *data, const QTransform &matrix)
+{
+    if (!pointCount)
+        return;
+
+    setCurveThresholdFromTransform(QTransform());
+    begin(data);
+    if (matrix.isIdentity()) {
+        moveTo(qt_real_to_fixed(points[0].x()), qt_real_to_fixed(points[0].y()));
+        for (int i=1; i<pointCount; ++i)
+            lineTo(qt_real_to_fixed(points[i].x()),
+                   qt_real_to_fixed(points[i].y()));
+        if (implicit_close)
+            lineTo(qt_real_to_fixed(points[0].x()), qt_real_to_fixed(points[0].y()));
+    } else {
+        QPointF start = points[0] * matrix;
+        moveTo(qt_real_to_fixed(start.x()), qt_real_to_fixed(start.y()));
+        for (int i=1; i<pointCount; ++i) {
+            QPointF pt = points[i] * matrix;
+            lineTo(qt_real_to_fixed(pt.x()), qt_real_to_fixed(pt.y()));
+        }
+        if (implicit_close)
+            lineTo(qt_real_to_fixed(start.x()), qt_real_to_fixed(start.y()));
+    }
+    end();
+}
+
+/*!
+    Convenience function for stroking an ellipse with bounding rect \a
+    rect. The \a matrix is used to transform the coordinates before
+    they enter the stroker.
+*/
+void QStrokerOps::strokeEllipse(const QRectF &rect, void *data, const QTransform &matrix)
+{
+    int count = 0;
+    QPointF pts[12];
+    QPointF start = qt_curves_for_arc(rect, 0, -360, pts, &count);
+    Q_ASSERT(count == 12); // a perfect circle..
+
+    if (!matrix.isIdentity()) {
+        start = start * matrix;
+        for (int i=0; i<12; ++i) {
+            pts[i] = pts[i] * matrix;
+        }
+    }
+
+    setCurveThresholdFromTransform(QTransform());
+    begin(data);
+    moveTo(qt_real_to_fixed(start.x()), qt_real_to_fixed(start.y()));
+    for (int i=0; i<12; i+=3) {
+        cubicTo(qt_real_to_fixed(pts[i].x()), qt_real_to_fixed(pts[i].y()),
+                qt_real_to_fixed(pts[i+1].x()), qt_real_to_fixed(pts[i+1].y()),
+                qt_real_to_fixed(pts[i+2].x()), qt_real_to_fixed(pts[i+2].y()));
+    }
+    end();
+}
+
+
+QStroker::QStroker()
+    : m_capStyle(SquareJoin), m_joinStyle(FlatJoin),
+      m_back1X(0), m_back1Y(0),
+      m_back2X(0), m_back2Y(0)
+{
+    m_strokeWidth = qt_real_to_fixed(1);
+    m_miterLimit = qt_real_to_fixed(2);
+}
+
+QStroker::~QStroker()
+{
+}
+
+Qt::PenCapStyle QStroker::capForJoinMode(LineJoinMode mode)
+{
+    if (mode == FlatJoin) return Qt::FlatCap;
+    else if (mode == SquareJoin) return Qt::SquareCap;
+    else return Qt::RoundCap;
+}
+
+QStroker::LineJoinMode QStroker::joinModeForCap(Qt::PenCapStyle style)
+{
+    if (style == Qt::FlatCap) return FlatJoin;
+    else if (style == Qt::SquareCap) return SquareJoin;
+    else return RoundCap;
+}
+
+Qt::PenJoinStyle QStroker::joinForJoinMode(LineJoinMode mode)
+{
+    if (mode == FlatJoin) return Qt::BevelJoin;
+    else if (mode == MiterJoin) return Qt::MiterJoin;
+    else if (mode == SvgMiterJoin) return Qt::SvgMiterJoin;
+    else return Qt::RoundJoin;
+}
+
+QStroker::LineJoinMode QStroker::joinModeForJoin(Qt::PenJoinStyle joinStyle)
+{
+    if (joinStyle == Qt::BevelJoin) return FlatJoin;
+    else if (joinStyle == Qt::MiterJoin) return MiterJoin;
+    else if (joinStyle == Qt::SvgMiterJoin) return SvgMiterJoin;
+    else return RoundJoin;
+}
+
+
+/*!
+    This function is called to stroke the currently built up
+    subpath. The subpath is cleared when the function completes.
+*/
+void QStroker::processCurrentSubpath()
+{
+    Q_ASSERT(!m_elements.isEmpty());
+    Q_ASSERT(m_elements.first().type == QPainterPath::MoveToElement);
+    Q_ASSERT(m_elements.size() > 1);
+
+    QSubpathForwardIterator fwit(&m_elements);
+    QSubpathBackwardIterator bwit(&m_elements);
+
+    QLineF fwStartTangent, bwStartTangent;
+
+    bool fwclosed = qt_stroke_side(&fwit, this, false, &fwStartTangent);
+    bool bwclosed = qt_stroke_side(&bwit, this, !fwclosed, &bwStartTangent);
+
+    if (!bwclosed)
+        joinPoints(m_elements.at(0).x, m_elements.at(0).y, fwStartTangent, m_capStyle);
+}
+
+
+/*!
+    \internal
+*/
+void QStroker::joinPoints(qfixed focal_x, qfixed focal_y, const QLineF &nextLine, LineJoinMode join)
+{
+#ifdef QPP_STROKE_DEBUG
+    printf(" -----> joinPoints: around=(%.0f, %.0f), next_p1=(%.0f, %.f) next_p2=(%.0f, %.f)\n",
+           qt_fixed_to_real(focal_x),
+           qt_fixed_to_real(focal_y),
+           nextLine.x1(), nextLine.y1(), nextLine.x2(), nextLine.y2());
+#endif
+    // points connected already, don't join
+
+#if !defined (QFIXED_26_6) && !defined (Q_FIXED_32_32)
+    if (qFuzzyCompare(m_back1X, nextLine.x1()) && qFuzzyCompare(m_back1Y, nextLine.y1()))
+        return;
+#else
+    if (m_back1X == qt_real_to_fixed(nextLine.x1())
+        && m_back1Y == qt_real_to_fixed(nextLine.y1())) {
+        return;
+    }
+#endif
+
+    if (join == FlatJoin) {
+        QLineF prevLine(qt_fixed_to_real(m_back2X), qt_fixed_to_real(m_back2Y),
+                        qt_fixed_to_real(m_back1X), qt_fixed_to_real(m_back1Y));
+        QPointF isect;
+        QLineF::IntersectType type = prevLine.intersect(nextLine, &isect);
+        QLineF shortCut(prevLine.p2(), nextLine.p1());
+        qreal angle = shortCut.angleTo(prevLine);
+        if (type == QLineF::BoundedIntersection || (angle > 90 && !qFuzzyCompare(angle, (qreal)90))) {
+            emitLineTo(focal_x, focal_y);
+            emitLineTo(qt_real_to_fixed(nextLine.x1()), qt_real_to_fixed(nextLine.y1()));
+            return;
+        }
+        emitLineTo(qt_real_to_fixed(nextLine.x1()),
+                   qt_real_to_fixed(nextLine.y1()));
+
+    } else {
+        QLineF prevLine(qt_fixed_to_real(m_back2X), qt_fixed_to_real(m_back2Y),
+                        qt_fixed_to_real(m_back1X), qt_fixed_to_real(m_back1Y));
+
+        QPointF isect;
+        QLineF::IntersectType type = prevLine.intersect(nextLine, &isect);
+
+        if (join == MiterJoin) {
+            qreal appliedMiterLimit = qt_fixed_to_real(m_strokeWidth * m_miterLimit);
+
+            // If we are on the inside, do the short cut...
+            QLineF shortCut(prevLine.p2(), nextLine.p1());
+            qreal angle = shortCut.angleTo(prevLine);
+            if (type == QLineF::BoundedIntersection || (angle > 90 && !qFuzzyCompare(angle, (qreal)90))) {
+                emitLineTo(focal_x, focal_y);
+                emitLineTo(qt_real_to_fixed(nextLine.x1()), qt_real_to_fixed(nextLine.y1()));
+                return;
+            }
+            QLineF miterLine(QPointF(qt_fixed_to_real(m_back1X),
+                                     qt_fixed_to_real(m_back1Y)), isect);
+            if (type == QLineF::NoIntersection || miterLine.length() > appliedMiterLimit) {
+                QLineF l1(prevLine);
+                l1.setLength(appliedMiterLimit);
+                l1.translate(prevLine.dx(), prevLine.dy());
+
+                QLineF l2(nextLine);
+                l2.setLength(appliedMiterLimit);
+                l2.translate(-l2.dx(), -l2.dy());
+
+                emitLineTo(qt_real_to_fixed(l1.x2()), qt_real_to_fixed(l1.y2()));
+                emitLineTo(qt_real_to_fixed(l2.x1()), qt_real_to_fixed(l2.y1()));
+                emitLineTo(qt_real_to_fixed(nextLine.x1()), qt_real_to_fixed(nextLine.y1()));
+            } else {
+                emitLineTo(qt_real_to_fixed(isect.x()), qt_real_to_fixed(isect.y()));
+                emitLineTo(qt_real_to_fixed(nextLine.x1()), qt_real_to_fixed(nextLine.y1()));
+            }
+
+        } else if (join == SquareJoin) {
+            qfixed offset = m_strokeWidth / 2;
+
+            QLineF l1(prevLine);
+            l1.translate(l1.dx(), l1.dy());
+            l1.setLength(qt_fixed_to_real(offset));
+            QLineF l2(nextLine.p2(), nextLine.p1());
+            l2.translate(l2.dx(), l2.dy());
+            l2.setLength(qt_fixed_to_real(offset));
+            emitLineTo(qt_real_to_fixed(l1.x2()), qt_real_to_fixed(l1.y2()));
+            emitLineTo(qt_real_to_fixed(l2.x2()), qt_real_to_fixed(l2.y2()));
+            emitLineTo(qt_real_to_fixed(l2.x1()), qt_real_to_fixed(l2.y1()));
+
+        } else if (join == RoundJoin) {
+            qfixed offset = m_strokeWidth / 2;
+
+            QLineF shortCut(prevLine.p2(), nextLine.p1());
+            qreal angle = shortCut.angleTo(prevLine);
+            if (type == QLineF::BoundedIntersection || (angle > 90 && !qFuzzyCompare(angle, (qreal)90))) {
+                emitLineTo(focal_x, focal_y);
+                emitLineTo(qt_real_to_fixed(nextLine.x1()), qt_real_to_fixed(nextLine.y1()));
+                return;
+            }
+            qreal l1_on_x = adapted_angle_on_x(prevLine);
+            qreal l2_on_x = adapted_angle_on_x(nextLine);
+
+            qreal sweepLength = qAbs(l2_on_x - l1_on_x);
+
+            int point_count;
+            QPointF curves[15];
+
+            QPointF curve_start =
+                qt_curves_for_arc(QRectF(qt_fixed_to_real(focal_x - offset),
+                                         qt_fixed_to_real(focal_y - offset),
+                                         qt_fixed_to_real(offset * 2),
+                                         qt_fixed_to_real(offset * 2)),
+                                  l1_on_x + 90, -sweepLength,
+                                  curves, &point_count);
+
+//             // 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()));
+
+            for (int i=0; i<point_count; i+=3) {
+                emitCubicTo(qt_real_to_fixed(curves[i].x()),
+                            qt_real_to_fixed(curves[i].y()),
+                            qt_real_to_fixed(curves[i+1].x()),
+                            qt_real_to_fixed(curves[i+1].y()),
+                            qt_real_to_fixed(curves[i+2].x()),
+                            qt_real_to_fixed(curves[i+2].y()));
+            }
+
+            // line to the end of the arc segment, (should also not be needed).
+            emitLineTo(qt_real_to_fixed(nextLine.x1()), qt_real_to_fixed(nextLine.y1()));
+
+        // Same as round join except we know its 180 degrees. Can also optimize this
+        // later based on the addEllipse logic
+        } else if (join == RoundCap) {
+            qfixed offset = m_strokeWidth / 2;
+
+            // first control line
+            QLineF l1 = prevLine;
+            l1.translate(l1.dx(), l1.dy());
+            l1.setLength(QT_PATH_KAPPA * offset);
+
+            // second control line, find through normal between prevLine and focal.
+            QLineF l2(qt_fixed_to_real(focal_x), qt_fixed_to_real(focal_y),
+                      prevLine.x2(), prevLine.y2());
+            l2.translate(-l2.dy(), l2.dx());
+            l2.setLength(QT_PATH_KAPPA * offset);
+
+            emitCubicTo(qt_real_to_fixed(l1.x2()),
+                        qt_real_to_fixed(l1.y2()),
+                        qt_real_to_fixed(l2.x2()),
+                        qt_real_to_fixed(l2.y2()),
+                        qt_real_to_fixed(l2.x1()),
+                        qt_real_to_fixed(l2.y1()));
+
+            // move so that it matches
+            l2 = QLineF(l2.x1(), l2.y1(), l2.x1()-l2.dx(), l2.y1()-l2.dy());
+
+            // last line is parallel to l1 so just shift it down.
+            l1.translate(nextLine.x1() - l1.x1(), nextLine.y1() - l1.y1());
+
+            emitCubicTo(qt_real_to_fixed(l2.x2()),
+                        qt_real_to_fixed(l2.y2()),
+                        qt_real_to_fixed(l1.x2()),
+                        qt_real_to_fixed(l1.y2()),
+                        qt_real_to_fixed(l1.x1()),
+                        qt_real_to_fixed(l1.y1()));
+        } else if (join == SvgMiterJoin) {
+            QLineF shortCut(prevLine.p2(), nextLine.p1());
+            qreal angle = shortCut.angleTo(prevLine);
+            if (type == QLineF::BoundedIntersection || (angle > 90 && !qFuzzyCompare(angle, (qreal)90))) {
+                emitLineTo(focal_x, focal_y);
+                emitLineTo(qt_real_to_fixed(nextLine.x1()), qt_real_to_fixed(nextLine.y1()));
+                return;
+            }
+            QLineF miterLine(QPointF(qt_fixed_to_real(focal_x),
+                                     qt_fixed_to_real(focal_y)), isect);
+            if (type == QLineF::NoIntersection || miterLine.length() > qt_fixed_to_real(m_strokeWidth * m_miterLimit) / 2) {
+                emitLineTo(qt_real_to_fixed(nextLine.x1()),
+                           qt_real_to_fixed(nextLine.y1()));
+            } else {
+                emitLineTo(qt_real_to_fixed(isect.x()), qt_real_to_fixed(isect.y()));
+                emitLineTo(qt_real_to_fixed(nextLine.x1()), qt_real_to_fixed(nextLine.y1()));
+            }
+        } else {
+            Q_ASSERT(!"QStroker::joinPoints(), bad join style...");
+        }
+    }
+}
+
+
+/*
+   Strokes a subpath side using the \a it as source. Results are put into
+   \a stroke. The function returns true if the subpath side was closed.
+   If \a capFirst is true, we will use capPoints instead of joinPoints to
+   connect the first segment, other segments will be joined using joinPoints.
+   This is to put capping in order...
+*/
+template <class Iterator> bool qt_stroke_side(Iterator *it,
+                                              QStroker *stroker,
+                                              bool capFirst,
+                                              QLineF *startTangent)
+{
+    // Used in CurveToElement section below.
+    const int MAX_OFFSET = 16;
+    QBezier offsetCurves[MAX_OFFSET];
+
+    Q_ASSERT(it->hasNext()); // The initaial move to
+    QStrokerOps::Element first_element = it->next();
+    Q_ASSERT(first_element.isMoveTo());
+
+    qfixed2d start = first_element;
+
+#ifdef QPP_STROKE_DEBUG
+    qDebug(" -> (side) [%.2f, %.2f], startPos=%d",
+           qt_fixed_to_real(start.x),
+           qt_fixed_to_real(start.y));
+#endif
+
+    qfixed2d prev = start;
+
+    bool first = true;
+
+    qfixed offset = stroker->strokeWidth() / 2;
+
+    while (it->hasNext()) {
+        QStrokerOps::Element e = it->next();
+
+        // LineToElement
+        if (e.isLineTo()) {
+#ifdef QPP_STROKE_DEBUG
+            qDebug("\n ---> (side) lineto [%.2f, %.2f]", e.x, e.y);
+#endif
+            QLineF line(qt_fixed_to_real(prev.x), qt_fixed_to_real(prev.y),
+                        qt_fixed_to_real(e.x), qt_fixed_to_real(e.y));
+            if (line.p1() != line.p2()) {
+                QLineF normal = line.normalVector();
+                normal.setLength(offset);
+                line.translate(normal.dx(), normal.dy());
+
+                // If we are starting a new subpath, move to correct starting point.
+                if (first) {
+                    if (capFirst)
+                        stroker->joinPoints(prev.x, prev.y, line, stroker->capStyleMode());
+                    else
+                        stroker->emitMoveTo(qt_real_to_fixed(line.x1()), qt_real_to_fixed(line.y1()));
+                    *startTangent = line;
+                    first = false;
+                } else {
+                    stroker->joinPoints(prev.x, prev.y, line, stroker->joinStyleMode());
+                }
+
+                // Add the stroke for this line.
+                stroker->emitLineTo(qt_real_to_fixed(line.x2()),
+                                    qt_real_to_fixed(line.y2()));
+                prev = e;
+            }
+
+        // CurveToElement
+        } else if (e.isCurveTo()) {
+            QStrokerOps::Element cp2 = it->next(); // control point 2
+            QStrokerOps::Element ep = it->next();  // end point
+
+#ifdef QPP_STROKE_DEBUG
+            qDebug("\n ---> (side) cubicTo [%.2f, %.2f]",
+                   qt_fixed_to_real(ep.x),
+                   qt_fixed_to_real(ep.y));
+#endif
+
+            QBezier bezier =
+                QBezier::fromPoints(QPointF(qt_fixed_to_real(prev.x), qt_fixed_to_real(prev.y)),
+                                    QPointF(qt_fixed_to_real(e.x), qt_fixed_to_real(e.y)),
+                                    QPointF(qt_fixed_to_real(cp2.x), qt_fixed_to_real(cp2.y)),
+                                    QPointF(qt_fixed_to_real(ep.x), qt_fixed_to_real(ep.y)));
+
+            int count = bezier.shifted(offsetCurves,
+                                       MAX_OFFSET,
+                                       offset,
+                                       stroker->curveThreshold());
+
+            if (count) {
+                // If we are starting a new subpath, move to correct starting point
+                QLineF tangent = bezier.startTangent();
+                tangent.translate(offsetCurves[0].pt1() - bezier.pt1());
+                if (first) {
+                    QPointF pt = offsetCurves[0].pt1();
+                    if (capFirst) {
+                        stroker->joinPoints(prev.x, prev.y,
+                                            tangent,
+                                            stroker->capStyleMode());
+                    } else {
+                        stroker->emitMoveTo(qt_real_to_fixed(pt.x()),
+                                            qt_real_to_fixed(pt.y()));
+                    }
+                    *startTangent = tangent;
+                    first = false;
+                } else {
+                    stroker->joinPoints(prev.x, prev.y,
+                                        tangent,
+                                        stroker->joinStyleMode());
+                }
+
+                // Add these beziers
+                for (int i=0; i<count; ++i) {
+                    QPointF cp1 = offsetCurves[i].pt2();
+                    QPointF cp2 = offsetCurves[i].pt3();
+                    QPointF ep = offsetCurves[i].pt4();
+                    stroker->emitCubicTo(qt_real_to_fixed(cp1.x()), qt_real_to_fixed(cp1.y()),
+                                         qt_real_to_fixed(cp2.x()), qt_real_to_fixed(cp2.y()),
+                                         qt_real_to_fixed(ep.x()), qt_real_to_fixed(ep.y()));
+                }
+            }
+
+            prev = ep;
+        }
+    }
+
+    if (start == prev) {
+        // closed subpath, join first and last point
+#ifdef QPP_STROKE_DEBUG
+        qDebug("\n ---> (side) closed subpath");
+#endif
+        stroker->joinPoints(prev.x, prev.y, *startTangent, stroker->joinStyleMode());
+        return true;
+    } else {
+#ifdef QPP_STROKE_DEBUG
+        qDebug("\n ---> (side) open subpath");
+#endif
+        return false;
+    }
+}
+
+/*!
+    \internal
+
+    For a given angle in the range [0 .. 90], finds the corresponding parameter t
+    of the prototype cubic bezier arc segment
+    b = fromPoints(QPointF(1, 0), QPointF(1, KAPPA), QPointF(KAPPA, 1), QPointF(0, 1));
+
+    From the bezier equation:
+    b.pointAt(t).x() = (1-t)^3 + t*(1-t)^2 + t^2*(1-t)*KAPPA
+    b.pointAt(t).y() = t*(1-t)^2 * KAPPA + t^2*(1-t) + t^3
+
+    Third degree coefficients:
+    b.pointAt(t).x() = at^3 + bt^2 + ct + d
+    where a = 2-3*KAPPA, b = 3*(KAPPA-1), c = 0, d = 1
+
+    b.pointAt(t).y() = at^3 + bt^2 + ct + d
+    where a = 3*KAPPA-2, b = 6*KAPPA+3, c = 3*KAPPA, d = 0
+
+    Newton's method to find the zero of a function:
+    given a function f(x) and initial guess x_0
+    x_1 = f(x_0) / f'(x_0)
+    x_2 = f(x_1) / f'(x_1)
+    etc...
+*/
+
+qreal qt_t_for_arc_angle(qreal angle)
+{
+    if (qFuzzyIsNull(angle))
+        return 0;
+
+    if (qFuzzyCompare(angle, qreal(90)))
+        return 1;
+
+    qreal radians = Q_PI * angle / 180;
+    qreal cosAngle = qCos(radians);
+    qreal sinAngle = qSin(radians);
+
+    // initial guess
+    qreal tc = angle / 90;
+    // do some iterations of newton's method to approximate cosAngle
+    // finds the zero of the function b.pointAt(tc).x() - cosAngle
+    tc -= ((((2-3*QT_PATH_KAPPA) * tc + 3*(QT_PATH_KAPPA-1)) * tc) * tc + 1 - cosAngle) // value
+         / (((6-9*QT_PATH_KAPPA) * tc + 6*(QT_PATH_KAPPA-1)) * tc); // derivative
+    tc -= ((((2-3*QT_PATH_KAPPA) * tc + 3*(QT_PATH_KAPPA-1)) * tc) * tc + 1 - cosAngle) // value
+         / (((6-9*QT_PATH_KAPPA) * tc + 6*(QT_PATH_KAPPA-1)) * tc); // derivative
+
+    // initial guess
+    qreal ts = tc;
+    // do some iterations of newton's method to approximate sinAngle
+    // finds the zero of the function b.pointAt(tc).y() - sinAngle
+    ts -= ((((3*QT_PATH_KAPPA-2) * ts -  6*QT_PATH_KAPPA + 3) * ts + 3*QT_PATH_KAPPA) * ts - sinAngle)
+         / (((9*QT_PATH_KAPPA-6) * ts + 12*QT_PATH_KAPPA - 6) * ts + 3*QT_PATH_KAPPA);
+    ts -= ((((3*QT_PATH_KAPPA-2) * ts -  6*QT_PATH_KAPPA + 3) * ts + 3*QT_PATH_KAPPA) * ts - sinAngle)
+         / (((9*QT_PATH_KAPPA-6) * ts + 12*QT_PATH_KAPPA - 6) * ts + 3*QT_PATH_KAPPA);
+
+    // use the average of the t that best approximates cosAngle
+    // and the t that best approximates sinAngle
+    qreal t = 0.5 * (tc + ts);
+
+#if 0
+    printf("angle: %f, t: %f\n", angle, t);
+    qreal a, b, c, d;
+    bezierCoefficients(t, a, b, c, d);
+    printf("cosAngle: %.10f, value: %.10f\n", cosAngle, a + b + c * QT_PATH_KAPPA);
+    printf("sinAngle: %.10f, value: %.10f\n", sinAngle, b * QT_PATH_KAPPA + c + d);
+#endif
+
+    return t;
+}
+
+Q_GUI_EXPORT void qt_find_ellipse_coords(const QRectF &r, qreal angle, qreal length,
+                            QPointF* startPoint, QPointF *endPoint);
+
+/*!
+    \internal
+
+    Creates a number of curves for a given arc definition. The arc is
+    defined an arc along the ellipses that fits into \a rect starting
+    at \a startAngle and an arc length of \a sweepLength.
+
+    The function has three out parameters. The return value is the
+    starting point of the arc. The \a curves array represents the list
+    of cubicTo elements up to a maximum of \a point_count. There are of course
+    3 points pr curve.
+*/
+QPointF qt_curves_for_arc(const QRectF &rect, qreal startAngle, qreal sweepLength,
+                       QPointF *curves, int *point_count)
+{
+    Q_ASSERT(point_count);
+    Q_ASSERT(curves);
+
+    *point_count = 0;
+    if (qt_is_nan(rect.x()) || qt_is_nan(rect.y()) || qt_is_nan(rect.width()) || qt_is_nan(rect.height())
+        || qt_is_nan(startAngle) || qt_is_nan(sweepLength)) {
+        qWarning("QPainterPath::arcTo: Adding arc where a parameter is NaN, results are undefined");
+        return QPointF();
+    }
+
+    if (rect.isNull()) {
+        return QPointF();
+    }
+
+    qreal x = rect.x();
+    qreal y = rect.y();
+
+    qreal w = rect.width();
+    qreal w2 = rect.width() / 2;
+    qreal w2k = w2 * QT_PATH_KAPPA;
+
+    qreal h = rect.height();
+    qreal h2 = rect.height() / 2;
+    qreal h2k = h2 * QT_PATH_KAPPA;
+
+    QPointF points[16] =
+    {
+        // start point
+        QPointF(x + w, y + h2),
+
+        // 0 -> 270 degrees
+        QPointF(x + w, y + h2 + h2k),
+        QPointF(x + w2 + w2k, y + h),
+        QPointF(x + w2, y + h),
+
+        // 270 -> 180 degrees
+        QPointF(x + w2 - w2k, y + h),
+        QPointF(x, y + h2 + h2k),
+        QPointF(x, y + h2),
+
+        // 180 -> 90 degrees
+        QPointF(x, y + h2 - h2k),
+        QPointF(x + w2 - w2k, y),
+        QPointF(x + w2, y),
+
+        // 90 -> 0 degrees
+        QPointF(x + w2 + w2k, y),
+        QPointF(x + w, y + h2 - h2k),
+        QPointF(x + w, y + h2)
+    };
+
+    if (sweepLength > 360) sweepLength = 360;
+    else if (sweepLength < -360) sweepLength = -360;
+
+    // Special case fast paths
+    if (startAngle == 0.0) {
+        if (sweepLength == 360.0) {
+            for (int i = 11; i >= 0; --i)
+                curves[(*point_count)++] = points[i];
+            return points[12];
+        } else if (sweepLength == -360.0) {
+            for (int i = 1; i <= 12; ++i)
+                curves[(*point_count)++] = points[i];
+            return points[0];
+        }
+    }
+
+    int startSegment = int(qFloor(startAngle / 90));
+    int endSegment = int(qFloor((startAngle + sweepLength) / 90));
+
+    qreal startT = (startAngle - startSegment * 90) / 90;
+    qreal endT = (startAngle + sweepLength - endSegment * 90) / 90;
+
+    int delta = sweepLength > 0 ? 1 : -1;
+    if (delta < 0) {
+        startT = 1 - startT;
+        endT = 1 - endT;
+    }
+
+    // avoid empty start segment
+    if (qFuzzyIsNull(startT - qreal(1))) {
+        startT = 0;
+        startSegment += delta;
+    }
+
+    // avoid empty end segment
+    if (qFuzzyIsNull(endT)) {
+        endT = 1;
+        endSegment -= delta;
+    }
+
+    startT = qt_t_for_arc_angle(startT * 90);
+    endT = qt_t_for_arc_angle(endT * 90);
+
+    const bool splitAtStart = !qFuzzyIsNull(startT);
+    const bool splitAtEnd = !qFuzzyIsNull(endT - qreal(1));
+
+    const int end = endSegment + delta;
+
+    // empty arc?
+    if (startSegment == end) {
+        const int quadrant = 3 - ((startSegment % 4) + 4) % 4;
+        const int j = 3 * quadrant;
+        return delta > 0 ? points[j + 3] : points[j];
+    }
+
+    QPointF startPoint, endPoint;
+    qt_find_ellipse_coords(rect, startAngle, sweepLength, &startPoint, &endPoint);
+
+    for (int i = startSegment; i != end; i += delta) {
+        const int quadrant = 3 - ((i % 4) + 4) % 4;
+        const int j = 3 * quadrant;
+
+        QBezier b;
+        if (delta > 0)
+            b = QBezier::fromPoints(points[j + 3], points[j + 2], points[j + 1], points[j]);
+        else
+            b = QBezier::fromPoints(points[j], points[j + 1], points[j + 2], points[j + 3]);
+
+        // empty arc?
+        if (startSegment == endSegment && qFuzzyCompare(startT, endT))
+            return startPoint;
+
+        if (i == startSegment) {
+            if (i == endSegment && splitAtEnd)
+                b = b.bezierOnInterval(startT, endT);
+            else if (splitAtStart)
+                b = b.bezierOnInterval(startT, 1);
+        } else if (i == endSegment && splitAtEnd) {
+            b = b.bezierOnInterval(0, endT);
+        }
+
+        // push control points
+        curves[(*point_count)++] = b.pt2();
+        curves[(*point_count)++] = b.pt3();
+        curves[(*point_count)++] = b.pt4();
+    }
+
+    Q_ASSERT(*point_count > 0);
+    curves[*(point_count)-1] = endPoint;
+
+    return startPoint;
+}
+
+
+static inline void qdashstroker_moveTo(qfixed x, qfixed y, void *data) {
+    ((QStroker *) data)->moveTo(x, y);
+}
+
+static inline void qdashstroker_lineTo(qfixed x, qfixed y, void *data) {
+    ((QStroker *) data)->lineTo(x, y);
+}
+
+static inline void qdashstroker_cubicTo(qfixed, qfixed, qfixed, qfixed, qfixed, qfixed, void *) {
+    Q_ASSERT(0);
+//     ((QStroker *) data)->cubicTo(c1x, c1y, c2x, c2y, ex, ey);
+}
+
+
+/*******************************************************************************
+ * QDashStroker members
+ */
+QDashStroker::QDashStroker(QStroker *stroker)
+    : m_stroker(stroker), m_dashOffset(0), m_stroke_width(1), m_miter_limit(1)
+{
+    if (m_stroker) {
+        setMoveToHook(qdashstroker_moveTo);
+        setLineToHook(qdashstroker_lineTo);
+        setCubicToHook(qdashstroker_cubicTo);
+    }
+}
+
+QVector<qfixed> QDashStroker::patternForStyle(Qt::PenStyle style)
+{
+    const qfixed space = 2;
+    const qfixed dot = 1;
+    const qfixed dash = 4;
+
+    QVector<qfixed> pattern;
+
+    switch (style) {
+    case Qt::DashLine:
+        pattern << dash << space;
+        break;
+    case Qt::DotLine:
+        pattern << dot << space;
+        break;
+    case Qt::DashDotLine:
+        pattern << dash << space << dot << space;
+        break;
+    case Qt::DashDotDotLine:
+        pattern << dash << space << dot << space << dot << space;
+        break;
+    default:
+        break;
+    }
+
+    return pattern;
+}
+
+static inline bool lineRectIntersectsRect(qfixed2d p1, qfixed2d p2, const qfixed2d &tl, const qfixed2d &br)
+{
+    return ((p1.x > tl.x || p2.x > tl.x) && (p1.x < br.x || p2.x < br.x)
+        && (p1.y > tl.y || p2.y > tl.y) && (p1.y < br.y || p2.y < br.y));
+}
+
+// If the line intersects the rectangle, this function will return true.
+static bool lineIntersectsRect(qfixed2d p1, qfixed2d p2, const qfixed2d &tl, const qfixed2d &br)
+{
+    if (!lineRectIntersectsRect(p1, p2, tl, br))
+        return false;
+    if (p1.x == p2.x || p1.y == p2.y)
+        return true;
+
+    if (p1.y > p2.y)
+        qSwap(p1, p2); // make p1 above p2
+    qfixed2d u;
+    qfixed2d v;
+    qfixed2d w = {p2.x - p1.x, p2.y - p1.y};
+    if (p1.x < p2.x) {
+        // backslash
+        u.x = tl.x - p1.x; u.y = br.y - p1.y;
+        v.x = br.x - p1.x; v.y = tl.y - p1.y;
+    } else {
+        // slash
+        u.x = tl.x - p1.x; u.y = tl.y - p1.y;
+        v.x = br.x - p1.x; v.y = br.y - p1.y;
+    }
+#if defined(QFIXED_IS_26_6) || defined(QFIXED_IS_16_16)
+    qint64 val1 = qint64(u.x) * qint64(w.y) - qint64(u.y) * qint64(w.x);
+    qint64 val2 = qint64(v.x) * qint64(w.y) - qint64(v.y) * qint64(w.x);
+    return (val1 < 0 && val2 > 0) || (val1 > 0 && val2 < 0);
+#elif defined(QFIXED_IS_32_32)
+    // Cannot do proper test because it may overflow.
+    return true;
+#else
+    qreal val1 = u.x * w.y - u.y * w.x;
+    qreal val2 = v.x * w.y - v.y * w.x;
+    return (val1 < 0 && val2 > 0) || (val1 > 0 && val2 < 0);
+#endif
+}
+
+void QDashStroker::processCurrentSubpath()
+{
+    int dashCount = qMin(m_dashPattern.size(), 32);
+    qfixed dashes[32];
+
+    if (m_stroker) {
+        m_customData = m_stroker;
+        m_stroke_width = m_stroker->strokeWidth();
+        m_miter_limit = m_stroker->miterLimit();
+    }
+
+    qreal longestLength = 0;
+    qreal sumLength = 0;
+    for (int i=0; i<dashCount; ++i) {
+        dashes[i] = qMax(m_dashPattern.at(i), qreal(0)) * m_stroke_width;
+        sumLength += dashes[i];
+        if (dashes[i] > longestLength)
+            longestLength = dashes[i];
+    }
+
+    if (qFuzzyIsNull(sumLength))
+        return;
+
+    qreal invSumLength = qreal(1) / sumLength;
+
+    Q_ASSERT(dashCount > 0);
+
+    dashCount = dashCount & -2; // Round down to even number
+
+    int idash = 0; // Index to current dash
+    qreal pos = 0; // The position on the curve, 0 <= pos <= path.length
+    qreal elen = 0; // element length
+    qreal doffset = m_dashOffset * m_stroke_width;
+
+    // make sure doffset is in range [0..sumLength)
+    doffset -= qFloor(doffset * invSumLength) * sumLength;
+
+    while (doffset >= dashes[idash]) {
+        doffset -= dashes[idash];
+        if (++idash >= dashCount)
+            idash = 0;
+    }
+
+    qreal estart = 0; // The elements starting position
+    qreal estop = 0; // The element stop position
+
+    QLineF cline;
+
+    QPainterPath dashPath;
+
+    QSubpathFlatIterator it(&m_elements, m_dashThreshold);
+    qfixed2d prev = it.next();
+
+    bool clipping = !m_clip_rect.isEmpty();
+    qfixed2d move_to_pos = prev;
+    qfixed2d line_to_pos;
+
+    // Pad to avoid clipping the borders of thick pens.
+    qfixed padding = qt_real_to_fixed(qMax(m_stroke_width, m_miter_limit) * longestLength);
+    qfixed2d clip_tl = { qt_real_to_fixed(m_clip_rect.left()) - padding,
+                         qt_real_to_fixed(m_clip_rect.top()) - padding };
+    qfixed2d clip_br = { qt_real_to_fixed(m_clip_rect.right()) + padding ,
+                         qt_real_to_fixed(m_clip_rect.bottom()) + padding };
+
+    bool hasMoveTo = false;
+    while (it.hasNext()) {
+        QStrokerOps::Element e = it.next();
+
+        Q_ASSERT(e.isLineTo());
+        cline = QLineF(qt_fixed_to_real(prev.x),
+                       qt_fixed_to_real(prev.y),
+                       qt_fixed_to_real(e.x),
+                       qt_fixed_to_real(e.y));
+        elen = cline.length();
+
+        estop = estart + elen;
+
+        bool done = pos >= estop;
+
+        if (clipping) {
+            // Check if the entire line can be clipped away.
+            if (!lineIntersectsRect(prev, e, clip_tl, clip_br)) {
+                // Cut away full dash sequences.
+                elen -= qFloor(elen * invSumLength) * sumLength;
+                // Update dash offset.
+                while (!done) {
+                    qreal dpos = pos + dashes[idash] - doffset - estart;
+
+                    Q_ASSERT(dpos >= 0);
+
+                    if (dpos > elen) { // dash extends this line
+                        doffset = dashes[idash] - (dpos - elen); // subtract the part already used
+                        pos = estop; // move pos to next path element
+                        done = true;
+                    } else { // Dash is on this line
+                        pos = dpos + estart;
+                        done = pos >= estop;
+                        if (++idash >= dashCount)
+                            idash = 0;
+                        doffset = 0; // full segment so no offset on next.
+                    }
+                }
+                hasMoveTo = false;
+                move_to_pos = e;
+            }
+        }
+
+        // Dash away...
+        while (!done) {
+            QPointF p2;
+
+            bool has_offset = doffset > 0;
+            bool evenDash = (idash & 1) == 0;
+            qreal dpos = pos + dashes[idash] - doffset - estart;
+
+            Q_ASSERT(dpos >= 0);
+
+            if (dpos > elen) { // dash extends this line
+                doffset = dashes[idash] - (dpos - elen); // subtract the part already used
+                pos = estop; // move pos to next path element
+                done = true;
+                p2 = cline.p2();
+            } else { // Dash is on this line
+                p2 = cline.pointAt(dpos/elen);
+                pos = dpos + estart;
+                done = pos >= estop;
+                if (++idash >= dashCount)
+                    idash = 0;
+                doffset = 0; // full segment so no offset on next.
+            }
+
+            if (evenDash) {
+                line_to_pos.x = qt_real_to_fixed(p2.x());
+                line_to_pos.y = qt_real_to_fixed(p2.y());
+
+                if (!clipping
+                    || lineRectIntersectsRect(move_to_pos, line_to_pos, clip_tl, clip_br))
+                {
+                    // If we have an offset, we're continuing a dash
+                    // from a previous element and should only
+                    // continue the current dash, without starting a
+                    // new subpath.
+                    if (!has_offset || !hasMoveTo) {
+                        emitMoveTo(move_to_pos.x, move_to_pos.y);
+                        hasMoveTo = true;
+                    }
+
+                    emitLineTo(line_to_pos.x, line_to_pos.y);
+                } else {
+                    hasMoveTo = false;
+                }
+                move_to_pos = line_to_pos;
+            } else {
+                move_to_pos.x = qt_real_to_fixed(p2.x());
+                move_to_pos.y = qt_real_to_fixed(p2.y());
+            }
+        }
+
+        // Shuffle to the next cycle...
+        estart = estop;
+        prev = e;
+    }
+
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qstroker_p.h b/src/gui/painting/qstroker_p.h
new file mode 100644
index 0000000000..8344f6cf86
--- /dev/null
+++ b/src/gui/painting/qstroker_p.h
@@ -0,0 +1,394 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QSTROKER_P_H
+#define QSTROKER_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "QtGui/qpainterpath.h"
+#include "private/qdatabuffer_p.h"
+#include "private/qnumeric_p.h"
+
+QT_BEGIN_NAMESPACE
+
+// #define QFIXED_IS_26_6
+
+#if defined QFIXED_IS_26_6
+typedef int qfixed;
+#define qt_real_to_fixed(real) qfixed(real * 64)
+#define qt_int_to_fixed(real) qfixed(int(real) << 6)
+#define qt_fixed_to_real(fixed) qreal(fixed / qreal(64))
+#define qt_fixed_to_int(fixed) int(fixed >> 6)
+struct qfixed2d
+{
+    qfixed x;
+    qfixed y;
+
+    bool operator==(const qfixed2d &other) const { return x == other.x && y == other.y; }
+};
+#elif defined QFIXED_IS_32_32
+typedef qint64 qfixed;
+#define qt_real_to_fixed(real) qfixed(real * double(qint64(1) << 32))
+#define qt_fixed_to_real(fixed) qreal(fixed / double(qint64(1) << 32))
+struct qfixed2d
+{
+    qfixed x;
+    qfixed y;
+
+    bool operator==(const qfixed2d &other) const { return x == other.x && y == other.y; }
+};
+#elif defined QFIXED_IS_16_16
+typedef int qfixed;
+#define qt_real_to_fixed(real) qfixed(real * qreal(1 << 16))
+#define qt_fixed_to_real(fixed) qreal(fixed / qreal(1 << 16))
+struct qfixed2d
+{
+    qfixed x;
+    qfixed y;
+
+    bool operator==(const qfixed2d &other) const { return x == other.x && y == other.y; }
+};
+#else
+typedef qreal qfixed;
+#define qt_real_to_fixed(real) qfixed(real)
+#define qt_fixed_to_real(fixed) fixed
+struct qfixed2d
+{
+    qfixed x;
+    qfixed y;
+
+    bool operator==(const qfixed2d &other) const { return qFuzzyCompare(x, other.x)
+                                                       && qFuzzyCompare(y, other.y); }
+};
+#endif
+
+#define QT_PATH_KAPPA 0.5522847498
+
+QPointF qt_curves_for_arc(const QRectF &rect, qreal startAngle, qreal sweepLength,
+                          QPointF *controlPoints, int *point_count);
+
+qreal qt_t_for_arc_angle(qreal angle);
+
+typedef void (*qStrokerMoveToHook)(qfixed x, qfixed y, void *data);
+typedef void (*qStrokerLineToHook)(qfixed x, qfixed y, void *data);
+typedef void (*qStrokerCubicToHook)(qfixed c1x, qfixed c1y,
+                                    qfixed c2x, qfixed c2y,
+                                    qfixed ex, qfixed ey,
+                                    void *data);
+
+// qtransform.cpp
+Q_GUI_EXPORT bool qt_scaleForTransform(const QTransform &transform, qreal *scale);
+
+class Q_GUI_EXPORT QStrokerOps
+{
+public:
+    struct Element {
+        QPainterPath::ElementType type;
+        qfixed x;
+        qfixed y;
+
+        inline bool isMoveTo() const { return type == QPainterPath::MoveToElement; }
+        inline bool isLineTo() const { return type == QPainterPath::LineToElement; }
+        inline bool isCurveTo() const { return type == QPainterPath::CurveToElement; }
+
+        operator qfixed2d () { qfixed2d pt = { x, y }; return pt; }
+    };
+
+    QStrokerOps();
+    virtual ~QStrokerOps();
+
+    void setMoveToHook(qStrokerMoveToHook moveToHook) { m_moveTo = moveToHook; }
+    void setLineToHook(qStrokerLineToHook lineToHook) { m_lineTo = lineToHook; }
+    void setCubicToHook(qStrokerCubicToHook cubicToHook) { m_cubicTo = cubicToHook; }
+
+    virtual void begin(void *customData);
+    virtual void end();
+
+    inline void moveTo(qfixed x, qfixed y);
+    inline void lineTo(qfixed x, qfixed y);
+    inline void cubicTo(qfixed x1, qfixed y1, qfixed x2, qfixed y2, qfixed ex, qfixed ey);
+
+    void strokePath(const QPainterPath &path, void *data, const QTransform &matrix);
+    void strokePolygon(const QPointF *points, int pointCount, bool implicit_close,
+                       void *data, const QTransform &matrix);
+    void strokeEllipse(const QRectF &ellipse, void *data, const QTransform &matrix);
+
+    QRectF clipRect() const { return m_clip_rect; }
+    void setClipRect(const QRectF &clip) { m_clip_rect = clip; }
+
+    void setCurveThresholdFromTransform(const QTransform &transform)
+    {
+        qreal scale;
+        qt_scaleForTransform(transform, &scale);
+        m_dashThreshold = scale == 0 ? qreal(0.5) : (qreal(0.5) / scale);
+    }
+
+    void setCurveThreshold(qfixed threshold) { m_curveThreshold = threshold; }
+    qfixed curveThreshold() const { return m_curveThreshold; }
+
+protected:
+    inline void emitMoveTo(qfixed x, qfixed y);
+    inline void emitLineTo(qfixed x, qfixed y);
+    inline void emitCubicTo(qfixed c1x, qfixed c1y, qfixed c2x, qfixed c2y, qfixed ex, qfixed ey);
+
+    virtual void processCurrentSubpath() = 0;
+    QDataBuffer<Element> m_elements;
+
+    QRectF m_clip_rect;
+    qfixed m_curveThreshold;
+    qfixed m_dashThreshold;
+
+    void *m_customData;
+    qStrokerMoveToHook m_moveTo;
+    qStrokerLineToHook m_lineTo;
+    qStrokerCubicToHook m_cubicTo;
+
+};
+
+class Q_GUI_EXPORT QStroker : public QStrokerOps
+{
+public:
+
+    enum LineJoinMode {
+        FlatJoin,
+        SquareJoin,
+        MiterJoin,
+        RoundJoin,
+        RoundCap,
+        SvgMiterJoin
+    };
+
+    QStroker();
+    ~QStroker();
+
+    void setStrokeWidth(qfixed width) { m_strokeWidth = width; }
+    qfixed strokeWidth() const { return m_strokeWidth; }
+
+    void setCapStyle(Qt::PenCapStyle capStyle) { m_capStyle = joinModeForCap(capStyle); }
+    Qt::PenCapStyle capStyle() const { return capForJoinMode(m_capStyle); }
+    LineJoinMode capStyleMode() const { return m_capStyle; }
+
+    void setJoinStyle(Qt::PenJoinStyle style) { m_joinStyle = joinModeForJoin(style); }
+    Qt::PenJoinStyle joinStyle() const { return joinForJoinMode(m_joinStyle); }
+    LineJoinMode joinStyleMode() const { return m_joinStyle; }
+
+    void setMiterLimit(qfixed length) { m_miterLimit = length; }
+    qfixed miterLimit() const { return m_miterLimit; }
+
+    void joinPoints(qfixed x, qfixed y, const QLineF &nextLine, LineJoinMode join);
+    inline void emitMoveTo(qfixed x, qfixed y);
+    inline void emitLineTo(qfixed x, qfixed y);
+    inline void emitCubicTo(qfixed c1x, qfixed c1y, qfixed c2x, qfixed c2y, qfixed ex, qfixed ey);
+
+protected:
+    static Qt::PenCapStyle capForJoinMode(LineJoinMode mode);
+    static LineJoinMode joinModeForCap(Qt::PenCapStyle);
+
+    static Qt::PenJoinStyle joinForJoinMode(LineJoinMode mode);
+    static LineJoinMode joinModeForJoin(Qt::PenJoinStyle joinStyle);
+
+    virtual void processCurrentSubpath();
+
+    qfixed m_strokeWidth;
+    qfixed m_miterLimit;
+
+    LineJoinMode m_capStyle;
+    LineJoinMode m_joinStyle;
+
+    qfixed m_back1X;
+    qfixed m_back1Y;
+
+    qfixed m_back2X;
+    qfixed m_back2Y;
+};
+
+class Q_GUI_EXPORT QDashStroker : public QStrokerOps
+{
+public:
+    QDashStroker(QStroker *stroker);
+
+    QStroker *stroker() const { return m_stroker; }
+
+    static QVector<qfixed> patternForStyle(Qt::PenStyle style);
+
+    void setDashPattern(const QVector<qfixed> &dashPattern) { m_dashPattern = dashPattern; }
+    QVector<qfixed> dashPattern() const { return m_dashPattern; }
+
+    void setDashOffset(qreal offset) { m_dashOffset = offset; }
+    qreal dashOffset() const { return m_dashOffset; }
+
+    virtual void begin(void *data);
+    virtual void end();
+
+    inline void setStrokeWidth(qreal width) { m_stroke_width = width; }
+    inline void setMiterLimit(qreal limit) { m_miter_limit = limit; }
+
+protected:
+    virtual void processCurrentSubpath();
+
+    QStroker *m_stroker;
+    QVector<qfixed> m_dashPattern;
+    qreal m_dashOffset;
+
+    qreal m_stroke_width;
+    qreal m_miter_limit;
+};
+
+
+/*******************************************************************************
+ * QStrokerOps inline membmers
+ */
+
+inline void QStrokerOps::emitMoveTo(qfixed x, qfixed y)
+{
+    Q_ASSERT(m_moveTo);
+    m_moveTo(x, y, m_customData);
+}
+
+inline void QStrokerOps::emitLineTo(qfixed x, qfixed y)
+{
+    Q_ASSERT(m_lineTo);
+    m_lineTo(x, y, m_customData);
+}
+
+inline void QStrokerOps::emitCubicTo(qfixed c1x, qfixed c1y, qfixed c2x, qfixed c2y, qfixed ex, qfixed ey)
+{
+    Q_ASSERT(m_cubicTo);
+    m_cubicTo(c1x, c1y, c2x, c2y, ex, ey, m_customData);
+}
+
+inline void QStrokerOps::moveTo(qfixed x, qfixed y)
+{
+    if (m_elements.size()>1)
+        processCurrentSubpath();
+    m_elements.reset();
+    Element e = { QPainterPath::MoveToElement, x, y };
+    m_elements.add(e);
+}
+
+inline void QStrokerOps::lineTo(qfixed x, qfixed y)
+{
+    Element e = { QPainterPath::LineToElement, x, y };
+    m_elements.add(e);
+}
+
+inline void QStrokerOps::cubicTo(qfixed x1, qfixed y1, qfixed x2, qfixed y2, qfixed ex, qfixed ey)
+{
+    Element c1 = { QPainterPath::CurveToElement, x1, y1 };
+    Element c2 = { QPainterPath::CurveToDataElement, x2, y2 };
+    Element e = { QPainterPath::CurveToDataElement, ex, ey };
+    m_elements.add(c1);
+    m_elements.add(c2);
+    m_elements.add(e);
+}
+
+/*******************************************************************************
+ * QStroker inline members
+ */
+inline void QStroker::emitMoveTo(qfixed x, qfixed y)
+{
+    m_back2X = m_back1X;
+    m_back2Y = m_back1Y;
+    m_back1X = x;
+    m_back1Y = y;
+    QStrokerOps::emitMoveTo(x, y);
+}
+
+inline void QStroker::emitLineTo(qfixed x, qfixed y)
+{
+    m_back2X = m_back1X;
+    m_back2Y = m_back1Y;
+    m_back1X = x;
+    m_back1Y = y;
+    QStrokerOps::emitLineTo(x, y);
+}
+
+inline void QStroker::emitCubicTo(qfixed c1x, qfixed c1y,
+                                  qfixed c2x, qfixed c2y,
+                                  qfixed ex, qfixed ey)
+{
+    if (c2x == ex && c2y == ey) {
+        if (c1x == ex && c1y == ey) {
+            m_back2X = m_back1X;
+            m_back2Y = m_back1Y;
+        } else {
+            m_back2X = c1x;
+            m_back2Y = c1y;
+        }
+    } else {
+        m_back2X = c2x;
+        m_back2Y = c2y;
+    }
+    m_back1X = ex;
+    m_back1Y = ey;
+    QStrokerOps::emitCubicTo(c1x, c1y, c2x, c2y, ex, ey);
+}
+
+/*******************************************************************************
+ * QDashStroker inline members
+ */
+inline void QDashStroker::begin(void *data)
+{
+    if (m_stroker)
+        m_stroker->begin(data);
+    QStrokerOps::begin(data);
+}
+
+inline void QDashStroker::end()
+{
+    QStrokerOps::end();
+    if (m_stroker)
+        m_stroker->end();
+}
+
+QT_END_NAMESPACE
+
+#endif // QSTROKER_P_H
diff --git a/src/gui/painting/qstylepainter.cpp b/src/gui/painting/qstylepainter.cpp
new file mode 100644
index 0000000000..c8f9d05315
--- /dev/null
+++ b/src/gui/painting/qstylepainter.cpp
@@ -0,0 +1,176 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qstylepainter.h"
+
+QT_BEGIN_NAMESPACE
+
+/*!
+    \class QStylePainter
+
+    \brief The QStylePainter class is a convenience class for drawing QStyle
+    elements inside a widget.
+
+    \ingroup appearance
+    \ingroup painting
+
+    QStylePainter extends QPainter with a set of high-level \c
+    draw...() functions implemented on top of QStyle's API. The
+    advantage of using QStylePainter is that the parameter lists get
+    considerably shorter. Whereas a QStyle object must be able to
+    draw on any widget using any painter (because the application
+    normally has one QStyle object shared by all widget), a
+    QStylePainter is initialized with a widget, eliminating the need
+    to specify the QWidget, the QPainter, and the QStyle for every
+    function call.
+
+    Example using QStyle directly:
+
+    \snippet doc/src/snippets/styles/styles.cpp 1
+
+    Example using QStylePainter:
+
+    \snippet doc/src/snippets/styles/styles.cpp 0
+    \snippet doc/src/snippets/styles/styles.cpp 4
+    \snippet doc/src/snippets/styles/styles.cpp 6
+
+    \sa QStyle, QStyleOption
+*/
+
+/*!
+    \fn QStylePainter::QStylePainter()
+
+    Constructs a QStylePainter.
+*/
+
+/*!
+    \fn QStylePainter::QStylePainter(QWidget *widget)
+
+    Construct a QStylePainter using widget \a widget for its paint device.
+*/
+
+/*!
+    \fn QStylePainter::QStylePainter(QPaintDevice *pd, QWidget *widget)
+
+    Construct a QStylePainter using \a pd for its paint device, and
+    attributes from \a widget.
+*/
+
+
+/*!
+    \fn bool QStylePainter::begin(QWidget *widget)
+
+    Begin painting operations on the specified \a widget.
+    Returns true if the painter is ready to use; otherwise returns false.
+
+    This is automatically called by the constructor that takes a QWidget.
+*/
+
+/*!
+    \fn bool QStylePainter::begin(QPaintDevice *pd, QWidget *widget)
+    \overload
+
+    Begin painting operations on paint device \a pd as if it was \a
+    widget.
+
+    This is automatically called by the constructor that
+    takes a QPaintDevice and a QWidget.
+*/
+
+
+/*!
+    \fn void QStylePainter::drawPrimitive(QStyle::PrimitiveElement pe, const QStyleOption &option)
+
+    Use the widget's style to draw a primitive element \a pe specified by QStyleOption \a option.
+
+    \sa QStyle::drawPrimitive()
+*/
+
+/*!
+    \fn void QStylePainter::drawControl(QStyle::ControlElement ce, const QStyleOption &option)
+
+    Use the widget's style to draw a control element \a ce specified by QStyleOption \a option.
+
+    \sa QStyle::drawControl()
+*/
+
+/*!
+  \fn void QStylePainter::drawComplexControl(QStyle::ComplexControl cc,
+                                             const QStyleOptionComplex &option)
+
+    Use the widget's style to draw a complex control \a cc specified by the
+    QStyleOptionComplex \a option.
+
+    \sa QStyle::drawComplexControl()
+*/
+
+/*!
+    \fn void QStylePainter::drawItemText(const QRect &rect, int flags, const QPalette &pal,
+                                         bool enabled, const QString &text,
+                                         QPalette::ColorRole textRole = QPalette::NoRole)
+
+    Draws the \a text in rectangle \a rect and palette \a pal.
+    The text is aligned and wrapped according to \a
+    flags.
+
+    The pen color is specified with \a textRole. The \a enabled bool
+    indicates whether or not the item is enabled; when reimplementing
+    this bool should influence how the item is drawn.
+
+    \sa QStyle::drawItemText(), Qt::Alignment
+*/
+
+/*!
+    \fn void QStylePainter::drawItemPixmap(const QRect &rect, int flags, const QPixmap &pixmap)
+
+    Draws the \a pixmap in rectangle \a rect.
+    The pixmap is aligned according to \a flags.
+
+    \sa QStyle::drawItemPixmap(), Qt::Alignment
+*/
+
+/*!
+    \fn QStyle *QStylePainter::style() const
+
+    Return the current style used by the QStylePainter.
+*/
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qstylepainter.h b/src/gui/painting/qstylepainter.h
new file mode 100644
index 0000000000..0fc3f2b4b9
--- /dev/null
+++ b/src/gui/painting/qstylepainter.h
@@ -0,0 +1,112 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QSTYLEPAINTER_H
+#define QSTYLEPAINTER_H
+
+#include <QtGui/qpainter.h>
+#include <QtGui/qstyle.h>
+#include <QtGui/qwidget.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+class QStylePainter : public QPainter
+{
+public:
+    inline QStylePainter() : QPainter(), widget(0), wstyle(0) {}
+    inline explicit QStylePainter(QWidget *w) { begin(w, w); }
+    inline QStylePainter(QPaintDevice *pd, QWidget *w) { begin(pd, w); }
+    inline bool begin(QWidget *w) { return begin(w, w); }
+    inline bool begin(QPaintDevice *pd, QWidget *w) {
+        Q_ASSERT_X(w, "QStylePainter::QStylePainter", "Widget must be non-zero");
+        widget = w;
+        wstyle = w->style();
+        return QPainter::begin(pd);
+    };
+    inline void drawPrimitive(QStyle::PrimitiveElement pe, const QStyleOption &opt);
+    inline void drawControl(QStyle::ControlElement ce, const QStyleOption &opt);
+    inline void drawComplexControl(QStyle::ComplexControl cc, const QStyleOptionComplex &opt);
+    inline void drawItemText(const QRect &r, int flags, const QPalette &pal, bool enabled,
+                             const QString &text, QPalette::ColorRole textRole = QPalette::NoRole);
+    inline void drawItemPixmap(const QRect &r, int flags, const QPixmap &pixmap);
+    inline QStyle *style() const { return wstyle; }
+
+private:
+    QWidget *widget;
+    QStyle *wstyle;
+    Q_DISABLE_COPY(QStylePainter)
+};
+
+void QStylePainter::drawPrimitive(QStyle::PrimitiveElement pe, const QStyleOption &opt)
+{
+    wstyle->drawPrimitive(pe, &opt, this, widget);
+}
+
+void QStylePainter::drawControl(QStyle::ControlElement ce, const QStyleOption &opt)
+{
+    wstyle->drawControl(ce, &opt, this, widget);
+}
+
+void QStylePainter::drawComplexControl(QStyle::ComplexControl cc, const QStyleOptionComplex &opt)
+{
+    wstyle->drawComplexControl(cc, &opt, this, widget);
+}
+
+void QStylePainter::drawItemText(const QRect &r, int flags, const QPalette &pal, bool enabled,
+                                 const QString &text, QPalette::ColorRole textRole)
+{
+    wstyle->drawItemText(this, r, flags, pal, enabled, text, textRole);
+}
+
+void QStylePainter::drawItemPixmap(const QRect &r, int flags, const QPixmap &pixmap)
+{
+    wstyle->drawItemPixmap(this, r, flags, pixmap);
+}
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QSTYLEPAINTER_H
diff --git a/src/gui/painting/qtessellator.cpp b/src/gui/painting/qtessellator.cpp
new file mode 100644
index 0000000000..328f4dd96a
--- /dev/null
+++ b/src/gui/painting/qtessellator.cpp
@@ -0,0 +1,1498 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qtessellator_p.h"
+
+#include <QRect>
+#include <QList>
+#include <QDebug>
+
+#include <qmath.h>
+#include <limits.h>
+
+QT_BEGIN_NAMESPACE
+
+//#define DEBUG
+#ifdef DEBUG
+#define QDEBUG qDebug
+#else
+#define QDEBUG if (1){} else qDebug
+#endif
+
+static const bool emit_clever = true;
+static const bool mark_clever = false;
+
+enum VertexFlags {
+    LineBeforeStarts = 0x1,
+    LineBeforeEnds = 0x2,
+    LineBeforeHorizontal = 0x4,
+    LineAfterStarts = 0x8,
+    LineAfterEnds = 0x10,
+    LineAfterHorizontal = 0x20
+};
+
+
+
+class QTessellatorPrivate {
+public:
+    struct Vertices;
+
+    QTessellatorPrivate() {}
+
+    QRectF collectAndSortVertices(const QPointF *points, int *maxActiveEdges);
+    void cancelCoincidingEdges();
+
+    void emitEdges(QTessellator *tessellator);
+    void processIntersections();
+    void removeEdges();
+    void addEdges();
+    void addIntersections();
+
+    struct Vertex : public QTessellator::Vertex
+    {
+        int flags;
+    };
+
+    struct Intersection
+    {
+        Q27Dot5 y;
+        int edge;
+        bool operator <(const Intersection &other) const {
+            if (y != other.y)
+                return y < other.y;
+            return edge < other.edge;
+        }
+    };
+    struct IntersectionLink
+    {
+        int next;
+        int prev;
+    };
+    typedef QMap<Intersection, IntersectionLink> Intersections;
+
+    struct Edge {
+        Edge(const Vertices &v, int _edge);
+        int edge;
+        const Vertex *v0;
+        const Vertex *v1;
+        Q27Dot5 y_left;
+        Q27Dot5 y_right;
+        signed int winding : 8;
+        bool mark;
+        bool free;
+        bool intersect_left;
+        bool intersect_right;
+        bool isLeftOf(const Edge &other, Q27Dot5 y) const;
+        Q27Dot5 positionAt(Q27Dot5 y) const;
+        bool intersect(const Edge &other, Q27Dot5 *y, bool *det_positive) const;
+
+    };
+
+    class EdgeSorter
+    {
+    public:
+        EdgeSorter(int _y) : y(_y) {}
+        bool operator() (const Edge *e1, const Edge *e2);
+        int y;
+    };
+
+    class Scanline {
+    public:
+        Scanline();
+        ~Scanline();
+
+        void init(int maxActiveEdges);
+        void done();
+
+        int findEdgePosition(Q27Dot5 x, Q27Dot5 y) const;
+        int findEdgePosition(const Edge &e) const;
+        int findEdge(int edge) const;
+        void clearMarks();
+
+        void swap(int p1, int p2) {
+            Edge *tmp = edges[p1];
+            edges[p1] = edges[p2];
+            edges[p2] = tmp;
+        }
+        void insert(int pos, const Edge &e);
+        void removeAt(int pos);
+        void markEdges(int pos1, int pos2);
+
+        void prepareLine();
+        void lineDone();
+
+        Edge **old;
+        int old_size;
+
+        Edge **edges;
+        int size;
+
+    private:
+        Edge *edge_table;
+        int first_unused;
+        int max_edges;
+        enum { default_alloc = 32 };
+    };
+
+    struct Vertices {
+        enum { default_alloc = 128 };
+        Vertices();
+        ~Vertices();
+        void init(int maxVertices);
+        void done();
+        Vertex *storage;
+        Vertex **sorted;
+
+        Vertex *operator[] (int i) { return storage + i; }
+        const Vertex *operator[] (int i) const { return storage + i; }
+        int position(const Vertex *v) const {
+            return v - storage;
+        }
+        Vertex *next(Vertex *v) {
+            ++v;
+            if (v == storage + nPoints)
+                v = storage;
+            return v;
+        }
+        const Vertex *next(const Vertex *v) const {
+            ++v;
+            if (v == storage + nPoints)
+                v = storage;
+            return v;
+        }
+        int nextPos(const Vertex *v) const {
+            ++v;
+            if (v == storage + nPoints)
+                return 0;
+            return v - storage;
+        }
+        Vertex *prev(Vertex *v) {
+            if (v == storage)
+                v = storage + nPoints;
+            --v;
+            return v;
+        }
+        const Vertex *prev(const Vertex *v) const {
+            if (v == storage)
+                v = storage + nPoints;
+            --v;
+            return v;
+        }
+        int prevPos(const Vertex *v) const {
+            if (v == storage)
+                v = storage + nPoints;
+            --v;
+            return v - storage;
+        }
+        int nPoints;
+        int allocated;
+    };
+    Vertices vertices;
+    Intersections intersections;
+    Scanline scanline;
+    bool winding;
+    Q27Dot5 y;
+    int currentVertex;
+
+private:
+    void addIntersection(const Edge *e1, const Edge *e2);
+    bool edgeInChain(Intersection i, int edge);
+};
+
+
+QTessellatorPrivate::Edge::Edge(const QTessellatorPrivate::Vertices &vertices, int edge)
+{
+    this->edge = edge;
+    intersect_left = intersect_right = true;
+    mark = false;
+    free = false;
+
+    v0 = vertices[edge];
+    v1 = vertices.next(v0);
+
+    Q_ASSERT(v0->y != v1->y);
+
+    if (v0->y > v1->y) {
+        qSwap(v0, v1);
+        winding = -1;
+    } else {
+        winding = 1;
+    }
+    y_left = y_right = v0->y;
+}
+
+// This is basically the algorithm from graphics gems. The algorithm
+// is cubic in the coordinates at one place.  Since we use 64bit
+// integers, this implies, that the allowed range for our coordinates
+// is limited to 21 bits.  With 5 bits behind the decimal, this
+// implies that differences in coordaintes can range from 2*SHORT_MIN
+// to 2*SHORT_MAX, giving us efficiently a coordinate system from
+// SHORT_MIN to SHORT_MAX.
+//
+
+// WARNING: It's absolutely critical that the intersect() and isLeftOf() methods use
+// exactly the same algorithm to calulate yi. It's also important to be sure the algorithms
+// are transitive (ie. the conditions below are true for all input data):
+//
+// a.intersect(b) == b.intersect(a)
+// a.isLeftOf(b) != b.isLeftOf(a)
+//
+// This is tricky to get right, so be very careful when changing anything in here!
+
+static inline bool sameSign(qint64 a, qint64 b) {
+    return (((qint64) ((quint64) a ^ (quint64) b)) >= 0 );
+}
+
+bool QTessellatorPrivate::Edge::intersect(const Edge &other, Q27Dot5 *y, bool *det_positive) const
+{
+    qint64 a1 = v1->y - v0->y;
+    qint64 b1 = v0->x - v1->x;
+
+    qint64 a2 = other.v1->y - other.v0->y;
+    qint64 b2 = other.v0->x - other.v1->x;
+
+    qint64 det = a1 * b2 - a2 * b1;
+    if (det == 0)
+        return false;
+
+    qint64 c1 = qint64(v1->x) * v0->y - qint64(v0->x) * v1->y;
+
+    qint64 r3 = a1 * other.v0->x + b1 * other.v0->y + c1;
+    qint64 r4 = a1 * other.v1->x + b1 * other.v1->y + c1;
+
+    // Check signs of r3 and r4.  If both point 3 and point 4 lie on
+    // same side of line 1, the line segments do not intersect.
+    QDEBUG() << "        " << r3 << r4;
+    if (r3 != 0 && r4 != 0 && sameSign( r3, r4 ))
+        return false;
+
+    qint64 c2 = qint64(other.v1->x) * other.v0->y - qint64(other.v0->x) * other.v1->y;
+
+    qint64 r1 = a2 * v0->x + b2 * v0->y + c2;
+    qint64 r2 = a2 * v1->x + b2 * v1->y + c2;
+
+    // Check signs of r1 and r2.  If both point 1 and point 2 lie
+    // on same side of second line segment, the line segments do not intersect.
+    QDEBUG() << "        " << r1 << r2;
+    if (r1 != 0 && r2 != 0 && sameSign( r1, r2 ))
+        return false;
+
+    // The det/2 is to get rounding instead of truncating.  It
+    // is added or subtracted to the numerator, depending upon the
+    // sign of the numerator.
+    qint64 offset = det < 0 ? -det : det;
+    offset >>= 1;
+
+    qint64 num = a2 * c1 - a1 * c2;
+    *y = ( num < 0 ? num - offset : num + offset ) / det;
+
+    *det_positive = (det > 0);
+
+    return true;
+}
+
+#undef SAME_SIGNS
+
+bool QTessellatorPrivate::Edge::isLeftOf(const Edge &other, Q27Dot5 y) const
+{
+//     QDEBUG() << "isLeftOf" << edge << other.edge << y;
+    qint64 a1 = v1->y - v0->y;
+    qint64 b1 = v0->x - v1->x;
+    qint64 a2 = other.v1->y - other.v0->y;
+    qint64 b2 = other.v0->x - other.v1->x;
+
+    qint64 c2 = qint64(other.v1->x) * other.v0->y - qint64(other.v0->x) * other.v1->y;
+
+    qint64 det = a1 * b2 - a2 * b1;
+    if (det == 0) {
+        // lines are parallel. Only need to check side of one point
+        // fixed ordering for coincident edges
+        qint64 r1 = a2 * v0->x + b2 * v0->y + c2;
+//         QDEBUG() << "det = 0" << r1;
+        if (r1 == 0)
+            return edge < other.edge;
+        return (r1 < 0);
+    }
+
+    // not parallel, need to find the y coordinate of the intersection point
+    qint64 c1 = qint64(v1->x) * v0->y - qint64(v0->x) * v1->y;
+
+    qint64 offset = det < 0 ? -det : det;
+    offset >>= 1;
+
+    qint64 num = a2 * c1 - a1 * c2;
+    qint64 yi = ( num < 0 ? num - offset : num + offset ) / det;
+//     QDEBUG() << "    num=" << num << "offset=" << offset << "det=" << det;
+
+    return ((yi > y) ^ (det < 0));
+}
+
+static inline bool compareVertex(const QTessellatorPrivate::Vertex *p1,
+                                 const QTessellatorPrivate::Vertex *p2)
+{
+    if (p1->y == p2->y) {
+        if (p1->x == p2->x)
+            return p1 < p2;
+        return p1->x < p2->x;
+    }
+    return p1->y < p2->y;
+}
+
+Q27Dot5 QTessellatorPrivate::Edge::positionAt(Q27Dot5 y) const
+{
+    if (y == v0->y)
+        return v0->x;
+    else if (y == v1->y)
+        return v1->x;
+
+    qint64 d = v1->x - v0->x;
+    return (v0->x + d*(y - v0->y)/(v1->y-v0->y));
+}
+
+bool QTessellatorPrivate::EdgeSorter::operator() (const Edge *e1, const Edge *e2)
+{
+    return e1->isLeftOf(*e2, y);
+}
+
+
+QTessellatorPrivate::Scanline::Scanline()
+{
+    edges = 0;
+    edge_table = 0;
+    old = 0;
+}
+
+void QTessellatorPrivate::Scanline::init(int maxActiveEdges)
+{
+    maxActiveEdges *= 2;
+    if (!edges || maxActiveEdges > default_alloc) {
+        max_edges = maxActiveEdges;
+        int s = qMax(maxActiveEdges + 1, default_alloc + 1);
+        edges = q_check_ptr((Edge **)realloc(edges, s*sizeof(Edge *)));
+        edge_table = q_check_ptr((Edge *)realloc(edge_table, s*sizeof(Edge)));
+        old = q_check_ptr((Edge **)realloc(old, s*sizeof(Edge *)));
+    }
+    size = 0;
+    old_size = 0;
+    first_unused = 0;
+    for (int i = 0; i < maxActiveEdges; ++i)
+        edge_table[i].edge = i+1;
+    edge_table[maxActiveEdges].edge = -1;
+}
+
+void QTessellatorPrivate::Scanline::done()
+{
+    if (max_edges > default_alloc) {
+        free(edges);
+        free(old);
+        free(edge_table);
+        edges = 0;
+        old = 0;
+        edge_table = 0;
+    }
+}
+
+QTessellatorPrivate::Scanline::~Scanline()
+{
+    free(edges);
+    free(old);
+    free(edge_table);
+}
+
+int QTessellatorPrivate::Scanline::findEdgePosition(Q27Dot5 x, Q27Dot5 y) const
+{
+    int min = 0;
+    int max = size - 1;
+    while (min < max) {
+        int pos = min + ((max - min + 1) >> 1);
+        Q27Dot5 ax = edges[pos]->positionAt(y);
+        if (ax > x) {
+            max = pos - 1;
+        } else {
+            min = pos;
+        }
+    }
+    return min;
+}
+
+int QTessellatorPrivate::Scanline::findEdgePosition(const Edge &e) const
+{
+//     qDebug() << ">>      findEdgePosition";
+    int min = 0;
+    int max = size;
+    while (min < max) {
+        int pos = min + ((max - min) >> 1);
+//         qDebug() << "        " << min << max << pos << edges[pos]->isLeftOf(e, e.y0);
+        if (edges[pos]->isLeftOf(e, e.v0->y)) {
+            min = pos + 1;
+        } else {
+            max = pos;
+        }
+    }
+//     qDebug() << "<<      findEdgePosition got" << min;
+    return min;
+}
+
+int QTessellatorPrivate::Scanline::findEdge(int edge) const
+{
+    for (int i = 0; i < size; ++i) {
+        int item_edge = edges[i]->edge;
+        if (item_edge == edge)
+            return i;
+    }
+    //Q_ASSERT(false);
+    return -1;
+}
+
+void QTessellatorPrivate::Scanline::clearMarks()
+{
+    for (int i = 0; i < size; ++i) {
+        edges[i]->mark = false;
+        edges[i]->intersect_left = false;
+        edges[i]->intersect_right = false;
+    }
+}
+
+void QTessellatorPrivate::Scanline::prepareLine()
+{
+    Edge **end = edges + size;
+    Edge **e = edges;
+    Edge **o = old;
+    while (e < end) {
+        *o = *e;
+        ++o;
+        ++e;
+    }
+    old_size = size;
+}
+
+void QTessellatorPrivate::Scanline::lineDone()
+{
+    Edge **end = old + old_size;
+    Edge **e = old;
+    while (e < end) {
+        if ((*e)->free) {
+            (*e)->edge = first_unused;
+            first_unused = (*e - edge_table);
+        }
+        ++e;
+    }
+}
+
+void QTessellatorPrivate::Scanline::insert(int pos, const Edge &e)
+{
+    Edge *edge = edge_table + first_unused;
+    first_unused = edge->edge;
+    Q_ASSERT(first_unused != -1);
+    *edge = e;
+    memmove(edges + pos + 1, edges + pos, (size - pos)*sizeof(Edge *));
+    edges[pos] = edge;
+    ++size;
+}
+
+void QTessellatorPrivate::Scanline::removeAt(int pos)
+{
+    Edge *e = edges[pos];
+    e->free = true;
+    --size;
+    memmove(edges + pos, edges + pos + 1, (size - pos)*sizeof(Edge *));
+}
+
+void QTessellatorPrivate::Scanline::markEdges(int pos1, int pos2)
+{
+    if (pos2 < pos1)
+        return;
+
+    for (int i = pos1; i <= pos2; ++i)
+        edges[i]->mark = true;
+}
+
+
+QTessellatorPrivate::Vertices::Vertices()
+{
+    storage = 0;
+    sorted = 0;
+    allocated = 0;
+    nPoints = 0;
+}
+
+QTessellatorPrivate::Vertices::~Vertices()
+{
+    if (storage) {
+        free(storage);
+        free(sorted);
+    }
+}
+
+void QTessellatorPrivate::Vertices::init(int maxVertices)
+{
+    if (!storage || maxVertices > allocated) {
+        int size = qMax((int)default_alloc, maxVertices);
+        storage = q_check_ptr((Vertex *)realloc(storage, size*sizeof(Vertex)));
+        sorted = q_check_ptr((Vertex **)realloc(sorted, size*sizeof(Vertex *)));
+        allocated = maxVertices;
+    }
+}
+
+void QTessellatorPrivate::Vertices::done()
+{
+    if (allocated > default_alloc) {
+        free(storage);
+        free(sorted);
+        storage = 0;
+        sorted = 0;
+        allocated = 0;
+    }
+}
+
+
+
+static inline void fillTrapezoid(Q27Dot5 y1, Q27Dot5 y2, int left, int right,
+                                 const QTessellatorPrivate::Vertices &vertices,
+                                 QTessellator::Trapezoid *trap)
+{
+    trap->top = y1;
+    trap->bottom = y2;
+    const QTessellatorPrivate::Vertex *v = vertices[left];
+    trap->topLeft = v;
+    trap->bottomLeft = vertices.next(v);
+    if (trap->topLeft->y > trap->bottomLeft->y)
+        qSwap(trap->topLeft,trap->bottomLeft);
+    v = vertices[right];
+    trap->topRight = v;
+    trap->bottomRight = vertices.next(v);
+    if (trap->topRight->y > trap->bottomRight->y)
+        qSwap(trap->topRight, trap->bottomRight);
+}
+
+QRectF QTessellatorPrivate::collectAndSortVertices(const QPointF *points, int *maxActiveEdges)
+{
+    *maxActiveEdges = 0;
+    Vertex *v = vertices.storage;
+    Vertex **vv = vertices.sorted;
+
+    qreal xmin(points[0].x());
+    qreal xmax(points[0].x());
+    qreal ymin(points[0].y());
+    qreal ymax(points[0].y());
+
+    // collect vertex data
+    Q27Dot5 y_prev = FloatToQ27Dot5(points[vertices.nPoints-1].y());
+    Q27Dot5 x_next = FloatToQ27Dot5(points[0].x());
+    Q27Dot5 y_next = FloatToQ27Dot5(points[0].y());
+    int j = 0;
+    int i = 0;
+    while (i < vertices.nPoints) {
+        Q27Dot5 y_curr = y_next;
+
+        *vv = v;
+
+        v->x = x_next;
+        v->y = y_next;
+        v->flags = 0;
+
+    next_point:
+
+        xmin = qMin(xmin, points[i+1].x());
+        xmax = qMax(xmax, points[i+1].x());
+        ymin = qMin(ymin, points[i+1].y());
+        ymax = qMax(ymax, points[i+1].y());
+
+        y_next = FloatToQ27Dot5(points[i+1].y());
+        x_next = FloatToQ27Dot5(points[i+1].x());
+
+        // skip vertices on top of each other
+        if (v->x == x_next && v->y == y_next) {
+            ++i;
+            if (i < vertices.nPoints)
+                goto next_point;
+            Vertex *v0 = vertices.storage;
+            v0->flags &= ~(LineBeforeStarts|LineBeforeEnds|LineBeforeHorizontal);
+            if (y_prev < y_curr)
+                v0->flags |= LineBeforeEnds;
+            else if (y_prev > y_curr)
+                v0->flags |= LineBeforeStarts;
+            else
+                v0->flags |= LineBeforeHorizontal;
+            if ((v0->flags & (LineBeforeStarts|LineAfterStarts))
+                && !(v0->flags & (LineAfterEnds|LineBeforeEnds)))
+                *maxActiveEdges += 2;
+            break;
+        }
+
+        if (y_prev < y_curr)
+            v->flags |= LineBeforeEnds;
+        else if (y_prev > y_curr)
+            v->flags |= LineBeforeStarts;
+        else
+            v->flags |= LineBeforeHorizontal;
+
+
+        if (y_curr < y_next)
+            v->flags |= LineAfterStarts;
+        else if (y_curr > y_next)
+            v->flags |= LineAfterEnds;
+        else
+            v->flags |= LineAfterHorizontal;
+        // ### could probably get better limit by looping over sorted list and counting down on ending edges
+        if ((v->flags & (LineBeforeStarts|LineAfterStarts))
+            && !(v->flags & (LineAfterEnds|LineBeforeEnds)))
+            *maxActiveEdges += 2;
+        y_prev = y_curr;
+        ++v;
+        ++vv;
+        ++j;
+        ++i;
+    }
+    vertices.nPoints = j;
+
+    QDEBUG() << "maxActiveEdges=" << *maxActiveEdges;
+    vv = vertices.sorted;
+    qSort(vv, vv + vertices.nPoints, compareVertex);
+
+    return QRectF(xmin, ymin, xmax-xmin, ymax-ymin);
+}
+
+struct QCoincidingEdge {
+    QTessellatorPrivate::Vertex *start;
+    QTessellatorPrivate::Vertex *end;
+    bool used;
+    bool before;
+
+    inline bool operator<(const QCoincidingEdge &e2) const
+    {
+        return end->y == e2.end->y ? end->x < e2.end->x : end->y < e2.end->y;
+    }
+};
+
+static void cancelEdges(QCoincidingEdge &e1, QCoincidingEdge &e2)
+{
+    if (e1.before) {
+        e1.start->flags &= ~(LineBeforeStarts|LineBeforeHorizontal);
+        e1.end->flags &= ~(LineAfterEnds|LineAfterHorizontal);
+    } else {
+        e1.start->flags &= ~(LineAfterStarts|LineAfterHorizontal);
+        e1.end->flags &= ~(LineBeforeEnds|LineBeforeHorizontal);
+    }
+    if (e2.before) {
+        e2.start->flags &= ~(LineBeforeStarts|LineBeforeHorizontal);
+        e2.end->flags &= ~(LineAfterEnds|LineAfterHorizontal);
+    } else {
+        e2.start->flags &= ~(LineAfterStarts|LineAfterHorizontal);
+        e2.end->flags &= ~(LineBeforeEnds|LineBeforeHorizontal);
+    }
+    e1.used = e2.used = true;
+}
+
+void QTessellatorPrivate::cancelCoincidingEdges()
+{
+    Vertex **vv = vertices.sorted;
+
+    QCoincidingEdge *tl = 0;
+    int tlSize = 0;
+
+    for (int i = 0; i < vertices.nPoints - 1; ++i) {
+        Vertex *v = vv[i];
+        int testListSize = 0;
+        while (i < vertices.nPoints - 1) {
+            Vertex *n = vv[i];
+            if (v->x != n->x || v->y != n->y)
+                break;
+
+            if (testListSize > tlSize - 2) {
+                tlSize = qMax(tlSize*2, 16);
+                tl = q_check_ptr((QCoincidingEdge *)realloc(tl, tlSize*sizeof(QCoincidingEdge)));
+            }
+            if (n->flags & (LineBeforeStarts|LineBeforeHorizontal)) {
+                tl[testListSize].start = n;
+                tl[testListSize].end = vertices.prev(n);
+                tl[testListSize].used = false;
+                tl[testListSize].before = true;
+                ++testListSize;
+            }
+            if (n->flags & (LineAfterStarts|LineAfterHorizontal)) {
+                tl[testListSize].start = n;
+                tl[testListSize].end = vertices.next(n);
+                tl[testListSize].used = false;
+                tl[testListSize].before = false;
+                ++testListSize;
+            }
+            ++i;
+        }
+        if (!testListSize)
+            continue;
+
+        qSort(tl, tl + testListSize);
+
+        for (int j = 0; j < testListSize; ++j) {
+            if (tl[j].used)
+                continue;
+
+            for (int k = j + 1; k < testListSize; ++k) {
+                if (tl[j].end->x != tl[k].end->x
+                    || tl[j].end->y != tl[k].end->y
+                    || tl[k].used)
+                    break;
+
+                if (!winding || tl[j].before != tl[k].before) {
+                    cancelEdges(tl[j], tl[k]);
+                    break;
+                }
+                ++k;
+            }
+            ++j;
+        }
+    }
+    free(tl);
+}
+
+
+void QTessellatorPrivate::emitEdges(QTessellator *tessellator)
+{
+    //QDEBUG() << "TRAPS:";
+    if (!scanline.old_size)
+        return;
+
+    // emit edges
+    if (winding) {
+        // winding fill rule
+        int w = 0;
+
+        scanline.old[0]->y_left = y;
+
+        for (int i = 0; i < scanline.old_size - 1; ++i) {
+            Edge *left = scanline.old[i];
+            Edge *right = scanline.old[i+1];
+            w += left->winding;
+//             qDebug() << "i=" << i << "edge->winding=" << left->winding << "winding=" << winding;
+            if (w == 0) {
+                left->y_right = y;
+                right->y_left = y;
+            } else if (!emit_clever || left->mark || right->mark) {
+                Q27Dot5 top = qMax(left->y_right, right->y_left);
+                if (top != y) {
+                    QTessellator::Trapezoid trap;
+                    fillTrapezoid(top, y, left->edge, right->edge, vertices, &trap);
+                    tessellator->addTrap(trap);
+//                     QDEBUG() << "    top=" << Q27Dot5ToDouble(top) << "left=" << left->edge << "right=" << right->edge;
+                }
+                right->y_left = y;
+                left->y_right = y;
+            }
+            left->mark = false;
+        }
+        if (scanline.old[scanline.old_size - 1]->mark) {
+            scanline.old[scanline.old_size - 1]->y_right = y;
+            scanline.old[scanline.old_size - 1]->mark = false;
+        }
+    } else {
+        // odd-even fill rule
+        for (int i = 0; i < scanline.old_size; i += 2) {
+            Edge *left = scanline.old[i];
+            Edge *right = scanline.old[i+1];
+            if (!emit_clever || left->mark || right->mark) {
+                Q27Dot5 top = qMax(left->y_right, right->y_left);
+                if (top != y) {
+                    QTessellator::Trapezoid trap;
+                    fillTrapezoid(top, y, left->edge, right->edge, vertices, &trap);
+                    tessellator->addTrap(trap);
+                }
+//                 QDEBUG() << "    top=" << Q27Dot5ToDouble(top) << "left=" << left->edge << "right=" << right->edge;
+                left->y_left = y;
+                left->y_right = y;
+                right->y_left = y;
+                right->y_right = y;
+                left->mark = right->mark = false;
+            }
+        }
+    }
+}
+
+
+void QTessellatorPrivate::processIntersections()
+{
+    QDEBUG() << "PROCESS INTERSECTIONS";
+    // process intersections
+    while (!intersections.isEmpty()) {
+        Intersections::iterator it = intersections.begin();
+        if (it.key().y != y)
+            break;
+
+        // swap edges
+        QDEBUG() << "    swapping intersecting edges ";
+        int min = scanline.size;
+        int max = 0;
+        Q27Dot5 xmin = INT_MAX;
+        Q27Dot5 xmax = INT_MIN;
+        int num = 0;
+        while (1) {
+            const Intersection &i = it.key();
+            int next = it->next;
+
+            int edgePos = scanline.findEdge(i.edge);
+            if (edgePos >= 0) {
+                ++num;
+                min = qMin(edgePos, min);
+                max = qMax(edgePos, max);
+                Edge *edge = scanline.edges[edgePos];
+                xmin = qMin(xmin, edge->positionAt(y));
+                xmax = qMax(xmax, edge->positionAt(y));
+            }
+            Intersection key;
+            key.y = y;
+            key.edge = next;
+            it = intersections.find(key);
+            intersections.remove(i);
+            if (it == intersections.end())
+                break;
+        }
+        if (num < 2)
+            continue;
+
+        Q_ASSERT(min != max);
+        QDEBUG() << "sorting between" << min << "and" << max << "xpos=" << xmin << xmax;
+        while (min > 0 && scanline.edges[min - 1]->positionAt(y) >= xmin) {
+            QDEBUG() << "    adding edge on left";
+            --min;
+        }
+        while (max < scanline.size - 1 && scanline.edges[max + 1]->positionAt(y) <=  xmax) {
+            QDEBUG() << "    adding edge on right";
+            ++max;
+        }
+
+        qSort(scanline.edges + min, scanline.edges + max + 1, EdgeSorter(y));
+#ifdef DEBUG
+        for (int i = min; i <= max; ++i)
+            QDEBUG() << "        " << scanline.edges[i]->edge << "at pos" << i;
+#endif
+        for (int i = min; i <= max; ++i) {
+            Edge *edge = scanline.edges[i];
+            edge->intersect_left = true;
+            edge->intersect_right = true;
+            edge->mark = true;
+        }
+    }
+}
+
+void QTessellatorPrivate::removeEdges()
+{
+    int cv = currentVertex;
+    while (cv < vertices.nPoints) {
+        const Vertex *v = vertices.sorted[cv];
+        if (v->y > y)
+            break;
+        if (v->flags & LineBeforeEnds) {
+            QDEBUG() << "    removing edge" << vertices.prevPos(v);
+            int pos = scanline.findEdge(vertices.prevPos(v));
+            if (pos == -1)
+                continue;
+            scanline.edges[pos]->mark = true;
+            if (pos > 0)
+                scanline.edges[pos - 1]->intersect_right = true;
+            if (pos < scanline.size - 1)
+                scanline.edges[pos + 1]->intersect_left = true;
+            scanline.removeAt(pos);
+        }
+        if (v->flags & LineAfterEnds) {
+            QDEBUG() << "    removing edge" << vertices.position(v);
+            int pos = scanline.findEdge(vertices.position(v));
+            if (pos == -1)
+                continue;
+            scanline.edges[pos]->mark = true;
+            if (pos > 0)
+                scanline.edges[pos - 1]->intersect_right = true;
+            if (pos < scanline.size - 1)
+                scanline.edges[pos + 1]->intersect_left = true;
+            scanline.removeAt(pos);
+        }
+        ++cv;
+    }
+}
+
+void QTessellatorPrivate::addEdges()
+{
+    while (currentVertex < vertices.nPoints) {
+        const Vertex *v = vertices.sorted[currentVertex];
+        if (v->y > y)
+            break;
+        if (v->flags & LineBeforeStarts) {
+            // add new edge
+            int start = vertices.prevPos(v);
+            Edge e(vertices, start);
+            int pos = scanline.findEdgePosition(e);
+            QDEBUG() << "    adding edge" << start << "at position" << pos;
+            scanline.insert(pos, e);
+            if (!mark_clever || !(v->flags & LineAfterEnds)) {
+                if (pos > 0)
+                    scanline.edges[pos - 1]->mark = true;
+                if (pos < scanline.size - 1)
+                    scanline.edges[pos + 1]->mark = true;
+            }
+        }
+        if (v->flags & LineAfterStarts) {
+            Edge e(vertices, vertices.position(v));
+            int pos = scanline.findEdgePosition(e);
+            QDEBUG() << "    adding edge" << vertices.position(v) << "at position" << pos;
+            scanline.insert(pos, e);
+            if (!mark_clever || !(v->flags & LineBeforeEnds)) {
+                if (pos > 0)
+                    scanline.edges[pos - 1]->mark = true;
+                if (pos < scanline.size - 1)
+                    scanline.edges[pos + 1]->mark = true;
+            }
+        }
+        if (v->flags & LineAfterHorizontal) {
+            int pos1 = scanline.findEdgePosition(v->x, v->y);
+            const Vertex *next = vertices.next(v);
+            Q_ASSERT(v->y == next->y);
+            int pos2 = scanline.findEdgePosition(next->x, next->y);
+            if (pos2 < pos1)
+                qSwap(pos1, pos2);
+            if (pos1 > 0)
+                --pos1;
+            if (pos2 == scanline.size)
+                --pos2;
+            //QDEBUG() << "marking horizontal edge from " << pos1 << "to" << pos2;
+            scanline.markEdges(pos1, pos2);
+        }
+        ++currentVertex;
+    }
+}
+
+#ifdef DEBUG
+static void checkLinkChain(const QTessellatorPrivate::Intersections &intersections,
+                           QTessellatorPrivate::Intersection i)
+{
+//     qDebug() << "              Link chain: ";
+    int end = i.edge;
+    while (1) {
+        QTessellatorPrivate::IntersectionLink l = intersections.value(i);
+//         qDebug() << "                     " << i.edge << "next=" << l.next << "prev=" << l.prev;
+        if (l.next == end)
+            break;
+        Q_ASSERT(l.next != -1);
+        Q_ASSERT(l.prev != -1);
+
+        QTessellatorPrivate::Intersection i2 = i;
+        i2.edge = l.next;
+        QTessellatorPrivate::IntersectionLink l2 = intersections.value(i2);
+
+        Q_ASSERT(l2.next != -1);
+        Q_ASSERT(l2.prev != -1);
+        Q_ASSERT(l.next == i2.edge);
+        Q_ASSERT(l2.prev == i.edge);
+        i = i2;
+    }
+}
+#endif
+
+bool QTessellatorPrivate::edgeInChain(Intersection i, int edge)
+{
+    int end = i.edge;
+    while (1) {
+        if (i.edge == edge)
+            return true;
+        IntersectionLink l = intersections.value(i);
+        if (l.next == end)
+            break;
+        Q_ASSERT(l.next != -1);
+        Q_ASSERT(l.prev != -1);
+
+        Intersection i2 = i;
+        i2.edge = l.next;
+
+#ifndef QT_NO_DEBUG
+        IntersectionLink l2 = intersections.value(i2);
+        Q_ASSERT(l2.next != -1);
+        Q_ASSERT(l2.prev != -1);
+        Q_ASSERT(l.next == i2.edge);
+        Q_ASSERT(l2.prev == i.edge);
+#endif
+        i = i2;
+    }
+    return false;
+}
+
+
+void QTessellatorPrivate::addIntersection(const Edge *e1, const Edge *e2)
+{
+    const IntersectionLink emptyLink = {-1, -1};
+
+    int next = vertices.nextPos(vertices[e1->edge]);
+    if (e2->edge == next)
+        return;
+    int prev = vertices.prevPos(vertices[e1->edge]);
+    if (e2->edge == prev)
+        return;
+
+    Q27Dot5 yi;
+    bool det_positive;
+    bool isect = e1->intersect(*e2, &yi, &det_positive);
+    QDEBUG("checking edges %d and %d", e1->edge, e2->edge);
+    if (!isect) {
+        QDEBUG() << "    no intersection";
+        return;
+    }
+
+    // don't emit an intersection if it's at the start of a line segment or above us
+    if (yi <= y) {
+        if (!det_positive)
+            return;
+        QDEBUG() << "        ----->>>>>> WRONG ORDER!";
+        yi = y;
+    }
+    QDEBUG() << "   between edges " << e1->edge << "and" << e2->edge << "at point ("
+             << Q27Dot5ToDouble(yi) << ')';
+
+    Intersection i1;
+    i1.y = yi;
+    i1.edge = e1->edge;
+    IntersectionLink link1 = intersections.value(i1, emptyLink);
+    Intersection i2;
+    i2.y = yi;
+    i2.edge = e2->edge;
+    IntersectionLink link2 = intersections.value(i2, emptyLink);
+
+    // new pair of edges
+    if (link1.next == -1 && link2.next == -1) {
+        link1.next = link1.prev = i2.edge;
+        link2.next = link2.prev = i1.edge;
+    } else if (link1.next == i2.edge || link1.prev == i2.edge
+               || link2.next == i1.edge || link2.prev == i1.edge) {
+#ifdef DEBUG
+        checkLinkChain(intersections, i1);
+        checkLinkChain(intersections, i2);
+        Q_ASSERT(edgeInChain(i1, i2.edge));
+#endif
+        return;
+    } else if (link1.next == -1 || link2.next == -1) {
+        if (link2.next == -1) {
+            qSwap(i1, i2);
+            qSwap(link1, link2);
+        }
+        Q_ASSERT(link1.next == -1);
+#ifdef DEBUG
+        checkLinkChain(intersections, i2);
+#endif
+        // only i2 in list
+        link1.next = i2.edge;
+        link1.prev = link2.prev;
+        link2.prev = i1.edge;
+        Intersection other;
+        other.y = yi;
+        other.edge = link1.prev;
+        IntersectionLink link = intersections.value(other, emptyLink);
+        Q_ASSERT(link.next == i2.edge);
+        Q_ASSERT(link.prev != -1);
+        link.next = i1.edge;
+        intersections.insert(other, link);
+    } else {
+        bool connected = edgeInChain(i1, i2.edge);
+        if (connected)
+            return;
+#ifdef DEBUG
+        checkLinkChain(intersections, i1);
+        checkLinkChain(intersections, i2);
+#endif
+        // both already in some list. Have to make sure they are connected
+        // this can be done by cutting open the ring(s) after the two eges and
+        // connecting them again
+        Intersection other1;
+        other1.y = yi;
+        other1.edge = link1.next;
+        IntersectionLink linko1 = intersections.value(other1, emptyLink);
+        Intersection other2;
+        other2.y = yi;
+        other2.edge = link2.next;
+        IntersectionLink linko2 = intersections.value(other2, emptyLink);
+
+        linko1.prev = i2.edge;
+        link2.next = other1.edge;
+
+        linko2.prev = i1.edge;
+        link1.next = other2.edge;
+        intersections.insert(other1, linko1);
+        intersections.insert(other2, linko2);
+    }
+    intersections.insert(i1, link1);
+    intersections.insert(i2, link2);
+#ifdef DEBUG
+    checkLinkChain(intersections, i1);
+    checkLinkChain(intersections, i2);
+    Q_ASSERT(edgeInChain(i1, i2.edge));
+#endif
+    return;
+
+}
+
+
+void QTessellatorPrivate::addIntersections()
+{
+    if (scanline.size) {
+        QDEBUG() << "INTERSECTIONS";
+        // check marked edges for intersections
+#ifdef DEBUG
+        for (int i = 0; i < scanline.size; ++i) {
+            Edge *e = scanline.edges[i];
+            QDEBUG() << "    " << i << e->edge << "isect=(" << e->intersect_left << e->intersect_right
+                     << ')';
+        }
+#endif
+
+        for (int i = 0; i < scanline.size - 1; ++i) {
+            Edge *e1 = scanline.edges[i];
+            Edge *e2 = scanline.edges[i + 1];
+            // check for intersection
+            if (e1->intersect_right || e2->intersect_left)
+                addIntersection(e1, e2);
+        }
+    }
+#if 0
+    if (intersections.constBegin().key().y == y) {
+        QDEBUG() << "----------------> intersection on same line";
+        scanline.clearMarks();
+        scanline.processIntersections(y, &intersections);
+        goto redo;
+    }
+#endif
+}
+
+
+QTessellator::QTessellator()
+{
+    d = new QTessellatorPrivate;
+}
+
+QTessellator::~QTessellator()
+{
+    delete d;
+}
+
+void QTessellator::setWinding(bool w)
+{
+    d->winding = w;
+}
+
+
+QRectF QTessellator::tessellate(const QPointF *points, int nPoints)
+{
+    Q_ASSERT(points[0] == points[nPoints-1]);
+    --nPoints;
+
+#ifdef DEBUG
+    QDEBUG()<< "POINTS:";
+    for (int i = 0; i < nPoints; ++i) {
+        QDEBUG() << points[i];
+    }
+#endif
+
+    // collect edges and calculate bounds
+    d->vertices.nPoints = nPoints;
+    d->vertices.init(nPoints);
+
+    int maxActiveEdges = 0;
+    QRectF br = d->collectAndSortVertices(points, &maxActiveEdges);
+    d->cancelCoincidingEdges();
+
+#ifdef DEBUG
+    QDEBUG() << "nPoints = " << nPoints << "using " << d->vertices.nPoints;
+    QDEBUG()<< "VERTICES:";
+    for (int i = 0; i < d->vertices.nPoints; ++i) {
+        QDEBUG() << "    " << i << ": "
+                 << "point=" << d->vertices.position(d->vertices.sorted[i])
+                 << "flags=" << d->vertices.sorted[i]->flags
+                 << "pos=(" << Q27Dot5ToDouble(d->vertices.sorted[i]->x) << '/'
+                 << Q27Dot5ToDouble(d->vertices.sorted[i]->y) << ')';
+    }
+#endif
+
+    d->scanline.init(maxActiveEdges);
+    d->y = INT_MIN/256;
+    d->currentVertex = 0;
+
+    while (d->currentVertex < d->vertices.nPoints) {
+        d->scanline.clearMarks();
+
+        d->y = d->vertices.sorted[d->currentVertex]->y;
+        if (!d->intersections.isEmpty())
+            d->y = qMin(d->y, d->intersections.constBegin().key().y);
+
+        QDEBUG()<< "===== SCANLINE: y =" << Q27Dot5ToDouble(d->y) << " =====";
+
+        d->scanline.prepareLine();
+        d->processIntersections();
+        d->removeEdges();
+        d->addEdges();
+        d->addIntersections();
+        d->emitEdges(this);
+        d->scanline.lineDone();
+
+#ifdef DEBUG
+        QDEBUG()<< "===== edges:";
+        for (int i = 0; i < d->scanline.size; ++i) {
+            QDEBUG() << "   " << d->scanline.edges[i]->edge
+                     << "p0= (" << Q27Dot5ToDouble(d->scanline.edges[i]->v0->x)
+                     << '/' << Q27Dot5ToDouble(d->scanline.edges[i]->v0->y)
+                     << ") p1= (" << Q27Dot5ToDouble(d->scanline.edges[i]->v1->x)
+                     << '/' << Q27Dot5ToDouble(d->scanline.edges[i]->v1->y) << ')'
+                     << "x=" << Q27Dot5ToDouble(d->scanline.edges[i]->positionAt(d->y))
+                     << "isLeftOfNext="
+                     << ((i < d->scanline.size - 1)
+                         ? d->scanline.edges[i]->isLeftOf(*d->scanline.edges[i+1], d->y)
+                         : true);
+        }
+#endif
+}
+
+    d->scanline.done();
+    d->intersections.clear();
+    return br;
+}
+
+// tessellates the given convex polygon
+void QTessellator::tessellateConvex(const QPointF *points, int nPoints)
+{
+    Q_ASSERT(points[0] == points[nPoints-1]);
+    --nPoints;
+
+    d->vertices.nPoints = nPoints;
+    d->vertices.init(nPoints);
+
+    for (int i = 0; i < nPoints; ++i) {
+        d->vertices[i]->x = FloatToQ27Dot5(points[i].x());
+        d->vertices[i]->y = FloatToQ27Dot5(points[i].y());
+    }
+
+    int left = 0, right = 0;
+
+    int top = 0;
+    for (int i = 1; i < nPoints; ++i) {
+        if (d->vertices[i]->y < d->vertices[top]->y)
+            top = i;
+    }
+
+    left = (top + nPoints - 1) % nPoints;
+    right = (top + 1) % nPoints;
+
+    while (d->vertices[left]->x == d->vertices[top]->x && d->vertices[left]->y == d->vertices[top]->y && left != right)
+        left = (left + nPoints - 1) % nPoints;
+
+    while (d->vertices[right]->x == d->vertices[top]->x && d->vertices[right]->y == d->vertices[top]->y && left != right)
+        right = (right + 1) % nPoints;
+
+    if (left == right)
+        return;
+
+    int dir = 1;
+
+    Vertex dLeft = { d->vertices[top]->x - d->vertices[left]->x,
+                     d->vertices[top]->y - d->vertices[left]->y };
+
+    Vertex dRight = { d->vertices[right]->x - d->vertices[top]->x,
+                      d->vertices[right]->y - d->vertices[top]->y };
+
+    Q27Dot5 cross = dLeft.x * dRight.y - dLeft.y * dRight.x;
+
+    // flip direction if polygon is clockwise
+    if (cross < 0 || (cross == 0 && dLeft.x > 0)) {
+        qSwap(left, right);
+        dir = -1;
+    }
+
+    Vertex *lastLeft = d->vertices[top];
+    Vertex *lastRight = d->vertices[top];
+
+    QTessellator::Trapezoid trap;
+
+    while (lastLeft->y == d->vertices[left]->y && left != right) {
+        lastLeft = d->vertices[left];
+        left = (left + nPoints - dir) % nPoints;
+    }
+
+    while (lastRight->y == d->vertices[right]->y && left != right) {
+        lastRight = d->vertices[right];
+        right = (right + nPoints + dir) % nPoints;
+    }
+
+    while (true) {
+        trap.top = qMax(lastRight->y, lastLeft->y);
+        trap.bottom = qMin(d->vertices[left]->y, d->vertices[right]->y);
+        trap.topLeft = lastLeft;
+        trap.topRight = lastRight;
+        trap.bottomLeft = d->vertices[left];
+        trap.bottomRight = d->vertices[right];
+
+        if (trap.bottom > trap.top)
+            addTrap(trap);
+
+        if (left == right)
+            break;
+
+        if (d->vertices[right]->y < d->vertices[left]->y) {
+            do {
+                lastRight = d->vertices[right];
+                right = (right + nPoints + dir) % nPoints;
+            }
+            while (lastRight->y == d->vertices[right]->y && left != right);
+        } else {
+            do {
+                lastLeft = d->vertices[left];
+                left = (left + nPoints - dir) % nPoints;
+            }
+            while (lastLeft->y == d->vertices[left]->y && left != right);
+        }
+    }
+}
+
+// tessellates the stroke of the line from a_ to b_ with the given width and a flat cap
+void QTessellator::tessellateRect(const QPointF &a_, const QPointF &b_, qreal width)
+{
+    Vertex a = { FloatToQ27Dot5(a_.x()), FloatToQ27Dot5(a_.y()) };
+    Vertex b = { FloatToQ27Dot5(b_.x()), FloatToQ27Dot5(b_.y()) };
+
+    QPointF pa = a_, pb = b_;
+
+    if (a.y > b.y) {
+        qSwap(a, b);
+        qSwap(pa, pb);
+    }
+
+    Vertex delta = { b.x - a.x, b.y - a.y };
+
+    if (delta.x == 0 && delta.y == 0)
+        return;
+
+    qreal hw = 0.5 * width;
+
+    if (delta.x == 0) {
+        Q27Dot5 halfWidth = FloatToQ27Dot5(hw);
+
+        if (halfWidth == 0)
+            return;
+
+        Vertex topLeft = { a.x - halfWidth, a.y };
+        Vertex topRight = { a.x + halfWidth, a.y };
+        Vertex bottomLeft = { a.x - halfWidth, b.y };
+        Vertex bottomRight = { a.x + halfWidth, b.y };
+
+        QTessellator::Trapezoid trap = { topLeft.y, bottomLeft.y, &topLeft, &bottomLeft, &topRight, &bottomRight };
+        addTrap(trap);
+    } else if (delta.y == 0) {
+        Q27Dot5 halfWidth = FloatToQ27Dot5(hw);
+
+        if (halfWidth == 0)
+            return;
+
+        if (a.x > b.x)
+            qSwap(a.x, b.x);
+
+        Vertex topLeft = { a.x, a.y - halfWidth };
+        Vertex topRight = { b.x, a.y - halfWidth };
+        Vertex bottomLeft = { a.x, a.y + halfWidth };
+        Vertex bottomRight = { b.x, a.y + halfWidth };
+
+        QTessellator::Trapezoid trap = { topLeft.y, bottomLeft.y, &topLeft, &bottomLeft, &topRight, &bottomRight };
+        addTrap(trap);
+    } else {
+        QPointF perp(pb.y() - pa.y(), pa.x() - pb.x());
+        qreal length = qSqrt(perp.x() * perp.x() + perp.y() * perp.y());
+
+        if (qFuzzyIsNull(length))
+            return;
+
+        // need the half of the width
+        perp *= hw / length;
+
+        QPointF pta = pa + perp;
+        QPointF ptb = pa - perp;
+        QPointF ptc = pb - perp;
+        QPointF ptd = pb + perp;
+
+        Vertex ta = { FloatToQ27Dot5(pta.x()), FloatToQ27Dot5(pta.y()) };
+        Vertex tb = { FloatToQ27Dot5(ptb.x()), FloatToQ27Dot5(ptb.y()) };
+        Vertex tc = { FloatToQ27Dot5(ptc.x()), FloatToQ27Dot5(ptc.y()) };
+        Vertex td = { FloatToQ27Dot5(ptd.x()), FloatToQ27Dot5(ptd.y()) };
+
+        if (ta.y < tb.y) {
+            if (tb.y < td.y) {
+                QTessellator::Trapezoid top = { ta.y, tb.y, &ta, &tb, &ta, &td };
+                QTessellator::Trapezoid bottom = { td.y, tc.y, &tb, &tc, &td, &tc };
+                addTrap(top);
+                addTrap(bottom);
+
+                QTessellator::Trapezoid middle = { tb.y, td.y, &tb, &tc, &ta, &td };
+                addTrap(middle);
+            } else {
+                QTessellator::Trapezoid top = { ta.y, td.y, &ta, &tb, &ta, &td };
+                QTessellator::Trapezoid bottom = { tb.y, tc.y, &tb, &tc, &td, &tc };
+                addTrap(top);
+                addTrap(bottom);
+
+                if (tb.y != td.y) {
+                    QTessellator::Trapezoid middle = { td.y, tb.y, &ta, &tb, &td, &tc };
+                    addTrap(middle);
+                }
+            }
+        } else {
+            if (ta.y < tc.y) {
+                QTessellator::Trapezoid top = { tb.y, ta.y, &tb, &tc, &tb, &ta };
+                QTessellator::Trapezoid bottom = { tc.y, td.y, &tc, &td, &ta, &td };
+                addTrap(top);
+                addTrap(bottom);
+
+                QTessellator::Trapezoid middle = { ta.y, tc.y, &tb, &tc, &ta, &td };
+                addTrap(middle);
+            } else {
+                QTessellator::Trapezoid top = { tb.y, tc.y, &tb, &tc, &tb, &ta };
+                QTessellator::Trapezoid bottom = { ta.y, td.y, &tc, &td, &ta, &td };
+                addTrap(top);
+                addTrap(bottom);
+
+                if (ta.y != tc.y) {
+                    QTessellator::Trapezoid middle = { tc.y, ta.y, &tc, &td, &tb, &ta };
+                    addTrap(middle);
+                }
+            }
+        }
+    }
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qtessellator_p.h b/src/gui/painting/qtessellator_p.h
new file mode 100644
index 0000000000..ad3ef9776f
--- /dev/null
+++ b/src/gui/painting/qtessellator_p.h
@@ -0,0 +1,102 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QTESSELATOR_P_H
+#define QTESSELATOR_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of other Qt classes.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <qpoint.h>
+#include <qrect.h>
+
+QT_BEGIN_NAMESPACE
+
+class QTessellatorPrivate;
+
+typedef int Q27Dot5;
+#define Q27Dot5ToDouble(i) ((i)/32.)
+#define FloatToQ27Dot5(i) (int)((i) * 32)
+#define IntToQ27Dot5(i) ((i) << 5)
+#define Q27Dot5ToXFixed(i) ((i) << 11)
+#define Q27Dot5Factor 32
+
+class Q_GUI_EXPORT QTessellator {
+public:
+    QTessellator();
+    virtual ~QTessellator();
+
+    QRectF tessellate(const QPointF *points, int nPoints);
+    void tessellateConvex(const QPointF *points, int nPoints);
+    void tessellateRect(const QPointF &a, const QPointF &b, qreal width);
+
+    void setWinding(bool w);
+
+    struct Vertex {
+        Q27Dot5 x;
+        Q27Dot5 y;
+    };
+    struct Trapezoid {
+        Q27Dot5 top;
+        Q27Dot5 bottom;
+        const Vertex *topLeft;
+        const Vertex *bottomLeft;
+        const Vertex *topRight;
+        const Vertex *bottomRight;
+    };
+    virtual void addTrap(const Trapezoid &trap) = 0;
+
+private:
+    friend class QTessellatorPrivate;
+    QTessellatorPrivate *d;
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/gui/painting/qtextureglyphcache.cpp b/src/gui/painting/qtextureglyphcache.cpp
new file mode 100644
index 0000000000..53f025f819
--- /dev/null
+++ b/src/gui/painting/qtextureglyphcache.cpp
@@ -0,0 +1,468 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <qmath.h>
+
+#include "qtextureglyphcache_p.h"
+
+#include "private/qnumeric_p.h"
+#include "private/qnativeimage_p.h"
+#include "private/qfontengine_ft_p.h"
+
+QT_BEGIN_NAMESPACE
+
+// #define CACHE_DEBUG
+
+// returns the highest number closest to v, which is a power of 2
+// NB! assumes 32 bit ints
+static inline int qt_next_power_of_two(int v)
+{
+    v--;
+    v |= v >> 1;
+    v |= v >> 2;
+    v |= v >> 4;
+    v |= v >> 8;
+    v |= v >> 16;
+    ++v;
+    return v;
+}
+
+int QTextureGlyphCache::calculateSubPixelPositionCount(glyph_t glyph) const
+{
+    // Test 12 different subpixel positions since it factors into 3*4 so it gives
+    // the coverage we need.
+
+    QList<QImage> images;
+    for (int i=0; i<12; ++i) {
+        QImage img = textureMapForGlyph(glyph, QFixed::fromReal(i / 12.0));
+
+        if (images.isEmpty()) {
+            QPainterPath path;
+            QFixedPoint point;
+            m_current_fontengine->addGlyphsToPath(&glyph, &point, 1, &path, QTextItem::RenderFlags());
+
+            // Glyph is space, return 0 to indicate that we need to keep trying
+            if (path.isEmpty())
+                break;
+
+            images.append(img);
+        } else {
+            bool found = false;
+            for (int j=0; j<images.size(); ++j) {
+                if (images.at(j) == img) {
+                    found = true;
+                    break;
+                }
+            }
+            if (!found)
+                images.append(img);
+        }
+    }
+
+    return images.size();
+}
+
+QFixed QTextureGlyphCache::subPixelPositionForX(QFixed x) const
+{
+    if (m_subPixelPositionCount <= 1)
+        return QFixed();
+
+    QFixed subPixelPosition;
+    if (x != 0) {
+        subPixelPosition = x - x.floor();
+        QFixed fraction = (subPixelPosition / QFixed::fromReal(1.0 / m_subPixelPositionCount)).floor();
+
+        // Compensate for precision loss in fixed point to make sure we are always drawing at a subpixel position over
+        // the lower boundary for the selected rasterization by adding 1/64.
+        subPixelPosition = fraction / QFixed(m_subPixelPositionCount) + QFixed::fromReal(0.015625);
+    }
+    return subPixelPosition;
+}
+
+bool QTextureGlyphCache::populate(QFontEngine *fontEngine, int numGlyphs, const glyph_t *glyphs,
+                                                const QFixedPoint *positions)
+{
+#ifdef CACHE_DEBUG
+    printf("Populating with %d glyphs\n", numGlyphs);
+    qDebug() << " -> current transformation: " << m_transform;
+#endif
+
+    m_current_fontengine = fontEngine;
+    const int margin = glyphMargin();
+    const int paddingDoubled = glyphPadding() * 2;
+
+    bool supportsSubPixelPositions = fontEngine->supportsSubPixelPositions();
+    if (m_subPixelPositionCount == 0) {
+        if (!supportsSubPixelPositions) {
+            m_subPixelPositionCount = 1;
+        } else {
+#if !defined(Q_WS_X11)
+            int i = 0;
+            while (m_subPixelPositionCount == 0 && i < numGlyphs)
+                m_subPixelPositionCount = calculateSubPixelPositionCount(glyphs[i++]);
+#else
+            m_subPixelPositionCount = 4;
+#endif
+        }
+    }
+
+    QHash<GlyphAndSubPixelPosition, Coord> listItemCoordinates;
+    int rowHeight = 0;
+
+    QFontEngine::GlyphFormat format;
+    switch (m_type) {
+    case Raster_A8: format = QFontEngine::Format_A8; break;
+    case Raster_RGBMask: format = QFontEngine::Format_A32; break;
+    default: format = QFontEngine::Format_Mono; break;
+    }
+
+    // check each glyph for its metrics and get the required rowHeight.
+    for (int i=0; i < numGlyphs; ++i) {
+        const glyph_t glyph = glyphs[i];
+
+        QFixed subPixelPosition;
+        if (supportsSubPixelPositions) {
+            QFixed x = positions != 0 ? positions[i].x : QFixed();
+            subPixelPosition = subPixelPositionForX(x);
+        }
+
+        if (coords.contains(GlyphAndSubPixelPosition(glyph, subPixelPosition)))
+            continue;
+        if (listItemCoordinates.contains(GlyphAndSubPixelPosition(glyph, subPixelPosition)))
+            continue;
+        glyph_metrics_t metrics = fontEngine->alphaMapBoundingBox(glyph, subPixelPosition, m_transform, format);
+
+#ifdef CACHE_DEBUG
+        printf("(%4x): w=%.2f, h=%.2f, xoff=%.2f, yoff=%.2f, x=%.2f, y=%.2f\n",
+               glyph,
+               metrics.width.toReal(),
+               metrics.height.toReal(),
+               metrics.xoff.toReal(),
+               metrics.yoff.toReal(),
+               metrics.x.toReal(),
+               metrics.y.toReal());
+#endif        
+        GlyphAndSubPixelPosition key(glyph, subPixelPosition);
+        int glyph_width = metrics.width.ceil().toInt();
+        int glyph_height = metrics.height.ceil().toInt();
+        if (glyph_height == 0 || glyph_width == 0) {
+            // Avoid multiple calls to boundingBox() for non-printable characters
+            Coord c = { 0, 0, 0, 0, 0, 0 };
+            coords.insert(key, c);
+            continue;
+        }
+        glyph_width += margin * 2 + 4;
+        glyph_height += margin * 2 + 4;
+        // align to 8-bit boundary
+        if (m_type == QFontEngineGlyphCache::Raster_Mono)
+            glyph_width = (glyph_width+7)&~7;
+
+        Coord c = { 0, 0, // will be filled in later
+                    glyph_width,
+                    glyph_height, // texture coords
+                    metrics.x.round().truncate(),
+                    -metrics.y.truncate() }; // baseline for horizontal scripts
+
+        listItemCoordinates.insert(key, c);
+        rowHeight = qMax(rowHeight, glyph_height);
+    }
+    if (listItemCoordinates.isEmpty())
+        return true;
+
+    rowHeight += margin * 2 + paddingDoubled;
+
+    if (m_w == 0) {
+        if (fontEngine->maxCharWidth() <= QT_DEFAULT_TEXTURE_GLYPH_CACHE_WIDTH)
+            m_w = QT_DEFAULT_TEXTURE_GLYPH_CACHE_WIDTH;
+        else
+            m_w = qt_next_power_of_two(fontEngine->maxCharWidth());
+    }
+
+    // now actually use the coords and paint the wanted glyps into cache.
+    QHash<GlyphAndSubPixelPosition, Coord>::iterator iter = listItemCoordinates.begin();
+    int requiredWidth = m_w;
+    while (iter != listItemCoordinates.end()) {
+        Coord c = iter.value();
+
+        m_currentRowHeight = qMax(m_currentRowHeight, c.h + margin * 2);
+
+        if (m_cx + c.w > requiredWidth) {
+            int new_width = requiredWidth*2;
+            while (new_width < m_cx + c.w)
+                new_width *= 2;
+            if (new_width <= maxTextureWidth()) {
+                requiredWidth = new_width;
+            } else {
+                // no room on the current line, start new glyph strip
+                m_cx = 0;
+                m_cy += m_currentRowHeight + paddingDoubled;
+                m_currentRowHeight = c.h + margin * 2; // New row
+            }
+        }
+
+        if (maxTextureHeight() > 0 && m_cy + c.h > maxTextureHeight()) {
+            // We can't make a cache of the required size, so we bail out
+            return false;
+        }
+
+        c.x = m_cx;
+        c.y = m_cy;
+
+        coords.insert(iter.key(), c);
+        m_pendingGlyphs.insert(iter.key(), c);
+
+        m_cx += c.w + paddingDoubled;
+        ++iter;
+    }
+    return true;
+
+}
+
+void QTextureGlyphCache::fillInPendingGlyphs()
+{
+    if (m_pendingGlyphs.isEmpty())
+        return;
+
+    int requiredHeight = m_h;
+    int requiredWidth = m_w; // Use a minimum size to avoid a lot of initial reallocations
+    {
+        QHash<GlyphAndSubPixelPosition, Coord>::iterator iter = m_pendingGlyphs.begin();
+        while (iter != m_pendingGlyphs.end()) {
+            Coord c = iter.value();
+            requiredHeight = qMax(requiredHeight, c.y + c.h);
+            requiredWidth = qMax(requiredWidth, c.x + c.w);
+            ++iter;
+        }
+    }
+
+    if (isNull() || requiredHeight > m_h || requiredWidth > m_w) {
+        if (isNull())
+            createCache(qt_next_power_of_two(requiredWidth), qt_next_power_of_two(requiredHeight));
+        else
+            resizeCache(qt_next_power_of_two(requiredWidth), qt_next_power_of_two(requiredHeight));
+    }
+
+    {
+        QHash<GlyphAndSubPixelPosition, Coord>::iterator iter = m_pendingGlyphs.begin();
+        while (iter != m_pendingGlyphs.end()) {
+            GlyphAndSubPixelPosition key = iter.key();
+            fillTexture(iter.value(), key.glyph, key.subPixelPosition);
+
+            ++iter;
+        }
+    }
+
+    m_pendingGlyphs.clear();
+}
+
+QImage QTextureGlyphCache::textureMapForGlyph(glyph_t g, QFixed subPixelPosition) const
+{
+#if defined(Q_WS_X11)
+    if (m_transform.type() > QTransform::TxTranslate) {
+        QFontEngineFT::GlyphFormat format = QFontEngineFT::Format_None;
+        QImage::Format imageFormat = QImage::Format_Invalid;
+        switch (m_type) {
+        case Raster_RGBMask:
+            format = QFontEngineFT::Format_A32;
+            imageFormat = QImage::Format_RGB32;
+            break;
+        case Raster_A8:
+            format = QFontEngineFT::Format_A8;
+            imageFormat = QImage::Format_Indexed8;
+            break;
+        case Raster_Mono:
+            format = QFontEngineFT::Format_Mono;
+            imageFormat = QImage::Format_Mono;
+            break;
+        };
+
+        QFontEngineFT *ft = static_cast<QFontEngineFT*> (m_current_fontengine);
+        QFontEngineFT::QGlyphSet *gset = ft->loadTransformedGlyphSet(m_transform);
+        QFixedPoint positions[1];
+        positions[0].x = subPixelPosition;
+
+        if (gset && ft->loadGlyphs(gset, &g, 1, positions, format)) {
+            QFontEngineFT::Glyph *glyph = gset->getGlyph(g, subPixelPosition);
+            const int bytesPerLine = (format == QFontEngineFT::Format_Mono ? ((glyph->width + 31) & ~31) >> 3
+                               : (glyph->width + 3) & ~3);
+            return QImage(glyph->data, glyph->width, glyph->height, bytesPerLine, imageFormat);
+        }
+    } else
+#endif
+    if (m_type == QFontEngineGlyphCache::Raster_RGBMask)
+        return m_current_fontengine->alphaRGBMapForGlyph(g, subPixelPosition, glyphMargin(), m_transform);
+    else
+        return m_current_fontengine->alphaMapForGlyph(g, subPixelPosition, m_transform);
+
+    return QImage();
+}
+
+/************************************************************************
+ * QImageTextureGlyphCache
+ */
+
+void QImageTextureGlyphCache::resizeTextureData(int width, int height)
+{
+    m_image = m_image.copy(0, 0, width, height);
+}
+
+void QImageTextureGlyphCache::createTextureData(int width, int height)
+{
+    switch (m_type) {
+    case QFontEngineGlyphCache::Raster_Mono:
+        m_image = QImage(width, height, QImage::Format_Mono);
+        break;
+    case QFontEngineGlyphCache::Raster_A8: {
+        m_image = QImage(width, height, QImage::Format_Indexed8);
+        m_image.fill(0);
+        QVector<QRgb> colors(256);
+        QRgb *it = colors.data();
+        for (int i=0; i<256; ++i, ++it)
+            *it = 0xff000000 | i | (i<<8) | (i<<16);
+        m_image.setColorTable(colors);
+        break;   }
+    case QFontEngineGlyphCache::Raster_RGBMask:
+        m_image = QImage(width, height, QImage::Format_RGB32);
+        break;
+    }
+}
+
+int QImageTextureGlyphCache::glyphMargin() const
+{
+#if (defined(Q_WS_MAC) && defined(QT_MAC_USE_COCOA)) || defined(Q_WS_X11)
+    return 0;
+#else
+    return m_type == QFontEngineGlyphCache::Raster_RGBMask ? 2 : 0;
+#endif
+}
+
+void QImageTextureGlyphCache::fillTexture(const Coord &c, glyph_t g, QFixed subPixelPosition)
+{
+    QImage mask = textureMapForGlyph(g, subPixelPosition);
+
+#ifdef CACHE_DEBUG
+    printf("fillTexture of %dx%d at %d,%d in the cache of %dx%d\n", c.w, c.h, c.x, c.y, m_image.width(), m_image.height());
+    if (mask.width() > c.w || mask.height() > c.h) {
+        printf("   ERROR; mask is bigger than reserved space! %dx%d instead of %dx%d\n", mask.width(), mask.height(), c.w,c.h);
+        return;
+    }
+#endif
+
+    if (m_type == QFontEngineGlyphCache::Raster_RGBMask) {        
+        QImage ref(m_image.bits() + (c.x * 4 + c.y * m_image.bytesPerLine()),
+                   qMax(mask.width(), c.w), qMax(mask.height(), c.h), m_image.bytesPerLine(),
+                   m_image.format());
+        QPainter p(&ref);
+        p.setCompositionMode(QPainter::CompositionMode_Source);
+        p.fillRect(0, 0, c.w, c.h, QColor(0,0,0,0)); // TODO optimize this
+        p.drawImage(0, 0, mask);
+        p.end();
+    } else if (m_type == QFontEngineGlyphCache::Raster_Mono) {
+        if (mask.depth() > 1) {
+            // TODO optimize this
+            mask = mask.alphaChannel();
+            mask.invertPixels();
+            mask = mask.convertToFormat(QImage::Format_Mono);
+        }
+
+        int mw = qMin(mask.width(), c.w);
+        int mh = qMin(mask.height(), c.h);
+        uchar *d = m_image.bits();
+        int dbpl = m_image.bytesPerLine();
+
+        for (int y = 0; y < c.h; ++y) {
+            uchar *dest = d + (c.y + y) *dbpl + c.x/8;
+
+            if (y < mh) {
+                uchar *src = mask.scanLine(y);
+                for (int x = 0; x < c.w/8; ++x) {
+                    if (x < (mw+7)/8)
+                        dest[x] = src[x];
+                    else
+                        dest[x] = 0;
+                }
+            } else {
+                for (int x = 0; x < c.w/8; ++x)
+                    dest[x] = 0;
+            }
+        }
+    } else { // A8
+        int mw = qMin(mask.width(), c.w);
+        int mh = qMin(mask.height(), c.h);
+        uchar *d = m_image.bits();
+        int dbpl = m_image.bytesPerLine();
+
+        if (mask.depth() == 1) {
+            for (int y = 0; y < c.h; ++y) {
+                uchar *dest = d + (c.y + y) *dbpl + c.x;
+                if (y < mh) {
+                    uchar *src = (uchar *) mask.scanLine(y);
+                    for (int x = 0; x < c.w; ++x) {
+                        if (x < mw)
+                            dest[x] = (src[x >> 3] & (1 << (7 - (x & 7)))) > 0 ? 255 : 0;
+                    }
+                }
+            }
+        } else if (mask.depth() == 8) {
+            for (int y = 0; y < c.h; ++y) {
+                uchar *dest = d + (c.y + y) *dbpl + c.x;
+                if (y < mh) {
+                    uchar *src = (uchar *) mask.scanLine(y);
+                    for (int x = 0; x < c.w; ++x) {
+                        if (x < mw)
+                            dest[x] = src[x];
+                    }
+                }
+            }
+        }
+    }
+
+#ifdef CACHE_DEBUG
+//     QPainter p(&m_image);
+//     p.drawLine(
+    QPoint base(c.x + glyphMargin(), c.y + glyphMargin() + c.baseLineY-1);
+    if (m_image.rect().contains(base))
+        m_image.setPixel(base, 255);
+    m_image.save(QString::fromLatin1("cache-%1.png").arg(qint64(this)));
+#endif
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qtextureglyphcache_p.h b/src/gui/painting/qtextureglyphcache_p.h
new file mode 100644
index 0000000000..922e2901bd
--- /dev/null
+++ b/src/gui/painting/qtextureglyphcache_p.h
@@ -0,0 +1,189 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QTEXTUREGLYPHCACHE_P_H
+#define QTEXTUREGLYPHCACHE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of other Qt classes.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <qhash.h>
+#include <qimage.h>
+#include <qobject.h>
+#include <qtransform.h>
+
+#include <private/qfontengineglyphcache_p.h>
+
+#if defined(Q_OS_VXWORKS) && defined(m_type)
+#  undef m_type
+#endif
+
+#ifndef QT_DEFAULT_TEXTURE_GLYPH_CACHE_WIDTH
+#define QT_DEFAULT_TEXTURE_GLYPH_CACHE_WIDTH 256
+#endif
+
+struct glyph_metrics_t;
+typedef unsigned int glyph_t;
+
+
+QT_BEGIN_NAMESPACE
+
+class QTextItemInt;
+
+class Q_GUI_EXPORT QTextureGlyphCache : public QFontEngineGlyphCache
+{
+public:
+    QTextureGlyphCache(QFontEngineGlyphCache::Type type, const QTransform &matrix)
+        : QFontEngineGlyphCache(matrix, type), m_current_fontengine(0),
+                                               m_w(0), m_h(0), m_cx(0), m_cy(0), m_currentRowHeight(0), m_subPixelPositionCount(0)
+        { }
+
+    virtual ~QTextureGlyphCache() { }
+
+    struct GlyphAndSubPixelPosition
+    {
+        GlyphAndSubPixelPosition(glyph_t g, QFixed spp) : glyph(g), subPixelPosition(spp) {}
+
+        bool operator==(const GlyphAndSubPixelPosition &other) const
+        {
+            return glyph == other.glyph && subPixelPosition == other.subPixelPosition;
+        }
+
+        glyph_t glyph;
+        QFixed subPixelPosition;
+    };
+
+    struct Coord {
+        int x;
+        int y;
+        int w;
+        int h;
+
+        int baseLineX;
+        int baseLineY;
+
+        bool isNull() const
+        {
+            return w == 0 || h == 0;
+        }
+    };
+
+    bool populate(QFontEngine *fontEngine, int numGlyphs, const glyph_t *glyphs,
+                  const QFixedPoint *positions);
+    void fillInPendingGlyphs();
+
+    virtual void createTextureData(int width, int height) = 0;
+    virtual void resizeTextureData(int width, int height) = 0;
+    virtual int glyphMargin() const { return 0; }
+    virtual int glyphPadding() const { return 0; }
+
+    virtual void fillTexture(const Coord &coord, glyph_t glyph, QFixed subPixelPosition) = 0;
+
+    inline void createCache(int width, int height) {
+        m_w = width;
+        m_h = height;
+        createTextureData(width, height);
+    }
+
+    inline void resizeCache(int width, int height)
+    {
+        resizeTextureData(width, height);
+        m_w = width;
+        m_h = height;
+    }
+
+    inline bool isNull() const { return m_h == 0; }
+
+    QHash<GlyphAndSubPixelPosition, Coord> coords;
+    virtual int maxTextureWidth() const { return QT_DEFAULT_TEXTURE_GLYPH_CACHE_WIDTH; }
+    virtual int maxTextureHeight() const { return -1; }
+
+    QImage textureMapForGlyph(glyph_t g, QFixed subPixelPosition) const;
+
+    QFixed subPixelPositionForX(QFixed x) const;
+
+protected:
+    int calculateSubPixelPositionCount(glyph_t) const;
+
+    QFontEngine *m_current_fontengine;
+    QHash<GlyphAndSubPixelPosition, Coord> m_pendingGlyphs;
+
+    int m_w; // image width
+    int m_h; // image height
+    int m_cx; // current x
+    int m_cy; // current y
+    int m_currentRowHeight; // Height of last row
+    int m_subPixelPositionCount; // Number of positions within a single pixel for this cache
+};
+
+inline uint qHash(const QTextureGlyphCache::GlyphAndSubPixelPosition &g)
+{
+    return (g.glyph << 8)  | (g.subPixelPosition * 10).round().toInt();
+}
+
+
+class Q_GUI_EXPORT QImageTextureGlyphCache : public QTextureGlyphCache
+{
+public:
+    QImageTextureGlyphCache(QFontEngineGlyphCache::Type type, const QTransform &matrix)
+        : QTextureGlyphCache(type, matrix) { }
+    virtual int glyphMargin() const;
+    virtual void createTextureData(int width, int height);
+    virtual void resizeTextureData(int width, int height);
+    virtual void fillTexture(const Coord &c, glyph_t glyph, QFixed subPixelPosition);
+
+    inline const QImage &image() const { return m_image; }
+
+private:
+    QImage m_image;
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/gui/painting/qtransform.cpp b/src/gui/painting/qtransform.cpp
new file mode 100644
index 0000000000..7d11e2fd07
--- /dev/null
+++ b/src/gui/painting/qtransform.cpp
@@ -0,0 +1,2301 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include "qtransform.h"
+
+#include "qdatastream.h"
+#include "qdebug.h"
+#include "qmatrix.h"
+#include "qregion.h"
+#include "qpainterpath.h"
+#include "qvariant.h"
+#include <qmath.h>
+#include <qnumeric.h>
+
+#include <private/qbezier_p.h>
+
+QT_BEGIN_NAMESPACE
+
+#define Q_NEAR_CLIP (sizeof(qreal) == sizeof(double) ? 0.000001 : 0.0001)
+
+#ifdef MAP
+#  undef MAP
+#endif
+#define MAP(x, y, nx, ny) \
+    do { \
+        qreal FX_ = x; \
+        qreal FY_ = y; \
+        switch(t) {   \
+        case TxNone:  \
+            nx = FX_;   \
+            ny = FY_;   \
+            break;    \
+        case TxTranslate:    \
+            nx = FX_ + affine._dx;                \
+            ny = FY_ + affine._dy;                \
+            break;                              \
+        case TxScale:                           \
+            nx = affine._m11 * FX_ + affine._dx;  \
+            ny = affine._m22 * FY_ + affine._dy;  \
+            break;                              \
+        case TxRotate:                          \
+        case TxShear:                           \
+        case TxProject:                                      \
+            nx = affine._m11 * FX_ + affine._m21 * FY_ + affine._dx;        \
+            ny = affine._m12 * FX_ + affine._m22 * FY_ + affine._dy;        \
+            if (t == TxProject) {                                       \
+                qreal w = (m_13 * FX_ + m_23 * FY_ + m_33);              \
+                if (w < qreal(Q_NEAR_CLIP)) w = qreal(Q_NEAR_CLIP);     \
+                w = 1./w;                                               \
+                nx *= w;                                                \
+                ny *= w;                                                \
+            }                                                           \
+        }                                                               \
+    } while (0)
+
+/*!
+    \class QTransform
+    \brief The QTransform class specifies 2D transformations of a coordinate system.
+    \since 4.3
+    \ingroup painting
+
+    A transformation specifies how to translate, scale, shear, rotate
+    or project the coordinate system, and is typically used when
+    rendering graphics.
+
+    QTransform differs from QMatrix in that it is a true 3x3 matrix,
+    allowing perspective transformations. QTransform's toAffine()
+    method allows casting QTransform to QMatrix. If a perspective
+    transformation has been specified on the matrix, then the
+    conversion will cause loss of data.
+
+    QTransform is the recommended transformation class in Qt.
+
+    A QTransform object can be built using the setMatrix(), scale(),
+    rotate(), translate() and shear() functions.  Alternatively, it
+    can be built by applying \l {QTransform#Basic Matrix
+    Operations}{basic matrix operations}. The matrix can also be
+    defined when constructed, and it can be reset to the identity
+    matrix (the default) using the reset() function.
+
+    The QTransform class supports mapping of graphic primitives: A given
+    point, line, polygon, region, or painter path can be mapped to the
+    coordinate system defined by \e this matrix using the map()
+    function. In case of a rectangle, its coordinates can be
+    transformed using the mapRect() function. A rectangle can also be
+    transformed into a \e polygon (mapped to the coordinate system
+    defined by \e this matrix), using the mapToPolygon() function.
+
+    QTransform provides the isIdentity() function which returns true if
+    the matrix is the identity matrix, and the isInvertible() function
+    which returns true if the matrix is non-singular (i.e. AB = BA =
+    I). The inverted() function returns an inverted copy of \e this
+    matrix if it is invertible (otherwise it returns the identity
+    matrix), and adjoint() returns the matrix's classical adjoint.
+    In addition, QTransform provides the determinant() function which
+    returns the matrix's determinant.
+
+    Finally, the QTransform class supports matrix multiplication, addition
+    and subtraction, and objects of the class can be streamed as well
+    as compared.
+
+    \tableofcontents
+
+    \section1 Rendering Graphics
+
+    When rendering graphics, the matrix defines the transformations
+    but the actual transformation is performed by the drawing routines
+    in QPainter.
+
+    By default, QPainter operates on the associated device's own
+    coordinate system.  The standard coordinate system of a
+    QPaintDevice has its origin located at the top-left position. The
+    \e x values increase to the right; \e y values increase
+    downward. For a complete description, see the \l {Coordinate
+    System} {coordinate system} documentation.
+
+    QPainter has functions to translate, scale, shear and rotate the
+    coordinate system without using a QTransform. For example:
+
+    \table 100%
+    \row
+    \o \inlineimage qtransform-simpletransformation.png
+    \o
+    \snippet doc/src/snippets/transform/main.cpp 0
+    \endtable
+
+    Although these functions are very convenient, it can be more
+    efficient to build a QTransform and call QPainter::setTransform() if you
+    want to perform more than a single transform operation. For
+    example:
+
+    \table 100%
+    \row
+    \o \inlineimage qtransform-combinedtransformation.png
+    \o
+    \snippet doc/src/snippets/transform/main.cpp 1
+    \endtable
+
+    \section1 Basic Matrix Operations
+
+    \image qtransform-representation.png
+
+    A QTransform object contains a 3 x 3 matrix.  The \c m31 (\c dx) and
+    \c m32 (\c dy) elements specify horizontal and vertical translation.
+    The \c m11 and \c m22 elements specify horizontal and vertical scaling.
+    The \c m21 and \c m12 elements specify horizontal and vertical \e shearing.
+    And finally, the \c m13 and \c m23 elements specify horizontal and vertical
+    projection, with \c m33 as an additional projection factor.
+
+    QTransform transforms a point in the plane to another point using the
+    following formulas:
+
+    \snippet doc/src/snippets/code/src_gui_painting_qtransform.cpp 0
+
+    The point \e (x, y) is the original point, and \e (x', y') is the
+    transformed point. \e (x', y') can be transformed back to \e (x,
+    y) by performing the same operation on the inverted() matrix.
+
+    The various matrix elements can be set when constructing the
+    matrix, or by using the setMatrix() function later on. They can also
+    be manipulated using the translate(), rotate(), scale() and
+    shear() convenience functions. The currently set values can be
+    retrieved using the m11(), m12(), m13(), m21(), m22(), m23(),
+    m31(), m32(), m33(), dx() and dy() functions.
+
+    Translation is the simplest transformation. Setting \c dx and \c
+    dy will move the coordinate system \c dx units along the X axis
+    and \c dy units along the Y axis.  Scaling can be done by setting
+    \c m11 and \c m22. For example, setting \c m11 to 2 and \c m22 to
+    1.5 will double the height and increase the width by 50%.  The
+    identity matrix has \c m11, \c m22, and \c m33 set to 1 (all others are set
+    to 0) mapping a point to itself. Shearing is controlled by \c m12
+    and \c m21. Setting these elements to values different from zero
+    will twist the coordinate system. Rotation is achieved by
+    setting both the shearing factors and the scaling factors. Perspective
+    transformation is achieved by setting both the projection factors and
+    the scaling factors.
+
+    Here's the combined transformations example using basic matrix
+    operations:
+
+    \table 100%
+    \row
+    \o \inlineimage qtransform-combinedtransformation2.png
+    \o
+    \snippet doc/src/snippets/transform/main.cpp 2
+    \endtable
+
+    \sa QPainter, {Coordinate System}, {demos/affine}{Affine
+    Transformations Demo}, {Transformations Example}
+*/
+
+/*!
+    \enum QTransform::TransformationType
+
+    \value TxNone
+    \value TxTranslate
+    \value TxScale
+    \value TxRotate
+    \value TxShear
+    \value TxProject
+*/
+
+/*!
+    \fn QTransform::QTransform(Qt::Initialization)
+    \internal
+*/
+
+/*!
+    Constructs an identity matrix.
+
+    All elements are set to zero except \c m11 and \c m22 (specifying
+    the scale) and \c m13 which are set to 1.
+
+    \sa reset()
+*/
+QTransform::QTransform()
+    : affine(true)
+    , m_13(0), m_23(0), m_33(1)
+    , m_type(TxNone)
+    , m_dirty(TxNone)
+{
+}
+
+/*!
+    \fn QTransform::QTransform(qreal m11, qreal m12, qreal m13, qreal m21, qreal m22, qreal m23, qreal m31, qreal m32, qreal m33)
+
+    Constructs a matrix with the elements, \a m11, \a m12, \a m13,
+    \a m21, \a m22, \a m23, \a m31, \a m32, \a m33.
+
+    \sa setMatrix()
+*/
+QTransform::QTransform(qreal h11, qreal h12, qreal h13,
+                       qreal h21, qreal h22, qreal h23,
+                       qreal h31, qreal h32, qreal h33)
+    : affine(h11, h12, h21, h22, h31, h32, true)
+    , m_13(h13), m_23(h23), m_33(h33)
+    , m_type(TxNone)
+    , m_dirty(TxProject)
+{
+}
+
+/*!
+    \fn QTransform::QTransform(qreal m11, qreal m12, qreal m21, qreal m22, qreal dx, qreal dy)
+
+    Constructs a matrix with the elements, \a m11, \a m12, \a m21, \a m22, \a dx and \a dy.
+
+    \sa setMatrix()
+*/
+QTransform::QTransform(qreal h11, qreal h12, qreal h21,
+                       qreal h22, qreal dx, qreal dy)
+    : affine(h11, h12, h21, h22, dx, dy, true)
+    , m_13(0), m_23(0), m_33(1)
+    , m_type(TxNone)
+    , m_dirty(TxShear)
+{
+}
+
+/*!
+    \fn QTransform::QTransform(const QMatrix &matrix)
+
+    Constructs a matrix that is a copy of the given \a matrix.
+    Note that the \c m13, \c m23, and \c m33 elements are set to 0, 0,
+    and 1 respectively.
+ */
+QTransform::QTransform(const QMatrix &mtx)
+    : affine(mtx._m11, mtx._m12, mtx._m21, mtx._m22, mtx._dx, mtx._dy, true),
+      m_13(0), m_23(0), m_33(1)
+    , m_type(TxNone)
+    , m_dirty(TxShear)
+{
+}
+
+/*!
+    Returns the adjoint of this matrix.
+*/
+QTransform QTransform::adjoint() const
+{
+    qreal h11, h12, h13,
+        h21, h22, h23,
+        h31, h32, h33;
+    h11 = affine._m22*m_33 - m_23*affine._dy;
+    h21 = m_23*affine._dx - affine._m21*m_33;
+    h31 = affine._m21*affine._dy - affine._m22*affine._dx;
+    h12 = m_13*affine._dy - affine._m12*m_33;
+    h22 = affine._m11*m_33 - m_13*affine._dx;
+    h32 = affine._m12*affine._dx - affine._m11*affine._dy;
+    h13 = affine._m12*m_23 - m_13*affine._m22;
+    h23 = m_13*affine._m21 - affine._m11*m_23;
+    h33 = affine._m11*affine._m22 - affine._m12*affine._m21;
+
+    return QTransform(h11, h12, h13,
+                      h21, h22, h23,
+                      h31, h32, h33, true);
+}
+
+/*!
+    Returns the transpose of this matrix.
+*/
+QTransform QTransform::transposed() const
+{
+    QTransform t(affine._m11, affine._m21, affine._dx,
+                 affine._m12, affine._m22, affine._dy,
+                 m_13, m_23, m_33, true);
+    t.m_type = m_type;
+    t.m_dirty = m_dirty;
+    return t;
+}
+
+/*!
+    Returns an inverted copy of this matrix.
+
+    If the matrix is singular (not invertible), the returned matrix is
+    the identity matrix. If \a invertible is valid (i.e. not 0), its
+    value is set to true if the matrix is invertible, otherwise it is
+    set to false.
+
+    \sa isInvertible()
+*/
+QTransform QTransform::inverted(bool *invertible) const
+{
+    QTransform invert(true);
+    bool inv = true;
+
+    switch(inline_type()) {
+    case TxNone:
+        break;
+    case TxTranslate:
+        invert.affine._dx = -affine._dx;
+        invert.affine._dy = -affine._dy;
+        break;
+    case TxScale:
+        inv = !qFuzzyIsNull(affine._m11);
+        inv &= !qFuzzyIsNull(affine._m22);
+        if (inv) {
+            invert.affine._m11 = 1. / affine._m11;
+            invert.affine._m22 = 1. / affine._m22;
+            invert.affine._dx = -affine._dx * invert.affine._m11;
+            invert.affine._dy = -affine._dy * invert.affine._m22;
+        }
+        break;
+    case TxRotate:
+    case TxShear:
+        invert.affine = affine.inverted(&inv);
+        break;
+    default:
+        // general case
+        qreal det = determinant();
+        inv = !qFuzzyIsNull(det);
+        if (inv)
+            invert = adjoint() / det;
+        break;
+    }
+
+    if (invertible)
+        *invertible = inv;
+
+    if (inv) {
+        // inverting doesn't change the type
+        invert.m_type = m_type;
+        invert.m_dirty = m_dirty;
+    }
+
+    return invert;
+}
+
+/*!
+    Moves the coordinate system \a dx along the x axis and \a dy along
+    the y axis, and returns a reference to the matrix.
+
+    \sa setMatrix()
+*/
+QTransform &QTransform::translate(qreal dx, qreal dy)
+{
+    if (dx == 0 && dy == 0)
+        return *this;
+#ifndef QT_NO_DEBUG
+    if (qIsNaN(dx) | qIsNaN(dy)) {
+        qWarning() << "QTransform::translate with NaN called";
+        return *this;
+    }
+#endif
+
+    switch(inline_type()) {
+    case TxNone:
+        affine._dx = dx;
+        affine._dy = dy;
+        break;
+    case TxTranslate:
+        affine._dx += dx;
+        affine._dy += dy;
+        break;
+    case TxScale:
+        affine._dx += dx*affine._m11;
+        affine._dy += dy*affine._m22;
+        break;
+    case TxProject:
+        m_33 += dx*m_13 + dy*m_23;
+        // Fall through
+    case TxShear:
+    case TxRotate:
+        affine._dx += dx*affine._m11 + dy*affine._m21;
+        affine._dy += dy*affine._m22 + dx*affine._m12;
+        break;
+    }
+    if (m_dirty < TxTranslate)
+        m_dirty = TxTranslate;
+    return *this;
+}
+
+/*!
+    Creates a matrix which corresponds to a translation of \a dx along
+    the x axis and \a dy along the y axis. This is the same as
+    QTransform().translate(dx, dy) but slightly faster.
+
+    \since 4.5
+*/
+QTransform QTransform::fromTranslate(qreal dx, qreal dy)
+{
+#ifndef QT_NO_DEBUG
+    if (qIsNaN(dx) | qIsNaN(dy)) {
+        qWarning() << "QTransform::fromTranslate with NaN called";
+        return QTransform();
+}
+#endif
+    QTransform transform(1, 0, 0, 0, 1, 0, dx, dy, 1, true);
+    if (dx == 0 && dy == 0)
+        transform.m_type = TxNone;
+    else
+        transform.m_type = TxTranslate;
+    transform.m_dirty = TxNone;
+    return transform;
+}
+
+/*!
+    Scales the coordinate system by \a sx horizontally and \a sy
+    vertically, and returns a reference to the matrix.
+
+    \sa setMatrix()
+*/
+QTransform & QTransform::scale(qreal sx, qreal sy)
+{
+    if (sx == 1 && sy == 1)
+        return *this;
+#ifndef QT_NO_DEBUG
+    if (qIsNaN(sx) | qIsNaN(sy)) {
+        qWarning() << "QTransform::scale with NaN called";
+        return *this;
+    }
+#endif
+
+    switch(inline_type()) {
+    case TxNone:
+    case TxTranslate:
+        affine._m11 = sx;
+        affine._m22 = sy;
+        break;
+    case TxProject:
+        m_13 *= sx;
+        m_23 *= sy;
+        // fall through
+    case TxRotate:
+    case TxShear:
+        affine._m12 *= sx;
+        affine._m21 *= sy;
+        // fall through
+    case TxScale:
+        affine._m11 *= sx;
+        affine._m22 *= sy;
+        break;
+    }
+    if (m_dirty < TxScale)
+        m_dirty = TxScale;
+    return *this;
+}
+
+/*!
+    Creates a matrix which corresponds to a scaling of
+    \a sx horizontally and \a sy vertically.
+    This is the same as QTransform().scale(sx, sy) but slightly faster.
+
+    \since 4.5
+*/
+QTransform QTransform::fromScale(qreal sx, qreal sy)
+{
+#ifndef QT_NO_DEBUG
+    if (qIsNaN(sx) | qIsNaN(sy)) {
+        qWarning() << "QTransform::fromScale with NaN called";
+        return QTransform();
+}
+#endif
+    QTransform transform(sx, 0, 0, 0, sy, 0, 0, 0, 1, true);
+    if (sx == 1. && sy == 1.)
+        transform.m_type = TxNone;
+    else
+        transform.m_type = TxScale;
+    transform.m_dirty = TxNone;
+    return transform;
+}
+
+/*!
+    Shears the coordinate system by \a sh horizontally and \a sv
+    vertically, and returns a reference to the matrix.
+
+    \sa setMatrix()
+*/
+QTransform & QTransform::shear(qreal sh, qreal sv)
+{
+    if (sh == 0 && sv == 0)
+        return *this;
+#ifndef QT_NO_DEBUG
+    if (qIsNaN(sh) | qIsNaN(sv)) {
+        qWarning() << "QTransform::shear with NaN called";
+        return *this;
+    }
+#endif
+
+    switch(inline_type()) {
+    case TxNone:
+    case TxTranslate:
+        affine._m12 = sv;
+        affine._m21 = sh;
+        break;
+    case TxScale:
+        affine._m12 = sv*affine._m22;
+        affine._m21 = sh*affine._m11;
+        break;
+    case TxProject: {
+        qreal tm13 = sv*m_23;
+        qreal tm23 = sh*m_13;
+        m_13 += tm13;
+        m_23 += tm23;
+    }
+        // fall through
+    case TxRotate:
+    case TxShear: {
+        qreal tm11 = sv*affine._m21;
+        qreal tm22 = sh*affine._m12;
+        qreal tm12 = sv*affine._m22;
+        qreal tm21 = sh*affine._m11;
+        affine._m11 += tm11; affine._m12 += tm12;
+        affine._m21 += tm21; affine._m22 += tm22;
+        break;
+    }
+    }
+    if (m_dirty < TxShear)
+        m_dirty = TxShear;
+    return *this;
+}
+
+const qreal deg2rad = qreal(0.017453292519943295769);        // pi/180
+const qreal inv_dist_to_plane = 1. / 1024.;
+
+/*!
+    \fn QTransform &QTransform::rotate(qreal angle, Qt::Axis axis)
+
+    Rotates the coordinate system counterclockwise by the given \a angle
+    about the specified \a axis and returns a reference to the matrix.
+
+    Note that if you apply a QTransform to a point defined in widget
+    coordinates, the direction of the rotation will be clockwise
+    because the y-axis points downwards.
+
+    The angle is specified in degrees.
+
+    \sa setMatrix()
+*/
+QTransform & QTransform::rotate(qreal a, Qt::Axis axis)
+{
+    if (a == 0)
+        return *this;
+#ifndef QT_NO_DEBUG
+    if (qIsNaN(a)) {
+        qWarning() << "QTransform::rotate with NaN called";
+        return *this;
+    }
+#endif
+
+    qreal sina = 0;
+    qreal cosa = 0;
+    if (a == 90. || a == -270.)
+        sina = 1.;
+    else if (a == 270. || a == -90.)
+        sina = -1.;
+    else if (a == 180.)
+        cosa = -1.;
+    else{
+        qreal b = deg2rad*a;          // convert to radians
+        sina = qSin(b);               // fast and convenient
+        cosa = qCos(b);
+    }
+
+    if (axis == Qt::ZAxis) {
+        switch(inline_type()) {
+        case TxNone:
+        case TxTranslate:
+            affine._m11 = cosa;
+            affine._m12 = sina;
+            affine._m21 = -sina;
+            affine._m22 = cosa;
+            break;
+        case TxScale: {
+            qreal tm11 = cosa*affine._m11;
+            qreal tm12 = sina*affine._m22;
+            qreal tm21 = -sina*affine._m11;
+            qreal tm22 = cosa*affine._m22;
+            affine._m11 = tm11; affine._m12 = tm12;
+            affine._m21 = tm21; affine._m22 = tm22;
+            break;
+        }
+        case TxProject: {
+            qreal tm13 = cosa*m_13 + sina*m_23;
+            qreal tm23 = -sina*m_13 + cosa*m_23;
+            m_13 = tm13;
+            m_23 = tm23;
+            // fall through
+        }
+        case TxRotate:
+        case TxShear: {
+            qreal tm11 = cosa*affine._m11 + sina*affine._m21;
+            qreal tm12 = cosa*affine._m12 + sina*affine._m22;
+            qreal tm21 = -sina*affine._m11 + cosa*affine._m21;
+            qreal tm22 = -sina*affine._m12 + cosa*affine._m22;
+            affine._m11 = tm11; affine._m12 = tm12;
+            affine._m21 = tm21; affine._m22 = tm22;
+            break;
+        }
+        }
+        if (m_dirty < TxRotate)
+            m_dirty = TxRotate;
+    } else {
+        QTransform result;
+        if (axis == Qt::YAxis) {
+            result.affine._m11 = cosa;
+            result.m_13 = -sina * inv_dist_to_plane;
+        } else {
+            result.affine._m22 = cosa;
+            result.m_23 = -sina * inv_dist_to_plane;
+        }
+        result.m_type = TxProject;
+        *this = result * *this;
+    }
+
+    return *this;
+}
+
+/*!
+    \fn QTransform & QTransform::rotateRadians(qreal angle, Qt::Axis axis)
+
+    Rotates the coordinate system counterclockwise by the given \a angle
+    about the specified \a axis and returns a reference to the matrix.
+
+    Note that if you apply a QTransform to a point defined in widget
+    coordinates, the direction of the rotation will be clockwise
+    because the y-axis points downwards.
+
+    The angle is specified in radians.
+
+    \sa setMatrix()
+*/
+QTransform & QTransform::rotateRadians(qreal a, Qt::Axis axis)
+{
+#ifndef QT_NO_DEBUG
+    if (qIsNaN(a)) {
+        qWarning() << "QTransform::rotateRadians with NaN called";
+        return *this;
+    }
+#endif
+    qreal sina = qSin(a);
+    qreal cosa = qCos(a);
+
+    if (axis == Qt::ZAxis) {
+        switch(inline_type()) {
+        case TxNone:
+        case TxTranslate:
+            affine._m11 = cosa;
+            affine._m12 = sina;
+            affine._m21 = -sina;
+            affine._m22 = cosa;
+            break;
+        case TxScale: {
+            qreal tm11 = cosa*affine._m11;
+            qreal tm12 = sina*affine._m22;
+            qreal tm21 = -sina*affine._m11;
+            qreal tm22 = cosa*affine._m22;
+            affine._m11 = tm11; affine._m12 = tm12;
+            affine._m21 = tm21; affine._m22 = tm22;
+            break;
+        }
+        case TxProject: {
+            qreal tm13 = cosa*m_13 + sina*m_23;
+            qreal tm23 = -sina*m_13 + cosa*m_23;
+            m_13 = tm13;
+            m_23 = tm23;
+            // fall through
+        }
+        case TxRotate:
+        case TxShear: {
+            qreal tm11 = cosa*affine._m11 + sina*affine._m21;
+            qreal tm12 = cosa*affine._m12 + sina*affine._m22;
+            qreal tm21 = -sina*affine._m11 + cosa*affine._m21;
+            qreal tm22 = -sina*affine._m12 + cosa*affine._m22;
+            affine._m11 = tm11; affine._m12 = tm12;
+            affine._m21 = tm21; affine._m22 = tm22;
+            break;
+        }
+        }
+        if (m_dirty < TxRotate)
+            m_dirty = TxRotate;
+    } else {
+        QTransform result;
+        if (axis == Qt::YAxis) {
+            result.affine._m11 = cosa;
+            result.m_13 = -sina * inv_dist_to_plane;
+        } else {
+            result.affine._m22 = cosa;
+            result.m_23 = -sina * inv_dist_to_plane;
+        }
+        result.m_type = TxProject;
+        *this = result * *this;
+    }
+    return *this;
+}
+
+/*!
+    \fn bool QTransform::operator==(const QTransform &matrix) const
+    Returns true if this matrix is equal to the given \a matrix,
+    otherwise returns false.
+*/
+bool QTransform::operator==(const QTransform &o) const
+{
+    return affine._m11 == o.affine._m11 &&
+           affine._m12 == o.affine._m12 &&
+           affine._m21 == o.affine._m21 &&
+           affine._m22 == o.affine._m22 &&
+           affine._dx == o.affine._dx &&
+           affine._dy == o.affine._dy &&
+           m_13 == o.m_13 &&
+           m_23 == o.m_23 &&
+           m_33 == o.m_33;
+}
+
+/*!
+    \fn bool QTransform::operator!=(const QTransform &matrix) const
+    Returns true if this matrix is not equal to the given \a matrix,
+    otherwise returns false.
+*/
+bool QTransform::operator!=(const QTransform &o) const
+{
+    return !operator==(o);
+}
+
+/*!
+    \fn QTransform & QTransform::operator*=(const QTransform &matrix)
+    \overload
+
+    Returns the result of multiplying this matrix by the given \a
+    matrix.
+*/
+QTransform & QTransform::operator*=(const QTransform &o)
+{
+    const TransformationType otherType = o.inline_type();
+    if (otherType == TxNone)
+        return *this;
+
+    const TransformationType thisType = inline_type();
+    if (thisType == TxNone)
+        return operator=(o);
+
+    TransformationType t = qMax(thisType, otherType);
+    switch(t) {
+    case TxNone:
+        break;
+    case TxTranslate:
+        affine._dx += o.affine._dx;
+        affine._dy += o.affine._dy;
+        break;
+    case TxScale:
+    {
+        qreal m11 = affine._m11*o.affine._m11;
+        qreal m22 = affine._m22*o.affine._m22;
+
+        qreal m31 = affine._dx*o.affine._m11 + o.affine._dx;
+        qreal m32 = affine._dy*o.affine._m22 + o.affine._dy;
+
+        affine._m11 = m11;
+        affine._m22 = m22;
+        affine._dx = m31; affine._dy = m32;
+        break;
+    }
+    case TxRotate:
+    case TxShear:
+    {
+        qreal m11 = affine._m11*o.affine._m11 + affine._m12*o.affine._m21;
+        qreal m12 = affine._m11*o.affine._m12 + affine._m12*o.affine._m22;
+
+        qreal m21 = affine._m21*o.affine._m11 + affine._m22*o.affine._m21;
+        qreal m22 = affine._m21*o.affine._m12 + affine._m22*o.affine._m22;
+
+        qreal m31 = affine._dx*o.affine._m11 + affine._dy*o.affine._m21 + o.affine._dx;
+        qreal m32 = affine._dx*o.affine._m12 + affine._dy*o.affine._m22 + o.affine._dy;
+
+        affine._m11 = m11; affine._m12 = m12;
+        affine._m21 = m21; affine._m22 = m22;
+        affine._dx = m31; affine._dy = m32;
+        break;
+    }
+    case TxProject:
+    {
+        qreal m11 = affine._m11*o.affine._m11 + affine._m12*o.affine._m21 + m_13*o.affine._dx;
+        qreal m12 = affine._m11*o.affine._m12 + affine._m12*o.affine._m22 + m_13*o.affine._dy;
+        qreal m13 = affine._m11*o.m_13 + affine._m12*o.m_23 + m_13*o.m_33;
+
+        qreal m21 = affine._m21*o.affine._m11 + affine._m22*o.affine._m21 + m_23*o.affine._dx;
+        qreal m22 = affine._m21*o.affine._m12 + affine._m22*o.affine._m22 + m_23*o.affine._dy;
+        qreal m23 = affine._m21*o.m_13 + affine._m22*o.m_23 + m_23*o.m_33;
+
+        qreal m31 = affine._dx*o.affine._m11 + affine._dy*o.affine._m21 + m_33*o.affine._dx;
+        qreal m32 = affine._dx*o.affine._m12 + affine._dy*o.affine._m22 + m_33*o.affine._dy;
+        qreal m33 = affine._dx*o.m_13 + affine._dy*o.m_23 + m_33*o.m_33;
+
+        affine._m11 = m11; affine._m12 = m12; m_13 = m13;
+        affine._m21 = m21; affine._m22 = m22; m_23 = m23;
+        affine._dx = m31; affine._dy = m32; m_33 = m33;
+    }
+    }
+
+    m_dirty = t;
+    m_type = t;
+
+    return *this;
+}
+
+/*!
+    \fn QTransform QTransform::operator*(const QTransform &matrix) const
+    Returns the result of multiplying this matrix by the given \a
+    matrix.
+
+    Note that matrix multiplication is not commutative, i.e. a*b !=
+    b*a.
+*/
+QTransform QTransform::operator*(const QTransform &m) const
+{
+    const TransformationType otherType = m.inline_type();
+    if (otherType == TxNone)
+        return *this;
+
+    const TransformationType thisType = inline_type();
+    if (thisType == TxNone)
+        return m;
+
+    QTransform t(true);
+    TransformationType type = qMax(thisType, otherType);
+    switch(type) {
+    case TxNone:
+        break;
+    case TxTranslate:
+        t.affine._dx = affine._dx + m.affine._dx;
+        t.affine._dy += affine._dy + m.affine._dy;
+        break;
+    case TxScale:
+    {
+        qreal m11 = affine._m11*m.affine._m11;
+        qreal m22 = affine._m22*m.affine._m22;
+
+        qreal m31 = affine._dx*m.affine._m11 + m.affine._dx;
+        qreal m32 = affine._dy*m.affine._m22 + m.affine._dy;
+
+        t.affine._m11 = m11;
+        t.affine._m22 = m22;
+        t.affine._dx = m31; t.affine._dy = m32;
+        break;
+    }
+    case TxRotate:
+    case TxShear:
+    {
+        qreal m11 = affine._m11*m.affine._m11 + affine._m12*m.affine._m21;
+        qreal m12 = affine._m11*m.affine._m12 + affine._m12*m.affine._m22;
+
+        qreal m21 = affine._m21*m.affine._m11 + affine._m22*m.affine._m21;
+        qreal m22 = affine._m21*m.affine._m12 + affine._m22*m.affine._m22;
+
+        qreal m31 = affine._dx*m.affine._m11 + affine._dy*m.affine._m21 + m.affine._dx;
+        qreal m32 = affine._dx*m.affine._m12 + affine._dy*m.affine._m22 + m.affine._dy;
+
+        t.affine._m11 = m11; t.affine._m12 = m12;
+        t.affine._m21 = m21; t.affine._m22 = m22;
+        t.affine._dx = m31; t.affine._dy = m32;
+        break;
+    }
+    case TxProject:
+    {
+        qreal m11 = affine._m11*m.affine._m11 + affine._m12*m.affine._m21 + m_13*m.affine._dx;
+        qreal m12 = affine._m11*m.affine._m12 + affine._m12*m.affine._m22 + m_13*m.affine._dy;
+        qreal m13 = affine._m11*m.m_13 + affine._m12*m.m_23 + m_13*m.m_33;
+
+        qreal m21 = affine._m21*m.affine._m11 + affine._m22*m.affine._m21 + m_23*m.affine._dx;
+        qreal m22 = affine._m21*m.affine._m12 + affine._m22*m.affine._m22 + m_23*m.affine._dy;
+        qreal m23 = affine._m21*m.m_13 + affine._m22*m.m_23 + m_23*m.m_33;
+
+        qreal m31 = affine._dx*m.affine._m11 + affine._dy*m.affine._m21 + m_33*m.affine._dx;
+        qreal m32 = affine._dx*m.affine._m12 + affine._dy*m.affine._m22 + m_33*m.affine._dy;
+        qreal m33 = affine._dx*m.m_13 + affine._dy*m.m_23 + m_33*m.m_33;
+
+        t.affine._m11 = m11; t.affine._m12 = m12; t.m_13 = m13;
+        t.affine._m21 = m21; t.affine._m22 = m22; t.m_23 = m23;
+        t.affine._dx = m31; t.affine._dy = m32; t.m_33 = m33;
+    }
+    }
+
+    t.m_dirty = type;
+    t.m_type = type;
+
+    return t;
+}
+
+/*!
+    \fn QTransform & QTransform::operator*=(qreal scalar)
+    \overload
+
+    Returns the result of performing an element-wise multiplication of this
+    matrix with the given \a scalar.
+*/
+
+/*!
+    \fn QTransform & QTransform::operator/=(qreal scalar)
+    \overload
+
+    Returns the result of performing an element-wise division of this
+    matrix by the given \a scalar.
+*/
+
+/*!
+    \fn QTransform & QTransform::operator+=(qreal scalar)
+    \overload
+
+    Returns the matrix obtained by adding the given \a scalar to each
+    element of this matrix.
+*/
+
+/*!
+    \fn QTransform & QTransform::operator-=(qreal scalar)
+    \overload
+
+    Returns the matrix obtained by subtracting the given \a scalar from each
+    element of this matrix.
+*/
+
+/*!
+    Assigns the given \a matrix's values to this matrix.
+*/
+QTransform & QTransform::operator=(const QTransform &matrix)
+{
+    affine._m11 = matrix.affine._m11;
+    affine._m12 = matrix.affine._m12;
+    affine._m21 = matrix.affine._m21;
+    affine._m22 = matrix.affine._m22;
+    affine._dx = matrix.affine._dx;
+    affine._dy = matrix.affine._dy;
+    m_13 = matrix.m_13;
+    m_23 = matrix.m_23;
+    m_33 = matrix.m_33;
+    m_type = matrix.m_type;
+    m_dirty = matrix.m_dirty;
+
+    return *this;
+}
+
+/*!
+    Resets the matrix to an identity matrix, i.e. all elements are set
+    to zero, except \c m11 and \c m22 (specifying the scale) and \c m33
+    which are set to 1.
+
+    \sa QTransform(), isIdentity(), {QTransform#Basic Matrix
+    Operations}{Basic Matrix Operations}
+*/
+void QTransform::reset()
+{
+    affine._m11 = affine._m22 = m_33 = 1.0;
+    affine._m12 = m_13 = affine._m21 = m_23 = affine._dx = affine._dy = 0;
+    m_type = TxNone;
+    m_dirty = TxNone;
+}
+
+#ifndef QT_NO_DATASTREAM
+/*!
+    \fn QDataStream &operator<<(QDataStream &stream, const QTransform &matrix)
+    \since 4.3
+    \relates QTransform
+
+    Writes the given \a matrix to the given \a stream and returns a
+    reference to the stream.
+
+    \sa {Serializing Qt Data Types}
+*/
+QDataStream & operator<<(QDataStream &s, const QTransform &m)
+{
+    s << double(m.m11())
+      << double(m.m12())
+      << double(m.m13())
+      << double(m.m21())
+      << double(m.m22())
+      << double(m.m23())
+      << double(m.m31())
+      << double(m.m32())
+      << double(m.m33());
+    return s;
+}
+
+/*!
+    \fn QDataStream &operator>>(QDataStream &stream, QTransform &matrix)
+    \since 4.3
+    \relates QTransform
+
+    Reads the given \a matrix from the given \a stream and returns a
+    reference to the stream.
+
+    \sa {Serializing Qt Data Types}
+*/
+QDataStream & operator>>(QDataStream &s, QTransform &t)
+{
+     double m11, m12, m13,
+         m21, m22, m23,
+         m31, m32, m33;
+
+     s >> m11;
+     s >> m12;
+     s >> m13;
+     s >> m21;
+     s >> m22;
+     s >> m23;
+     s >> m31;
+     s >> m32;
+     s >> m33;
+     t.setMatrix(m11, m12, m13,
+                 m21, m22, m23,
+                 m31, m32, m33);
+     return s;
+}
+
+#endif // QT_NO_DATASTREAM
+
+#ifndef QT_NO_DEBUG_STREAM
+QDebug operator<<(QDebug dbg, const QTransform &m)
+{
+    static const char *typeStr[] =
+    {
+        "TxNone",
+        "TxTranslate",
+        "TxScale",
+        0,
+        "TxRotate",
+        0, 0, 0,
+        "TxShear",
+        0, 0, 0, 0, 0, 0, 0,
+        "TxProject"
+    };
+
+    dbg.nospace() << "QTransform(type=" << typeStr[m.type()] << ','
+                  << " 11=" << m.m11()
+                  << " 12=" << m.m12()
+                  << " 13=" << m.m13()
+                  << " 21=" << m.m21()
+                  << " 22=" << m.m22()
+                  << " 23=" << m.m23()
+                  << " 31=" << m.m31()
+                  << " 32=" << m.m32()
+                  << " 33=" << m.m33()
+                  << ')';
+
+    return dbg.space();
+}
+#endif
+
+/*!
+    \fn QPoint operator*(const QPoint &point, const QTransform &matrix)
+    \relates QTransform
+
+    This is the same as \a{matrix}.map(\a{point}).
+
+    \sa QTransform::map()
+*/
+QPoint QTransform::map(const QPoint &p) const
+{
+    qreal fx = p.x();
+    qreal fy = p.y();
+
+    qreal x = 0, y = 0;
+
+    TransformationType t = inline_type();
+    switch(t) {
+    case TxNone:
+        x = fx;
+        y = fy;
+        break;
+    case TxTranslate:
+        x = fx + affine._dx;
+        y = fy + affine._dy;
+        break;
+    case TxScale:
+        x = affine._m11 * fx + affine._dx;
+        y = affine._m22 * fy + affine._dy;
+        break;
+    case TxRotate:
+    case TxShear:
+    case TxProject:
+        x = affine._m11 * fx + affine._m21 * fy + affine._dx;
+        y = affine._m12 * fx + affine._m22 * fy + affine._dy;
+        if (t == TxProject) {
+            qreal w = 1./(m_13 * fx + m_23 * fy + m_33);
+            x *= w;
+            y *= w;
+        }
+    }
+    return QPoint(qRound(x), qRound(y));
+}
+
+
+/*!
+    \fn QPointF operator*(const QPointF &point, const QTransform &matrix)
+    \relates QTransform
+
+    Same as \a{matrix}.map(\a{point}).
+
+    \sa QTransform::map()
+*/
+
+/*!
+    \overload
+
+    Creates and returns a QPointF object that is a copy of the given point,
+    \a p, mapped into the coordinate system defined by this matrix.
+*/
+QPointF QTransform::map(const QPointF &p) const
+{
+    qreal fx = p.x();
+    qreal fy = p.y();
+
+    qreal x = 0, y = 0;
+
+    TransformationType t = inline_type();
+    switch(t) {
+    case TxNone:
+        x = fx;
+        y = fy;
+        break;
+    case TxTranslate:
+        x = fx + affine._dx;
+        y = fy + affine._dy;
+        break;
+    case TxScale:
+        x = affine._m11 * fx + affine._dx;
+        y = affine._m22 * fy + affine._dy;
+        break;
+    case TxRotate:
+    case TxShear:
+    case TxProject:
+        x = affine._m11 * fx + affine._m21 * fy + affine._dx;
+        y = affine._m12 * fx + affine._m22 * fy + affine._dy;
+        if (t == TxProject) {
+            qreal w = 1./(m_13 * fx + m_23 * fy + m_33);
+            x *= w;
+            y *= w;
+        }
+    }
+    return QPointF(x, y);
+}
+
+/*!
+    \fn QPoint QTransform::map(const QPoint &point) const
+    \overload
+
+    Creates and returns a QPoint object that is a copy of the given \a
+    point, mapped into the coordinate system defined by this
+    matrix. Note that the transformed coordinates are rounded to the
+    nearest integer.
+*/
+
+/*!
+    \fn QLineF operator*(const QLineF &line, const QTransform &matrix)
+    \relates QTransform
+
+    This is the same as \a{matrix}.map(\a{line}).
+
+    \sa QTransform::map()
+*/
+
+/*!
+    \fn QLine operator*(const QLine &line, const QTransform &matrix)
+    \relates QTransform
+
+    This is the same as \a{matrix}.map(\a{line}).
+
+    \sa QTransform::map()
+*/
+
+/*!
+    \overload
+
+    Creates and returns a QLineF object that is a copy of the given line,
+    \a l, mapped into the coordinate system defined by this matrix.
+*/
+QLine QTransform::map(const QLine &l) const
+{
+    qreal fx1 = l.x1();
+    qreal fy1 = l.y1();
+    qreal fx2 = l.x2();
+    qreal fy2 = l.y2();
+
+    qreal x1 = 0, y1 = 0, x2 = 0, y2 = 0;
+
+    TransformationType t = inline_type();
+    switch(t) {
+    case TxNone:
+        x1 = fx1;
+        y1 = fy1;
+        x2 = fx2;
+        y2 = fy2;
+        break;
+    case TxTranslate:
+        x1 = fx1 + affine._dx;
+        y1 = fy1 + affine._dy;
+        x2 = fx2 + affine._dx;
+        y2 = fy2 + affine._dy;
+        break;
+    case TxScale:
+        x1 = affine._m11 * fx1 + affine._dx;
+        y1 = affine._m22 * fy1 + affine._dy;
+        x2 = affine._m11 * fx2 + affine._dx;
+        y2 = affine._m22 * fy2 + affine._dy;
+        break;
+    case TxRotate:
+    case TxShear:
+    case TxProject:
+        x1 = affine._m11 * fx1 + affine._m21 * fy1 + affine._dx;
+        y1 = affine._m12 * fx1 + affine._m22 * fy1 + affine._dy;
+        x2 = affine._m11 * fx2 + affine._m21 * fy2 + affine._dx;
+        y2 = affine._m12 * fx2 + affine._m22 * fy2 + affine._dy;
+        if (t == TxProject) {
+            qreal w = 1./(m_13 * fx1 + m_23 * fy1 + m_33);
+            x1 *= w;
+            y1 *= w;
+            w = 1./(m_13 * fx2 + m_23 * fy2 + m_33);
+            x2 *= w;
+            y2 *= w;
+        }
+    }
+    return QLine(qRound(x1), qRound(y1), qRound(x2), qRound(y2));
+}
+
+/*!
+    \overload
+
+    \fn QLineF QTransform::map(const QLineF &line) const
+
+    Creates and returns a QLine object that is a copy of the given \a
+    line, mapped into the coordinate system defined by this matrix.
+    Note that the transformed coordinates are rounded to the nearest
+    integer.
+*/
+
+QLineF QTransform::map(const QLineF &l) const
+{
+    qreal fx1 = l.x1();
+    qreal fy1 = l.y1();
+    qreal fx2 = l.x2();
+    qreal fy2 = l.y2();
+
+    qreal x1 = 0, y1 = 0, x2 = 0, y2 = 0;
+
+    TransformationType t = inline_type();
+    switch(t) {
+    case TxNone:
+        x1 = fx1;
+        y1 = fy1;
+        x2 = fx2;
+        y2 = fy2;
+        break;
+    case TxTranslate:
+        x1 = fx1 + affine._dx;
+        y1 = fy1 + affine._dy;
+        x2 = fx2 + affine._dx;
+        y2 = fy2 + affine._dy;
+        break;
+    case TxScale:
+        x1 = affine._m11 * fx1 + affine._dx;
+        y1 = affine._m22 * fy1 + affine._dy;
+        x2 = affine._m11 * fx2 + affine._dx;
+        y2 = affine._m22 * fy2 + affine._dy;
+        break;
+    case TxRotate:
+    case TxShear:
+    case TxProject:
+        x1 = affine._m11 * fx1 + affine._m21 * fy1 + affine._dx;
+        y1 = affine._m12 * fx1 + affine._m22 * fy1 + affine._dy;
+        x2 = affine._m11 * fx2 + affine._m21 * fy2 + affine._dx;
+        y2 = affine._m12 * fx2 + affine._m22 * fy2 + affine._dy;
+        if (t == TxProject) {
+            qreal w = 1./(m_13 * fx1 + m_23 * fy1 + m_33);
+            x1 *= w;
+            y1 *= w;
+            w = 1./(m_13 * fx2 + m_23 * fy2 + m_33);
+            x2 *= w;
+            y2 *= w;
+        }
+    }
+    return QLineF(x1, y1, x2, y2);
+}
+
+static QPolygonF mapProjective(const QTransform &transform, const QPolygonF &poly)
+{
+    if (poly.size() == 0)
+        return poly;
+
+    if (poly.size() == 1)
+        return QPolygonF() << transform.map(poly.at(0));
+
+    QPainterPath path;
+    path.addPolygon(poly);
+
+    path = transform.map(path);
+
+    QPolygonF result;
+    for (int i = 0; i < path.elementCount(); ++i)
+        result << path.elementAt(i);
+    return result;
+}
+
+
+/*!
+    \fn QPolygonF operator *(const QPolygonF &polygon, const QTransform &matrix)
+    \since 4.3
+    \relates QTransform
+
+    This is the same as \a{matrix}.map(\a{polygon}).
+
+    \sa QTransform::map()
+*/
+
+/*!
+    \fn QPolygon operator*(const QPolygon &polygon, const QTransform &matrix)
+    \relates QTransform
+
+    This is the same as \a{matrix}.map(\a{polygon}).
+
+    \sa QTransform::map()
+*/
+
+/*!
+    \fn QPolygonF QTransform::map(const QPolygonF &polygon) const
+    \overload
+
+    Creates and returns a QPolygonF object that is a copy of the given
+    \a polygon, mapped into the coordinate system defined by this
+    matrix.
+*/
+QPolygonF QTransform::map(const QPolygonF &a) const
+{
+    TransformationType t = inline_type();
+    if (t <= TxTranslate)
+        return a.translated(affine._dx, affine._dy);
+
+    if (t >= QTransform::TxProject)
+        return mapProjective(*this, a);
+
+    int size = a.size();
+    int i;
+    QPolygonF p(size);
+    const QPointF *da = a.constData();
+    QPointF *dp = p.data();
+
+    for(i = 0; i < size; ++i) {
+        MAP(da[i].xp, da[i].yp, dp[i].xp, dp[i].yp);
+    }
+    return p;
+}
+
+/*!
+    \fn QPolygon QTransform::map(const QPolygon &polygon) const
+    \overload
+
+    Creates and returns a QPolygon object that is a copy of the given
+    \a polygon, mapped into the coordinate system defined by this
+    matrix. Note that the transformed coordinates are rounded to the
+    nearest integer.
+*/
+QPolygon QTransform::map(const QPolygon &a) const
+{
+    TransformationType t = inline_type();
+    if (t <= TxTranslate)
+        return a.translated(qRound(affine._dx), qRound(affine._dy));
+
+    if (t >= QTransform::TxProject)
+        return mapProjective(*this, QPolygonF(a)).toPolygon();
+
+    int size = a.size();
+    int i;
+    QPolygon p(size);
+    const QPoint *da = a.constData();
+    QPoint *dp = p.data();
+
+    for(i = 0; i < size; ++i) {
+        qreal nx = 0, ny = 0;
+        MAP(da[i].xp, da[i].yp, nx, ny);
+        dp[i].xp = qRound(nx);
+        dp[i].yp = qRound(ny);
+    }
+    return p;
+}
+
+/*!
+    \fn QRegion operator*(const QRegion &region, const QTransform &matrix)
+    \relates QTransform
+
+    This is the same as \a{matrix}.map(\a{region}).
+
+    \sa QTransform::map()
+*/
+
+extern QPainterPath qt_regionToPath(const QRegion &region);
+
+/*!
+    \fn QRegion QTransform::map(const QRegion &region) const
+    \overload
+
+    Creates and returns a QRegion object that is a copy of the given
+    \a region, mapped into the coordinate system defined by this matrix.
+
+    Calling this method can be rather expensive if rotations or
+    shearing are used.
+*/
+QRegion QTransform::map(const QRegion &r) const
+{
+    TransformationType t = inline_type();
+    if (t == TxNone)
+        return r;
+
+    if (t == TxTranslate) {
+        QRegion copy(r);
+        copy.translate(qRound(affine._dx), qRound(affine._dy));
+        return copy;
+    }
+
+    if (t == TxScale && r.rectCount() == 1)
+        return QRegion(mapRect(r.boundingRect()));
+
+    QPainterPath p = map(qt_regionToPath(r));
+    return p.toFillPolygon(QTransform()).toPolygon();
+}
+
+struct QHomogeneousCoordinate
+{
+    qreal x;
+    qreal y;
+    qreal w;
+
+    QHomogeneousCoordinate() {}
+    QHomogeneousCoordinate(qreal x_, qreal y_, qreal w_) : x(x_), y(y_), w(w_) {}
+
+    const QPointF toPoint() const {
+        qreal iw = 1. / w;
+        return QPointF(x * iw, y * iw);
+    }
+};
+
+static inline QHomogeneousCoordinate mapHomogeneous(const QTransform &transform, const QPointF &p)
+{
+    QHomogeneousCoordinate c;
+    c.x = transform.m11() * p.x() + transform.m21() * p.y() + transform.m31();
+    c.y = transform.m12() * p.x() + transform.m22() * p.y() + transform.m32();
+    c.w = transform.m13() * p.x() + transform.m23() * p.y() + transform.m33();
+    return c;
+}
+
+static inline bool lineTo_clipped(QPainterPath &path, const QTransform &transform, const QPointF &a, const QPointF &b,
+                                  bool needsMoveTo, bool needsLineTo = true)
+{
+    QHomogeneousCoordinate ha = mapHomogeneous(transform, a);
+    QHomogeneousCoordinate hb = mapHomogeneous(transform, b);
+
+    if (ha.w < Q_NEAR_CLIP && hb.w < Q_NEAR_CLIP)
+        return false;
+
+    if (hb.w < Q_NEAR_CLIP) {
+        const qreal t = (Q_NEAR_CLIP - hb.w) / (ha.w - hb.w);
+
+        hb.x += (ha.x - hb.x) * t;
+        hb.y += (ha.y - hb.y) * t;
+        hb.w = qreal(Q_NEAR_CLIP);
+    } else if (ha.w < Q_NEAR_CLIP) {
+        const qreal t = (Q_NEAR_CLIP - ha.w) / (hb.w - ha.w);
+
+        ha.x += (hb.x - ha.x) * t;
+        ha.y += (hb.y - ha.y) * t;
+        ha.w = qreal(Q_NEAR_CLIP);
+
+        const QPointF p = ha.toPoint();
+        if (needsMoveTo) {
+            path.moveTo(p);
+            needsMoveTo = false;
+        } else {
+            path.lineTo(p);
+        }
+    }
+
+    if (needsMoveTo)
+        path.moveTo(ha.toPoint());
+
+    if (needsLineTo)
+        path.lineTo(hb.toPoint());
+
+    return true;
+}
+Q_GUI_EXPORT bool qt_scaleForTransform(const QTransform &transform, qreal *scale);
+
+static inline bool cubicTo_clipped(QPainterPath &path, const QTransform &transform, const QPointF &a, const QPointF &b, const QPointF &c, const QPointF &d, bool needsMoveTo)
+{
+    // Convert projective xformed curves to line
+    // segments so they can be transformed more accurately
+
+    qreal scale;
+    qt_scaleForTransform(transform, &scale);
+
+    qreal curveThreshold = scale == 0 ? qreal(0.25) : (qreal(0.25) / scale);
+
+    QPolygonF segment = QBezier::fromPoints(a, b, c, d).toPolygon(curveThreshold);
+
+    for (int i = 0; i < segment.size() - 1; ++i)
+        if (lineTo_clipped(path, transform, segment.at(i), segment.at(i+1), needsMoveTo))
+            needsMoveTo = false;
+
+    return !needsMoveTo;
+}
+
+static QPainterPath mapProjective(const QTransform &transform, const QPainterPath &path)
+{
+    QPainterPath result;
+
+    QPointF last;
+    QPointF lastMoveTo;
+    bool needsMoveTo = true;
+    for (int i = 0; i < path.elementCount(); ++i) {
+        switch (path.elementAt(i).type) {
+        case QPainterPath::MoveToElement:
+            if (i > 0 && lastMoveTo != last)
+                lineTo_clipped(result, transform, last, lastMoveTo, needsMoveTo);
+
+            lastMoveTo = path.elementAt(i);
+            last = path.elementAt(i);
+            needsMoveTo = true;
+            break;
+        case QPainterPath::LineToElement:
+            if (lineTo_clipped(result, transform, last, path.elementAt(i), needsMoveTo))
+                needsMoveTo = false;
+            last = path.elementAt(i);
+            break;
+        case QPainterPath::CurveToElement:
+            if (cubicTo_clipped(result, transform, last, path.elementAt(i), path.elementAt(i+1), path.elementAt(i+2), needsMoveTo))
+                needsMoveTo = false;
+            i += 2;
+            last = path.elementAt(i);
+            break;
+        default:
+            Q_ASSERT(false);
+        }
+    }
+
+    if (path.elementCount() > 0 && lastMoveTo != last)
+        lineTo_clipped(result, transform, last, lastMoveTo, needsMoveTo, false);
+
+    result.setFillRule(path.fillRule());
+    return result;
+}
+
+/*!
+    \fn QPainterPath operator *(const QPainterPath &path, const QTransform &matrix)
+    \since 4.3
+    \relates QTransform
+
+    This is the same as \a{matrix}.map(\a{path}).
+
+    \sa QTransform::map()
+*/
+
+/*!
+    \overload
+
+    Creates and returns a QPainterPath object that is a copy of the
+    given \a path, mapped into the coordinate system defined by this
+    matrix.
+*/
+QPainterPath QTransform::map(const QPainterPath &path) const
+{
+    TransformationType t = inline_type();
+    if (t == TxNone || path.elementCount() == 0)
+        return path;
+
+    if (t >= TxProject)
+        return mapProjective(*this, path);
+
+    QPainterPath copy = path;
+
+    if (t == TxTranslate) {
+        copy.translate(affine._dx, affine._dy);
+    } else {
+        copy.detach();
+        // Full xform
+        for (int i=0; i<path.elementCount(); ++i) {
+            QPainterPath::Element &e = copy.d_ptr->elements[i];
+            MAP(e.x, e.y, e.x, e.y);
+        }
+    }
+
+    return copy;
+}
+
+/*!
+    \fn QPolygon QTransform::mapToPolygon(const QRect &rectangle) const
+
+    Creates and returns a QPolygon representation of the given \a
+    rectangle, mapped into the coordinate system defined by this
+    matrix.
+
+    The rectangle's coordinates are transformed using the following
+    formulas:
+
+    \snippet doc/src/snippets/code/src_gui_painting_qtransform.cpp 1
+
+    Polygons and rectangles behave slightly differently when
+    transformed (due to integer rounding), so
+    \c{matrix.map(QPolygon(rectangle))} is not always the same as
+    \c{matrix.mapToPolygon(rectangle)}.
+
+    \sa mapRect(), {QTransform#Basic Matrix Operations}{Basic Matrix
+    Operations}
+*/
+QPolygon QTransform::mapToPolygon(const QRect &rect) const
+{
+    TransformationType t = inline_type();
+
+    QPolygon a(4);
+    qreal x[4] = { 0, 0, 0, 0 }, y[4] = { 0, 0, 0, 0 };
+    if (t <= TxScale) {
+        x[0] = affine._m11*rect.x() + affine._dx;
+        y[0] = affine._m22*rect.y() + affine._dy;
+        qreal w = affine._m11*rect.width();
+        qreal h = affine._m22*rect.height();
+        if (w < 0) {
+            w = -w;
+            x[0] -= w;
+        }
+        if (h < 0) {
+            h = -h;
+            y[0] -= h;
+        }
+        x[1] = x[0]+w;
+        x[2] = x[1];
+        x[3] = x[0];
+        y[1] = y[0];
+        y[2] = y[0]+h;
+        y[3] = y[2];
+    } else {
+        qreal right = rect.x() + rect.width();
+        qreal bottom = rect.y() + rect.height();
+        MAP(rect.x(), rect.y(), x[0], y[0]);
+        MAP(right, rect.y(), x[1], y[1]);
+        MAP(right, bottom, x[2], y[2]);
+        MAP(rect.x(), bottom, x[3], y[3]);
+    }
+
+    // all coordinates are correctly, tranform to a pointarray
+    // (rounding to the next integer)
+    a.setPoints(4, qRound(x[0]), qRound(y[0]),
+                qRound(x[1]), qRound(y[1]),
+                qRound(x[2]), qRound(y[2]),
+                qRound(x[3]), qRound(y[3]));
+    return a;
+}
+
+/*!
+    Creates a transformation matrix, \a trans, that maps a unit square
+    to a four-sided polygon, \a quad. Returns true if the transformation
+    is constructed or false if such a transformation does not exist.
+
+    \sa quadToSquare(), quadToQuad()
+*/
+bool QTransform::squareToQuad(const QPolygonF &quad, QTransform &trans)
+{
+    if (quad.count() != 4)
+        return false;
+
+    qreal dx0 = quad[0].x();
+    qreal dx1 = quad[1].x();
+    qreal dx2 = quad[2].x();
+    qreal dx3 = quad[3].x();
+
+    qreal dy0 = quad[0].y();
+    qreal dy1 = quad[1].y();
+    qreal dy2 = quad[2].y();
+    qreal dy3 = quad[3].y();
+
+    double ax  = dx0 - dx1 + dx2 - dx3;
+    double ay  = dy0 - dy1 + dy2 - dy3;
+
+    if (!ax && !ay) { //afine transform
+        trans.setMatrix(dx1 - dx0, dy1 - dy0,  0,
+                        dx2 - dx1, dy2 - dy1,  0,
+                        dx0,       dy0,  1);
+    } else {
+        double ax1 = dx1 - dx2;
+        double ax2 = dx3 - dx2;
+        double ay1 = dy1 - dy2;
+        double ay2 = dy3 - dy2;
+
+        /*determinants */
+        double gtop    =  ax  * ay2 - ax2 * ay;
+        double htop    =  ax1 * ay  - ax  * ay1;
+        double bottom  =  ax1 * ay2 - ax2 * ay1;
+
+        double a, b, c, d, e, f, g, h;  /*i is always 1*/
+
+        if (!bottom)
+            return false;
+
+        g = gtop/bottom;
+        h = htop/bottom;
+
+        a = dx1 - dx0 + g * dx1;
+        b = dx3 - dx0 + h * dx3;
+        c = dx0;
+        d = dy1 - dy0 + g * dy1;
+        e = dy3 - dy0 + h * dy3;
+        f = dy0;
+
+        trans.setMatrix(a, d, g,
+                        b, e, h,
+                        c, f, 1.0);
+    }
+
+    return true;
+}
+
+/*!
+    \fn bool QTransform::quadToSquare(const QPolygonF &quad, QTransform &trans)
+
+    Creates a transformation matrix, \a trans, that maps a four-sided polygon,
+    \a quad, to a unit square. Returns true if the transformation is constructed
+    or false if such a transformation does not exist.
+
+    \sa squareToQuad(), quadToQuad()
+*/
+bool QTransform::quadToSquare(const QPolygonF &quad, QTransform &trans)
+{
+    if (!squareToQuad(quad, trans))
+        return false;
+
+    bool invertible = false;
+    trans = trans.inverted(&invertible);
+
+    return invertible;
+}
+
+/*!
+    Creates a transformation matrix, \a trans, that maps a four-sided
+    polygon, \a one, to another four-sided polygon, \a two.
+    Returns true if the transformation is possible; otherwise returns
+    false.
+
+    This is a convenience method combining quadToSquare() and
+    squareToQuad() methods. It allows the input quad to be
+    transformed into any other quad.
+
+    \sa squareToQuad(), quadToSquare()
+*/
+bool QTransform::quadToQuad(const QPolygonF &one,
+                            const QPolygonF &two,
+                            QTransform &trans)
+{
+    QTransform stq;
+    if (!quadToSquare(one, trans))
+        return false;
+    if (!squareToQuad(two, stq))
+        return false;
+    trans *= stq;
+    //qDebug()<<"Final = "<<trans;
+    return true;
+}
+
+/*!
+    Sets the matrix elements to the specified values, \a m11,
+    \a m12, \a m13 \a m21, \a m22, \a m23 \a m31, \a m32 and
+    \a m33. Note that this function replaces the previous values.
+    QTransform provides the translate(), rotate(), scale() and shear()
+    convenience functions to manipulate the various matrix elements
+    based on the currently defined coordinate system.
+
+    \sa QTransform()
+*/
+
+void QTransform::setMatrix(qreal m11, qreal m12, qreal m13,
+                           qreal m21, qreal m22, qreal m23,
+                           qreal m31, qreal m32, qreal m33)
+{
+    affine._m11 = m11; affine._m12 = m12; m_13 = m13;
+    affine._m21 = m21; affine._m22 = m22; m_23 = m23;
+    affine._dx = m31; affine._dy = m32; m_33 = m33;
+    m_type = TxNone;
+    m_dirty = TxProject;
+}
+
+static inline bool needsPerspectiveClipping(const QRectF &rect, const QTransform &transform)
+{
+    const qreal wx = qMin(transform.m13() * rect.left(), transform.m13() * rect.right());
+    const qreal wy = qMin(transform.m23() * rect.top(), transform.m23() * rect.bottom());
+
+    return wx + wy + transform.m33() < Q_NEAR_CLIP;
+}
+
+QRect QTransform::mapRect(const QRect &rect) const
+{
+    TransformationType t = inline_type();
+    if (t <= TxTranslate)
+        return rect.translated(qRound(affine._dx), qRound(affine._dy));
+
+    if (t <= TxScale) {
+        int x = qRound(affine._m11*rect.x() + affine._dx);
+        int y = qRound(affine._m22*rect.y() + affine._dy);
+        int w = qRound(affine._m11*rect.width());
+        int h = qRound(affine._m22*rect.height());
+        if (w < 0) {
+            w = -w;
+            x -= w;
+        }
+        if (h < 0) {
+            h = -h;
+            y -= h;
+        }
+        return QRect(x, y, w, h);
+    } else if (t < TxProject || !needsPerspectiveClipping(rect, *this)) {
+        // see mapToPolygon for explanations of the algorithm.
+        qreal x = 0, y = 0;
+        MAP(rect.left(), rect.top(), x, y);
+        qreal xmin = x;
+        qreal ymin = y;
+        qreal xmax = x;
+        qreal ymax = y;
+        MAP(rect.right() + 1, rect.top(), x, y);
+        xmin = qMin(xmin, x);
+        ymin = qMin(ymin, y);
+        xmax = qMax(xmax, x);
+        ymax = qMax(ymax, y);
+        MAP(rect.right() + 1, rect.bottom() + 1, x, y);
+        xmin = qMin(xmin, x);
+        ymin = qMin(ymin, y);
+        xmax = qMax(xmax, x);
+        ymax = qMax(ymax, y);
+        MAP(rect.left(), rect.bottom() + 1, x, y);
+        xmin = qMin(xmin, x);
+        ymin = qMin(ymin, y);
+        xmax = qMax(xmax, x);
+        ymax = qMax(ymax, y);
+        return QRect(qRound(xmin), qRound(ymin), qRound(xmax)-qRound(xmin), qRound(ymax)-qRound(ymin));
+    } else {
+        QPainterPath path;
+        path.addRect(rect);
+        return map(path).boundingRect().toRect();
+    }
+}
+
+/*!
+    \fn QRectF QTransform::mapRect(const QRectF &rectangle) const
+
+    Creates and returns a QRectF object that is a copy of the given \a
+    rectangle, mapped into the coordinate system defined by this
+    matrix.
+
+    The rectangle's coordinates are transformed using the following
+    formulas:
+
+    \snippet doc/src/snippets/code/src_gui_painting_qtransform.cpp 2
+
+    If rotation or shearing has been specified, this function returns
+    the \e bounding rectangle. To retrieve the exact region the given
+    \a rectangle maps to, use the mapToPolygon() function instead.
+
+    \sa mapToPolygon(), {QTransform#Basic Matrix Operations}{Basic Matrix
+    Operations}
+*/
+QRectF QTransform::mapRect(const QRectF &rect) const
+{
+    TransformationType t = inline_type();
+    if (t <= TxTranslate)
+        return rect.translated(affine._dx, affine._dy);
+
+    if (t <= TxScale) {
+        qreal x = affine._m11*rect.x() + affine._dx;
+        qreal y = affine._m22*rect.y() + affine._dy;
+        qreal w = affine._m11*rect.width();
+        qreal h = affine._m22*rect.height();
+        if (w < 0) {
+            w = -w;
+            x -= w;
+        }
+        if (h < 0) {
+            h = -h;
+            y -= h;
+        }
+        return QRectF(x, y, w, h);
+    } else if (t < TxProject || !needsPerspectiveClipping(rect, *this)) {
+        qreal x = 0, y = 0;
+        MAP(rect.x(), rect.y(), x, y);
+        qreal xmin = x;
+        qreal ymin = y;
+        qreal xmax = x;
+        qreal ymax = y;
+        MAP(rect.x() + rect.width(), rect.y(), x, y);
+        xmin = qMin(xmin, x);
+        ymin = qMin(ymin, y);
+        xmax = qMax(xmax, x);
+        ymax = qMax(ymax, y);
+        MAP(rect.x() + rect.width(), rect.y() + rect.height(), x, y);
+        xmin = qMin(xmin, x);
+        ymin = qMin(ymin, y);
+        xmax = qMax(xmax, x);
+        ymax = qMax(ymax, y);
+        MAP(rect.x(), rect.y() + rect.height(), x, y);
+        xmin = qMin(xmin, x);
+        ymin = qMin(ymin, y);
+        xmax = qMax(xmax, x);
+        ymax = qMax(ymax, y);
+        return QRectF(xmin, ymin, xmax-xmin, ymax - ymin);
+    } else {
+        QPainterPath path;
+        path.addRect(rect);
+        return map(path).boundingRect();
+    }
+}
+
+/*!
+    \fn QRect QTransform::mapRect(const QRect &rectangle) const
+    \overload
+
+    Creates and returns a QRect object that is a copy of the given \a
+    rectangle, mapped into the coordinate system defined by this
+    matrix. Note that the transformed coordinates are rounded to the
+    nearest integer.
+*/
+
+/*!
+    Maps the given coordinates \a x and \a y into the coordinate
+    system defined by this matrix. The resulting values are put in *\a
+    tx and *\a ty, respectively.
+
+    The coordinates are transformed using the following formulas:
+
+    \snippet doc/src/snippets/code/src_gui_painting_qtransform.cpp 3
+
+    The point (x, y) is the original point, and (x', y') is the
+    transformed point.
+
+    \sa {QTransform#Basic Matrix Operations}{Basic Matrix Operations}
+*/
+void QTransform::map(qreal x, qreal y, qreal *tx, qreal *ty) const
+{
+    TransformationType t = inline_type();
+    MAP(x, y, *tx, *ty);
+}
+
+/*!
+    \overload
+
+    Maps the given coordinates \a x and \a y into the coordinate
+    system defined by this matrix. The resulting values are put in *\a
+    tx and *\a ty, respectively. Note that the transformed coordinates
+    are rounded to the nearest integer.
+*/
+void QTransform::map(int x, int y, int *tx, int *ty) const
+{
+    TransformationType t = inline_type();
+    qreal fx = 0, fy = 0;
+    MAP(x, y, fx, fy);
+    *tx = qRound(fx);
+    *ty = qRound(fy);
+}
+
+/*!
+  Returns the QTransform as an affine matrix.
+
+  \warning If a perspective transformation has been specified,
+  then the conversion will cause loss of data.
+*/
+const QMatrix &QTransform::toAffine() const
+{
+    return affine;
+}
+
+/*!
+  Returns the transformation type of this matrix.
+
+  The transformation type is the highest enumeration value
+  capturing all of the matrix's transformations. For example,
+  if the matrix both scales and shears, the type would be \c TxShear,
+  because \c TxShear has a higher enumeration value than \c TxScale.
+
+  Knowing the transformation type of a matrix is useful for optimization:
+  you can often handle specific types more optimally than handling
+  the generic case.
+  */
+QTransform::TransformationType QTransform::type() const
+{
+    if(m_dirty == TxNone || m_dirty < m_type)
+        return static_cast<TransformationType>(m_type);
+
+    switch (static_cast<TransformationType>(m_dirty)) {
+    case TxProject:
+        if (!qFuzzyIsNull(m_13) || !qFuzzyIsNull(m_23) || !qFuzzyIsNull(m_33 - 1)) {
+             m_type = TxProject;
+             break;
+         }
+    case TxShear:
+    case TxRotate:
+        if (!qFuzzyIsNull(affine._m12) || !qFuzzyIsNull(affine._m21)) {
+            const qreal dot = affine._m11 * affine._m12 + affine._m21 * affine._m22;
+            if (qFuzzyIsNull(dot))
+                m_type = TxRotate;
+            else
+                m_type = TxShear;
+            break;
+        }
+    case TxScale:
+        if (!qFuzzyIsNull(affine._m11 - 1) || !qFuzzyIsNull(affine._m22 - 1)) {
+            m_type = TxScale;
+            break;
+        }
+    case TxTranslate:
+        if (!qFuzzyIsNull(affine._dx) || !qFuzzyIsNull(affine._dy)) {
+            m_type = TxTranslate;
+            break;
+        }
+    case TxNone:
+        m_type = TxNone;
+        break;
+    }
+
+    m_dirty = TxNone;
+    return static_cast<TransformationType>(m_type);
+}
+
+/*!
+
+    Returns the transform as a QVariant.
+*/
+QTransform::operator QVariant() const
+{
+    return QVariant(QVariant::Transform, this);
+}
+
+
+/*!
+    \fn bool QTransform::isInvertible() const
+
+    Returns true if the matrix is invertible, otherwise returns false.
+
+    \sa inverted()
+*/
+
+/*!
+    \fn qreal QTransform::det() const
+    \obsolete
+
+    Returns the matrix's determinant. Use determinant() instead.
+*/
+
+
+/*!
+    \fn qreal QTransform::m11() const
+
+    Returns the horizontal scaling factor.
+
+    \sa scale(), {QTransform#Basic Matrix Operations}{Basic Matrix
+    Operations}
+*/
+
+/*!
+    \fn qreal QTransform::m12() const
+
+    Returns the vertical shearing factor.
+
+    \sa shear(), {QTransform#Basic Matrix Operations}{Basic Matrix
+    Operations}
+*/
+
+/*!
+    \fn qreal QTransform::m21() const
+
+    Returns the horizontal shearing factor.
+
+    \sa shear(), {QTransform#Basic Matrix Operations}{Basic Matrix
+    Operations}
+*/
+
+/*!
+    \fn qreal QTransform::m22() const
+
+    Returns the vertical scaling factor.
+
+    \sa scale(), {QTransform#Basic Matrix Operations}{Basic Matrix
+    Operations}
+*/
+
+/*!
+    \fn qreal QTransform::dx() const
+
+    Returns the horizontal translation factor.
+
+    \sa m31(), translate(), {QTransform#Basic Matrix Operations}{Basic Matrix
+    Operations}
+*/
+
+/*!
+    \fn qreal QTransform::dy() const
+
+    Returns the vertical translation factor.
+
+    \sa translate(), {QTransform#Basic Matrix Operations}{Basic Matrix
+    Operations}
+*/
+
+
+/*!
+    \fn qreal QTransform::m13() const
+
+    Returns the horizontal projection factor.
+
+    \sa translate(), {QTransform#Basic Matrix Operations}{Basic Matrix
+    Operations}
+*/
+
+
+/*!
+    \fn qreal QTransform::m23() const
+
+    Returns the vertical projection factor.
+
+    \sa translate(), {QTransform#Basic Matrix Operations}{Basic Matrix
+    Operations}
+*/
+
+/*!
+    \fn qreal QTransform::m31() const
+
+    Returns the horizontal translation factor.
+
+    \sa dx(), translate(), {QTransform#Basic Matrix Operations}{Basic Matrix
+    Operations}
+*/
+
+/*!
+    \fn qreal QTransform::m32() const
+
+    Returns the vertical translation factor.
+
+    \sa dy(), translate(), {QTransform#Basic Matrix Operations}{Basic Matrix
+    Operations}
+*/
+
+/*!
+    \fn qreal QTransform::m33() const
+
+    Returns the division factor.
+
+    \sa translate(), {QTransform#Basic Matrix Operations}{Basic Matrix
+    Operations}
+*/
+
+/*!
+    \fn qreal QTransform::determinant() const
+
+    Returns the matrix's determinant.
+*/
+
+/*!
+    \fn bool QTransform::isIdentity() const
+
+    Returns true if the matrix is the identity matrix, otherwise
+    returns false.
+
+    \sa reset()
+*/
+
+/*!
+    \fn bool QTransform::isAffine() const
+
+    Returns true if the matrix represent an affine transformation,
+    otherwise returns false.
+*/
+
+/*!
+    \fn bool QTransform::isScaling() const
+
+    Returns true if the matrix represents a scaling
+    transformation, otherwise returns false.
+
+    \sa reset()
+*/
+
+/*!
+    \fn bool QTransform::isRotating() const
+
+    Returns true if the matrix represents some kind of a
+    rotating transformation, otherwise returns false.
+
+    \sa reset()
+*/
+
+/*!
+    \fn bool QTransform::isTranslating() const
+
+    Returns true if the matrix represents a translating
+    transformation, otherwise returns false.
+
+    \sa reset()
+*/
+
+/*!
+    \fn bool qFuzzyCompare(const QTransform& t1, const QTransform& t2)
+
+    \relates QTransform
+    \since 4.6
+
+    Returns true if \a t1 and \a t2 are equal, allowing for a small
+    fuzziness factor for floating-point comparisons; false otherwise.
+*/
+
+
+// returns true if the transform is uniformly scaling
+// (same scale in x and y direction)
+// scale is set to the max of x and y scaling factors
+Q_GUI_EXPORT
+bool qt_scaleForTransform(const QTransform &transform, qreal *scale)
+{
+    const QTransform::TransformationType type = transform.type();
+    if (type <= QTransform::TxTranslate) {
+        if (scale)
+            *scale = 1;
+        return true;
+    } else if (type == QTransform::TxScale) {
+        const qreal xScale = qAbs(transform.m11());
+        const qreal yScale = qAbs(transform.m22());
+        if (scale)
+            *scale = qMax(xScale, yScale);
+        return qFuzzyCompare(xScale, yScale);
+    }
+
+    const qreal xScale = transform.m11() * transform.m11()
+                         + transform.m21() * transform.m21();
+    const qreal yScale = transform.m12() * transform.m12()
+                         + transform.m22() * transform.m22();
+    if (scale)
+        *scale = qSqrt(qMax(xScale, yScale));
+    return type == QTransform::TxRotate && qFuzzyCompare(xScale, yScale);
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qtransform.h b/src/gui/painting/qtransform.h
new file mode 100644
index 0000000000..a165bd5ce3
--- /dev/null
+++ b/src/gui/painting/qtransform.h
@@ -0,0 +1,395 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#ifndef QTRANSFORM_H
+#define QTRANSFORM_H
+
+#include <QtGui/qmatrix.h>
+#include <QtGui/qpainterpath.h>
+#include <QtGui/qpolygon.h>
+#include <QtGui/qregion.h>
+#include <QtGui/qwindowdefs.h>
+#include <QtCore/qline.h>
+#include <QtCore/qpoint.h>
+#include <QtCore/qrect.h>
+
+#if defined(Q_OS_VXWORKS) && defined(m_type)
+#  undef m_type
+#endif
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+class QVariant;
+
+class Q_GUI_EXPORT QTransform
+{
+public:
+    enum TransformationType {
+        TxNone      = 0x00,
+        TxTranslate = 0x01,
+        TxScale     = 0x02,
+        TxRotate    = 0x04,
+        TxShear     = 0x08,
+        TxProject   = 0x10
+    };
+
+    inline explicit QTransform(Qt::Initialization) : affine(Qt::Uninitialized) {}
+    QTransform();
+    QTransform(qreal h11, qreal h12, qreal h13,
+               qreal h21, qreal h22, qreal h23,
+               qreal h31, qreal h32, qreal h33 = 1.0);
+    QTransform(qreal h11, qreal h12, qreal h21,
+               qreal h22, qreal dx, qreal dy);
+    explicit QTransform(const QMatrix &mtx);
+
+    bool isAffine() const;
+    bool isIdentity() const;
+    bool isInvertible() const;
+    bool isScaling() const;
+    bool isRotating() const;
+    bool isTranslating() const;
+
+    TransformationType type() const;
+
+    inline qreal determinant() const;
+    qreal det() const;
+
+    qreal m11() const;
+    qreal m12() const;
+    qreal m13() const;
+    qreal m21() const;
+    qreal m22() const;
+    qreal m23() const;
+    qreal m31() const;
+    qreal m32() const;
+    qreal m33() const;
+    qreal dx() const;
+    qreal dy() const;
+
+    void setMatrix(qreal m11, qreal m12, qreal m13,
+                   qreal m21, qreal m22, qreal m23,
+                   qreal m31, qreal m32, qreal m33);
+
+    QTransform inverted(bool *invertible = 0) const;
+    QTransform adjoint() const;
+    QTransform transposed() const;
+
+    QTransform &translate(qreal dx, qreal dy);
+    QTransform &scale(qreal sx, qreal sy);
+    QTransform &shear(qreal sh, qreal sv);
+    QTransform &rotate(qreal a, Qt::Axis axis = Qt::ZAxis);
+    QTransform &rotateRadians(qreal a, Qt::Axis axis = Qt::ZAxis);
+
+    static bool squareToQuad(const QPolygonF &square, QTransform &result);
+    static bool quadToSquare(const QPolygonF &quad, QTransform &result);
+    static bool quadToQuad(const QPolygonF &one,
+                           const QPolygonF &two,
+                           QTransform &result);
+
+    bool operator==(const QTransform &) const;
+    bool operator!=(const QTransform &) const;
+
+    QTransform &operator*=(const QTransform &);
+    QTransform operator*(const QTransform &o) const;
+
+    QTransform &operator=(const QTransform &);
+
+    operator QVariant() const;
+
+    void reset();
+    QPoint       map(const QPoint &p) const;
+    QPointF      map(const QPointF &p) const;
+    QLine        map(const QLine &l) const;
+    QLineF       map(const QLineF &l) const;
+    QPolygonF    map(const QPolygonF &a) const;
+    QPolygon     map(const QPolygon &a) const;
+    QRegion      map(const QRegion &r) const;
+    QPainterPath map(const QPainterPath &p) const;
+    QPolygon     mapToPolygon(const QRect &r) const;
+    QRect mapRect(const QRect &) const;
+    QRectF mapRect(const QRectF &) const;
+    void map(int x, int y, int *tx, int *ty) const;
+    void map(qreal x, qreal y, qreal *tx, qreal *ty) const;
+
+    const QMatrix &toAffine() const;
+
+    QTransform &operator*=(qreal div);
+    QTransform &operator/=(qreal div);
+    QTransform &operator+=(qreal div);
+    QTransform &operator-=(qreal div);
+
+    static QTransform fromTranslate(qreal dx, qreal dy);
+    static QTransform fromScale(qreal dx, qreal dy);
+
+private:
+    inline QTransform(qreal h11, qreal h12, qreal h13,
+                      qreal h21, qreal h22, qreal h23,
+                      qreal h31, qreal h32, qreal h33, bool)
+        : affine(h11, h12, h21, h22, h31, h32, true)
+        , m_13(h13), m_23(h23), m_33(h33)
+        , m_type(TxNone)
+        , m_dirty(TxProject) {}
+    inline QTransform(bool)
+        : affine(true)
+        , m_13(0), m_23(0), m_33(1)
+        , m_type(TxNone)
+        , m_dirty(TxNone) {}
+    inline TransformationType inline_type() const;
+    QMatrix affine;
+    qreal   m_13;
+    qreal   m_23;
+    qreal   m_33;
+
+    mutable uint m_type : 5;
+    mutable uint m_dirty : 5;
+
+    class Private;
+    Private *d;
+};
+Q_DECLARE_TYPEINFO(QTransform, Q_MOVABLE_TYPE);
+
+/******* inlines *****/
+inline QTransform::TransformationType QTransform::inline_type() const
+{
+    if (m_dirty == TxNone)
+        return static_cast<TransformationType>(m_type);
+    return type();
+}
+
+inline bool QTransform::isAffine() const
+{
+    return inline_type() < TxProject;
+}
+inline bool QTransform::isIdentity() const
+{
+    return inline_type() == TxNone;
+}
+
+inline bool QTransform::isInvertible() const
+{
+    return !qFuzzyIsNull(determinant());
+}
+
+inline bool QTransform::isScaling() const
+{
+    return type() >= TxScale;
+}
+inline bool QTransform::isRotating() const
+{
+    return inline_type() >= TxRotate;
+}
+
+inline bool QTransform::isTranslating() const
+{
+    return inline_type() >= TxTranslate;
+}
+
+inline qreal QTransform::determinant() const
+{
+    return affine._m11*(m_33*affine._m22-affine._dy*m_23) -
+        affine._m21*(m_33*affine._m12-affine._dy*m_13)+affine._dx*(m_23*affine._m12-affine._m22*m_13);
+}
+inline qreal QTransform::det() const
+{
+    return determinant();
+}
+inline qreal QTransform::m11() const
+{
+    return affine._m11;
+}
+inline qreal QTransform::m12() const
+{
+    return affine._m12;
+}
+inline qreal QTransform::m13() const
+{
+    return m_13;
+}
+inline qreal QTransform::m21() const
+{
+    return affine._m21;
+}
+inline qreal QTransform::m22() const
+{
+    return affine._m22;
+}
+inline qreal QTransform::m23() const
+{
+    return m_23;
+}
+inline qreal QTransform::m31() const
+{
+    return affine._dx;
+}
+inline qreal QTransform::m32() const
+{
+    return affine._dy;
+}
+inline qreal QTransform::m33() const
+{
+    return m_33;
+}
+inline qreal QTransform::dx() const
+{
+    return affine._dx;
+}
+inline qreal QTransform::dy() const
+{
+    return affine._dy;
+}
+
+inline QTransform &QTransform::operator*=(qreal num)
+{
+    if (num == 1.)
+        return *this;
+    affine._m11 *= num;
+    affine._m12 *= num;
+    m_13        *= num;
+    affine._m21 *= num;
+    affine._m22 *= num;
+    m_23        *= num;
+    affine._dx  *= num;
+    affine._dy  *= num;
+    m_33        *= num;
+    if (m_dirty < TxScale)
+        m_dirty = TxScale;
+    return *this;
+}
+inline QTransform &QTransform::operator/=(qreal div)
+{
+    if (div == 0)
+        return *this;
+    div = 1/div;
+    return operator*=(div);
+}
+inline QTransform &QTransform::operator+=(qreal num)
+{
+    if (num == 0)
+        return *this;
+    affine._m11 += num;
+    affine._m12 += num;
+    m_13        += num;
+    affine._m21 += num;
+    affine._m22 += num;
+    m_23        += num;
+    affine._dx  += num;
+    affine._dy  += num;
+    m_33        += num;
+    m_dirty     = TxProject;
+    return *this;
+}
+inline QTransform &QTransform::operator-=(qreal num)
+{
+    if (num == 0)
+        return *this;
+    affine._m11 -= num;
+    affine._m12 -= num;
+    m_13        -= num;
+    affine._m21 -= num;
+    affine._m22 -= num;
+    m_23        -= num;
+    affine._dx  -= num;
+    affine._dy  -= num;
+    m_33        -= num;
+    m_dirty     = TxProject;
+    return *this;
+}
+
+inline bool qFuzzyCompare(const QTransform& t1, const QTransform& t2)
+{
+    return qFuzzyCompare(t1.m11(), t2.m11())
+        && qFuzzyCompare(t1.m12(), t2.m12())
+        && qFuzzyCompare(t1.m13(), t2.m13())
+        && qFuzzyCompare(t1.m21(), t2.m21())
+        && qFuzzyCompare(t1.m22(), t2.m22())
+        && qFuzzyCompare(t1.m23(), t2.m23())
+        && qFuzzyCompare(t1.m31(), t2.m31())
+        && qFuzzyCompare(t1.m32(), t2.m32())
+        && qFuzzyCompare(t1.m33(), t2.m33());
+}
+
+
+/****** stream functions *******************/
+#ifndef QT_NO_DATASTREAM
+Q_GUI_EXPORT QDataStream &operator<<(QDataStream &, const QTransform &);
+Q_GUI_EXPORT QDataStream &operator>>(QDataStream &, QTransform &);
+#endif
+
+#ifndef QT_NO_DEBUG_STREAM
+Q_GUI_EXPORT QDebug operator<<(QDebug, const QTransform &);
+#endif
+/****** end stream functions *******************/
+
+// mathematical semantics
+Q_GUI_EXPORT_INLINE QPoint operator*(const QPoint &p, const QTransform &m)
+{ return m.map(p); }
+Q_GUI_EXPORT_INLINE QPointF operator*(const QPointF &p, const QTransform &m)
+{ return m.map(p); }
+Q_GUI_EXPORT_INLINE QLineF operator*(const QLineF &l, const QTransform &m)
+{ return m.map(l); }
+Q_GUI_EXPORT_INLINE QLine operator*(const QLine &l, const QTransform &m)
+{ return m.map(l); }
+Q_GUI_EXPORT_INLINE QPolygon operator *(const QPolygon &a, const QTransform &m)
+{ return m.map(a); }
+Q_GUI_EXPORT_INLINE QPolygonF operator *(const QPolygonF &a, const QTransform &m)
+{ return m.map(a); }
+Q_GUI_EXPORT_INLINE QRegion operator *(const QRegion &r, const QTransform &m)
+{ return m.map(r); }
+Q_GUI_EXPORT_INLINE QPainterPath operator *(const QPainterPath &p, const QTransform &m)
+{ return m.map(p); }
+
+Q_GUI_EXPORT_INLINE QTransform operator *(const QTransform &a, qreal n)
+{ QTransform t(a); t *= n; return t; }
+Q_GUI_EXPORT_INLINE QTransform operator /(const QTransform &a, qreal n)
+{ QTransform t(a); t /= n; return t; }
+Q_GUI_EXPORT_INLINE QTransform operator +(const QTransform &a, qreal n)
+{ QTransform t(a); t += n; return t; }
+Q_GUI_EXPORT_INLINE QTransform operator -(const QTransform &a, qreal n)
+{ QTransform t(a); t -= n; return t; }
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/gui/painting/qunifiedtoolbarsurface_mac.cpp b/src/gui/painting/qunifiedtoolbarsurface_mac.cpp
new file mode 100644
index 0000000000..3876c3d1a2
--- /dev/null
+++ b/src/gui/painting/qunifiedtoolbarsurface_mac.cpp
@@ -0,0 +1,264 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qunifiedtoolbarsurface_mac_p.h"
+#include <private/qt_cocoa_helpers_mac_p.h>
+#include <private/qbackingstore_p.h>
+#include <private/qmainwindowlayout_p.h>
+
+#include <QDebug>
+
+#ifdef QT_MAC_USE_COCOA
+
+QT_BEGIN_NAMESPACE
+
+QUnifiedToolbarSurface::QUnifiedToolbarSurface(QWidget *widget)
+    : QRasterWindowSurface(widget, false), d_ptr(new QUnifiedToolbarSurfacePrivate)
+{
+    d_ptr->image = 0;
+    d_ptr->inSetGeometry = false;
+
+    setGeometry(QRect(QPoint(0, 0), QSize(widget->width(), 100))); // FIXME: Fix height.
+}
+
+QUnifiedToolbarSurface::~QUnifiedToolbarSurface()
+{
+    if (d_ptr->image)
+        delete d_ptr->image;
+}
+
+QPaintDevice *QUnifiedToolbarSurface::paintDevice()
+{
+    return &d_ptr->image->image;
+}
+
+void QUnifiedToolbarSurface::recursiveRedirect(QObject *object, QWidget *parent_toolbar, const QPoint &offset)
+{
+    if (object != 0) {
+        if (object->isWidgetType()) {
+            QWidget *widget = qobject_cast<QWidget *>(object);
+
+            // We redirect the painting only if the widget is in the same window
+            // and is not a window in itself.
+            if (!(widget->windowType() & Qt::Window)) {
+                widget->d_func()->unifiedSurface = this;
+                widget->d_func()->isInUnifiedToolbar = true;
+                widget->d_func()->toolbar_offset = offset;
+                widget->d_func()->toolbar_ancestor = parent_toolbar;
+
+                for (int i = 0; i < object->children().size(); ++i) {
+                    recursiveRedirect(object->children().at(i), parent_toolbar, offset);
+                }
+            }
+        }
+    }
+}
+
+void QUnifiedToolbarSurface::insertToolbar(QWidget *toolbar, const QPoint &offset)
+{
+    setGeometry(QRect(QPoint(0, 0), QSize(offset.x() + toolbar->width(), 100))); // FIXME
+    recursiveRedirect(toolbar, toolbar, offset);
+}
+
+// We basically undo what we set in recursiveRedirect().
+void QUnifiedToolbarSurface::recursiveRemoval(QObject *object)
+{
+    if (object != 0) {
+        if (object->isWidgetType()) {
+            QWidget *widget = qobject_cast<QWidget *>(object);
+
+            // If it's a pop-up or something similar, we don't redirect it.
+            if (widget->windowType() & Qt::Window)
+                return;
+
+            widget->d_func()->unifiedSurface = 0;
+            widget->d_func()->isInUnifiedToolbar = false;
+            widget->d_func()->toolbar_offset = QPoint();
+            widget->d_func()->toolbar_ancestor = 0;
+        }
+
+        for (int i = 0; i < object->children().size(); ++i) {
+            recursiveRemoval(object->children().at(i));
+        }
+    }
+}
+
+void QUnifiedToolbarSurface::removeToolbar(QToolBar *toolbar)
+{
+    recursiveRemoval(toolbar);
+}
+
+void QUnifiedToolbarSurface::setGeometry(const QRect &rect)
+{
+    QWindowSurface::setGeometry(rect);
+    Q_D(QUnifiedToolbarSurface);
+    d->inSetGeometry = true;
+    if (d->image == 0 || d->image->width() < rect.width() || d->image->height() < rect.height())
+            prepareBuffer(QImage::Format_ARGB32_Premultiplied, window());
+    d->inSetGeometry = false;
+
+    // FIXME: set unified toolbar height.
+}
+
+void QUnifiedToolbarSurface::beginPaint(const QRegion &rgn)
+{
+    QPainter p(&d_ptr->image->image);
+    p.setCompositionMode(QPainter::CompositionMode_Source);
+    const QVector<QRect> rects = rgn.rects();
+    const QColor blank = Qt::transparent;
+    for (QVector<QRect>::const_iterator it = rects.begin(); it != rects.end(); ++it) {
+        p.fillRect(*it, blank);
+    }
+}
+
+void QUnifiedToolbarSurface::updateToolbarOffset(QWidget *widget)
+{
+    QMainWindowLayout *mlayout = qobject_cast<QMainWindowLayout*> (widget->window()->layout());
+    mlayout->updateUnifiedToolbarOffset();
+}
+
+void QUnifiedToolbarSurface::flush(QWidget *widget, const QRegion &region, const QPoint &offset)
+{
+    Q_UNUSED(region);
+    Q_UNUSED(offset);
+
+    this->flush(widget);
+}
+
+void QUnifiedToolbarSurface::flush(QWidget *widget)
+{
+    Q_D(QUnifiedToolbarSurface);
+
+    if (!d->image)
+        return;
+
+    if (widget->d_func()->flushRequested) {
+        // We call display: directly to avoid flickering in the toolbar.
+        qt_mac_display(widget);
+    }
+}
+
+void QUnifiedToolbarSurface::prepareBuffer(QImage::Format format, QWidget *widget)
+{
+    Q_D(QUnifiedToolbarSurface);
+
+    int width = geometry().width();
+    int height = 100; // FIXME
+    if (d->image) {
+        width = qMax(d->image->width(), width);
+        height = qMax(d->image->height(), height);
+    }
+
+    if (width == 0 || height == 0) {
+        delete d->image;
+        d->image = 0;
+        return;
+    }
+
+    QNativeImage *oldImage = d->image;
+
+    d->image = new QNativeImage(width, height, format, false, widget);
+
+    if (oldImage && d->inSetGeometry && hasStaticContents()) {
+        // Make sure we use the const version of bits() (no detach).
+        const uchar *src = const_cast<const QImage &>(oldImage->image).bits();
+        uchar *dst = d->image->image.bits();
+
+        const int srcBytesPerLine = oldImage->image.bytesPerLine();
+        const int dstBytesPerLine = d->image->image.bytesPerLine();
+        const int bytesPerPixel = oldImage->image.depth() >> 3;
+
+        QRegion staticRegion(staticContents());
+        // Make sure we're inside the boundaries of the old image.
+        staticRegion &= QRect(0, 0, oldImage->image.width(), oldImage->image.height());
+        const QVector<QRect> &rects = staticRegion.rects();
+        const QRect *srcRect = rects.constData();
+
+        // Copy the static content of the old image into the new one.
+        int numRectsLeft = rects.size();
+        do {
+            const int bytesOffset = srcRect->x() * bytesPerPixel;
+            const int dy = srcRect->y();
+
+            // Adjust src and dst to point to the right offset.
+            const uchar *s = src + dy * srcBytesPerLine + bytesOffset;
+            uchar *d = dst + dy * dstBytesPerLine + bytesOffset;
+            const int numBytes = srcRect->width() * bytesPerPixel;
+
+            int numScanLinesLeft = srcRect->height();
+            do {
+                ::memcpy(d, s, numBytes);
+                d += dstBytesPerLine;
+                s += srcBytesPerLine;
+            } while (--numScanLinesLeft);
+
+            ++srcRect;
+        } while (--numRectsLeft);
+    }
+
+    delete oldImage;
+}
+
+CGContextRef QUnifiedToolbarSurface::imageContext()
+{
+    Q_D(QUnifiedToolbarSurface);
+    return d->image->cg;
+}
+
+void QUnifiedToolbarSurface::renderToolbar(QWidget *widget, bool forceFlush)
+{
+    QWidget *toolbar = widget->d_func()->toolbar_ancestor;
+
+    updateToolbarOffset(toolbar);
+    QRect beginPaintRect(toolbar->d_func()->toolbar_offset.x(), toolbar->d_func()->toolbar_offset.y(), toolbar->geometry().width(), toolbar->geometry().height());
+    QRegion beginPaintRegion(beginPaintRect);
+
+    beginPaint(beginPaintRegion);
+    toolbar->render(paintDevice(), toolbar->d_func()->toolbar_offset, QRegion(toolbar->geometry()), QWidget::DrawChildren);
+    toolbar->d_func()->flushRequested = true;
+
+    if (forceFlush)
+        flush(toolbar);
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_MAC_USE_COCOA
diff --git a/src/gui/painting/qunifiedtoolbarsurface_mac_p.h b/src/gui/painting/qunifiedtoolbarsurface_mac_p.h
new file mode 100644
index 0000000000..0a7ebf1759
--- /dev/null
+++ b/src/gui/painting/qunifiedtoolbarsurface_mac_p.h
@@ -0,0 +1,107 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QUNIFIEDTOOLBARSURFACE_MAC_P_H
+#define QUNIFIEDTOOLBARSURFACE_MAC_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <private/qwindowsurface_raster_p.h>
+#include <QWidget>
+#include <QToolBar>
+#include <private/qwidget_p.h>
+#include <private/qnativeimage_p.h>
+
+#ifdef QT_MAC_USE_COCOA
+
+QT_BEGIN_NAMESPACE
+
+class QNativeImage;
+
+
+class QUnifiedToolbarSurfacePrivate
+{
+public:
+    QNativeImage *image;
+    uint inSetGeometry : 1;
+};
+
+class Q_GUI_EXPORT QUnifiedToolbarSurface : public QRasterWindowSurface
+{
+public:
+    QUnifiedToolbarSurface(QWidget *widget);
+    ~QUnifiedToolbarSurface();
+
+    void flush(QWidget *widget);
+    void flush(QWidget *widget, const QRegion &region, const QPoint &offset);
+    void setGeometry(const QRect &rect);
+    void beginPaint(const QRegion &rgn);
+    void insertToolbar(QWidget *toolbar, const QPoint &offset);
+    void removeToolbar(QToolBar *toolbar);
+    void updateToolbarOffset(QWidget *widget);
+    void renderToolbar(QWidget *widget, bool forceFlush = false);
+    void recursiveRedirect(QObject *widget, QWidget *parent_toolbar, const QPoint &offset);
+
+    QPaintDevice *paintDevice();
+    CGContextRef imageContext();
+
+private:
+    void prepareBuffer(QImage::Format format, QWidget *widget);
+    void recursiveRemoval(QObject *object);
+
+    Q_DECLARE_PRIVATE(QUnifiedToolbarSurface)
+    QScopedPointer<QUnifiedToolbarSurfacePrivate> d_ptr;
+};
+
+QT_END_NAMESPACE
+
+#endif // QT_MAC_USE_COCOA
+
+#endif // QUNIFIEDTOOLBARSURFACE_MAC_P_H
diff --git a/src/gui/painting/qvectorpath_p.h b/src/gui/painting/qvectorpath_p.h
new file mode 100644
index 0000000000..76212be5d4
--- /dev/null
+++ b/src/gui/painting/qvectorpath_p.h
@@ -0,0 +1,184 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QVECTORPATH_P_H
+#define QVECTORPATH_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtGui/qpaintengine.h>
+
+#include <private/qpaintengine_p.h>
+#include <private/qstroker_p.h>
+#include <private/qpainter_p.h>
+
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+class QPaintEngineEx;
+
+typedef void (*qvectorpath_cache_cleanup)(QPaintEngineEx *engine, void *data);
+
+struct QRealRect {
+    qreal x1, y1, x2, y2;
+};
+
+class Q_GUI_EXPORT QVectorPath
+{
+public:
+    enum Hint {
+        // Shape hints, in 0x000000ff, access using shape()
+        AreaShapeMask           = 0x0001,       // shape covers an area
+        NonConvexShapeMask      = 0x0002,       // shape is not convex
+        CurvedShapeMask         = 0x0004,       // shape contains curves...
+        LinesShapeMask          = 0x0008,
+        RectangleShapeMask      = 0x0010,
+        ShapeMask               = 0x001f,
+
+        // Shape hints merged into basic shapes..
+        LinesHint               = LinesShapeMask,
+        RectangleHint           = AreaShapeMask | RectangleShapeMask,
+        EllipseHint             = AreaShapeMask | CurvedShapeMask,
+        ConvexPolygonHint       = AreaShapeMask,
+        PolygonHint             = AreaShapeMask | NonConvexShapeMask,
+        RoundedRectHint         = AreaShapeMask | CurvedShapeMask,
+        ArbitraryShapeHint      = AreaShapeMask | NonConvexShapeMask | CurvedShapeMask,
+
+        // Other hints
+        IsCachedHint            = 0x0100, // Set if the cache hint is set
+        ShouldUseCacheHint      = 0x0200, // Set if the path should be cached when possible..
+        ControlPointRect        = 0x0400, // Set if the control point rect has been calculated...
+
+        // Shape rendering specifiers...
+        OddEvenFill             = 0x1000,
+        WindingFill             = 0x2000,
+        ImplicitClose           = 0x4000
+    };
+
+    // ### Falcon: introduca a struct XY for points so lars is not so confused...
+    QVectorPath(const qreal *points,
+                int count,
+                const QPainterPath::ElementType *elements = 0,
+                uint hints = ArbitraryShapeHint)
+        : m_elements(elements),
+          m_points(points),
+          m_count(count),
+          m_hints(hints)
+    {
+    }
+
+    ~QVectorPath();
+
+    QRectF controlPointRect() const;
+
+    inline Hint shape() const { return (Hint) (m_hints & ShapeMask); }
+    inline bool isConvex() const { return (m_hints & NonConvexShapeMask) == 0; }
+    inline bool isCurved() const { return m_hints & CurvedShapeMask; }
+
+    inline bool isCacheable() const { return m_hints & ShouldUseCacheHint; }
+    inline bool hasImplicitClose() const { return m_hints & ImplicitClose; }
+    inline bool hasWindingFill() const { return m_hints & WindingFill; }
+
+    inline void makeCacheable() const { m_hints |= ShouldUseCacheHint; m_cache = 0; }
+    inline uint hints() const { return m_hints; }
+
+    inline const QPainterPath::ElementType *elements() const { return m_elements; }
+    inline const qreal *points() const { return m_points; }
+    inline bool isEmpty() const { return m_points == 0; }
+
+    inline int elementCount() const { return m_count; }
+    inline const QPainterPath convertToPainterPath() const;
+
+    static inline uint polygonFlags(QPaintEngine::PolygonDrawMode mode);
+
+    struct CacheEntry {
+        QPaintEngineEx *engine;
+        void *data;
+        qvectorpath_cache_cleanup cleanup;
+        CacheEntry *next;
+    };
+
+    CacheEntry *addCacheData(QPaintEngineEx *engine, void *data, qvectorpath_cache_cleanup cleanup) const;
+    inline CacheEntry *lookupCacheData(QPaintEngineEx *engine) const {
+        Q_ASSERT(m_hints & ShouldUseCacheHint);
+        CacheEntry *e = m_cache;
+        while (e) {
+            if (e->engine == engine)
+                return e;
+            e = e->next;
+        }
+        return 0;
+    }
+
+
+private:
+    Q_DISABLE_COPY(QVectorPath)
+
+    const QPainterPath::ElementType *m_elements;
+    const qreal *m_points;
+    const int m_count;
+
+    mutable uint m_hints;
+    mutable QRealRect m_cp_rect;
+
+    mutable CacheEntry *m_cache;
+};
+
+Q_GUI_EXPORT const QVectorPath &qtVectorPathForPath(const QPainterPath &path);
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/gui/painting/qwindowsurface.cpp b/src/gui/painting/qwindowsurface.cpp
new file mode 100644
index 0000000000..0fb9bf78a9
--- /dev/null
+++ b/src/gui/painting/qwindowsurface.cpp
@@ -0,0 +1,383 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <private/qwindowsurface_p.h>
+#include <qwidget.h>
+#include <private/qwidget_p.h>
+#include <private/qbackingstore_p.h>
+#include <private/qapplication_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QWindowSurfacePrivate
+{
+public:
+    QWindowSurfacePrivate(QWidget *w)
+        : window(w)
+    {
+    }
+
+    QWidget *window;
+#if !defined(Q_WS_QPA)
+    QRect geometry;
+#else
+    QSize size;
+#endif //Q_WS_QPA
+    QRegion staticContents;
+    QList<QImage*> bufferImages;
+};
+
+/*!
+    \class QWindowSurface
+    \since 4.3
+    \internal
+    \preliminary
+    \ingroup qws qpa
+
+    \brief The QWindowSurface class provides the drawing area for top-level
+    windows.
+*/
+
+
+/*!
+    \fn void QWindowSurface::beginPaint(const QRegion &region)
+
+    This function is called before painting onto the surface begins,
+    with the \a region in which the painting will occur.
+
+    \sa endPaint(), paintDevice()
+*/
+
+/*!
+    \fn void QWindowSurface::endPaint(const QRegion &region)
+
+    This function is called after painting onto the surface has ended,
+    with the \a region in which the painting was performed.
+
+    \sa beginPaint(), paintDevice()
+*/
+
+/*!
+    \fn void QWindowSurface::flush(QWidget *widget, const QRegion &region,
+                                  const QPoint &offset)
+
+    Flushes the given \a region from the specified \a widget onto the
+    screen.
+
+    Note that the \a offset parameter is currently unused.
+*/
+
+/*!
+    \fn QPaintDevice* QWindowSurface::paintDevice()
+
+    Implement this function to return the appropriate paint device.
+*/
+
+/*!
+    Constructs an empty surface for the given top-level \a window.
+*/
+QWindowSurface::QWindowSurface(QWidget *window, bool setDefaultSurface)
+    : d_ptr(new QWindowSurfacePrivate(window))
+{
+    if (!QApplicationPrivate::runtime_graphics_system) {
+        if(setDefaultSurface && window)
+            window->setWindowSurface(this);
+    }
+}
+
+/*!
+    Destroys this surface.
+*/
+QWindowSurface::~QWindowSurface()
+{
+    if (d_ptr->window)
+        d_ptr->window->d_func()->extra->topextra->windowSurface = 0;
+    delete d_ptr;
+}
+
+/*!
+    Returns a pointer to the top-level window associated with this
+    surface.
+*/
+QWidget* QWindowSurface::window() const
+{
+    return d_ptr->window;
+}
+
+void QWindowSurface::beginPaint(const QRegion &)
+{
+}
+
+void QWindowSurface::endPaint(const QRegion &)
+{
+//     QApplication::syncX();
+    qDeleteAll(d_ptr->bufferImages);
+    d_ptr->bufferImages.clear();
+}
+
+#if !defined(Q_WS_QPA)
+/*!
+    Sets the currently allocated area to be the given \a rect.
+
+    This function is called whenever area covered by the top-level
+    window changes.
+
+    \sa geometry()
+*/
+void QWindowSurface::setGeometry(const QRect &rect)
+{
+    d_ptr->geometry = rect;
+}
+
+/*!
+    Returns the currently allocated area on the screen.
+*/
+QRect QWindowSurface::geometry() const
+{
+    return d_ptr->geometry;
+}
+#else
+
+/*!
+      Sets the size of the windowsurface to be \a size.
+
+      \sa size()
+*/
+void QWindowSurface::resize(const QSize &size)
+{
+    d_ptr->size = size;
+}
+
+/*!
+    Returns the current size of the windowsurface.
+*/
+QSize QWindowSurface::size() const
+{
+    return d_ptr->size;
+}
+#endif //Q_WS_QPA
+
+/*!
+    Scrolls the given \a area \a dx pixels to the right and \a dy
+    downward; both \a dx and \a dy may be negative.
+
+    Returns true if the area was scrolled successfully; false otherwise.
+*/
+bool QWindowSurface::scroll(const QRegion &area, int dx, int dy)
+{
+    Q_UNUSED(area);
+    Q_UNUSED(dx);
+    Q_UNUSED(dy);
+
+    return false;
+}
+
+/*!
+    Returns a QImage pointer which represents the actual buffer the \a widget
+    is drawn into or 0 if this is unavailable.
+
+    You must call beginPaint() before you call this function and the returned
+    pointer is only valid until endPaint() is called.
+*/
+QImage* QWindowSurface::buffer(const QWidget *widget)
+{
+    if (widget->window() != window())
+        return 0;
+
+    QPaintDevice *pdev = paintDevice();
+    if (!pdev || pdev->devType() != QInternal::Image)
+        return 0;
+
+    const QPoint off = offset(widget);
+    QImage *img = static_cast<QImage*>(pdev);
+
+    QRect rect(off, widget->size());
+    rect &= QRect(QPoint(), img->size());
+
+    if (rect.isEmpty())
+        return 0;
+
+    img = new QImage(img->scanLine(rect.y()) + rect.x() * img->depth() / 8,
+                     rect.width(), rect.height(),
+                     img->bytesPerLine(), img->format());
+    d_ptr->bufferImages.append(img);
+
+    return img;
+}
+
+/*!
+  Returns a QPixmap generated from the part of the backing store
+  corresponding to \a widget. Returns a null QPixmap if an error
+  occurs. The contents of the pixmap are only defined for the regions
+  of \a widget that have received paint events since the last resize
+  of the backing store.
+
+  If \a rectangle is a null rectangle (the default), the entire widget
+  is grabbed. Otherwise, the grabbed area is limited to \a rectangle.
+
+  The default implementation uses QWindowSurface::buffer().
+
+  \sa QPixmap::grabWidget()
+*/
+QPixmap QWindowSurface::grabWidget(const QWidget *widget, const QRect &rectangle) const
+{
+    QPixmap result;
+
+    if (widget->window() != window())
+        return result;
+
+    const QImage *img = const_cast<QWindowSurface *>(this)->buffer(widget->window());
+
+    if (!img || img->isNull())
+        return result;
+
+    QRect rect = rectangle.isEmpty() ? widget->rect() : (widget->rect() & rectangle);
+
+    rect.translate(offset(widget) - offset(widget->window()));
+    rect &= QRect(QPoint(), img->size());
+
+    if (rect.isEmpty())
+        return result;
+
+    QImage subimg(img->scanLine(rect.y()) + rect.x() * img->depth() / 8,
+                  rect.width(), rect.height(),
+                  img->bytesPerLine(), img->format());
+    subimg.detach(); //### expensive -- maybe we should have a real SubImage that shares reference count
+
+    result = QPixmap::fromImage(subimg);
+    return result;
+}
+
+/*!
+  Returns the offset of \a widget in the coordinates of this
+  window surface.
+ */
+QPoint QWindowSurface::offset(const QWidget *widget) const
+{
+    QWidget *window = d_ptr->window;
+    QPoint offset = widget->mapTo(window, QPoint());
+#ifdef Q_WS_QWS
+    offset += window->geometry().topLeft() - window->frameGeometry().topLeft();
+#endif
+    return offset;
+}
+
+/*!
+  \fn QRect QWindowSurface::rect(const QWidget *widget) const
+
+  Returns the rectangle for \a widget in the coordinates of this
+  window surface.
+*/
+
+void QWindowSurface::setStaticContents(const QRegion &region)
+{
+    d_ptr->staticContents = region;
+}
+
+QRegion QWindowSurface::staticContents() const
+{
+    return d_ptr->staticContents;
+}
+
+bool QWindowSurface::hasStaticContents() const
+{
+    return hasFeature(QWindowSurface::StaticContents) && !d_ptr->staticContents.isEmpty();
+}
+
+QWindowSurface::WindowSurfaceFeatures QWindowSurface::features() const
+{
+    return PartialUpdates | PreservedContents;
+}
+
+#ifdef Q_WS_QPA
+#define Q_EXPORT_SCROLLRECT Q_GUI_EXPORT
+#else
+#define Q_EXPORT_SCROLLRECT
+#endif
+
+void Q_EXPORT_SCROLLRECT qt_scrollRectInImage(QImage &img, const QRect &rect, const QPoint &offset)
+{
+    // make sure we don't detach
+    uchar *mem = const_cast<uchar*>(const_cast<const QImage &>(img).bits());
+
+    int lineskip = img.bytesPerLine();
+    int depth = img.depth() >> 3;
+
+    const QRect imageRect(0, 0, img.width(), img.height());
+    const QRect r = rect & imageRect & imageRect.translated(-offset);
+    const QPoint p = rect.topLeft() + offset;
+
+    if (r.isEmpty())
+        return;
+
+    const uchar *src;
+    uchar *dest;
+
+    if (r.top() < p.y()) {
+        src = mem + r.bottom() * lineskip + r.left() * depth;
+        dest = mem + (p.y() + r.height() - 1) * lineskip + p.x() * depth;
+        lineskip = -lineskip;
+    } else {
+        src = mem + r.top() * lineskip + r.left() * depth;
+        dest = mem + p.y() * lineskip + p.x() * depth;
+    }
+
+    const int w = r.width();
+    int h = r.height();
+    const int bytes = w * depth;
+
+    // overlapping segments?
+    if (offset.y() == 0 && qAbs(offset.x()) < w) {
+        do {
+            ::memmove(dest, src, bytes);
+            dest += lineskip;
+            src += lineskip;
+        } while (--h);
+    } else {
+        do {
+            ::memcpy(dest, src, bytes);
+            dest += lineskip;
+            src += lineskip;
+        } while (--h);
+    }
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qwindowsurface_mac.cpp b/src/gui/painting/qwindowsurface_mac.cpp
new file mode 100644
index 0000000000..620a50f3ea
--- /dev/null
+++ b/src/gui/painting/qwindowsurface_mac.cpp
@@ -0,0 +1,139 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qwindowsurface_mac_p.h"
+
+#include <private/qt_mac_p.h>
+#include <private/qt_cocoa_helpers_mac_p.h>
+#include <QtGui/qwidget.h>
+
+QT_BEGIN_NAMESPACE
+
+struct QMacWindowSurfacePrivate
+{
+    QWidget *widget;
+    QPixmap device;
+};
+
+QMacWindowSurface::QMacWindowSurface(QWidget *widget)
+    : QWindowSurface(widget), d_ptr(new QMacWindowSurfacePrivate)
+{
+    d_ptr->widget = widget;
+}
+
+QMacWindowSurface::~QMacWindowSurface()
+{
+    delete d_ptr;
+}
+
+QPaintDevice *QMacWindowSurface::paintDevice()
+{
+    return &d_ptr->device;
+}
+
+void QMacWindowSurface::flush(QWidget *widget, const QRegion &rgn, const QPoint &offset)
+{
+    Q_UNUSED(offset);
+
+    // Get a context for the widget.
+#ifndef QT_MAC_USE_COCOA
+    CGContextRef context;
+    CGrafPtr port = GetWindowPort(qt_mac_window_for(widget));
+    QDBeginCGContext(port, &context);
+#else
+    extern CGContextRef qt_mac_graphicsContextFor(QWidget *);
+    CGContextRef context = qt_mac_graphicsContextFor(widget);
+#endif
+    CGContextRetain(context);
+    CGContextSaveGState(context);
+
+    // Flip context.
+    CGContextTranslateCTM(context, 0, widget->height());
+    CGContextScaleCTM(context, 1, -1);
+
+    // Clip to region.
+    const QVector<QRect> &rects = rgn.rects();
+    for (int i = 0; i < rects.size(); ++i) {
+        const QRect &rect = rects.at(i);
+        CGContextAddRect(context, CGRectMake(rect.x(), rect.y(), rect.width(), rect.height()));
+    }
+    CGContextClip(context);
+
+    // Draw the image onto the window.
+    const CGRect dest = CGRectMake(0, 0, widget->width(), widget->height());
+    const CGImageRef image = d_ptr->device.toMacCGImageRef();
+    qt_mac_drawCGImage(context, &dest, image);
+    CFRelease(image);
+
+    // Restore context.
+    CGContextRestoreGState(context);
+#ifndef QT_MAC_USE_COCOA
+    QDEndCGContext(port, &context);
+#else
+    CGContextFlush(context);
+#endif
+    CGContextRelease(context);
+}
+
+void QMacWindowSurface::setGeometry(const QRect &rect)
+{
+    QWindowSurface::setGeometry(rect);
+    const QSize size = rect.size();
+    if (d_ptr->device.size() != size)
+        d_ptr->device = QPixmap(size);
+}
+
+bool QMacWindowSurface::scroll(const QRegion &area, int dx, int dy)
+{
+    if (d_ptr->device.size().isNull())
+        return false;
+
+    QCFType<CGImageRef> image = d_ptr->device.toMacCGImageRef();
+    const QRect rect(area.boundingRect());
+    const CGRect dest = CGRectMake(rect.x(), rect.y(), rect.width(), rect.height());
+    QCFType<CGImageRef> subimage = CGImageCreateWithImageInRect(image, dest);
+    QCFType<CGContextRef> context = qt_mac_cg_context(&d_ptr->device);
+    CGContextTranslateCTM(context, dx, dy);
+    qt_mac_drawCGImage(context, &dest, subimage);
+    return true;
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qwindowsurface_mac_p.h b/src/gui/painting/qwindowsurface_mac_p.h
new file mode 100644
index 0000000000..fd68b1fe91
--- /dev/null
+++ b/src/gui/painting/qwindowsurface_mac_p.h
@@ -0,0 +1,84 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QWINDOWSURFACE_MAC_P_H
+#define QWINDOWSURFACE_MAC_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of other Qt classes.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <qglobal.h>
+#include "private/qwindowsurface_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QPaintDevice;
+class QPoint;
+class QRegion;
+class QWidget;
+struct QMacWindowSurfacePrivate;
+
+class QMacWindowSurface : public QWindowSurface
+{
+public:
+    QMacWindowSurface(QWidget *widget);
+    ~QMacWindowSurface();
+
+    QPaintDevice *paintDevice();
+    void flush(QWidget *widget, const QRegion &region, const QPoint &offset);
+    void setGeometry(const QRect &rect);
+    bool scroll(const QRegion &area, int dx, int dy);
+
+private:
+    QMacWindowSurfacePrivate *d_ptr;
+};
+
+QT_END_NAMESPACE
+
+#endif // QWINDOWSURFACE_MAC_P_H
diff --git a/src/gui/painting/qwindowsurface_p.h b/src/gui/painting/qwindowsurface_p.h
new file mode 100644
index 0000000000..a3fea67f24
--- /dev/null
+++ b/src/gui/painting/qwindowsurface_p.h
@@ -0,0 +1,138 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QWINDOWSURFACE_P_H
+#define QWINDOWSURFACE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of other Qt classes.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtGui/qwidget.h>
+
+QT_BEGIN_NAMESPACE
+
+class QPaintDevice;
+class QRegion;
+class QRect;
+class QPoint;
+class QImage;
+class QWindowSurfacePrivate;
+class QPlatformWindow;
+
+class Q_GUI_EXPORT QWindowSurface
+{
+public:
+    enum WindowSurfaceFeature {
+        PartialUpdates               = 0x00000001, // Supports doing partial updates.
+        PreservedContents            = 0x00000002, // Supports doing flush without first doing a repaint.
+        StaticContents               = 0x00000004, // Supports having static content regions when being resized.
+        AllFeatures                  = 0xffffffff  // For convenience
+    };
+    Q_DECLARE_FLAGS(WindowSurfaceFeatures, WindowSurfaceFeature)
+
+    QWindowSurface(QWidget *window, bool setDefaultSurface = true);
+    virtual ~QWindowSurface();
+
+    QWidget *window() const;
+
+    virtual QPaintDevice *paintDevice() = 0;
+
+    // 'widget' can be a child widget, in which case 'region' is in child widget coordinates and
+    // offset is the (child) widget's offset in relation to the window surface. On QWS, 'offset'
+    // can be larger than just the offset from the top-level widget as there may also be window
+    // decorations which are painted into the window surface.
+    virtual void flush(QWidget *widget, const QRegion &region, const QPoint &offset) = 0;
+#if !defined(Q_WS_QPA)
+    virtual void setGeometry(const QRect &rect);
+    QRect geometry() const;
+#else
+    virtual void resize(const QSize &size);
+    QSize size() const;
+    inline QRect geometry() const { return QRect(QPoint(), size()); }     //### cleanup before Qt 5
+#endif
+
+    virtual bool scroll(const QRegion &area, int dx, int dy);
+
+    virtual void beginPaint(const QRegion &);
+    virtual void endPaint(const QRegion &);
+
+    virtual QImage* buffer(const QWidget *widget);
+    virtual QPixmap grabWidget(const QWidget *widget, const QRect& rectangle = QRect()) const;
+
+    virtual QPoint offset(const QWidget *widget) const;
+    inline QRect rect(const QWidget *widget) const;
+
+    bool hasFeature(WindowSurfaceFeature feature) const;
+    virtual WindowSurfaceFeatures features() const;
+
+    void setStaticContents(const QRegion &region);
+    QRegion staticContents() const;
+
+protected:
+    bool hasStaticContents() const;
+
+private:
+    QWindowSurfacePrivate *d_ptr;
+};
+
+Q_DECLARE_OPERATORS_FOR_FLAGS(QWindowSurface::WindowSurfaceFeatures)
+
+inline QRect QWindowSurface::rect(const QWidget *widget) const
+{
+    return widget->rect().translated(offset(widget));
+}
+
+inline bool QWindowSurface::hasFeature(WindowSurfaceFeature feature) const
+{
+    return (features() & feature) != 0;
+}
+
+QT_END_NAMESPACE
+
+#endif // QWINDOWSURFACE_P_H
diff --git a/src/gui/painting/qwindowsurface_qws.cpp b/src/gui/painting/qwindowsurface_qws.cpp
new file mode 100644
index 0000000000..cb293cb135
--- /dev/null
+++ b/src/gui/painting/qwindowsurface_qws.cpp
@@ -0,0 +1,1433 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qwindowsurface_qws_p.h"
+#include <qwidget.h>
+#include <qscreen_qws.h>
+#include <qwsmanager_qws.h>
+#include <qapplication.h>
+#include <qwsdisplay_qws.h>
+#include <qrgb.h>
+#include <qpaintengine.h>
+#include <qdesktopwidget.h>
+#include <private/qapplication_p.h>
+#include <private/qwsdisplay_qws_p.h>
+#include <private/qwidget_p.h>
+#include <private/qwsmanager_p.h>
+#include <private/qwslock_p.h>
+#include <private/qbackingstore_p.h>
+#include <stdio.h>
+
+QT_BEGIN_NAMESPACE
+
+#ifdef Q_BACKINGSTORE_SUBSURFACES
+
+typedef QMap<int, QWSWindowSurface*> SurfaceMap;
+Q_GLOBAL_STATIC(SurfaceMap, winIdToSurfaceMap);
+
+QWSWindowSurface* qt_findWindowSurface(int winId)
+{
+    return winIdToSurfaceMap()->value(winId);
+}
+
+static void qt_insertWindowSurface(int winId, QWSWindowSurface *surface)
+{
+    if (!surface)
+        winIdToSurfaceMap()->remove(winId);
+    else
+        winIdToSurfaceMap()->insert(winId, surface);
+}
+
+#endif // Q_BACKINGSTORE_SUBSURFACES
+
+inline bool isWidgetOpaque(const QWidget *w)
+{
+    return w->d_func()->isOpaque && !w->testAttribute(Qt::WA_TranslucentBackground);
+}
+
+static inline QScreen *getScreen(const QWidget *w)
+{
+    const QList<QScreen*> subScreens = qt_screen->subScreens();
+    if (subScreens.isEmpty())
+        return qt_screen;
+
+    const int screen = QApplication::desktop()->screenNumber(w);
+
+    return qt_screen->subScreens().at(screen < 0 ? 0 : screen);
+}
+
+static int bytesPerPixel(QImage::Format format)
+{
+    switch (format) {
+    case QImage::Format_Invalid:
+        return 0;
+#ifndef QT_NO_DEBUG
+    case QImage::Format_Mono:
+    case QImage::Format_MonoLSB:
+        qFatal("QWSWindowSurface: Invalid backingstore format: %i",
+               int(format));
+#endif
+    case QImage::Format_Indexed8:
+        return 1;
+    case QImage::Format_RGB32:
+    case QImage::Format_ARGB32:
+    case QImage::Format_ARGB32_Premultiplied:
+        return 4;
+    case QImage::Format_RGB16:
+    case QImage::Format_RGB555:
+    case QImage::Format_RGB444:
+    case QImage::Format_ARGB4444_Premultiplied:
+        return 2;
+    case QImage::Format_ARGB8565_Premultiplied:
+    case QImage::Format_ARGB8555_Premultiplied:
+    case QImage::Format_ARGB6666_Premultiplied:
+    case QImage::Format_RGB666:
+    case QImage::Format_RGB888:
+        return 3;
+    default:
+#ifndef QT_NO_DEBUG
+        qFatal("QWSWindowSurface: Invalid backingstore format: %i",
+               int(format));
+#endif
+        return 0;
+    }
+}
+
+static inline int nextMulOf4(int n)
+{
+    return ((n + 3) & 0xfffffffc);
+}
+
+static inline void setImageMetrics(QImage &img, QWidget *window) {
+    QScreen *myScreen = getScreen(window);
+    if (myScreen) {
+        int dpmx = myScreen->width()*1000 / myScreen->physicalWidth();
+        int dpmy = myScreen->height()*1000 / myScreen->physicalHeight();
+        img.setDotsPerMeterX(dpmx);
+        img.setDotsPerMeterY(dpmy);
+    }
+}
+
+void QWSWindowSurface::invalidateBuffer()
+{
+
+    QWidget *win = window();
+    if (win) {
+        win->d_func()->invalidateBuffer(win->rect());
+#ifndef QT_NO_QWS_MANAGER
+        QTLWExtra *topextra = win->d_func()->extra->topextra;
+        QWSManager *manager = topextra->qwsManager;
+        if (manager)
+            manager->d_func()->dirtyRegion(QDecoration::All,
+                                           QDecoration::Normal);
+#endif
+    }
+}
+
+QWSWindowSurfacePrivate::QWSWindowSurfacePrivate()
+    : flags(0),
+#ifdef QT_QWS_CLIENTBLIT
+    directId(-1),
+#endif
+    winId(0)
+{
+}
+
+void QWSWindowSurfacePrivate::setWinId(int id)
+{
+    winId = id;
+}
+
+int QWSWindowSurface::winId() const
+{
+    // XXX: the widget winId may change during the lifetime of the widget!!!
+
+    const QWidget *win = window();
+    if (win && win->isWindow())
+        return win->internalWinId();
+
+#ifdef Q_BACKINGSTORE_SUBSURFACES
+    if (!d_ptr->winId) {
+        QWSWindowSurface *that = const_cast<QWSWindowSurface*>(this);
+        QWSDisplay *display = QWSDisplay::instance();
+        const int id = display->takeId();
+        qt_insertWindowSurface(id, that);
+        that->d_ptr->winId = id;
+
+        if (win)
+            display->nameRegion(id, win->objectName(), win->windowTitle());
+        else
+            display->nameRegion(id, QString(), QString());
+
+        display->setAltitude(id, 1, true); // XXX
+    }
+#endif
+
+    return d_ptr->winId;
+}
+
+void QWSWindowSurface::setWinId(int id)
+{
+    d_ptr->winId = id;
+}
+
+/*!
+    \class QWSWindowSurface
+    \since 4.2
+    \ingroup qws
+    \preliminary
+    \internal
+
+    \brief The QWSWindowSurface class provides the drawing area for top-level
+    windows in Qt for Embedded Linux.
+
+    Note that this class is only available in Qt for Embedded Linux.
+
+    In \l{Qt for Embedded Linux}, the default behavior is for each client to
+    render its widgets into memory while the server is responsible for
+    putting the contents of the memory onto the
+    screen. QWSWindowSurface is used by the window system to implement
+    the associated memory allocation.
+
+    When a screen update is required, the server runs through all the
+    top-level windows that intersect with the region that is about to
+    be updated, and ensures that the associated clients have updated
+    their memory buffer. Then the server uses the screen driver to
+    copy the content of the memory to the screen. To locate the
+    relevant parts of memory, the driver is provided with the list of
+    top-level windows that intersect with the given region. Associated
+    with each of the top-level windows there is a window surface
+    representing the drawing area of the window.
+
+    When deriving from the QWSWindowSurface class, e.g., when adding
+    an \l {Adding an Accelerated Graphics Driver to Qt for Embedded Linux}
+    {accelerated graphics driver}, there are several pure virtual
+    functions that must be implemented. In addition, QWSWindowSurface
+    provides several virtual functions that can be reimplemented to
+    customize the drawing process.
+
+    \tableofcontents
+
+    \section1 Pure Virtual Functions
+
+    There are in fact two window surface instances for each top-level
+    window; one used by the application when drawing a window, and
+    another used by the server application to perform window
+    compositioning. Implement the attach() to create the server-side
+    representation of the surface. The data() function must be
+    implemented to provide the required data.
+
+    Implement the key() function to uniquely identify the surface
+    class, and the isValid() function to determine is a surface
+    corresponds to a given widget.
+
+    The geometry() function must be implemented to let the window
+    system determine the area required by the window surface
+    (QWSWindowSurface also provides a corresponding virtual
+    setGeometry() function that is called whenever the area necessary
+    for the top-level window to be drawn, changes). The image()
+    function is called by the window system during window
+    compositioning, and must be implemented to return an image of the
+    top-level window.
+
+    Finally, the paintDevice() function must be implemented to return
+    the appropriate paint device, and the scroll() function must be
+    implemented to scroll the given region of the surface the given
+    number of pixels.
+
+    \section1 Virtual Functions
+
+    When painting onto the surface, the window system will always call
+    the beginPaint() function before any painting operations are
+    performed. Likewise the endPaint() function is automatically
+    called when the painting is done. Reimplement the painterOffset()
+    function to alter the offset that is applied when drawing.
+
+    The window system uses the flush() function to put a given region
+    of the widget onto the screen, and the release() function to
+    deallocate the screen region corresponding to this window surface.
+
+    \section1 Other Members
+
+    QWSWindowSurface provides the window() function returning a
+    pointer to the top-level window the surface is representing. The
+    currently visible region of the associated widget can be retrieved
+    and set using the clipRegion() and setClipRegion() functions,
+    respectively.
+
+    When the window system performs the window compositioning, it uses
+    the SurfaceFlag enum describing the surface content. The currently
+    set surface flags can be retrieved and altered using the
+    surfaceFlags() and setSurfaceFlags() functions. In addition,
+    QWSWindowSurface provides the isBuffered(), isOpaque() and
+    isRegionReserved() convenience functions.
+
+    \sa {Qt for Embedded Linux Architecture#Drawing on Screen}{Qt for
+    Embedded Linux Architecture}
+*/
+
+/*!
+    \enum QWSWindowSurface::SurfaceFlag
+
+    This enum is used to describe the window surface's contents.  It
+    is used by the screen driver to handle region allocation and
+    composition.
+
+    \value RegionReserved The surface contains a reserved area. Once
+    allocated, a reserved area can not not be changed by the window
+    system, i.e., no other widgets can be drawn on top of this.
+
+    \value Buffered
+    The surface is in a memory area which is not part of a framebuffer.
+    (A top-level window with QWidget::windowOpacity() other than 1.0 must use
+    a buffered surface in order to making blending with the background work.)
+
+    \value Opaque
+    The surface contains only opaque pixels.
+
+    \sa surfaceFlags(), setSurfaceFlags()
+*/
+
+/*!
+    \fn bool QWSWindowSurface::isValid() const
+    \since 4.3
+
+    Implement this function to return true if the surface is a valid
+    surface for the given top-level \a window; otherwise return
+    false.
+
+    \sa window(), key()
+*/
+
+/*!
+    \fn QString QWSWindowSurface::key() const
+
+    Implement this function to return a string that uniquely
+    identifies the class of this surface.
+
+    \sa window(), isValid()
+*/
+
+/*!
+    \fn QByteArray QWSWindowSurface::permanentState() const
+    \since 4.3
+
+    Implement this function to return the data required for creating a
+    server-side representation of the surface.
+
+    \sa attach()
+*/
+
+/*!
+    \fn void QWSWindowSurface::setPermanentState(const QByteArray &data)
+    \since 4.3
+
+    Implement this function to attach a server-side surface instance
+    to the corresponding client side instance using the given \a
+    data. Return true if successful; otherwise return false.
+
+    \sa data()
+*/
+
+/*!
+    \fn const QImage QWSWindowSurface::image() const
+
+    Implement this function to return an image of the top-level window.
+
+    \sa geometry()
+*/
+
+/*!
+    \fn bool QWSWindowSurface::isRegionReserved() const
+
+    Returns true if the QWSWindowSurface::RegionReserved is set; otherwise
+    returns false.
+
+    \sa surfaceFlags()
+*/
+
+/*!
+    \fn bool QWSWindowSurface::isBuffered() const
+
+    Returns true if the QWSWindowSurface::Buffered is set; otherwise returns false.
+
+    \sa surfaceFlags()
+*/
+
+/*!
+    \fn bool QWSWindowSurface::isOpaque() const
+
+    Returns true if the QWSWindowSurface::Opaque is set; otherwise
+    returns false.
+
+    \sa surfaceFlags()
+*/
+
+
+/*!
+    Constructs an empty surface.
+*/
+QWSWindowSurface::QWSWindowSurface()
+    : QWindowSurface(0), d_ptr(new QWSWindowSurfacePrivate)
+{
+}
+
+/*!
+    Constructs an empty surface for the given top-level \a widget.
+*/
+QWSWindowSurface::QWSWindowSurface(QWidget *widget)
+    : QWindowSurface(widget), d_ptr(new QWSWindowSurfacePrivate)
+{
+}
+
+QWSWindowSurface::~QWSWindowSurface()
+{
+#ifdef Q_BACKINGSTORE_SUBSURFACES
+    if (d_ptr->winId)
+        winIdToSurfaceMap()->remove(d_ptr->winId);
+#endif
+
+    delete d_ptr;
+}
+
+/*!
+    Returns the offset to be used when painting.
+
+    \sa paintDevice()
+*/
+QPoint QWSWindowSurface::painterOffset() const
+{
+    const QWidget *w = window();
+    if (!w)
+        return QPoint();
+    return w->geometry().topLeft() - w->frameGeometry().topLeft();
+}
+
+void QWSWindowSurface::beginPaint(const QRegion &)
+{
+    lock();
+}
+
+void QWSWindowSurface::endPaint(const QRegion &)
+{
+    unlock();
+}
+
+// XXX: documentation!!!
+QByteArray QWSWindowSurface::transientState() const
+{
+    return QByteArray();
+}
+
+QByteArray QWSWindowSurface::permanentState() const
+{
+    return QByteArray();
+}
+
+void QWSWindowSurface::setTransientState(const QByteArray &state)
+{
+    Q_UNUSED(state);
+}
+
+void QWSWindowSurface::setPermanentState(const QByteArray &state)
+{
+    Q_UNUSED(state);
+}
+
+bool QWSWindowSurface::lock(int timeout)
+{
+    Q_UNUSED(timeout);
+    return true;
+}
+
+void QWSWindowSurface::unlock()
+{
+}
+
+#ifdef QT_QWS_CLIENTBLIT
+/*! \internal */
+const QRegion QWSWindowSurface::directRegion() const
+{
+    return d_ptr->direct;
+}
+
+/*! \internal */
+int QWSWindowSurface::directRegionId() const
+{
+    return d_ptr->directId;
+}
+
+/*! \internal */
+void QWSWindowSurface::setDirectRegion(const QRegion &r, int id)
+{
+    d_ptr->direct = r;
+    d_ptr->directId = id;
+}
+#endif
+
+/*!
+    Returns the region currently visible on the screen.
+
+    \sa setClipRegion()
+*/
+const QRegion QWSWindowSurface::clipRegion() const
+{
+    return d_ptr->clip;
+}
+
+/*!
+    Sets the region currently visible on the screen to be the given \a
+    clip region.
+
+    \sa clipRegion()
+*/
+void QWSWindowSurface::setClipRegion(const QRegion &clip)
+{
+    if (clip == d_ptr->clip)
+        return;
+
+    QRegion expose = (clip - d_ptr->clip);
+    d_ptr->clip = clip;
+
+    if (expose.isEmpty() || clip.isEmpty())
+        return; // No repaint or flush required.
+
+    QWidget *win = window();
+    if (!win)
+        return;
+
+    if (isBuffered()) {
+        // No repaint required. Flush exposed area via the backing store.
+        win->d_func()->syncBackingStore(expose);
+        return;
+    }
+
+#ifndef QT_NO_QWS_MANAGER
+    // Invalidate exposed decoration area.
+    if (win && win->isWindow()) {
+        QTLWExtra *topextra = win->d_func()->extra->topextra;
+        if (QWSManager *manager = topextra->qwsManager) {
+            QRegion decorationExpose(manager->region());
+            decorationExpose.translate(-win->geometry().topLeft());
+            decorationExpose &= expose;
+            if (!decorationExpose.isEmpty()) {
+                expose -= decorationExpose;
+                manager->d_func()->dirtyRegion(QDecoration::All, QDecoration::Normal, decorationExpose);
+            }
+        }
+    }
+#endif
+
+    // Invalidate exposed widget area.
+    win->d_func()->invalidateBuffer(expose);
+}
+
+/*!
+    Returns the surface flags describing the contents of this surface.
+
+    \sa isBuffered(), isOpaque(), isRegionReserved()
+*/
+QWSWindowSurface::SurfaceFlags QWSWindowSurface::surfaceFlags() const
+{
+    return d_ptr->flags;
+}
+
+/*!
+    Sets the surface flags describing the contents of this surface, to
+    be the given \a flags.
+
+    \sa surfaceFlags()
+*/
+void QWSWindowSurface::setSurfaceFlags(SurfaceFlags flags)
+{
+    d_ptr->flags = flags;
+}
+
+void QWSWindowSurface::setGeometry(const QRect &rect)
+{
+    QRegion mask = rect;
+
+    const QWidget *win = window();
+    if (win) {
+#ifndef QT_NO_QWS_MANAGER
+        if (win->isWindow()) {
+            QTLWExtra *topextra = win->d_func()->extra->topextra;
+            QWSManager *manager = topextra->qwsManager;
+
+            if (manager) {
+                // The frame geometry is the bounding rect of manager->region,
+                // which could be too much, so we need to clip.
+                mask &= (manager->region() + win->geometry());
+            }
+        }
+#endif
+
+        const QRegion winMask = win->mask();
+        if (!winMask.isEmpty())
+            mask &= winMask.translated(win->geometry().topLeft());
+    }
+
+    setGeometry(rect, mask);
+}
+
+void QWSWindowSurface::setGeometry(const QRect &rect, const QRegion &mask)
+{
+    if (rect == geometry()) // XXX: && mask == prevMask
+        return;
+
+    const bool isResize = rect.size() != geometry().size();
+    const bool needsRepaint = isResize || !isBuffered();
+
+    QWindowSurface::setGeometry(rect);
+
+    const QRegion region = mask & rect;
+    QWidget *win = window();
+    // Only request regions for widgets visible on the screen.
+    // (Added the !win check for compatibility reasons, because
+    // there was no "if (win)" check before).
+    const bool requestQWSRegion = !win || !win->testAttribute(Qt::WA_DontShowOnScreen);
+    if (requestQWSRegion)
+        QWidget::qwsDisplay()->requestRegion(winId(), key(), permanentState(), region);
+
+    if (needsRepaint)
+        invalidateBuffer();
+
+    if (!requestQWSRegion) {
+        // We didn't request a region, hence we won't get a QWSRegionEvent::Allocation
+        // event back from the server so we set the clip directly. We have to
+        // do this after the invalidateBuffer() call above, as it might trigger a
+        // backing store sync, resulting in too many update requests.
+        setClipRegion(region);
+    }
+}
+
+static inline void flushUpdate(QWidget *widget, const QRegion &region,
+                               const QPoint &offset)
+{
+#ifdef QT_NO_PAINT_DEBUG
+    Q_UNUSED(widget);
+    Q_UNUSED(region);
+    Q_UNUSED(offset);
+#else
+    static int delay = -1;
+
+    if (delay == -1)
+        delay = qgetenv("QT_FLUSH_UPDATE").toInt() * 10;
+
+    if (delay == 0)
+        return;
+
+    static QWSYellowSurface surface(true);
+    surface.setDelay(delay);
+    surface.flush(widget, region, offset);
+#endif // QT_NO_PAINT_DEBUG
+}
+
+void QWSWindowSurface::flush(QWidget *widget, const QRegion &region,
+                             const QPoint &offset)
+{
+    const QWidget *win = window();
+    if (!win)
+        return;
+
+#ifndef QT_NO_GRAPHICSVIEW
+    QWExtra *extra = win->d_func()->extra;
+    if (extra && extra->proxyWidget)
+        return;
+#endif //QT_NO_GRAPHICSVIEW
+
+    Q_UNUSED(offset);
+
+    const bool opaque = isOpaque();
+#ifdef QT_QWS_DISABLE_FLUSHCLIPPING
+    QRegion toFlush = region;
+#else
+    QRegion toFlush = region & d_ptr->clip;
+#endif
+
+    if (!toFlush.isEmpty()) {
+        flushUpdate(widget, toFlush, QPoint(0, 0));
+        QPoint globalZero = win->mapToGlobal(QPoint(0, 0));
+        toFlush.translate(globalZero);
+
+#ifdef QT_QWS_CLIENTBLIT
+        bool needRepaint = true;
+        if (opaque) {
+            QScreen* widgetScreen = getScreen(widget);
+            if (widgetScreen->supportsBlitInClients()) {
+
+                QWSDisplay::grab();
+                if(directRegion().intersected(toFlush) == toFlush) {
+                    QPoint translate = -globalZero + painterOffset() + geometry().topLeft();
+                    QRegion flushRegion = toFlush.translated(translate);
+                    widgetScreen->blit(image(), geometry().topLeft(), flushRegion);
+                    widgetScreen->setDirty(toFlush.boundingRect());
+                    needRepaint = false;
+                }
+                QWSDisplay::ungrab();
+            }
+        }
+
+        if(needRepaint)
+#endif
+            win->qwsDisplay()->repaintRegion(winId(), win->windowFlags(), opaque, toFlush);
+    }
+}
+
+/*!
+    Move the surface with the given \a offset.
+
+    A subclass may reimplement this function to enable accelerated window move.
+    It must return true if the move was successful and no repaint is necessary,
+    false otherwise.
+
+    The default implementation updates the QWindowSurface geometry and
+    returns true if the surface is buffered; false otherwise.
+
+    This function is called by the window system on the client instance.
+
+    \sa isBuffered()
+*/
+bool QWSWindowSurface::move(const QPoint &offset)
+{
+    QWindowSurface::setGeometry(geometry().translated(offset));
+    return isBuffered();
+}
+
+/*!
+    Move the surface with the given \a offset.
+
+    The new visible region after the window move is given by \a newClip
+    in screen coordinates.
+
+    A subclass may reimplement this function to enable accelerated window move.
+    The returned region indicates the area that still needs to be composed
+    on the screen.
+
+    The default implementation updates the QWindowSurface geometry and
+    returns the union of the old and new geometry.
+
+    This function is called by the window system on the server instance.
+*/
+QRegion QWSWindowSurface::move(const QPoint &offset, const QRegion &newClip)
+{
+    const QRegion oldGeometry = geometry();
+    QWindowSurface::setGeometry(geometry().translated(offset));
+    return oldGeometry + newClip;
+}
+
+void QWSWindowSurface::releaseSurface()
+{
+}
+
+bool QWSMemorySurface::lock(int timeout)
+{
+    Q_UNUSED(timeout);
+#ifndef QT_NO_QWS_MULTIPROCESS
+    if (memlock && !memlock->lock(QWSLock::BackingStore))
+        return false;
+#endif
+#ifndef QT_NO_THREAD
+    threadLock.lock();
+#endif
+    return true;
+}
+
+void QWSMemorySurface::unlock()
+{
+#ifndef QT_NO_THREAD
+    threadLock.unlock();
+#endif
+#ifndef QT_NO_QWS_MULTIPROCESS
+    if (memlock)
+        memlock->unlock(QWSLock::BackingStore);
+#endif
+}
+
+QWSMemorySurface::QWSMemorySurface()
+    : QWSWindowSurface()
+#ifndef QT_NO_QWS_MULTIPROCESS
+    , memlock(0)
+#endif
+{
+    setSurfaceFlags(Buffered);
+}
+
+QWSMemorySurface::QWSMemorySurface(QWidget *w)
+    : QWSWindowSurface(w)
+{
+    SurfaceFlags flags = Buffered;
+    if (isWidgetOpaque(w))
+        flags |= Opaque;
+    setSurfaceFlags(flags);
+
+#ifndef QT_NO_QWS_MULTIPROCESS
+    memlock = QWSDisplay::Data::getClientLock();
+#endif
+}
+
+QWSMemorySurface::~QWSMemorySurface()
+{
+}
+
+
+QImage::Format
+QWSMemorySurface::preferredImageFormat(const QWidget *widget) const
+{
+    QScreen *screen = getScreen(widget);
+    const int depth = screen->depth();
+    const bool opaque = isWidgetOpaque(widget);
+
+    if (!opaque) {
+        if (depth <= 12)
+            return QImage::Format_ARGB4444_Premultiplied;
+        else if (depth <= 15)
+            return QImage::Format_ARGB8555_Premultiplied;
+        else if (depth <= 16)
+            return QImage::Format_ARGB8565_Premultiplied;
+        else if (depth <= 18)
+            return QImage::Format_ARGB6666_Premultiplied;
+        else
+            return QImage::Format_ARGB32_Premultiplied;
+    }
+
+    QImage::Format format = screen->pixelFormat();
+    if (format > QImage::Format_Indexed8) // ### assumes all new image formats supports a QPainter
+        return format;
+
+    if (depth <= 12)
+        return QImage::Format_RGB444;
+    else if (depth <= 15)
+        return QImage::Format_RGB555;
+    else if (depth <= 16)
+        return QImage::Format_RGB16;
+    else if (depth <= 18)
+        return QImage::Format_RGB666;
+    else if (depth <= 24)
+        return QImage::Format_RGB888;
+    else
+        return QImage::Format_ARGB32_Premultiplied;
+}
+
+#ifndef QT_NO_QWS_MULTIPROCESS
+void QWSMemorySurface::setLock(int lockId)
+{
+    if (memlock && memlock->id() == lockId)
+        return;
+    delete memlock;
+    memlock = (lockId == -1 ? 0 : new QWSLock(lockId));
+    return;
+}
+#endif // QT_NO_QWS_MULTIPROCESS
+
+bool QWSMemorySurface::isValid() const
+{
+    if (img.isNull())
+        return true;
+
+    const QWidget *win = window();
+    if (preferredImageFormat(win) != img.format())
+        return false;
+
+    if (isOpaque() != isWidgetOpaque(win)) // XXX: use QWidgetPrivate::isOpaque()
+        return false;
+
+    return true;
+}
+
+// ### copied from qwindowsurface_raster.cpp -- should be cross-platform
+void QWSMemorySurface::beginPaint(const QRegion &rgn)
+{
+    if (!isWidgetOpaque(window())) {
+        QPainter p(&img);
+        p.setCompositionMode(QPainter::CompositionMode_Source);
+        const QVector<QRect> rects = rgn.rects();
+        const QColor blank = Qt::transparent;
+        for (QVector<QRect>::const_iterator it = rects.begin(); it != rects.end(); ++it) {
+            QRect r = *it;
+#ifdef Q_BACKINGSTORE_SUBSURFACES
+            r.translate(painterOffset());
+#endif
+            p.fillRect(r, blank);
+        }
+    }
+    QWSWindowSurface::beginPaint(rgn);
+}
+
+// from qwindowsurface.cpp
+extern void qt_scrollRectInImage(QImage &img, const QRect &rect, const QPoint &offset);
+
+bool QWSMemorySurface::scroll(const QRegion &area, int dx, int dy)
+{
+    const QVector<QRect> rects = area.rects();
+    for (int i = 0; i < rects.size(); ++i)
+        qt_scrollRectInImage(img, rects.at(i), QPoint(dx, dy));
+
+    return true;
+}
+
+QPoint QWSMemorySurface::painterOffset() const
+{
+    const QWidget *w = window();
+    if (!w)
+        return QPoint();
+
+    if (w->mask().isEmpty())
+        return QWSWindowSurface::painterOffset();
+
+    const QRegion region = w->mask()
+                           & w->frameGeometry().translated(-w->geometry().topLeft());
+    return -region.boundingRect().topLeft();
+}
+
+QWSLocalMemSurface::QWSLocalMemSurface()
+    : QWSMemorySurface(), mem(0), memsize(0)
+{
+}
+
+QWSLocalMemSurface::QWSLocalMemSurface(QWidget *w)
+    : QWSMemorySurface(w), mem(0), memsize(0)
+{
+}
+
+QWSLocalMemSurface::~QWSLocalMemSurface()
+{
+    if (memsize)
+        delete[] mem;
+}
+
+void QWSLocalMemSurface::setGeometry(const QRect &rect)
+{
+    QSize size = rect.size();
+
+    QWidget *win = window();
+    if (win && !win->mask().isEmpty()) {
+        const QRegion region = win->mask()
+                               & rect.translated(-win->geometry().topLeft());
+        size = region.boundingRect().size();
+    }
+
+    uchar *deleteLater = 0;
+    // In case of a Hide event we need to delete the memory after sending the
+    // event to the server in order to let the server animate the event.
+    if (size.isEmpty()) {
+        deleteLater = mem;
+        mem = 0;
+    }
+
+    if (img.size() != size) {
+        delete[] mem;
+        if (size.isEmpty()) {
+            mem = 0;
+            img = QImage();
+        } else {
+            const QImage::Format format = preferredImageFormat(win);
+            const int bpl = nextMulOf4(bytesPerPixel(format) * size.width());
+            const int memsize = bpl * size.height();
+            mem = new uchar[memsize];
+            img = QImage(mem, size.width(), size.height(), bpl, format);
+            setImageMetrics(img, win);
+        }
+    }
+
+    QWSWindowSurface::setGeometry(rect);
+    delete[] deleteLater;
+}
+
+QByteArray QWSLocalMemSurface::permanentState() const
+{
+    QByteArray array;
+    array.resize(sizeof(uchar*) + 3 * sizeof(int) +
+                 sizeof(SurfaceFlags));
+
+    char *ptr = array.data();
+
+    *reinterpret_cast<uchar**>(ptr) = mem;
+    ptr += sizeof(uchar*);
+
+    reinterpret_cast<int*>(ptr)[0] = img.width();
+    reinterpret_cast<int*>(ptr)[1] = img.height();
+    ptr += 2 * sizeof(int);
+
+    *reinterpret_cast<int *>(ptr) = img.format();
+    ptr += sizeof(int);
+
+    *reinterpret_cast<SurfaceFlags*>(ptr) = surfaceFlags();
+
+    return array;
+}
+
+void QWSLocalMemSurface::setPermanentState(const QByteArray &data)
+{
+    int width;
+    int height;
+    QImage::Format format;
+    SurfaceFlags flags;
+
+    const char *ptr = data.constData();
+
+    mem = *reinterpret_cast<uchar* const*>(ptr);
+    ptr += sizeof(uchar*);
+
+    width = reinterpret_cast<const int*>(ptr)[0];
+    height = reinterpret_cast<const int*>(ptr)[1];
+    ptr += 2 * sizeof(int);
+
+    format = QImage::Format(*reinterpret_cast<const int*>(ptr));
+    ptr += sizeof(int);
+
+    flags = *reinterpret_cast<const SurfaceFlags*>(ptr);
+
+    const int bpl = nextMulOf4(bytesPerPixel(format) * width);
+    QWSMemorySurface::img = QImage(mem, width, height, bpl, format);
+    setSurfaceFlags(flags);
+}
+
+void QWSLocalMemSurface::releaseSurface()
+{
+    mem = 0;
+    img = QImage();
+}
+
+#ifndef QT_NO_QWS_MULTIPROCESS
+
+QWSSharedMemSurface::QWSSharedMemSurface()
+    : QWSMemorySurface()
+{
+}
+
+QWSSharedMemSurface::QWSSharedMemSurface(QWidget *widget)
+    : QWSMemorySurface(widget)
+{
+}
+
+QWSSharedMemSurface::~QWSSharedMemSurface()
+{
+    // mem.detach() is done automatically by ~QSharedMemory
+}
+
+bool QWSSharedMemSurface::setMemory(int memId)
+{
+    if (mem.id() == memId)
+        return true;
+
+    mem.detach();
+    if (!mem.attach(memId)) {
+        perror("QWSSharedMemSurface: attaching to shared memory");
+        qCritical("QWSSharedMemSurface: Error attaching to"
+                  " shared memory 0x%x", memId);
+        return false;
+    }
+
+    return true;
+}
+
+#ifdef QT_QWS_CLIENTBLIT
+void QWSSharedMemSurface::setDirectRegion(const QRegion &r, int id)
+{
+    QWSMemorySurface::setDirectRegion(r, id);
+    if(mem.address())
+        *(uint *)mem.address() = id;
+}
+
+const QRegion QWSSharedMemSurface::directRegion() const
+{
+    QWSSharedMemory *cmem = const_cast<QWSSharedMemory *>(&mem);
+    if (cmem->address() && ((int*)cmem->address())[0] == directRegionId())
+        return QWSMemorySurface::directRegion();
+    else
+        return QRegion();
+}
+#endif
+
+void QWSSharedMemSurface::setPermanentState(const QByteArray &data)
+{
+    int memId;
+    int width;
+    int height;
+    int lockId;
+    QImage::Format format;
+    SurfaceFlags flags;
+
+    const int *ptr = reinterpret_cast<const int*>(data.constData());
+
+    memId = ptr[0];
+    width = ptr[1];
+    height = ptr[2];
+    lockId = ptr[3];
+    format = QImage::Format(ptr[4]);
+    flags = SurfaceFlags(ptr[5]);
+
+    setSurfaceFlags(flags);
+    setMemory(memId);
+    setLock(lockId);
+
+#ifdef QT_QWS_CLIENTBLIT
+    uchar *base = static_cast<uchar*>(mem.address()) + sizeof(uint);
+#else
+    uchar *base = static_cast<uchar*>(mem.address());
+#endif
+    const int bpl = nextMulOf4(bytesPerPixel(format) * width);
+    QWSMemorySurface::img = QImage(base, width, height, bpl, format);
+}
+
+void QWSSharedMemSurface::setGeometry(const QRect &rect)
+{
+    const QSize size = rect.size();
+    if (img.size() != size) {
+        if (size.isEmpty()) {
+            mem.detach();
+            img = QImage();
+        } else {
+            mem.detach();
+
+            QWidget *win = window();
+            const QImage::Format format = preferredImageFormat(win);
+            const int bpl = nextMulOf4(bytesPerPixel(format) * size.width());
+#ifdef QT_QWS_CLIENTBLIT
+            const int imagesize = bpl * size.height() + sizeof(uint);
+#else
+            const int imagesize = bpl * size.height();
+#endif
+            if (!mem.create(imagesize)) {
+                perror("QWSSharedMemSurface::setGeometry allocating shared memory");
+                qFatal("Error creating shared memory of size %d", imagesize);
+            }
+#ifdef QT_QWS_CLIENTBLIT
+            *((uint *)mem.address()) = 0;
+            uchar *base = static_cast<uchar*>(mem.address()) + sizeof(uint);
+#else
+            uchar *base = static_cast<uchar*>(mem.address());
+#endif
+            img = QImage(base, size.width(), size.height(), bpl, format);
+            setImageMetrics(img, win);
+        }
+    }
+
+    QWSWindowSurface::setGeometry(rect);
+}
+
+QByteArray QWSSharedMemSurface::permanentState() const
+{
+    QByteArray array;
+    array.resize(6 * sizeof(int));
+
+    int *ptr = reinterpret_cast<int*>(array.data());
+
+    ptr[0] = mem.id();
+    ptr[1] = img.width();
+    ptr[2] = img.height();
+    ptr[3] = (memlock ? memlock->id() : -1);
+    ptr[4] = int(img.format());
+    ptr[5] = int(surfaceFlags());
+
+    return array;
+}
+
+void QWSSharedMemSurface::releaseSurface()
+{
+    mem.detach();
+    img = QImage();
+}
+
+#endif // QT_NO_QWS_MULTIPROCESS
+
+#ifndef QT_NO_PAINTONSCREEN
+
+QWSOnScreenSurface::QWSOnScreenSurface(QWidget *w)
+    : QWSMemorySurface(w)
+{
+    attachToScreen(getScreen(w));
+    setSurfaceFlags(Opaque);
+}
+
+QWSOnScreenSurface::QWSOnScreenSurface()
+    : QWSMemorySurface()
+{
+    setSurfaceFlags(Opaque);
+}
+
+void QWSOnScreenSurface::attachToScreen(const QScreen *s)
+{
+    screen = s;
+    uchar *base = screen->base();
+    QImage::Format format  = screen->pixelFormat();
+
+    if (format == QImage::Format_Invalid || format == QImage::Format_Indexed8) {
+        //### currently we have no paint engine for indexed image formats
+        qFatal("QWSOnScreenSurface::attachToScreen(): screen depth %d "
+               "not implemented", screen->depth());
+        return;
+    }
+    QWSMemorySurface::img = QImage(base, screen->width(), screen->height(),
+                                   screen->linestep(), format );
+}
+
+QWSOnScreenSurface::~QWSOnScreenSurface()
+{
+}
+
+QPoint QWSOnScreenSurface::painterOffset() const
+{
+    return geometry().topLeft() + QWSWindowSurface::painterOffset();
+}
+
+bool QWSOnScreenSurface::isValid() const
+{
+    const QWidget *win = window();
+    if (screen != getScreen(win))
+        return false;
+    if (img.isNull())
+        return false;
+    return QScreen::isWidgetPaintOnScreen(win);
+}
+
+QByteArray QWSOnScreenSurface::permanentState() const
+{
+    QByteArray array;
+    array.resize(sizeof(int));
+    int *ptr = reinterpret_cast<int*>(array.data());
+    ptr[0] = QApplication::desktop()->screenNumber(window());
+    return array;
+}
+
+void QWSOnScreenSurface::setPermanentState(const QByteArray &data)
+{
+    const int *ptr = reinterpret_cast<const int*>(data.constData());
+    const int screenNo = ptr[0];
+
+    QScreen *screen = qt_screen;
+    if (screenNo > 0)
+        screen = qt_screen->subScreens().at(screenNo);
+    attachToScreen(screen);
+}
+
+#endif // QT_NO_PAINTONSCREEN
+
+#ifndef QT_NO_PAINT_DEBUG
+
+QWSYellowSurface::QWSYellowSurface(bool isClient)
+    : QWSWindowSurface(), delay(10)
+{
+    if (isClient) {
+        setWinId(QWidget::qwsDisplay()->takeId());
+        QWidget::qwsDisplay()->nameRegion(winId(),
+                                          QLatin1String("Debug flush paint"),
+                                          QLatin1String("Silly yellow thing"));
+        QWidget::qwsDisplay()->setAltitude(winId(), 1, true);
+    }
+    setSurfaceFlags(Buffered);
+}
+
+QWSYellowSurface::~QWSYellowSurface()
+{
+}
+
+QByteArray QWSYellowSurface::permanentState() const
+{
+    QByteArray array;
+    array.resize(2 * sizeof(int));
+
+    int *ptr = reinterpret_cast<int*>(array.data());
+    ptr[0] = surfaceSize.width();
+    ptr[1] = surfaceSize.height();
+
+    return array;
+}
+
+void QWSYellowSurface::setPermanentState(const QByteArray &data)
+{
+    const int *ptr = reinterpret_cast<const int*>(data.constData());
+
+    const int width = ptr[0];
+    const int height = ptr[1];
+
+    img = QImage(width, height, QImage::Format_ARGB32);
+    img.fill(qRgba(255,255,31,127));
+}
+
+void QWSYellowSurface::flush(QWidget *widget, const QRegion &region,
+                             const QPoint &offset)
+{
+    Q_UNUSED(offset);
+
+    QWSDisplay *display = QWidget::qwsDisplay();
+    QRegion rgn = region;
+
+    if (widget)
+        rgn.translate(widget->mapToGlobal(QPoint(0, 0)));
+
+    surfaceSize = region.boundingRect().size();
+
+    const int id = winId();
+    display->requestRegion(id, key(), permanentState(), rgn);
+    display->setAltitude(id, 1, true);
+    display->repaintRegion(id, 0, false, rgn);
+
+    ::usleep(500 * delay);
+    display->requestRegion(id, key(), permanentState(), QRegion());
+    ::usleep(500 * delay);
+}
+
+#endif // QT_NO_PAINT_DEBUG
+
+#ifndef QT_NO_DIRECTPAINTER
+
+static inline QScreen *getPrimaryScreen()
+{
+    QScreen *screen = QScreen::instance();
+    if (!screen->base()) {
+        QList<QScreen*> subScreens = screen->subScreens();
+        if (subScreens.size() < 1)
+            return 0;
+        screen = subScreens.at(0);
+    }
+    return screen;
+}
+
+QWSDirectPainterSurface::QWSDirectPainterSurface(bool isClient,
+                                                 QDirectPainter::SurfaceFlag flags)
+    : QWSWindowSurface(), flushingRegionEvents(false), doLocking(false)
+{
+    setSurfaceFlags(Opaque);
+    synchronous = (flags == QDirectPainter::ReservedSynchronous);
+
+    if (isClient) {
+        setWinId(QWidget::qwsDisplay()->takeId());
+        QWidget::qwsDisplay()->nameRegion(winId(),
+                                          QLatin1String("QDirectPainter reserved space"),
+                                          QLatin1String("reserved"));
+    } else {
+        setWinId(0);
+    }
+    _screen = QScreen::instance();
+    if (!_screen->base()) {
+        QList<QScreen*> subScreens = _screen->subScreens();
+        if (subScreens.size() < 1)
+            _screen = 0;
+        else
+            _screen = subScreens.at(0);
+    }
+}
+
+QWSDirectPainterSurface::~QWSDirectPainterSurface()
+{
+    if (winId() && QWSDisplay::instance()) // make sure not in QApplication destructor
+        QWidget::qwsDisplay()->destroyRegion(winId());
+}
+
+void QWSDirectPainterSurface::setRegion(const QRegion &region)
+{
+    const int id = winId();
+    QWidget::qwsDisplay()->requestRegion(id, key(), permanentState(), region);
+#ifndef QT_NO_QWS_MULTIPROCESS
+    if (synchronous)
+        QWSDisplay::instance()->d->waitForRegionAck(id);
+#endif
+}
+
+void QWSDirectPainterSurface::flush(QWidget *, const QRegion &r, const QPoint &)
+{
+    QWSDisplay::instance()->repaintRegion(winId(), 0, true, r);
+}
+
+QByteArray QWSDirectPainterSurface::permanentState() const
+{
+    QByteArray res;
+    if (isRegionReserved())
+        res.append( 'r');
+    return res;
+}
+
+void QWSDirectPainterSurface::setPermanentState(const QByteArray &ba)
+{
+    if (ba.size() > 0 && ba.at(0) == 'r')
+        setReserved();
+    setSurfaceFlags(surfaceFlags() | Opaque);
+}
+
+void QWSDirectPainterSurface::beginPaint(const QRegion &region)
+{
+    QWSWindowSurface::beginPaint(region);
+#ifndef QT_NO_QWS_MULTIPROCESS
+    if (!synchronous) {
+        flushingRegionEvents = true;
+        QWSDisplay::instance()->d->waitForRegionEvents(winId(), doLocking);
+        flushingRegionEvents = false;
+    }
+#endif
+}
+
+bool QWSDirectPainterSurface::hasPendingRegionEvents() const
+{
+#ifndef QT_NO_QWS_MULTIPROCESS
+    if (synchronous)
+        return false;
+
+    return QWSDisplay::instance()->d->hasPendingRegionEvents();
+#else
+    return false;
+#endif
+}
+
+bool QWSDirectPainterSurface::lock(int timeout)
+{
+#ifndef QT_NO_THREAD
+    threadLock.lock();
+#endif
+    Q_UNUSED(timeout);
+    if (doLocking)
+        QWSDisplay::grab(true);
+    return true;
+}
+
+void QWSDirectPainterSurface::unlock()
+{
+    if (doLocking)
+        QWSDisplay::ungrab();
+#ifndef QT_NO_THREAD
+    threadLock.unlock();
+#endif
+}
+
+#endif // QT_NO_DIRECTPAINTER
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qwindowsurface_qws_p.h b/src/gui/painting/qwindowsurface_qws_p.h
new file mode 100644
index 0000000000..fd56c814a3
--- /dev/null
+++ b/src/gui/painting/qwindowsurface_qws_p.h
@@ -0,0 +1,355 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QWINDOWSURFACE_QWS_P_H
+#define QWINDOWSURFACE_QWS_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qwindowsurface_p.h"
+#include <qregion.h>
+#include <qimage.h>
+#include <qdirectpainter_qws.h>
+#include <qmutex.h>
+#include <private/qwssharedmemory_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QScreen;
+class QWSWindowSurfacePrivate;
+
+class Q_GUI_EXPORT QWSWindowSurface : public QWindowSurface
+{
+public:
+    QWSWindowSurface();
+    QWSWindowSurface(QWidget *widget);
+    ~QWSWindowSurface();
+
+    virtual bool isValid() const = 0;
+
+    virtual void setGeometry(const QRect &rect);
+    virtual void setGeometry(const QRect &rect, const QRegion &mask);
+    virtual void flush(QWidget *widget, const QRegion &region,
+                       const QPoint &offset);
+
+    virtual bool move(const QPoint &offset);
+    virtual QRegion move(const QPoint &offset, const QRegion &newClip);
+
+    virtual QPoint painterOffset() const; // remove!!!
+
+    virtual void beginPaint(const QRegion &);
+    virtual void endPaint(const QRegion &);
+
+    virtual bool lock(int timeout = -1);
+    virtual void unlock();
+
+    virtual QString key() const = 0;
+
+    // XXX: not good enough
+    virtual QByteArray transientState() const;
+    virtual QByteArray permanentState() const;
+    virtual void setTransientState(const QByteArray &state);
+    virtual void setPermanentState(const QByteArray &state);
+
+    virtual QImage image() const = 0;
+    virtual QPaintDevice *paintDevice() = 0;
+
+    const QRegion clipRegion() const;
+    void setClipRegion(const QRegion &);
+
+#ifdef QT_QWS_CLIENTBLIT
+    virtual const QRegion directRegion() const;
+    virtual int directRegionId() const;
+    virtual void setDirectRegion(const QRegion &, int);
+#endif
+
+    enum SurfaceFlag {
+        RegionReserved = 0x1,
+        Buffered = 0x2,
+        Opaque = 0x4
+    };
+    Q_DECLARE_FLAGS(SurfaceFlags, SurfaceFlag)
+
+    SurfaceFlags surfaceFlags() const;
+
+    inline bool isRegionReserved() const {
+        return surfaceFlags() & RegionReserved;
+    }
+    inline bool isBuffered() const { return surfaceFlags() & Buffered; }
+    inline bool isOpaque() const { return surfaceFlags() & Opaque; }
+
+    int winId() const;
+    virtual void releaseSurface();
+
+protected:
+    void setSurfaceFlags(SurfaceFlags type);
+    void setWinId(int id);
+
+private:
+    friend class QWidgetPrivate;
+
+    void invalidateBuffer();
+
+    QWSWindowSurfacePrivate *d_ptr;
+};
+
+Q_DECLARE_OPERATORS_FOR_FLAGS(QWSWindowSurface::SurfaceFlags)
+
+class QWSWindowSurfacePrivate
+{
+public:
+    QWSWindowSurfacePrivate();
+
+    void setWinId(int id);
+
+    QWSWindowSurface::SurfaceFlags flags;
+    QRegion clip;
+#ifdef QT_QWS_CLIENTBLIT
+    QRegion direct;
+    int directId;
+#endif
+
+    int winId;
+};
+
+class QWSLock;
+
+class Q_GUI_EXPORT QWSMemorySurface : public QWSWindowSurface
+{
+public:
+    QWSMemorySurface();
+    QWSMemorySurface(QWidget *widget);
+    ~QWSMemorySurface();
+
+    bool isValid() const;
+
+    QPaintDevice *paintDevice() { return &img; }
+    bool scroll(const QRegion &area, int dx, int dy);
+
+    QImage image() const { return img; }
+    QPoint painterOffset() const;
+
+    void beginPaint(const QRegion &rgn);
+
+    bool lock(int timeout = -1);
+    void unlock();
+
+protected:
+    QImage::Format preferredImageFormat(const QWidget *widget) const;
+
+#ifndef QT_NO_QWS_MULTIPROCESS
+    void setLock(int lockId);
+    QWSLock *memlock;
+#endif
+#ifndef QT_NO_THREAD
+    QMutex threadLock;
+#endif
+
+    QImage img;
+};
+
+class Q_GUI_EXPORT QWSLocalMemSurface : public QWSMemorySurface
+{
+public:
+    QWSLocalMemSurface();
+    QWSLocalMemSurface(QWidget *widget);
+    ~QWSLocalMemSurface();
+
+    void setGeometry(const QRect &rect);
+
+    QString key() const { return QLatin1String("mem"); }
+    QByteArray permanentState() const;
+
+    void setPermanentState(const QByteArray &data);
+    virtual void releaseSurface();
+protected:
+    uchar *mem;
+    int memsize;
+};
+
+#ifndef QT_NO_QWS_MULTIPROCESS
+class Q_GUI_EXPORT QWSSharedMemSurface : public QWSMemorySurface
+{
+public:
+    QWSSharedMemSurface();
+    QWSSharedMemSurface(QWidget *widget);
+    ~QWSSharedMemSurface();
+
+    void setGeometry(const QRect &rect);
+
+    QString key() const { return QLatin1String("shm"); }
+    QByteArray permanentState() const;
+
+    void setPermanentState(const QByteArray &data);
+
+#ifdef QT_QWS_CLIENTBLIT
+    virtual void setDirectRegion(const QRegion &, int);
+    virtual const QRegion directRegion() const;
+#endif
+    virtual void releaseSurface();
+
+private:
+    bool setMemory(int memId);
+
+    QWSSharedMemory mem;
+};
+#endif // QT_NO_QWS_MULTIPROCESS
+
+#ifndef QT_NO_PAINTONSCREEN
+class Q_GUI_EXPORT QWSOnScreenSurface : public QWSMemorySurface
+{
+public:
+    QWSOnScreenSurface();
+    QWSOnScreenSurface(QWidget *widget);
+    ~QWSOnScreenSurface();
+
+    bool isValid() const;
+    QPoint painterOffset() const;
+
+    QString key() const { return QLatin1String("OnScreen"); }
+    QByteArray permanentState() const;
+
+    void setPermanentState(const QByteArray &data);
+
+private:
+    void attachToScreen(const QScreen *screen);
+
+    const QScreen *screen;
+};
+#endif // QT_NO_PAINTONSCREEN
+
+#ifndef QT_NO_PAINT_DEBUG
+class Q_GUI_EXPORT QWSYellowSurface : public QWSWindowSurface
+{
+public:
+    QWSYellowSurface(bool isClient = false);
+    ~QWSYellowSurface();
+
+    void setDelay(int msec) { delay = msec; }
+
+    bool isValid() const { return true; }
+
+    void flush(QWidget *widget, const QRegion &region, const QPoint &offset);
+
+    QString key() const { return QLatin1String("Yellow"); }
+    QByteArray permanentState() const;
+
+    void setPermanentState(const QByteArray &data);
+
+    QPaintDevice *paintDevice() { return &img; }
+    QImage image() const { return img; }
+
+private:
+    int delay;
+    QSize surfaceSize; // client side
+    QImage img; // server side
+};
+#endif // QT_NO_PAINT_DEBUG
+
+#ifndef QT_NO_DIRECTPAINTER
+
+class QScreen;
+
+class Q_GUI_EXPORT QWSDirectPainterSurface : public QWSWindowSurface
+{
+public:
+    QWSDirectPainterSurface(bool isClient = false,
+                            QDirectPainter::SurfaceFlag flags = QDirectPainter::NonReserved);
+    ~QWSDirectPainterSurface();
+
+    void setReserved() { setSurfaceFlags(RegionReserved); }
+
+    void setGeometry(const QRect &rect) { setRegion(rect); }
+
+    void setRegion(const QRegion &region);
+    QRegion region() const { return clipRegion(); }
+
+    void flush(QWidget*, const QRegion &, const QPoint &);
+
+    bool isValid() const { return false; }
+
+    QString key() const { return QLatin1String("DirectPainter"); }
+    QByteArray permanentState() const;
+
+    void setPermanentState(const QByteArray &);
+
+    QImage image() const { return QImage(); }
+    QPaintDevice *paintDevice() { return 0; }
+
+    // hw: get rid of this
+    WId windowId() const { return static_cast<WId>(winId()); }
+
+    QScreen *screen() const { return _screen; }
+
+    void beginPaint(const QRegion &);
+    bool lock(int timeout = -1);
+    void unlock();
+
+    void setLocking(bool b) { doLocking = b; }
+
+    bool hasPendingRegionEvents() const;
+
+private:
+    QScreen *_screen;
+#ifndef QT_NO_THREAD
+    QMutex threadLock;
+#endif
+
+    friend void qt_directpainter_region(QDirectPainter*, const QRegion&, int);
+    bool flushingRegionEvents;
+    bool synchronous;
+    bool doLocking;
+};
+
+#endif // QT_NO_DIRECTPAINTER
+
+QT_END_NAMESPACE
+
+#endif // QWINDOWSURFACE_QWS_P_H
diff --git a/src/gui/painting/qwindowsurface_raster.cpp b/src/gui/painting/qwindowsurface_raster.cpp
new file mode 100644
index 0000000000..9860841640
--- /dev/null
+++ b/src/gui/painting/qwindowsurface_raster.cpp
@@ -0,0 +1,487 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <qdebug.h>
+
+#include <qglobal.h> // for Q_WS_WIN define (non-PCH)
+#ifdef Q_WS_WIN
+#include <qlibrary.h>
+#include <qt_windows.h>
+#endif
+
+#include <QtGui/qpaintdevice.h>
+#include <QtGui/qwidget.h>
+
+#include "private/qwindowsurface_raster_p.h"
+#include "private/qnativeimage_p.h"
+#include "private/qwidget_p.h"
+
+#ifdef Q_WS_X11
+#include "private/qpixmap_x11_p.h"
+#include "private/qt_x11_p.h"
+#include "private/qwidget_p.h"
+#include "qx11info_x11.h"
+#endif
+#include "private/qdrawhelper_p.h"
+
+#ifdef Q_WS_MAC
+#include <private/qt_cocoa_helpers_mac_p.h>
+#include <QMainWindow>
+#include <private/qmainwindowlayout_p.h>
+#include <QToolBar>
+#endif
+
+QT_BEGIN_NAMESPACE
+
+class QRasterWindowSurfacePrivate
+{
+public:
+    QNativeImage *image;
+
+#ifdef Q_WS_X11
+    GC gc;
+#ifndef QT_NO_MITSHM
+    uint needsSync : 1;
+#endif
+#ifndef QT_NO_XRENDER
+    uint translucentBackground : 1;
+#endif
+#endif
+    uint inSetGeometry : 1;
+};
+
+QRasterWindowSurface::QRasterWindowSurface(QWidget *window, bool setDefaultSurface)
+    : QWindowSurface(window, setDefaultSurface), d_ptr(new QRasterWindowSurfacePrivate)
+{
+#ifdef Q_WS_X11
+    d_ptr->gc = XCreateGC(X11->display, window->handle(), 0, 0);
+#ifndef QT_NO_XRENDER
+    d_ptr->translucentBackground = X11->use_xrender
+        && window->x11Info().depth() == 32;
+#endif
+#ifndef QT_NO_MITHSM
+    d_ptr->needsSync = false;
+#endif
+#endif
+    d_ptr->image = 0;
+    d_ptr->inSetGeometry = false;
+
+#ifdef QT_MAC_USE_COCOA
+    needsFlush = false;
+    regionToFlush = QRegion();
+#endif // QT_MAC_USE_COCOA
+}
+
+
+QRasterWindowSurface::~QRasterWindowSurface()
+{
+#ifdef Q_WS_X11
+    XFreeGC(X11->display, d_ptr->gc);
+#endif
+    if (d_ptr->image)
+        delete d_ptr->image;
+}
+
+
+QPaintDevice *QRasterWindowSurface::paintDevice()
+{
+    return &d_ptr->image->image;
+}
+
+#if defined(Q_WS_X11) && !defined(QT_NO_MITSHM)
+void QRasterWindowSurface::syncX()
+{
+    // delay writing to the backbuffer until we know for sure X is done reading from it
+    if (d_ptr->needsSync) {
+        XSync(X11->display, false);
+        d_ptr->needsSync = false;
+    }
+}
+#endif
+
+void QRasterWindowSurface::beginPaint(const QRegion &rgn)
+{
+#if defined(Q_WS_X11) && !defined(QT_NO_MITSHM)
+    syncX();
+#endif
+
+#if (defined(Q_WS_X11) && !defined(QT_NO_XRENDER)) || (defined(Q_WS_WIN) && !defined(Q_WS_WINCE))
+    if (!qt_widget_private(window())->isOpaque && window()->testAttribute(Qt::WA_TranslucentBackground)) {
+#if defined(Q_WS_WIN) && !defined(Q_WS_WINCE)
+        if (d_ptr->image->image.format() != QImage::Format_ARGB32_Premultiplied)
+            prepareBuffer(QImage::Format_ARGB32_Premultiplied, window());
+#endif
+        QPainter p(&d_ptr->image->image);
+        p.setCompositionMode(QPainter::CompositionMode_Source);
+        const QVector<QRect> rects = rgn.rects();
+        const QColor blank = Qt::transparent;
+        for (QVector<QRect>::const_iterator it = rects.begin(); it != rects.end(); ++it) {
+            p.fillRect(*it, blank);
+        }
+    }
+#else
+    Q_UNUSED(rgn);
+#endif
+}
+
+void QRasterWindowSurface::flush(QWidget *widget, const QRegion &rgn, const QPoint &offset)
+{
+    Q_D(QRasterWindowSurface);
+
+    // Not ready for painting yet, bail out. This can happen in
+    // QWidget::create_sys()
+    if (!d->image || rgn.rectCount() == 0)
+        return;
+
+#ifdef Q_WS_WIN
+    QRect br = rgn.boundingRect();
+
+#ifndef Q_WS_WINCE
+    if (!qt_widget_private(window())->isOpaque
+        && window()->testAttribute(Qt::WA_TranslucentBackground)
+        && (qt_widget_private(window())->data.window_flags & Qt::FramelessWindowHint))
+    {
+        QRect r = window()->frameGeometry();
+        QPoint frameOffset = qt_widget_private(window())->frameStrut().topLeft();
+        QRect dirtyRect = br.translated(offset + frameOffset);
+
+        SIZE size = {r.width(), r.height()};
+        POINT ptDst = {r.x(), r.y()};
+        POINT ptSrc = {0, 0};
+        BLENDFUNCTION blend = {AC_SRC_OVER, 0, (int)(255.0 * window()->windowOpacity()), Q_AC_SRC_ALPHA};
+        RECT dirty = {dirtyRect.x(), dirtyRect.y(),
+            dirtyRect.x() + dirtyRect.width(), dirtyRect.y() + dirtyRect.height()};
+        Q_UPDATELAYEREDWINDOWINFO info = {sizeof(info), NULL, &ptDst, &size, d->image->hdc, &ptSrc, 0, &blend, Q_ULW_ALPHA, &dirty};
+        ptrUpdateLayeredWindowIndirect(window()->internalWinId(), &info);
+    } else
+#endif
+    {
+        QPoint wOffset = qt_qwidget_data(widget)->wrect.topLeft();
+
+        HDC widget_dc = widget->getDC();
+
+        QRect wbr = br.translated(-wOffset);
+        BitBlt(widget_dc, wbr.x(), wbr.y(), wbr.width(), wbr.height(),
+               d->image->hdc, br.x() + offset.x(), br.y() + offset.y(), SRCCOPY);
+        widget->releaseDC(widget_dc);
+    }
+
+#ifndef QT_NO_DEBUG
+    static bool flush = !qgetenv("QT_FLUSH_WINDOWSURFACE").isEmpty();
+    if (flush) {
+        SelectObject(qt_win_display_dc(), GetStockObject(BLACK_BRUSH));
+        Rectangle(qt_win_display_dc(), 0, 0, d->image->width() + 2, d->image->height() + 2);
+        BitBlt(qt_win_display_dc(), 1, 1, d->image->width(), d->image->height(),
+               d->image->hdc, 0, 0, SRCCOPY);
+    }
+#endif
+
+#endif
+
+#ifdef Q_WS_X11
+    extern void *qt_getClipRects(const QRegion &r, int &num); // in qpaintengine_x11.cpp
+    extern QWidgetData* qt_widget_data(QWidget *);
+    QPoint wOffset = qt_qwidget_data(widget)->wrect.topLeft();
+
+    if (widget->window() != window()) {
+        XFreeGC(X11->display, d_ptr->gc);
+        d_ptr->gc = XCreateGC(X11->display, widget->handle(), 0, 0);
+    }
+
+    QRegion wrgn(rgn);
+    if (!wOffset.isNull())
+        wrgn.translate(-wOffset);
+    QRect wbr = wrgn.boundingRect();
+
+    if (wrgn.rectCount() != 1) {
+        int num;
+        XRectangle *rects = (XRectangle *)qt_getClipRects(wrgn, num);
+        XSetClipRectangles(X11->display, d_ptr->gc, 0, 0, rects, num, YXBanded);
+    }
+
+    QRect br = rgn.boundingRect().translated(offset);
+#ifndef QT_NO_MITSHM
+    if (d_ptr->image->xshmpm) {
+        XCopyArea(X11->display, d_ptr->image->xshmpm, widget->handle(), d_ptr->gc,
+                  br.x(), br.y(), br.width(), br.height(), wbr.x(), wbr.y());
+        d_ptr->needsSync = true;
+    } else if (d_ptr->image->xshmimg) {
+        const QImage &src = d->image->image;
+        br = br.intersected(src.rect());
+        XShmPutImage(X11->display, widget->handle(), d_ptr->gc, d_ptr->image->xshmimg,
+                     br.x(), br.y(), wbr.x(), wbr.y(), br.width(), br.height(), False);
+        d_ptr->needsSync = true;
+    } else
+#endif
+    {
+        const QImage &src = d->image->image;
+        br = br.intersected(src.rect());
+        if (src.format() != QImage::Format_RGB32 || widget->x11Info().depth() < 24) {
+            Q_ASSERT(src.depth() >= 16);
+            const QImage sub_src(src.scanLine(br.y()) + br.x() * (uint(src.depth()) / 8),
+                                 br.width(), br.height(), src.bytesPerLine(), src.format());
+            QX11PixmapData *data = new QX11PixmapData(QPixmapData::PixmapType);
+            data->xinfo = widget->x11Info();
+            data->fromImage(sub_src, Qt::NoOpaqueDetection);
+            QPixmap pm = QPixmap(data);
+            XCopyArea(X11->display, pm.handle(), widget->handle(), d_ptr->gc, 0 , 0 , br.width(), br.height(), wbr.x(), wbr.y());
+        } else {
+            // qpaintengine_x11.cpp
+            extern void qt_x11_drawImage(const QRect &rect, const QPoint &pos, const QImage &image, Drawable hd, GC gc, Display *dpy, Visual *visual, int depth);
+            qt_x11_drawImage(br, wbr.topLeft(), src, widget->handle(), d_ptr->gc, X11->display, (Visual *)widget->x11Info().visual(), widget->x11Info().depth());
+        }
+    }
+
+    if (wrgn.rectCount() != 1)
+        XSetClipMask(X11->display, d_ptr->gc, XNone);
+#endif // FALCON
+
+#ifdef Q_WS_MAC
+
+    Q_UNUSED(offset);
+
+    // This is mainly done for native components like native "open file" dialog.
+    if (widget->testAttribute(Qt::WA_DontShowOnScreen)) {
+        return;
+    }
+
+#ifdef QT_MAC_USE_COCOA
+
+    this->needsFlush = true;
+    this->regionToFlush += rgn;
+
+    // The actual flushing will be processed in [view drawRect:rect]
+    qt_mac_setNeedsDisplay(widget);
+
+#else
+    // Get a context for the widget.
+    CGContextRef context;
+    CGrafPtr port = GetWindowPort(qt_mac_window_for(widget));
+    QDBeginCGContext(port, &context);
+    CGContextRetain(context);
+    CGContextSaveGState(context);
+
+    // Flip context.
+    CGContextTranslateCTM(context, 0, widget->height());
+    CGContextScaleCTM(context, 1, -1);
+
+    // Clip to region.
+    const QVector<QRect> &rects = rgn.rects();
+    for (int i = 0; i < rects.size(); ++i) {
+        const QRect &rect = rects.at(i);
+        CGContextAddRect(context, CGRectMake(rect.x(), rect.y(), rect.width(), rect.height()));
+    }
+    CGContextClip(context);
+
+    QRect r = rgn.boundingRect();
+    const CGRect area = CGRectMake(r.x(), r.y(), r.width(), r.height());
+    CGImageRef image = CGBitmapContextCreateImage(d->image->cg);
+    CGImageRef subImage = CGImageCreateWithImageInRect(image, area);
+
+    qt_mac_drawCGImage(context, &area, subImage);
+
+    CGImageRelease(subImage);
+    CGImageRelease(image);
+
+    QDEndCGContext(port, &context);
+
+    // Restore context.
+    CGContextRestoreGState(context);
+    CGContextRelease(context);
+#endif // QT_MAC_USE_COCOA
+
+#endif // Q_WS_MAC
+
+#ifdef Q_OS_SYMBIAN
+    Q_UNUSED(widget);
+    Q_UNUSED(rgn);
+    Q_UNUSED(offset);
+#endif
+}
+
+void QRasterWindowSurface::setGeometry(const QRect &rect)
+{
+    QWindowSurface::setGeometry(rect);
+    Q_D(QRasterWindowSurface);
+    d->inSetGeometry = true;
+    if (d->image == 0 || d->image->width() < rect.width() || d->image->height() < rect.height()) {
+#if (defined(Q_WS_X11) && !defined(QT_NO_XRENDER)) || (defined(Q_WS_WIN) && !defined(Q_WS_WINCE))
+#ifndef Q_WS_WIN
+        if (d_ptr->translucentBackground)
+#else
+        if (!qt_widget_private(window())->isOpaque)
+#endif
+            prepareBuffer(QImage::Format_ARGB32_Premultiplied, window());
+        else
+#endif
+            prepareBuffer(QNativeImage::systemFormat(), window());
+    }
+    d->inSetGeometry = false;
+
+#if defined(Q_WS_MAC) && defined(QT_MAC_USE_COCOA)
+    QMainWindow* mWindow = qobject_cast<QMainWindow*>(window());
+    if (mWindow) {
+        QMainWindowLayout *mLayout = qobject_cast<QMainWindowLayout*>(mWindow->layout());
+        QList<QToolBar *> toolbarList = mLayout->qtoolbarsInUnifiedToolbarList;
+
+        for (int i = 0; i < toolbarList.size(); ++i) {
+            QToolBar* toolbar = toolbarList.at(i);
+            if (mLayout->toolBarArea(toolbar) == Qt::TopToolBarArea) {
+                QWidget* tbWidget = (QWidget*) toolbar;
+                if (tbWidget->d_func()->unifiedSurface) {
+                    tbWidget->d_func()->unifiedSurface->setGeometry(rect);
+                }
+            }
+        }
+    }
+#endif // Q_WS_MAC && QT_MAC_USE_COCOA
+
+}
+
+// from qwindowsurface.cpp
+extern void qt_scrollRectInImage(QImage &img, const QRect &rect, const QPoint &offset);
+
+bool QRasterWindowSurface::scroll(const QRegion &area, int dx, int dy)
+{
+#ifdef Q_WS_WIN
+    Q_D(QRasterWindowSurface);
+
+    if (!d->image || !d->image->hdc)
+        return false;
+
+    QRect rect = area.boundingRect();
+    BitBlt(d->image->hdc, rect.x()+dx, rect.y()+dy, rect.width(), rect.height(),
+           d->image->hdc, rect.x(), rect.y(), SRCCOPY);
+
+    return true;
+#else
+    Q_D(QRasterWindowSurface);
+
+    if (!d->image || d->image->image.isNull())
+        return false;
+
+#if defined(Q_WS_X11) && !defined(QT_NO_MITSHM)
+    syncX();
+#endif
+
+    const QVector<QRect> rects = area.rects();
+    for (int i = 0; i < rects.size(); ++i)
+        qt_scrollRectInImage(d->image->image, rects.at(i), QPoint(dx, dy));
+
+    return true;
+#endif
+}
+
+QWindowSurface::WindowSurfaceFeatures QRasterWindowSurface::features() const
+{
+    return QWindowSurface::AllFeatures;
+}
+
+void QRasterWindowSurface::prepareBuffer(QImage::Format format, QWidget *widget)
+{
+    Q_D(QRasterWindowSurface);
+
+    int width = window()->width();
+    int height = window()->height();
+    if (d->image) {
+        width = qMax(d->image->width(), width);
+        height = qMax(d->image->height(), height);
+    }
+
+    if (width == 0 || height == 0) {
+        delete d->image;
+        d->image = 0;
+        return;
+    }
+
+    QNativeImage *oldImage = d->image;
+
+    d->image = new QNativeImage(width, height, format, false, widget);
+
+    if (oldImage && d->inSetGeometry && hasStaticContents()) {
+        // Make sure we use the const version of bits() (no detach).
+        const uchar *src = const_cast<const QImage &>(oldImage->image).bits();
+        uchar *dst = d->image->image.bits();
+
+        const int srcBytesPerLine = oldImage->image.bytesPerLine();
+        const int dstBytesPerLine = d->image->image.bytesPerLine();
+        const int bytesPerPixel = oldImage->image.depth() >> 3;
+
+        QRegion staticRegion(staticContents());
+        // Make sure we're inside the boundaries of the old image.
+        staticRegion &= QRect(0, 0, oldImage->image.width(), oldImage->image.height());
+        const QVector<QRect> &rects = staticRegion.rects();
+        const QRect *srcRect = rects.constData();
+
+        // Copy the static content of the old image into the new one.
+        int numRectsLeft = rects.size();
+        do {
+            const int bytesOffset = srcRect->x() * bytesPerPixel;
+            const int dy = srcRect->y();
+
+            // Adjust src and dst to point to the right offset.
+            const uchar *s = src + dy * srcBytesPerLine + bytesOffset;
+            uchar *d = dst + dy * dstBytesPerLine + bytesOffset;
+            const int numBytes = srcRect->width() * bytesPerPixel;
+
+            int numScanLinesLeft = srcRect->height();
+            do {
+                ::memcpy(d, s, numBytes);
+                d += dstBytesPerLine;
+                s += srcBytesPerLine;
+            } while (--numScanLinesLeft);
+
+            ++srcRect;
+        } while (--numRectsLeft);
+    }
+
+    delete oldImage;
+}
+
+#ifdef QT_MAC_USE_COCOA
+CGContextRef QRasterWindowSurface::imageContext()
+{
+    Q_D(QRasterWindowSurface);
+    return d->image->cg;
+}
+#endif // QT_MAC_USE_COCOA
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qwindowsurface_raster_p.h b/src/gui/painting/qwindowsurface_raster_p.h
new file mode 100644
index 0000000000..06abcd3a4a
--- /dev/null
+++ b/src/gui/painting/qwindowsurface_raster_p.h
@@ -0,0 +1,132 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QWINDOWSURFACE_RASTER_P_H
+#define QWINDOWSURFACE_RASTER_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of the QLibrary class.  This header file may change from
+// version to version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <qglobal.h>
+#include "private/qwindowsurface_p.h"
+
+#ifdef QT_MAC_USE_COCOA
+# include <private/qt_cocoa_helpers_mac_p.h>
+#endif // QT_MAC_USE_COCOA
+
+QT_BEGIN_NAMESPACE
+
+#ifdef Q_WS_WIN
+#define Q_WS_EX_LAYERED           0x00080000 // copied from WS_EX_LAYERED in winuser.h
+#define Q_LWA_ALPHA               0x00000002 // copied from LWA_ALPHA in winuser.h
+#define Q_ULW_ALPHA               0x00000002 // copied from ULW_ALPHA in winuser.h
+#define Q_AC_SRC_ALPHA            0x00000001 // copied from AC_SRC_ALPHA in winuser.h
+
+struct Q_UPDATELAYEREDWINDOWINFO {
+    DWORD cbSize;
+    HDC hdcDst;
+    const POINT *pptDst;
+    const SIZE *psize;
+    HDC hdcSrc;
+    const POINT *pptSrc;
+    COLORREF crKey;
+    const BLENDFUNCTION *pblend;
+    DWORD dwFlags;
+    const RECT *prcDirty;
+};
+
+typedef BOOL (WINAPI *PtrUpdateLayeredWindow)(HWND hwnd, HDC hdcDst, const POINT *pptDst,
+             const SIZE *psize, HDC hdcSrc, const POINT *pptSrc, COLORREF crKey,
+             const BLENDFUNCTION *pblend, DWORD dwflags);
+typedef BOOL (WINAPI *PtrUpdateLayeredWindowIndirect)(HWND hwnd, const Q_UPDATELAYEREDWINDOWINFO *pULWInfo);
+extern PtrUpdateLayeredWindow ptrUpdateLayeredWindow;
+extern PtrUpdateLayeredWindowIndirect ptrUpdateLayeredWindowIndirect;
+#endif
+
+class QPaintDevice;
+class QPoint;
+class QRegion;
+class QRegion;
+class QSize;
+class QWidget;
+class QRasterWindowSurfacePrivate;
+class QNativeImage;
+
+class Q_GUI_EXPORT QRasterWindowSurface : public QWindowSurface
+{
+public:
+    QRasterWindowSurface(QWidget *widget, bool setDefaultSurface = true);
+    ~QRasterWindowSurface();
+
+    QPaintDevice *paintDevice();
+    void flush(QWidget *widget, const QRegion &region, const QPoint &offset);
+    void beginPaint(const QRegion &rgn);
+    void setGeometry(const QRect &rect);
+    bool scroll(const QRegion &area, int dx, int dy);
+    WindowSurfaceFeatures features() const;
+
+#ifdef QT_MAC_USE_COCOA
+    CGContextRef imageContext();
+
+    bool needsFlush;
+    QRegion regionToFlush;
+#endif // QT_MAC_USE_COCOA
+
+private:
+#if defined(Q_WS_X11) && !defined(QT_NO_MITSHM)
+    void syncX();
+#endif
+    void prepareBuffer(QImage::Format format, QWidget *widget);
+    Q_DECLARE_PRIVATE(QRasterWindowSurface)
+    QScopedPointer<QRasterWindowSurfacePrivate> d_ptr;
+};
+
+QT_END_NAMESPACE
+
+#endif // QWINDOWSURFACE_RASTER_P_H
diff --git a/src/gui/painting/qwindowsurface_s60.cpp b/src/gui/painting/qwindowsurface_s60.cpp
new file mode 100644
index 0000000000..9fa01edf7d
--- /dev/null
+++ b/src/gui/painting/qwindowsurface_s60.cpp
@@ -0,0 +1,254 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <qglobal.h> // for Q_WS_WIN define (non-PCH)
+
+#include <QtGui/qpaintdevice.h>
+#include <private/qwidget_p.h>
+#include <private/qwindowsurface_s60_p.h>
+#include <private/qpixmap_s60_p.h>
+#include <private/qt_s60_p.h>
+#include <private/qapplication_p.h>
+#include <private/qdrawhelper_p.h>
+
+#ifdef QT_GRAPHICSSYSTEM_RUNTIME
+#include <private/qgraphicssystem_runtime_p.h>
+#endif
+
+QT_BEGIN_NAMESPACE
+
+struct QS60WindowSurfacePrivate
+{
+    QPixmap device;
+    QList<QImage*> bufferImages;
+};
+
+TDisplayMode displayMode(bool opaque)
+{
+    TDisplayMode mode = S60->screenDevice()->DisplayMode();
+    if (opaque) {
+        mode = EColor16MU;
+    } else  {
+        if (QSysInfo::symbianVersion() >= QSysInfo::SV_SF_3)
+            mode = Q_SYMBIAN_ECOLOR16MAP; // Symbian^3 WServ has support for ARGB32_PRE
+        else
+            mode = EColor16MA; // Symbian prior to Symbian^3 sw accelerates EColor16MA
+    }
+    return mode;
+}
+
+bool blitWriteAlpha(QWidgetPrivate *widgetPrivate)
+{
+    QWExtra *extra = widgetPrivate->extraData();
+    return extra ? extra->nativePaintMode == QWExtra::BlitWriteAlpha : false;
+}
+
+QS60WindowSurface::QS60WindowSurface(QWidget* widget)
+    : QWindowSurface(widget), d_ptr(new QS60WindowSurfacePrivate)
+{
+    QWidgetPrivate *widgetPrivate = qt_widget_private(widget);
+    const bool opaque = widgetPrivate->isOpaque && !blitWriteAlpha(widgetPrivate);
+    TDisplayMode mode = displayMode(opaque);
+    // We create empty CFbsBitmap here -> it will be resized in setGeometry
+    CFbsBitmap *bitmap = new CFbsBitmap;	// CBase derived object needs check on new
+    Q_CHECK_PTR(bitmap);
+    qt_symbian_throwIfError( bitmap->Create( TSize(0, 0), mode ) );
+
+    QS60PixmapData *data = new QS60PixmapData(QPixmapData::PixmapType);
+    if (data) {
+        data->fromSymbianBitmap(bitmap, true);
+        d_ptr->device = QPixmap(data);
+    }
+}
+
+QS60WindowSurface::~QS60WindowSurface()
+{
+#if defined(QT_GRAPHICSSYSTEM_RUNTIME) && defined(Q_SYMBIAN_SUPPORTS_SURFACES)
+    if(QApplicationPrivate::runtime_graphics_system) {
+        QRuntimeGraphicsSystem *runtimeGraphicsSystem =
+                static_cast<QRuntimeGraphicsSystem*>(QApplicationPrivate::graphics_system);
+        if(runtimeGraphicsSystem->graphicsSystemName() == QLatin1String("openvg")) {
+
+            // Graphics system has been switched from raster to openvg.
+            // Issue empty redraw to clear the UI surface
+
+            QWidget *w = window();
+            if (w->testAttribute(Qt::WA_WState_Created)) {
+                RWindow *const window = static_cast<RWindow *>(w->winId()->DrawableWindow());
+                window->BeginRedraw();
+                window->EndRedraw();
+            }
+        }
+    }
+#endif
+
+    delete d_ptr;
+}
+
+void QS60WindowSurface::beginPaint(const QRegion &rgn)
+{
+#ifdef Q_SYMBIAN_SUPPORTS_SURFACES
+    S60->wsSession().Finish();
+#endif
+
+    QWidgetPrivate *windowPrivate = qt_widget_private(window());
+    if (!windowPrivate->isOpaque || blitWriteAlpha(windowPrivate)) {
+        QS60PixmapData *pixmapData = static_cast<QS60PixmapData *>(d_ptr->device.data_ptr().data());
+
+        TDisplayMode mode = displayMode(false);
+        if (pixmapData->cfbsBitmap->DisplayMode() != mode)
+            pixmapData->convertToDisplayMode(mode);
+
+        pixmapData->beginDataAccess();
+
+        if (!windowPrivate->isOpaque) {
+            QPainter p(&pixmapData->image);
+            p.setCompositionMode(QPainter::CompositionMode_Source);
+            const QVector<QRect> rects = rgn.rects();
+            const QColor blank = Qt::transparent;
+            for (QVector<QRect>::const_iterator it = rects.begin(); it != rects.end(); ++it) {
+                p.fillRect(*it, blank);
+            }
+        }
+
+        pixmapData->endDataAccess();
+    }
+}
+
+void QS60WindowSurface::endPaint(const QRegion &)
+{
+    qDeleteAll(d_ptr->bufferImages);
+    d_ptr->bufferImages.clear();
+}
+
+QImage* QS60WindowSurface::buffer(const QWidget *widget)
+{
+    if (widget->window() != window())
+        return 0;
+
+    QPaintDevice *pdev = paintDevice();
+    if (!pdev)
+        return 0;
+
+    const QPoint off = offset(widget);
+    QImage *img = &(static_cast<QS60PixmapData *>(d_ptr->device.data_ptr().data())->image);
+
+    QRect rect(off, widget->size());
+    rect &= QRect(QPoint(), img->size());
+
+    if (rect.isEmpty())
+        return 0;
+
+    img = new QImage(img->scanLine(rect.y()) + rect.x() * img->depth() / 8,
+                     rect.width(), rect.height(),
+                     img->bytesPerLine(), img->format());
+    d_ptr->bufferImages.append(img);
+
+    return img;
+}
+
+void QS60WindowSurface::flush(QWidget *widget, const QRegion &region, const QPoint &)
+{
+    QWidget *window = widget->window();
+    Q_ASSERT(window);
+    QTLWExtra *topExtra = window->d_func()->maybeTopData();
+    Q_ASSERT(topExtra);
+    QRect qr = region.boundingRect();
+    if (!topExtra->inExpose) {
+        topExtra->inExpose = true; // Prevent DrawNow() from calling syncBackingStore() again
+        TRect tr = qt_QRect2TRect(qr);
+        widget->winId()->DrawNow(tr);
+        topExtra->inExpose = false;
+    } else {
+        // This handles the case when syncBackingStore updates content outside of the
+        // original drawing rectangle. This might happen if there are pending update()
+        // events at the same time as we get a Draw() from Symbian.
+        QRect drawRect = qt_TRect2QRect(widget->winId()->DrawableWindow()->GetDrawRect());
+        if (!drawRect.contains(qr))
+            widget->winId()->DrawDeferred();
+    }
+}
+
+bool QS60WindowSurface::scroll(const QRegion &area, int dx, int dy)
+{
+    QRect rect = area.boundingRect();
+
+    if (dx == 0 && dy == 0)
+        return false;
+
+    if (d_ptr->device.isNull())
+        return false;
+
+    QS60PixmapData *data = static_cast<QS60PixmapData*>(d_ptr->device.data_ptr().data());
+    data->scroll(dx, dy, rect);
+
+    return true;
+}
+
+QPaintDevice* QS60WindowSurface::paintDevice()
+{
+    return &d_ptr->device;
+}
+
+void QS60WindowSurface::setGeometry(const QRect& rect)
+{
+    if (rect == geometry())
+        return;
+
+    QS60PixmapData *data = static_cast<QS60PixmapData*>(d_ptr->device.data_ptr().data());
+    data->resize(rect.width(), rect.height());
+
+    QWindowSurface::setGeometry(rect);
+}
+
+QWindowSurface::WindowSurfaceFeatures QS60WindowSurface::features() const
+{
+    return QWindowSurface::AllFeatures;
+}
+
+CFbsBitmap* QS60WindowSurface::symbianBitmap() const
+{
+    QS60PixmapData *data = static_cast<QS60PixmapData*>(d_ptr->device.data_ptr().data());
+    return data->cfbsBitmap;
+}
+
+QT_END_NAMESPACE
+
diff --git a/src/gui/painting/qwindowsurface_s60_p.h b/src/gui/painting/qwindowsurface_s60_p.h
new file mode 100644
index 0000000000..25018d86e2
--- /dev/null
+++ b/src/gui/painting/qwindowsurface_s60_p.h
@@ -0,0 +1,93 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QWINDOWSURFACE_S60_P_H
+#define QWINDOWSURFACE_S60_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of other Qt classes.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <qglobal.h>
+#include "private/qwindowsurface_p.h"
+
+class CFbsBitmap;
+
+QT_BEGIN_NAMESPACE
+
+struct QS60WindowSurfacePrivate;
+
+class QS60WindowSurface : public QWindowSurface
+{
+public:
+    QS60WindowSurface(QWidget *widget);
+    ~QS60WindowSurface();
+
+    QPaintDevice *paintDevice();
+    void flush(QWidget *widget, const QRegion &region, const QPoint &offset);
+    bool scroll(const QRegion &area, int dx, int dy);
+
+    void beginPaint(const QRegion &);
+    void endPaint(const QRegion &);
+
+    QImage* buffer(const QWidget *widget);
+
+    void setGeometry(const QRect &rect);
+
+    WindowSurfaceFeatures features() const;
+
+    CFbsBitmap *symbianBitmap() const;
+
+private:
+    QS60WindowSurfacePrivate* d_ptr;
+
+};
+
+QT_END_NAMESPACE
+
+#endif // QWINDOWSURFACE_S60_P_H
diff --git a/src/gui/painting/qwindowsurface_x11.cpp b/src/gui/painting/qwindowsurface_x11.cpp
new file mode 100644
index 0000000000..deb83b452c
--- /dev/null
+++ b/src/gui/painting/qwindowsurface_x11.cpp
@@ -0,0 +1,265 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtGui/QPaintDevice>
+#include <QtGui/QPainter>
+#include <QtGui/QPixmap>
+#include <QtGui/QWidget>
+
+#include "private/qt_x11_p.h"
+#include "private/qpixmap_x11_p.h"
+#include "private/qwidget_p.h"
+#include "qx11info_x11.h"
+#include "qwindowsurface_x11_p.h"
+
+QT_BEGIN_NAMESPACE
+
+extern void *qt_getClipRects(const QRegion &r, int &num); // in qpaintengine_x11.cpp
+
+struct QX11WindowSurfacePrivate
+{
+    QWidget *widget;
+    QPixmap device;
+#ifndef QT_NO_XRENDER
+    bool translucentBackground;
+#endif
+};
+
+QX11WindowSurface::QX11WindowSurface(QWidget *widget)
+    : QWindowSurface(widget), d_ptr(new QX11WindowSurfacePrivate), gc(0)
+{
+    d_ptr->widget = widget;
+#ifndef QT_NO_XRENDER
+    d_ptr->translucentBackground = X11->use_xrender
+        && widget->x11Info().depth() == 32;
+#endif
+}
+
+
+QX11WindowSurface::~QX11WindowSurface()
+{
+    delete d_ptr;
+    if (gc) {
+        XFreeGC(X11->display, gc);
+        gc = 0;
+    }
+}
+
+QPaintDevice *QX11WindowSurface::paintDevice()
+{
+    return &d_ptr->device;
+}
+
+void QX11WindowSurface::beginPaint(const QRegion &rgn)
+{
+#ifndef QT_NO_XRENDER
+    Q_ASSERT(!d_ptr->device.isNull());
+
+    if (d_ptr->translucentBackground) {
+        if (d_ptr->device.depth() != 32)
+            static_cast<QX11PixmapData *>(d_ptr->device.data_ptr().data())->convertToARGB32();
+        ::Picture src = X11->getSolidFill(d_ptr->device.x11Info().screen(), Qt::transparent);
+        ::Picture dst = d_ptr->device.x11PictureHandle();
+        const QVector<QRect> rects = rgn.rects();
+        const int w = d_ptr->device.width();
+        const int h = d_ptr->device.height();
+        for (QVector<QRect>::const_iterator it = rects.begin(); it != rects.end(); ++it)
+            XRenderComposite(X11->display, PictOpSrc, src, 0, dst,
+                             0, 0, w, h, it->x(), it->y(),
+                             it->width(), it->height());
+    }
+#endif
+}
+
+void QX11WindowSurface::flush(QWidget *widget, const QRegion &rgn, const QPoint &offset)
+{
+    if (d_ptr->device.isNull())
+        return;
+
+    QPoint wOffset = qt_qwidget_data(widget)->wrect.topLeft();
+    QRegion wrgn(rgn);
+    QRect br = rgn.boundingRect();
+    if (!wOffset.isNull())
+        wrgn.translate(-wOffset);
+    QRect wbr = wrgn.boundingRect();
+
+    int num;
+    XRectangle *rects = (XRectangle *)qt_getClipRects(wrgn, num);
+    if (num <= 0)
+        return;
+//         qDebug() << "XSetClipRectangles";
+//         for  (int i = 0; i < num; ++i)
+//             qDebug() << ' ' << i << rects[i].x << rects[i].x << rects[i].y << rects[i].width << rects[i].height;
+    if (num != 1)
+        XSetClipRectangles(X11->display, gc, 0, 0, rects, num, YXBanded);
+    XCopyArea(X11->display, d_ptr->device.handle(), widget->handle(), gc,
+              br.x() + offset.x(), br.y() + offset.y(), br.width(), br.height(), wbr.x(), wbr.y());
+    if (num != 1)
+        XSetClipMask(X11->display, gc, XNone);
+}
+
+void QX11WindowSurface::setGeometry(const QRect &rect)
+{
+    QWindowSurface::setGeometry(rect);
+
+    const QSize size = rect.size();
+
+    if (d_ptr->device.size() == size || size.width() <= 0 || size.height() <= 0)
+        return;
+#ifndef QT_NO_XRENDER
+    if (d_ptr->translucentBackground) {
+        QPixmap::x11SetDefaultScreen(d_ptr->widget->x11Info().screen());
+
+        QX11PixmapData *data = new QX11PixmapData(QPixmapData::PixmapType);
+        data->xinfo = d_ptr->widget->x11Info();
+        data->resize(size.width(), size.height());
+        d_ptr->device = QPixmap(data);
+    } else
+#endif
+    {
+        QPixmap::x11SetDefaultScreen(d_ptr->widget->x11Info().screen());
+
+        QX11PixmapData *oldData = static_cast<QX11PixmapData *>(d_ptr->device.pixmapData());
+
+        if (oldData && !(oldData->flags & QX11PixmapData::Uninitialized) && hasStaticContents()) {
+            // Copy the content of the old pixmap into the new one.
+            QX11PixmapData *newData = new QX11PixmapData(QPixmapData::PixmapType);
+            newData->resize(size.width(), size.height());
+            Q_ASSERT(oldData->d == newData->d);
+
+            QRegion staticRegion(staticContents());
+            // Make sure we're inside the boundaries of the old pixmap.
+            staticRegion &= QRect(0, 0, oldData->w, oldData->h);
+            const QRect boundingRect(staticRegion.boundingRect());
+            const int dx = boundingRect.x();
+            const int dy = boundingRect.y();
+
+            int num;
+            XRectangle *rects = (XRectangle *)qt_getClipRects(staticRegion, num);
+            GC tmpGc = XCreateGC(X11->display, oldData->hd, 0, 0);
+            XSetClipRectangles(X11->display, tmpGc, 0, 0, rects, num, YXBanded);
+            XCopyArea(X11->display, oldData->hd, newData->hd, tmpGc,
+                      dx, dy, qMin(boundingRect.width(), size.width()),
+                      qMin(boundingRect.height(), size.height()), dx, dy);
+            XFreeGC(X11->display, tmpGc);
+            newData->flags &= ~QX11PixmapData::Uninitialized;
+
+            d_ptr->device = QPixmap(newData);
+        } else {
+            d_ptr->device = QPixmap(size);
+        }
+    }
+
+    if (gc) {
+        XFreeGC(X11->display, gc);
+        gc = 0;
+    }
+    if (!d_ptr->device.isNull()) {
+        gc = XCreateGC(X11->display, d_ptr->device.handle(), 0, 0);
+        XSetGraphicsExposures(X11->display, gc, False);
+    }
+}
+
+bool QX11WindowSurface::scroll(const QRegion &area, int dx, int dy)
+{
+    QRect rect = area.boundingRect();
+
+    if (d_ptr->device.isNull())
+        return false;
+
+    GC gc = XCreateGC(X11->display, d_ptr->device.handle(), 0, 0);
+    XCopyArea(X11->display, d_ptr->device.handle(), d_ptr->device.handle(), gc,
+              rect.x(), rect.y(), rect.width(), rect.height(),
+              rect.x()+dx, rect.y()+dy);
+    XFreeGC(X11->display, gc);
+
+    return true;
+}
+
+QPixmap QX11WindowSurface::grabWidget(const QWidget *widget,
+                                      const QRect& rect) const
+{
+    if (!widget || d_ptr->device.isNull())
+        return QPixmap();
+
+    QRect srcRect;
+
+    // make sure the rect is inside the widget & clip to widget's rect
+    if (!rect.isEmpty())
+        srcRect = rect & widget->rect();
+    else
+        srcRect = widget->rect();
+
+    if (srcRect.isEmpty())
+        return QPixmap();
+
+    // If it's a child widget we have to translate the coordinates
+    if (widget != window())
+        srcRect.translate(widget->mapTo(window(), QPoint(0, 0)));
+
+    QPixmap::x11SetDefaultScreen(widget->x11Info().screen());
+    QPixmap px(srcRect.width(), srcRect.height());
+
+    GC tmpGc = XCreateGC(X11->display, d_ptr->device.handle(), 0, 0);
+
+    // Copy srcRect from the backing store to the new pixmap
+    XSetGraphicsExposures(X11->display, tmpGc, False);
+    XCopyArea(X11->display, d_ptr->device.handle(), px.handle(), tmpGc,
+              srcRect.x(), srcRect.y(), srcRect.width(), srcRect.height(), 0, 0);
+
+    XFreeGC(X11->display, tmpGc);
+
+    return px;
+}
+
+QWindowSurface::WindowSurfaceFeatures QX11WindowSurface::features() const
+{
+    WindowSurfaceFeatures features = QWindowSurface::PartialUpdates | QWindowSurface::PreservedContents;
+#ifndef QT_NO_XRENDER
+    if (!d_ptr->translucentBackground)
+        features |= QWindowSurface::StaticContents;
+#else
+    features |= QWindowSurface::StaticContents;
+#endif
+    return features;
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qwindowsurface_x11_p.h b/src/gui/painting/qwindowsurface_x11_p.h
new file mode 100644
index 0000000000..df76f986ff
--- /dev/null
+++ b/src/gui/painting/qwindowsurface_x11_p.h
@@ -0,0 +1,92 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QWINDOWSURFACE_X11_P_H
+#define QWINDOWSURFACE_X11_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of other Qt classes.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <qglobal.h>
+#include "private/qwindowsurface_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QPaintDevice;
+class QPoint;
+class QRegion;
+class QRegion;
+class QSize;
+class QWidget;
+struct QX11WindowSurfacePrivate;
+
+class QX11WindowSurface : public QWindowSurface
+{
+public:
+    QX11WindowSurface(QWidget *widget);
+    ~QX11WindowSurface();
+
+    QPaintDevice *paintDevice();
+    void flush(QWidget *widget, const QRegion &region, const QPoint &offset);
+
+    void beginPaint(const QRegion &rgn);
+    void setGeometry(const QRect &rect);
+    bool scroll(const QRegion &area, int dx, int dy);
+    QPixmap grabWidget(const QWidget *widget,
+                       const QRect& rectangle = QRect()) const;
+    WindowSurfaceFeatures features() const;
+
+private:
+    QX11WindowSurfacePrivate *d_ptr;
+    GC gc;
+};
+
+QT_END_NAMESPACE
+
+#endif // QWINDOWSURFACE_X11_P_H
diff --git a/src/gui/painting/qwmatrix.h b/src/gui/painting/qwmatrix.h
new file mode 100644
index 0000000000..c4f4c75405
--- /dev/null
+++ b/src/gui/painting/qwmatrix.h
@@ -0,0 +1,61 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QWMATRIX_H
+#define QWMATRIX_H
+
+#include <QtGui/qmatrix.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+#if defined(QT3_SUPPORT)
+typedef QMatrix QWMatrix;
+#endif
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QWMATRIX_H