Merge branch 'kinetic-declarativeui' of git@scm.dev.nokia.troll.no:qt/kinetic into kinetic-declarativeui

124 files changed, 2217 insertions, 6495 deletions

diff --git a/src/3rdparty/webkit/ChangeLog b/src/3rdparty/webkit/ChangeLog
index ec8242d..76cfc80 100644
--- a/src/3rdparty/webkit/ChangeLog
+++ b/src/3rdparty/webkit/ChangeLog
@@ -1,3 +1,11 @@
+2009-04-24  Simon Hausmann  <simon.hausmann@nokia.com>
+
+        Reviewed by Ariya Hidayat.
+
+        Added support for generating API docs in the Qt build using "make docs"
+
+        * WebKit.pro: Include docs.pri for "make docs" target.
+
 2008-12-19  Marco Barisione  <marco.barisione@collabora.co.uk>
 
         Reviewed by Holger Freyther.
diff --git a/src/3rdparty/webkit/JavaScriptCore/ChangeLog b/src/3rdparty/webkit/JavaScriptCore/ChangeLog
index fe85bb9..3321570 100644
--- a/src/3rdparty/webkit/JavaScriptCore/ChangeLog
+++ b/src/3rdparty/webkit/JavaScriptCore/ChangeLog
@@ -1,3 +1,60 @@
+2009-01-22  Oliver Hunt  <oliver@apple.com>
+
+        Reviewed by Geoff Garen.
+
+        <rdar://problem/6516853> (r39682-r39736) JSFunFuzz: crash on "(function(){({ x2: x }), })()"
+        <https://bugs.webkit.org/show_bug.cgi?id=23479>
+
+        Automatic semicolon insertion was resulting in this being accepted in the initial
+        nodeless parsing, but subsequent reparsing for code generation would fail, leading
+        to a crash.  The solution is to ensure that reparsing a function performs parsing
+        in the same state as the initial parse.  We do this by modifying the saved source
+        ranges to include rather than exclude the opening and closing braces.
+
+        * bytecode/CodeBlock.cpp:
+        (JSC::CodeBlock::reparseForExceptionInfoIfNecessary): add an assertion for successful recompile
+        * parser/Lexer.h:
+        (JSC::Lexer::sourceCode): include rather than exclude braces.
+        * parser/Nodes.h:
+        (JSC::FunctionBodyNode::toSourceString):  No need to append braces anymore.
+
+2009-01-21  Alexey Proskuryakov  <ap@webkit.org>
+
+        Suggested by Oliver Hunt. Reviewed by Oliver Hunt.
+
+        https://bugs.webkit.org/show_bug.cgi?id=23456
+        Function argument names leak
+
+        * parser/Nodes.cpp: (JSC::FunctionBodyNode::~FunctionBodyNode): Destruct parameter names.
+
+2009-01-22  Beth Dakin  <bdakin@apple.com>
+
+        Reviewed by Sam Weinig.
+
+        Fix for https://bugs.webkit.org/show_bug.cgi?id=23461 LayoutTests/
+        fast/js/numeric-conversion.html is broken, and corresponding 
+        <rdar://problem/6514842>
+
+        The basic problem here is that parseInt(Infinity) should be NaN, 
+        but we were returning 0. NaN matches Safari 3.2.1 and Firefox.
+
+        * runtime/JSGlobalObjectFunctions.cpp:
+        (JSC::globalFuncParseInt):
+
+2009-01-13  Beth Dakin  <bdakin@apple.com>
+
+        Reviewed by Darin Adler and Oliver Hunt.
+
+        <rdar://problem/6489314> REGRESSION: Business widget's front side 
+        fails to render correctly when flipping widget
+
+        The problem here is that parseInt was parsing NaN as 0. This patch 
+        corrects that by parsing NaN as NaN. This matches our old behavior 
+        and Firefox. 
+
+        * runtime/JSGlobalObjectFunctions.cpp:
+        (JSC::globalFuncParseInt):
+
 2009-02-13  Adam Treat  <adam.treat@torchmobile.com>
 
         Reviewed by George Staikos.
diff --git a/src/3rdparty/webkit/JavaScriptCore/bytecode/CodeBlock.cpp b/src/3rdparty/webkit/JavaScriptCore/bytecode/CodeBlock.cpp
index 91fb1c0..9207c8a 100644
--- a/src/3rdparty/webkit/JavaScriptCore/bytecode/CodeBlock.cpp
+++ b/src/3rdparty/webkit/JavaScriptCore/bytecode/CodeBlock.cpp
@@ -1397,6 +1397,7 @@ void CodeBlock::reparseForExceptionInfoIfNecessary(CallFrame* callFrame)
         case FunctionCode: {
             FunctionBodyNode* ownerFunctionBodyNode = static_cast<FunctionBodyNode*>(m_ownerNode);
             RefPtr<FunctionBodyNode> newFunctionBody = m_globalData->parser->reparse<FunctionBodyNode>(m_globalData, ownerFunctionBodyNode);
+            ASSERT(newFunctionBody);
             newFunctionBody->finishParsing(ownerFunctionBodyNode->copyParameters(), ownerFunctionBodyNode->parameterCount());
             CodeBlock& newCodeBlock = newFunctionBody->bytecodeForExceptionInfoReparse(scopeChain);
             ASSERT(newCodeBlock.m_exceptionInfo);
diff --git a/src/3rdparty/webkit/JavaScriptCore/parser/Lexer.h b/src/3rdparty/webkit/JavaScriptCore/parser/Lexer.h
index cb553af..afcf09f 100644
--- a/src/3rdparty/webkit/JavaScriptCore/parser/Lexer.h
+++ b/src/3rdparty/webkit/JavaScriptCore/parser/Lexer.h
@@ -88,7 +88,7 @@ namespace JSC {
         bool sawError() const { return m_error; }
 
         void clear();
-        SourceCode sourceCode(int openBrace, int closeBrace, int firstLine) { return SourceCode(m_source->provider(), openBrace + 1, closeBrace, firstLine); }
+        SourceCode sourceCode(int openBrace, int closeBrace, int firstLine) { return SourceCode(m_source->provider(), openBrace, closeBrace + 1, firstLine); }
 
     private:
         friend class JSGlobalData;
diff --git a/src/3rdparty/webkit/JavaScriptCore/parser/Nodes.cpp b/src/3rdparty/webkit/JavaScriptCore/parser/Nodes.cpp
index bdc5d2f..201af28 100644
--- a/src/3rdparty/webkit/JavaScriptCore/parser/Nodes.cpp
+++ b/src/3rdparty/webkit/JavaScriptCore/parser/Nodes.cpp
@@ -2552,6 +2552,8 @@ FunctionBodyNode::FunctionBodyNode(JSGlobalData* globalData, SourceElements* chi
 FunctionBodyNode::~FunctionBodyNode()
 {
     ASSERT(!m_refCount);
+    for (size_t i = 0; i < m_parameterCount; ++i)
+        m_parameters[i].~Identifier();
     fastFree(m_parameters);
 }
 
diff --git a/src/3rdparty/webkit/JavaScriptCore/parser/Nodes.h b/src/3rdparty/webkit/JavaScriptCore/parser/Nodes.h
index f8512f7..20885c3 100644
--- a/src/3rdparty/webkit/JavaScriptCore/parser/Nodes.h
+++ b/src/3rdparty/webkit/JavaScriptCore/parser/Nodes.h
@@ -2205,7 +2205,7 @@ namespace JSC {
         void finishParsing(const SourceCode&, ParameterNode*);
         void finishParsing(Identifier* parameters, size_t parameterCount);
         
-        UString toSourceString() const JSC_FAST_CALL { return UString("{") + source().toString() + UString("}"); }
+        UString toSourceString() const JSC_FAST_CALL { return source().toString(); }
 
         // These objects are ref/deref'd a lot in the scope chain, so this is a faster ref/deref.
         // If the virtual machine changes so this doesn't happen as much we can change back.
diff --git a/src/3rdparty/webkit/JavaScriptCore/runtime/JSGlobalObjectFunctions.cpp b/src/3rdparty/webkit/JavaScriptCore/runtime/JSGlobalObjectFunctions.cpp
index f12d2f3..ecdddcf 100644
--- a/src/3rdparty/webkit/JavaScriptCore/runtime/JSGlobalObjectFunctions.cpp
+++ b/src/3rdparty/webkit/JavaScriptCore/runtime/JSGlobalObjectFunctions.cpp
@@ -302,9 +302,11 @@ JSValuePtr globalFuncParseInt(ExecState* exec, JSObject*, JSValuePtr, const ArgL
         if (JSImmediate::isImmediate(value))
             return value;
         double d = value->uncheckedGetNumber();
-        if (!isfinite(d))
-            return JSImmediate::zeroImmediate();
-        return jsNumber(exec, floor(d));
+        if (isfinite(d))
+            return jsNumber(exec, floor(d));
+        if (isnan(d) || isinf(d))
+            return jsNaN(&exec->globalData());
+        return JSImmediate::zeroImmediate();
     }
 
     return jsNumber(exec, parseInt(value->toString(exec), radix));
diff --git a/src/3rdparty/webkit/VERSION b/src/3rdparty/webkit/VERSION
index bfaefa2..26ce489 100644
--- a/src/3rdparty/webkit/VERSION
+++ b/src/3rdparty/webkit/VERSION
@@ -8,4 +8,4 @@ The commit imported was from the
 
 and has the sha1 checksum
 
-        450331808bfe11b1472c213a8cb311190355c2de
+        a6ebe3865025e2bb4d767a79435af4daf5a9b4db
diff --git a/src/3rdparty/webkit/WebCore/ChangeLog b/src/3rdparty/webkit/WebCore/ChangeLog
index 9be6e72..00bd427 100644
--- a/src/3rdparty/webkit/WebCore/ChangeLog
+++ b/src/3rdparty/webkit/WebCore/ChangeLog
@@ -1,3 +1,111 @@
+2009-03-13  Adam Bergkvist <adam.bergkvist@ericsson.com>
+
+        Reviewed by Alexey Proskuryakov.
+
+        https://bugs.webkit.org/show_bug.cgi?id=24349
+        [QT] HTTP status text is never set
+
+        Set HTTP status text to the reason phrase attribute of QNetworkReply.
+
+        * platform/network/qt/QNetworkReplyHandler.cpp:
+        (WebCore::QNetworkReplyHandler::sendResponseIfNeeded):
+
+2009-03-02  Dirk Schulze  <krit@webkit.org>
+
+        Reviewed by Holger Freyther.
+
+        Added putImageData to Qt. Discussed with Ariya Hidayat.
+
+        [Qt] lacks putImageData support in Canvas
+        https://bugs.webkit.org/show_bug.cgi?id=22186
+
+        * platform/graphics/qt/ImageBufferQt.cpp:
+        (WebCore::ImageBuffer::putImageData):
+
+2009-03-01  Larry Ewing  <lewing@novell.com>
+
+        Reviewed by Alexey Proskuryakov.
+
+        https://bugs.webkit.org/show_bug.cgi?id=24080
+        NPN_GetValue casting to the wrong type and writing outside bounds
+
+        Make sure to cast the value to the correct type so that only
+        memory owned by the value is written to.
+
+        * plugins/gtk/PluginViewGtk.cpp (PluginView::getValueStatic): 
+        * plugins/qt/PluginViewQt.cpp (PluginView::getValueStatic):
+        * plugins/mac/PluginViewMac.cpp (PluginView::getValueStatic): 
+        (PluginView::getValue):
+
+2009-02-27  Adam Treat  <adam.treat@torchmobile.com>
+
+        Reviewed by Eric Seidel.
+
+        https://bugs.webkit.org/show_bug.cgi?id=24229
+        If an image has no alpha channel there is no reason to use SourceOver.
+
+        * platform/graphics/qt/ImageQt.cpp:
+        (WebCore::Image::drawPattern):
+        (WebCore::BitmapImage::draw):
+
+2009-02-27  Zack Rusin  <zack@kde.org>
+
+        Reviewed by Nikolas Zimmermann.
+
+        Qt: be more reasonable about scrolled lines
+
+        cMouseWheelPixelsPerLineStep is currently a constant set to 13.3. it doesn't
+        match our metrics meaning that Qt scrolls by ~2 lines by default which is quite
+        irritating. so lets scroll vertically by the Qt set number of lines * Qt default
+        single step scroll
+
+        * platform/qt/WheelEventQt.cpp:
+
+2009-02-25  Dirk Schulze  <krit@webkit.org>
+
+        Reviewed by Oliver Hunt.
+
+        Ported arcTo to Qt. Qt has no native support for arcTo. This changes
+        calculate the behavior of arcTo and draws it with lineTo and arc.
+
+        [QT] implement Canvas arcTo
+        https://bugs.webkit.org/show_bug.cgi?id=23873
+
+        * platform/graphics/qt/PathQt.cpp:
+        (WebCore::Path::addArcTo):
+
+2009-03-12  Adam Treat  <adam.treat@torchmobile.com>
+
+        Reviewed by Oliver Hunt.
+
+        https://bugs.webkit.org/show_bug.cgi?id=24498
+        Fix the Qt port to use the same algorithm for drawing dashed and dotted
+        borders as the other ports.  This makes the Qt port pixel-for-pixel perfect
+        compared to border drawing with Apple's canonical mac port and much closer
+        to konqueror and firefox behavior.
+
+        * platform/graphics/qt/GraphicsContextQt.cpp:
+        (WebCore::GraphicsContext::drawLine):
+
+2009-03-09  Adam Treat  <adam.treat@torchmobile.com>
+
+        Reviewed by George Staikos.
+
+        https://bugs.webkit.org/show_bug.cgi?id=24463
+        WebCore::qstring is detaching and copying twice for every single
+        WebCore::TextRun that is processed and drawn.  This elevates this method
+        to one of the top-ten most expensive methods in all of QtWebKit according
+        to profiling.  This changes the method so that QString only detaches
+        when absolutely necessary.
+
+        * platform/graphics/qt/FontQt.cpp:
+        (WebCore::qstring):
+        (WebCore::fixSpacing):
+        (WebCore::Font::drawComplexText):
+        (WebCore::Font::floatWidthForComplexText):
+        (WebCore::Font::offsetForPositionForComplexText):
+        (WebCore::Font::selectionRectForComplexText):
+
 2009-02-04  Simon Hausmann  <simon.hausmann@nokia.com>
 
         Unreviewed Qt build fix.
diff --git a/src/3rdparty/webkit/WebCore/platform/graphics/qt/FontQt.cpp b/src/3rdparty/webkit/WebCore/platform/graphics/qt/FontQt.cpp
index deeea99..4e78083 100644
--- a/src/3rdparty/webkit/WebCore/platform/graphics/qt/FontQt.cpp
+++ b/src/3rdparty/webkit/WebCore/platform/graphics/qt/FontQt.cpp
@@ -37,20 +37,27 @@
 #if QT_VERSION >= 0x040400
 namespace WebCore {
 
-static QString qstring(const TextRun& run)
+static const QString qstring(const TextRun& run)
 {
-    QString string((QChar *)run.characters(), run.length());
-    QChar *uc = string.data();
+    //We don't detach
+    return QString::fromRawData((const QChar *)run.characters(), run.length());
+}
+
+static const QString fixSpacing(const QString &string)
+{
+    //Only detach if we're actually changing something
+    QString possiblyDetached = string;
     for (int i = 0; i < string.length(); ++i) {
-        if (Font::treatAsSpace(uc[i].unicode()))
-            uc[i] = 0x20;
-        else if (Font::treatAsZeroWidthSpace(uc[i].unicode()))
-            uc[i] = 0x200c;
+        const QChar c = string.at(i);
+        if (c.unicode() != 0x20 && Font::treatAsSpace(c.unicode())) {
+            possiblyDetached[i] = 0x20; //detach
+        } else if (c.unicode() != 0x200c && Font::treatAsZeroWidthSpace(c.unicode())) {
+            possiblyDetached[i] = 0x200c; //detach
+        }
     }
-    return string;
+    return possiblyDetached;
 }
 
-
 static QTextLine setupLayout(QTextLayout* layout, const TextRun& style)
 {
     int flags = style.rtl() ? Qt::TextForceRightToLeft : Qt::TextForceLeftToRight;
@@ -75,7 +82,7 @@ void Font::drawComplexText(GraphicsContext* ctx, const TextRun& run, const Float
     Color color = ctx->fillColor();
     p->setPen(QColor(color));
 
-    QString string = qstring(run);
+    const QString string = fixSpacing(qstring(run));
 
     // text shadow
     IntSize shadowSize;
@@ -144,7 +151,7 @@ float Font::floatWidthForComplexText(const TextRun& run) const
 {
     if (!run.length())
         return 0;
-    QString string = qstring(run);
+    const QString string = fixSpacing(qstring(run));
     QTextLayout layout(string, font());
     QTextLine line = setupLayout(&layout, run);
     int w = int(line.naturalTextWidth());
@@ -157,7 +164,7 @@ float Font::floatWidthForComplexText(const TextRun& run) const
 
 int Font::offsetForPositionForComplexText(const TextRun& run, int position, bool includePartialGlyphs) const
 {
-    QString string = qstring(run);
+    const QString string = fixSpacing(qstring(run));
     QTextLayout layout(string, font());
     QTextLine line = setupLayout(&layout, run);
     return line.xToCursor(position);
@@ -165,7 +172,7 @@ int Font::offsetForPositionForComplexText(const TextRun& run, int position, bool
 
 FloatRect Font::selectionRectForComplexText(const TextRun& run, const IntPoint& pt, int h, int from, int to) const
 {
-    QString string = qstring(run);
+    const QString string = fixSpacing(qstring(run));
     QTextLayout layout(string, font());
     QTextLine line = setupLayout(&layout, run);
 
diff --git a/src/3rdparty/webkit/WebCore/platform/graphics/qt/GraphicsContextQt.cpp b/src/3rdparty/webkit/WebCore/platform/graphics/qt/GraphicsContextQt.cpp
index 936c1ea..6c90ea3 100644
--- a/src/3rdparty/webkit/WebCore/platform/graphics/qt/GraphicsContextQt.cpp
+++ b/src/3rdparty/webkit/WebCore/platform/graphics/qt/GraphicsContextQt.cpp
@@ -470,13 +470,21 @@ void GraphicsContext::drawLine(const IntPoint& point1, const IntPoint& point2)
     if (paintingDisabled())
         return;
 
+    StrokeStyle style = strokeStyle();
+    Color color = strokeColor();
+    if (style == NoStroke || !color.alpha())
+        return;
+
+    float width = strokeThickness();
+
     FloatPoint p1 = point1;
     FloatPoint p2 = point2;
+    bool isVerticalLine = (p1.x() == p2.x());
 
     QPainter *p = m_data->p();
     const bool antiAlias = p->testRenderHint(QPainter::Antialiasing);
     p->setRenderHint(QPainter::Antialiasing, m_data->antiAliasingForRectsAndLines);
-    adjustLineToPixelBoundaries(p1, p2, strokeThickness(), strokeStyle());
+    adjustLineToPixelBoundaries(p1, p2, width, style);
 
     IntSize shadowSize;
     int shadowBlur;
@@ -489,8 +497,76 @@ void GraphicsContext::drawLine(const IntPoint& point1, const IntPoint& point2)
         p->restore();
     }
 
+    int patWidth = 0;
+    switch (style) {
+        case NoStroke:
+        case SolidStroke:
+            break;
+        case DottedStroke:
+            patWidth = (int)width;
+            break;
+        case DashedStroke:
+            patWidth = 3 * (int)width;
+            break;
+    }
+
+    if (patWidth) {
+        p->save();
+
+        // Do a rect fill of our endpoints.  This ensures we always have the
+        // appearance of being a border.  We then draw the actual dotted/dashed line.
+        if (isVerticalLine) {
+            p->fillRect(FloatRect(p1.x() - width / 2, p1.y() - width, width, width), color);
+            p->fillRect(FloatRect(p2.x() - width / 2, p2.y(), width, width), color);
+        } else {
+            p->fillRect(FloatRect(p1.x() - width, p1.y() - width / 2, width, width), color);
+            p->fillRect(FloatRect(p2.x(), p2.y() - width / 2, width, width), color);
+        }
+
+        // Example: 80 pixels with a width of 30 pixels.
+        // Remainder is 20.  The maximum pixels of line we could paint
+        // will be 50 pixels.
+        int distance = (isVerticalLine ? (point2.y() - point1.y()) : (point2.x() - point1.x())) - 2*(int)width;
+        int remainder = distance % patWidth;
+        int coverage = distance - remainder;
+        int numSegments = coverage / patWidth;
+
+        float patternOffset = 0.0f;
+        // Special case 1px dotted borders for speed.
+        if (patWidth == 1)
+            patternOffset = 1.0f;
+        else {
+            bool evenNumberOfSegments = numSegments % 2 == 0;
+            if (remainder)
+                evenNumberOfSegments = !evenNumberOfSegments;
+            if (evenNumberOfSegments) {
+                if (remainder) {
+                    patternOffset += patWidth - remainder;
+                    patternOffset += remainder / 2;
+                } else
+                    patternOffset = patWidth / 2;
+            } else {
+                if (remainder)
+                    patternOffset = (patWidth - remainder)/2;
+            }
+        }
+
+        QVector<qreal> dashes;
+        dashes << qreal(patWidth) / width << qreal(patWidth) / width;
+
+        QPen pen = p->pen();
+        pen.setWidthF(width);
+        pen.setCapStyle(Qt::FlatCap);
+        pen.setDashPattern(dashes);
+        pen.setDashOffset(patternOffset / width);
+        p->setPen(pen);
+    }
+
     p->drawLine(p1, p2);
 
+    if (patWidth)
+        p->restore();
+
     p->setRenderHint(QPainter::Antialiasing, antiAlias);
 }
 
diff --git a/src/3rdparty/webkit/WebCore/platform/graphics/qt/ImageBufferQt.cpp b/src/3rdparty/webkit/WebCore/platform/graphics/qt/ImageBufferQt.cpp
index d1009b5..29a02d4 100644
--- a/src/3rdparty/webkit/WebCore/platform/graphics/qt/ImageBufferQt.cpp
+++ b/src/3rdparty/webkit/WebCore/platform/graphics/qt/ImageBufferQt.cpp
@@ -1,6 +1,7 @@
 /*
  * Copyright (C) 2006 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2008 Holger Hans Peter Freyther
+ * Copyright (C) 2009 Dirk Schulze <krit@webkit.org>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -31,7 +32,6 @@
 #include "GraphicsContext.h"
 #include "ImageData.h"
 #include "MIMETypeRegistry.h"
-#include "NotImplemented.h"
 #include "StillImageQt.h"
 
 #include <QBuffer>
@@ -111,9 +111,7 @@ PassRefPtr<ImageData> ImageBuffer::getImageData(const IntRect& rect) const
         endy = m_size.height();
     int numRows = endy - originy;
 
-    QImage image = m_data.m_pixmap.toImage();
-    if (image.format() != QImage::Format_ARGB32)
-        image = image.convertToFormat(QImage::Format_ARGB32);
+    QImage image = m_data.m_pixmap.toImage().convertToFormat(QImage::Format_ARGB32);
     ASSERT(!image.isNull());
 
     unsigned destBytesPerRow = 4 * rect.width();
@@ -134,9 +132,58 @@ PassRefPtr<ImageData> ImageBuffer::getImageData(const IntRect& rect) const
     return result;
 }
 
-void ImageBuffer::putImageData(ImageData*, const IntRect&, const IntPoint&)
+void ImageBuffer::putImageData(ImageData* source, const IntRect& sourceRect, const IntPoint& destPoint)
 {
-    notImplemented();
+    ASSERT(sourceRect.width() > 0);
+    ASSERT(sourceRect.height() > 0);
+
+    int originx = sourceRect.x();
+    int destx = destPoint.x() + sourceRect.x();
+    ASSERT(destx >= 0);
+    ASSERT(destx < m_size.width());
+    ASSERT(originx >= 0);
+    ASSERT(originx <= sourceRect.right());
+
+    int endx = destPoint.x() + sourceRect.right();
+    ASSERT(endx <= m_size.width());
+
+    int numColumns = endx - destx;
+
+    int originy = sourceRect.y();
+    int desty = destPoint.y() + sourceRect.y();
+    ASSERT(desty >= 0);
+    ASSERT(desty < m_size.height());
+    ASSERT(originy >= 0);
+    ASSERT(originy <= sourceRect.bottom());
+
+    int endy = destPoint.y() + sourceRect.bottom();
+    ASSERT(endy <= m_size.height());
+    int numRows = endy - desty;
+
+    unsigned srcBytesPerRow = 4 * source->width();
+
+    bool isPainting = m_data.m_painter->isActive();
+    if (isPainting)
+        m_data.m_painter->end();
+
+    QImage image = m_data.m_pixmap.toImage().convertToFormat(QImage::Format_ARGB32);
+    ASSERT(!image.isNull());
+
+    unsigned char* srcRows = source->data()->data() + originy * srcBytesPerRow + originx * 4;
+    for (int y = 0; y < numRows; ++y) {
+        quint32* scanLine = reinterpret_cast<quint32*>(image.scanLine(y + desty));
+        for (int x = 0; x < numColumns; x++) {
+            int basex = x * 4;
+            scanLine[x + destx] = reinterpret_cast<quint32*>(srcRows + basex)[0];
+        }
+
+        srcRows += srcBytesPerRow;
+    }
+
+    m_data.m_pixmap = QPixmap::fromImage(image);
+
+    if (isPainting)
+        m_data.m_painter->begin(&m_data.m_pixmap);
 }
 
 // We get a mimeType here but QImageWriter does not support mimetypes but
diff --git a/src/3rdparty/webkit/WebCore/platform/graphics/qt/ImageQt.cpp b/src/3rdparty/webkit/WebCore/platform/graphics/qt/ImageQt.cpp
index be7d1e0..e266c07 100644
--- a/src/3rdparty/webkit/WebCore/platform/graphics/qt/ImageQt.cpp
+++ b/src/3rdparty/webkit/WebCore/platform/graphics/qt/ImageQt.cpp
@@ -109,6 +109,8 @@ void Image::drawPattern(GraphicsContext* ctxt, const FloatRect& tileRect, const
     ctxt->save();
     ctxt->setCompositeOperation(op);
     QPainter* p = ctxt->platformContext();
+    if (!pixmap.hasAlpha() && p->compositionMode() == QPainter::CompositionMode_SourceOver)
+        p->setCompositionMode(QPainter::CompositionMode_Source);
     p->setBrushOrigin(phase);
     p->fillRect(destRect, b);
     ctxt->restore();
@@ -146,6 +148,9 @@ void BitmapImage::draw(GraphicsContext* ctxt, const FloatRect& dst,
 
     QPainter* painter(ctxt->platformContext());
 
+    if (!image->hasAlpha() && painter->compositionMode() == QPainter::CompositionMode_SourceOver)
+        painter->setCompositionMode(QPainter::CompositionMode_Source);
+
     // Test using example site at
     // http://www.meyerweb.com/eric/css/edge/complexspiral/demo.html    
     painter->drawPixmap(dst, *image, src);
diff --git a/src/3rdparty/webkit/WebCore/platform/graphics/qt/PathQt.cpp b/src/3rdparty/webkit/WebCore/platform/graphics/qt/PathQt.cpp
index 90b342e..e68be2b 100644
--- a/src/3rdparty/webkit/WebCore/platform/graphics/qt/PathQt.cpp
+++ b/src/3rdparty/webkit/WebCore/platform/graphics/qt/PathQt.cpp
@@ -1,6 +1,7 @@
 /*
- * Copyright (C) 2006 Zack Rusin <zack@kde.org>
- *               2006 Rob Buis   <buis@kde.org>
+ * Copyright (C) 2006 Zack Rusin   <zack@kde.org>
+ *               2006 Rob Buis     <buis@kde.org>
+ *               2009 Dirk Schulze <krit@webkit.org>
  *
  * All rights reserved.
  *
@@ -139,9 +140,72 @@ void Path::addBezierCurveTo(const FloatPoint& cp1, const FloatPoint& cp2, const
 
 void Path::addArcTo(const FloatPoint& p1, const FloatPoint& p2, float radius)
 {
-    //FIXME: busted
-    qWarning("arcTo is busted");
-    m_path->arcTo(p1.x(), p1.y(), p2.x(), p2.y(), radius, 90);
+    FloatPoint p0(m_path->currentPosition());
+
+    if ((p1.x() == p0.x() && p1.y() == p0.y()) || (p1.x() == p2.x() && p1.y() == p2.y()) || radius == 0.f) {
+        m_path->lineTo(p1);
+        return;
+    }
+
+    FloatPoint p1p0((p0.x() - p1.x()),(p0.y() - p1.y()));
+    FloatPoint p1p2((p2.x() - p1.x()),(p2.y() - p1.y()));
+    float p1p0_length = sqrtf(p1p0.x() * p1p0.x() + p1p0.y() * p1p0.y());
+    float p1p2_length = sqrtf(p1p2.x() * p1p2.x() + p1p2.y() * p1p2.y());
+
+    double cos_phi = (p1p0.x() * p1p2.x() + p1p0.y() * p1p2.y()) / (p1p0_length * p1p2_length);
+    // all points on a line logic
+    if (cos_phi == -1) {
+        m_path->lineTo(p1);
+        return;
+    }
+    if (cos_phi == 1) {
+        // add infinite far away point
+        unsigned int max_length = 65535;
+        double factor_max = max_length / p1p0_length;
+        FloatPoint ep((p0.x() + factor_max * p1p0.x()), (p0.y() + factor_max * p1p0.y()));
+        m_path->lineTo(ep);
+        return;
+    }
+
+    float tangent = radius / tan(acos(cos_phi) / 2);
+    float factor_p1p0 = tangent / p1p0_length;
+    FloatPoint t_p1p0((p1.x() + factor_p1p0 * p1p0.x()), (p1.y() + factor_p1p0 * p1p0.y()));
+
+    FloatPoint orth_p1p0(p1p0.y(), -p1p0.x());
+    float orth_p1p0_length = sqrt(orth_p1p0.x() * orth_p1p0.x() + orth_p1p0.y() * orth_p1p0.y());
+    float factor_ra = radius / orth_p1p0_length;
+
+    // angle between orth_p1p0 and p1p2 to get the right vector orthographic to p1p0
+    double cos_alpha = (orth_p1p0.x() * p1p2.x() + orth_p1p0.y() * p1p2.y()) / (orth_p1p0_length * p1p2_length);
+    if (cos_alpha < 0.f)
+        orth_p1p0 = FloatPoint(-orth_p1p0.x(), -orth_p1p0.y());
+
+    FloatPoint p((t_p1p0.x() + factor_ra * orth_p1p0.x()), (t_p1p0.y() + factor_ra * orth_p1p0.y()));
+
+    // calculate angles for addArc
+    orth_p1p0 = FloatPoint(-orth_p1p0.x(), -orth_p1p0.y());
+    float sa = acos(orth_p1p0.x() / orth_p1p0_length);
+    if (orth_p1p0.y() < 0.f)
+        sa = 2 * piDouble - sa;
+
+    // anticlockwise logic
+    bool anticlockwise = false;
+
+    float factor_p1p2 = tangent / p1p2_length;
+    FloatPoint t_p1p2((p1.x() + factor_p1p2 * p1p2.x()), (p1.y() + factor_p1p2 * p1p2.y()));
+    FloatPoint orth_p1p2((t_p1p2.x() - p.x()),(t_p1p2.y() - p.y()));
+    float orth_p1p2_length = sqrtf(orth_p1p2.x() * orth_p1p2.x() + orth_p1p2.y() * orth_p1p2.y());
+    float ea = acos(orth_p1p2.x() / orth_p1p2_length);
+    if (orth_p1p2.y() < 0)
+        ea = 2 * piDouble - ea;
+    if ((sa > ea) && ((sa - ea) < piDouble))
+        anticlockwise = true;
+    if ((sa < ea) && ((ea - sa) > piDouble))
+        anticlockwise = true;
+
+    m_path->lineTo(t_p1p0);
+
+    addArc(p, radius, sa, ea, anticlockwise);
 }
 
 void Path::closeSubpath()
diff --git a/src/3rdparty/webkit/WebCore/platform/network/qt/QNetworkReplyHandler.cpp b/src/3rdparty/webkit/WebCore/platform/network/qt/QNetworkReplyHandler.cpp
index 2de2125..2c730a6 100644
--- a/src/3rdparty/webkit/WebCore/platform/network/qt/QNetworkReplyHandler.cpp
+++ b/src/3rdparty/webkit/WebCore/platform/network/qt/QNetworkReplyHandler.cpp
@@ -269,8 +269,10 @@ void QNetworkReplyHandler::sendResponseIfNeeded()
 
     const bool isLocalFileReply = (m_reply->url().scheme() == QLatin1String("file"));
     int statusCode = m_reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
-    if (!isLocalFileReply)
+    if (!isLocalFileReply) {
         response.setHTTPStatusCode(statusCode);
+        response.setHTTPStatusText(m_reply->attribute(QNetworkRequest::HttpReasonPhraseAttribute).toByteArray().constData());
+    }
     else if (m_reply->error() == QNetworkReply::ContentNotFoundError)
         response.setHTTPStatusCode(404);
 
diff --git a/src/3rdparty/webkit/WebCore/platform/qt/WheelEventQt.cpp b/src/3rdparty/webkit/WebCore/platform/qt/WheelEventQt.cpp
index cc8acd2..b25ae7a 100644
--- a/src/3rdparty/webkit/WebCore/platform/qt/WheelEventQt.cpp
+++ b/src/3rdparty/webkit/WebCore/platform/qt/WheelEventQt.cpp
@@ -21,7 +21,9 @@
 #include "PlatformWheelEvent.h"
 
 #include "PlatformMouseEvent.h"
+#include "Scrollbar.h"
 
+#include <qapplication.h>
 #include <QWheelEvent>
 
 namespace WebCore {
@@ -54,9 +56,14 @@ PlatformWheelEvent::PlatformWheelEvent(QWheelEvent* e)
         m_deltaY = (e->delta() / 120);
     }
 
-    // FIXME: retrieve the user setting for the number of lines to scroll on each wheel event
-    m_deltaX *= horizontalLineMultiplier();
-    m_deltaY *= verticalLineMultiplier();
+    m_deltaX *= QApplication::wheelScrollLines();
+    // use the same single scroll step as QTextEdit (in
+    // QTextEditPrivate::init [h,v]bar->setSingleStep )
+    // and divide by the default WebKit scroll step to
+    // get the Qt mouse wheel scroll behavior
+    static const float cDefaultQtScrollStep = 20.f;
+    m_deltaY *= QApplication::wheelScrollLines() *
+                (cDefaultQtScrollStep / cMouseWheelPixelsPerLineStep);
 }
 #endif // QT_NO_WHEELEVENT
 
diff --git a/src/3rdparty/webkit/WebCore/plugins/mac/PluginViewMac.cpp b/src/3rdparty/webkit/WebCore/plugins/mac/PluginViewMac.cpp
index 1d7d570..3229922 100644
--- a/src/3rdparty/webkit/WebCore/plugins/mac/PluginViewMac.cpp
+++ b/src/3rdparty/webkit/WebCore/plugins/mac/PluginViewMac.cpp
@@ -220,11 +220,11 @@ NPError PluginView::getValueStatic(NPNVariable variable, void* value)
 
     switch (variable) {
     case NPNVToolkit:
-        *((uint32 *)value) = 0;
+        *static_cast<uint32*>(value) = 0;
         return NPERR_NO_ERROR;
 
     case NPNVjavascriptEnabledBool:
-        *((uint32 *)value) = true;
+        *static_cast<NPBool*>(value) = true;
         return NPERR_NO_ERROR;
 
     default:
@@ -275,7 +275,7 @@ NPError PluginView::getValue(NPNVariable variable, void* value)
     }
 
     case NPNVsupportsCoreGraphicsBool:
-        *((uint32 *)value) = true;
+        *static_cast<NPBool*>(value) = true;
         return NPERR_NO_ERROR;
 
     default:
diff --git a/src/3rdparty/webkit/WebCore/plugins/qt/PluginViewQt.cpp b/src/3rdparty/webkit/WebCore/plugins/qt/PluginViewQt.cpp
index 5aa8933..c8dd0e5 100644
--- a/src/3rdparty/webkit/WebCore/plugins/qt/PluginViewQt.cpp
+++ b/src/3rdparty/webkit/WebCore/plugins/qt/PluginViewQt.cpp
@@ -301,15 +301,15 @@ NPError PluginView::getValueStatic(NPNVariable variable, void* value)
 {
     switch (variable) {
     case NPNVToolkit:
-        *((uint32 *)value) = 0;
+        *static_cast<uint32*>(value) = 0;
         return NPERR_NO_ERROR;
 
     case NPNVSupportsXEmbedBool:
-        *((uint32 *)value) = true;
+        *static_cast<NPBool*>(value) = true;
         return NPERR_NO_ERROR;
 
     case NPNVjavascriptEnabledBool:
-        *((uint32 *)value) = true;
+        *static_cast<NPBool*>(value) = true;
         return NPERR_NO_ERROR;
 
     default:
diff --git a/src/3rdparty/webkit/WebKit/qt/Api/qwebpage.cpp b/src/3rdparty/webkit/WebKit/qt/Api/qwebpage.cpp
index e17306d..01b68eb 100644
--- a/src/3rdparty/webkit/WebKit/qt/Api/qwebpage.cpp
+++ b/src/3rdparty/webkit/WebKit/qt/Api/qwebpage.cpp
@@ -1095,7 +1095,7 @@ QVariant QWebPage::inputMethodQuery(Qt::InputMethodQuery property) const
     This enum describes the types of action which can be performed on the web page.
 
     Actions only have an effect when they are applicable. The availability of
-    actions can be be determined by checking \l{QAction::}{enabled()} on the
+    actions can be be determined by checking \l{QAction::}{isEnabled()} on the
     action returned by \l{QWebPage::}{action()}.
 
     One method of enabling the text editing, cursor movement, and text selection actions
@@ -1198,18 +1198,18 @@ QVariant QWebPage::inputMethodQuery(Qt::InputMethodQuery property) const
 
     Suppose we have a \c Thumbnail class as follows:
 
-    \snippet doc/src/snippets/webkit/webpage/main.cpp 0
+    \snippet webkitsnippets/webpage/main.cpp 0
 
     The \c Thumbnail's constructor takes in a \a url. We connect our QWebPage
     object's \l{QWebPage::}{loadFinished()} signal to our private slot,
     \c render().
 
-    \snippet doc/src/snippets/webkit/webpage/main.cpp 1
+    \snippet webkitsnippets/webpage/main.cpp 1
 
     The \c render() function shows how we can paint a thumbnail using a
     QWebPage object.
 
-    \snippet doc/src/snippets/webkit/webpage/main.cpp 2
+    \snippet webkitsnippets/webpage/main.cpp 2
 
     We begin by setting the \l{QWebPage::viewportSize()}{viewportSize} and
     then we instantiate a QImage object, \c image, with the same size as our
@@ -1450,9 +1450,16 @@ void QWebPage::triggerAction(WebAction action, bool checked)
             openNewWindow(url, frame);
             break;
         }
-        case CopyLinkToClipboard:
+        case CopyLinkToClipboard: {
+#if defined(Q_WS_X11)
+            bool oldSelectionMode = Pasteboard::generalPasteboard()->isSelectionMode();
+            Pasteboard::generalPasteboard()->setSelectionMode(true);
+            editor->copyURL(d->hitTestResult.linkUrl(), d->hitTestResult.linkText());
+            Pasteboard::generalPasteboard()->setSelectionMode(oldSelectionMode);
+#endif
             editor->copyURL(d->hitTestResult.linkUrl(), d->hitTestResult.linkText());
             break;
+        }
         case OpenImageInNewWindow:
             openNewWindow(d->hitTestResult.imageUrl(), frame);
             break;
diff --git a/src/3rdparty/webkit/WebKit/qt/Api/qwebview.cpp b/src/3rdparty/webkit/WebKit/qt/Api/qwebview.cpp
index a843eba..9753f4f 100644
--- a/src/3rdparty/webkit/WebKit/qt/Api/qwebview.cpp
+++ b/src/3rdparty/webkit/WebKit/qt/Api/qwebview.cpp
@@ -86,7 +86,7 @@ public:
     Qt Widgets, the show() function must be invoked in order to display
     QWebView. The snippet below illustrates this:
 
-    \snippet doc/src/snippets/webkit/simple/main.cpp Using QWebView
+    \snippet webkitsnippets/simple/main.cpp Using QWebView
 
     Alternatively, setUrl() can also be used to load a web site. If you have
     the HTML content readily available, you can use setHtml() instead.
@@ -325,7 +325,7 @@ void QWebView::setContent(const QByteArray &data, const QString &mimeType, const
 
     It is equivalent to
 
-    \snippet doc/src/snippets/code/src_3rdparty_webkit_WebKit_qt_Api_qwebview.cpp 0
+    \snippet webkitsnippets/qtwebkit_qwebview_snippet.cpp 0
 */
 QWebHistory *QWebView::history() const
 {
@@ -337,7 +337,7 @@ QWebHistory *QWebView::history() const
 
     It is equivalent to
 
-    \snippet doc/src/snippets/code/src_3rdparty_webkit_WebKit_qt_Api_qwebview.cpp 1
+    \snippet webkitsnippets/qtwebkit_qwebview_snippet.cpp 1
 
     \sa QWebSettings::globalSettings()
 */
@@ -429,7 +429,7 @@ QAction *QWebView::pageAction(QWebPage::WebAction action) const
     The following example triggers the copy action and therefore copies any
     selected text to the clipboard.
 
-    \snippet doc/src/snippets/code/src_3rdparty_webkit_WebKit_qt_Api_qwebview.cpp 2
+    \snippet webkitsnippets/qtwebkit_qwebview_snippet.cpp 2
 
     \sa pageAction()
 */
@@ -606,7 +606,7 @@ void QWebView::print(QPrinter *printer) const
 
     It is equivalent to
 
-    \snippet doc/src/snippets/code/src_3rdparty_webkit_WebKit_qt_Api_qwebview.cpp 3
+    \snippet webkitsnippets/qtwebkit_qwebview_snippet.cpp 3
 
     \sa reload(), pageAction(), loadFinished()
 */
@@ -622,7 +622,7 @@ void QWebView::stop()
 
     It is equivalent to
 
-    \snippet doc/src/snippets/code/src_3rdparty_webkit_WebKit_qt_Api_qwebview.cpp 4
+    \snippet webkitsnippets/qtwebkit_qwebview_snippet.cpp 4
 
     \sa forward(), pageAction()
 */
@@ -638,7 +638,7 @@ void QWebView::back()
 
     It is equivalent to
 
-    \snippet doc/src/snippets/code/src_3rdparty_webkit_WebKit_qt_Api_qwebview.cpp 5
+    \snippet webkitsnippets/qtwebkit_qwebview_snippet.cpp 5
 
     \sa back(), pageAction()
 */
diff --git a/src/3rdparty/webkit/WebKit/qt/ChangeLog b/src/3rdparty/webkit/WebKit/qt/ChangeLog
index 5a23200..c3bd633 100644
--- a/src/3rdparty/webkit/WebKit/qt/ChangeLog
+++ b/src/3rdparty/webkit/WebKit/qt/ChangeLog
@@ -1,3 +1,42 @@
+2009-04-24  Simon Hausmann  <simon.hausmann@nokia.com>
+
+        Rubber-stamped by Ariya Hidayat.
+
+        Fix qdoc warning about link to QAction::isEnabled.
+
+        * Api/qwebpage.cpp:
+
+2009-04-24  Simon Hausmann  <simon.hausmann@nokia.com>
+
+        Reviewed by Ariya Hidayat.
+
+        Added support for generating API docs in the Qt build using "make docs"
+
+        Added code snippets and overview from the Qt sources references in the API docs.
+
+        * Api/qwebpage.cpp: Adjust paths to snippets.
+        * Api/qwebview.cpp: Ditto.
+        * docs/docs.pri: Added.
+        * docs/qtwebkit.qdoc: Added.
+        * docs/qtwebkit.qdocconf: Added.
+        * docs/webkitsnippets/qtwebkit_build_snippet.qdoc: Added.
+        * docs/webkitsnippets/qtwebkit_qwebview_snippet.cpp: Added.
+        * docs/webkitsnippets/simple/main.cpp: Added.
+        * docs/webkitsnippets/simple/simple.pro: Added.
+        * docs/webkitsnippets/webpage/main.cpp: Added.
+        * docs/webkitsnippets/webpage/webpage.pro: Added.
+
+2009-03-02  Benjamin C Meyer  <benjamin.meyer@torchmobile.com>
+
+        Reviewed by George Staikos.
+
+        https://bugs.webkit.org/show_bug.cgi?id=21230
+        On X11 match the behavior of Firefox and also copy the url to the
+        clipboard selection when the action Copy Link Location is executed.
+
+        * Api/qwebpage.cpp:
+        (QWebPage::triggerAction):
+
 2009-03-07  Adam Treat  <adam.treat@torchmobile.com>
 
         Reviewed by Cameron Zwarich.
diff --git a/src/3rdparty/webkit/WebKit/qt/docs/docs.pri b/src/3rdparty/webkit/WebKit/qt/docs/docs.pri
new file mode 100644
index 0000000..4a8c165
--- /dev/null
+++ b/src/3rdparty/webkit/WebKit/qt/docs/docs.pri
@@ -0,0 +1,15 @@
+include(../../../WebKit.pri)
+
+unix {
+    QDOC = SRCDIR=$$PWD/../../.. OUTPUT_DIR=$$OUTPUT_DIR $$(QTDIR)/tools/qdoc3/qdoc3
+} else {
+    QDOC = $$(QTDIR)\tools\qdoc3\release\qdoc3.exe
+}
+
+unix {
+docs.commands = $$QDOC $$PWD/qtwebkit.qdocconf
+} else {
+docs.commands = \"$$QDOC $$PWD/qtwebkit.qdocconf\"
+}
+
+QMAKE_EXTRA_TARGETS += docs
diff --git a/src/3rdparty/webkit/WebKit/qt/docs/qtwebkit.qdoc b/src/3rdparty/webkit/WebKit/qt/docs/qtwebkit.qdoc
new file mode 100644
index 0000000..06305e0
--- /dev/null
+++ b/src/3rdparty/webkit/WebKit/qt/docs/qtwebkit.qdoc
@@ -0,0 +1,189 @@
+/*!
+    \module QtWebKit
+    \title QtWebKit Module
+    \contentspage Qt's Modules
+    \previouspage QtSvg
+    \nextpage QtXml
+    \ingroup architecture
+    \ingroup modules
+    \brief An introduction to the QtWebKit module.
+
+    \keyword Browser
+    \keyword Web Browser
+
+    \since 4.4
+
+    QtWebKit provides a Web browser engine that makes it easy to embed content
+    from the World Wide Web into your Qt application. At the same time Web
+    content can be enhanced with native controls.
+
+    QtWebKit provides facilities for rendering of HyperText Markup Language
+    (HTML), Extensible HyperText Markup Language (XHTML) and Scalable Vector
+    Graphics (SVG) documents, styled using Cascading Style Sheets (CSS) and
+    scripted with JavaScript.
+
+    A bridge between the JavaScript execution environment and the Qt object
+    model makes it possible for custom QObjects to be scripted. Integration
+    with the Qt networking module enables Web pages to be transparently loaded
+    from Web servers, the local file system or even the Qt resource system.
+
+    In addition to providing pure rendering features, HTML documents can be
+    made fully editable to the user through the use of the \c{contenteditable}
+    attribute on HTML elements.
+
+    QtWebKit is based on the Open Source WebKit engine. More information about
+    WebKit itself can be found on the \l{WebKit Open Source Project} Web site.
+
+    The QtWebKit module is part of the \l{Qt Full Framework Edition}, and the
+    \l{Open Source Versions of Qt}.
+
+    \note Building the QtWebKit module with debugging symbols is problematic
+    on many platforms due to the size of the WebKit engine. We recommend
+    building the module in release mode only for embedded platforms.
+
+    \note Web site icons, also known as "FavIcons", are currently not supported
+    on Windows. We plan to address this in a future release.
+
+    \note WebKit has certain minimum requirements that must be met on
+    Embedded Linux systems. See the \l{Qt for Embedded Linux Requirements}
+    document for more information.
+
+    Topics:
+
+    \tableofcontents
+
+    \section1 Configuring the Build Process
+
+    Applications that use QtWebKit's classes need to be configured to be built
+    against the QtWebKit module. The following declaration in a \c qmake
+    project file ensures that an application is compiled and linked
+    appropriately:
+
+    \snippet webkitsnippets/qtwebkit_build_snippet.qdoc 0
+
+    This line is necessary because only the QtCore and QtGui modules are used
+    in the default build process.
+
+    To include the definitions of the module's classes, use the following
+    directive:
+
+    \snippet webkitsnippets/qtwebkit_build_snippet.qdoc 1
+
+    \section1 Architecture
+
+    The easiest way to render content is through the QWebView class. As a
+    widget it can be embedded into your forms or a graphics view, and it
+    provides convenience functions for downloading and rendering web sites.
+
+    \snippet webkitsnippets/simple/main.cpp Using QWebView
+
+    QWebView acts as a view onto Web pages, each of which is represented by an
+    instance of the QWebPage class. QWebPage provides access to the document
+    structure in a page, describing features such as frames, the navigation
+    history, and the undo/redo stack for editable content.
+
+    HTML documents can be nested using frames in a frameset. An individual
+    frame in HTML is represented using the QWebFrame class. It includes the
+    bridge to the JavaScript window object and can be painted using QPainter.
+    Each QWebPage has one QWebFrame object as its main frame.
+
+    Individual browser features, defaults and other settings can be configured
+    through the QWebSettings class. It is possible to provide defaults for all
+    QWebPage instances through the default settings. Individual attributes
+    can be overidden by the page specific settings object.
+
+    \section1 Netscape Plugin Support
+
+    Since WebKit supports the Netscape Plugin API, Qt applications can display
+    Web pages that embed common plugins, as long as the user has the appropriate
+    binary files for those plugins installed.
+
+    The following locations are searched for plugins:
+
+    \table
+    \header \o Linux/Unix  \o Windows
+    \row \o{1,3}
+    \list
+    \o \c{.mozilla/plugins} in the user's home directory
+    \o \c{.netscape/plugins} in the user's home directory
+    \o System locations, such as
+    \list
+    \o \c{/usr/lib/browser/plugins}
+    \o \c{/usr/local/lib/mozilla/plugins}
+    \o \c{/usr/lib/firefox/plugins}
+    \o \c{/usr/lib64/browser-plugins}
+    \o \c{/usr/lib/browser-plugins}
+    \o \c{/usr/lib/mozilla/plugins}
+    \o \c{/usr/local/netscape/plugins}
+    \o \c{/opt/mozilla/plugins}
+    \o \c{/opt/mozilla/lib/plugins}
+    \o \c{/opt/netscape/plugins}
+    \o \c{/opt/netscape/communicator/plugins}
+    \o \c{/usr/lib/netscape/plugins}
+    \o \c{/usr/lib/netscape/plugins-libc5}
+    \o \c{/usr/lib/netscape/plugins-libc6}
+    \o \c{/usr/lib64/netscape/plugins}
+    \o \c{/usr/lib64/mozilla/plugins}
+    \endlist
+    \o Locations specified by environment variables:
+    \list
+    \o \c{$MOZILLA_HOME/plugins}
+    \o \c{$MOZ_PLUGIN_PATH}
+    \o \c{$QTWEBKIT_PLUGIN_PATH}
+    \endlist
+    \endlist
+
+    \o
+    \list
+    \o The user's \c{Application Data\Mozilla\plugins} directory
+    \o Standard system locations of plugins for Quicktime, Flash, etc.
+    \endlist
+
+    \row
+    \raw HTML
+    <th class="qt-style">Mac OS X</th>
+    \endraw
+    \row
+    \o
+    \list
+    \o \c{Library/Internet Plug-Ins} in the user's home directory
+    \o The system \c{/Library/Internet Plug-Ins} directory
+    \endlist
+    \endtable
+
+    \section1 License Information
+
+    This is a snapshot of the Qt port of WebKit. The exact version information
+    can be found in the \c{src/3rdparty/webkit/VERSION} file supplied with Qt.
+
+    Qt Commercial Edition licensees that wish to distribute applications that
+    use the QtWebKit module need to be aware of their obligations under the
+    GNU Lesser General Public License (LGPL). 
+
+    Developers using the Open Source Edition can choose to redistribute
+    the module under the appropriate version of the GNU LGPL; version 2.1
+    for applications and libraries licensed under the GNU GPL version 2,
+    or version 3 for applications and libraries licensed under the GNU
+    GPL version 2.
+
+    \legalese
+    WebKit is licensed under the GNU Library General Public License.
+    Individual contributor names and copyright dates can be found
+    inline in the code.
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA 02110-1301, USA.
+    \endlegalese
+*/
diff --git a/src/3rdparty/webkit/WebKit/qt/docs/qtwebkit.qdocconf b/src/3rdparty/webkit/WebKit/qt/docs/qtwebkit.qdocconf
new file mode 100644
index 0000000..e60e586
--- /dev/null
+++ b/src/3rdparty/webkit/WebKit/qt/docs/qtwebkit.qdocconf
@@ -0,0 +1,195 @@
+# Run qdoc from the directory that contains this file.
+
+project     = qtwebkit
+description = "Qt WebKit API Documentation"
+
+headerdirs = $SRCDIR/WebKit/qt/Api
+sourcedirs = $SRCDIR/WebKit/qt/Api $SRCDIR/WebKit/qt/docs
+outputdir = $OUTPUT_DIR/doc/html
+outputformats = HTML
+sources.fileextensions  = "*.cpp *.doc *.qdoc *.h"
+exampledirs = $SRCDIR/WebKit/qt/docs
+
+indexes = $QTDIR/doc/html/qt.index
+
+# macros.qdocconf
+
+macro.aring.HTML        = "&aring;"
+macro.Auml.HTML         = "&Auml;"
+macro.author            = "\\bold{Author:}"
+macro.br.HTML           = "<br />"
+macro.BR.HTML           = "<br />"
+macro.aacute.HTML       = "&aacute;"
+macro.eacute.HTML       = "&eacute;"
+macro.iacute.HTML       = "&iacute;"
+macro.gui               = "\\bold"
+macro.hr.HTML           = "<hr />"
+macro.key               = "\\bold"
+macro.menu              = "\\bold"
+macro.note              = "\\bold{Note:}"
+macro.oslash.HTML       = "&oslash;"
+macro.ouml.HTML         = "&ouml;"
+macro.QA                = "\\e{Qt Assistant}"
+macro.QD                = "\\e{Qt Designer}"
+macro.QL                = "\\e{Qt Linguist}"
+macro.param             = "\\e"
+macro.raisedaster.HTML  = "<sup>*</sup>"
+macro.reg.HTML          = "<sup>&reg;</sup>"
+macro.return            = "Returns"
+macro.starslash         = "\\c{*/}"
+macro.uuml.HTML         = "&uuml;"
+macro.mdash.HTML        = "&mdash;"
+
+# compat.qdocconf
+
+alias.i				= e
+alias.include			= input
+
+macro.0                         = "\\\\0"
+macro.b                         = "\\\\b"
+macro.n                         = "\\\\n"
+macro.r                         = "\\\\r"
+macro.i                         = "\\o"
+macro.i11                       = "\\o{1,1}"
+macro.i12                       = "\\o{1,2}"
+macro.i13                       = "\\o{1,3}"
+macro.i14                       = "\\o{1,4}"
+macro.i15                       = "\\o{1,5}"
+macro.i16                       = "\\o{1,6}"
+macro.i17                       = "\\o{1,7}"
+macro.i18                       = "\\o{1,8}"
+macro.i19                       = "\\o{1,9}"
+macro.i21                       = "\\o{2,1}"
+macro.i31                       = "\\o{3,1}"
+macro.i41                       = "\\o{4,1}"
+macro.i51                       = "\\o{5,1}"
+macro.i61                       = "\\o{6,1}"
+macro.i71                       = "\\o{7,1}"
+macro.i81                       = "\\o{8,1}"
+macro.i91                       = "\\o{9,1}"
+macro.img                       = "\\image"
+macro.endquote                  = "\\endquotation"
+
+spurious			= "Missing comma in .*" \
+				  "Missing pattern .*"
+
+# Doxygen compatibility commands
+
+macro.see                       = "\\sa"
+macro.function                  = "\\fn"
+
+# qt-cpp-ignore.qdocconf
+
+Cpp.ignoretokens        = QAXFACTORY_EXPORT \
+                          QDESIGNER_COMPONENTS_LIBRARY \
+                          QDESIGNER_EXTENSION_LIBRARY \
+                          QDESIGNER_SDK_LIBRARY \
+                          QDESIGNER_SHARED_LIBRARY \
+                          QDESIGNER_UILIB_LIBRARY \
+                          QM_EXPORT_CANVAS \
+                          QM_EXPORT_DNS \
+                          QM_EXPORT_DOM \
+                          QM_EXPORT_FTP \
+                          QM_EXPORT_HTTP \
+                          QM_EXPORT_ICONVIEW \
+                          QM_EXPORT_NETWORK \
+                          QM_EXPORT_OPENGL \
+                          QM_EXPORT_SQL \
+                          QM_EXPORT_TABLE \
+                          QM_EXPORT_WORKSPACE \
+                          QM_EXPORT_XML \
+                          QT_ASCII_CAST_WARN \
+                          QT_ASCII_CAST_WARN_CONSTRUCTOR \
+                          QT_BEGIN_HEADER \
+                          QT_DESIGNER_STATIC \
+                          QT_END_HEADER \
+                          QT_FASTCALL \
+                          QT_WIDGET_PLUGIN_EXPORT \
+                          Q_COMPAT_EXPORT \
+                          Q_CORE_EXPORT \
+                          Q_EXPLICIT \
+                          Q_EXPORT \
+                          Q_EXPORT_CODECS_CN \
+                          Q_EXPORT_CODECS_JP \
+                          Q_EXPORT_CODECS_KR \
+                          Q_EXPORT_PLUGIN \
+                          Q_GFX_INLINE \
+                          Q_GUI_EXPORT \
+                          Q_GUI_EXPORT_INLINE \
+                          Q_GUI_EXPORT_STYLE_CDE \
+                          Q_GUI_EXPORT_STYLE_COMPACT \
+                          Q_GUI_EXPORT_STYLE_MAC \
+                          Q_GUI_EXPORT_STYLE_MOTIF \
+                          Q_GUI_EXPORT_STYLE_MOTIFPLUS \
+                          Q_GUI_EXPORT_STYLE_PLATINUM \
+                          Q_GUI_EXPORT_STYLE_POCKETPC \
+                          Q_GUI_EXPORT_STYLE_SGI \
+                          Q_GUI_EXPORT_STYLE_WINDOWS \
+                          Q_GUI_EXPORT_STYLE_WINDOWSXP \
+                          QHELP_EXPORT \
+                          Q_INLINE_TEMPLATE \
+                          Q_INTERNAL_WIN_NO_THROW \
+                          Q_NETWORK_EXPORT \
+                          Q_OPENGL_EXPORT \
+                          Q_OUTOFLINE_TEMPLATE \
+                          Q_SQL_EXPORT \
+                          Q_SVG_EXPORT \
+                          Q_SCRIPT_EXPORT \
+                          Q_TESTLIB_EXPORT \
+                          Q_TYPENAME \
+                          Q_XML_EXPORT \
+                          Q_XMLSTREAM_EXPORT \
+                          Q_XMLPATTERNS_EXPORT \
+                          QDBUS_EXPORT \
+                          QT_BEGIN_NAMESPACE \
+                          QT_BEGIN_INCLUDE_NAMESPACE \
+                          QT_END_NAMESPACE \
+                          QT_END_INCLUDE_NAMESPACE \
+                          PHONON_EXPORT \
+                          EXTENSIONSYSTEM_EXPORT
+Cpp.ignoredirectives    = Q_DECLARE_HANDLE \
+                          Q_DECLARE_INTERFACE \
+                          Q_DECLARE_METATYPE \
+                          Q_DECLARE_OPERATORS_FOR_FLAGS \
+                          Q_DECLARE_PRIVATE \
+                          Q_DECLARE_PUBLIC \
+                          Q_DECLARE_SHARED \
+                          Q_DECLARE_TR_FUNCTIONS \
+                          Q_DECLARE_TYPEINFO \
+                          Q_DISABLE_COPY \
+                          QT_FORWARD_DECLARE_CLASS \
+                          Q_DUMMY_COMPARISON_OPERATOR \
+                          Q_ENUMS \
+                          Q_FLAGS \
+                          Q_INTERFACES \
+                          __attribute__ \
+                          K_DECLARE_PRIVATE \
+                          PHONON_OBJECT \
+                          PHONON_HEIR
+
+
+
+HTML.style              = "" \
+                          "h3.fn,span.fn { margin-left: 1cm; text-indent: -1cm; }"\
+                          "a:link { color: #004faf; text-decoration: none }"\
+                          "a:visited { color: #672967; text-decoration: none }"\
+                          "td.postheader { font-family: sans-serif }"\
+                          "tr.address { font-family: sans-serif }"\
+                          "body { background: #ffffff; color: black }"\
+                          "table tr.odd { background: #f0f0f0; color: black; }"\
+                          "table tr.even { background: #e4e4e4; color: black; }"\
+                          "table.annotated th { padding: 3px; text-align: left }"\
+                          "table.annotated td { padding: 3px; } "\
+                          "table tr pre { padding-top: none; padding-bottom: none; padding-left: none; padding-right: none; border: none; background: none }"\
+                          "tr.qt-style { background: #a2c511; color: black }"\
+                          "body pre { padding: 0.2em; border: #e7e7e7 1px solid; background: #f1f1f1; color: black }"\
+                          "span.preprocessor, span.preprocessor a { color: darkblue; }"\
+                          "span.comment { color: darkred; font-style: italic }"\
+                          "span.string,span.char { color: darkgreen; }"\
+                          ".title { text-align: center }"\
+                          ".subtitle { font-size: 0.8em }"\
+                          ".small-subtitle { font-size: 0.65em }"
+
+HTML.postheader         = ""
+
+HTML.footer             = ""
diff --git a/src/3rdparty/webkit/WebKit/qt/docs/webkitsnippets/qtwebkit_build_snippet.qdoc b/src/3rdparty/webkit/WebKit/qt/docs/webkitsnippets/qtwebkit_build_snippet.qdoc
new file mode 100644
index 0000000..d4fc2bd
--- /dev/null
+++ b/src/3rdparty/webkit/WebKit/qt/docs/webkitsnippets/qtwebkit_build_snippet.qdoc
@@ -0,0 +1,8 @@
+//! [0]
+QT += webkit
+//! [0]
+
+
+//! [1]
+#include <QtWebKit>
+//! [1]
diff --git a/src/3rdparty/webkit/WebKit/qt/docs/webkitsnippets/qtwebkit_qwebview_snippet.cpp b/src/3rdparty/webkit/WebKit/qt/docs/webkitsnippets/qtwebkit_qwebview_snippet.cpp
new file mode 100644
index 0000000..f04cd29
--- /dev/null
+++ b/src/3rdparty/webkit/WebKit/qt/docs/webkitsnippets/qtwebkit_qwebview_snippet.cpp
@@ -0,0 +1,35 @@
+
+void wrapInFunction()
+{
+
+//! [0]
+    view->page()->history();
+//! [0]
+
+
+//! [1]
+    view->page()->settings();
+//! [1]
+
+
+//! [2]
+    view->triggerAction(QWebPage::Copy);
+//! [2]
+
+
+//! [3]
+    view->page()->triggerPageAction(QWebPage::Stop);
+//! [3]
+
+
+//! [4]
+    view->page()->triggerPageAction(QWebPage::GoBack);
+//! [4]
+
+
+//! [5]
+    view->page()->triggerPageAction(QWebPage::GoForward);
+//! [5]
+
+}
+
diff --git a/src/3rdparty/webkit/WebKit/qt/docs/webkitsnippets/simple/main.cpp b/src/3rdparty/webkit/WebKit/qt/docs/webkitsnippets/simple/main.cpp
new file mode 100644
index 0000000..82f5b6c
--- /dev/null
+++ b/src/3rdparty/webkit/WebKit/qt/docs/webkitsnippets/simple/main.cpp
@@ -0,0 +1,34 @@
+/*
+    Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies)
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA 02110-1301, USA.
+*/
+
+#include <QApplication>
+#include <QUrl>
+#include <QWebView>
+
+int main(int argc, char *argv[])
+{
+    QApplication app(argc, argv);
+    QWidget *parent = 0;
+//! [Using QWebView]
+    QWebView *view = new QWebView(parent);
+    view->load(QUrl("http://qtsoftware.com/"));
+    view->show();
+//! [Using QWebView]
+    return app.exec();
+}
diff --git a/src/3rdparty/webkit/WebKit/qt/docs/webkitsnippets/simple/simple.pro b/src/3rdparty/webkit/WebKit/qt/docs/webkitsnippets/simple/simple.pro
new file mode 100644
index 0000000..61cd3bf
--- /dev/null
+++ b/src/3rdparty/webkit/WebKit/qt/docs/webkitsnippets/simple/simple.pro
@@ -0,0 +1,2 @@
+QT       += webkit
+SOURCES   = main.cpp
diff --git a/src/3rdparty/webkit/WebKit/qt/docs/webkitsnippets/webpage/main.cpp b/src/3rdparty/webkit/WebKit/qt/docs/webkitsnippets/webpage/main.cpp
new file mode 100644
index 0000000..b91bc30
--- /dev/null
+++ b/src/3rdparty/webkit/WebKit/qt/docs/webkitsnippets/webpage/main.cpp
@@ -0,0 +1,81 @@
+/*
+    Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies)
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA 02110-1301, USA.
+*/
+
+#include <QtGui>
+#include <QWebPage>
+#include <QWebFrame>
+
+//! [0]
+class Thumbnailer : public QObject
+{
+    Q_OBJECT
+
+public:
+    Thumbnailer(const QUrl &url);
+
+signals:
+    void finished();
+
+private slots:
+    void render();
+
+private:
+    QWebPage page;
+
+};
+//! [0]
+
+int main(int argc, char *argv[])
+{
+    QApplication app(argc, argv);
+
+    Thumbnailer thumbnail(QUrl("http://qtsoftware.com"));
+
+    QObject::connect(&thumbnail, SIGNAL(finished()),
+        &app, SLOT(quit()));
+
+    return app.exec();
+}
+
+//! [1]
+Thumbnailer::Thumbnailer(const QUrl &url)
+{
+    page.mainFrame()->load(url);
+    connect(&page, SIGNAL(loadFinished(bool)),
+        this, SLOT(render()));
+}
+//! [1]
+
+//! [2]
+void Thumbnailer::render()
+{
+    page.setViewportSize(page.mainFrame()->contentsSize());
+    QImage image(page.viewportSize(), QImage::Format_ARGB32);
+    QPainter painter(&image);
+
+    page.mainFrame()->render(&painter);
+    painter.end();
+
+    QImage thumbnail = image.scaled(400, 400);
+    thumbnail.save("thumbnail.png");
+
+    emit finished();
+}
+//! [2]
+#include "main.moc"
diff --git a/src/3rdparty/webkit/WebKit/qt/docs/webkitsnippets/webpage/webpage.pro b/src/3rdparty/webkit/WebKit/qt/docs/webkitsnippets/webpage/webpage.pro
new file mode 100644
index 0000000..fcad03b
--- /dev/null
+++ b/src/3rdparty/webkit/WebKit/qt/docs/webkitsnippets/webpage/webpage.pro
@@ -0,0 +1,3 @@
+CONFIG += console
+QT += webkit
+SOURCES = main.cpp
\ No newline at end of file
diff --git a/src/corelib/codecs/qtsciicodec.cpp b/src/corelib/codecs/qtsciicodec.cpp
index 14d2c9c..0ec0567 100644
--- a/src/corelib/codecs/qtsciicodec.cpp
+++ b/src/corelib/codecs/qtsciicodec.cpp
@@ -180,8 +180,7 @@ QByteArray QTsciiCodec::name() const
 */
 int QTsciiCodec::mibEnum() const
 {
-  /* There is no MIBEnum for TSCII now */
-  return -3197;
+  return 2107;
 }
 
 static const int UnToTsLast = 124; // 125 items -- so the last will be 124
diff --git a/src/corelib/codecs/qutfcodec.cpp b/src/corelib/codecs/qutfcodec.cpp
index 281bf75..1ac592e 100644
--- a/src/corelib/codecs/qutfcodec.cpp
+++ b/src/corelib/codecs/qutfcodec.cpp
@@ -413,9 +413,7 @@ QByteArray QUtf16Codec::name() const
 
 QList<QByteArray> QUtf16Codec::aliases() const
 {
-    QList<QByteArray> list;
-    list << "ISO-10646-UCS-2";
-    return list;
+    return QList<QByteArray>();
 }
 
 int QUtf16BECodec::mibEnum() const
diff --git a/src/corelib/global/qfeatures.h b/src/corelib/global/qfeatures.h
index c172f5f..f11c9df 100644
--- a/src/corelib/global/qfeatures.h
+++ b/src/corelib/global/qfeatures.h
@@ -386,11 +386,6 @@
 #define QT_NO_PHONON_VOLUMESLIDER
 #endif
 
-// QPrinter
-#if !defined(QT_NO_PRINTER) && (defined(QT_NO_TEXTSTREAM))
-#define QT_NO_PRINTER
-#endif
-
 // QProcess
 #if !defined(QT_NO_PROCESS) && (defined(QT_NO_THREAD))
 #define QT_NO_PROCESS
@@ -516,6 +511,11 @@
 #define QT_NO_LIBRARY
 #endif
 
+// QPrinter
+#if !defined(QT_NO_PRINTER) && (defined(QT_NO_TEXTSTREAM) || defined(QT_NO_PICTURE))
+#define QT_NO_PRINTER
+#endif
+
 // QScrollArea
 #if !defined(QT_NO_SCROLLAREA) && (defined(QT_NO_SCROLLBAR))
 #define QT_NO_SCROLLAREA
@@ -646,11 +646,6 @@
 #define QT_NO_WHATSTHIS
 #endif
 
-// Common UNIX Printing System
-#if !defined(QT_NO_CUPS) && (defined(QT_NO_PRINTER) || defined(QT_NO_LIBRARY))
-#define QT_NO_CUPS
-#endif
-
 // QDirModel
 #if !defined(QT_NO_DIRMODEL) && (defined(QT_NO_ITEMVIEWS))
 #define QT_NO_DIRMODEL
@@ -731,6 +726,11 @@
 #define QT_NO_COMPLETER
 #endif
 
+// Common UNIX Printing System
+#if !defined(QT_NO_CUPS) && (defined(QT_NO_PRINTER) || defined(QT_NO_LIBRARY))
+#define QT_NO_CUPS
+#endif
+
 // QDataWidgetMapper
 #if !defined(QT_NO_DATAWIDGETMAPPER) && (defined(QT_NO_ITEMVIEWS) || defined(QT_NO_PROPERTIES))
 #define QT_NO_DATAWIDGETMAPPER
@@ -762,7 +762,7 @@
 #endif
 
 // QPrintPreviewWidget
-#if !defined(QT_NO_PRINTPREVIEWWIDGET) && (defined(QT_NO_GRAPHICSVIEW) || defined(QT_NO_PRINTER) || defined(QT_NO_PICTURE))
+#if !defined(QT_NO_PRINTPREVIEWWIDGET) && (defined(QT_NO_GRAPHICSVIEW) || defined(QT_NO_PRINTER))
 #define QT_NO_PRINTPREVIEWWIDGET
 #endif
 
diff --git a/src/corelib/kernel/qcoreapplication.cpp b/src/corelib/kernel/qcoreapplication.cpp
index a23b2dd..e4bd664 100644
--- a/src/corelib/kernel/qcoreapplication.cpp
+++ b/src/corelib/kernel/qcoreapplication.cpp
@@ -377,12 +377,12 @@ QString qAppName()
     QLibrary) can be retrieved with libraryPaths() and manipulated by
     setLibraryPaths(), addLibraryPath(), and removeLibraryPath().
 
-	On Unix/Linux Qt is configured to use the system local settings by 
-	default. This can cause a conflict when using POSIX functions, for 
-	instance, when converting between data types such as floats and 
-	strings, since the notation may differ between locales. To get 
-	around this problem call the POSIX function setlocale(LC_NUMERIC,"C") 
-	right after initializing QApplication or QCoreApplication to reset 
+	On Unix/Linux Qt is configured to use the system local settings by
+	default. This can cause a conflict when using POSIX functions, for
+	instance, when converting between data types such as floats and
+	strings, since the notation may differ between locales. To get
+	around this problem call the POSIX function setlocale(LC_NUMERIC,"C")
+	right after initializing QApplication or QCoreApplication to reset
 	the locale that is used for number formatting to "C"-locale.
 
     \sa QApplication, QAbstractEventDispatcher, QEventLoop,
@@ -1908,8 +1908,7 @@ QStringList QCoreApplication::arguments()
                 l1arg == "-qdebug" ||
                 l1arg == "-reverse" ||
                 l1arg == "-stylesheet" ||
-                l1arg == "-widgetcount" ||
-                l1arg == "-direct3d")
+                l1arg == "-widgetcount")
                 ;
             else if (l1arg.startsWith("-style="))
                 ;
diff --git a/src/corelib/kernel/qcoreevent.cpp b/src/corelib/kernel/qcoreevent.cpp
index fc1cefb..4b4dfe5 100644
--- a/src/corelib/kernel/qcoreevent.cpp
+++ b/src/corelib/kernel/qcoreevent.cpp
@@ -260,6 +260,7 @@ QT_BEGIN_NAMESPACE
     \omitvalue ApplicationActivated
     \omitvalue ApplicationDeactivated
     \omitvalue MacGLWindowChange
+    \omitvalue MacGLClearDrawable
     \omitvalue NetworkReplyUpdated
     \omitvalue FutureCallOut
     \omitvalue CocoaRequestModal
diff --git a/src/corelib/kernel/qeventdispatcher_glib.cpp b/src/corelib/kernel/qeventdispatcher_glib.cpp
index 3fd768a..3c5b277 100644
--- a/src/corelib/kernel/qeventdispatcher_glib.cpp
+++ b/src/corelib/kernel/qeventdispatcher_glib.cpp
@@ -42,6 +42,7 @@
 #include "qeventdispatcher_glib_p.h"
 #include "qeventdispatcher_unix_p.h"
 
+#include <private/qmutexpool_p.h>
 #include <private/qthread_p.h>
 
 #include "qcoreapplication.h"
@@ -224,6 +225,8 @@ QEventDispatcherGlibPrivate::QEventDispatcherGlibPrivate(GMainContext *context)
     : mainContext(context)
 {
     if (qgetenv("QT_NO_THREADED_GLIB").isEmpty()) {
+        static int dummyValue = 0; // only used for its address
+        QMutexLocker locker(QMutexPool::instance()->get(&dummyValue));
         if (!g_thread_supported())
             g_thread_init(NULL);
     }
diff --git a/src/corelib/kernel/qeventloop.cpp b/src/corelib/kernel/qeventloop.cpp
index 92bdf73..600f787 100644
--- a/src/corelib/kernel/qeventloop.cpp
+++ b/src/corelib/kernel/qeventloop.cpp
@@ -188,8 +188,9 @@ int QEventLoop::exec(ProcessEventsFlags flags)
     d->threadData->eventLoops.push(this);
 
     // remove posted quit events when entering a new event loop
-    if (qApp->thread() == thread())
-        QCoreApplication::removePostedEvents(qApp, QEvent::Quit);
+    QCoreApplication *app = QCoreApplication::instance();
+    if (app && app->thread() == thread())
+        QCoreApplication::removePostedEvents(app, QEvent::Quit);
 
 #if defined(QT_NO_EXCEPTIONS)
     while (!d->exit)
diff --git a/src/corelib/kernel/qvariant.cpp b/src/corelib/kernel/qvariant.cpp
index b4427c0..b53e91f 100644
--- a/src/corelib/kernel/qvariant.cpp
+++ b/src/corelib/kernel/qvariant.cpp
@@ -71,27 +71,6 @@ QT_BEGIN_NAMESPACE
 #  define FLT_DIG 6
 #endif
 
-
-static const void *constDataHelper(const QVariant::Private &d)
-{
-    switch (d.type) {
-    case QVariant::Int:
-        return &d.data.i;
-    case QVariant::UInt:
-        return &d.data.u;
-    case QVariant::Bool:
-        return &d.data.b;
-    case QVariant::LongLong:
-        return &d.data.ll;
-    case QVariant::ULongLong:
-        return &d.data.ull;
-    case QVariant::Double:
-        return &d.data.d;
-    default:
-        return d.is_shared ? d.data.shared->ptr : reinterpret_cast<const void *>(&d.data.ptr);
-    }
-}
-
 static void construct(QVariant::Private *x, const void *copy)
 {
     x->is_shared = false;
@@ -179,6 +158,9 @@ static void construct(QVariant::Private *x, const void *copy)
     case QVariant::Double:
         x->data.d = copy ? *static_cast<const double*>(copy) : 0.0;
         break;
+    case QMetaType::Float:
+        x->data.f = copy ? *static_cast<const float*>(copy) : 0.0f;
+        break;
     case QVariant::LongLong:
         x->data.ll = copy ? *static_cast<const qlonglong *>(copy) : Q_INT64_C(0);
         break;
@@ -274,6 +256,7 @@ static void clear(QVariant::Private *d)
     case QVariant::LongLong:
     case QVariant::ULongLong:
     case QVariant::Double:
+    case QMetaType::Float:
         break;
     case QVariant::Invalid:
     case QVariant::UserType:
@@ -342,6 +325,7 @@ static bool isNull(const QVariant::Private *d)
     case QVariant::ULongLong:
     case QVariant::Bool:
     case QVariant::Double:
+    case QMetaType::Float:
         break;
     }
     return d->is_null;
@@ -433,6 +417,8 @@ static bool compare(const QVariant::Private *a, const QVariant::Private *b)
         return a->data.b == b->data.b;
     case QVariant::Double:
         return a->data.d == b->data.d;
+    case QMetaType::Float:
+        return a->data.f == b->data.f;
     case QVariant::Date:
         return *v_cast<QDate>(a) == *v_cast<QDate>(b);
     case QVariant::Time:
@@ -491,7 +477,7 @@ static qlonglong qMetaTypeNumber(const QVariant::Private *d)
     case QMetaType::Long:
         return qlonglong(*static_cast<long *>(d->data.shared->ptr));
     case QMetaType::Float:
-        return qRound64(*static_cast<float *>(d->data.shared->ptr));
+        return qRound64(d->data.f);
     case QVariant::Double:
         return qRound64(d->data.d);
     }
@@ -628,7 +614,7 @@ static bool convert(const QVariant::Private *d, QVariant::Type t, void *result,
             *str = QString::number(qMetaTypeUNumber(d));
             break;
         case QMetaType::Float:
-            *str = QString::number(*static_cast<float *>(d->data.shared->ptr), 'g', FLT_DIG);
+            *str = QString::number(d->data.f, 'g', FLT_DIG);
             break;
         case QVariant::Double:
             *str = QString::number(d->data.d, 'g', DBL_DIG);
@@ -799,7 +785,7 @@ static bool convert(const QVariant::Private *d, QVariant::Type t, void *result,
             *ba = QByteArray::number(d->data.d, 'g', DBL_DIG);
             break;
         case QMetaType::Float:
-            *ba = QByteArray::number(*static_cast<float *>(d->data.shared->ptr), 'g', FLT_DIG);
+            *ba = QByteArray::number(d->data.f, 'g', FLT_DIG);
             break;
         case QMetaType::Char:
         case QMetaType::UChar:
@@ -901,7 +887,7 @@ static bool convert(const QVariant::Private *d, QVariant::Type t, void *result,
             *f = double(d->data.b);
             break;
         case QMetaType::Float:
-            *f = *static_cast<float *>(d->data.shared->ptr);
+            *f = double(d->data.f);
             break;
         case QVariant::LongLong:
         case QVariant::Int:
@@ -1355,7 +1341,7 @@ void QVariant::create(int type, const void *copy)
 
 QVariant::~QVariant()
 {
-    if (d.type > Char && (!d.is_shared || !d.data.shared->ref.deref()))
+    if (d.type > Char && d.type != QMetaType::Float && (!d.is_shared || !d.data.shared->ref.deref()))
         handler->clear(&d);
 }
 
@@ -1371,7 +1357,7 @@ QVariant::QVariant(const QVariant &p)
 {
     if (d.is_shared) {
         d.data.shared->ref.ref();
-    } else if (p.d.type > Char) {
+    } else if (p.d.type > Char && p.d.type != QMetaType::Float) {
         handler->construct(&d, p.constData());
         d.is_null = p.d.is_null;
     }
@@ -1565,6 +1551,12 @@ QVariant::QVariant(const char *val)
 */
 
 /*!
+  \fn QVariant::QVariant(float val)
+
+    Constructs a new variant with a floating point value, \a val.
+*/
+
+/*!
     \fn QVariant::QVariant(const QList<QVariant> &val)
 
     Constructs a new variant with a list value, \a val.
@@ -1619,44 +1611,44 @@ QVariant::QVariant(double val)
 { d.is_null = false; d.type = Double; d.data.d = val; }
 
 QVariant::QVariant(const QByteArray &val)
-{ create(ByteArray, &val); }
+{ d.is_null = false; d.type = ByteArray; v_construct<QByteArray>(&d, val); }
 QVariant::QVariant(const QBitArray &val)
-{ create(BitArray, &val); }
+{ d.is_null = false; d.type = BitArray; v_construct<QBitArray>(&d, val);  }
 QVariant::QVariant(const QString &val)
-{ create(String, &val); }
+{ d.is_null = false; d.type = String; v_construct<QString>(&d, val);  }
 QVariant::QVariant(const QChar &val)
-{ create (Char, &val); }
+{ d.is_null = false; d.type = Char; v_construct<QChar>(&d, val);  }
 QVariant::QVariant(const QLatin1String &val)
-{ QString str(val); create(String, &str); }
+{ QString str(val); d.is_null = false; d.type = String; v_construct<QString>(&d, str); }
 QVariant::QVariant(const QStringList &val)
-{ create(StringList, &val); }
+{ d.is_null = false; d.type = StringList; v_construct<QStringList>(&d, val); }
 
 QVariant::QVariant(const QDate &val)
-{ create(Date, &val); }
+{ d.is_null = false; d.type = Date; v_construct<QDate>(&d, val); }
 QVariant::QVariant(const QTime &val)
-{ create(Time, &val); }
+{ d.is_null = false; d.type = Time; v_construct<QTime>(&d, val); }
 QVariant::QVariant(const QDateTime &val)
-{ create(DateTime, &val); }
+{ d.is_null = false; d.type = DateTime; v_construct<QDateTime>(&d, val); }
 QVariant::QVariant(const QList<QVariant> &list)
-{ create(List, &list); }
+{ d.is_null = false; d.type = List; v_construct<QVariantList>(&d, list); }
 QVariant::QVariant(const QMap<QString, QVariant> &map)
-{ create(Map, &map); }
+{ d.is_null = false; d.type = Map; v_construct<QVariantMap>(&d, map); }
 QVariant::QVariant(const QHash<QString, QVariant> &hash)
-{ create(Hash, &hash); }
+{ d.is_null = false; d.type = Hash; v_construct<QVariantHash>(&d, hash); }
 #ifndef QT_NO_GEOM_VARIANT
-QVariant::QVariant(const QPoint &pt) { create(Point, &pt); }
-QVariant::QVariant(const QPointF &pt) { create (PointF, &pt); }
-QVariant::QVariant(const QRectF &r) { create (RectF, &r); }
-QVariant::QVariant(const QLineF &l) { create (LineF, &l); }
-QVariant::QVariant(const QLine &l) { create (Line, &l); }
-QVariant::QVariant(const QRect &r) { create(Rect, &r); }
-QVariant::QVariant(const QSize &s) { create(Size, &s); }
-QVariant::QVariant(const QSizeF &s) { create(SizeF, &s); }
+QVariant::QVariant(const QPoint &pt) { d.is_null = false; d.type = Point; v_construct<QPoint>(&d, pt); }
+QVariant::QVariant(const QPointF &pt) { d.is_null = false; d.type = PointF; v_construct<QPointF>(&d, pt); }
+QVariant::QVariant(const QRectF &r) { d.is_null = false; d.type = RectF; v_construct<QRectF>(&d, r); }
+QVariant::QVariant(const QLineF &l) { d.is_null = false; d.type = LineF; v_construct<QLineF>(&d, l); }
+QVariant::QVariant(const QLine &l) { d.is_null = false; d.type = Line; v_construct<QLine>(&d, l); }
+QVariant::QVariant(const QRect &r) { d.is_null = false; d.type = Rect; v_construct<QRect>(&d, r); }
+QVariant::QVariant(const QSize &s) { d.is_null = false; d.type = Size; v_construct<QSize>(&d, s); }
+QVariant::QVariant(const QSizeF &s) { d.is_null = false; d.type = SizeF; v_construct<QSizeF>(&d, s); }
 #endif
-QVariant::QVariant(const QUrl &u) { create(Url, &u); }
-QVariant::QVariant(const QLocale &l) { create(Locale, &l); }
+QVariant::QVariant(const QUrl &u) { d.is_null = false; d.type = Url; v_construct<QUrl>(&d, u); }
+QVariant::QVariant(const QLocale &l) { d.is_null = false; d.type = Locale; v_construct<QLocale>(&d, l); }
 #ifndef QT_NO_REGEXP
-QVariant::QVariant(const QRegExp &regExp) { create(RegExp, &regExp); }
+QVariant::QVariant(const QRegExp &regExp) { d.is_null = false; d.type = RegExp; v_construct<QRegExp>(&d, regExp); }
 #endif
 QVariant::QVariant(Qt::GlobalColor color) { create(62, &color); }
 
@@ -1721,7 +1713,7 @@ QVariant& QVariant::operator=(const QVariant &variant)
     if (variant.d.is_shared) {
         variant.d.data.shared->ref.ref();
         d = variant.d;
-    } else if (variant.d.type > Char) {
+    } else if (variant.d.type > Char && variant.d.type != QMetaType::Float) {
         d.type = variant.d.type;
         handler->construct(&d, variant.constData());
         d.is_null = variant.d.is_null;
@@ -1907,7 +1899,7 @@ void QVariant::load(QDataStream &s)
     }
 
     // const cast is safe since we operate on a newly constructed variant
-    if (!QMetaType::load(s, d.type, const_cast<void *>(constDataHelper(d)))) {
+    if (!QMetaType::load(s, d.type, const_cast<void *>(constData()))) {
         s.setStatus(QDataStream::ReadCorruptData);
         qWarning("QVariant::load: unable to load type %d.", d.type);
     }
@@ -1947,7 +1939,7 @@ void QVariant::save(QDataStream &s) const
         return;
     }
 
-    if (!QMetaType::save(s, d.type, constDataHelper(d))) {
+    if (!QMetaType::save(s, d.type, constData())) {
         Q_ASSERT_X(false, "QVariant::save", "Invalid type to save");
         qWarning("QVariant::save: unable to save type %d.", d.type);
     }
@@ -2565,57 +2557,63 @@ static const quint32 qCanConvertMatrix[QVariant::LastCoreType + 1] =
 */
 bool QVariant::canConvert(Type t) const
 {
-    if (d.type == uint(t))
+    //we can treat floats as double
+    //the reason for not doing it the "proper" way is that QMetaType::Float's value is 135,
+    //which can't be handled by qCanConvertMatrix
+    //In addition QVariant::Type doesn't have a Float value, so we're using QMetaType::Float
+    const uint currentType = ((d.type == QMetaType::Float) ? QVariant::Double : d.type);
+    if (uint(t) == uint(QMetaType::Float)) t = QVariant::Double;
+
+    if (currentType == uint(t))
         return true;
 
-    if (d.type > QVariant::LastCoreType || t > QVariant::LastCoreType) {
+    if (currentType > QVariant::LastCoreType || t > QVariant::LastCoreType) {
         switch (uint(t)) {
         case QVariant::Int:
-            return d.type == QVariant::KeySequence
-                   || d.type == QMetaType::ULong
-                   || d.type == QMetaType::Long
-                   || d.type == QMetaType::UShort
-                   || d.type == QMetaType::UChar
-                   || d.type == QMetaType::Char
-                   || d.type == QMetaType::Short;
+            return currentType == QVariant::KeySequence
+                   || currentType == QMetaType::ULong
+                   || currentType == QMetaType::Long
+                   || currentType == QMetaType::UShort
+                   || currentType == QMetaType::UChar
+                   || currentType == QMetaType::Char
+                   || currentType == QMetaType::Short;
         case QVariant::Image:
-            return d.type == QVariant::Pixmap || d.type == QVariant::Bitmap;
+            return currentType == QVariant::Pixmap || currentType == QVariant::Bitmap;
         case QVariant::Pixmap:
-            return d.type == QVariant::Image || d.type == QVariant::Bitmap
-                              || d.type == QVariant::Brush;
+            return currentType == QVariant::Image || currentType == QVariant::Bitmap
+                              || currentType == QVariant::Brush;
         case QVariant::Bitmap:
-            return d.type == QVariant::Pixmap || d.type == QVariant::Image;
+            return currentType == QVariant::Pixmap || currentType == QVariant::Image;
         case QVariant::ByteArray:
-            return d.type == QVariant::Color;
+            return currentType == QVariant::Color;
         case QVariant::String:
-            return d.type == QVariant::KeySequence || d.type == QVariant::Font
-                              || d.type == QVariant::Color;
+            return currentType == QVariant::KeySequence || currentType == QVariant::Font
+                              || currentType == QVariant::Color;
         case QVariant::KeySequence:
-            return d.type == QVariant::String || d.type == QVariant::Int;
+            return currentType == QVariant::String || currentType == QVariant::Int;
         case QVariant::Font:
-            return d.type == QVariant::String;
+            return currentType == QVariant::String;
         case QVariant::Color:
-            return d.type == QVariant::String || d.type == QVariant::ByteArray
-                              || d.type == QVariant::Brush;
+            return currentType == QVariant::String || currentType == QVariant::ByteArray
+                              || currentType == QVariant::Brush;
         case QVariant::Brush:
-            return d.type == QVariant::Color || d.type == QVariant::Pixmap;
+            return currentType == QVariant::Color || currentType == QVariant::Pixmap;
         case QMetaType::Long:
         case QMetaType::Char:
         case QMetaType::UChar:
         case QMetaType::ULong:
         case QMetaType::Short:
         case QMetaType::UShort:
-        case QMetaType::Float:
-            return qCanConvertMatrix[QVariant::Int] & (1 << d.type) || d.type == QVariant::Int;
+            return qCanConvertMatrix[QVariant::Int] & (1 << currentType) || currentType == QVariant::Int;
         default:
             return false;
         }
     }
 
-    if(t == String && d.type == StringList)
+    if(t == String && currentType == StringList)
         return v_cast<QStringList>(&d)->count() == 1;
     else
-        return qCanConvertMatrix[t] & (1 << d.type);
+        return qCanConvertMatrix[t] & (1 << currentType);
 }
 
 /*!
@@ -2726,7 +2724,7 @@ bool QVariant::cmp(const QVariant &v) const
 
 const void *QVariant::constData() const
 {
-    return constDataHelper(d);
+    return d.is_shared ? d.data.shared->ptr : reinterpret_cast<const void *>(&d.data.ptr);
 }
 
 /*!
@@ -2739,7 +2737,7 @@ const void *QVariant::constData() const
 void* QVariant::data()
 {
     detach();
-    return const_cast<void *>(constDataHelper(d));
+    return const_cast<void *>(constData());
 }
 
 
diff --git a/src/corelib/kernel/qvariant.h b/src/corelib/kernel/qvariant.h
index 580b101..d73fcbc 100644
--- a/src/corelib/kernel/qvariant.h
+++ b/src/corelib/kernel/qvariant.h
@@ -128,7 +128,7 @@ class Q_CORE_EXPORT QVariant
         LineF = 24,
         Point = 25,
         PointF = 26,
-        RegExp = 27,
+	RegExp = 27,
         Hash = 28,
         LastCoreType = Hash,
 
@@ -181,6 +181,7 @@ class Q_CORE_EXPORT QVariant
     QVariant(qulonglong ull);
     QVariant(bool b);
     QVariant(double d);
+    QVariant(float f) { d.is_null = false; d.type = QMetaType::Float; d.data.f = f; }
 #ifndef QT_NO_CAST_FROM_ASCII
     QT_ASCII_CAST_WARN_CONSTRUCTOR QVariant(const char *str);
 #endif
@@ -349,6 +350,7 @@ class Q_CORE_EXPORT QVariant
             uint u;
             bool b;
             double d;
+            float f;
             qlonglong ll;
             qulonglong ull;
             void *ptr;
@@ -443,7 +445,18 @@ inline QVariant qVariantFromValue(const QVariant &t) { return t; }
 template <typename T>
 inline void qVariantSetValue(QVariant &v, const T &t)
 {
-    v = QVariant(qMetaTypeId<T>(reinterpret_cast<T *>(0)), &t);
+    //if possible we reuse the current QVariant private
+    const int type = qMetaTypeId<T>(reinterpret_cast<T *>(0));
+    QVariant::Private &d = v.data_ptr();
+    if (type <= int(QVariant::Char) || (type == d.type && v.isDetached())) {
+        d.type = type;
+        T *old = reinterpret_cast<T*>(d.is_shared ? d.data.shared->ptr : &d.data.ptr);
+        if (QTypeInfo<T>::isComplex)
+            old->~T();
+        new (old) T(t); //call the copy constructor
+    } else {
+        v = QVariant(type, &t);
+    }
 }
 
 inline QVariant::QVariant() {}
diff --git a/src/corelib/kernel/qvariant_p.h b/src/corelib/kernel/qvariant_p.h
index 0764fe3..074575b 100644
--- a/src/corelib/kernel/qvariant_p.h
+++ b/src/corelib/kernel/qvariant_p.h
@@ -60,8 +60,6 @@
 
 QT_BEGIN_NAMESPACE
 
-extern Q_CORE_EXPORT const QVariant::Handler *qExtendedVariantHandler;
-
 #ifdef Q_CC_SUN // Sun CC picks the wrong overload, so introduce awful hack
 
 template <typename T>
@@ -70,7 +68,7 @@ inline T *v_cast(const QVariant::Private *nd, T * = 0)
     QVariant::Private *d = const_cast<QVariant::Private *>(nd);
     return ((sizeof(T) > sizeof(QVariant::Private::Data))
             ? static_cast<T *>(d->data.shared->ptr)
-            : reinterpret_cast<T*>(&d->data.c));
+            : static_cast<T *>(static_cast<void *>(&d->data.c)));
 }
 
 #else // every other compiler in this world
@@ -80,7 +78,7 @@ inline const T *v_cast(const QVariant::Private *d, T * = 0)
 {
     return ((sizeof(T) > sizeof(QVariant::Private::Data))
             ? static_cast<const T *>(d->data.shared->ptr)
-            : reinterpret_cast<const T *>(&d->data.c));
+            : static_cast<const T *>(static_cast<const void *>(&d->data.c)));
 }
 
 template <typename T>
@@ -88,15 +86,17 @@ inline T *v_cast(QVariant::Private *d, T * = 0)
 {
     return ((sizeof(T) > sizeof(QVariant::Private::Data))
             ? static_cast<T *>(d->data.shared->ptr)
-            : reinterpret_cast<T *>(&d->data.c));
+            : static_cast<T *>(static_cast<void *>(&d->data.c)));
 }
 
 #endif
 
-//a simple template that avoids to allocate 2 buffers when creating a QVariant
+
+//a simple template that avoids to allocate 2 memory chunks when creating a QVariant
 template <class T> class QVariantPrivateSharedEx : public QVariant::PrivateShared
 {
 public:
+    QVariantPrivateSharedEx() : QVariant::PrivateShared(&m_t) { }
     QVariantPrivateSharedEx(const T&t) : QVariant::PrivateShared(&m_t), m_t(t) { }
 
 private:
@@ -105,14 +105,12 @@ private:
 
 // constructs a new variant if copy is 0, otherwise copy-constructs
 template <class T>
-inline void v_construct(QVariant::Private *x, const T& t)
+inline void v_construct(QVariant::Private *x, const T &t)
 {
-    x->type = qMetaTypeId<T>(reinterpret_cast<T *>(0));
     if (sizeof(T) > sizeof(QVariant::Private::Data)) {
         x->data.shared = new QVariantPrivateSharedEx<T>(t);
         x->is_shared = true;
     } else {
-        x->is_shared = false;
         new (&x->data.ptr) T(t);
     }
 }
@@ -120,24 +118,31 @@ inline void v_construct(QVariant::Private *x, const T& t)
 template <class T>
 inline void v_construct(QVariant::Private *x, const void *copy, T * = 0)
 {
-    if (copy) {
-      v_construct<T>(x, *reinterpret_cast<const T*>(copy));
+    if (sizeof(T) > sizeof(QVariant::Private::Data)) {
+        x->data.shared = copy ? new QVariantPrivateSharedEx<T>(*static_cast<const T *>(copy))
+                              : new QVariantPrivateSharedEx<T>;
+        x->is_shared = true;
     } else {
-      T t;
-      v_construct<T>(x, t);
+        if (copy)
+            new (&x->data.ptr) T(*static_cast<const T *>(copy));
+        else
+            new (&x->data.ptr) T;
     }
 }
 
-
 // deletes the internal structures
 template <class T>
 inline void v_clear(QVariant::Private *d, T* = 0)
 {
-    //now we need to call the destructor in any case
-    //because QVariant::PrivateShared doesn't have a virtual destructor
-    v_cast<T>(d)->~T();
-    if (sizeof(T) > sizeof(QVariant::Private::Data))
-        delete d->data.shared;
+
+    if (sizeof(T) > sizeof(QVariant::Private::Data)) {
+        //now we need to cast
+        //because QVariant::PrivateShared doesn't have a virtual destructor
+        delete static_cast<QVariantPrivateSharedEx<T>*>(d->data.shared);
+    } else {
+        v_cast<T>(d)->~T();
+    }
+
 }
 
 QT_END_NAMESPACE
diff --git a/src/corelib/thread/qthread_unix.cpp b/src/corelib/thread/qthread_unix.cpp
index f602821..8f1c698 100644
--- a/src/corelib/thread/qthread_unix.cpp
+++ b/src/corelib/thread/qthread_unix.cpp
@@ -180,8 +180,7 @@ void *QThreadPrivate::start(void *arg)
     data->quitNow = false;
 
     // ### TODO: allow the user to create a custom event dispatcher
-    if (QCoreApplication::instance())
-        createEventDispatcher(data);
+    createEventDispatcher(data);
 
     emit thr->started();
     pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
diff --git a/src/corelib/thread/qthread_win.cpp b/src/corelib/thread/qthread_win.cpp
index 27193c6..7094e3d 100644
--- a/src/corelib/thread/qthread_win.cpp
+++ b/src/corelib/thread/qthread_win.cpp
@@ -292,8 +292,7 @@ unsigned int __stdcall QThreadPrivate::start(void *arg)
 
     data->quitNow = false;
     // ### TODO: allow the user to create a custom event dispatcher
-    if (QCoreApplication::instance())
-        createEventDispatcher(data);
+    createEventDispatcher(data);
 
 #if !defined(QT_NO_DEBUG) && defined(Q_CC_MSVC) && !defined(Q_OS_WINCE)
     // sets the name of the current thread.
diff --git a/src/corelib/tools/qbytearraymatcher.cpp b/src/corelib/tools/qbytearraymatcher.cpp
index cd4cf90..211d190 100644
--- a/src/corelib/tools/qbytearraymatcher.cpp
+++ b/src/corelib/tools/qbytearraymatcher.cpp
@@ -120,6 +120,7 @@ QByteArrayMatcher::QByteArrayMatcher()
     : d(0)
 {
     p.p = 0;
+    p.l = 0;
     qMemSet(p.q_skiptable, 0, sizeof(p.q_skiptable));
 }
 
@@ -170,7 +171,7 @@ QByteArrayMatcher::~QByteArrayMatcher()
 QByteArrayMatcher &QByteArrayMatcher::operator=(const QByteArrayMatcher &other)
 {
     q_pattern = other.q_pattern;
-    qMemCopy(p.q_skiptable, other.p.q_skiptable, sizeof(p.q_skiptable));
+    qMemCopy(&p, &other.p, sizeof(p));
     return *this;
 }
 
diff --git a/src/corelib/tools/qbytearraymatcher.h b/src/corelib/tools/qbytearraymatcher.h
index d7f2366..633e92c 100644
--- a/src/corelib/tools/qbytearraymatcher.h
+++ b/src/corelib/tools/qbytearraymatcher.h
@@ -67,7 +67,12 @@ public:
 
     int indexIn(const QByteArray &ba, int from = 0) const;
     int indexIn(const char *str, int len, int from = 0) const;
-    inline QByteArray pattern() const { return q_pattern; }
+    inline QByteArray pattern() const
+    {
+        if (q_pattern.isNull())
+            return QByteArray((const char*)p.p, p.l);
+        return q_pattern;
+    }
 
 private:
     QByteArrayMatcherPrivate *d;
diff --git a/src/gui/dialogs/qfiledialog.cpp b/src/gui/dialogs/qfiledialog.cpp
index d786f3e..073c25b 100644
--- a/src/gui/dialogs/qfiledialog.cpp
+++ b/src/gui/dialogs/qfiledialog.cpp
@@ -1538,52 +1538,51 @@ extern QString qt_win_get_existing_directory(const QFileDialogArgs &args);
 #endif
 
 /*!
-  This is a convenience static function that returns an existing file
-  selected by the user. If the user presses Cancel, it returns a null
-  string.
+    This is a convenience static function that returns an existing file
+    selected by the user. If the user presses Cancel, it returns a null string.
 
-  \snippet doc/src/snippets/code/src_gui_dialogs_qfiledialog.cpp 8
+    \snippet doc/src/snippets/code/src_gui_dialogs_qfiledialog.cpp 8
 
-  The function creates a modal file dialog with the given \a parent widget.
-  If the parent is not 0, the dialog will be shown centered over the
-  parent widget.
+    The function creates a modal file dialog with the given \a parent widget.
+    If \a parent is not 0, the dialog will be shown centered over the parent
+    widget.
 
-  The file dialog's working directory will be set to \a dir.  If \a
-  dir includes a file name, the file will be selected. Only files
-  that match the given \a filter are shown. The filter selected is
-  set to \a selectedFilter. The parameters \a dir, \a
-  selectedFilter, and \a filter may be empty strings. If you want
-  multiple filters, separate them with ';;', for example:
+    The file dialog's working directory will be set to \a dir. If \a dir
+    includes a file name, the file will be selected. Only files that match the
+    given \a filter are shown. The filter selected is set to \a selectedFilter.
+    The parameters \a dir, \a selectedFilter, and \a filter may be empty
+    strings. If you want multiple filters, separate them with ';;', for
+    example:
 
-  \code
+    \code
     "Images (*.png *.xpm *.jpg);;Text files (*.txt);;XML files (*.xml)"
-  \endcode
+    \endcode
 
-  The \a options argument holds various
-  options about how to run the dialog, see the QFileDialog::Option enum for
-  more information on the flags you can pass.
+    The \a options argument holds various options about how to run the dialog,
+    see the QFileDialog::Option enum for more information on the flags you can
+    pass.
 
-  The dialog's caption is set to \a caption. If \a caption is not
-  specified then a default caption will be used.
+    The dialog's caption is set to \a caption. If \a caption is not specified
+    then a default caption will be used.
 
-  Under Windows and Mac OS X, this static function will use the native
-  file dialog and not a QFileDialog.
+    On Windows and Mac OS X, this static function will use the native file
+    dialog and not a QFileDialog.
 
-  Note that on Windows the dialog will spin a blocking modal event loop
-  that will not dispatch any QTimers, and if parent is not 0 then it will
-  position the dialog just under the parent's title bar.
+    On Windows the dialog will spin a blocking modal event loop that will not
+    dispatch any QTimers, and if \a parent is not 0 then it will position the
+    dialog just below the parent's title bar.
 
-  Under Unix/X11, the normal behavior of the file dialog is to resolve
-  and follow symlinks. For example, if \c{/usr/tmp} is a symlink to
-  \c{/var/tmp}, the file dialog will change to \c{/var/tmp} after
-  entering \c{/usr/tmp}. If \a options includes DontResolveSymlinks,
-  the file dialog will treat symlinks as regular directories.
+    On Unix/X11, the normal behavior of the file dialog is to resolve and
+    follow symlinks. For example, if \c{/usr/tmp} is a symlink to \c{/var/tmp},
+    the file dialog will change to \c{/var/tmp} after entering \c{/usr/tmp}. If
+    \a options includes DontResolveSymlinks, the file dialog will treat
+    symlinks as regular directories.
 
-  \warning Do not delete \a parent during the execution of the dialog.
-           If you want to do this, you should create the dialog
-           yourself using one of the QFileDialog constructors.
+    \warning Do not delete \a parent during the execution of the dialog. If you
+    want to do this, you should create the dialog yourself using one of the
+    QFileDialog constructors.
 
-  \sa getOpenFileNames(), getSaveFileName(), getExistingDirectory()
+    \sa getOpenFileNames(), getSaveFileName(), getExistingDirectory()
 */
 QString QFileDialog::getOpenFileName(QWidget *parent,
                                const QString &caption,
@@ -1626,54 +1625,53 @@ QString QFileDialog::getOpenFileName(QWidget *parent,
 }
 
 /*!
-  This is a convenience static function that will return one or more
-  existing files selected by the user.
+    This is a convenience static function that will return one or more existing
+    files selected by the user.
 
-  \snippet doc/src/snippets/code/src_gui_dialogs_qfiledialog.cpp 9
+    \snippet doc/src/snippets/code/src_gui_dialogs_qfiledialog.cpp 9
 
-  This function creates a modal file dialog with the given \a parent
-  widget. If the parent is not 0, the dialog will be shown centered
-  over the parent widget.
+    This function creates a modal file dialog with the given \a parent widget.
+    If \a parent is not 0, the dialog will be shown centered over the parent
+    widget.
 
-  The file dialog's working directory will be set to \a dir. If \a
-  dir includes a file name, the file will be selected. The filter
-  is set to \a filter so that only those files which match the filter
-  are shown. The filter selected is set to \a selectedFilter. The parameters
-  \a dir, \a selectedFilter and \a filter may be empty strings. If you
-  need multiple filters, separate them with ';;', for instance:
+    The file dialog's working directory will be set to \a dir. If \a dir
+    includes a file name, the file will be selected. The filter is set to
+    \a filter so that only those files which match the filter are shown. The
+    filter selected is set to \a selectedFilter. The parameters \a dir,
+    \a selectedFilter and \a filter may be empty strings. If you need multiple
+    filters, separate them with ';;', for instance:
 
-  \code
+    \code
     "Images (*.png *.xpm *.jpg);;Text files (*.txt);;XML files (*.xml)"
-  \endcode
+    \endcode
 
-  The dialog's caption is set to \a caption. If \a caption is not
-  specified then a default caption will be used.
+    The dialog's caption is set to \a caption. If \a caption is not specified
+    then a default caption will be used.
 
-  Under Windows and Mac OS X, this static function will use the native
-  file dialog and not a QFileDialog. On Mac OS X, the \a dir argument
-  is ignored, the native dialog always displays the last visited directory.
+    On Windows and Mac OS X, this static function will use the native file
+    dialog and not a QFileDialog.
 
-  Note that on Windows the dialog will spin a blocking modal event loop
-  that will not dispatch any QTimers, and if parent is not 0 then it will
-  position the dialog just under the parent's title bar.
+    On Windows the dialog will spin a blocking modal event loop that will not
+    dispatch any QTimers, and if \a parent is not 0 then it will position the
+    dialog just below the parent's title bar.
 
-  Under Unix/X11, the normal behavior of the file dialog is to resolve
-  and follow symlinks. For example, if \c{/usr/tmp} is a symlink to
-  \c{/var/tmp}, the file dialog will change to \c{/var/tmp} after
-  entering \c{/usr/tmp}. The \a options argument holds various
-  options about how to run the dialog, see the QFileDialog::Option enum for
-  more information on the flags you can pass.
+    On Unix/X11, the normal behavior of the file dialog is to resolve and
+    follow symlinks. For example, if \c{/usr/tmp} is a symlink to \c{/var/tmp},
+    the file dialog will change to \c{/var/tmp} after entering \c{/usr/tmp}.
+    The \a options argument holds various options about how to run the dialog,
+    see the QFileDialog::Option enum for more information on the flags you can
+    pass.
 
-  Note that if you want to iterate over the list of files, you should
-  iterate over a copy. For example:
+    \note If you want to iterate over the list of files, you should iterate
+    over a copy. For example:
 
     \snippet doc/src/snippets/code/src_gui_dialogs_qfiledialog.cpp 10
 
-  \warning Do not delete \a parent during the execution of the dialog.
-           If you want to do this, you should create the dialog
-           yourself using one of the QFileDialog constructors.
+    \warning Do not delete \a parent during the execution of the dialog. If you
+    want to do this, you should create the dialog yourself using one of the
+    QFileDialog constructors.
 
-  \sa getOpenFileName(), getSaveFileName(), getExistingDirectory()
+    \sa getOpenFileName(), getSaveFileName(), getExistingDirectory()
 */
 QStringList QFileDialog::getOpenFileNames(QWidget *parent,
                                           const QString &caption,
@@ -1717,54 +1715,54 @@ QStringList QFileDialog::getOpenFileNames(QWidget *parent,
 }
 
 /*!
-  This is a convenience static function that will return a file name
-  selected by the user. The file does not have to exist.
+    This is a convenience static function that will return a file name selected
+    by the user. The file does not have to exist.
 
-  It creates a modal file dialog with the given \a parent widget. If the
-  parent is not 0, the dialog will be shown centered over the parent
-  widget.
+    It creates a modal file dialog with the given \a parent widget. If
+    \a parent is not 0, the dialog will be shown centered over the parent
+    widget.
 
-  \snippet doc/src/snippets/code/src_gui_dialogs_qfiledialog.cpp 11
+    \snippet doc/src/snippets/code/src_gui_dialogs_qfiledialog.cpp 11
 
-  The file dialog's working directory will be set to \a dir. If \a
-  dir includes a file name, the file will be selected. Only files that
-  match the \a filter are shown. The filter selected is set to
-  \a selectedFilter. The parameters \a dir, \a selectedFilter, and
-  \a filter may be empty strings. Multiple filters are separated with ';;'.
-  For instance:
+    The file dialog's working directory will be set to \a dir. If \a dir
+    includes a file name, the file will be selected. Only files that match the
+    \a filter are shown. The filter selected is set to \a selectedFilter. The
+    parameters \a dir, \a selectedFilter, and \a filter may be empty strings.
+    Multiple filters are separated with ';;'. For instance:
 
-  \code
+    \code
     "Images (*.png *.xpm *.jpg);;Text files (*.txt);;XML files (*.xml)"
-  \endcode
+    \endcode
 
-  The \a options argument holds various
-  options about how to run the dialog, see the QFileDialog::Option enum for
-  more information on the flags you can pass.
+    The \a options argument holds various options about how to run the dialog,
+    see the QFileDialog::Option enum for more information on the flags you can
+    pass.
 
-  The default filter can be chosen by setting \a selectedFilter to the desired value.
+    The default filter can be chosen by setting \a selectedFilter to the
+    desired value.
 
-  The dialog's caption is set to \a caption. If \a caption is not
-  specified then a default caption will be used.
+    The dialog's caption is set to \a caption. If \a caption is not specified,
+    a default caption will be used.
 
-  Under Windows and Mac OS X, this static function will use the native
-  file dialog and not a QFileDialog.
+    On Windows and Mac OS X, this static function will use the native file
+    dialog and not a QFileDialog.
 
-  Note that on Windows the dialog will spin a blocking modal event loop
-  that will not dispatch any QTimers, and if parent is not 0 then it will
-  position the dialog just under the parent's title bar.
-  On Mac OS X, the filter argument is ignored.
+    On Windows the dialog will spin a blocking modal event loop that will not
+    dispatch any QTimers, and if \a parent is not 0 then it will position the
+    dialog just below the parent's title bar. On Mac OS X, with its native file
+    dialog, the filter argument is ignored.
 
-  Under Unix/X11, the normal behavior of the file dialog is to resolve
-  and follow symlinks. For example, if \c{/usr/tmp} is a symlink to
-  \c{/var/tmp}, the file dialog will change to \c{/var/tmp} after
-  entering \c{/usr/tmp}. If \a options includes DontResolveSymlinks,
-  the file dialog will treat symlinks as regular directories.
+    On Unix/X11, the normal behavior of the file dialog is to resolve and
+    follow symlinks. For example, if \c{/usr/tmp} is a symlink to \c{/var/tmp},
+    the file dialog will change to \c{/var/tmp} after entering \c{/usr/tmp}. If
+    \a options includes DontResolveSymlinks the file dialog will treat symlinks
+    as regular directories.
 
-  \warning Do not delete \a parent during the execution of the dialog.
-           If you want to do this, you should create the dialog
-           yourself using one of the QFileDialog constructors.
+    \warning Do not delete \a parent during the execution of the dialog. If you
+    want to do this, you should create the dialog yourself using one of the
+    QFileDialog constructors.
 
-  \sa getOpenFileName(), getOpenFileNames(), getExistingDirectory()
+    \sa getOpenFileName(), getOpenFileNames(), getExistingDirectory()
 */
 QString QFileDialog::getSaveFileName(QWidget *parent,
                                      const QString &caption,
@@ -1810,46 +1808,43 @@ QString QFileDialog::getSaveFileName(QWidget *parent,
 }
 
 /*!
-  This is a convenience static function that will return an existing
-  directory selected by the user.
+    This is a convenience static function that will return an existing
+    directory selected by the user.
 
-  \snippet doc/src/snippets/code/src_gui_dialogs_qfiledialog.cpp 12
+    \snippet doc/src/snippets/code/src_gui_dialogs_qfiledialog.cpp 12
 
-  This function creates a modal file dialog with the given \a parent
-  widget. If the parent is not 0, the dialog will be shown centered over
-  the parent widget.
+    This function creates a modal file dialog with the given \a parent widget.
+    If \a parent is not 0, the dialog will be shown centered over the parent
+    widget.
 
-  The dialog's working directory is set to \a dir, and the caption is
-  set to \a caption. Either of these may be an empty string in which case
-  the current directory and a default caption will be used
-  respectively.
+    The dialog's working directory is set to \a dir, and the caption is set to
+    \a caption. Either of these may be an empty string in which case the
+    current directory and a default caption will be used respectively.
 
-  The \a options argument holds various
-  options about how to run the dialog, see the QFileDialog::Option enum for
-  more information on the flags you can pass. Note that \l{QFileDialog::}{ShowDirsOnly}
-  must be set to ensure a native file dialog.
+    The \a options argument holds various options about how to run the dialog,
+    see the QFileDialog::Option enum for more information on the flags you can
+    pass. To ensure a native file dialog, \l{QFileDialog::}{ShowDirsOnly} must
+    be set.
 
-  Under Windows and Mac OS X, this static function will use the native
-  file dialog and not a QFileDialog. On Mac OS X, the \a dir argument
-  is ignored, the native dialog always displays the last visited directory.
-  On Windows CE, if the device has no native file dialog, a QFileDialog
-  will be used.
+    On Windows and Mac OS X, this static function will use the native file
+    dialog and not a QFileDialog. On Windows CE, if the device has no native
+    file dialog, a QFileDialog will be used.
 
-  Under Unix/X11, the normal behavior of the file dialog is to resolve
-  and follow symlinks. For example, if \c{/usr/tmp} is a symlink to
-  \c{/var/tmp}, the file dialog will change to \c{/var/tmp} after
-  entering \c{/usr/tmp}. If \a options includes DontResolveSymlinks,
-  the file dialog will treat symlinks as regular directories.
+    On Unix/X11, the normal behavior of the file dialog is to resolve and
+    follow symlinks. For example, if \c{/usr/tmp} is a symlink to \c{/var/tmp},
+    the file dialog will change to \c{/var/tmp} after entering \c{/usr/tmp}. If
+    \a options includes DontResolveSymlinks, the file dialog will treat
+    symlinks as regular directories.
 
-  Note that on Windows the dialog will spin a blocking modal event loop
-  that will not dispatch any QTimers, and if parent is not 0 then it will
-  position the dialog just under the parent's title bar.
+    On Windows the dialog will spin a blocking modal event loop that will not
+    dispatch any QTimers, and if \a parent is not 0 then it will position the
+    dialog just below the parent's title bar.
 
-  \warning Do not delete \a parent during the execution of the dialog.
-           If you want to do this, you should create the dialog
-           yourself using one of the QFileDialog constructors.
+    \warning Do not delete \a parent during the execution of the dialog. If you
+    want to do this, you should create the dialog yourself using one of the
+    QFileDialog constructors.
 
-  \sa getOpenFileName(), getOpenFileNames(), getSaveFileName()
+    \sa getOpenFileName(), getOpenFileNames(), getSaveFileName()
 */
 QString QFileDialog::getExistingDirectory(QWidget *parent,
                                           const QString &caption,
diff --git a/src/gui/dialogs/qfilesystemmodel_p.h b/src/gui/dialogs/qfilesystemmodel_p.h
index 0a1265a..61e8b4c 100644
--- a/src/gui/dialogs/qfilesystemmodel_p.h
+++ b/src/gui/dialogs/qfilesystemmodel_p.h
@@ -164,9 +164,12 @@ public:
             QHash<QString, QFileSystemNode *>::const_iterator iterator;
             for(iterator = children.constBegin() ; iterator != children.constEnd() ; ++iterator) {
                 //On windows the root (My computer) has no path so we don't want to add a / for nothing (e.g. /C:/)
-                if (!path.isEmpty())
-                    iterator.value()->updateIcon(iconProvider, path + QLatin1Char('/') + iterator.value()->fileName);
-                else
+                if (!path.isEmpty()) {
+                    if (path.endsWith(QLatin1Char('/')))
+                        iterator.value()->updateIcon(iconProvider, path + iterator.value()->fileName);
+                    else
+                        iterator.value()->updateIcon(iconProvider, path + QLatin1Char('/') + iterator.value()->fileName);
+                } else
                     iterator.value()->updateIcon(iconProvider, iterator.value()->fileName);
             }
         }
@@ -177,9 +180,12 @@ public:
             QHash<QString, QFileSystemNode *>::const_iterator iterator;
             for(iterator = children.constBegin() ; iterator != children.constEnd() ; ++iterator) {
                 //On windows the root (My computer) has no path so we don't want to add a / for nothing (e.g. /C:/)
-                if (!path.isEmpty())
-                    iterator.value()->retranslateStrings(iconProvider, path + QLatin1Char('/') + iterator.value()->fileName);
-                else
+                if (!path.isEmpty()) {
+                    if (path.endsWith(QLatin1Char('/')))
+                        iterator.value()->retranslateStrings(iconProvider, path + iterator.value()->fileName);
+                    else
+                        iterator.value()->retranslateStrings(iconProvider, path + QLatin1Char('/') + iterator.value()->fileName);
+                } else
                     iterator.value()->retranslateStrings(iconProvider, iterator.value()->fileName);
             }
         }
diff --git a/src/gui/dialogs/qfontdialog_mac.mm b/src/gui/dialogs/qfontdialog_mac.mm
index 42be3be..50917a1 100644
--- a/src/gui/dialogs/qfontdialog_mac.mm
+++ b/src/gui/dialogs/qfontdialog_mac.mm
@@ -87,7 +87,6 @@ const int StyleMask = NSTitledWindowMask | NSClosableWindowMask | NSResizableWin
     NSButton *mOkButton;
     NSButton *mCancelButton;
     QFontDialogPrivate *mPriv;
-    NSFont *mCocoaFont;
     QFont *mQtFont;
     BOOL mPanelHackedWithButtons;
     CGFloat mDialogExtraWidth;
@@ -119,6 +118,29 @@ const int StyleMask = NSTitledWindowMask | NSClosableWindowMask | NSResizableWin
 - (void)cleanUpAfterMyself;
 @end
 
+static QFont qfontForCocoaFont(NSFont *cocoaFont, const QFont &resolveFont)
+{
+    QFont newFont;
+    if (cocoaFont) {
+        int pSize = qRound([cocoaFont pointSize]);
+        QString family(QCFString::toQString(reinterpret_cast<CFStringRef>([cocoaFont familyName])));
+        QString typeface(QCFString::toQString(reinterpret_cast<CFStringRef>([cocoaFont fontName])));
+//        qDebug() << "original family" << family << "typeface" << typeface << "psize" << pSize;
+        int hyphenPos = typeface.indexOf(QLatin1Char('-'));
+        if (hyphenPos != -1) {
+            typeface.remove(0, hyphenPos + 1);
+        } else {
+            typeface = QLatin1String("Normal");
+        }
+//        qDebug() << " massaged family" << family << "typeface" << typeface << "psize" << pSize;
+        newFont = QFontDatabase().font(family, typeface, pSize);
+        newFont.setUnderline(resolveFont.underline());
+        newFont.setStrikeOut(resolveFont.strikeOut());
+
+    }
+    return newFont;
+}
+
 @implementation QCocoaFontPanelDelegate
 - (id)initWithFontPanel:(NSFontPanel *)panel
        stolenContentView:(NSView *)stolenContentView
@@ -134,7 +156,6 @@ const int StyleMask = NSTitledWindowMask | NSClosableWindowMask | NSResizableWin
     mOkButton = okButton;
     mCancelButton = cancelButton;
     mPriv = priv;
-    mCocoaFont = 0;
     mPanelHackedWithButtons = (okButton != 0);
     mDialogExtraWidth = extraWidth;
     mDialogExtraHeight = extraHeight;
@@ -155,42 +176,14 @@ const int StyleMask = NSTitledWindowMask | NSClosableWindowMask | NSResizableWin
 
 - (void)dealloc
 {
-    if (mCocoaFont)
-        [mCocoaFont release];
     delete mQtFont;
     [super dealloc];
 }
 
 - (void)changeFont:(id)sender
 {
-    Q_UNUSED(sender);
-
-    QFont newFont;
-
-    if (mCocoaFont)
-        [mCocoaFont autorelease];
     NSFont *dummyFont = [NSFont userFontOfSize:12.0];
-    mCocoaFont = [sender convertFont:dummyFont];
-    if (mCocoaFont) {
-        [mCocoaFont retain];
-
-        int pSize = qRound([mCocoaFont pointSize]);
-        QString family(QCFString::toQString(reinterpret_cast<CFStringRef>([mCocoaFont familyName])));
-        QString typeface(QCFString::toQString(reinterpret_cast<CFStringRef>([mCocoaFont fontName])));
-//        qDebug() << "original family" << family << "typeface" << typeface << "psize" << pSize;
-        int hyphenPos = typeface.indexOf(QLatin1Char('-'));
-        if (hyphenPos != -1) {
-            typeface.remove(0, hyphenPos + 1);
-        } else {
-            typeface = QLatin1String("Normal");
-        }
-//        qDebug() << " massaged family" << family << "typeface" << typeface << "psize" << pSize;
-        newFont = QFontDatabase().font(family, typeface, pSize);
-        newFont.setUnderline(mQtFont->underline());
-        newFont.setStrikeOut(mQtFont->strikeOut());
-    }
-
-    [self setQtFont:newFont];
+    [self setQtFont:qfontForCocoaFont([sender convertFont:dummyFont], *mQtFont)];
     if (mPriv)
         mPriv->updateSampleFont(*mQtFont);
 }
@@ -317,6 +310,9 @@ const int StyleMask = NSTitledWindowMask | NSClosableWindowMask | NSResizableWin
 - (void)onOkClicked
 {
     Q_ASSERT(mPanelHackedWithButtons);
+    NSFontManager *fontManager = [NSFontManager sharedFontManager];
+    [self setQtFont:qfontForCocoaFont([fontManager convertFont:[fontManager selectedFont]],
+                                      *mQtFont)];
     [[mStolenContentView window] close];
     [self finishOffWithCode:NSOKButton];
 }
@@ -374,16 +370,7 @@ const int StyleMask = NSTitledWindowMask | NSClosableWindowMask | NSResizableWin
             mModalSession = 0;
         }
 
-        // temporary hack to work around bug in deleteLater() in Qt/Mac Cocoa
-#if 1
-        bool deleteDialog = mPriv->fontDialog()->testAttribute(Qt::WA_DeleteOnClose);
-        mPriv->fontDialog()->setAttribute(Qt::WA_DeleteOnClose, false);
-#endif
         mPriv->done((code == NSOKButton) ? QDialog::Accepted : QDialog::Rejected);
-#if 1
-        if (deleteDialog)
-            delete mPriv->fontDialog();
-#endif
     } else {
         [NSApp stopModalWithCode:code];
     }
diff --git a/src/gui/dialogs/qsidebar.cpp b/src/gui/dialogs/qsidebar.cpp
index bfdb37e..26108d7 100644
--- a/src/gui/dialogs/qsidebar.cpp
+++ b/src/gui/dialogs/qsidebar.cpp
@@ -248,7 +248,11 @@ void QUrlModel::addUrls(const QList<QUrl> &list, int row, bool move)
         if (!url.isValid() || url.scheme() != QLatin1String("file"))
             continue;
         for (int j = 0; move && j < rowCount(); ++j) {
+#if defined(Q_OS_WIN)
+            if (index(j, 0).data(UrlRole).toUrl().toLocalFile().toLower() == url.toLocalFile().toLower()) {
+#else
             if (index(j, 0).data(UrlRole) == url) {
+#endif
                 removeRow(j);
                 if (j <= row)
                     row--;
diff --git a/src/gui/embedded/qscreentransformed_qws.cpp b/src/gui/embedded/qscreentransformed_qws.cpp
index f988789..46ac1d1 100644
--- a/src/gui/embedded/qscreentransformed_qws.cpp
+++ b/src/gui/embedded/qscreentransformed_qws.cpp
@@ -410,7 +410,9 @@ void QTransformedScreen::blit(const QImage &image, const QPoint &topLeft,
 #endif
 #ifdef QT_QWS_DEPTH_8
     case 8:
-        if (image.depth() == 16)
+        if (image.format() == QImage::Format_RGB444)
+            SET_BLIT_FUNC(quint8, qrgb444, trans, func);
+        else if (image.depth() == 16)
             SET_BLIT_FUNC(quint8, quint16, trans, func);
         else
             SET_BLIT_FUNC(quint8, quint32, trans, func);
diff --git a/src/gui/graphicsview/qgraphicsitem.cpp b/src/gui/graphicsview/qgraphicsitem.cpp
index 7971711..92be62f 100644
--- a/src/gui/graphicsview/qgraphicsitem.cpp
+++ b/src/gui/graphicsview/qgraphicsitem.cpp
@@ -885,6 +885,38 @@ void QGraphicsItemPrivate::setParentItemHelper(QGraphicsItem *newParent, bool de
 /*!
     \internal
 
+    Returns the bounding rect of this item's children (excluding itself).
+*/
+void QGraphicsItemPrivate::childrenBoundingRectHelper(QTransform *x, QRectF *rect)
+{
+    for (int i = 0; i < children.size(); ++i) {
+        QGraphicsItem *child = children.at(i);
+        QGraphicsItemPrivate *childd = child->d_ptr;
+        bool hasX = childd->hasTransform;
+        bool hasPos = !childd->pos.isNull();
+        if (hasPos || hasX) {
+            QTransform matrix;
+            if (hasX)
+                matrix = child->transform();
+            if (hasPos) {
+                const QPointF &p = childd->pos;
+                matrix *= QTransform::fromTranslate(p.x(), p.y());
+            }
+            matrix *= *x;
+            *rect |= matrix.mapRect(child->boundingRect());
+            if (!childd->children.isEmpty())
+                childd->childrenBoundingRectHelper(&matrix, rect);
+        } else {
+            *rect |= x->mapRect(child->boundingRect());
+            if (!childd->children.isEmpty())
+                childd->childrenBoundingRectHelper(x, rect);
+        }
+    }
+}
+
+/*!
+    \internal
+
     Empty all cached pixmaps from the pixmap cache.
 */
 void QGraphicsItemCache::purge()
@@ -3255,13 +3287,8 @@ void QGraphicsItem::setZValue(qreal z)
 QRectF QGraphicsItem::childrenBoundingRect() const
 {
     QRectF childRect;
-    foreach (QGraphicsItem *child, children()) {
-        QPointF childPos = child->pos();
-        QTransform matrix = child->transform();
-        if (!childPos.isNull())
-            matrix *= QTransform::fromTranslate(childPos.x(), childPos.y());
-        childRect |= matrix.mapRect(child->boundingRect() | child->childrenBoundingRect());
-    }
+    QTransform x;
+    d_ptr->childrenBoundingRectHelper(&x, &childRect);
     return childRect;
 }
 
diff --git a/src/gui/graphicsview/qgraphicsitem_p.h b/src/gui/graphicsview/qgraphicsitem_p.h
index fb0bd2d..bcbd737 100644
--- a/src/gui/graphicsview/qgraphicsitem_p.h
+++ b/src/gui/graphicsview/qgraphicsitem_p.h
@@ -187,6 +187,7 @@ public:
     void addChild(QGraphicsItem *child);
     void removeChild(QGraphicsItem *child);
     void setParentItemHelper(QGraphicsItem *parent, bool deleting);
+    void childrenBoundingRectHelper(QTransform *x, QRectF *rect);
 
     virtual void resolveFont(uint inheritedMask)
     {
diff --git a/src/gui/graphicsview/qgraphicsview.cpp b/src/gui/graphicsview/qgraphicsview.cpp
index a9d585c..7720a10 100644
--- a/src/gui/graphicsview/qgraphicsview.cpp
+++ b/src/gui/graphicsview/qgraphicsview.cpp
@@ -2809,9 +2809,7 @@ void QGraphicsView::setupViewport(QWidget *widget)
 
     const bool isGLWidget = widget->inherits("QGLWidget");
 
-    d->accelerateScrolling = !(isGLWidget
-                               || widget->testAttribute(Qt::WA_MSWindowsUseDirect3D)
-                               || qApp->testAttribute(Qt::AA_MSWindowsUseDirect3DByDefault));
+    d->accelerateScrolling = !(isGLWidget);
 
     widget->setFocusPolicy(Qt::StrongFocus);
 
diff --git a/src/gui/image/qpixmap.cpp b/src/gui/image/qpixmap.cpp
index 3b82da8..f495b31 100644
--- a/src/gui/image/qpixmap.cpp
+++ b/src/gui/image/qpixmap.cpp
@@ -1359,14 +1359,6 @@ bool QPixmap::isDetached() const
 void QPixmap::deref()
 {
     if (data && !data->ref.deref()) { // Destroy image if last ref
-#if !defined(QT_NO_DIRECT3D) && defined(Q_WS_WIN)
-        if (data->classId() == QPixmapData::RasterClass) {
-            QRasterPixmapData *rData = static_cast<QRasterPixmapData*>(data);
-            if (rData->texture)
-                rData->texture->Release();
-            rData->texture = 0;
-        }
-#endif
         if (data->is_cached && qt_pixmap_cleanup_hook_64)
             qt_pixmap_cleanup_hook_64(cacheKey());
         delete data;
@@ -1938,12 +1930,6 @@ void QPixmap::detach()
     if (id == QPixmapData::RasterClass) {
         QRasterPixmapData *rasterData = static_cast<QRasterPixmapData*>(data);
         rasterData->image.detach();
-#if defined(Q_WS_WIN) && !defined(QT_NO_DIRECT3D)
-        if (rasterData->texture) {
-            rasterData->texture->Release();
-            rasterData->texture = 0;
-        }
-#endif
     }
 
     if (data->is_cached && qt_pixmap_cleanup_hook_64 && data->ref == 1)
diff --git a/src/gui/image/qpixmap.h b/src/gui/image/qpixmap.h
index cd3b465..a5609e4 100644
--- a/src/gui/image/qpixmap.h
+++ b/src/gui/image/qpixmap.h
@@ -254,8 +254,6 @@ private:
     friend class QWidgetPrivate;
     friend class QRasterPaintEngine;
     friend class QRasterBuffer;
-    friend class QDirect3DPaintEngine;
-    friend class QDirect3DPaintEnginePrivate;
     friend class QDetachedPixmap;
 #if !defined(QT_NO_DATASTREAM)
     friend Q_GUI_EXPORT QDataStream &operator>>(QDataStream &, QPixmap &);
diff --git a/src/gui/image/qpixmap_raster.cpp b/src/gui/image/qpixmap_raster.cpp
index 145b02a..b5556cd 100644
--- a/src/gui/image/qpixmap_raster.cpp
+++ b/src/gui/image/qpixmap_raster.cpp
@@ -50,12 +50,6 @@
 #include <private/qwidget_p.h>
 #include <private/qdrawhelper_p.h>
 
-#if !defined(QT_NO_DIRECT3D) && defined(Q_WS_WIN)
-#include <private/qpaintengine_d3d_p.h>
-#include <d3d9.h>
-extern QDirect3DPaintEngine *qt_d3dEngine();
-#endif
-
 QT_BEGIN_NAMESPACE
 
 const uchar qt_pixmap_bit_mask[] = { 0x01, 0x02, 0x04, 0x08,
@@ -63,9 +57,6 @@ const uchar qt_pixmap_bit_mask[] = { 0x01, 0x02, 0x04, 0x08,
 
 QRasterPixmapData::QRasterPixmapData(PixelType type)
     : QPixmapData(type, RasterClass)
-#if defined(Q_WS_WIN) && !defined(QT_NO_DIRECT3D)
-    , texture(0)
-#endif
 {
 }
 
diff --git a/src/gui/image/qpixmap_raster_p.h b/src/gui/image/qpixmap_raster_p.h
index 48d5cf8..9d3bf72 100644
--- a/src/gui/image/qpixmap_raster_p.h
+++ b/src/gui/image/qpixmap_raster_p.h
@@ -58,9 +58,6 @@
 
 #ifdef Q_WS_WIN
 # include "qt_windows.h"
-# ifndef QT_NO_DIRECT3D
-#  include <d3d9.h>
-# endif
 #endif
 
 QT_BEGIN_NAMESPACE
@@ -88,10 +85,6 @@ protected:
     int metric(QPaintDevice::PaintDeviceMetric metric) const;
 
 private:
-#if defined(Q_WS_WIN) && !defined(QT_NO_DIRECT3D)
-    friend class QDirect3DPaintEnginePrivate;
-    IDirect3DTexture9 *texture;
-#endif
     friend class QPixmap;
     friend class QBitmap;
     friend class QDetachedPixmap;
diff --git a/src/gui/image/qpixmapcache.cpp b/src/gui/image/qpixmapcache.cpp
index eedb6a3..458d6b9 100644
--- a/src/gui/image/qpixmapcache.cpp
+++ b/src/gui/image/qpixmapcache.cpp
@@ -187,6 +187,11 @@ bool QPMCache::insert(const QString& key, const QPixmap &pixmap, int cost)
         cacheKeys.insert(key, cacheKey);
         return true;
     }
+    qint64 oldCacheKey = cacheKeys.value(key, -1);
+    //If for the same key we add already a pixmap we should delete it
+    if (oldCacheKey != -1)
+        QCache<qint64, QDetachedPixmap>::remove(oldCacheKey);
+
     bool success = QCache<qint64, QDetachedPixmap>::insert(cacheKey, new QDetachedPixmap(pixmap), cost);
     if (success) {
         cacheKeys.insert(key, cacheKey);
diff --git a/src/gui/itemviews/qsortfilterproxymodel.cpp b/src/gui/itemviews/qsortfilterproxymodel.cpp
index 91431c4..fee19c9 100644
--- a/src/gui/itemviews/qsortfilterproxymodel.cpp
+++ b/src/gui/itemviews/qsortfilterproxymodel.cpp
@@ -56,6 +56,15 @@ QT_BEGIN_NAMESPACE
 
 typedef QList<QPair<QModelIndex, QPersistentModelIndex> > QModelIndexPairList;
 
+static inline QSet<int> qVectorToSet(const QVector<int> &vector)
+{
+    QSet<int> set;
+    set.reserve(vector.size());
+    for(int i=0; i < vector.size(); ++i)
+        set << vector.at(i);
+    return set;
+}
+
 class QSortFilterProxyModelLessThan
 {
 public:
@@ -223,8 +232,8 @@ public:
     QModelIndexPairList store_persistent_indexes();
     void update_persistent_indexes(const QModelIndexPairList &source_indexes);
 
-    void filter_changed();
-    void handle_filter_changed(
+    void filter_changed(const QModelIndex &source_parent = QModelIndex());
+    QSet<int> handle_filter_changed(
         QVector<int> &source_to_proxy, QVector<int> &proxy_to_source,
         const QModelIndex &source_parent, Qt::Orientation orient);
 
@@ -928,27 +937,39 @@ void QSortFilterProxyModelPrivate::update_persistent_indexes(
     q->changePersistentIndexList(from, to);
 }
 
+
 /*!
   \internal
 
   Updates the proxy model (adds/removes rows) based on the
   new filter.
 */
-void QSortFilterProxyModelPrivate::filter_changed()
+void QSortFilterProxyModelPrivate::filter_changed(const QModelIndex &source_parent)
 {
-    QMap<QModelIndex, Mapping *>::const_iterator it;
-    for (it = source_index_mapping.constBegin(); it != source_index_mapping.constEnd(); ++it) {
-        QModelIndex source_parent = it.key();
-        Mapping *m = it.value();
-        handle_filter_changed(m->proxy_rows, m->source_rows, source_parent, Qt::Vertical);
-        handle_filter_changed(m->proxy_columns, m->source_columns, source_parent, Qt::Horizontal);
+    IndexMap::const_iterator it = source_index_mapping.constFind(source_parent);
+    if (it == source_index_mapping.constEnd())
+        return;
+    Mapping *m = it.value();
+    QSet<int> rows_removed = handle_filter_changed(m->proxy_rows, m->source_rows, source_parent, Qt::Vertical);
+    QSet<int> columns_removed = handle_filter_changed(m->proxy_columns, m->source_columns, source_parent, Qt::Horizontal);
+    QVector<QModelIndex>::iterator it2 = m->mapped_children.end();
+    while (it2 != m->mapped_children.begin()) {
+        --it2;
+        const QModelIndex source_child_index = *it2;
+        if (rows_removed.contains(source_child_index.row()) || columns_removed.contains(source_child_index.column())) {
+            it2 = m->mapped_children.erase(it2);
+            remove_from_mapping(source_child_index);
+        } else {
+            filter_changed(source_child_index);
+        }
     }
 }
 
 /*!
   \internal
+  returns the removed items indexes
 */
-void QSortFilterProxyModelPrivate::handle_filter_changed(
+QSet<int> QSortFilterProxyModelPrivate::handle_filter_changed(
     QVector<int> &source_to_proxy, QVector<int> &proxy_to_source,
     const QModelIndex &source_parent, Qt::Orientation orient)
 {
@@ -985,6 +1006,7 @@ void QSortFilterProxyModelPrivate::handle_filter_changed(
         insert_source_items(source_to_proxy, proxy_to_source,
                             source_items_insert, source_parent, orient);
     }
+    return qVectorToSet(source_items_remove);
 }
 
 void QSortFilterProxyModelPrivate::_q_sourceDataChanged(const QModelIndex &source_top_left,
@@ -1035,15 +1057,14 @@ void QSortFilterProxyModelPrivate::_q_sourceDataChanged(const QModelIndex &sourc
     if (!source_rows_remove.isEmpty()) {
         remove_source_items(m->proxy_rows, m->source_rows,
                             source_rows_remove, source_parent, Qt::Vertical);
-        QSet<int> source_rows_remove_set = source_rows_remove.toList().toSet();
-        QVector<QModelIndex>::iterator it = m->mapped_children.begin();
-        while (it != m->mapped_children.end()) {
+        QSet<int> source_rows_remove_set = qVectorToSet(source_rows_remove);
+        QVector<QModelIndex>::iterator it = m->mapped_children.end();
+        while (it != m->mapped_children.begin()) {
+            --it;
             const QModelIndex source_child_index = *it;
             if (source_rows_remove_set.contains(source_child_index.row())) {
                 it = m->mapped_children.erase(it);
                 remove_from_mapping(source_child_index);
-            } else {
-                ++it;
             }
         }
     }
diff --git a/src/gui/kernel/kernel.pri b/src/gui/kernel/kernel.pri
index cb2b014..a1b982a 100644
--- a/src/gui/kernel/kernel.pri
+++ b/src/gui/kernel/kernel.pri
@@ -193,7 +193,7 @@ embedded {
         MENU_NIB.path = Resources 
         MENU_NIB.version = Versions
         QMAKE_BUNDLE_DATA += MENU_NIB 
-        RESOURCES += mac/maccursors.qrc
+        RESOURCES += mac/macresources.qrc
 
         LIBS += -framework AppKit
 }
diff --git a/src/gui/kernel/qaction.cpp b/src/gui/kernel/qaction.cpp
index 921be22..c6addc1 100644
--- a/src/gui/kernel/qaction.cpp
+++ b/src/gui/kernel/qaction.cpp
@@ -136,27 +136,25 @@ void QActionPrivate::redoGrab(QShortcutMap &map)
 void QActionPrivate::redoGrabAlternate(QShortcutMap &map)
 {
     Q_Q(QAction);
-    for (int i = 0; i < alternateShortcutIds.size(); ++i)
-        if (int id = alternateShortcutIds.at(i))
+    foreach (int id, alternateShortcutIds)
+        if (id)
             map.removeShortcut(id, q);
     alternateShortcutIds.clear();
     if (alternateShortcuts.isEmpty())
         return;
-    for (int i = 0; i < alternateShortcuts.size(); ++i) {
-        const QKeySequence &alternate = alternateShortcuts.at(i);
+    foreach (const QKeySequence& alternate, alternateShortcuts) {
         if (!alternate.isEmpty())
             alternateShortcutIds.append(map.addShortcut(q, alternate, shortcutContext));
         else
             alternateShortcutIds.append(0);
     }
-
     if (!enabled) {
-        for (int i = 0; i < alternateShortcutIds.size(); ++i)
-            map.setShortcutEnabled(false, alternateShortcutIds.at(i), q);
+        foreach (int id, alternateShortcutIds)
+            map.setShortcutEnabled(false, id, q);
     }
     if (!autorepeat) {
-        for (int i = 0; i < alternateShortcutIds.size(); ++i)
-            map.setShortcutAutoRepeat(false, alternateShortcutIds.at(i), q);
+        foreach (int id, alternateShortcutIds)
+            map.setShortcutAutoRepeat(false, id, q);
     }
 }
 
@@ -165,26 +163,10 @@ void QActionPrivate::setShortcutEnabled(bool enable, QShortcutMap &map)
     Q_Q(QAction);
     if (shortcutId)
         map.setShortcutEnabled(enable, shortcutId, q);
-    for (int i = 0; i < alternateShortcutIds.size(); ++i)
-        if (int id = alternateShortcutIds.at(i))
+    foreach (int id, alternateShortcutIds)
+        if (id)
             map.setShortcutEnabled(enable, id, q);
 }
-
-void QActionPrivate::removeAll(QShortcutMap &map)
-{
-    Q_Q(QAction);
-    if (shortcutId) {
-        map.removeShortcut(shortcutId, q);
-        shortcutId = 0;
-    }
-
-    for (int i = 0; i < alternateShortcutIds.size(); ++i)
-        if (int id = alternateShortcutIds.at(i))
-            map.removeShortcut(id, q);
-
-    alternateShortcutIds.clear();
-}
-
 #endif // QT_NO_SHORTCUT
 
 
@@ -633,8 +615,8 @@ QAction::~QAction()
 #ifndef QT_NO_SHORTCUT
     if (d->shortcutId && qApp) {
         qApp->d_func()->shortcutMap.removeShortcut(d->shortcutId, this);
-        for (int i = 0; i < d->alternateShortcutIds.size(); ++i)
-            qApp->d_func()->shortcutMap.removeShortcut(d->alternateShortcutIds.at(i), this);
+        foreach (int id, d->alternateShortcutIds)
+            qApp->d_func()->shortcutMap.removeShortcut(id, this);
     }
 #endif
 }
@@ -1067,12 +1049,7 @@ void QAction::setVisible(bool b)
     d->visible = b;
     d->enabled = b && !d->forceDisabled && (!d->group || d->group->isEnabled()) ;
 #ifndef QT_NO_SHORTCUT
-    if (b) {
-        d->redoGrab(qApp->d_func()->shortcutMap);
-        d->redoGrabAlternate(qApp->d_func()->shortcutMap);
-    } else {
-        d->removeAll(qApp->d_func()->shortcutMap);
-    }
+    d->setShortcutEnabled(d->enabled, qApp->d_func()->shortcutMap);
 #endif
     d->sendDataChanged();
 }
diff --git a/src/gui/kernel/qaction_p.h b/src/gui/kernel/qaction_p.h
index a5b3731..0617ef5 100644
--- a/src/gui/kernel/qaction_p.h
+++ b/src/gui/kernel/qaction_p.h
@@ -111,7 +111,6 @@ public:
     void redoGrab(QShortcutMap &map);
     void redoGrabAlternate(QShortcutMap &map);
     void setShortcutEnabled(bool enable, QShortcutMap &map);
-    void removeAll(QShortcutMap &map);
 
     static QShortcutMap *globalMap;
 #endif // QT_NO_SHORTCUT
diff --git a/src/gui/kernel/qapplication.cpp b/src/gui/kernel/qapplication.cpp
index fd189c7..34c135c 100644
--- a/src/gui/kernel/qapplication.cpp
+++ b/src/gui/kernel/qapplication.cpp
@@ -107,9 +107,6 @@ static void initResources()
     Q_INIT_RESOURCE(qstyle);
 #endif
 
-#if !defined(QT_NO_DIRECT3D) && defined(Q_WS_WIN)
-    Q_INIT_RESOURCE(qpaintengine_d3d);
-#endif
     Q_INIT_RESOURCE(qmessagebox);
 #if !defined(QT_NO_PRINTDIALOG)
     Q_INIT_RESOURCE(qprintdialog);
@@ -620,13 +617,6 @@ void QApplicationPrivate::process_cmdline()
             and QPixmaps. Available options are \c{raster} and \c{opengl}.
     \endlist
 
-    The Windows version of Qt supports an additional command line  option, if
-    Direct3D support has been compiled into Qt:
-    \list
-        \o  -direct3d will make the Direct3D paint engine the default widget
-            paint engine in Qt. \bold {This functionality is experimental.}
-    \endlist
-
     The X11 version of Qt supports some traditional X11 command line options:
     \list
         \o  -display \e display, sets the X display (default is $DISPLAY).
@@ -832,12 +822,13 @@ QApplication::QApplication(Display *dpy, int &argc, char **argv,
 
 #endif // Q_WS_X11
 
+extern void qInitDrawhelperAsm();
 
 /*!
+  \fn void QApplicationPrivate::initialize()
+
   Initializes the QApplication object, called from the constructors.
 */
-extern void qInitDrawhelperAsm();
-
 void QApplicationPrivate::initialize()
 {
     QWidgetPrivate::mapper = new QWidgetMapper;
@@ -2106,8 +2097,8 @@ void QApplicationPrivate::setFocusWidget(QWidget *focus, Qt::FocusReason reason)
                 if (that)
                     QApplication::sendEvent(that->style(), &in);
             }
+            emit qApp->focusChanged(prev, focus_widget);
         }
-        emit qApp->focusChanged(prev, focus_widget);
     }
 }
 
@@ -3504,7 +3495,7 @@ void QApplication::changeOverrideCursor(const QCursor &cursor)
     It is necessary to call this function to start event handling. The main
     event loop receives events from the window system and dispatches these to
     the application widgets.
- 
+
     Generally, no user interaction can take place before calling exec(). As a
     special case, modal widgets like QMessageBox can be used before calling
     exec(), because modal widgets call exec() to start a local event loop.
diff --git a/src/gui/kernel/qapplication_win.cpp b/src/gui/kernel/qapplication_win.cpp
index 2f2fc2c..c1cb7e2 100644
--- a/src/gui/kernel/qapplication_win.cpp
+++ b/src/gui/kernel/qapplication_win.cpp
@@ -745,9 +745,6 @@ void qt_init(QApplicationPrivate *priv, int)
             appNoGrab = !appNoGrab;
         else
 #endif // QT_DEBUG
-        if (qstrcmp(argv[i], "-direct3d") == 0)
-            QApplication::setAttribute(Qt::AA_MSWindowsUseDirect3DByDefault);
-        else
             argv[j++] = argv[i];
     }
     if(j < priv->argc) {
diff --git a/src/gui/kernel/qapplication_x11.cpp b/src/gui/kernel/qapplication_x11.cpp
index 366e576..d7ca2f4 100644
--- a/src/gui/kernel/qapplication_x11.cpp
+++ b/src/gui/kernel/qapplication_x11.cpp
@@ -402,7 +402,7 @@ extern bool qt_xdnd_dragging;
 // gui or non-gui from qapplication.cpp
 extern bool qt_is_gui_used;
 
-/*! 
+/*!
     \internal
     Try to resolve a \a symbol from \a library with the version specified
     by \a vernum.
@@ -840,7 +840,7 @@ bool QApplicationPrivate::x11_apply_settings()
     }
 
     int kdeSessionVersion = QString::fromLocal8Bit(qgetenv("KDE_SESSION_VERSION")).toInt();
- 
+
     if (!appFont) {
         QFont font(QApplication::font());
         QString fontDescription;
@@ -1583,6 +1583,7 @@ static PtrWacomConfigOpenDevice ptrWacomConfigOpenDevice = 0;
 static PtrWacomConfigGetRawParam ptrWacomConfigGetRawParam = 0;
 static PtrWacomConfigCloseDevice ptrWacomConfigCloseDevice = 0;
 static PtrWacomConfigTerm ptrWacomConfigTerm = 0;
+Q_GLOBAL_STATIC(QByteArray, wacomDeviceName)
 #endif
 
 #endif
@@ -1952,11 +1953,17 @@ void qt_init(QApplicationPrivate *priv, int,
         {
             QString displayName = QLatin1String(XDisplayName(NULL));
 
-            // apparently MITSHM only works for local displays, so do a quick check here
-            // to determine whether the display is local or not (not 100 % accurate)
+            // MITSHM only works for local displays, so do a quick check here
+            // to determine whether the display is local or not (not 100 % accurate).
+            // BGR server layouts are not supported either, since it requires the raster
+            // engine to work on a QImage with BGR layout.
             bool local = displayName.isEmpty() || displayName.lastIndexOf(QLatin1Char(':')) == 0;
-            if (local && (qgetenv("QT_X11_NO_MITSHM").toInt() == 0))
-                X11->use_mitshm = mitshm_pixmaps;
+            if (local && (qgetenv("QT_X11_NO_MITSHM").toInt() == 0)) {
+                Visual *defaultVisual = DefaultVisual(X11->display, DefaultScreen(X11->display));
+                X11->use_mitshm = mitshm_pixmaps && (defaultVisual->red_mask == 0xff0000
+                                                     && defaultVisual->green_mask == 0xff00
+                                                     && defaultVisual->blue_mask == 0xff);
+            }
         }
 #endif // QT_NO_MITSHM
 
@@ -2377,6 +2384,8 @@ void qt_init(QApplicationPrivate *priv, int,
 #else
                 if (devs->type == ATOM(XWacomStylus)) {
                     deviceType = QTabletEvent::Stylus;
+                    if (wacomDeviceName()->isEmpty())
+                        wacomDeviceName()->append(devs->name);
                     gotStylus = true;
                 } else if (devs->type == ATOM(XWacomEraser)) {
                     deviceType = QTabletEvent::XFreeEraser;
@@ -4511,8 +4520,7 @@ void fetchWacomToolId(int &deviceType, qint64 &serialId)
     WACOMCONFIG *config = ptrWacomConfigInit(X11->display, 0);
     if (config == 0)
         return;
-    const char *name = "stylus"; // TODO get this from the X config instead (users may have called it differently)
-    WACOMDEVICE *device = ptrWacomConfigOpenDevice (config, name);
+    WACOMDEVICE *device = ptrWacomConfigOpenDevice (config, wacomDeviceName()->constData());
     if (device == 0)
         return;
     unsigned keys[1];
diff --git a/src/gui/kernel/qcocoaview_mac.mm b/src/gui/kernel/qcocoaview_mac.mm
index dcb3564..cf66605 100644
--- a/src/gui/kernel/qcocoaview_mac.mm
+++ b/src/gui/kernel/qcocoaview_mac.mm
@@ -293,9 +293,18 @@ extern "C" {
     QPoint posDrag(localPoint.x, localPoint.y);
     NSDragOperation nsActions = [sender draggingSourceOperationMask]; 
     Qt::DropActions qtAllowed = qt_mac_mapNSDragOperations(nsActions);
+    QT_PREPEND_NAMESPACE(qt_mac_dnd_answer_rec.lastOperation) = nsActions;
+    Qt::KeyboardModifiers modifiers  = Qt::NoModifier;
+    if ([sender draggingSource] != nil) {
+        // modifier flags might have changed, update it here since we don't send any input events.
+        QApplicationPrivate::modifier_buttons = qt_cocoaModifiers2QtModifiers([[NSApp currentEvent] modifierFlags]);
+        modifiers = QApplication::keyboardModifiers();
+    } else {
+        // when the source is from another application the above technique will not work.
+        modifiers = qt_cocoaDragOperation2QtModifiers(nsActions);
+    }
     // send the drag enter event to the widget.
-    QDragEnterEvent qDEEvent(posDrag, qtAllowed, mimeData,
-            QApplication::mouseButtons(), QApplication::keyboardModifiers());
+    QDragEnterEvent qDEEvent(posDrag, qtAllowed, mimeData, QApplication::mouseButtons(), modifiers);
     QApplication::sendEvent(qwidget, &qDEEvent);
     if (!qDEEvent.isAccepted()) {
         // widget is not interested in this drag, so ignore this drop data.
@@ -303,24 +312,23 @@ extern "C" {
         return NSDragOperationNone;
     } else {
         // send a drag move event immediately after a drag enter event (as per documentation).
-        QDragMoveEvent qDMEvent(posDrag, qtAllowed, mimeData,
-                QApplication::mouseButtons(), QApplication::keyboardModifiers());
+        QDragMoveEvent qDMEvent(posDrag, qtAllowed, mimeData, QApplication::mouseButtons(), modifiers);
         qDMEvent.setDropAction(qDEEvent.dropAction());
         qDMEvent.accept(); // accept by default, since enter event was accepted.
         QApplication::sendEvent(qwidget, &qDMEvent);
         if (!qDMEvent.isAccepted() || qDMEvent.dropAction() == Qt::IgnoreAction) {
             // since we accepted the drag enter event, the widget expects 
             // future drage move events.  
-	    // ### check if we need to treat this like the drag enter event.
+            // ### check if we need to treat this like the drag enter event.
             nsActions = QT_PREPEND_NAMESPACE(qt_mac_mapDropAction)(qDEEvent.dropAction());
         } else {
             nsActions = QT_PREPEND_NAMESPACE(qt_mac_mapDropAction)(qDMEvent.dropAction());
-	}
+        }
         QT_PREPEND_NAMESPACE(qt_mac_copy_answer_rect)(qDMEvent);
-	return nsActions;
+        return nsActions;
     } 
  }
- 
+
 - (NSDragOperation)draggingUpdated:(id < NSDraggingInfo >)sender
 {
     // drag enter event was rejected, so ignore the move event. 
@@ -338,11 +346,19 @@ extern "C" {
     // send drag move event to the widget    
     QT_PREPEND_NAMESPACE(qt_mac_dnd_answer_rec.lastOperation) = nsActions;
     Qt::DropActions qtAllowed = QT_PREPEND_NAMESPACE(qt_mac_mapNSDragOperations)(nsActions);
+    Qt::KeyboardModifiers modifiers  = Qt::NoModifier;
+    if ([sender draggingSource] != nil) {
+        // modifier flags might have changed, update it here since we don't send any input events.
+        QApplicationPrivate::modifier_buttons = qt_cocoaModifiers2QtModifiers([[NSApp currentEvent] modifierFlags]);
+        modifiers = QApplication::keyboardModifiers();
+    } else {
+        // when the source is from another application the above technique will not work.
+        modifiers = qt_cocoaDragOperation2QtModifiers(nsActions);
+    }
     QMimeData *mimeData = dropData;
     if (QDragManager::self()->source())
         mimeData = QDragManager::self()->dragPrivate()->data;
-    QDragMoveEvent qDMEvent(posDrag, qtAllowed, mimeData,
-            QApplication::mouseButtons(), QApplication::keyboardModifiers());
+    QDragMoveEvent qDMEvent(posDrag, qtAllowed, mimeData, QApplication::mouseButtons(), modifiers);
     qDMEvent.setDropAction(QT_PREPEND_NAMESPACE(qt_mac_dnd_answer_rec).lastAction);
     qDMEvent.accept();
     QApplication::sendEvent(qwidget, &qDMEvent);
@@ -371,12 +387,12 @@ extern "C" {
 - (BOOL)performDragOperation:(id <NSDraggingInfo>)sender
 {
     [self addDropData:sender];
-    
+
     NSPoint windowPoint = [sender draggingLocation];
     NSPoint globalPoint = [[sender draggingDestinationWindow] convertBaseToScreen:windowPoint];
     NSPoint localPoint = [self convertPoint:windowPoint fromView:nil];
     QPoint posDrop(localPoint.x, localPoint.y);
-    
+
     NSDragOperation nsActions = [sender draggingSourceOperationMask]; 
     Qt::DropActions qtAllowed = qt_mac_mapNSDragOperations(nsActions);
     QMimeData *mimeData = dropData;
@@ -388,6 +404,8 @@ extern "C" {
     if (QDragManager::self()->object)
         QDragManager::self()->dragPrivate()->target = qwidget;
     QApplication::sendEvent(qwidget, &de);
+    if (QDragManager::self()->object)
+        QDragManager::self()->dragPrivate()->executed_action = de.dropAction();
     if (!de.isAccepted())
         return NO;
     else
@@ -419,10 +437,9 @@ extern "C" {
 - (void) setFrameSize:(NSSize)newSize
 {
     [super setFrameSize:newSize];
- 
+
     // A change in size has required the view to be invalidated.
-    if ([self inLiveResize])
-    {
+    if ([self inLiveResize]) {
         NSRect rects[4];
         NSInteger count;
         [self getRectsExposedDuringLiveResize:rects count:&count];
@@ -430,9 +447,7 @@ extern "C" {
         {
             [self setNeedsDisplayInRect:rects[count]];
         }
-    }
-    else
-    {
+    } else {
         [self setNeedsDisplay:YES];
     }
 }
@@ -567,7 +582,7 @@ extern "C" {
     if (!qAppInstance()->activeModalWidget() || QApplicationPrivate::tryModalHelper(qwidget, 0)) {
         QApplication::sendEvent(qwidget, &enterEvent);
         qt_mouseover = qwidget;
-        
+
         // Update cursor and dispatch hover events.
         qt_mac_update_cursor_at_global_pos(flipPoint(globalPoint).toPoint());
         if (qwidget->testAttribute(Qt::WA_Hover) &&
@@ -622,7 +637,7 @@ extern "C" {
         [viewsToLookAt addObject:qt_mac_nativeview_for(parentWidget)];
         parentWidget = parentWidget->parentWidget();
     }
-    
+
     // Now walk through the subviews of each view and determine which subview should
     // get the event. We look through all the subviews at a given level with
     // the assumption that the last item to be found the candidate has a higher z-order.
@@ -758,7 +773,7 @@ extern "C" {
     if (currentIManager && [currentIManager wantsToHandleMouseEvents]) {
         [currentIManager handleMouseEvent:theEvent];
     }
-    
+
     NSPoint windowPoint = [theEvent locationInWindow];
     NSPoint globalPoint = [[theEvent window] convertBaseToScreen:windowPoint];
     NSPoint localPoint = [self convertPoint:windowPoint fromView:nil];
@@ -767,7 +782,7 @@ extern "C" {
     Qt::MouseButton buttons = cocoaButton2QtButton([theEvent buttonNumber]);
     bool wheelOK = false;
     Qt::KeyboardModifiers keyMods = qt_cocoaModifiers2QtModifiers([theEvent modifierFlags]);
-    
+
     // Mouse wheel deltas seem to tick in at increments of 0.1. Qt widgets
     // expect the delta to be a multiple of 120. 
     const int ScrollFactor = 10 * 120;
@@ -789,7 +804,7 @@ extern "C" {
             wheelOK = qwe2.isAccepted();
         }
     }
-    
+
     if (deltaY) {
         QWheelEvent qwe(qlocal, qglobal, deltaY, buttons, keyMods, Qt::Vertical);
         qt_sendSpontaneousEvent(qwidget, &qwe);
@@ -802,7 +817,7 @@ extern "C" {
             wheelOK = qwe2.isAccepted();
         }
     }
-    
+
     if (deltaZ) {
         // Qt doesn't explicitly support wheels with a Z component. In a misguided attempt to
         // try to be ahead of the pack, I'm adding this extra value.
@@ -891,6 +906,11 @@ extern "C" {
     Q_UNUSED(anImage);
     Q_UNUSED(aPoint);
     qMacDnDParams()->performedAction = operation;
+    if (QDragManager::self()->object
+        && QDragManager::self()->dragPrivate()->executed_action != Qt::ActionMask) {
+        qMacDnDParams()->performedAction =
+                qt_mac_mapDropAction(QDragManager::self()->dragPrivate()->executed_action);
+    }
 }
 
 - (QWidget *)qt_qwidget
@@ -1214,13 +1234,13 @@ Qt::DropAction QDragManager::drag(QDrag *o)
      so we just bail early to prevent it */
     if(!(GetCurrentEventButtonState() & kEventMouseButtonPrimary))
         return Qt::IgnoreAction;
-    
+
     if(object) {
         dragPrivate()->source->removeEventFilter(this);
         cancel();
         beingCancelled = false;
     }
-    
+
     object = o;
     dragPrivate()->target = 0;
 
@@ -1232,7 +1252,7 @@ Qt::DropAction QDragManager::drag(QDrag *o)
     QMacPasteboard dragBoard((CFStringRef) NSDragPboard, QMacPasteboardMime::MIME_DND);
     dragPrivate()->data->setData(QLatin1String("application/x-qt-mime-type-name"), QByteArray());
     dragBoard.setMimeData(dragPrivate()->data);
-    
+
     // create the image
     QPoint hotspot;
     QPixmap pix = dragPrivate()->pixmap;
@@ -1278,6 +1298,7 @@ Qt::DropAction QDragManager::drag(QDrag *o)
     NSSize mouseOffset = {0.0, 0.0};
     NSPasteboard *pboard = [NSPasteboard pasteboardWithName:NSDragPboard];
     NSPoint windowPoint = [dndParams->theEvent locationInWindow];
+    dragPrivate()->executed_action = Qt::ActionMask;
     // do the drag
     [dndParams->view retain];
     [dndParams->view dragImage:image
@@ -1289,6 +1310,7 @@ Qt::DropAction QDragManager::drag(QDrag *o)
                      slideBack:YES];
     [dndParams->view release];
     [image release];
+    dragPrivate()->executed_action = Qt::IgnoreAction;
     object = 0;
     Qt::DropAction performedAction(qt_mac_mapNSDragOperation(dndParams->performedAction));
     // do post drag processing, if required.
diff --git a/src/gui/kernel/qshortcut.cpp b/src/gui/kernel/qshortcut.cpp
index f3c93c6..50b6e59 100644
--- a/src/gui/kernel/qshortcut.cpp
+++ b/src/gui/kernel/qshortcut.cpp
@@ -385,21 +385,19 @@ bool QShortcut::event(QEvent *e)
 {
     Q_D(QShortcut);
     bool handled = false;
-    if (e->type() == QEvent::Shortcut) {
+    if (d->sc_enabled && e->type() == QEvent::Shortcut) {
         QShortcutEvent *se = static_cast<QShortcutEvent *>(e);
         if (se->shortcutId() == d->sc_id && se->key() == d->sc_sequence){
-            if (d->sc_enabled) {
 #ifndef QT_NO_WHATSTHIS
-                if (QWhatsThis::inWhatsThisMode()) {
-                    QWhatsThis::showText(QCursor::pos(), d->sc_whatsthis);
-                    handled = true;
-                } else
+            if (QWhatsThis::inWhatsThisMode()) {
+                QWhatsThis::showText(QCursor::pos(), d->sc_whatsthis);
+                handled = true;
+            } else
 #endif
-                if (se->isAmbiguous())
-                    emit activatedAmbiguously();
-                else
-                    emit activated();
-            }
+            if (se->isAmbiguous())
+                emit activatedAmbiguously();
+            else
+                emit activated();
             handled = true;
         }
     }
diff --git a/src/gui/kernel/qshortcutmap.cpp b/src/gui/kernel/qshortcutmap.cpp
index 9766a69..ed9654b 100644
--- a/src/gui/kernel/qshortcutmap.cpp
+++ b/src/gui/kernel/qshortcutmap.cpp
@@ -370,8 +370,9 @@ bool QShortcutMap::tryShortcutEvent(QObject *o, QKeyEvent *e)
     default:
 	break;
     }
-
-    return true;
+    // If nextState is QKeySequence::ExactMatch && identicals.count == 0
+    // we've only found disabled shortcuts
+    return identicalMatches > 0 || result == QKeySequence::PartialMatch;
 }
 
 /*! \internal
@@ -493,7 +494,9 @@ QKeySequence::SequenceMatch QShortcutMap::find(QKeyEvent *e)
                     // We don't need partials, if we have identicals
                     if (d->identicals.size())
                         break;
-                    partialFound = true;
+                    // We only care about enabled partials, so we don't consume
+                    // key events when all partials are disabled!
+                    partialFound |= (*it).enabled;
                 }
             }
             ++it;
diff --git a/src/gui/kernel/qt_cocoa_helpers_mac.mm b/src/gui/kernel/qt_cocoa_helpers_mac.mm
index 52e76d8..f000292 100644
--- a/src/gui/kernel/qt_cocoa_helpers_mac.mm
+++ b/src/gui/kernel/qt_cocoa_helpers_mac.mm
@@ -515,6 +515,18 @@ Qt::KeyboardModifiers qt_cocoaModifiers2QtModifiers(ulong modifierFlags)
     return qtMods;
 }
 
+Qt::KeyboardModifiers qt_cocoaDragOperation2QtModifiers(uint dragOperations)
+{
+    Qt::KeyboardModifiers qtMods =Qt::NoModifier;
+    if (dragOperations &  NSDragOperationLink)
+        qtMods |= Qt::MetaModifier;
+    if (dragOperations & NSDragOperationGeneric)
+        qtMods |= Qt::ControlModifier;
+    if (dragOperations & NSDragOperationCopy)
+        qtMods |= Qt::AltModifier;
+    return qtMods;
+}
+
 static inline QEvent::Type cocoaEvent2QtEvent(NSUInteger eventType)
 {
     // Handle the trivial cases that can be determined from the type.
diff --git a/src/gui/kernel/qt_cocoa_helpers_mac_p.h b/src/gui/kernel/qt_cocoa_helpers_mac_p.h
index ef55aa4..63a301c 100644
--- a/src/gui/kernel/qt_cocoa_helpers_mac_p.h
+++ b/src/gui/kernel/qt_cocoa_helpers_mac_p.h
@@ -141,6 +141,7 @@ inline QApplication *qAppInstance() { return static_cast<QApplication *>(QCoreAp
 struct ::TabletProximityRec;
 void qt_dispatchTabletProximityEvent(const ::TabletProximityRec &proxRec);
 Qt::KeyboardModifiers qt_cocoaModifiers2QtModifiers(ulong modifierFlags);
+Qt::KeyboardModifiers qt_cocoaDragOperation2QtModifiers(uint dragOperations);
 inline int flipYCoordinate(int y)
 {
     return QApplication::desktop()->screenGeometry(0).height() - y;    
diff --git a/src/gui/kernel/qwidget.cpp b/src/gui/kernel/qwidget.cpp
index 9f5f18d..9f0d2a4 100644
--- a/src/gui/kernel/qwidget.cpp
+++ b/src/gui/kernel/qwidget.cpp
@@ -183,6 +183,7 @@ QWidgetPrivate::QWidgetPrivate(int version) :
         ,inDirtyList(0)
         ,isScrolled(0)
         ,isMoved(0)
+        ,usesDoubleBufferedGLContext(0)
 #ifdef Q_WS_WIN
         ,noPaintOnScreen(0)
 #endif
@@ -2132,6 +2133,10 @@ QWidget *QWidget::find(WId id)
     If a widget is non-native (alien) and winId() is invoked on it, that widget
     will be provided a native handle.
 
+    On Mac OS X, the type returned depends on which framework Qt was linked
+    against. If Qt is using Carbon, the {WId} is actually an HIViewRef. If Qt
+    is using Cocoa, {WId} is a pointer to an NSView.
+
     \note We recommend that you do not store this value as it is likely to
     change at run-time.
 
@@ -4714,10 +4719,13 @@ void QWidget::render(QPaintDevice *target, const QPoint &targetOffset,
     if (redirected) {
         target = redirected;
         offset -= redirectionOffset;
-        if (!inRenderWithPainter) { // Clip handled by shared painter (in qpainter.cpp).
-            const QRegion redirectedSystemClip = redirected->paintEngine()->systemClip();
-            if (!redirectedSystemClip.isEmpty())
-                paintRegion &= redirectedSystemClip.translated(-offset);
+    }
+
+    if (!inRenderWithPainter) { // Clip handled by shared painter (in qpainter.cpp).
+        if (QPaintEngine *targetEngine = target->paintEngine()) {
+            const QRegion targetSystemClip = targetEngine->systemClip();
+            if (!targetSystemClip.isEmpty())
+                paintRegion &= targetSystemClip.translated(-offset);
         }
     }
 
@@ -9792,27 +9800,6 @@ void QWidget::setAttribute(Qt::WidgetAttribute attribute, bool on)
         QEvent e(QEvent::MouseTrackingChange);
         QApplication::sendEvent(this, &e);
         break; }
-#if !defined(QT_NO_DIRECT3D) && defined(Q_WS_WIN)
-    case Qt::WA_MSWindowsUseDirect3D:
-        if (!qApp->testAttribute(Qt::AA_MSWindowsUseDirect3DByDefault)) {
-            if (on) {
-                if (!d->extra)
-                    d->createExtra();
-                d->extra->had_auto_fill_bg = d->extra->autoFillBackground;
-                d->extra->had_no_system_bg = testAttribute(Qt::WA_NoSystemBackground);
-                d->extra->had_paint_on_screen = testAttribute(Qt::WA_PaintOnScreen);
-                // enforce the opaque widget state D3D needs
-                d->extra->autoFillBackground = true;
-                setAttribute(Qt::WA_PaintOnScreen);
-                setAttribute(Qt::WA_NoSystemBackground);
-            } else if (d->extra) {
-                d->extra->autoFillBackground = d->extra->had_auto_fill_bg;
-                setAttribute(Qt::WA_PaintOnScreen, d->extra->had_paint_on_screen);
-                setAttribute(Qt::WA_NoSystemBackground, d->extra->had_no_system_bg);
-            }
-        }
-        break;
-#endif
     case Qt::WA_NativeWindow: {
         QInputContext *ic = 0;
         if (on && !internalWinId() && testAttribute(Qt::WA_InputMethodEnabled) && hasFocus()) {
diff --git a/src/gui/kernel/qwidget_mac.mm b/src/gui/kernel/qwidget_mac.mm
index 013fc1e..0f74c32 100644
--- a/src/gui/kernel/qwidget_mac.mm
+++ b/src/gui/kernel/qwidget_mac.mm
@@ -3995,6 +3995,33 @@ void QWidgetPrivate::setWSGeometry(bool dontShow, const QRect &oldRect)
     }
 }
 
+void QWidgetPrivate::applyMaxAndMinSizeConstraints(int &w, int &h)
+{
+    if (QWExtra *extra = extraData()) {
+        w = qMin(w, extra->maxw);
+        h = qMin(h, extra->maxh);
+        w = qMax(w, extra->minw);
+        h = qMax(h, extra->minh);
+
+        // Deal with size increment
+        if (QTLWExtra *top = topData()) {
+            if(top->incw) {
+                w = w/top->incw;
+                w *= top->incw;
+            }
+            if(top->inch) {
+                h = h/top->inch;
+                h *= top->inch;
+            }
+        }
+    }
+
+    if (isRealWindow()) {
+        w = qMax(0, w);
+        h = qMax(0, h);
+    }
+}
+
 void QWidgetPrivate::setGeometry_sys(int x, int y, int w, int h, bool isMove)
 {
     Q_Q(QWidget);
@@ -4005,7 +4032,9 @@ void QWidgetPrivate::setGeometry_sys(int x, int y, int w, int h, bool isMove)
 
     QMacCocoaAutoReleasePool pool;
     bool realWindow = isRealWindow();
+
     if (realWindow && !(w == 0 && h == 0) && !q->testAttribute(Qt::WA_DontShowOnScreen)) {
+        applyMaxAndMinSizeConstraints(w, h);
         topData()->isSetGeometry = 1;
         topData()->isMove = isMove;
 #ifndef QT_MAC_USE_COCOA
@@ -4031,10 +4060,26 @@ void QWidgetPrivate::setGeometry_sys_helper(int x, int y, int w, int h, bool isM
 {
     Q_Q(QWidget);
     bool realWindow = isRealWindow();
-    if(QWExtra *extra = extraData()) {        // any size restrictions?
-        if(realWindow) {
+
+    QPoint oldp = q->pos();
+    QSize  olds = q->size();
+    const bool isResize = (olds != QSize(w, h));
+
+    if (!realWindow && !isResize && QPoint(x, y) == oldp)
+        return;
+
+    if (isResize)
+        data.window_state = data.window_state & ~Qt::WindowMaximized;
+
+    const bool visible = q->isVisible();
+    data.crect = QRect(x, y, w, h);
+
+    if (realWindow) {
+        if (QWExtra *extra = extraData()) {
+            applyMaxAndMinSizeConstraints(w, h);
             qt_mac_update_sizer(q);
-            if(q->windowFlags() & Qt::WindowMaximizeButtonHint) {
+
+            if (q->windowFlags() & Qt::WindowMaximizeButtonHint) {
 #ifndef QT_MAC_USE_COCOA
                 OSWindowRef window = qt_mac_window_for(q);
                 if(extra->maxw && extra->maxh && extra->maxw == extra->minw
@@ -4045,43 +4090,8 @@ void QWidgetPrivate::setGeometry_sys_helper(int x, int y, int w, int h, bool isM
                 }
 #endif
             }
-        }
-
-        w = qMin(w,extra->maxw);
-        h = qMin(h,extra->maxh);
-        w = qMax(w,extra->minw);
-        h = qMax(h,extra->minh);
-
-        // Deal with size increment
-        if(QTLWExtra *top = topData()) {
-            if(top->incw) {
-                w = w/top->incw;
-                w *= top->incw;
-            }
-            if(top->inch) {
-                h = h/top->inch;
-                h *= top->inch;
-            }
-        }
-    }
-
-    if (realWindow) {
-        w = qMax(0, w);
-        h = qMax(0, h);
-    }
-
-    QPoint oldp = q->pos();
-    QSize  olds = q->size();
-    const bool isResize = (olds != QSize(w, h));
-    if(!realWindow && !isResize && QPoint(x, y) == oldp)
-        return;
-    if(isResize && q->isMaximized())
-        data.window_state = data.window_state & ~Qt::WindowMaximized;
-    const bool visible = q->isVisible();
-    data.crect = QRect(x, y, w, h);
 
-    if(realWindow) {
-        if(QWExtra *extra = extraData()) { //set constraints
+            // Update max and min constraints:
             const float max_f(20000);
 #ifndef QT_MAC_USE_COCOA
 #define SF(x) ((x > max_f) ? max_f : x)
diff --git a/src/gui/kernel/qwidget_p.h b/src/gui/kernel/qwidget_p.h
index 9e93f66..8731551 100644
--- a/src/gui/kernel/qwidget_p.h
+++ b/src/gui/kernel/qwidget_p.h
@@ -177,11 +177,6 @@ struct QWExtra {
 //bit flags at the end to improve packing
 #if defined(Q_WS_WIN)
     uint shown_mode : 8; // widget show mode
-#ifndef QT_NO_DIRECT3D
-    uint had_paint_on_screen : 1;
-    uint had_no_system_bg : 1;
-    uint had_auto_fill_bg : 1;
-#endif
 #endif
 #if defined(Q_WS_X11)
     uint compress_events : 1;
@@ -257,6 +252,7 @@ public:
     void macUpdateIsOpaque();
     void setEnabled_helper_sys(bool enable);
     bool isRealWindow() const;
+    void applyMaxAndMinSizeConstraints(int &w, int &h);
 #endif
 
     void raise_sys();
@@ -535,6 +531,7 @@ public:
     uint inDirtyList : 1;
     uint isScrolled : 1;
     uint isMoved : 1;
+    uint usesDoubleBufferedGLContext : 1;
 
 #ifdef Q_WS_WIN
     uint noPaintOnScreen : 1; // see qwidget_win.cpp ::paintEngine()
diff --git a/src/gui/kernel/qwidget_win.cpp b/src/gui/kernel/qwidget_win.cpp
index ffbb341..7374994 100644
--- a/src/gui/kernel/qwidget_win.cpp
+++ b/src/gui/kernel/qwidget_win.cpp
@@ -56,12 +56,6 @@
 #include "private/qbackingstore_p.h"
 #include "private/qwindowsurface_raster_p.h"
 
-#ifndef QT_NO_DIRECT3D
-#include "private/qpaintengine_d3d_p.h"
-#include "private/qwindowsurface_d3d_p.h"
-#endif
-
-
 #include <qdebug.h>
 
 #include <private/qapplication_p.h>
@@ -1716,11 +1710,6 @@ void QWidgetPrivate::createSysExtra()
 #ifndef QT_NO_DRAGANDDROP
     extra->dropTarget = 0;
 #endif
-#ifndef QT_NO_DIRECT3D
-    extra->had_auto_fill_bg = 0;
-    extra->had_paint_on_screen = 0;
-    extra->had_no_system_bg = 0;
-#endif
 }
 
 void QWidgetPrivate::deleteSysExtra()
@@ -1931,22 +1920,6 @@ void QWidgetPrivate::setWindowOpacity_sys(qreal level)
 // };
 // Q_GLOBAL_STATIC(QGlobalRasterPaintEngine, globalRasterPaintEngine)
 
-#ifndef QT_NO_DIRECT3D
-static void cleanup_d3d_engine();
-Q_GLOBAL_STATIC_WITH_INITIALIZER(QDirect3DPaintEngine, _qt_d3dEngine,
-                                 {
-                                     qAddPostRoutine(cleanup_d3d_engine);
-                                 })
-static void cleanup_d3d_engine()
-{
-    _qt_d3dEngine()->cleanup();
-}
-QDirect3DPaintEngine* qt_d3dEngine()
-{
-    return _qt_d3dEngine();
-}
-#endif
-
 
 #ifndef QT_NO_DIRECTDRAW
 static uchar *qt_primary_surface_bits;
@@ -2059,19 +2032,6 @@ void qt_win_initialize_directdraw() { }
 
 QPaintEngine *QWidget::paintEngine() const
 {
-#ifndef QT_NO_DIRECT3D
-    if ((qApp->testAttribute(Qt::AA_MSWindowsUseDirect3DByDefault)
-         || testAttribute(Qt::WA_MSWindowsUseDirect3D))
-        && qt_d3dEngine()->hasDirect3DSupport())
-    {
-        QDirect3DPaintEngine *engine = qt_d3dEngine();
-        if (qApp->testAttribute(Qt::AA_MSWindowsUseDirect3DByDefault))
-            engine->setFlushOnEnd(false);
-        else
-            engine->setFlushOnEnd(true);
-        return engine;
-    }
-#endif
 #ifndef QT_NO_DIRECTDRAW
     QOnScreenRasterPaintEngine *pe = onScreenPaintEngine();
     pe->widget = this;
@@ -2100,13 +2060,6 @@ QPaintEngine *QWidget::paintEngine() const
 QWindowSurface *QWidgetPrivate::createDefaultWindowSurface_sys()
 {
     Q_Q(QWidget);
-#ifndef QT_NO_DIRECT3D
-    extern QDirect3DPaintEngine *qt_d3dEngine();
-    if (qApp->testAttribute(Qt::AA_MSWindowsUseDirect3DByDefault) && (q->windowOpacity() == 1.0f)
-        && qt_d3dEngine()->hasDirect3DSupport()) {
-        return new QD3DWindowSurface(q);
-    }
-#endif
     return new QRasterWindowSurface(q);
 }
 
diff --git a/src/gui/mac/images/leopard-unified-toolbar-on.png b/src/gui/mac/images/leopard-unified-toolbar-on.png
new file mode 100644
index 0000000..6716597
--- /dev/null
+++ b/src/gui/mac/images/leopard-unified-toolbar-on.png
diff --git a/src/gui/mac/maccursors.qrc b/src/gui/mac/macresources.qrc
index d80a63b..9696002 100644
--- a/src/gui/mac/maccursors.qrc
+++ b/src/gui/mac/macresources.qrc
@@ -6,4 +6,7 @@
 <file>images/waitcursor.png</file>
 <file>images/pluscursor.png</file>
 </qresource>
+<qresource prefix="/trolltech/mac/style">
+<file>images/leopard-unified-toolbar-on.png</file>
+</qresource>
 </RCC>
diff --git a/src/gui/painting/painting.pri b/src/gui/painting/painting.pri
index 528559c..34d1779 100644
--- a/src/gui/painting/painting.pri
+++ b/src/gui/painting/painting.pri
@@ -103,12 +103,6 @@ win32 {
                 painting/qprinterinfo_win.cpp \
                 painting/qregion_win.cpp
         !win32-borland:!wince*:LIBS += -lmsimg32
-        contains(QT_CONFIG, direct3d) {
-                HEADERS += painting/qpaintengine_d3d_p.h
-                SOURCES += painting/qpaintengine_d3d.cpp
-                RESOURCES += painting/qpaintengine_d3d.qrc
-                LIBS += -ldxguid
-        }
 }
 
 embedded {
@@ -362,8 +356,4 @@ embedded {
         SOURCES += painting/qwindowsurface_qws.cpp
 }
 
-win32:contains(QT_CONFIG, direct3d) {
-        HEADERS += painting/qwindowsurface_d3d_p.h
-        SOURCES += painting/qwindowsurface_d3d.cpp
-}
 
diff --git a/src/gui/painting/qbackingstore.cpp b/src/gui/painting/qbackingstore.cpp
index fbac811a..34df6c9 100644
--- a/src/gui/painting/qbackingstore.cpp
+++ b/src/gui/painting/qbackingstore.cpp
@@ -1517,13 +1517,20 @@ void QWidgetPrivate::repaint_sys(const QRegion &rgn)
         extra->staticContentsSize = data.crect.size();
     }
 
+    QPaintEngine *engine = q->paintEngine();
+    // 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)
+                                        && (usesDoubleBufferedGLContext || q->autoFillBackground());
+    QRegion toBePainted(noPartialUpdateSupport ? q->rect() : rgn);
+
 #ifdef Q_WS_MAC
     // No difference between update() and repaint() on the Mac.
-    update_sys(rgn);
+    update_sys(toBePainted);
     return;
 #endif
 
-    QRegion toBePainted(rgn);
     toBePainted &= clipRect();
     clipToEffectiveMask(toBePainted);
     if (toBePainted.isEmpty())
diff --git a/src/gui/painting/qmemrotate.cpp b/src/gui/painting/qmemrotate.cpp
index 7ad0e42..4058143 100644
--- a/src/gui/painting/qmemrotate.cpp
+++ b/src/gui/painting/qmemrotate.cpp
@@ -537,6 +537,7 @@ 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)
 #ifdef QT_QWS_DEPTH_GENERIC
 QT_IMPL_MEMROTATE(quint32, qrgb_generic16)
diff --git a/src/gui/painting/qmemrotate_p.h b/src/gui/painting/qmemrotate_p.h
index bd6006b..c1eb93e 100644
--- a/src/gui/painting/qmemrotate_p.h
+++ b/src/gui/painting/qmemrotate_p.h
@@ -90,6 +90,7 @@ 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_DEPTH_GENERIC
 QT_DECL_MEMROTATE(quint32, qrgb_generic16);
diff --git a/src/gui/painting/qpaintengine.cpp b/src/gui/painting/qpaintengine.cpp
index ad09060..7de1ec4 100644
--- a/src/gui/painting/qpaintengine.cpp
+++ b/src/gui/painting/qpaintengine.cpp
@@ -949,8 +949,8 @@ 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 set.
-    if (d->hasSystemTransform) {
+    // if we currently have a system transform/viewport set.
+    if (d->hasSystemTransform || d->hasSystemViewport) {
         d->transformSystemClip();
         d->systemStateChanged();
     }
diff --git a/src/gui/painting/qpaintengine_d3d.cpp b/src/gui/painting/qpaintengine_d3d.cpp
deleted file mode 100644
index 9a7638b..0000000
--- a/src/gui/painting/qpaintengine_d3d.cpp
+++ /dev/null
@@ -1,4576 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
-** Beta Release License Agreement.
-**
-** 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.0, included in the file LGPL_EXCEPTION.txt in this
-** package.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3.0 as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU General Public License version 3.0 requirements will be
-** met: http://www.gnu.org/copyleft/gpl.html.
-**
-** If you are unsure which license is appropriate for your use, please
-** contact the sales department at qt-sales@nokia.com.
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include <qdebug.h>
-#include "qpaintengine_d3d_p.h"
-
-#include "private/qdrawhelper_p.h"
-#include "private/qfont_p.h"
-#include "private/qfontengine_p.h"
-#include "private/qpaintengine_p.h"
-#include "private/qtessellator_p.h"
-#include <private/qbezier_p.h>
-#include <private/qpainter_p.h>
-#include <private/qpixmap_raster_p.h>
-#include <private/qpolygonclipper_p.h>
-#include <qbuffer.h>
-#include <qcache.h>
-#include <qdir.h>
-#include <qfileinfo.h>
-#include <qlibrary.h>
-#include <qlibraryinfo.h>
-#include <qmath.h>
-#include <qpaintdevice.h>
-#include <qpixmapcache.h>
-
-#include <qwidget.h>
-#include <d3d9.h>
-#include <d3dx9.h>
-
-#include <mmintrin.h>
-#include <xmmintrin.h>
-
-QT_BEGIN_NAMESPACE
-
-#ifndef M_PI
-    #define M_PI 3.14159265358979323846
-#endif
-
-#define QD3D_MASK_MARGIN 1
-#define QD3D_BATCH_SIZE 256
-
-// for the ClearType detection stuff..
-#ifndef SPI_GETFONTSMOOTHINGTYPE
-#define SPI_GETFONTSMOOTHINGTYPE 0x200A
-#endif
-
-#ifndef FE_FONTSMOOTHINGCLEARTYPE
-#define FE_FONTSMOOTHINGCLEARTYPE 0x0002
-#endif
-
-//#include <performance.h>
-#define PM_INIT
-#define PM_MEASURE(A)
-#define PM_DISPLAY
-
-//debugging
-//#define QT_DEBUG_VERTEXBUFFER_ACCESS
-//#define QT_DEBUG_D3D
-//#define QT_DEBUG_D3D_CALLS
-
-#define QD3D_SET_MARK(output) \
-    D3DPERF_SetMarker(0, QString(output).utf16());
-
-#define QT_VERTEX_RESET_LIMIT   24576
-#define QT_VERTEX_BUF_SIZE      32768
-#define QD3DFVF_CSVERTEX (D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX2 | D3DFVF_TEXCOORDSIZE4(0) |  D3DFVF_TEXCOORDSIZE4(1))
-
-// this is a different usage of the effect framework than intended,
-// but it's convenient for us to use (See effect file)
-#define PASS_STENCIL_ODDEVEN                0
-#define PASS_STENCIL_WINDING                1
-#define PASS_STENCIL_DRAW                   2
-#define PASS_STENCIL_DRAW_DIRECT            3
-#define PASS_STENCIL_CLIP                   4
-#define PASS_STENCIL_NOSTENCILCHECK         5
-#define PASS_STENCIL_NOSTENCILCHECK_DIRECT  6
-#define PASS_TEXT                           7
-#define PASS_CLEARTYPE_TEXT                 8
-#define PASS_ALIASED_LINES                  9
-#define PASS_ALIASED_LINES_DIRECT          10
-
-#define PASS_AA_CREATEMASK                  0
-#define PASS_AA_DRAW                        1
-#define PASS_AA_DRAW_DIRECT                 2
-
-#define D3D_STAGE_COUNT             2
-#define D3D_RENDER_STATES           210
-#define D3D_TEXTURE_STATES          33
-#define D3D_SAMPLE_STATES           14
-
-
-typedef HRESULT (APIENTRY *PFND3DXCREATEBUFFER)(DWORD, LPD3DXBUFFER *);
-typedef HRESULT (APIENTRY *PFND3DXCREATEEFFECT)(LPDIRECT3DDEVICE9, LPCVOID, UINT, CONST D3DXMACRO *,
-                                                LPD3DXINCLUDE, DWORD, LPD3DXEFFECTPOOL,
-                                                LPD3DXEFFECT *, LPD3DXBUFFER *);
-typedef D3DXMATRIX *(APIENTRY *PFND3DXMATRIXORTHOOFFCENTERLH)(D3DMATRIX *, FLOAT, FLOAT,
-                                                              FLOAT, FLOAT, FLOAT, FLOAT);
-typedef IDirect3D9 *(APIENTRY *PFNDIRECT3DCREATE9)(uint);
-
-static PFNDIRECT3DCREATE9 pDirect3DCreate9 = 0;
-static PFND3DXCREATEBUFFER pD3DXCreateBuffer = 0;
-static PFND3DXCREATEEFFECT pD3DXCreateEffect = 0;
-static PFND3DXMATRIXORTHOOFFCENTERLH pD3DXMatrixOrthoOffCenterLH = 0;
-
-
-class QD3DSurfaceManager : public QObject {
-    Q_OBJECT
-
-public:
-    enum QD3DSurfaceManagerStatus {
-        NoStatus = 0,
-        NeedsResetting = 0x01,
-        MaxSizeChanged = 0x02
-    };
-
-    QD3DSurfaceManager();
-    ~QD3DSurfaceManager();
-
-    void init(LPDIRECT3D9 object);
-
-    void setPaintDevice(QPaintDevice *pd);
-
-    int status() const;
-    void reset();
-
-    LPDIRECT3DSURFACE9 renderTarget();
-
-    LPDIRECT3DSURFACE9 surface(QPaintDevice *pd);
-    LPDIRECT3DSWAPCHAIN9 swapChain(QPaintDevice *pd);
-    void releasePaintDevice(QPaintDevice *pd);
-
-    LPDIRECT3DDEVICE9 device();
-    void cleanup();
-
-    QSize maxSize() const;
-
-private:
-    struct D3DSwapChain {
-        QSize size;
-        LPDIRECT3DSWAPCHAIN9 swapchain;
-        LPDIRECT3DSURFACE9 surface;
-    };
-
-    void updateMaxSize();
-    void initPresentParameters(D3DPRESENT_PARAMETERS *params);
-    D3DSwapChain *createSwapChain(QWidget *w);
-
-    QSize m_max_size;
-    int m_status;
-    QMap<QPaintDevice *, D3DSwapChain *> m_swapchains;
-
-    LPDIRECT3DDEVICE9 m_device;
-    QPaintDevice *m_pd;
-    HWND m_dummy;
-    D3DSwapChain *m_current;
-
-private Q_SLOTS:
-    void cleanupPaintDevice(QObject *);
-};
-
-struct vertex {
-    D3DVECTOR pos;
-    DWORD color;
-    FLOAT s0, t0, r0, q0;
-    FLOAT s1, t1, r1, q1;
-};
-
-struct QD3DMaskPosition {
-    int x, y, channel;
-};
-
-
-struct QD3DBatchItem {
-    enum QD3DBatchInfo {
-        BI_WINDING          = 0x0001,
-        BI_AA               = 0x0002,
-        BI_BRECT            = 0x0004,
-        BI_MASKFULL         = 0x0008,
-        BI_TEXT             = 0x0010,
-        BI_MASK             = 0x0020,
-        BI_CLIP             = 0x0040,
-        BI_SCISSOR          = 0x0080,
-
-        BI_PIXMAP           = 0x0100,
-        BI_IMAGE            = 0x0200,
-        BI_COMPLEXBRUSH     = 0x0400,
-
-        BI_CLEARCLIP        = 0x0800, // clip nothing (filling the clip mask with 0)
-        BI_TRANSFORM        = 0x1000,
-        BI_MASKSCISSOR      = 0x2000,
-        BI_FASTLINE         = 0x4000,
-        BI_COSMETICPEN      = 0x8000
-    };
-
-    int m_info;
-
-    int m_count;
-    int m_offset;
-
-    QD3DMaskPosition m_maskpos;
-    qreal m_xoffset;
-    qreal m_yoffset;
-    qreal m_opacity;
-
-    QPixmap m_pixmap;
-    QRectF m_brect;
-    QBrush m_brush;
-
-    IDirect3DTexture9 *m_texture;
-
-    qreal m_width;
-    qreal m_distance;
-
-    QTransform m_matrix;
-    QPainter::CompositionMode m_cmode;
-
-    QVector<int> m_pointstops;
-};
-
-struct QD3DBatch {
-    int m_item_index;
-    QD3DBatchItem items[QD3D_BATCH_SIZE];
-};
-
-class QD3DStateManager;
-class QD3DFontCache;
-class QD3DDrawHelper;
-class QD3DGradientCache;
-
-class QDirect3DPaintEnginePrivate : public QPaintEnginePrivate
-{
-    Q_DECLARE_PUBLIC(QDirect3DPaintEngine)
-
-public:
-    enum RenderTechnique {
-        RT_NoTechnique,
-        RT_Antialiased,
-        RT_Aliased,
-    };
-
-    QDirect3DPaintEnginePrivate()
-        : m_d3d_object(0)
-        , m_d3d_device(0)
-        , m_txop(QTransform::TxNone)
-        , m_effect(0)
-        , m_flush_on_end(0)
-    { init(); }
-
-    ~QDirect3DPaintEnginePrivate();
-
-    bool init();
-    void initDevice();
-
-    inline QD3DBatchItem *nextBatchItem();
-
-    QPolygonF brushCoordinates(const QRectF &r, bool stroke, qreal *fp) const;
-    void fillAliasedPath(QPainterPath path, const QRectF &brect, const QTransform &txform);
-    void fillAntialiasedPath(const QPainterPath &path, const QRectF &brect,
-        const QTransform &txform, bool stroke);
-    void fillPath(const QPainterPath &path, QRectF brect);
-
-    void strokePath(const QPainterPath &path, QRectF brect, bool simple = false);
-    QPainterPath strokePathFastPen(const QPainterPath &path);
-    void strokeAliasedPath(QPainterPath path, const QRectF &brect, const QTransform &txform);
-
-    void flushBatch();
-    int flushAntialiased(int offset);
-    void flushAliased(QD3DBatchItem *item, int offset);
-    void flushText(QD3DBatchItem *item, int offset);
-    void flushLines(QD3DBatchItem *item, int offset);
-
-    void updateTransform(const QTransform &matrix);
-    void updatePen(const QPen &pen);
-    void updateBrush(const QBrush &pen);
-    void updateClipRegion(const QRegion &clipregion, Qt::ClipOperation op = Qt::ReplaceClip);
-    void updateClipPath(const QPainterPath &clipregion, Qt::ClipOperation op = Qt::ReplaceClip);
-    void updateFont(const QFont &font);
-
-    void setRenderTechnique(RenderTechnique technique);
-
-    QPointF transformPoint(const QPointF &p, qreal *w) const;
-
-    bool prepareBatch(QD3DBatchItem *item, int offset);
-    void prepareItem(QD3DBatchItem *item);
-    void cleanupItem(QD3DBatchItem *item);
-    void setCompositionMode(QPainter::CompositionMode mode);
-
-    void verifyTexture(const QPixmap &pixmap);
-
-    bool isFastRect(const QRectF &rect);
-
-    void releaseDC();
-
-    void cleanup();
-    bool testCaps();
-
-    QPixmap getPattern(Qt::BrushStyle style) const;
-
-    // clipping
-    QPainterPath m_sysclip_path;
-    QPainterPath m_clip_path;
-    QRegion m_sysclip_region;
-    QRegion m_clip_region;
-
-    qreal m_opacity;
-    D3DCOLOR m_opacity_color;
-
-    int m_current_state;
-
-    ID3DXEffect* m_effect;
-
-    RenderTechnique m_current_technique;
-
-    QTransform m_matrix;
-    qreal m_inv_scale;
-
-    QPen m_pen;
-    Qt::BrushStyle m_pen_brush_style;
-    QTransform m_inv_pen_matrix;
-    D3DCOLOR m_pen_color;
-    qreal m_pen_width;
-
-    QBrush m_brush;
-    Qt::BrushStyle m_brush_style;
-    QTransform m_inv_brush_matrix;
-    D3DCOLOR m_brush_color;
-    QTransform m_brush_origin;
-
-    uint m_clipping_enabled : 1;
-    uint m_has_complex_clipping : 1;
-    uint m_cleartype_text: 1;
-    uint m_has_pen : 1;
-    uint m_has_cosmetic_pen : 1;
-    uint m_has_brush : 1;
-    uint m_has_fast_pen : 1;
-    uint m_has_aa_fast_pen : 1;
-    uint m_flush_on_end : 1;
-    uint m_supports_d3d : 1;
-
-    QTransform::TransformationType m_txop;
-
-    QPainter::CompositionMode m_cmode;
-
-    QD3DSurfaceManager m_surface_manager;
-    QSize m_surface_size;
-
-    LPDIRECT3D9 m_d3d_object;
-    LPDIRECT3DDEVICE9 m_d3d_device;
-    IDirect3DSurface9 *m_current_surface;
-    bool m_in_scene;
-
-    QD3DGradientCache *m_gradient_cache;
-    QD3DDrawHelper *m_draw_helper;
-    QD3DBatch m_batch;
-    QD3DStateManager *m_statemanager;
-
-    HDC m_dc;
-    IDirect3DSurface9 *m_dcsurface;
-
-    QMap<Qt::BrushStyle, QPixmap> m_patterns;
-};
-
-
-class QD3DStateManager : public ID3DXEffectStateManager {
-public:
-    QD3DStateManager(LPDIRECT3DDEVICE9 pDevice, ID3DXEffect *effect);
-    void reset();
-
-    inline void startStateBlock();
-    inline void endStateBlock();
-
-    inline void setCosmeticPen(bool enabled);
-    inline void setBrushMode(int mode);
-    inline void setTexture(LPDIRECT3DBASETEXTURE9 pTexture);
-    inline void setTexture(LPDIRECT3DBASETEXTURE9 pTexture, QGradient::Spread spread);
-    inline void setTransformation(const QTransform *matrix = 0);
-    inline void setProjection(const D3DXMATRIX *pMatrix);
-    inline void setMaskChannel(int channel);
-    inline void setMaskOffset(qreal x, qreal y);
-    inline void setFocalDistance(const qreal &fd);
-
-    inline void beginPass(int pass);
-    inline void endPass();
-
-    STDMETHOD(QueryInterface)(REFIID iid, LPVOID *ppv);
-    STDMETHOD_(ULONG, AddRef)();
-    STDMETHOD_(ULONG, Release)();
-
-    STDMETHOD(SetTransform)(D3DTRANSFORMSTATETYPE State, CONST D3DMATRIX *pMatrix);
-    STDMETHOD(SetMaterial)(CONST D3DMATERIAL9 *pMaterial);
-    STDMETHOD(SetLight)(DWORD Index, CONST D3DLIGHT9 *pLight);
-    STDMETHOD(LightEnable)(DWORD Index, BOOL Enable);
-    STDMETHOD(SetRenderState)(D3DRENDERSTATETYPE State, DWORD Value);
-    STDMETHOD(SetTexture)(DWORD Stage, LPDIRECT3DBASETEXTURE9 pTexture);
-    STDMETHOD(SetTextureStageState)(DWORD Stage, D3DTEXTURESTAGESTATETYPE Type, DWORD Value);
-    STDMETHOD(SetSamplerState)(DWORD Sampler, D3DSAMPLERSTATETYPE Type, DWORD Value);
-    STDMETHOD(SetNPatchMode)(FLOAT NumSegments);
-    STDMETHOD(SetFVF)(DWORD FVF);
-    STDMETHOD(SetVertexShader)(LPDIRECT3DVERTEXSHADER9 pShader);
-    STDMETHOD(SetVertexShaderConstantF)(UINT RegisterIndex, CONST FLOAT *pConstantData, UINT RegisterCount);
-    STDMETHOD(SetVertexShaderConstantI)(UINT RegisterIndex, CONST INT *pConstantData, UINT RegisterCount);
-    STDMETHOD(SetVertexShaderConstantB)(UINT RegisterIndex, CONST BOOL *pConstantData, UINT RegisterCount);
-    STDMETHOD(SetPixelShader)(LPDIRECT3DPIXELSHADER9 pShader);
-    STDMETHOD(SetPixelShaderConstantF)(UINT RegisterIndex, CONST FLOAT *pConstantData, UINT RegisterCount);
-    STDMETHOD(SetPixelShaderConstantI)(UINT RegisterIndex, CONST INT *pConstantData, UINT RegisterCount);
-    STDMETHOD(SetPixelShaderConstantB)(UINT RegisterIndex, CONST BOOL *pConstantData, UINT RegisterCount);
-private:
-    LPDIRECT3DVERTEXSHADER9 m_vertexshader;
-    LPDIRECT3DPIXELSHADER9 m_pixelshader;
-
-    LPDIRECT3DBASETEXTURE9 m_textures[D3D_STAGE_COUNT];
-    DWORD m_texturestates[D3D_STAGE_COUNT][D3D_TEXTURE_STATES];
-    DWORD m_samplerstates[D3D_STAGE_COUNT][D3D_SAMPLE_STATES];
-    DWORD m_renderstate[D3D_RENDER_STATES];
-
-    qreal m_radgradfd;
-
-    bool m_cosmetic_pen;
-    int m_pass;
-    int m_maskchannel;
-    int m_brushmode;
-    LPDIRECT3DBASETEXTURE9 m_texture;
-    D3DXMATRIX m_projection;
-
-    D3DXMATRIX m_d3dIdentityMatrix;
-    bool m_isIdentity;
-    QTransform m_transformation;
-
-    LPDIRECT3DDEVICE9 m_pDevice;
-    ID3DXEffect *m_effect;
-
-    LONG m_refs;
-    bool m_changed;
-    qreal m_xoffset, m_yoffset;
-    static int m_mask_channels[4][4];
-};
-
-//
-// font cache stuff
-//
-
-struct QD3DGlyphCoord {
-    // stores the offset and size of a glyph texture
-    qreal x;
-    qreal y;
-    qreal width;
-    qreal height;
-    qreal log_width;
-    qreal log_height;
-    QFixed x_offset;
-    QFixed y_offset;
-};
-
-struct QD3DFontTexture {
-    int x_offset; // current glyph offset within the texture
-    int y_offset;
-    int width;
-    int height;
-    IDirect3DTexture9 *texture;
-};
-
-typedef QHash<glyph_t, QD3DGlyphCoord*>  QD3DGlyphHash;
-typedef QHash<QFontEngine*, QD3DGlyphHash*> QD3DFontGlyphHash;
-typedef QHash<quint64, QD3DFontTexture*> QD3DFontTexHash;
-
-class QD3DGlyphCache : public QObject
-{
-    Q_OBJECT
-public:
-    QD3DGlyphCache()
-        : QObject(0)
-        , current_cache(0) {}
-    ~QD3DGlyphCache();
-    QD3DGlyphCoord *lookup(QFontEngine *, glyph_t);
-    void cacheGlyphs(QDirect3DPaintEngine *, const QTextItemInt &, const QVarLengthArray<glyph_t> &,
-                     bool);
-    void cleanCache();
-    inline QD3DFontTexture *fontTexture(QFontEngine *engine) {
-        return font_textures.constFind(reinterpret_cast<quint64>(engine)).value();
-    }
-
-public slots:
-    void fontEngineDestroyed(QObject *);
-
-private:
-    QImage clearTypeGlyph(QFontEngine *, glyph_t glyph);
-    QD3DGlyphHash *current_cache;
-    QD3DFontTexHash font_textures;
-    QD3DFontGlyphHash font_cache;
-};
-
-QD3DGlyphCache::~QD3DGlyphCache()
-{
-}
-
-QD3DGlyphCoord *QD3DGlyphCache::lookup(QFontEngine *, glyph_t g)
-{
-    Q_ASSERT(current_cache != 0);
-    QD3DGlyphHash::const_iterator it = current_cache->constFind(g);
-    if (it == current_cache->constEnd())
-        return 0;
-    return it.value();
-}
-
-void QD3DGlyphCache::cleanCache()
-{
-    QList<quint64> keys = font_textures.keys();
-    for (int i=0; i<keys.size(); ++i)
-        font_textures.value(keys.at(i))->texture->Release();
-
-    qDeleteAll(font_textures);
-    qDeleteAll(font_cache);
-    font_textures.clear();
-    font_cache.clear();
-    current_cache = 0;
-}
-
-void QD3DGlyphCache::fontEngineDestroyed(QObject *object)
-{
-//     qDebug() << "=> font engine destroyed: " << object;
-    QFontEngine *engine = static_cast<QFontEngine *>(object);
-
-    QD3DFontGlyphHash::iterator cache_it = font_cache.find(engine);
-    if (cache_it != font_cache.end()) {
-        QD3DGlyphHash *cache = font_cache.take(engine);
-        delete cache;
-    }
-
-    quint64 font_key = reinterpret_cast<quint64>(engine);
-    QD3DFontTexture *tex = font_textures.take(font_key);
-    if (tex) {
-        tex->texture->Release();
-        delete tex;
-    }
-}
-
-QImage QD3DGlyphCache::clearTypeGlyph(QFontEngine *engine, glyph_t glyph)
-{
-    glyph_metrics_t gm = engine->boundingBox(glyph);
-    int glyph_x = qFloor(gm.x.toReal());
-    int glyph_y = qFloor(gm.y.toReal());
-    int glyph_width = qCeil((gm.x + gm.width).toReal()) -  glyph_x + 2;
-    int glyph_height = qCeil((gm.y + gm.height).toReal()) - glyph_y + 2;
-
-    if (glyph_width + glyph_x <= 0 || glyph_height <= 0)
-        return QImage();
-    QImage im(glyph_width + glyph_x, glyph_height, QImage::Format_ARGB32_Premultiplied);
-    im.fill(0xff000000); // solid black
-    QPainter p(&im);
-
-    p.setPen(Qt::white);
-    p.setBrush(Qt::NoBrush);
-
-    QTextItemInt ti;
-    ti.ascent = engine->ascent();
-    ti.descent = engine->descent();
-    ti.width = glyph_width;
-    ti.fontEngine = engine;
-
-    QGlyphLayoutArray<1> glyphLayout;
-    ti.glyphs = glyphLayout;
-    ti.glyphs.glyphs[0] = glyph;
-    ti.glyphs.advances_x[0] = glyph_width;
-    p.drawTextItem(QPointF(-glyph_x, -glyph_y), ti);
-    p.end();
-    return im;
-}
-
-#if 0
-static void dump_font_texture(QD3DFontTexture *tex)
-{
-    QColor color(Qt::red);
-    D3DLOCKED_RECT rect;
-    if (FAILED(tex->texture->LockRect(0, &rect, 0, 0))) {
-        qDebug() << "debug: unable to lock texture rect.";
-        return;
-    }
-
-// cleartype version
-//     uint *tex_data = (uint *) rect.pBits;
-//     QImage im(tex->width, tex->height, QImage::Format_ARGB32);
-//     for (int y=0; y<tex->height; ++y) {
-//         for (int x=0; x<tex->width; ++x) {
-//             im.setPixel(x, y, ((*(tex_data+x+y*tex->width))));
-//         }
-//     }
-    uchar *tex_data = (uchar *) rect.pBits;
-    QImage im(rect.Pitch, tex->height, QImage::Format_ARGB32);
-    for (int y=0; y<tex->height; ++y) {
-        for (int x=0; x<rect.Pitch; ++x) {
-            uchar val = ((*(tex_data+x+y*rect.Pitch)));
-            im.setPixel(x, y, 0xff000000 | (val << 16) | (val << 8) | val);
-        }
-    }
-    tex->texture->UnlockRect(0);
-    static  int i= 0;
-    im.save(QString("tx%1.png").arg(i++));
-}
-#endif
-
-void QD3DGlyphCache::cacheGlyphs(QDirect3DPaintEngine *engine, const QTextItemInt &ti,
-                                 const QVarLengthArray<glyph_t> &glyphs, bool clearType)
-{
-    IDirect3DDevice9 *device = engine->d_func()->m_d3d_device;
-    QD3DFontGlyphHash::const_iterator cache_it = font_cache.constFind(ti.fontEngine);
-    QD3DGlyphHash *cache = 0;
-    if (cache_it == font_cache.constEnd()) {
-        cache = new QD3DGlyphHash;
-        font_cache.insert(ti.fontEngine, cache);
-        connect(ti.fontEngine, SIGNAL(destroyed(QObject *)), SLOT(fontEngineDestroyed(QObject *)));
-    } else {
-        cache = cache_it.value();
-    }
-
-    current_cache = cache;
-
-    D3DFORMAT tex_format = clearType ? D3DFMT_A8R8G8B8 : D3DFMT_A8;
-    quint64 font_key = reinterpret_cast<quint64>(ti.fontEngine);
-    QD3DFontTexHash::const_iterator it = font_textures.constFind(font_key);
-    QD3DFontTexture *font_tex = 0;
-    if (it == font_textures.constEnd()) {
-        // alloc a new texture, put it into the cache
-        int tex_height = qCeil(ti.ascent.toReal() + ti.descent.toReal()) + 5;
-        int tex_width = tex_height * 30; // ###
-        IDirect3DTexture9 *tex;
-        if (FAILED(device->CreateTexture(tex_width, tex_height, 1, 0,
-                                         tex_format, D3DPOOL_MANAGED, &tex, NULL)))
-        {
-            qWarning("QD3DGlyphCache::cacheGlyphs(): can't allocate font texture (%dx%d).",
-                     tex_width, tex_height);
-            return;
-        } else {
-//             qDebug() << "=> new font texture: " << QSize(tex_width,tex_height);
-            font_tex = new QD3DFontTexture;
-            font_tex->texture = tex;
-            font_tex->x_offset = 0;
-            font_tex->y_offset = 0;
-            font_tex->width = tex_width;
-            font_tex->height = tex_height;
-            font_textures.insert(font_key, font_tex);
-        }
-    } else {
-        font_tex = it.value();
-        // make it current render target..
-    }
-
-    // cache each glyph
-    for (int i=0; i<glyphs.size(); ++i) {
-        QD3DGlyphHash::const_iterator it = cache->constFind(glyphs[i]);
-        if (it == cache->constEnd()) {
-            glyph_metrics_t metrics = ti.fontEngine->boundingBox(glyphs[i]);
-            int glyph_width = qCeil(metrics.width.toReal()) + 5;
-            int glyph_height = qCeil(ti.ascent.toReal() + ti.descent.toReal()) + 5;
-            if (font_tex->x_offset + glyph_width > font_tex->width) {
-                // no room on the current line, start new glyph strip
-                int strip_height = glyph_height;
-                font_tex->x_offset = 0;
-                font_tex->y_offset += strip_height;
-                if (font_tex->y_offset >= font_tex->height) {
-                    // if no room in the current texture - realloc a larger texture
-                    int old_tex_height = font_tex->height;
-                    font_tex->height += strip_height;
-
-                    IDirect3DTexture9 *new_tex;
-                    if (FAILED(device->CreateTexture(font_tex->width, font_tex->height, 1, 0,
-                                                     tex_format, D3DPOOL_MANAGED, &new_tex, NULL)))
-                    {
-                        qWarning("QD3DGlyphCache(): can't re-allocate font texture.");
-                        return;
-                    } else {
-//                         qDebug() << " -> new glyph strip added:" << QSize(font_tex->width,font_tex->height);
-
-                        D3DLOCKED_RECT new_rect, old_rect;
-                        if (FAILED(font_tex->texture->LockRect(0, &old_rect, 0, D3DLOCK_READONLY))) {
-                            qDebug() << "QD3DGlyphCache: unable to lock texture rect.";
-                            return;
-                        }
-                        if (FAILED(new_tex->LockRect(0, &new_rect, 0, 0))) {
-                            qDebug() << "QD3DGlyphCache: unable to lock texture rect.";
-                            return;
-                        }
-                        memcpy(new_rect.pBits, old_rect.pBits, new_rect.Pitch * old_tex_height);
-                        font_tex->texture->UnlockRect(0);
-                        new_tex->UnlockRect(0);
-                        engine->d_func()->flushBatch();
-                        font_tex->texture->Release();
-                        font_tex->texture = new_tex;
-                    }
-
-                    // update the texture coords and the y offset for the existing glyphs in
-                    // the cache, because of the texture size change
-                    QD3DGlyphHash::iterator it = cache->begin();
-                    while (it != cache->end()) {
-                        it.value()->height = (it.value()->height * old_tex_height) / font_tex->height;
-                        it.value()->y = (it.value()->y * old_tex_height) / font_tex->height;
-                        ++it;
-                    }
-                }
-            }
-            QD3DGlyphCoord *d3d_glyph = new QD3DGlyphCoord;
-            d3d_glyph->x = qreal(font_tex->x_offset) / font_tex->width;
-            d3d_glyph->y = qreal(font_tex->y_offset) / font_tex->height;
-            d3d_glyph->width = qreal(glyph_width) / font_tex->width;
-            d3d_glyph->height = qreal(glyph_height) / font_tex->height;
-            d3d_glyph->log_width = d3d_glyph->width * font_tex->width;
-            d3d_glyph->log_height = d3d_glyph->height * font_tex->height;
-            d3d_glyph->x_offset = -metrics.x;
-            d3d_glyph->y_offset = metrics.y;
-
-            QImage glyph_im;
-            if (clearType)
-                glyph_im = clearTypeGlyph(ti.fontEngine, glyphs[i]);
-            else
-                glyph_im = ti.fontEngine->alphaMapForGlyph(glyphs[i]).convertToFormat(QImage::Format_Indexed8);
-
-            // write glyph to texture
-            D3DLOCKED_RECT rect;
-            RECT glyph_rect = { font_tex->x_offset, font_tex->y_offset,
-                                font_tex->x_offset + glyph_im.width(),
-                                font_tex->y_offset + glyph_im.height() };
-
-//             qDebug() << "  > new glyph char added:" << QSize(glyph_im.width(), glyph_im.height());
-            if (FAILED(font_tex->texture->LockRect(0, &rect, &glyph_rect, 0))) {
-                qDebug() << "QD3DGlyphCache: unable to lock texture rect.";
-                return;
-            }
-
-            // ### unify these loops
-            if (clearType) {
-                int ppl = rect.Pitch / 4;
-                uint *tex_data = (uint *) rect.pBits;
-                for (int y=0; y<glyph_im.height(); ++y) {
-                    uint *s = (uint *) glyph_im.scanLine(y);
-                    for (int x=0; x<glyph_im.width(); ++x) {
-                        tex_data[ppl*y + x] = *s;
-                        ++s;
-                    }
-                }
-            } else {
-                int ppl = rect.Pitch;
-                uchar *tex_data = (uchar *) rect.pBits;
-                for (int y=0; y<glyph_im.height(); ++y) {
-                    uchar *s = (uchar *) glyph_im.scanLine(y);
-                    for (int x=0; x<glyph_im.width(); ++x) {
-                        tex_data[ppl*y + x] = *s;
-                        ++s;
-                    }
-                }
-            }
-            font_tex->texture->UnlockRect(0);
-
-            // debug
-//             dump_font_texture(font_tex);
-
-            if (font_tex->x_offset + glyph_width > font_tex->width) {
-                font_tex->x_offset = 0;
-                font_tex->y_offset += glyph_height;
-            } else {
-                font_tex->x_offset += glyph_width;
-            }
-
-            cache->insert(glyphs[i], d3d_glyph);
-        }
-    }
-}
-
-Q_GLOBAL_STATIC(QD3DGlyphCache, qd3d_glyph_cache)
-
-//
-// end font caching stuff
-//
-
-
-//
-//  D3D image cache stuff
-//
-
-// ### keep the GL stuff in mind..
-typedef void (*_qt_image_cleanup_hook_64)(qint64);
-extern Q_GUI_EXPORT _qt_image_cleanup_hook_64 qt_image_cleanup_hook_64;
-
-static void qd3d_image_cleanup(qint64 key);
-
-class QD3DImage
-{
-public:
-    QD3DImage(IDirect3DDevice9 *device, const QImage &image);
-    ~QD3DImage();
-
-    IDirect3DTexture9 *texture;
-};
-
-static QList<IDirect3DTexture9 *> qd3d_release_list;
-
-QD3DImage::QD3DImage(IDirect3DDevice9 *device, const QImage &image)
-{
-    texture = 0;
-    Q_ASSERT(device);
-    QImage im = image.convertToFormat(QImage::Format_ARGB32);
-    if (FAILED(device->CreateTexture(im.width(), im.height(), 1, 0,
-                                     D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &texture, 0))) {
-        qWarning("QD3DImage(): unable to create Direct3D texture.");
-        return;
-    }
-//     qDebug(" -> created image texture: %p - 0x%08x%08x",texture,uint (image.cacheKey() >> 32),uint (image.cacheKey() & 0xffffffff));
-    D3DLOCKED_RECT rect;
-    if (FAILED(texture->LockRect(0, &rect, 0, 0))) {
-        qDebug() << "QD3DImage: unable to lock texture rect.";
-        return;
-    }
-    DWORD *dst = (DWORD *) rect.pBits;
-    DWORD *src = (DWORD *) im.scanLine(0);
-
-    Q_ASSERT((rect.Pitch/4) == (im.bytesPerLine()/4));
-    memcpy(dst, src, rect.Pitch*im.height());
-    texture->UnlockRect(0);
-}
-
-QD3DImage::~QD3DImage()
-{
-    if (texture)
-        qd3d_release_list.append(texture);
-}
-
-static int qd3d_cache_limit = 64*1024; // cache ~64 MB worth of textures
-typedef QCache<quint64, QD3DImage> QD3DImageCache;
-
-class QD3DImageManager
-{
-public:
-    QD3DImageManager() {
-        // ### GL does the same!
-        qt_image_cleanup_hook_64 = qd3d_image_cleanup;
-        cache.setMaxCost(qd3d_cache_limit);
-    }
-    ~QD3DImageManager() {
-//         qDebug() << "unhooking d3d image cache";
-        qt_image_cleanup_hook_64 = 0;
-        cache.clear();
-    }
-
-    IDirect3DTexture9 *lookup(IDirect3DDevice9 *device, const QImage &image);
-    void remove(quint64 key);
-
-private:
-    QD3DImageCache cache;
-};
-
-IDirect3DTexture9 *QD3DImageManager::lookup(IDirect3DDevice9 *device, const QImage &image)
-{
-    QD3DImage *tex_image = 0;
-
-    tex_image = cache.object(image.cacheKey());
-    if (!tex_image) {
-        // to avoid cache thrashing we remove images from the cache
-        // that have the same serial no as the cached image, since
-        // that image is most likely destoyed already, and we got a
-        // stale cache entry
-        uint serial = (uint) (image.cacheKey() >> 32);
-        QList<quint64> keys = cache.keys();
-        for (int i=0; i<keys.size(); ++i) {
-            if ((uint)(keys.at(i) >> 32) == serial) {
-                cache.remove(keys.at(i));
-                break;
-            }
-        }
-//         qDebug(" => cached: %d, adding cache image: 0x%08x%08x",cache.size(), uint (image.cacheKey() >> 32),uint (image.cacheKey() & 0xffffffff));
-        // add cache entry
-        int cost = image.width()*image.height()*4/1024;
-        if (cache.totalCost() + cost > cache.maxCost()) {
-            // no room for new entries? kick out half the cached images
-            int old_max_cost = cache.maxCost();
-            cache.setMaxCost(old_max_cost/2);
-            cache.setMaxCost(old_max_cost);
-        }
-        tex_image = new QD3DImage(device, image);
-        cache.insert(image.cacheKey(), tex_image, cost);
-//         qDebug() << "==> total cache cost: " << cache.totalCost() << cost;
-    }
-
-    return tex_image->texture;
-}
-
-void QD3DImageManager::remove(quint64 key)
-{
-//     QList<quint64> keys = cache.keys();
-//     if (keys.contains(key))
-//         qDebug() << "entery removed from cache";
-    cache.remove(key);
-}
-
-Q_GLOBAL_STATIC(QD3DImageManager, qd3d_image_cache)
-
-static void qd3d_image_cleanup(qint64 key)
-{
-//     qDebug() << "qd3d_image_cleanup:";
-//     qDebug("  => key: 0x%08x%08x", (uint) (key >> 32), (uint)(key & 0xffffffff));
-    qd3d_image_cache()->remove(key);
-}
-
-//
-// end D3D image cache stuff
-//
-
-class QD3DDrawHelper : public QTessellator
-{
-public:
-    QD3DDrawHelper(QDirect3DPaintEnginePrivate *pe);
-    ~QD3DDrawHelper();
-
-    bool needsFlushing() const;
-    QD3DMaskPosition allocateMaskPosition(const QRectF &brect, bool *breakbatch);
-
-    void setClipPath(const QPainterPath &path, QD3DBatchItem **item);
-
-    void queueAntialiasedMask(const QPolygonF &poly, QD3DBatchItem **item, const QRectF &brect);
-    QRectF queueAliasedMask(const QPainterPath &path, QD3DBatchItem **item, D3DCOLOR color);
-
-    void queueRect(const QRectF &rect, QD3DBatchItem *item, D3DCOLOR color, const QPolygonF &trect);
-    void queueRect(const QRectF &rect, QD3DBatchItem *item, D3DCOLOR color);
-
-    void queueTextGlyph(const QRectF &rect, const qreal *tex_coords, QD3DBatchItem *item,
-                        D3DCOLOR color);
-
-    void queueAntialiasedLines(const QPainterPath &path, QD3DBatchItem **item, const QRectF &brect);
-    void queueAliasedLines(const QLineF *lines, int lineCount, QD3DBatchItem **item);
-
-    int drawAntialiasedMask(int offset, int maxoffset);
-    void drawAliasedMask(int offset);
-    void drawAntialiasedBoundingRect(QD3DBatchItem *item);
-    void drawAliasedBoundingRect(QD3DBatchItem *item);
-    void drawTextItem(QD3DBatchItem *item);
-    void drawAliasedLines(QD3DBatchItem *item);
-
-    void setMaskSize(QSize size);
-
-    void beforeReset();
-    void afterReset();
-
-    IDirect3DSurface9 *freeMaskSurface();
-
-    inline void lockVertexBuffer();
-    inline void unlockVertexBuffer();
-
-    inline int index() { return m_index; }
-
-#ifdef QT_DEBUG_VERTEXBUFFER_ACCESS
-    enum VertexBufferAccess {
-        CLEAR   = 0x00,
-        READ    = 0x01,
-        WRITE   = 0x02
-    };
-    int accesscontrol[QT_VERTEX_BUF_SIZE];
-#endif
-
-private:
-    void addTrap(const Trapezoid &trap);
-    void tessellate(const QPolygonF &poly);
-    inline void lineToStencil(qreal x, qreal y);
-    inline void curveToStencil(const QPointF &cp1, const QPointF &cp2, const QPointF &ep);
-    QRectF pathToVertexArrays(const QPainterPath &path);
-    void resetMask();
-
-    QDirect3DPaintEnginePrivate *m_pe;
-
-    qreal m_xoffset, m_yoffset;
-    int m_startindex;
-    int m_index;
-    int m_height, m_width;
-    LPDIRECT3DVERTEXBUFFER9 m_d3dvbuff;
-    vertex *m_vbuff;
-    QD3DBatchItem *m_item;
-    QRectF m_boundingRect;
-
-    qreal max_x;
-    qreal max_y;
-    qreal min_x;
-    qreal min_y;
-    qreal firstx;
-    qreal firsty;
-
-    QPointF tess_lastpoint;
-    int tess_index;
-
-    bool m_locked;
-    IDirect3DTexture9 *m_mask;
-    IDirect3DSurface9 *m_maskSurface;
-    IDirect3DSurface9 *m_depthStencilSurface;
-
-    D3DCOLOR m_color;
-    bool m_clearmask;
-    bool m_isLine;
-    bool m_firstPoint;
-
-    QD3DMaskPosition m_mask_position;
-    int m_mask_offsetX2;
-    int m_mask_offsetY2;
-};
-
-QD3DStateManager::QD3DStateManager(LPDIRECT3DDEVICE9 pDevice, ID3DXEffect *effect)
-    : m_pDevice(pDevice), m_effect(effect), m_refs(0)
-{
-    if (FAILED(D3DXMatrixIdentity(&m_d3dIdentityMatrix))) {
-        qWarning("QDirect3DPaintEngine: D3DXMatrixIdentity failed");
-    }
-    reset();
-}
-
-void QD3DStateManager::reset()
-{
-    m_radgradfd = -1;
-
-    m_cosmetic_pen = false;
-    m_pass = -1;
-    m_maskchannel = -1;
-    m_brushmode = -1;
-    m_texture = 0;
-    m_xoffset = INT_MAX;
-    m_yoffset = INT_MAX;
-
-    m_vertexshader = 0;
-    m_pixelshader = 0;
-
-    m_isIdentity = true;
-    m_transformation = QTransform();
-    m_effect->SetMatrix("g_mTransformation", &m_d3dIdentityMatrix);
-
-    ZeroMemory(&m_projection, sizeof(D3DMATRIX));
-    ZeroMemory(m_textures, sizeof(LPDIRECT3DBASETEXTURE9) * D3D_STAGE_COUNT);
-    FillMemory(m_samplerstates, sizeof(DWORD) * D3D_SAMPLE_STATES * D3D_STAGE_COUNT, 0xFFFFFFFE);
-    FillMemory(m_texturestates, sizeof(DWORD) * D3D_TEXTURE_STATES * D3D_STAGE_COUNT, 0xFFFFFFFE);
-    FillMemory(m_renderstate, sizeof(DWORD) * D3D_RENDER_STATES, 0xFFFFFFFE);
-}
-
-inline void QD3DStateManager::beginPass(int pass)
-{
-    if (pass != m_pass) {
-        if (m_pass != -1)
-            m_effect->EndPass();
-        m_effect->BeginPass(pass);
-        m_pass = pass;
-    }
-}
-
-inline void QD3DStateManager::endPass()
-{
-    if (m_pass != -1) {
-        m_pass = -1;
-        m_effect->EndPass();
-    }
-}
-
-inline void QD3DStateManager::startStateBlock() {
-    m_changed = false;
-}
-
-inline void QD3DStateManager::setCosmeticPen(bool enabled)
-{
-    if (enabled != m_cosmetic_pen) {
-        m_effect->SetBool("g_mCosmeticPen", enabled);
-        m_cosmetic_pen = enabled;
-        m_changed = true;
-    }
-}
-
-inline void QD3DStateManager::setBrushMode(int mode)
-{
-    if (mode != m_brushmode) {
-        m_effect->SetInt("g_mBrushMode", mode);
-        m_brushmode = mode;
-        m_changed = true;
-    }
-}
-
-inline void QD3DStateManager::setTexture(LPDIRECT3DBASETEXTURE9 pTexture)
-{
-    SetSamplerState(0, D3DSAMP_ADDRESSU, D3DTADDRESS_BORDER);
-    SetSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_BORDER);
-
-    if (pTexture != m_texture) {
-        m_texture = pTexture;
-        m_effect->SetTexture("g_mTexture", pTexture);
-        m_changed = true;
-    }
-}
-
-inline void QD3DStateManager::setTexture(LPDIRECT3DBASETEXTURE9 pTexture, QGradient::Spread spread)
-{
-    switch(spread) {
-        case QGradient::RepeatSpread:
-            SetSamplerState(0, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP);
-            SetSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP);
-            break;
-        case QGradient::ReflectSpread:
-            SetSamplerState(0, D3DSAMP_ADDRESSU, D3DTADDRESS_MIRROR);
-            SetSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_MIRROR);
-            break;
-        default:
-            SetSamplerState(0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
-            SetSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
-            break;
-    };
-
-    if (pTexture != m_texture) {
-        m_texture = pTexture;
-        m_effect->SetTexture("g_mTexture", pTexture);
-        m_changed = true;
-    }
-}
-
-inline void QD3DStateManager::setTransformation(const QTransform *matrix)
-{
-    if (matrix) {
-        if (*matrix != m_transformation) {
-            D3DXMATRIX dxmatrix(matrix->m11(), matrix->m12(), 0, matrix->m13(),
-                    matrix->m21(), matrix->m22(), 0, matrix->m23(),
-                    0, 0, 1, 0,
-                    matrix->dx(), matrix->dy(), 0, 1);
-            m_effect->SetMatrix("g_mTransformation", &dxmatrix);
-            m_transformation = *matrix;
-            m_changed = true;
-            m_isIdentity = false;
-        }
-    } else if (!m_isIdentity) {
-        m_effect->SetMatrix("g_mTransformation", &m_d3dIdentityMatrix);
-        m_transformation = QTransform();
-        m_changed = true;
-        m_isIdentity = true;
-    }
-}
-
-inline void QD3DStateManager::setProjection(const D3DXMATRIX *pMatrix)
-{
-    if (*pMatrix != m_projection) {
-        m_effect->SetMatrix("g_mViewProjection", pMatrix);
-        m_projection = *pMatrix;
-        m_changed = true;
-    }
-}
-
-inline void QD3DStateManager::setFocalDistance(const qreal &fd)
-{
-    if (fd != m_radgradfd) {
-        m_effect->SetFloat("g_mFocalDist", fd);
-        m_changed = true;
-        m_radgradfd = fd;
-    }
-}
-
-inline void QD3DStateManager::setMaskOffset(qreal x, qreal y)
-{
-    if (x != m_xoffset || y != m_yoffset) {
-        float offset[2] = {x, y};
-        m_effect->SetFloatArray("g_mMaskOffset", offset, 2);
-        m_xoffset = x;
-        m_yoffset = y;
-        m_changed = true;
-    }
-}
-
-inline void QD3DStateManager::setMaskChannel(int channel)
-{
-    if (m_maskchannel != channel) {
-        m_effect->SetIntArray("g_mChannel", m_mask_channels[channel], 4);
-        m_maskchannel = channel;
-        m_changed = true;
-    }
-}
-
-inline void QD3DStateManager::endStateBlock()
-{
-    if (m_changed) {
-        m_effect->CommitChanges();
-        m_changed = false;
-    }
-}
-
-STDMETHODIMP QD3DStateManager::QueryInterface(REFIID iid, LPVOID *ppv)
-{
-    if(iid == IID_IUnknown || iid == IID_ID3DXEffectStateManager)
-    {
-        *ppv = this;
-        ++m_refs;
-        return NOERROR;
-    }
-    *ppv = NULL;
-    return ResultFromScode(E_NOINTERFACE);
-}
-
-STDMETHODIMP_(ULONG) QD3DStateManager::AddRef(void)
-{
-    return (ULONG)InterlockedIncrement( &m_refs );
-}
-
-
-STDMETHODIMP_(ULONG) QD3DStateManager::Release(void)
-{
-    if( 0L == InterlockedDecrement( &m_refs ) ) {
-        delete this;
-        return 0L;
-    }
-
-    return m_refs;
-}
-STDMETHODIMP QD3DStateManager::SetTransform(D3DTRANSFORMSTATETYPE State, CONST D3DMATRIX *pMatrix)
-{
-    return m_pDevice->SetTransform(State, pMatrix);
-}
-
-STDMETHODIMP QD3DStateManager::SetMaterial(CONST D3DMATERIAL9 *pMaterial)
-{
-    return m_pDevice->SetMaterial(pMaterial);
-}
-
-STDMETHODIMP QD3DStateManager::SetLight(DWORD Index, CONST D3DLIGHT9 *pLight)
-{
-    return m_pDevice->SetLight(Index, pLight);
-}
-
-STDMETHODIMP QD3DStateManager::LightEnable(DWORD Index, BOOL Enable)
-{
-    return m_pDevice->LightEnable(Index, Enable);
-}
-
-STDMETHODIMP QD3DStateManager::SetRenderState(D3DRENDERSTATETYPE State, DWORD Value)
-{
-    if (State < D3D_RENDER_STATES) {
-        if (m_renderstate[State] == Value)
-            return S_OK;
-        m_renderstate[State] = Value;
-    }
-    return m_pDevice->SetRenderState(State, Value);
-}
-
-STDMETHODIMP QD3DStateManager::SetTexture(DWORD Stage, LPDIRECT3DBASETEXTURE9 pTexture)
-{
-    if (Stage < D3D_STAGE_COUNT) {
-        if (m_textures[Stage] == pTexture)
-            return S_OK;
-        m_textures[Stage] = pTexture;
-    }
-    return m_pDevice->SetTexture(Stage, pTexture);
-}
-
-STDMETHODIMP QD3DStateManager::SetTextureStageState(DWORD Stage, D3DTEXTURESTAGESTATETYPE Type, DWORD Value)
-{
-    if (Stage < D3D_STAGE_COUNT && Type < D3D_TEXTURE_STATES) {
-        if (m_texturestates[Stage][Type] == Value)
-            return S_OK;
-        m_texturestates[Stage][Type] = Value;
-    }
-    return m_pDevice->SetTextureStageState(Stage, Type, Value);
-}
-
-STDMETHODIMP QD3DStateManager::SetSamplerState(DWORD Sampler, D3DSAMPLERSTATETYPE Type, DWORD Value)
-{
-    if (Sampler < D3D_STAGE_COUNT && Type < D3D_SAMPLE_STATES) {
-        if (m_samplerstates[Sampler][Type] == Value)
-            return S_OK;
-        m_samplerstates[Sampler][Type] = Value;
-    }
-    return m_pDevice->SetSamplerState(Sampler, Type, Value);
-}
-
-STDMETHODIMP QD3DStateManager::SetNPatchMode(FLOAT NumSegments)
-{
-    return m_pDevice->SetNPatchMode(NumSegments);
-}
-
-STDMETHODIMP QD3DStateManager::SetFVF(DWORD FVF)
-{
-    return m_pDevice->SetFVF(FVF);
-}
-
-STDMETHODIMP QD3DStateManager::SetVertexShader(LPDIRECT3DVERTEXSHADER9 pShader)
-{
-    if (m_vertexshader == pShader)
-        return S_OK;
-    m_vertexshader = pShader;
-    return m_pDevice->SetVertexShader(pShader);
-}
-
-STDMETHODIMP QD3DStateManager::SetVertexShaderConstantF(UINT RegisterIndex, CONST FLOAT *pConstantData, UINT RegisterCount)
-{
-    return m_pDevice->SetVertexShaderConstantF(RegisterIndex, pConstantData, RegisterCount);
-}
-
-STDMETHODIMP QD3DStateManager::SetVertexShaderConstantI(UINT RegisterIndex, CONST INT *pConstantData, UINT RegisterCount)
-{
-    return m_pDevice->SetVertexShaderConstantI(RegisterIndex, pConstantData, RegisterCount);
-}
-
-STDMETHODIMP QD3DStateManager::SetVertexShaderConstantB(UINT RegisterIndex, CONST BOOL *pConstantData, UINT RegisterCount)
-{
-    return m_pDevice->SetVertexShaderConstantB(RegisterIndex, pConstantData, RegisterCount);
-}
-
-STDMETHODIMP QD3DStateManager::SetPixelShader(LPDIRECT3DPIXELSHADER9 pShader)
-{
-    if (m_pixelshader == pShader)
-        return S_OK;
-    m_pixelshader = pShader;
-    return m_pDevice->SetPixelShader(pShader);
-}
-
-STDMETHODIMP QD3DStateManager::SetPixelShaderConstantF(UINT RegisterIndex, CONST FLOAT *pConstantData, UINT RegisterCount)
-{
-    return m_pDevice->SetPixelShaderConstantF(RegisterIndex, pConstantData, RegisterCount);
-}
-
-STDMETHODIMP QD3DStateManager::SetPixelShaderConstantI(UINT RegisterIndex, CONST INT *pConstantData, UINT RegisterCount)
-{
-    return m_pDevice->SetPixelShaderConstantI(RegisterIndex, pConstantData, RegisterCount);
-}
-
-STDMETHODIMP QD3DStateManager::SetPixelShaderConstantB(UINT RegisterIndex, CONST BOOL *pConstantData, UINT RegisterCount)
-{
-    return m_pDevice->SetPixelShaderConstantB(RegisterIndex, pConstantData, RegisterCount);
-}
-
-#define QD3D_GRADIENT_CACHE_SIZE    60
-#define QD3D_GRADIENT_PALETTE_SIZE  1024
-
-class QD3DGradientCache
-{
-    struct CacheInfo
-    {
-        inline CacheInfo(QGradientStops s, qreal op) :
-            stops(s), opacity(op) {}
-
-        IDirect3DTexture9 *texture;
-        QGradientStops stops;
-        qreal opacity;
-    };
-
-    typedef QMultiHash<quint64, CacheInfo> QD3DGradientColorTableHash;
-
-public:
-    QD3DGradientCache(LPDIRECT3DDEVICE9 device);
-    ~QD3DGradientCache();
-
-    inline IDirect3DTexture9 *getBuffer(const QGradientStops &stops, qreal opacity);
-
-protected:
-    inline void generateGradientColorTable(const QGradientStops& s,
-                                           uint *colorTable,
-                                           int size, qreal opacity) const;
-    IDirect3DTexture9 *addCacheElement(quint64 hash_val, const QGradientStops &stops, qreal opacity);
-    void cleanCache();
-
-    QD3DGradientColorTableHash cache;
-    LPDIRECT3DDEVICE9 m_device;
-};
-
-QD3DGradientCache::QD3DGradientCache(LPDIRECT3DDEVICE9 device)
-    : m_device(device)
-{
-
-}
-
-QD3DGradientCache::~QD3DGradientCache()
-{
-    cleanCache();
-}
-
-inline IDirect3DTexture9 *QD3DGradientCache::getBuffer(const QGradientStops &stops, qreal opacity)
-{
-    quint64 hash_val = 0;
-
-    for (int i = 0; i < stops.size() && i <= 2; i++)
-        hash_val += stops[i].second.rgba();
-
-    QD3DGradientColorTableHash::const_iterator it = cache.constFind(hash_val);
-
-    if (it == cache.constEnd())
-        return addCacheElement(hash_val, stops, opacity);
-    else {
-        do {
-            const CacheInfo &cache_info = it.value();
-            if (cache_info.stops == stops && cache_info.opacity == opacity) {
-                return cache_info.texture;
-            }
-            ++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, stops, opacity);
-    }
-}
-
-void QD3DGradientCache::generateGradientColorTable(const QGradientStops& s, uint *colorTable, int size, qreal opacity) const
-{
-    int pos = 0;
-    qreal fpos = 0.0;
-    qreal incr = 1.0 / qreal(size);
-    QVector<uint> colors(s.size());
-
-    for (int i = 0; i < s.size(); ++i)
-        colors[i] = s[i].second.rgba();
-
-    uint alpha = qRound(opacity * 255);
-    while (fpos < s.first().first) {
-        colorTable[pos] = ARGB_COMBINE_ALPHA(colors[0], alpha);
-        pos++;
-        fpos += incr;
-    }
-
-    for (int i = 0; i < s.size() - 1; ++i) {
-        qreal delta = 1/(s[i+1].first - s[i].first);
-        while (fpos < s[i+1].first && pos < size) {
-            int dist = int(256 * ((fpos - s[i].first) * delta));
-            int idist = 256 - dist;
-            uint current_color = ARGB_COMBINE_ALPHA(colors[i], alpha);
-            uint next_color = ARGB_COMBINE_ALPHA(colors[i+1], alpha);
-#if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
-            colorTable[pos] = INTERPOLATE_PIXEL_256(current_color, idist, next_color, dist);
-#else
-            uint c = INTERPOLATE_PIXEL_256(current_color, idist, next_color, dist);
-            colorTable[pos] = ( (c << 24) & 0xff000000)
-                              | ((c >> 24) & 0x000000ff)
-                              | ((c << 8) & 0x00ff0000)
-                              | ((c >> 8) & 0x0000ff00);
-#endif // Q_BYTE_ORDER
-            ++pos;
-            fpos += incr;
-        }
-    }
-    for (;pos < size; ++pos)
-        colorTable[pos] = colors[s.size() - 1];
-}
-
-IDirect3DTexture9 *QD3DGradientCache::addCacheElement(quint64 hash_val, const QGradientStops &stops, qreal opacity)
-{
-    if (cache.size() == QD3D_GRADIENT_CACHE_SIZE) {
-        int elem_to_remove = qrand() % QD3D_GRADIENT_CACHE_SIZE;
-        uint key = cache.keys()[elem_to_remove];
-
-        // need to call release on each removed cache entry:
-        QD3DGradientColorTableHash::const_iterator it = cache.constFind(key);
-        do {
-            it.value().texture->Release();
-        } while (++it != cache.constEnd() && it.key() == key);
-
-        cache.remove(key); // may remove more than 1, but OK
-    }
-
-    CacheInfo cache_entry(stops, opacity);
-    uint buffer[QD3D_GRADIENT_PALETTE_SIZE];
-    generateGradientColorTable(stops, buffer, QD3D_GRADIENT_PALETTE_SIZE, opacity);
-
-    if (FAILED(m_device->CreateTexture(QD3D_GRADIENT_PALETTE_SIZE, 1, 1, 0,
-                    D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &cache_entry.texture, 0))) {
-        qWarning("QD3DGradientCache::addCacheElement(): unable to create Direct3D texture.");
-        return 0;
-    }
-
-    D3DLOCKED_RECT rect;
-    if (FAILED(cache_entry.texture->LockRect(0, &rect, 0, 0))) {
-        qDebug() << "QD3DGradientCache::addCacheElement(): unable to lock texture rect.";
-        return 0;
-    }
-    memcpy(rect.pBits, buffer, rect.Pitch);
-    cache_entry.texture->UnlockRect(0);
-
-    return cache.insert(hash_val, cache_entry).value().texture;
-}
-
-void QD3DGradientCache::cleanCache()
-{
-    QD3DGradientColorTableHash::const_iterator it = cache.constBegin();
-    for (; it != cache.constEnd(); ++it) {
-        const CacheInfo &cache_info = it.value();
-        cache_info.texture->Release();
-    }
-    cache.clear();
-}
-
-QD3DSurfaceManager::QD3DSurfaceManager() :
-    m_status(NoStatus), m_dummy(0), m_device(0), m_pd(0), m_current(0)
-{
-
-}
-
-QD3DSurfaceManager::~QD3DSurfaceManager()
-{
-}
-
-void QD3DSurfaceManager::setPaintDevice(QPaintDevice *pd)
-{
-    m_status = NoStatus;
-    m_pd = pd;
-    m_current = 0;
-
-    if (m_device->TestCooperativeLevel() != D3D_OK) {
-        m_status = NeedsResetting;
-        return;
-    }
-
-    m_current = m_swapchains.value(pd, 0);
-    QWidget *w = static_cast<QWidget*>(pd);
-
-    if (m_current) {
-        if (m_current->size != w->size()) {
-            m_swapchains.remove(pd);
-            m_current->surface->Release();
-            m_current->swapchain->Release();
-            delete m_current;
-            m_current = 0;
-        }
-    }
-
-    if (!m_current) {
-        m_current = createSwapChain(w);
-        updateMaxSize();
-    }
-}
-
-int QD3DSurfaceManager::status() const
-{
-    return m_status;
-}
-
-void QD3DSurfaceManager::reset()
-{
-    QList<QPaintDevice *> pds = m_swapchains.keys();
-
-    QMap<QPaintDevice *, D3DSwapChain *>::const_iterator i = m_swapchains.constBegin();
-    while (i != m_swapchains.constEnd()) {
-        i.value()->surface->Release();
-        i.value()->swapchain->Release();
-        ++i;
-    }
-    qDeleteAll(m_swapchains.values());
-    m_swapchains.clear();
-
-    D3DPRESENT_PARAMETERS params;
-    initPresentParameters(&params);
-    params.hDeviceWindow = m_dummy;
-
-    HRESULT res = m_device->Reset(&params);
-    if (FAILED(res)) {
-        switch (res) {
-            case D3DERR_DEVICELOST:
-                qWarning("QDirect3DPaintEngine: Reset failed (D3DERR_DEVICELOST)");
-                break;
-            case D3DERR_DRIVERINTERNALERROR:
-                qWarning("QDirect3DPaintEngine: Reset failed (D3DERR_DRIVERINTERNALERROR)");
-                break;
-            case D3DERR_OUTOFVIDEOMEMORY:
-                qWarning("QDirect3DPaintEngine: Reset failed (D3DERR_OUTOFVIDEOMEMORY)");
-                break;
-            default:
-                qWarning("QDirect3DPaintEngine: Reset failed");
-        };
-    }
-
-    for (int i=0; i<pds.count(); ++i) {
-        QWidget *w = static_cast<QWidget*>(pds.at(i));
-        createSwapChain(w);
-    }
-
-    // reset the mask as well
-    m_status = MaxSizeChanged;
-
-    setPaintDevice(m_pd);
-    updateMaxSize();
-}
-
-LPDIRECT3DSURFACE9 QD3DSurfaceManager::renderTarget()
-{
-    return m_current ? m_current->surface : 0;
-}
-
-LPDIRECT3DSURFACE9 QD3DSurfaceManager::surface(QPaintDevice *pd)
-{
-    D3DSwapChain *swapchain = m_swapchains.value(pd, 0);
-    return swapchain ? swapchain->surface : 0;
-}
-
-LPDIRECT3DSWAPCHAIN9 QD3DSurfaceManager::swapChain(QPaintDevice *pd)
-{
-    D3DSwapChain *swapchain = m_swapchains.value(pd, 0);
-    return swapchain ? swapchain->swapchain : 0;
-}
-
-void QD3DSurfaceManager::releasePaintDevice(QPaintDevice *pd)
-{
-    D3DSwapChain *swapchain = m_swapchains.take(pd);
-
-    if (swapchain) {
-        swapchain->surface->Release();
-        swapchain->swapchain->Release();
-        delete swapchain;
-        if (swapchain == m_current)
-            m_current = 0;
-    }
-}
-
-LPDIRECT3DDEVICE9 QD3DSurfaceManager::device()
-{
-    return m_device;
-}
-
-void QD3DSurfaceManager::cleanup()
-{
-    QPixmapCache::clear();
-    qd3d_glyph_cache()->cleanCache();
-
-    // release doomed textures
-    for (int k=0; k<qd3d_release_list.size(); ++k)
-        qd3d_release_list.at(k)->Release();
-    qd3d_release_list.clear();
-
-    QMap<QPaintDevice *, D3DSwapChain *>::const_iterator i = m_swapchains.constBegin();
-    while (i != m_swapchains.constEnd()) {
-        i.value()->surface->Release();
-        i.value()->swapchain->Release();
-        ++i;
-    }
-    qDeleteAll(m_swapchains.values());
-
-    if (m_device)
-        m_device->Release();
-
-    DestroyWindow(m_dummy);
-    QString cname(QLatin1String("qt_d3d_dummy"));
-    QT_WA({
-        UnregisterClass((TCHAR*)cname.utf16(), (HINSTANCE)qWinAppInst());
-    } , {
-        UnregisterClassA(cname.toLatin1(), (HINSTANCE)qWinAppInst());
-    });
-}
-
-QSize QD3DSurfaceManager::maxSize() const
-{
-    return m_max_size;
-}
-
-extern "C" {
-    LRESULT CALLBACK QtWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam);
-};
-
-void QD3DSurfaceManager::init(LPDIRECT3D9 object)
-{
-    QString cname(QLatin1String("qt_d3d_dummy"));
-    uint style = CS_DBLCLKS | CS_SAVEBITS;
-    ATOM atom;
-    QT_WA({
-        WNDCLASS wc;
-        wc.style         = style;
-        wc.lpfnWndProc   = (WNDPROC)QtWndProc;
-        wc.cbClsExtra    = 0;
-        wc.cbWndExtra    = 0;
-        wc.hInstance     = (HINSTANCE)qWinAppInst();
-        wc.hIcon         = 0;
-        wc.hCursor       = 0;
-        wc.hbrBackground = 0;
-        wc.lpszMenuName  = 0;
-        wc.lpszClassName = (TCHAR*)cname.utf16();
-        atom = RegisterClass(&wc);
-    } , {
-        WNDCLASSA wc;
-        wc.style         = style;
-        wc.lpfnWndProc   = (WNDPROC)QtWndProc;
-        wc.cbClsExtra    = 0;
-        wc.cbWndExtra    = 0;
-        wc.hInstance     = (HINSTANCE)qWinAppInst();
-        wc.hIcon         = 0;
-        wc.hCursor       = 0;
-        wc.hbrBackground = 0;
-        wc.lpszMenuName  = 0;
-        QByteArray tempArray = cname.toLatin1();
-        wc.lpszClassName = tempArray;
-        atom = RegisterClassA(&wc);
-    });
-
-    QT_WA({
-        const TCHAR *className = (TCHAR*)cname.utf16();
-        m_dummy = CreateWindow(className, className, 0,
-                               0, 0, 1, 1,
-                               0, 0, qWinAppInst(), 0);
-    } , {
-        m_dummy = CreateWindowA(cname.toLatin1(), cname.toLatin1(), 0,
-                                0, 0, 1, 1,
-                                0, 0, qWinAppInst(), 0);
-    });
-
-    D3DPRESENT_PARAMETERS params;
-    initPresentParameters(&params);
-    params.hDeviceWindow = m_dummy;
-
-    HRESULT res = object->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, 0,
-        D3DCREATE_PUREDEVICE|D3DCREATE_HARDWARE_VERTEXPROCESSING|D3DCREATE_NOWINDOWCHANGES|D3DCREATE_FPU_PRESERVE,
-        &params, &m_device);
-
-    if (FAILED(res) || m_device == 0)
-        qWarning("QDirect3DPaintEngine: failed to create Direct3D device (error=0x%x).", res);
-}
-
-void QD3DSurfaceManager::updateMaxSize()
-{
-    int w = 0, h = 0;
-    QMap<QPaintDevice *, D3DSwapChain *>::const_iterator i = m_swapchains.constBegin();
-    while (i != m_swapchains.constEnd()) {
-
-        int nw = i.key()->width();
-        if (nw > w)
-            w = nw;
-
-        int nh = i.key()->height();
-        if (nh > h)
-            h = nh;
-
-        ++i;
-    }
-
-    QSize newsize = QSize(w, h);
-    if (newsize != m_max_size) {
-        m_status |= MaxSizeChanged;
-        m_max_size = newsize;
-    }
-}
-
-void QD3DSurfaceManager::initPresentParameters(D3DPRESENT_PARAMETERS *params)
-{
-    ZeroMemory(params, sizeof(D3DPRESENT_PARAMETERS));
-    params->Windowed = true;
-    params->SwapEffect = D3DSWAPEFFECT_COPY;
-    params->BackBufferFormat = D3DFMT_UNKNOWN;
-    params->PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
-    params->Flags = D3DPRESENTFLAG_LOCKABLE_BACKBUFFER;
-}
-
-QD3DSurfaceManager::D3DSwapChain *QD3DSurfaceManager::createSwapChain(QWidget *w)
-{
-    D3DPRESENT_PARAMETERS params;
-    initPresentParameters(&params);
-    params.hDeviceWindow = w->winId();
-    D3DSwapChain *swapchain = new D3DSwapChain();
-    swapchain->size = w->size();
-    if (FAILED(m_device->CreateAdditionalSwapChain(&params, &swapchain->swapchain)))
-        qWarning("QDirect3DPaintEngine: CreateAdditionalSwapChain failed");
-    if (FAILED(swapchain->swapchain->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &swapchain->surface)))
-        qWarning("QDirect3DPaintEngine: GetBackBuffer failed");
-    m_swapchains.insert(w, swapchain);
-    connect(w, SIGNAL(destroyed(QObject *)), SLOT(cleanupPaintDevice(QObject *)));
-
-    // init with background color
-    QColor bg = w->palette().color(QPalette::Background);
-    m_device->ColorFill(swapchain->surface, 0, D3DCOLOR_ARGB(bg.alpha(), bg.red(),bg.green(),bg.blue()));
-
-    return swapchain;
-}
-
-void QD3DSurfaceManager::cleanupPaintDevice(QObject *object)
-{
-    QWidget *w = static_cast<QWidget *>(object);
-    releasePaintDevice(w);
-}
-
-int QD3DStateManager::m_mask_channels[4][4] =
-    {{1,0,0,0},{0,1,0,0},{0,0,1,0},{0,0,0,1}};
-
-QD3DDrawHelper::QD3DDrawHelper(QDirect3DPaintEnginePrivate *pe)
-    : m_pe(pe), m_d3dvbuff(0), m_maskSurface(0), m_depthStencilSurface(0),
-      m_locked(false), m_mask(0), m_startindex(0), m_index(0), m_vbuff(0), m_clearmask(true),
-      m_isLine(false), m_firstPoint(true)
-{
-    resetMask();
-#ifdef QT_DEBUG_VERTEXBUFFER_ACCESS
-    memset(accesscontrol, 0, QT_VERTEX_BUF_SIZE * sizeof(VertexBufferAccess));
-#endif
-
-    // create vertex buffer
-    afterReset();
-}
-
-QD3DDrawHelper::~QD3DDrawHelper()
-{
-    if (m_maskSurface)
-        m_maskSurface->Release();
-
-    if (m_mask)
-        m_mask->Release();
-
-    if (m_depthStencilSurface)
-        m_depthStencilSurface->Release();
-
-    if (m_d3dvbuff)
-        m_d3dvbuff->Release();
-}
-
-inline void QD3DDrawHelper::lockVertexBuffer()
-{
-    if (!m_locked) {
-        DWORD lockflags = D3DLOCK_NOOVERWRITE;
-        if (m_startindex >= QT_VERTEX_RESET_LIMIT) {
-            m_startindex = 0;
-            m_index = 0;
-
-#ifdef QT_DEBUG_VERTEXBUFFER_ACCESS
-            for (int i=0; i<QT_VERTEX_BUF_SIZE; ++i) {
-                if (accesscontrol[i] != (WRITE|READ) && accesscontrol[i] != CLEAR)
-                    qDebug() << "Vertex Buffer: Access Error";
-            }
-            memset(accesscontrol, 0, QT_VERTEX_BUF_SIZE * sizeof(VertexBufferAccess));
-#endif
-
-            lockflags = D3DLOCK_DISCARD;
-        }
-
-        if (FAILED(m_d3dvbuff->Lock(0, 0, (void**)&m_vbuff, lockflags))) {
-            qWarning() << "QDirect3DPaintEngine: unable to lock vertex buffer.";
-        }
-        m_locked = true;
-    }
-}
-
-inline void QD3DDrawHelper::unlockVertexBuffer()
-{
-    if (m_locked) {
-        if (FAILED(m_d3dvbuff->Unlock())) {
-            qWarning() << "QDirect3DPaintEngine: unable to unlock vertex buffer.";
-        }
-        m_locked = false;
-    }
-}
-
-void QD3DDrawHelper::setClipPath(const QPainterPath &path, QD3DBatchItem **item)
-{
-    lockVertexBuffer();
-
-    m_item = *item;
-    m_item->m_maskpos.x = m_item->m_maskpos.y = 0;
-    m_item->m_maskpos.channel = 3;
-    m_item->m_info |= QD3DBatchItem::BI_CLIP;
-
-    bool winding = (path.fillRule() == Qt::WindingFill);
-    if (winding)
-        m_item->m_info |= QD3DBatchItem::BI_WINDING;
-
-    if (!path.isEmpty()) {
-        m_item->m_info |= QD3DBatchItem::BI_MASK;
-        m_item->m_info &= ~QD3DBatchItem::BI_AA;
-        m_color = 0;
-        QRectF brect = pathToVertexArrays(path);
-        queueRect(brect, m_item, 0);
-    }
-
-    *item = m_item;
-}
-
-
-
-void QD3DDrawHelper::queueAntialiasedMask(const QPolygonF &poly, QD3DBatchItem **item, const QRectF &brect)
-{
-    lockVertexBuffer();
-
-    m_item = *item;
-    m_item->m_info |= QD3DBatchItem::BI_MASK;
-    setWinding(m_item->m_info & QD3DBatchItem::BI_WINDING);
-
-    int xoffset = m_item->m_maskpos.x;
-    int yoffset = m_item->m_maskpos.y;
-
-    int x = brect.left();
-    int y = brect.top();
-
-    m_item->m_xoffset = (xoffset - x) + 1;
-    m_item->m_yoffset = (yoffset - y) + 1;
-
-    m_boundingRect = brect;
-    tessellate(poly);
-
-    *item = m_item;
-}
-
-QRectF QD3DDrawHelper::queueAliasedMask(const QPainterPath &path, QD3DBatchItem **item, D3DCOLOR color)
-{
-    lockVertexBuffer();
-
-    m_color = color;
-    m_item = *item;
-    m_item->m_info |= QD3DBatchItem::BI_MASK;
-
-    bool winding = (path.fillRule() == Qt::WindingFill);
-    if (winding)
-        m_item->m_info |= QD3DBatchItem::BI_WINDING;
-
-    QRectF result = pathToVertexArrays(path);
-    *item = m_item;
-    return result;
-}
-
-// used for drawing aliased transformed rects directly
-// don't use for antialiased or masked drawing
-void QD3DDrawHelper::queueRect(const QRectF &rect, QD3DBatchItem *item, D3DCOLOR color, const QPolygonF &trect)
-{
-    lockVertexBuffer();
-
-    qreal zval = (item->m_info & QD3DBatchItem::BI_CLIP) ? 0.0f : 0.5f;
-    item->m_info |= QD3DBatchItem::BI_BRECT;
-
-    // if the item does not have a mask, the offset is different
-    if (!(item->m_info & QD3DBatchItem::BI_MASK)) {
-        item->m_offset = m_index;
-        item->m_count = (item->m_info & QD3DBatchItem::BI_AA) ? 0 : -2;
-    }
-
-    qreal x1 = rect.left();
-    qreal y1 = rect.top();
-    qreal x2 = rect.right();
-    qreal y2 = rect.bottom();
-
-    QPointF tc = trect.at(0);
-    vertex v1 = { {x1, y1, zval} , color,
-          tc.x(), tc.y(), 0.f, 0.f,
-          0.f   , 0.f   , 0.f, 0.f };
-
-    tc = trect.at(1);
-    vertex v2 = { {x2, y1, zval} , color,
-          tc.x(), tc.y(), 0.f, 0.f,
-          0.f   , 0.f   , 0.f, 0.f};
-
-    tc = trect.at(2);
-    vertex v3 = { {x2, y2, zval} , color,
-          tc.x(), tc.y(), 0.f, 0.f,
-          0.f   , 0.f   , 0.f, 0.f};;
-
-    tc = trect.at(3);
-    vertex v4 = { {x1, y2, zval} , color,
-          tc.x(), tc.y(), 0.f, 0.f,
-          0.f   , 0.f   , 0.f, 0.f};
-
-#ifdef QT_DEBUG_VERTEXBUFFER_ACCESS
-    for (int i=m_index; i<(m_index + 4); ++i) {
-        if ((m_index + 4) > QT_VERTEX_BUF_SIZE)
-            qDebug() << "Vertex Buffer: Buffer overflow";
-        if (accesscontrol[i] != CLEAR)
-            qDebug() << "Vertex Buffer: Access Error";
-        accesscontrol[i] |= WRITE;
-    }
-#endif
-
-    m_vbuff[m_index++] = v1;
-    m_vbuff[m_index++] = v2;
-    m_vbuff[m_index++] = v3;
-    m_vbuff[m_index++] = v4;
-
-    m_startindex = m_index;
-}
-
-
-QD3DMaskPosition QD3DDrawHelper::allocateMaskPosition(const QRectF &brect, bool *breakbatch)
-{
-    int w = brect.width();
-    int h = brect.height();
-
-    w += 3;
-    h += 3;
-
-    if (w > m_width)
-        w = m_width;
-    if (h > m_height)
-        h = m_height;
-
-    *breakbatch = false;
-
-    if ((m_height - m_mask_offsetY2) >= h && (m_width - m_mask_position.x) >= w) {
-        m_mask_position.y = m_mask_offsetY2;
-    } else if ((m_width - m_mask_offsetX2) >= w) {
-        m_mask_position.y = QD3D_MASK_MARGIN;
-        m_mask_position.x = m_mask_offsetX2;
-    } else if (m_mask_position.channel < 3) {
-        ++m_mask_position.channel;
-        m_mask_position.x = m_mask_position.y = QD3D_MASK_MARGIN;
-        m_mask_offsetX2 = m_mask_offsetY2 = QD3D_MASK_MARGIN;
-    } else {
-        resetMask();
-        *breakbatch = true;
-    }
-
-    int newoffset = m_mask_position.x + w;
-    if (m_mask_offsetX2 < newoffset)
-        m_mask_offsetX2 = newoffset;
-    m_mask_offsetY2 = (m_mask_position.y + h);
-
-    return m_mask_position;
-
-}
-
-void QD3DDrawHelper::queueRect(const QRectF &rect, QD3DBatchItem *item, D3DCOLOR color)
-{
-    lockVertexBuffer();
-
-    QRectF brect;
-    item->m_info |= QD3DBatchItem::BI_BRECT;
-    qreal zval = (item->m_info & QD3DBatchItem::BI_CLIP) ? 0.0f : 0.5f;
-
-    if (item->m_info & QD3DBatchItem::BI_AA) {
-        int xoffset = item->m_maskpos.x;
-        int yoffset = item->m_maskpos.y;
-
-        int x = rect.left();
-        int y = rect.top();
-
-        brect = QRectF(x, y, rect.width() + 1, rect.height() + 1);
-
-        item->m_xoffset = (xoffset - x) + 1;
-        item->m_yoffset = (yoffset - y) + 1;
-
-        // if the item does not have a mask, the offset is different
-        if (!(item->m_info & QD3DBatchItem::BI_MASK)) {
-            item->m_offset = m_index;
-            item->m_count = 0;
-        }
-    } else {
-        brect = rect;
-
-        if (!(item->m_info & QD3DBatchItem::BI_MASK)) {
-            item->m_offset = m_index;
-            item->m_count = -2;
-        }
-    }
-
-    qreal left = brect.left();
-    qreal right = brect.right();
-    qreal top = brect.top();
-    qreal bottom = brect.bottom();
-
-    vertex v1 = { {left, bottom, zval}, color,
-        0.f, 0.f, 0.f, 0.f,
-        0.f, 0.f, 0.f, 0.f};
-    vertex v2 = { {left, top, zval}, color,
-        0.f, 0.f, 0.f, 0.f,
-        0.f, 0.f, 0.f, 0.f};
-    vertex v3 = { {right, top, zval}, color,
-        0.f, 0.f, 0.f, 0.f,
-        0.f, 0.f, 0.f, 0.f};
-    vertex v4 = { {right, bottom, zval}, color,
-        0.f, 0.f, 0.f, 0.f,
-        0.f, 0.f, 0.f, 0.f};
-
-#ifdef QT_DEBUG_VERTEXBUFFER_ACCESS
-    for (int i=m_index; i<(m_index + 4); ++i) {
-        if ((m_index + 4) > QT_VERTEX_BUF_SIZE)
-            qDebug() << "Vertex Buffer: Buffer overflow";
-        if (accesscontrol[i] != CLEAR)
-            qDebug() << "Vertex Buffer: Access Error";
-        accesscontrol[i] |= WRITE;
-    }
-#endif
-
-    m_vbuff[m_index++] = v1;
-    m_vbuff[m_index++] = v2;
-    m_vbuff[m_index++] = v3;
-    m_vbuff[m_index++] = v4;
-
-    m_startindex = m_index;
-}
-
-void QD3DDrawHelper::queueAntialiasedLines(const QPainterPath &path, QD3DBatchItem **item, const QRectF &brect)
-{
-    lockVertexBuffer();
-
-    m_item = *item;
-    m_item->m_info |= QD3DBatchItem::BI_MASK;
-    setWinding(m_item->m_info & QD3DBatchItem::BI_WINDING);
-
-    int xoffset = m_item->m_maskpos.x;
-    int yoffset = m_item->m_maskpos.y;
-    int x = brect.left();
-    int y = brect.top();
-
-    m_item->m_xoffset = (xoffset - x) + 1;
-    m_item->m_yoffset = (yoffset - y) + 1;
-
-    m_boundingRect = brect;
-
-    m_xoffset = (x - xoffset) + 0.5f;
-    m_yoffset = (y - yoffset) + 0.5f;
-
-    QPointF last;
-    for (int i = 0; i < path.elementCount(); ++i) {
-        QPainterPath::Element element = path.elementAt(i);
-
-        //Q_ASSERT(!element.isCurveTo());
-
-        if (element.isLineTo())
-            QTessellator::tessellateRect(last, element, m_item->m_width);
-
-        last = element;
-    }
-
-    m_item->m_offset = m_startindex;
-    m_item->m_count = ( m_index - m_startindex ) / 3;
-    m_startindex = m_index;
-
-    *item = m_item;
-}
-
-void QD3DDrawHelper::queueAliasedLines(const QLineF *lines, int lineCount, QD3DBatchItem **item)
-{
-    lockVertexBuffer();
-
-    m_item = *item;
-    m_item->m_info |= QD3DBatchItem::BI_FASTLINE;
-
-    for (int i=0; i<lineCount; ++i) {
-        const QLineF line = lines[i];
-        qreal p1x = line.p1().x();
-        qreal p1y = line.p1().y();
-        qreal p2x = line.p2().x();
-        qreal p2y = line.p2().y();
-
-        vertex v1 = { {p1x, p1y, m_pe->m_pen_width} , m_pe->m_pen_color,
-                    -1.f, -1.f, p2x, p2y,
-                    0.f, 0.f, 0.f, 0.f };
-        vertex v2 = { {p1x, p1y, m_pe->m_pen_width} , m_pe->m_pen_color,
-                    1.f, -1.f, p2x, p2y,
-                    0.f, 0.f, 0.f, 0.f };
-        vertex v3 = { {p1x, p1y, m_pe->m_pen_width} , m_pe->m_pen_color,
-                    1.f, 1.f, p2x, p2y,
-                    0.f, 0.f, 0.f, 0.f };
-        vertex v4 = { {p1x, p1y, m_pe->m_pen_width} , m_pe->m_pen_color,
-                    -1.f, 1.f, p2x, p2y,
-                    0.f, 0.f, 0.f, 0.f };
-
-        m_vbuff[m_index++] = v1;
-        m_vbuff[m_index++] = v2;
-        m_vbuff[m_index++] = v4;
-        m_vbuff[m_index++] = v4;
-        m_vbuff[m_index++] = v2;
-        m_vbuff[m_index++] = v3;
-
-        if (m_index >= (QT_VERTEX_BUF_SIZE - 16)) {
-            m_item->m_offset = m_startindex;
-            m_item->m_count = ( m_index - m_startindex ) / 2;
-            m_startindex = m_index;
-
-            QD3DBatchItem itemcopy = *m_item;
-            m_item = m_pe->nextBatchItem();
-            *m_item = itemcopy;
-
-            lockVertexBuffer();
-        }
-    }
-
-    m_item->m_offset = m_startindex;
-    m_item->m_count = ( m_index - m_startindex ) - 2;
-    m_startindex = m_index;
-
-    *item = m_item;
-}
-
-void QD3DDrawHelper::queueTextGlyph(const QRectF &rect, const qreal *tex_coords,
-                                      QD3DBatchItem *item, D3DCOLOR color)
-{
-    lockVertexBuffer();
-
-    qreal x1 = rect.left();
-    qreal y1 = rect.top();
-    qreal x2 = rect.right();
-    qreal y2 = rect.bottom();
-
-    vertex v1 = { {x1, y1, 0.5f}, color,
-                 tex_coords[0], tex_coords[1], 0.f, 0.f,
-                 0.f   , 0.f   , 0.f, 0.f};
-    vertex v2 = { {x2, y1, 0.5f}, color,
-                 tex_coords[2], tex_coords[1], 0.f, 0.f,
-                 0.f   , 0.f   , 0.f, 0.f};
-    vertex v3 = { {x2, y2, 0.5f}, color,
-                 tex_coords[2], tex_coords[3], 0.f, 0.f,
-                 0.f   , 0.f   , 0.f, 0.f};
-    vertex v4 = { {x1, y1, 0.5f}, color,
-                 tex_coords[0], tex_coords[1], 0.f, 0.f,
-                 0.f   , 0.f   , 0.f, 0.f};
-    vertex v5 = { {x2, y2, 0.5f}, color,
-                 tex_coords[2], tex_coords[3], 0.f, 0.f,
-                 0.f   , 0.f   , 0.f, 0.f};
-    vertex v6 = { {x1, y2, 0.5f}, color,
-                 tex_coords[0], tex_coords[3], 0.f, 0.f,
-                 0.f   , 0.f   , 0.f, 0.f};
-
-#ifdef QT_DEBUG_VERTEXBUFFER_ACCESS
-    for (int i=m_index; i<(m_index + 6); ++i) {
-        if ((m_index + 6) > QT_VERTEX_BUF_SIZE)
-            qDebug() << "Vertex Buffer: Buffer overflow";
-        if (accesscontrol[i] != CLEAR)
-            qDebug() << "Vertex Buffer: Access Error";
-        accesscontrol[i] |= WRITE;
-    }
-#endif
-
-    m_vbuff[m_index++] = v1;
-    m_vbuff[m_index++] = v2;
-    m_vbuff[m_index++] = v3;
-    m_vbuff[m_index++] = v4;
-    m_vbuff[m_index++] = v5;
-    m_vbuff[m_index++] = v6;
-
-    m_startindex = m_index;
-    ++item->m_count;
-}
-
-bool QD3DDrawHelper::needsFlushing() const
-{
-    return (m_pe->m_batch.m_item_index >= QD3D_BATCH_SIZE || m_startindex >= QT_VERTEX_RESET_LIMIT);
-}
-
-void QD3DDrawHelper::setMaskSize(QSize size)
-{
-    m_width = size.width();
-    m_height = size.height();
-
-    if (m_maskSurface)
-        m_maskSurface->Release();
-
-    if (m_mask)
-        m_mask->Release();
-
-    if (FAILED(m_pe->m_d3d_device->CreateTexture(m_width, m_height, 1, D3DUSAGE_RENDERTARGET,
-        D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &m_mask, NULL))) {
-            qWarning() << "QDirect3DPaintEngine: CreateTexture() failed.";
-    }
-
-    if (m_depthStencilSurface)
-        m_depthStencilSurface->Release();
-
-    if (FAILED(m_pe->m_d3d_device->CreateDepthStencilSurface(m_width, m_height, D3DFMT_D24S8, D3DMULTISAMPLE_NONE, 0,
-                                                   TRUE, &m_depthStencilSurface, NULL))) {
-            qWarning() << "QDirect3DPaintEngine: CreateDepthStencilSurface() failed.";
-    }
-
-    m_pe->m_d3d_device->SetDepthStencilSurface(m_depthStencilSurface);
-    m_pe->m_d3d_device->Clear(0, 0, D3DCLEAR_ZBUFFER|D3DCLEAR_STENCIL, 0, 0.0f, 0);
-
-    if (FAILED(m_mask->GetSurfaceLevel(0, &m_maskSurface))) {
-        qWarning() << "QDirect3DPaintEngine: GetSurfaceLevel() failed.";
-    }
-
-    m_pe->m_d3d_device->ColorFill(m_maskSurface, 0, D3DCOLOR_ARGB(0,0,0,0));
-    D3DXMATRIX projMatrix;
-    pD3DXMatrixOrthoOffCenterLH(&projMatrix, 0, m_width, m_height, 0, 0, 1);
-    m_pe->m_effect->SetMatrix("g_mMaskProjection", &projMatrix);
-    m_pe->m_effect->SetTexture("g_mAAMask", m_mask);
-}
-
-void QD3DDrawHelper::beforeReset()
-{
-    resetMask();
-    m_clearmask = true;
-
-    if (m_maskSurface) {
-        m_maskSurface->Release();
-        m_maskSurface = 0;
-    }
-
-    if (m_mask) {
-        m_mask->Release();
-        m_mask = 0;
-    }
-
-    if (m_depthStencilSurface) {
-        m_depthStencilSurface->Release();
-        m_depthStencilSurface = 0;
-    }
-
-    if (m_d3dvbuff)
-        m_d3dvbuff->Release();
-}
-
-void QD3DDrawHelper::afterReset()
-{
-    if (FAILED(m_pe->m_d3d_device->CreateVertexBuffer(QT_VERTEX_BUF_SIZE*sizeof(vertex), D3DUSAGE_DYNAMIC|D3DUSAGE_WRITEONLY,
-        QD3DFVF_CSVERTEX,
-        D3DPOOL_DEFAULT, &m_d3dvbuff, NULL))) {
-            qWarning() << "QDirect3DPaintEngine: failed to create vertex buffer.";
-    }
-
-    m_pe->m_d3d_device->SetStreamSource(0, m_d3dvbuff, 0, sizeof(vertex));
-    m_pe->m_d3d_device->SetFVF(QD3DFVF_CSVERTEX);
-
-    m_startindex = 0;
-    m_index = 0;
-}
-
-IDirect3DSurface9 *QD3DDrawHelper::freeMaskSurface()
-{
-     // we need to make sure the mask is cleared when it's used for something else
-    resetMask();
-    m_clearmask = true;
-
-    return m_maskSurface;
-}
-
-int QD3DDrawHelper::drawAntialiasedMask(int offset, int maxoffset)
-{
-    int newoffset = offset;
-    QD3DBatchItem *item = &(m_pe->m_batch.items[offset]);
-
-    // set mask as render target
-    if (FAILED(m_pe->m_d3d_device->SetRenderTarget(0, m_maskSurface)))
-        qWarning() << "QDirect3DPaintEngine: SetRenderTarget failed!";
-
-    if (m_clearmask) {
-        m_pe->m_d3d_device->Clear(0, 0, D3DCLEAR_TARGET,D3DCOLOR_ARGB(0,0,0,0), 0, 0);
-        m_clearmask = false;
-    }
-
-    // fill the mask
-    m_pe->m_statemanager->beginPass(PASS_AA_CREATEMASK);
-    for (; newoffset<maxoffset; ++newoffset) {
-        item = &(m_pe->m_batch.items[newoffset]);
-        if (!(item->m_info & QD3DBatchItem::BI_AA) || !(item->m_info & QD3DBatchItem::BI_MASK)) {
-            break;
-        } else if (item->m_info & QD3DBatchItem::BI_MASKFULL) {
-            item->m_info &= ~QD3DBatchItem::BI_MASKFULL;
-            m_clearmask = true;
-            break;
-        }
-
-        m_pe->m_statemanager->startStateBlock();
-        if (item->m_info & QD3DBatchItem::BI_MASKSCISSOR) {
-            RECT rect;
-            QRectF srect = item->m_brect.adjusted(item->m_xoffset, item->m_yoffset,
-                item->m_xoffset, item->m_yoffset);
-            rect.left = qMax(qRound(srect.left()), 0);
-            rect.top = qMax(qRound(srect.top()), 0);
-            rect.bottom = qMin(m_height, qRound(srect.bottom()));
-            rect.right = qMin(m_width, qRound(srect.right()));
-            m_pe->m_d3d_device->SetScissorRect(&rect);
-            m_pe->m_statemanager->SetRenderState(D3DRS_SCISSORTESTENABLE, TRUE);
-        }
-        m_pe->m_statemanager->setMaskChannel(item->m_maskpos.channel);
-        m_pe->m_statemanager->endStateBlock();
-
-#ifdef QT_DEBUG_VERTEXBUFFER_ACCESS
-        int vbstart = item->m_offset;
-        for (int i=vbstart; i<(vbstart + (item->m_count * 3)); ++i) {
-            if (accesscontrol[i] != WRITE)
-                qDebug() << "Vertex Buffer: Access Error";
-            accesscontrol[i] |= READ;
-        }
-#endif
-
-        m_pe->m_d3d_device->DrawPrimitive(D3DPT_TRIANGLELIST, item->m_offset, item->m_count);
-
-        if (item->m_info & QD3DBatchItem::BI_MASKSCISSOR) {
-            m_pe->m_statemanager->SetRenderState(D3DRS_SCISSORTESTENABLE, FALSE);
-        }
-    }
-    m_pe->m_statemanager->endPass();
-
-    return newoffset;
-}
-
-void QD3DDrawHelper::drawAliasedMask(int offset)
-{
-    QD3DBatchItem *item = &(m_pe->m_batch.items[offset]);
-    if (item->m_info & QD3DBatchItem::BI_MASK) {
-        m_pe->m_statemanager->beginPass( (item->m_info & QD3DBatchItem::BI_WINDING) ? PASS_STENCIL_WINDING : PASS_STENCIL_ODDEVEN );
-        int prev_stop = 0;
-        for (int i=0; i<item->m_pointstops.count(); ++i) {
-            int stop = item->m_pointstops.at(i);
-
-#ifdef QT_DEBUG_VERTEXBUFFER_ACCESS
-            int vbstart = (item->m_offset + prev_stop);
-            for (int j=vbstart; j<(vbstart+(stop - prev_stop)); ++j) {
-                if (accesscontrol[j] != WRITE)
-                    qDebug() << "Vertex Buffer: Access Error";
-                accesscontrol[j] |= READ;
-            }
-#endif
-            m_pe->m_d3d_device->DrawPrimitive(D3DPT_TRIANGLEFAN, item->m_offset + prev_stop, (stop - prev_stop) - 2);
-            prev_stop = stop;
-        }
-        m_pe->m_statemanager->endPass();
-    }
-}
-
-void QD3DDrawHelper::drawTextItem(QD3DBatchItem *item)
-{
-#ifdef QT_DEBUG_VERTEXBUFFER_ACCESS
-    int vbstart = item->m_offset;
-    for (int j=vbstart; j<(vbstart + ((item->m_count * 2) * 3)); ++j) {
-        if (accesscontrol[j] != WRITE)
-            qDebug() << "Vertex Buffer: Access Error";
-        accesscontrol[j] |= READ;
-    }
-#endif
-    m_pe->m_d3d_device->DrawPrimitive(D3DPT_TRIANGLELIST, item->m_offset, item->m_count*2);
-}
-
-void QD3DDrawHelper::drawAliasedLines(QD3DBatchItem *item)
-{
-    m_pe->m_statemanager->setCosmeticPen(item->m_info & QD3DBatchItem::BI_COSMETICPEN);
-    if (item->m_info & QD3DBatchItem::BI_TRANSFORM) {
-        m_pe->m_statemanager->setTransformation(&item->m_matrix);
-    } else {
-        m_pe->m_statemanager->setTransformation();
-    }
-    int pass = (item->m_info & QD3DBatchItem::BI_MASK)
-               ? PASS_ALIASED_LINES
-               : PASS_ALIASED_LINES_DIRECT;
-    m_pe->m_statemanager->beginPass(pass);
-    m_pe->m_d3d_device->DrawPrimitive(D3DPT_TRIANGLELIST, item->m_offset, (item->m_count + 2) / 3);
-    m_pe->m_statemanager->endPass();
-}
-
-void QD3DDrawHelper::drawAntialiasedBoundingRect(QD3DBatchItem *item)
-{
-    if (item->m_info & QD3DBatchItem::BI_SCISSOR) {
-        RECT rect;
-        rect.left = qMax(qRound(item->m_brect.left()), 0);
-        rect.top = qMax(qRound(item->m_brect.top()), 0);
-        rect.bottom = qMin(m_height, qRound(item->m_brect.bottom()));
-        rect.right = qMin(m_width, qRound(item->m_brect.right()));
-        m_pe->m_d3d_device->SetScissorRect(&rect);
-        m_pe->m_statemanager->SetRenderState(D3DRS_SCISSORTESTENABLE, TRUE);
-    }
-
-#ifdef QT_DEBUG_VERTEXBUFFER_ACCESS
-    int vbstart = item->m_offset + (item->m_count * 3);
-    for (int j=vbstart; j<(vbstart + 4); ++j) {
-        if (accesscontrol[j] != WRITE)
-            qDebug() << "Vertex Buffer: Access Error";
-        accesscontrol[j] |= READ;
-    }
-#endif
-
-    m_pe->m_d3d_device->DrawPrimitive(D3DPT_TRIANGLEFAN, item->m_offset + (item->m_count * 3), 2);
-
-    if (item->m_info & QD3DBatchItem::BI_SCISSOR) {
-        m_pe->m_statemanager->SetRenderState(D3DRS_SCISSORTESTENABLE, FALSE);
-    }
-}
-
-void QD3DDrawHelper::drawAliasedBoundingRect(QD3DBatchItem *item)
-{
-#ifdef QT_DEBUG_VERTEXBUFFER_ACCESS
-    int vbstart = (item->m_offset + item->m_count + 2);
-    for (int j=vbstart; j<(vbstart + 4); ++j) {
-        if (accesscontrol[j] != WRITE)
-            qDebug() << "Vertex Buffer: Access Error";
-        accesscontrol[j] |= READ;
-    }
-#endif
-
-    m_pe->m_d3d_device->DrawPrimitive(D3DPT_TRIANGLEFAN, item->m_offset + item->m_count + 2, 2);
-}
-
-void QD3DDrawHelper::addTrap(const Trapezoid &trap)
-{
-    qreal topLeftY = Q27Dot5ToDouble(trap.topLeft->y) - m_yoffset;
-    qreal topLeftX = Q27Dot5ToDouble(trap.topLeft->x) - m_xoffset;
-    qreal topRightY = Q27Dot5ToDouble(trap.topRight->y) - m_yoffset;
-    qreal topRightX = Q27Dot5ToDouble(trap.topRight->x) - m_xoffset;
-    qreal top = Q27Dot5ToDouble(trap.top) - m_yoffset;
-    qreal bottom = Q27Dot5ToDouble(trap.bottom) - m_yoffset;
-
-    Q27Dot5 _h = trap.topLeft->y - trap.bottomLeft->y;
-    Q27Dot5 _w = trap.topLeft->x - trap.bottomLeft->x;
-    qreal _leftA = (qreal)_w/_h;
-    qreal _leftB = topLeftX - _leftA * topLeftY;
-
-    _h = trap.topRight->y - trap.bottomRight->y;
-    _w = trap.topRight->x - trap.bottomRight->x;
-    qreal _rightA = (qreal)_w/_h;
-    qreal _rightB = topRightX - _rightA * topRightY;
-
-    qreal invLeftA = qFuzzyIsNull(_leftA) ? 0.0 : 1.0 / _leftA;
-    qreal invRightA = qFuzzyIsNull(_rightA) ? 0.0 : 1.0 / _rightA;
-
-    vertex v1 = { {1.f, top - 1.f, 0.5f}, 0.f,
-        top, bottom, invLeftA, -invRightA,
-        _leftA, _leftB, _rightA, _rightB};
-    vertex v2 = { {0.f, top - 1.f, 0.5f}, 0.f,
-        top, bottom, invLeftA, -invRightA,
-        _leftA, _leftB, _rightA, _rightB};
-    vertex v3 = { {0.f, bottom + 1.f, 0.5f}, 0.f,
-        top, bottom, invLeftA, -invRightA,
-        _leftA, _leftB, _rightA, _rightB};
-
-    vertex v4 = { {1.f, top - 1.f, 0.5f}, 0.f,
-        top, bottom, invLeftA, -invRightA,
-        _leftA, _leftB, _rightA, _rightB};
-    vertex v5 = { {0.f, bottom + 1.f, 0.5f}, 0.f,
-        top, bottom, invLeftA, -invRightA,
-        _leftA, _leftB, _rightA, _rightB};
-    vertex v6 = { {1.f, bottom + 1.f, 0.5f}, 0.f,
-        top, bottom, invLeftA, -invRightA,
-        _leftA, _leftB, _rightA, _rightB};
-
-#ifdef QT_DEBUG_VERTEXBUFFER_ACCESS
-    for (int i=m_index; i<(m_index + 6); ++i) {
-        if ((m_index + 6) > QT_VERTEX_BUF_SIZE)
-            qDebug() << "Vertex Buffer: Buffer overflow";
-        if (accesscontrol[i] != CLEAR)
-            qDebug() << "Vertex Buffer: Access Error";
-        accesscontrol[i] |= WRITE;
-    }
-#endif
-
-    m_vbuff[m_index++] = v1;
-    m_vbuff[m_index++] = v2;
-    m_vbuff[m_index++] = v3;
-    m_vbuff[m_index++] = v4;
-    m_vbuff[m_index++] = v5;
-    m_vbuff[m_index++] = v6;
-
-    // check if buffer is full
-    if (m_index >= (QT_VERTEX_BUF_SIZE - 16)) {
-        m_item->m_offset = m_startindex;
-        m_item->m_count = ( m_index - m_startindex ) / 3;
-        m_startindex = m_index;
-
-        QD3DBatchItem itemcopy = *m_item;
-        m_item = m_pe->nextBatchItem();
-        *m_item = itemcopy;
-        m_item->m_info &= ~QD3DBatchItem::BI_MASKFULL;
-
-        lockVertexBuffer();
-    }
-}
-
-void QD3DDrawHelper::tessellate(const QPolygonF &poly) {
-    int xoffset = m_item->m_maskpos.x;
-    int yoffset = m_item->m_maskpos.y;
-
-    int x = m_boundingRect.left();
-    int y = m_boundingRect.top();
-    m_xoffset = (x - xoffset) + 0.5f;
-    m_yoffset = (y - yoffset) + 0.5f;
-
-    QTessellator::tessellate(poly.data(), poly.count());
-
-    m_item->m_offset = m_startindex;
-    m_item->m_count = ( m_index - m_startindex ) / 3;
-    m_startindex = m_index;
-}
-
-inline void QD3DDrawHelper::lineToStencil(qreal x, qreal y)
-{
-    QPointF lastPt = tess_lastpoint;
-    tess_lastpoint = QPointF(x, y);
-
-    if (m_isLine && m_firstPoint)
-        return;
-
-
-#ifdef QT_DEBUG_VERTEXBUFFER_ACCESS
-    if (m_index > QT_VERTEX_BUF_SIZE)
-        qDebug() << "Vertex Buffer: Buffer overflow";
-    if (accesscontrol[m_index] != CLEAR)
-        qDebug() << "Vertex Buffer: Access Error";
-    accesscontrol[m_index] |= WRITE;
-#endif
-
-    vertex v;
-    if (m_isLine) {
-        vertex v1 = { {lastPt.x(), lastPt.y(), m_pe->m_pen_width }, m_color,
-                     -1.f, -1.f, x, y,
-                     0.f, 0.f, 0.f, 0.f};
-        vertex v2 = { {lastPt.x(), lastPt.y(), m_pe->m_pen_width }, m_color,
-                     1.f, -1.f, x, y,
-                     0.f, 0.f, 0.f, 0.f};
-        vertex v3 = { {lastPt.x(), lastPt.y(), m_pe->m_pen_width }, m_color,
-                     1.f, 1.f, x, y,
-                     0.f, 0.f, 0.f, 0.f};
-        vertex v4 = { {lastPt.x(), lastPt.y(), m_pe->m_pen_width }, m_color,
-                     -1.f, 1.f, x, y,
-                     0.f, 0.f, 0.f, 0.f};
-        m_vbuff[m_index++] = v1;
-        m_vbuff[m_index++] = v2;
-        m_vbuff[m_index++] = v4;
-        m_vbuff[m_index++] = v4;
-        m_vbuff[m_index++] = v2;
-        m_vbuff[m_index++] = v3;
-    } else {
-        vertex v1 = { {x, y, 0.5f}, m_color,
-                     0.f, 0.f, 0.f, 0.f,
-                     0.f, 0.f, 0.f, 0.f};
-        m_vbuff[m_index++] = v1;
-        v = v1;
-    }
-    ++tess_index;
-
-    // check if buffer is full
-    if (m_index >= (QT_VERTEX_BUF_SIZE - 16)) {
-        int firstindex = m_startindex;
-        if (!m_item->m_pointstops.isEmpty())
-            firstindex = m_item->m_pointstops.last();
-
-        vertex first = m_vbuff[firstindex];
-
-        // finish current polygon
-        m_item->m_pointstops.append(tess_index);
-        m_item->m_offset = m_startindex;
-        m_startindex = m_index;
-
-        // copy item
-        QD3DBatchItem itemcopy = *m_item;
-        m_item = m_pe->nextBatchItem();
-        *m_item = itemcopy;
-
-        // start new polygon
-        lockVertexBuffer();
-        m_item->m_pointstops.clear();
-        if (!m_isLine) {
-            tess_index = 2;
-
-#ifdef QT_DEBUG_VERTEXBUFFER_ACCESS
-            if (accesscontrol[m_index] != CLEAR)
-                qDebug() << "Vertex Buffer: Access Error";
-            accesscontrol[m_index] |= WRITE;
-#endif
-
-            m_vbuff[m_index++] = first;
-
-#ifdef QT_DEBUG_VERTEXBUFFER_ACCESS
-            if (accesscontrol[m_index] != CLEAR)
-                qDebug() << "Vertex Buffer: Access Error";
-            accesscontrol[m_index] |= WRITE;
-#endif
-
-            m_vbuff[m_index++] = v;
-        } else {
-            tess_index = 0;
-        }
-    }
-
-    if (x > max_x)
-        max_x = x;
-    else if (x < min_x)
-        min_x = x;
-    if (y > max_y)
-        max_y = y;
-    else if (y < min_y)
-        min_y = y;
-}
-
-inline void QD3DDrawHelper::curveToStencil(const QPointF &cp1, const QPointF &cp2,
-                                             const QPointF &ep)
-{
-    qreal inverseScale = 0.5f;
-    qreal inverseScaleHalf = inverseScale / 2;
-
-    QBezier beziers[32];
-    beziers[0] = QBezier::fromPoints(tess_lastpoint, cp1, cp2, ep);
-    QBezier *b = beziers;
-    while (b >= beziers) {
-        // check if we can pop the top bezier curve from the stack
-        qreal l = qAbs(b->x4 - b->x1) + qAbs(b->y4 - b->y1);
-        qreal d;
-        if (l > inverseScale) {
-            d = qAbs( (b->x4 - b->x1)*(b->y1 - b->y2) - (b->y4 - b->y1)*(b->x1 - b->x2) )
-                + qAbs( (b->x4 - b->x1)*(b->y1 - b->y3) - (b->y4 - b->y1)*(b->x1 - b->x3) );
-            d /= l;
-        } else {
-            d = qAbs(b->x1 - b->x2) + qAbs(b->y1 - b->y2) +
-                qAbs(b->x1 - b->x3) + qAbs(b->y1 - b->y3);
-        }
-        if (d < inverseScaleHalf || b == beziers + 31) {
-            // good enough, we pop it off and add the endpoint
-            lineToStencil(b->x4, b->y4);
-            --b;
-        } else {
-            // split, second half of the polygon goes lower into the stack
-            b->split(b+1, b);
-           ++b;
-        }
-    }
-}
-
-QRectF QD3DDrawHelper::pathToVertexArrays(const QPainterPath &path)
-{
-    m_isLine = (m_item->m_info & QD3DBatchItem::BI_FASTLINE);
-    const QPainterPath::Element &first = path.elementAt(0);
-    firstx = first.x;
-    firsty = first.y;
-    min_x = max_x = firstx;
-    min_y = max_y = firsty;
-
-    m_firstPoint = true;
-    tess_index = 0;
-    m_item->m_pointstops.clear();
-    lineToStencil(firstx, firsty);
-    m_firstPoint = false;
-
-    for (int i=1; i<path.elementCount(); ++i) {
-        const QPainterPath::Element &e = path.elementAt(i);
-        switch (e.type) {
-        case QPainterPath::MoveToElement:
-            m_item->m_pointstops.append(tess_index);
-            m_firstPoint = true;
-            lineToStencil(e.x, e.y);
-            m_firstPoint = false;
-            break;
-        case QPainterPath::LineToElement:
-            lineToStencil(e.x, e.y);
-            break;
-        case QPainterPath::CurveToElement:
-            curveToStencil(e, path.elementAt(i+1), path.elementAt(i+2));
-            i+=2;
-            break;
-        default:
-            break;
-        }
-    }
-
-    if (!m_isLine)
-        lineToStencil(firstx, firsty);
-
-    m_item->m_pointstops.append(tess_index);
-
-    m_item->m_offset = m_startindex;
-    m_item->m_count = ( m_index - m_startindex ) - 2;
-    m_startindex = m_index;
-
-    QRectF result;
-    result.setLeft(min_x);
-    result.setRight(max_x);
-    result.setTop(min_y);
-    result.setBottom(max_y);
-
-    if (m_isLine)
-        result.adjust(0,0,1,1);
-
-    return result;
-}
-
-void QD3DDrawHelper::resetMask()
-{
-    m_mask_position.x = m_mask_position.y = QD3D_MASK_MARGIN;
-    m_mask_position.channel = 0;
-    m_mask_offsetX2 = m_mask_offsetY2 = QD3D_MASK_MARGIN;
-}
-
-
-static inline QPainterPath strokeForPath(const QPainterPath &path, const QPen &cpen) {
-    QPainterPathStroker stroker;
-    if (cpen.style() == Qt::CustomDashLine)
-        stroker.setDashPattern(cpen.dashPattern());
-    else
-        stroker.setDashPattern(cpen.style());
-
-    stroker.setCapStyle(cpen.capStyle());
-    stroker.setJoinStyle(cpen.joinStyle());
-    stroker.setMiterLimit(cpen.miterLimit());
-    stroker.setWidth(cpen.widthF());
-
-    QPainterPath stroke = stroker.createStroke(path);
-    stroke.setFillRule(Qt::WindingFill);
-    return stroke;
-}
-
-
-QDirect3DPaintEnginePrivate::~QDirect3DPaintEnginePrivate()
-{
-
-}
-
-void QDirect3DPaintEnginePrivate::updateClipPath(const QPainterPath &path, Qt::ClipOperation op)
-{
-    //#### remove me
-    QRegion r(path.toFillPolygon().toPolygon(), path.fillRule());
-    updateClipRegion(r, op);
-
-/*    if (m_draw_helper->needsFlushing())
-        flushBatch();
-
-    if (op == Qt::IntersectClip && !has_clipping)
-        op = Qt::ReplaceClip;
-
-    // switch to paths
-    if (!m_has_complex_clipping) {
-        m_clip_path = QPainterPath();
-        m_clip_path.addRegion(m_clip_region);
-        m_clip_region = QRegion();
-        m_sysclip_path = QPainterPath();
-        m_sysclip_path.addRegion(m_sysclip_region);
-        m_sysclip_region = QRegion();
-        m_has_complex_clipping = true;
-    }
-
-    QPainterPath cpath = m_matrix.map(path);
-
-    QD3DBatchItem *item = &m_batch.items[m_batch.m_item_index++];
-    item->m_info = QD3DBatchItem::BI_COMPLEXCLIP;
-
-    switch (op) {
-        case Qt::UniteClip:
-            has_clipping = true;
-            m_clip_path = m_clip_path.united(cpath);
-            break;
-        case Qt::ReplaceClip:
-            has_clipping = true;
-            m_clip_path = cpath;
-            break;
-        case Qt::NoClip:
-            m_has_complex_clipping = false;
-            has_clipping = false;
-            item->m_info |= QD3DBatchItem::BI_CLEARCLIP;
-            break;
-        default: // intersect clip
-            has_clipping = true;
-            m_clip_path = m_clip_path.intersected(cpath);
-            break;
-    }
-
-    if (!m_sysclip_path.isEmpty()) {
-        item->m_info &= ~QD3DBatchItem::BI_CLEARCLIP;
-        if (has_clipping)
-            m_clip_path = m_clip_path.intersected(m_sysclip_path);
-        else
-            m_clip_path = m_sysclip_path;
-    }
-
-    // update the aliased clipping mask
-    m_draw_helper->setClipPath(m_clip_path, item);
-
-    // update the antialiased clipping mask
-    if (m_draw_helper->needsFlushing())
-        flushBatch();
-
-    QD3DBatchItem *aaitem = &m_batch.items[m_batch.m_item_index++];
-    aaitem->m_info = item->m_info|QD3DBatchItem::BI_AA;
-    m_draw_helper->setClipPath(m_clip_path, aaitem); */
-}
-
-extern QPainterPath qt_regionToPath(const QRegion &region);
-
-void QDirect3DPaintEnginePrivate::updateClipRegion(const QRegion &clipregion, Qt::ClipOperation op)
-{
-    if (m_draw_helper->needsFlushing())
-        flushBatch();
-    if (m_has_complex_clipping) {
-        QPainterPath path = qt_regionToPath(clipregion);
-        updateClipPath(path, op);
-        return;
-    }
-
-    if (op == Qt::IntersectClip && m_clip_region.isEmpty())
-        op = Qt::ReplaceClip;
-
-    QRegion cregion = m_matrix.map(clipregion);
-
-    QD3DBatchItem *item = nextBatchItem();
-    item->m_info &= ~QD3DBatchItem::BI_AA;
-
-    switch (op) {
-        case Qt::UniteClip:
-            m_clip_region = m_clip_region.united(cregion);
-            break;
-        case Qt::ReplaceClip:
-            m_clip_region = cregion;
-            break;
-        case Qt::NoClip:
-            m_clip_region = QRegion();
-            item->m_info |= QD3DBatchItem::BI_CLEARCLIP;
-            break;
-        default: // intersect clip
-            m_clip_region = m_clip_region.intersected(cregion);
-            break;
-    }
-
-    QRegion crgn = m_clip_region;
-    if (!m_sysclip_region.isEmpty()) {
-        item->m_info &= ~QD3DBatchItem::BI_CLEARCLIP;
-        if (!crgn.isEmpty())
-            crgn = crgn.intersected(m_sysclip_region);
-        else
-            crgn = m_sysclip_region;
-    }
-
-    QPainterPath path = qt_regionToPath(crgn);
-    m_draw_helper->setClipPath(path, &item);
-}
-
-void QDirect3DPaintEnginePrivate::updateFont(const QFont &)
-{
-}
-
-void QDirect3DPaintEnginePrivate::setRenderTechnique(RenderTechnique technique)
-{
-    if (m_current_technique != technique) {
-        if (m_current_technique != RT_NoTechnique)
-            m_effect->End();
-
-        if (technique == RT_Aliased) {
-            m_effect->SetTechnique("Aliased");
-            m_effect->Begin(0,D3DXFX_DONOTSAVESTATE);
-        } else if (technique == RT_Antialiased) {
-            m_effect->SetTechnique("Antialiased");
-            m_effect->Begin(0,D3DXFX_DONOTSAVESTATE);
-        }
-    }
-
-    m_current_technique = technique;
-}
-
-/*QPolygonF QDirect3DPaintEnginePrivate::transformedRect(const QRectF &brect) const
-{
-    QPolygonF poly(brect);
-    return m_matrix.map(poly);
-}
-
-QPolygonF QDirect3DPaintEnginePrivate::calcTextureCoords(const QPolygonF &trect) const
-{
-    QPolygonF result(4);
-    QRectF brect = trect.boundingRect();
-    qreal angle = atan(trect.at(0).x() -
-}
-
-QPolygonF QDirect3DPaintEnginePrivate::offsetTextureCoords(const QRectF &brect, const QPolygonF &trect) const
-{
-
-}*/
-
-inline QD3DBatchItem *QDirect3DPaintEnginePrivate::nextBatchItem()
-{
-    if (m_draw_helper->needsFlushing())
-        flushBatch();
-
-    QD3DBatchItem *item = &m_batch.items[m_batch.m_item_index++];
-    item->m_info = m_current_state;
-    item->m_cmode = m_cmode;
-    return item;
-}
-
-qreal calculateAngle(qreal dx, qreal dy)
-{
-    qreal angle;
-
-    if (qFuzzyIsNull(dx)) {
-        angle = (dy < 0) ? -M_PI/2 : M_PI/2;
-    } else {
-        angle = atanf(dy/dx);
-        if (dx < 0)
-            angle += M_PI;
-    }
-
-    return angle;
-}
-
-QPolygonF QDirect3DPaintEnginePrivate::brushCoordinates(const QRectF &r, bool stroke, qreal *fd) const
-{
-    QBrush brush;
-    QTransform matrix;
-    Qt::BrushStyle style;
-
-    if (stroke) {
-        brush = m_pen.brush();
-        matrix = m_inv_pen_matrix;
-        style = m_pen_brush_style;
-    } else {
-        brush = m_brush;
-        matrix = m_inv_brush_matrix;
-        style = m_brush_style;
-    }
-
-    QPolygonF bpoly;
-    switch(style) {
-        case Qt::TexturePattern: {
-            QTransform totxcoords;
-            QRectF adj_brect = r.adjusted(-0.5f, -0.5f, -0.5f, -0.5f);
-            totxcoords.scale(1.0f/brush.texture().width(),
-                1.0f/brush.texture().height());
-            bpoly = matrix.map(QPolygonF(adj_brect));
-            bpoly = totxcoords.map(bpoly);
-            break; }
-        case Qt::LinearGradientPattern: {
-            const QLinearGradient *g = static_cast<const QLinearGradient *>(brush.gradient());
-            QPointF start = g->start();
-            QPointF stop = g->finalStop();
-            qreal dx = stop.x() - start.x();
-            qreal dy = stop.y() - start.y();
-            qreal length = sqrt(dx * dx + dy * dy);
-            qreal angle = calculateAngle(dx, dy);
-            QTransform totxcoords;
-            QRectF adj_brect = r.adjusted(-0.5f, -0.5f, -0.5f, -0.5f);
-            totxcoords.scale(1.0f/length, 1.0f/length);
-            totxcoords.rotateRadians(-angle);
-            totxcoords.translate(-start.x(), -start.y());
-            bpoly = matrix.map(QPolygonF(adj_brect));
-            bpoly = totxcoords.map(bpoly);
-            break; }
-        case Qt::ConicalGradientPattern: {
-            const QConicalGradient *g = static_cast<const QConicalGradient *>(brush.gradient());
-            QPointF center = g->center();
-            qreal angle = g->angle();
-            QTransform totxcoords;
-            totxcoords.rotate(angle);
-            totxcoords.translate(-center.x(), -center.y());
-            bpoly = matrix.map(QPolygonF(r));
-            bpoly = totxcoords.map(bpoly);
-            break; }
-        case Qt::RadialGradientPattern: {
-            const QRadialGradient *g = static_cast<const QRadialGradient *>(brush.gradient());
-            QPointF center = g->center();
-            QPointF focalpoint = g->focalPoint();
-            qreal dx = focalpoint.x() - center.x();
-            qreal dy = focalpoint.y() - center.y();
-            qreal radius = g->radius();
-            *fd = sqrt(dx * dx + dy * dy) / radius;
-            qreal angle = calculateAngle(dx, dy);
-            QTransform totxcoords;
-            totxcoords.scale(1.0f/radius, 1.0f/radius);
-            totxcoords.rotateRadians(-angle);
-            totxcoords.translate(-center.x(), -center.y());
-            bpoly = matrix.map(QPolygonF(r));
-            bpoly = totxcoords.map(bpoly);
-            break; }
-        default: {
-            QTransform totxcoords;
-            QRectF adj_brect = r.adjusted(-0.5f, -0.5f, -0.5f, -0.5f);
-            QPixmap pat = getPattern(style);
-            totxcoords.scale(1.0f/pat.width(),
-                1.0f/pat.height());
-            bpoly = matrix.map(QPolygonF(adj_brect));
-            bpoly = totxcoords.map(bpoly); }
-    };
-
-    return bpoly;
-}
-
-void QDirect3DPaintEnginePrivate::strokeAliasedPath(QPainterPath path, const QRectF &brect, const QTransform &txform)
-{
-    D3DCOLOR solid_color;
-    QD3DBatchItem *item = nextBatchItem();
-
-    if (!txform.isIdentity())
-        path = txform.map(path);
-
-    QRectF trect;
-    QPolygonF txcoord;
-
-    solid_color = m_pen_color;
-    bool has_complex_brush = false;
-    if (m_pen_brush_style != Qt::SolidPattern) {
-        has_complex_brush = true;
-        item->m_brush = m_pen.brush();
-        item->m_info |= QD3DBatchItem::BI_COMPLEXBRUSH;
-        item->m_opacity = m_opacity;
-    }
-
-    if (m_has_fast_pen) {
-        item->m_info |= QD3DBatchItem::BI_FASTLINE;
-        if (m_pen_brush_style == Qt::SolidPattern) {
-            m_draw_helper->queueAliasedMask(path, &item, solid_color);
-            item->m_info &= ~QD3DBatchItem::BI_MASK; // bypass stencil buffer
-            return;
-        }
-    }
-
-    QRectF txrect = m_draw_helper->queueAliasedMask(path, &item, 0);
-
-    if (has_complex_brush) {
-        trect = brect;
-        txcoord = brushCoordinates(brect, true, &item->m_distance);
-        item->m_info |= QD3DBatchItem::BI_TRANSFORM;
-        item->m_matrix = m_matrix;
-    } else {
-        trect = txrect;
-        static const QPolygonF empty_poly(4);
-        txcoord = empty_poly;
-    }
-
-    m_draw_helper->queueRect(trect, item, solid_color, txcoord);
-}
-
-void QDirect3DPaintEnginePrivate::fillAliasedPath(QPainterPath path, const QRectF &brect, const QTransform &txform)
-{
-    D3DCOLOR solid_color;
-    QD3DBatchItem *item = nextBatchItem();
-
-    if (!txform.isIdentity())
-        path = txform.map(path);
-
-    QRectF trect;
-    QPolygonF txcoord;
-
-    solid_color = m_brush_color;
-    bool has_complex_brush = false;
-    if (m_brush_style != Qt::SolidPattern) {
-        has_complex_brush = true;
-        item->m_brush = m_brush;
-        item->m_info |= QD3DBatchItem::BI_COMPLEXBRUSH;
-        item->m_opacity = m_opacity;
-    }
-
-    QRectF txrect = m_draw_helper->queueAliasedMask(path, &item, 0);
-
-    if (has_complex_brush) {
-        trect = brect;
-        txcoord = brushCoordinates(brect, false, &item->m_distance);
-        item->m_info |= QD3DBatchItem::BI_TRANSFORM;
-        item->m_matrix = m_matrix;
-    } else {
-        trect = txrect;
-        static const QPolygonF empty_poly(4);
-        txcoord = empty_poly;
-    }
-
-    m_draw_helper->queueRect(trect, item, solid_color, txcoord);
-}
-
-void QDirect3DPaintEnginePrivate::fillAntialiasedPath(const QPainterPath &path, const QRectF &brect,
-                                                      const QTransform &txform, bool stroke)
-{
-    D3DCOLOR solid_color;
-    bool winding = (path.fillRule() == Qt::WindingFill);
-    QPolygonF poly;
-    QRectF txrect;
-    QPainterPath tpath;
-
-    if (m_has_aa_fast_pen && stroke) {
-        tpath = txform.map(path);
-        txrect = tpath.controlPointRect();
-        txrect.adjust(-(m_pen_width/2),-(m_pen_width/2), m_pen_width, m_pen_width);
-    } else {
-        poly = path.toFillPolygon(txform);
-        txrect = poly.boundingRect();
-    }
-
-    // brect = approx. bounding rect before transformation
-    // txrect = exact bounding rect after transformation
-    // trect = the rectangle to be drawn
-    // txcoord = the texture coordinates
-    // adj_txrect = adjusted rect to include aliased outline
-
-    bool use_scissor = false;
-    if (txrect.left() < 0) {
-        txrect.adjust(-txrect.left(),0,0,0);
-        use_scissor = true;
-    }
-    if (txrect.top() < 0) {
-        txrect.adjust(0,-txrect.top(),0,0);
-        use_scissor = true;
-    }
-
-    if (!txrect.isValid())
-        return;
-
-    QD3DBatchItem *item = nextBatchItem();
-
-    QRectF adj_txrect = txrect.adjusted(-1,-1,1,1);
-    QRectF trect;
-    QPolygonF txcoord;
-
-    bool has_complex_brush = false;
-    if (stroke) {
-        solid_color = m_pen_color;
-        if (m_pen_brush_style != Qt::SolidPattern) {
-            has_complex_brush = true;
-            item->m_brush = m_pen.brush();
-        }
-        item->m_width = m_pen_width;
-    } else {
-        solid_color = m_brush_color;
-        if (m_brush_style != Qt::SolidPattern) {
-            has_complex_brush = true;
-            item->m_brush = m_brush;
-        }
-    }
-
-    qreal focaldist = 0;
-    if (has_complex_brush) {
-        trect = brect;
-        txcoord = brushCoordinates(brect, stroke, &focaldist);
-    } else {
-        trect = adj_txrect;
-        static const QPolygonF empty_poly(4);
-        txcoord = empty_poly;
-    }
-
-    bool maskfull;
-    item->m_maskpos = m_draw_helper->allocateMaskPosition(txrect, &maskfull);
-    if (maskfull)
-        item->m_info |= QD3DBatchItem::BI_MASKFULL;
-    item->m_distance = focaldist;
-
-    if (winding)
-        item->m_info |= QD3DBatchItem::BI_WINDING;
-
-    if (has_complex_brush) {
-        item->m_info |= QD3DBatchItem::BI_SCISSOR|QD3DBatchItem::BI_COMPLEXBRUSH|
-            QD3DBatchItem::BI_TRANSFORM;
-        item->m_brect = adj_txrect;
-        item->m_matrix = m_matrix;
-        item->m_opacity = m_opacity;
-    }
-    if (use_scissor) {
-        item->m_info |= QD3DBatchItem::BI_MASKSCISSOR;
-        item->m_brect = adj_txrect;
-    }
-
-    if (m_has_aa_fast_pen && stroke) {
-        m_draw_helper->queueAntialiasedLines(tpath, &item, txrect);
-    } else {
-        m_draw_helper->queueAntialiasedMask(poly, &item, txrect);
-    }
-
-    m_draw_helper->queueRect(trect, item, solid_color, txcoord);
-}
-
-QPainterPath QDirect3DPaintEnginePrivate::strokePathFastPen(const QPainterPath &path)
-{
-    QPainterPath result;
-    QBezier beziers[32];
-    for (int i=0; i<path.elementCount(); ++i) {
-        const QPainterPath::Element &e = path.elementAt(i);
-        switch (e.type) {
-        case QPainterPath::MoveToElement:
-            result.moveTo(e.x, e.y);
-            break;
-        case QPainterPath::LineToElement:
-            result.lineTo(e.x, e.y);
-            break;
-
-        case QPainterPath::CurveToElement:
-        {
-            QPointF sp = path.elementAt(i-1);
-            QPointF cp2 = path.elementAt(i+1);
-            QPointF ep = path.elementAt(i+2);
-            i+=2;
-
-            qreal inverseScaleHalf = m_inv_scale / 2;
-            beziers[0] = QBezier::fromPoints(sp, e, cp2, ep);
-            QBezier *b = beziers;
-            while (b >= beziers) {
-                // check if we can pop the top bezier curve from the stack
-                qreal l = qAbs(b->x4 - b->x1) + qAbs(b->y4 - b->y1);
-                qreal d;
-                if (l > m_inv_scale) {
-                    d = qAbs( (b->x4 - b->x1)*(b->y1 - b->y2)
-                              - (b->y4 - b->y1)*(b->x1 - b->x2) )
-                        + qAbs( (b->x4 - b->x1)*(b->y1 - b->y3)
-                                - (b->y4 - b->y1)*(b->x1 - b->x3) );
-                    d /= l;
-                } else {
-                    d = qAbs(b->x1 - b->x2) + qAbs(b->y1 - b->y2) +
-                        qAbs(b->x1 - b->x3) + qAbs(b->y1 - b->y3);
-                }
-                if (d < inverseScaleHalf || b == beziers + 31) {
-                    // good enough, we pop it off and add the endpoint
-                    result.lineTo(b->x4, b->y4);
-                    --b;
-                } else {
-                    // split, second half of the polygon goes lower into the stack
-                    b->split(b+1, b);
-                    ++b;
-                }
-            }
-        } // case CurveToElement
-        default:
-            break;
-        } // end of switch
-    }
-    return result;
-}
-
-void QDirect3DPaintEnginePrivate::strokePath(const QPainterPath &path, QRectF brect, bool simple)
-{
-    QTransform txform;
-    QPainterPath tpath;
-
-    if (m_has_fast_pen || m_has_aa_fast_pen) {
-        if (!simple)
-            tpath = strokePathFastPen(path);
-        else
-            tpath = path;  //already only lines
-    } else {
-        tpath = strokeForPath(path, m_pen);
-    }
-
-    if (tpath.isEmpty())
-        return;
-
-    //brect is null if the path is not transformed
-    if (brect.isNull())
-        txform = m_matrix;
-
-    if (!brect.isNull()) {
-        // brect is set when the path is transformed already,
-        // this is the case when we have a cosmetic pen.
-        brect.adjust(-(m_pen_width/2),-(m_pen_width/2), m_pen_width, m_pen_width);
-    }
-
-    if (brect.isNull())
-        brect = tpath.controlPointRect();
-    brect.adjust(-m_inv_scale,-m_inv_scale,m_inv_scale,m_inv_scale); //adjust for antialiasing
-
-    if (m_current_state & QD3DBatchItem::BI_AA) {
-        fillAntialiasedPath(tpath, brect, txform, true);
-    } else {
-        strokeAliasedPath(tpath, brect, txform);
-    }
-}
-
-void QDirect3DPaintEnginePrivate::fillPath(const QPainterPath &path, QRectF brect)
-{
-    QTransform txform;
-
-    //brect is null if the path is not transformed
-    if (brect.isNull())
-        txform = m_matrix;
-
-    if (brect.isNull())
-        brect = path.controlPointRect();
-    brect.adjust(-m_inv_scale,-m_inv_scale,m_inv_scale,m_inv_scale); //adjust for antialiasing
-
-    if (m_current_state & QD3DBatchItem::BI_AA) {
-        fillAntialiasedPath(path, brect, txform, false);
-    } else {
-        fillAliasedPath(path, brect, txform);
-    }
-}
-
-
-bool QDirect3DPaintEnginePrivate::init()
-{
-#ifdef QT_DEBUG_D3D_CALLS
-    qDebug() << "QDirect3DPaintEnginePrivate::init()";
-#endif
-
-    m_draw_helper = 0;
-    m_gradient_cache = 0;
-    m_dc = 0;
-    m_dcsurface = 0;
-
-    m_supports_d3d = false;
-    m_current_state = 0;
-    m_in_scene = false;
-    m_has_fast_pen = false;
-    m_has_aa_fast_pen = false;
-    m_has_pen = false;
-    m_has_brush = false;
-    m_pen_color = 0;
-    m_brush_color = 0;
-    m_current_surface = 0;
-    m_batch.m_item_index = 0;
-    m_current_technique = RT_NoTechnique;
-
-    if (!pDirect3DCreate9) {
-        QLibrary d3d_lib(QLatin1String("d3d9.dll"));
-        pDirect3DCreate9 = (PFNDIRECT3DCREATE9) d3d_lib.resolve("Direct3DCreate9");
-        if (!pDirect3DCreate9) {
-            qWarning("QDirect3DPaintEngine: failed to resolve symbols from d3d9.dll.\n"
-                     "Make sure you have the DirectX run-time installed.");
-            return false;
-        }
-    }
-
-    if (!pD3DXCreateBuffer || !pD3DXCreateEffect || !pD3DXMatrixOrthoOffCenterLH) {
-        QLibrary d3dx_lib(QLatin1String("d3dx9_32.dll"));
-        pD3DXCreateBuffer = (PFND3DXCREATEBUFFER) d3dx_lib.resolve("D3DXCreateBuffer");
-        pD3DXCreateEffect = (PFND3DXCREATEEFFECT) d3dx_lib.resolve("D3DXCreateEffect");
-        pD3DXMatrixOrthoOffCenterLH = (PFND3DXMATRIXORTHOOFFCENTERLH)
-                                        d3dx_lib.resolve("D3DXMatrixOrthoOffCenterLH");
-        if (!(pD3DXCreateBuffer && pD3DXCreateEffect && pD3DXMatrixOrthoOffCenterLH)) {
-            qWarning("QDirect3DPaintEngine: failed to resolve symbols from d3dx9_32.dll.\n"
-                     "Make sure you have the DirectX run-time installed.");
-            return false;
-        }
-    }
-
-    if (!m_d3d_object) {
-        m_d3d_object = pDirect3DCreate9(D3D_SDK_VERSION);
-        if (!m_d3d_object) {
-            qWarning("QDirect3DPaintEngine: failed to create Direct3D object.\n"
-                     "Direct3D support in Qt will be disabled.");
-            return false;
-        }
-    }
-
-    m_supports_d3d = testCaps();
-    if (!m_supports_d3d)
-        return false;
-
-    m_surface_manager.init(m_d3d_object);
-    m_d3d_device = m_surface_manager.device();
-
-    if (!m_d3d_device)
-        return false;
-
-    /* load shaders */
-    QFile file(QLatin1String(":/qpaintengine_d3d.fx"));
-    QByteArray fxFile;
-    if (file.open(QFile::ReadOnly))
-        fxFile = file.readAll();
-
-    if (fxFile.size() > 0) {
-        LPD3DXBUFFER compout;
-        pD3DXCreateBuffer(4096, &compout);
-        DWORD dwShaderFlags = D3DXFX_NOT_CLONEABLE|D3DXFX_DONOTSAVESTATE|D3DXSHADER_OPTIMIZATION_LEVEL3;
-        if(FAILED(pD3DXCreateEffect(m_d3d_device, fxFile.constData(), fxFile.size(),
-                                    NULL, NULL, dwShaderFlags, NULL, &m_effect, &compout))) {
-            qWarning("QDirect3DPaintEngine: failed to compile effect file");
-            if (compout)
-                qWarning((char *)compout->GetBufferPointer());
-            m_supports_d3d = false;
-            return false;
-        }
-        if (m_effect) {
-            m_statemanager = new QD3DStateManager(m_d3d_device, m_effect);
-            m_effect->SetStateManager(m_statemanager);
-            m_draw_helper = new QD3DDrawHelper(this);
-            initDevice();
-            m_gradient_cache = new QD3DGradientCache(m_d3d_device);
-        }
-    } else {
-        return false;
-    }
-
-    return true;
-}
-
-QPixmap QDirect3DPaintEnginePrivate::getPattern(Qt::BrushStyle style) const
-{
-    if (!m_patterns.contains(style)) {
-        QImage img(16,16,QImage::Format_ARGB32);
-        img.fill(0);
-        QPainter p(&img);
-        p.setBrush(QBrush(Qt::white, style));
-        p.setPen(Qt::NoPen);
-        p.drawRect(0,0,16,16);
-        p.end();
-        QPixmap pattern(QPixmap::fromImage(img));
-        QDirect3DPaintEnginePrivate *ct = const_cast<QDirect3DPaintEnginePrivate *>(this);
-        ct->verifyTexture(pattern);
-        ct->m_patterns.insert(style, pattern);
-    }
-
-    return m_patterns.value(style);
-}
-
-bool QDirect3DPaintEnginePrivate::testCaps()
-{
-    D3DCAPS9 caps;
-    if (FAILED(m_d3d_object->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &caps)))
-        return false;
-
-    if ((caps.PresentationIntervals & D3DPRESENT_INTERVAL_IMMEDIATE)
-        && (caps.DevCaps & D3DDEVCAPS_PUREDEVICE)
-        && (caps.RasterCaps & D3DPRASTERCAPS_SCISSORTEST)
-        && (caps.StencilCaps & D3DSTENCILCAPS_TWOSIDED))
-        return true;
-#if 0
-    qDebug() << "Direct3D caps:";
-    qDebug() << "D3DPRESENT_INTERVAL_IMMEDIATE:" << ((caps.PresentationIntervals & D3DPRESENT_INTERVAL_IMMEDIATE) != 0);
-    qDebug() << "D3DDEVCAPS_PUREDEVICE:" << ((caps.DevCaps & D3DDEVCAPS_PUREDEVICE) != 0);
-    qDebug() << "D3DPRASTERCAPS_SCISSORTEST:" << ((caps.RasterCaps & D3DPRASTERCAPS_SCISSORTEST) != 0);
-    qDebug() << "D3DSTENCILCAPS_TWOSIDED:" << ((caps.StencilCaps & D3DSTENCILCAPS_TWOSIDED) != 0);
-#endif
-    return false;
-}
-
-void QDirect3DPaintEnginePrivate::initDevice()
-{
-    m_statemanager->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
-    m_statemanager->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE);
-    m_statemanager->SetRenderState(D3DRS_ZWRITEENABLE, FALSE);
-    m_statemanager->SetRenderState(D3DRS_LIGHTING, FALSE);
-    m_statemanager->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
-    m_statemanager->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
-    m_statemanager->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_DESTALPHA);
-}
-
-void QDirect3DPaintEnginePrivate::updatePen(const QPen &pen)
-{
-#ifdef QT_DEBUG_D3D_CALLS
-    qDebug() << "QDirect3DPaintEngine::updatePen";
-#endif
-    m_pen = pen;
-    m_has_cosmetic_pen = false;
-    m_has_pen = (m_pen.style() != Qt::NoPen);
-    if (m_has_pen) {
-        m_pen_brush_style = m_pen.brush().style();
-
-        if (m_pen_brush_style >= Qt::SolidPattern && m_pen_brush_style <= Qt::DiagCrossPattern) {
-            int a, r, g, b;
-            m_pen.color().getRgb(&r, &g, &b, &a);
-            m_pen_color = D3DCOLOR_ARGB((int)(a * m_opacity),r,g,b);
-        } else {
-            m_pen_color = m_opacity_color;
-        }
-
-        m_has_cosmetic_pen = m_pen.isCosmetic();
-
-        if (m_pen_brush_style != Qt::NoBrush &&
-            m_pen_brush_style != Qt::SolidPattern) {
-            bool ok;
-            m_inv_pen_matrix = m_pen.brush().transform().inverted(&ok);
-            if (!ok)
-                qWarning() << "QDirect3DPaintEngine: No inverse matix for pen brush matrix.";
-        }
-
-        m_pen_width = m_pen.widthF();
-        if (m_pen_width == 0.0f)
-            m_pen_width = 1.0f;
-    }
-}
-
-void QDirect3DPaintEnginePrivate::updateBrush(const QBrush &brush)
-{
-#ifdef QT_DEBUG_D3D_CALLS
-    qDebug() << "QDirect3DPaintEngine::updateBrush";
-#endif
-    m_brush = brush;
-    m_brush_style = m_brush.style();
-    m_has_brush = (m_brush_style != Qt::NoBrush);
-    if (m_has_brush) {
-        if (m_brush_style >= Qt::SolidPattern && m_brush_style <= Qt::DiagCrossPattern) {
-            int a, r, g, b;
-            m_brush.color().getRgb(&r, &g, &b, &a);
-            m_brush_color = D3DCOLOR_ARGB((int)(a * m_opacity),r,g,b);
-        } else {
-            m_brush_color = m_opacity_color;
-        }
-
-        if (m_brush_style != Qt::SolidPattern) {
-            bool ok;
-            m_inv_brush_matrix = (m_brush.transform() * m_brush_origin).inverted(&ok);
-            if (!ok)
-                qWarning() << "QDirect3DPaintEngine: No inverse matix for brush matrix.";
-
-            // make sure the texture is loaded as a texture
-            if (m_brush_style == Qt::TexturePattern)
-                verifyTexture(m_brush.texture());
-
-
-        }
-    }
-}
-
-void QDirect3DPaintEnginePrivate::updateTransform(const QTransform &matrix)
-{
-#ifdef QT_DEBUG_D3D_CALLS
-    qDebug() << "QDirect3DPaintEngine::updateTransform";
-#endif
-    m_matrix = matrix;
-    m_inv_scale = qMax(1 / qMax( qMax(qAbs(m_matrix.m11()), qAbs(m_matrix.m22())),
-        qMax(qAbs(m_matrix.m12()), qAbs(m_matrix.m21())) ), 0.0001);
-    m_txop = matrix.type();
-}
-
-int QDirect3DPaintEnginePrivate::flushAntialiased(int offset)
-{
-    // fills the mask (returns number of items added to the mask)
-    int newoffset = m_draw_helper->drawAntialiasedMask(offset, m_batch.m_item_index);
-
-    // set the render target to the current output surface
-    if (FAILED(m_d3d_device->SetRenderTarget(0, m_current_surface)))
-        qWarning() << "QDirect3DPaintEngine: SetRenderTarget failed!";
-
-    // draw the bounding boxes (using the mask generated by drawAntialiasedMask)
-    for (int i=offset; i<newoffset; ++i) {
-        QD3DBatchItem *item = &(m_batch.items[i]);
-        int pass = (item->m_info & QD3DBatchItem::BI_COMPLEXBRUSH) ? PASS_AA_DRAW : PASS_AA_DRAW_DIRECT;
-        m_statemanager->beginPass(pass);
-        prepareItem(item);
-        if (item->m_info & QD3DBatchItem::BI_BRECT)
-            m_draw_helper->drawAntialiasedBoundingRect(item);
-        cleanupItem(item);
-    }
-
-    m_statemanager->endPass();
-
-    return newoffset;
-}
-
-bool QDirect3DPaintEnginePrivate::prepareBatch(QD3DBatchItem *item, int offset)
-{
-    if (item->m_info & QD3DBatchItem::BI_CLIP) {
-        setRenderTechnique(RT_Aliased);
-        if (item->m_info & QD3DBatchItem::BI_CLEARCLIP) {
-            m_d3d_device->Clear(0, 0, D3DCLEAR_ZBUFFER, 0, 0.0f, 0);
-            return true;
-        }
-
-        m_draw_helper->drawAliasedMask(offset);
-        m_d3d_device->Clear(0, 0, D3DCLEAR_ZBUFFER, 0, 1.0f, 0);
-        if (item->m_info & QD3DBatchItem::BI_BRECT) {
-            m_statemanager->beginPass(PASS_STENCIL_CLIP);
-            m_draw_helper->drawAliasedBoundingRect(item);
-            m_statemanager->endPass();
-        }
-
-        return true;
-    }
-
-    if (item->m_info & QD3DBatchItem::BI_AA) {
-        setRenderTechnique(RT_Antialiased);
-    } else {
-        setRenderTechnique(RT_Aliased);
-    }
-
-    return false;
-}
-
-void QDirect3DPaintEnginePrivate::prepareItem(QD3DBatchItem *item) {
-    // pixmap
-    int brushmode = 0;
-    m_statemanager->startStateBlock();
-    if ((item->m_info & QD3DBatchItem::BI_PIXMAP) || (item->m_info & QD3DBatchItem::BI_IMAGE)) {
-        QRasterPixmapData *data = static_cast<QRasterPixmapData*>(item->m_pixmap.data);
-        IDirect3DTexture9 *tex = (item->m_info & QD3DBatchItem::BI_PIXMAP) ?
-                                 data->texture : item->m_texture;
-        m_statemanager->setTexture(tex);
-        brushmode = 5;
-    }
-
-    if (item->m_info & QD3DBatchItem::BI_AA) {
-        m_statemanager->setMaskChannel(item->m_maskpos.channel);
-        m_statemanager->setMaskOffset(item->m_xoffset, item->m_yoffset);
-    }
-
-    if (item->m_info & QD3DBatchItem::BI_COMPLEXBRUSH) {
-        const QBrush brush = item->m_brush;
-        switch (brush.style()) {
-    	    case Qt::TexturePattern: {
-                QRasterPixmapData *data = static_cast<QRasterPixmapData*>(brush.texture().data);
-                m_statemanager->setTexture(data->texture, QGradient::RepeatSpread);
-                brushmode = 1;
-                break;
-	    }
-            case Qt::LinearGradientPattern:
-                m_statemanager->setTexture(m_gradient_cache->
-                    getBuffer(brush.gradient()->stops(), item->m_opacity),
-                    brush.gradient()->spread());
-                brushmode = 2;
-                break;
-            case Qt::ConicalGradientPattern:
-                m_statemanager->setTexture(m_gradient_cache->
-                    getBuffer(brush.gradient()->stops(), item->m_opacity),
-                    brush.gradient()->spread());
-                brushmode = 3;
-                break;
-            case Qt::RadialGradientPattern:
-                m_statemanager->setTexture(m_gradient_cache->
-                    getBuffer(brush.gradient()->stops(), item->m_opacity),
-                    brush.gradient()->spread());
-                m_statemanager->setFocalDistance(item->m_distance);
-                brushmode = 4;
-                break;
-    	    default: {
-                QRasterPixmapData *data = static_cast<QRasterPixmapData*>(getPattern(brush.style()).data);
-                m_statemanager->setTexture(data->texture, QGradient::RepeatSpread);
-                brushmode = 5;
-	    }
-        };
-    }
-
-    if (item->m_info & QD3DBatchItem::BI_TRANSFORM) {
-        m_statemanager->setTransformation(&item->m_matrix);
-    } else {
-        m_statemanager->setTransformation();
-    }
-
-    m_statemanager->setBrushMode(brushmode);
-    setCompositionMode(item->m_cmode);
-    m_statemanager->endStateBlock();
-}
-
-
-void QDirect3DPaintEnginePrivate::releaseDC()
-{
-    if (m_dc) {
-        m_dcsurface->ReleaseDC(m_dc);
-        m_dcsurface = 0;
-        m_dc = 0;
-    }
-}
-
-
-void QDirect3DPaintEnginePrivate::cleanupItem(QD3DBatchItem *item)
-{
-    if (item->m_info & QD3DBatchItem::BI_PIXMAP)
-        item->m_pixmap = QPixmap();
-    item->m_brush = QBrush();
-}
-
-void QDirect3DPaintEnginePrivate::verifyTexture(const QPixmap &pm)
-{
-    QRasterPixmapData *pmData = static_cast<QRasterPixmapData*>(pm.data);
-    if (!pmData->texture) {
-        QImage im = pmData->image;
-        // bitmaps are drawn with the current pen color
-        if (im.depth() == 1) {
-            QVector<QRgb> colors(2);
-            colors[0] = 0;
-            colors[1] = m_pen.color().rgba();
-            im.setColorTable(colors);
-        }
-        im = im.convertToFormat(QImage::Format_ARGB32);
-        if (FAILED(m_d3d_device->CreateTexture(im.width(), im.height(), 1, 0,
-                                                 D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &pmData->texture, 0)))
-        {
-            qWarning("QDirect3DPaintEngine: unable to create Direct3D texture from pixmap.");
-            return;
-        }
-        D3DLOCKED_RECT rect;
-        if (FAILED(pmData->texture->LockRect(0, &rect, 0, 0))) {
-            qDebug() << "QDirect3DPaintEngine: unable to lock texture rect.";
-            return;
-        }
-        DWORD *dst = (DWORD *) rect.pBits;
-        DWORD *src = (DWORD *) im.scanLine(0);
-
-        Q_ASSERT((rect.Pitch/4) == (im.bytesPerLine()/4));
-        memcpy(dst, src, rect.Pitch*im.height());
-        pmData->texture->UnlockRect(0);
-    }
-}
-
-bool QDirect3DPaintEnginePrivate::isFastRect(const QRectF &rect)
-{
-    if (m_matrix.type() < QTransform::TxRotate) {
-        QRectF r = m_matrix.mapRect(rect);
-        return r.topLeft().toPoint() == r.topLeft()
-            && r.bottomRight().toPoint() == r.bottomRight();
-    }
-
-    return false;
-}
-
-void QDirect3DPaintEnginePrivate::setCompositionMode(QPainter::CompositionMode mode)
-{
-    switch(mode) {
-        case QPainter::CompositionMode_SourceOver:
-        default:
-            m_statemanager->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
-            m_statemanager->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
-    };
-}
-
-void QDirect3DPaintEnginePrivate::cleanup()
-{
-    // clean batch
-    for(int i=0; i<QD3D_BATCH_SIZE; ++i) {
-        m_batch.items[i].m_brush = QBrush();
-        m_batch.items[i].m_pixmap = QPixmap();
-    }
-
-    m_surface_manager.cleanup();
-    m_patterns.clear();
-
-    delete m_gradient_cache;
-    delete m_draw_helper;
-
-    if (m_effect)
-        m_effect->Release();
-
-    if (m_d3d_object)
-        m_d3d_object->Release();
-
-    m_effect = 0;
-    m_d3d_object = 0;
-    m_gradient_cache = 0;
-    m_draw_helper = 0;
-}
-
-void QDirect3DPaintEnginePrivate::flushAliased(QD3DBatchItem *item, int offset)
-{
-    m_draw_helper->drawAliasedMask(offset);
-
-    if (item->m_info & QD3DBatchItem::BI_BRECT) {
-        int pass = (item->m_info & QD3DBatchItem::BI_MASK) ? PASS_STENCIL_DRAW_DIRECT : PASS_STENCIL_NOSTENCILCHECK_DIRECT;
-        if (item->m_info & (QD3DBatchItem::BI_COMPLEXBRUSH|QD3DBatchItem::BI_IMAGE|QD3DBatchItem::BI_PIXMAP) )
-            pass = (item->m_info & QD3DBatchItem::BI_MASK) ? PASS_STENCIL_DRAW : PASS_STENCIL_NOSTENCILCHECK;
-        m_statemanager->beginPass(pass);
-        prepareItem(item);
-        m_draw_helper->drawAliasedBoundingRect(item);
-        cleanupItem(item);
-        m_statemanager->endPass();
-    }
-}
-
-void QDirect3DPaintEnginePrivate::flushText(QD3DBatchItem *item, int)
-{
-    prepareItem(item);
-    m_statemanager->setTexture(item->m_texture);
-    m_statemanager->setBrushMode(1);
-//     m_statemanager->SetRenderState(D3DRS_BLENDFACTOR, item->m_brush.color().rgba());
-    m_statemanager->beginPass(m_cleartype_text ? PASS_CLEARTYPE_TEXT : PASS_TEXT);
-    m_draw_helper->drawTextItem(item);
-    m_statemanager->endPass();
-    cleanupItem(item);
-}
-
-void QDirect3DPaintEnginePrivate::flushLines(QD3DBatchItem *item, int)
-{
-    m_draw_helper->drawAliasedLines(item);
-
-    if (item->m_info & QD3DBatchItem::BI_BRECT) {
-        int pass = (item->m_info & QD3DBatchItem::BI_COMPLEXBRUSH) ? PASS_STENCIL_DRAW : PASS_STENCIL_DRAW_DIRECT;
-        m_statemanager->beginPass(pass);
-        prepareItem(item);
-        m_draw_helper->drawAliasedBoundingRect(item);
-        cleanupItem(item);
-        m_statemanager->endPass();
-    }
-}
-
-void QDirect3DPaintEnginePrivate::flushBatch()
-{
-//     static int dbgcounter = 0;
-//     ++dbgcounter;
-//     qDebug() << " -> flush" << dbgcounter;
-
-    int offset = 0;
-    m_draw_helper->unlockVertexBuffer();
-    releaseDC();
-
-    // iterate over all items in the batch
-    while (offset != m_batch.m_item_index) {
-        QD3DBatchItem *item = &(m_batch.items[offset]);
-
-        if (prepareBatch(item, offset)) {
-            ++offset;
-            continue;
-        }
-
-        if (item->m_info & QD3DBatchItem::BI_FASTLINE) {
-            flushLines(item, offset++);
-        } else if (item->m_info & QD3DBatchItem::BI_AA) {
-            offset = flushAntialiased(offset);
-        } else if (item->m_info & QD3DBatchItem::BI_TEXT) {
-            flushText(item, offset++);
-        } else {
-            flushAliased(item, offset++);
-        }
-    }
-
-    // reset batch
-    m_batch.m_item_index = 0;
-
-    // release doomed textures
-    for (int i=0; i<qd3d_release_list.size(); ++i)
-        qd3d_release_list.at(i)->Release();
-    qd3d_release_list.clear();
-}
-
-QDirect3DPaintEngine::QDirect3DPaintEngine()
-    : QPaintEngine(*(new QDirect3DPaintEnginePrivate),
-                   PaintEngineFeatures(AllFeatures & ~ObjectBoundingModeGradients))
-{ }
-
-QDirect3DPaintEngine::~QDirect3DPaintEngine()
-{
-}
-
-bool QDirect3DPaintEngine::begin(QPaintDevice *device)
-{
-#ifdef QT_DEBUG_D3D_CALLS
-    qDebug() << "QDirect3DPaintEngine::begin";
-#endif
-    Q_D(QDirect3DPaintEngine);
-    setActive(true);
-
-    QSize old_size = d->m_surface_size;
-    d->m_surface_size = QRect(0, 0, device->width(), device->height()).size();
-
-    d->m_current_state = 0;
-    d->m_inv_scale = 1;
-    d->m_opacity = 1.0f;
-    d->m_opacity_color = D3DCOLOR_ARGB(255,255,255,255);
-    d->m_matrix = QTransform();
-    d->m_brush_origin = QTransform();
-    d->m_txop = QTransform::TxNone;
-    d->m_cmode = QPainter::CompositionMode_SourceOver;
-
-    Q_ASSERT(device && device->devType() == QInternal::Widget);
-    if (d->m_d3d_device == 0) {
-        qWarning() << "QDirect3DPaintEngine: No Device!";
-        return false;
-    }
-
-    d->m_cleartype_text = false;
-//     QT_WA({
-//         UINT result;
-//         BOOL ok;
-//         ok = SystemParametersInfoW(SPI_GETFONTSMOOTHINGTYPE, 0, &result, 0);
-//         if (ok)
-//             d->m_cleartype_text = (result == FE_FONTSMOOTHINGCLEARTYPE);
-//     }, {
-//         UINT result;
-//         BOOL ok;
-//         ok = SystemParametersInfoA(SPI_GETFONTSMOOTHINGTYPE, 0, &result, 0);
-//         if (ok)
-//             d->m_cleartype_text = (result == FE_FONTSMOOTHINGCLEARTYPE);
-//     });
-
-    d->m_surface_manager.setPaintDevice(device);
-    int status = d->m_surface_manager.status();
-    if (status & QD3DSurfaceManager::NeedsResetting) {
-        d->m_effect->OnLostDevice();
-        d->m_draw_helper->beforeReset();
-        d->m_statemanager->reset();
-        d->m_surface_manager.reset();
-        d->m_draw_helper->afterReset();
-        d->m_effect->OnResetDevice();
-        d->initDevice();
-    }
-
-    LPDIRECT3DSURFACE9 newsurface = d->m_surface_manager.renderTarget();
-    if (d->m_current_surface != newsurface) {
-        d->m_current_surface = newsurface;
-        if (FAILED(d->m_d3d_device->SetRenderTarget(0, newsurface)))
-            qWarning() << "QDirect3DPaintEngine: SetRenderTarget failed!";
-    }
-
-    status = d->m_surface_manager.status();
-    if (status & QD3DSurfaceManager::MaxSizeChanged) {
-        QSize maxsize = d->m_surface_manager.maxSize();
-        d->m_draw_helper->setMaskSize(maxsize);
-        int masksize[2] = {maxsize.width(), maxsize.height()};
-        d->m_effect->SetIntArray("g_mMaskSize", masksize, 2);
-    }
-
-    if (old_size != d->m_surface_size) {
-        D3DXMATRIX projMatrix;
-        pD3DXMatrixOrthoOffCenterLH(&projMatrix, 0, d->m_surface_size.width(), d->m_surface_size.height(), 0, 0.0f, 1.0f);
-        d->m_statemanager->setProjection(&projMatrix);
-    }
-
-    if (!d->m_in_scene) {
-        if (FAILED(d->m_d3d_device->BeginScene())) {
-            qWarning() << "QDirect3DPaintEngine: BeginScene() failed.";
-            return false;
-        }
-        QWidget *widget = static_cast<QWidget *>(device);
-        if (widget->autoFillBackground() == true) {
-            QColor color = widget->palette().brush(widget->backgroundRole()).color();
-            RECT rect = {0, 0, widget->width(), widget->height()};
-            d->m_d3d_device->ColorFill(d->m_current_surface, &rect,
-                D3DCOLOR_ARGB(color.alpha(), color.red(), color.green(), color.blue()));
-        }
-        d->m_in_scene = true;
-    }
-
-    // set system clip
-    d->m_clipping_enabled = false;
-    d->m_has_complex_clipping = false;
-
-    d->m_sysclip_region = systemClip();
-    QVector<QRect> rects = d->m_sysclip_region.rects();
-    if (rects.count() == 1 && rects.at(0).size() == d->m_surface_size)
-        d->m_sysclip_region = QRegion();
-
-    d->updateClipRegion(QRegion(), Qt::NoClip);
-
-    return true;
-}
-
-void QDirect3DPaintEngine::drawEllipse(const QRectF &rect)
-{
-#ifdef QT_DEBUG_D3D_CALLS
-    qDebug() << "QDirect3DPaintEngine::drawEllipse (float)";
-#endif
-    QPaintEngine::drawEllipse(rect);
-}
-
-void QDirect3DPaintEngine::drawEllipse(const QRect &rect)
-{
-#ifdef QT_DEBUG_D3D_CALLS
-    qDebug() << "QDirect3DPaintEngine::drawEllipse";
-#endif
-    QPaintEngine::drawEllipse(rect);
-}
-
-void QDirect3DPaintEngine::drawImage(const QRectF &r, const QImage &image, const QRectF &sr,
-                                     Qt::ImageConversionFlags)
-{
-#ifdef QT_DEBUG_D3D_CALLS
-    qDebug() << "QDirect3DPaintEngine::drawImage";
-#endif
-
-    Q_D(QDirect3DPaintEngine);
-    int width = image.width();
-    int height = image.height();
-
-    // transform rectangle
-    QPolygonF txrect(QRectF(sr.left() / width, sr.top() / height,
-        sr.width() / width, sr.height() / height));
-
-    QD3DBatchItem *item = d->nextBatchItem();
-    item->m_info = QD3DBatchItem::BI_IMAGE | QD3DBatchItem::BI_TRANSFORM;
-    item->m_texture = qd3d_image_cache()->lookup(d->m_d3d_device, image);
-    item->m_matrix = d->m_matrix;
-    d->m_draw_helper->queueRect(r.adjusted(-0.5f,-0.5f,-0.5f,-0.5f), item, d->m_opacity_color, txrect);
-}
-
-void QDirect3DPaintEngine::drawLines(const QLineF *lines, int lineCount)
-{
-#ifdef QT_DEBUG_D3D_CALLS
-    qDebug() << "QDirect3DPaintEngine::drawLines (float)";
-#endif
-    Q_D(QDirect3DPaintEngine);
-
-    if (!d->m_has_pen)
-        return;
-
-    if (d->m_has_fast_pen && (d->m_pen_brush_style == Qt::SolidPattern)) {
-        QD3DBatchItem *item = d->nextBatchItem();
-        if (d->m_pen.isCosmetic())
-            item->m_info |= QD3DBatchItem::BI_COSMETICPEN;
-        item->m_info |= QD3DBatchItem::BI_TRANSFORM;
-        item->m_matrix = d->m_matrix;
-        d->m_draw_helper->queueAliasedLines(lines, lineCount, &item);
-    } else {
-        QRectF brect;
-        QPainterPath path;
-
-        // creates a path with the lines
-        path.moveTo(lines[0].x1(), lines[0].y1());
-        qreal lastx = lines[0].x2();
-        qreal lasty = lines[0].y2();
-        path.lineTo(lastx, lasty);
-
-        for (int i=1; i<lineCount; ++i) {
-            qreal x = lines[i].x1();
-            qreal y = lines[i].y1();
-            if (lastx != x || lasty != y) {
-                path.moveTo(x, y);
-            }
-            path.lineTo(lines[i].x2(), lines[i].y2());
-        }
-
-        if (d->m_has_cosmetic_pen) {
-            brect = path.controlPointRect();
-            path = d->m_matrix.map(path);
-        }
-
-        d->strokePath(path, brect, true);
-    }
-}
-
-void QDirect3DPaintEngine::drawLines(const QLine *lines, int lineCount)
-{
-#ifdef QT_DEBUG_D3D_CALLS
-    qDebug() << "QDirect3DPaintEngine::drawLines";
-#endif
-    QPaintEngine::drawLines(lines, lineCount);
-}
-
-void QDirect3DPaintEngine::drawPath(const QPainterPath &path)
-{
-#ifdef QT_DEBUG_D3D_CALLS
-    qDebug() << "QDirect3DPaintEngine::drawPath";
-#endif
-    Q_D(QDirect3DPaintEngine);
-
-    if (path.isEmpty())
-        return;
-
-    QRectF brect;
-    QPainterPath tpath;
-
-    if (d->m_has_cosmetic_pen) {
-        brect = path.controlPointRect();
-        tpath = d->m_matrix.map(path);
-    } else {
-        tpath = path;
-    }
-
-    if (d->m_has_brush)
-        d->fillPath(tpath, brect);
-
-    if (d->m_has_pen)
-        d->strokePath(tpath, brect);
-}
-
-
-QPointF QDirect3DPaintEnginePrivate::transformPoint(const QPointF &p, qreal *w) const
-{
-    (*w) = 1.0f;
-    qreal fx = p.x();
-    qreal fy = p.y();
-    qreal nx = m_matrix.m11()*fx + m_matrix.m21()*fy + m_matrix.m31();
-    qreal ny = m_matrix.m12()*fx + m_matrix.m22()*fy + m_matrix.m32();
-    if (!m_matrix.isAffine()) {
-        *w = m_matrix.m13()*fx + m_matrix.m23()*fy + m_matrix.m33();
-        //*w = 1/(*w);
-        nx = nx/(*w);
-        ny = ny/(*w);
-    }
-    return QPointF(nx, ny);
-}
-
-void QDirect3DPaintEngine::drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr)
-{
-#ifdef QT_DEBUG_D3D_CALLS
-    qDebug() << "QDirect3DPaintEngine::drawPixmap";
-#endif
-    Q_D(QDirect3DPaintEngine);
-
-    if (d->m_draw_helper->needsFlushing())
-        d->flushBatch();
-
-    int width = pm.width();
-    int height = pm.height();
-
-    // transform rectangle
-    QPolygonF txrect(QRectF(sr.left() / width, sr.top() / height,
-        sr.width() / width, sr.height() / height));
-
-    QD3DBatchItem *item = d->nextBatchItem();
-    item->m_info = QD3DBatchItem::BI_PIXMAP|QD3DBatchItem::BI_TRANSFORM;
-
-    item->m_pixmap = pm;
-    d->verifyTexture(item->m_pixmap);
-
-    item->m_matrix = d->m_matrix;
-    d->m_draw_helper->queueRect(r.adjusted(-0.5f,-0.5f,-0.5f,-0.5f), item, d->m_opacity_color, txrect);
-}
-
-void QDirect3DPaintEngine::drawPoints(const QPointF *points, int pointCount)
-{
-#ifdef QT_DEBUG_D3D_CALLS
-    qDebug() << "QDirect3DPaintEngine::drawPoints (float)";
-#endif
-    QPaintEngine::drawPoints(points, pointCount);
-}
-
-void QDirect3DPaintEngine::drawPoints(const QPoint *points, int pointCount)
-{
-#ifdef QT_DEBUG_D3D_CALLS
-    qDebug() << "QDirect3DPaintEngine::drawPoints";
-#endif
-    QPaintEngine::drawPoints(points, pointCount);
-}
-
-void QDirect3DPaintEngine::drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode)
-{
-#ifdef QT_DEBUG_D3D_CALLS
-    qDebug() << "QDirect3DPaintEngine::drawPolygon";
-#endif
-    Q_D(QDirect3DPaintEngine);
-
-    if (d->m_has_brush && mode != PolylineMode) {
-        QPainterPath path;
-        path.setFillRule(mode == WindingMode ? Qt::WindingFill : Qt::OddEvenFill);
-        path.moveTo(points[0]);
-        for (int i=1; i<pointCount; ++i)
-            path.lineTo(points[i]);
-        if (path.isEmpty())
-            return;
-        d->fillPath(path, QRectF());
-    }
-
-    if (d->m_has_pen) {
-        QPainterPath path(points[0]);
-        for (int i = 1; i < pointCount; ++i)
-            path.lineTo(points[i]);
-        if (mode != PolylineMode)
-            path.lineTo(points[0]);
-
-        if (path.isEmpty())
-            return;
-        QRectF brect;
-        if (d->m_has_cosmetic_pen) {
-            brect = path.controlPointRect();
-            path = d->m_matrix.map(path);
-        }
-
-        d->strokePath(path, brect);
-    }
-}
-
-void QDirect3DPaintEngine::drawPolygon(const QPoint *points, int pointCount, PolygonDrawMode mode)
-{
-#ifdef QT_DEBUG_D3D_CALLS
-    qDebug() << "QDirect3DPaintEngine::drawPolygon";
-#endif
-    QPaintEngine::drawPolygon(points, pointCount, mode);
-}
-
-void QDirect3DPaintEngine::drawRects(const QRectF *rects, int rectCount)
-{
-    Q_D(QDirect3DPaintEngine);
-#ifdef QT_DEBUG_D3D_CALLS
-    qDebug() << "QDirect3DPaintEngine::drawRects (float)";
-#endif
-    for (int i=0; i<rectCount; ++i) {
-        if ((d->m_brush_style == Qt::SolidPattern) &&
-            (!(d->m_current_state & QD3DBatchItem::BI_AA) || d->isFastRect(rects[i]))) {
-            QD3DBatchItem *item = d->nextBatchItem();
-            item->m_info |= QD3DBatchItem::BI_TRANSFORM;
-            item->m_info &= ~QD3DBatchItem::BI_AA;
-            item->m_matrix = d->m_matrix;
-            const QRectF rect = rects[i];
-            d->m_draw_helper->queueRect(rect, item, d->m_brush_color);
-
-            if (d->m_has_pen) {
-                if (d->m_has_fast_pen && (d->m_pen_brush_style == Qt::SolidPattern)) {
-                    QLineF lines[4];
-                    qreal x1 = rect.x();
-                    qreal y1 = rect.y();
-                    qreal x2 = rect.width() + x1;
-                    qreal y2 = rect.height() + y1;
-                    lines[0] = QLineF(x1, y1, x2, y1);
-                    lines[1] = QLineF(x2, y1, x2, y2);
-                    lines[2] = QLineF(x2, y2, x1, y2);
-                    lines[3] = QLineF(x1, y2, x1, y1);
-                    QD3DBatchItem *item = d->nextBatchItem();
-                    if (d->m_pen.isCosmetic())
-                        item->m_info |= QD3DBatchItem::BI_COSMETICPEN;
-                    item->m_info |= QD3DBatchItem::BI_TRANSFORM;
-                    item->m_matrix = d->m_matrix;
-                    d->m_draw_helper->queueAliasedLines(lines, 4, &item);
-                } else {
-                    QPainterPath path;
-                    QRectF brect;
-
-                    path.addRect(rects[i]);
-                    if (d->m_has_cosmetic_pen) {
-                        brect = path.controlPointRect();
-                        path = d->m_matrix.map(path);
-                    }
-
-                    d->strokePath(path, brect, true);
-                }
-            }
-        } else {
-            QPainterPath path;
-            QRectF brect;
-
-            path.addRect(rects[i]);
-            if (d->m_has_cosmetic_pen) {
-                brect = path.controlPointRect();
-                path = d->m_matrix.map(path);
-            }
-
-            if (d->m_has_brush)
-                d->fillPath(path, brect);
-
-            if (d->m_has_pen)
-                d->strokePath(path, brect, true);
-        }
-    }
-}
-
-void QDirect3DPaintEngine::drawRects(const QRect *rects, int rectCount)
-{
-#ifdef QT_DEBUG_D3D_CALLS
-    qDebug() << "QDirect3DPaintEngine::drawRects";
-#endif
-    QPaintEngine::drawRects(rects, rectCount);
-}
-
-
-void QDirect3DPaintEngine::drawTextItem(const QPointF &p, const QTextItem &textItem)
-{
-    Q_D(QDirect3DPaintEngine);
-
-#ifdef QT_DEBUG_D3D_CALLS
-    qDebug() << "QDirect3DPaintEngine::drawTextItem";
-#endif
-//     if (d->m_matrix.isScaling() || (d->m_pen_brush_style >= Qt::LinearGradientPattern
-//                                     && d->m_pen_brush_style <= Qt::ConicalGradientPattern)) {
-//         QPaintEngine::drawTextItem(p, textItem);
-//         return;
-//     }
-
-    const QTextItemInt &ti = static_cast<const QTextItemInt &>(textItem);
-    QVarLengthArray<QFixedPoint> positions;
-    QVarLengthArray<glyph_t> glyphs;
-    QTransform matrix;
-    matrix.translate(p.x(), p.y());
-    ti.fontEngine->getGlyphPositions(ti.glyphs, matrix, ti.flags, glyphs, positions);
-
-    qd3d_glyph_cache()->cacheGlyphs(this, ti, glyphs, d->m_cleartype_text);
-    QD3DFontTexture *font_tex = qd3d_glyph_cache()->fontTexture(ti.fontEngine);
-
-    QD3DBatchItem *item = d->nextBatchItem();
-    d->m_draw_helper->lockVertexBuffer();
-
-    item->m_info = QD3DBatchItem::BI_TEXT
-        | (d->m_current_state & ~QD3DBatchItem::BI_AA) | QD3DBatchItem::BI_TRANSFORM;
-    item->m_texture = font_tex->texture;
-    item->m_offset = d->m_draw_helper->index();
-    item->m_matrix = d->m_matrix;
-    item->m_count = 0;
-    item->m_brush = d->m_pen.brush();
-
-    for (int i=0; i< glyphs.size(); ++i) {
-        QD3DGlyphCoord *g = qd3d_glyph_cache()->lookup(ti.fontEngine, glyphs[i]);
-
-        // we don't cache glyphs with no width/height
-        if (!g)
-            continue;
-
-        // texture coords
-        qreal tex_coords[] = { g->x, g->y, g->x + g->width, g->y + g->height };
-        QPointF logical_pos(qRound((positions[i].x - g->x_offset).toReal()) - 0.5f,
-                            qRound((positions[i].y + g->y_offset).toReal()) - 0.5f);
-
-        QRectF glyph_rect(logical_pos, QSizeF(g->log_width, g->log_height));
-        d->m_draw_helper->queueTextGlyph(glyph_rect, tex_coords, item, d->m_pen_color);
-    }
-}
-
-void QDirect3DPaintEngine::drawTiledPixmap(const QRectF &rect, const QPixmap &pixmap, const QPointF &p)
-{
-#ifdef QT_DEBUG_D3D_CALLS
-    qDebug() << "QDirect3DPaintEngine::drawTiledPixmap";
-#endif
-    QPaintEngine::drawTiledPixmap(rect, pixmap, p);
-}
-
-bool QDirect3DPaintEngine::end()
-{
-    Q_D(QDirect3DPaintEngine);
-
-    d->flushBatch();
-
-    if (d->m_flush_on_end) {
-        QPaintDevice *pdev = paintDevice();
-        LPDIRECT3DSWAPCHAIN9 swapchain = swapChain(pdev);
-
-
-        QWidget *w = 0;
-        if (pdev->devType() == QInternal::Widget) {
-            w = static_cast<QWidget *>(pdev);
-        }
-
-        if (w && swapchain) {
-            QRect br = w->rect();
-            QRect wbr = br;//.translated(-w->pos());
-
-            RECT destrect;
-            destrect.left   = wbr.x();
-            destrect.top    = wbr.y();
-            destrect.right  = destrect.left + wbr.width();
-            destrect.bottom = destrect.top  + wbr.height();
-
-            RECT srcrect;
-            srcrect.left    = br.x();// + w->x();
-            srcrect.top     = br.y();// + w->y();
-            srcrect.right   = wbr.width() + srcrect.left;
-            srcrect.bottom  = wbr.height() + srcrect.top;
-            int devwidth = w->width();
-            int devheight = w->height();
-
-            if (devwidth <= srcrect.right) {
-                int diff = srcrect.right - devwidth;
-                srcrect.right -= diff;
-                destrect.right -= diff;
-                if (srcrect.right <= srcrect.left)
-                    return false;
-            }
-            if (devheight <= srcrect.bottom) {
-                int diff = srcrect.bottom - devheight;
-                srcrect.bottom -= diff;
-                destrect.bottom -= diff;
-                if (srcrect.bottom <= srcrect.top)
-                    return false;
-            }
-
-            if (FAILED(swapchain->Present(&srcrect, &destrect, w->winId(), 0, 0)))
-                qWarning("QDirect3DPaintEngine: failed to present back buffer.");
-        }
-    }
-
-
-    return true;
-}
-
-void QDirect3DPaintEngine::updateState(const QPaintEngineState &state)
-{
-#ifdef QT_DEBUG_D3D_CALLS
-    qDebug() << "QDirect3DPaintEngine::updateState";
-#endif
-    Q_D(QDirect3DPaintEngine);
-
-    bool update_fast_pen = false;
-    DirtyFlags flags = state.state();
-
-    if (flags & DirtyOpacity) {
-        d->m_opacity = state.opacity();
-        if (d->m_opacity > 1.0f)
-            d->m_opacity = 1.0f;
-        if (d->m_opacity < 0.f)
-            d->m_opacity = 0.f;
-        uint c = (d->m_opacity * 255);
-        d->m_opacity_color = D3DCOLOR_ARGB(c,c,c,c);
-        flags |= (DirtyPen | DirtyBrush);
-    }
-
-    if (flags & DirtyCompositionMode) {
-        d->m_cmode = state.compositionMode();
-    }
-
-    if (flags & DirtyTransform) {
-        d->updateTransform(state.transform());
-        update_fast_pen = true;
-    }
-
-    if (flags & DirtyHints) {
-        if (state.renderHints() & QPainter::Antialiasing)
-            d->m_current_state |= QD3DBatchItem::BI_AA;
-        else
-            d->m_current_state &= ~QD3DBatchItem::BI_AA;
-        update_fast_pen = true;
-    }
-
-    if (flags & DirtyFont) {
-        d->updateFont(state.font());
-    }
-
-    if (state.state() & DirtyClipEnabled) {
-        if (state.isClipEnabled() && !d->m_clipping_enabled) {
-            d->m_clipping_enabled = true;
-            if (d->m_has_complex_clipping)
-                d->updateClipPath(painter()->clipPath(), Qt::ReplaceClip);
-            else
-                d->updateClipRegion(painter()->clipRegion(), Qt::ReplaceClip);
-        } else if (!state.isClipEnabled() && d->m_clipping_enabled) {
-            d->m_clipping_enabled = false;
-            if (d->m_has_complex_clipping)
-                d->updateClipPath(QPainterPath(), Qt::NoClip);
-            else
-                d->updateClipRegion(QRegion(), Qt::NoClip);
-        }
-    }
-
-    if (flags & DirtyClipRegion) {
-        d->updateClipRegion(state.clipRegion(), state.clipOperation());
-    }
-
-    if (flags & DirtyClipPath) {
-        d->updateClipPath(state.clipPath(), state.clipOperation());
-    }
-
-    if (flags & DirtyBrushOrigin) {
-        d->m_brush_origin = QTransform();
-        d->m_brush_origin.translate(-state.brushOrigin().x(),
-            -state.brushOrigin().y());
-        flags |= DirtyBrush;
-    }
-
-    if (flags & DirtyPen) {
-        d->updatePen(state.pen());
-        update_fast_pen = true;
-    }
-
-    if (flags & DirtyBrush)
-        d->updateBrush(state.brush());
-
-    if (update_fast_pen && d->m_has_pen) {
-        if (d->m_current_state & QD3DBatchItem::BI_AA) {
-            d->m_has_fast_pen = false;
-            d->m_has_aa_fast_pen = ((d->m_txop <= QTransform::TxTranslate) || d->m_has_cosmetic_pen)
-                && (d->m_pen_width <= 1.0f)
-                && (d->m_pen.style() == Qt::SolidLine);
-        } else {
-            d->m_has_aa_fast_pen = false;
-            d->m_has_fast_pen = ((d->m_txop <= QTransform::TxTranslate) || d->m_has_cosmetic_pen)
-                              && (d->m_pen.style() == Qt::SolidLine)
-                              && (d->m_pen.capStyle() == Qt::SquareCap);
-        }
-    }
-}
-
-void QDirect3DPaintEngine::cleanup()
-{
-    Q_D(QDirect3DPaintEngine);
-    d->cleanup();
-}
-
-void QDirect3DPaintEngine::scroll(QPaintDevice *pd, const RECT &srcrect, const RECT &destrect)
-{
-    Q_D(QDirect3DPaintEngine);
-    LPDIRECT3DSURFACE9 srcsurf = d->m_surface_manager.surface(pd);
-    LPDIRECT3DSURFACE9 masksurf = d->m_draw_helper->freeMaskSurface();
-    if (FAILED(d->m_d3d_device->StretchRect(srcsurf, &srcrect, masksurf, &srcrect, D3DTEXF_NONE)))
-        qWarning("QDirect3DPaintEngine: StretchRect failed.");
-    if (FAILED(d->m_d3d_device->StretchRect(masksurf, &srcrect, srcsurf, &destrect, D3DTEXF_NONE)))
-        qWarning("QDirect3DPaintEngine: StretchRect failed.");
-}
-
-LPDIRECT3DSWAPCHAIN9 QDirect3DPaintEngine::swapChain(QPaintDevice *pd)
-{
-    Q_D(QDirect3DPaintEngine);
-
-    if (d->m_in_scene) {
-        if (d->m_d3d_device == 0) {
-            qWarning("QDirect3DPaintEngine: No device!");
-            return false;
-        }
-
-        d->setRenderTechnique(QDirect3DPaintEnginePrivate::RT_NoTechnique);
-        if (FAILED(d->m_d3d_device->EndScene()))
-            qWarning("QDirect3DPaintEngine: failed to end scene.");
-
-        d->m_in_scene = false;
-    }
-
-    return d->m_surface_manager.swapChain(pd);
-}
-
-void QDirect3DPaintEngine::releaseSwapChain(QPaintDevice *pd)
-{
-    Q_D(QDirect3DPaintEngine);
-    d->m_surface_manager.releasePaintDevice(pd);
-}
-
-HDC QDirect3DPaintEngine::getDC() const
-{
-    QDirect3DPaintEnginePrivate *d = const_cast<QDirect3DPaintEnginePrivate *>(d_func());
-
-    if (!d->m_dc && d->m_current_surface) {
-        d->m_dcsurface = d->m_current_surface;
-        if (FAILED(d->m_current_surface->GetDC(&d->m_dc)))
-            qWarning() << "QDirect3DPaintEngine::getDC() failed!";
-    }
-
-    return d->m_dc;
-}
-
-void QDirect3DPaintEngine::setFlushOnEnd(bool flushOnEnd)
-{
-    Q_D(QDirect3DPaintEngine);
-
-    d->m_flush_on_end = flushOnEnd;
-}
-
-bool QDirect3DPaintEngine::hasDirect3DSupport()
-{
-    Q_D(QDirect3DPaintEngine);
-    return d->m_supports_d3d;
-}
-
-QT_END_NAMESPACE
-
-#include "qpaintengine_d3d.moc"
diff --git a/src/gui/painting/qpaintengine_d3d.fx b/src/gui/painting/qpaintengine_d3d.fx
deleted file mode 100644
index 1148b2a..0000000
--- a/src/gui/painting/qpaintengine_d3d.fx
+++ /dev/null
@@ -1,608 +0,0 @@
-bool g_mCosmeticPen;
-int4 g_mChannel;
-float2 g_mMaskOffset;
-int2 g_mMaskSize;
-float4x4 g_mMaskProjection;
-float4x4 g_mViewProjection;
-float4x4 g_mTransformation;
-texture g_mAAMask;
-texture g_mTexture;
-int g_mBrushMode;
-float g_mFocalDist;
-
-#define M_PI 3.14159265358979323846
-
-sampler PixmapSampler = sampler_state
-{
-    texture = <g_mTexture>;
-    MIPFILTER = NONE;
-    MINFILTER = LINEAR;
-    MAGFILTER = LINEAR;
-};
-
-sampler TextSampler = sampler_state
-{
-    texture = <g_mTexture>;
-    MIPFILTER = NONE;
-    MINFILTER = POINT;
-    MAGFILTER = POINT;
-};
-
-sampler AAMaskSampler = sampler_state
-{
-    texture = <g_mAAMask>;
-    AddressU  = WRAP;
-    AddressV  = WRAP;
-    AddressW  = WRAP;
-    MIPFILTER = NONE;
-    MINFILTER = POINT;
-    MAGFILTER = POINT;
-};
-
-struct VS_FULL
-{
-    float4 Position : POSITION;
-    float4 Diffuse : COLOR0;
-    float4 TexCoords0 : TEXCOORD0;
-    float4 TexCoords1 : TEXCOORD1;
-};
-
-VS_FULL TrapezoidVS( float4 Position : POSITION,
-                                float4 Diffuse : COLOR0,
-                                float4 TexCoords0 : TEXCOORD0,
-                                float4 TexCoords1 : TEXCOORD1)
-{
-    VS_FULL Output;
-
-    float a = (TexCoords1.x * Position.x) + (TexCoords1.z * (1.0 - Position.x) ); // left or right a
-    float b = (TexCoords1.y * Position.x) + (TexCoords1.w * (1.0 - Position.x) ); // left or right b
-    float d = 1.0 - (Position.x * 2);
-
-    Position.x = (a * Position.y + b) + ( sqrt( abs(a * a) ) * d );
-    //Position.x += step(abs(a), 0) * d;
-    Position.x += (0.5 * d);
-
-    Output.Position = mul(Position, g_mMaskProjection);
-    Output.Diffuse = Diffuse;
-    Output.TexCoords0 = TexCoords0;
-    Output.TexCoords1 = TexCoords1;
-
-    return Output;
-}
-
-struct PS_OUTPUT
-{
-    float4 Color : COLOR0;
-};
-
-PS_OUTPUT TrapezoidPS(VS_FULL In, float2 pixelPos : VPOS)
-{
-    PS_OUTPUT Out;
-
-    float top = max(pixelPos.y - 0.5, In.TexCoords0.x);
-    float bottom = min(pixelPos.y + 0.5, In.TexCoords0.y);
-
-    float area = bottom - top;
-
-    float left = pixelPos.x - 0.5;
-    float right = pixelPos.x + 0.5;
-
-    // use line equations to compute intersections of left/right edges with top/bottom of truncated pixel
-    // vecX: x = (left, top), y = (left, bottom), z = (right, top), w = (right, bottom)
-    float4 vecX = In.TexCoords1.xxzz * float2(top, bottom).xyxy + In.TexCoords1.yyww;
-
-    float2 invA = In.TexCoords0.zw;
-
-    // transform right line to left to be able to use same calculations for both
-    vecX.zw = 2 * pixelPos.x - vecX.zw;
-
-    float2 topX = float2(vecX.x, vecX.z);
-    float2 bottomX = float2(vecX.y, vecX.w);
-
-    // transform lines such that top intersection is to the right of bottom intersection
-    float2 topXTemp = max(topX, bottomX);
-    float2 bottomXTemp = min(topX, bottomX);
-
-    // make sure line slope reflects mirrored lines
-    invA = lerp(invA, -invA, step(topX, bottomX));
-
-    float2 vecLeftRight = float2(left, right);
-
-    // compute the intersections of the lines with the left and right edges of the pixel
-    // intersectY: x = (left_line, left), y = (left_line, right), z = (right_line, left), w = (right_line, right)
-    float4 intersectY = top + (vecLeftRight.xyxy - topXTemp.xxyy) * invA.xxyy;
-
-    float2 temp = lerp(area - 0.5 * (right - bottomXTemp) * (bottom - intersectY.yw), // left < bottom < right < top
-                    (0.5 * (topXTemp + bottomXTemp) - left) * area,    // left < bottom < top < right
-                    step(topXTemp, right));
-
-    float2 excluded = 0.5 * (intersectY.xz - top) * (topXTemp - left); // bottom < left < top < right
-
-    excluded = lerp(0.5 * (intersectY.yw + intersectY.xz) - top, // bottom < left < right < top
-                   excluded, step(topXTemp, right));
-
-    excluded = lerp(temp, // left < bottom < right (see calculation of temp)
-                   excluded, step(bottomXTemp, left));
-
-    excluded = lerp(float2(area, area), // right < bottom < top
-                   excluded, step(bottomXTemp, right));
-
-    excluded *= step(left, topXTemp);
-
-    float result = (area - excluded.x - excluded.y) * step(top, bottom);
-    Out.Color.r = result * g_mChannel[0];
-    Out.Color.g = result * g_mChannel[1];
-    Out.Color.b = result * g_mChannel[2];
-    Out.Color.a = result * g_mChannel[3];
-
-    return Out;
-}
-
-VS_FULL ViewProjectionVS( float4 Position : POSITION,
-                          float4 Diffuse : COLOR0,
-                          float4 TexCoords0 : TEXCOORD0,
-                          float4 TexCoords1 : TEXCOORD1)
-{
-    VS_FULL Output;
-
-    Output.Position = mul(Position, g_mTransformation);
-    Output.Position = mul(Output.Position, g_mViewProjection);
-    Output.Diffuse = Diffuse;
-    Output.TexCoords0 = TexCoords0;
-    Output.TexCoords1 = TexCoords1;
-
-    return Output;
-}
-
-PS_OUTPUT DirectMaskPS(VS_FULL In, float2 pixelPos : VPOS)
-{
-    PS_OUTPUT Out;
-    Out.Color = In.Diffuse;
-
-    float2 maskcoords = ( (pixelPos + g_mMaskOffset) - 0.5 ) / g_mMaskSize;
-    float2 clipcoords = (pixelPos - 0.5) / g_mMaskSize;
-
-    float4 c = tex2D(AAMaskSampler, maskcoords.xy) * Out.Color.a;
-    Out.Color.a  = c.r * g_mChannel[0];
-    Out.Color.a += c.g * g_mChannel[1];
-    Out.Color.a += c.b * g_mChannel[2];
-    Out.Color.a += c.a * g_mChannel[3];
-
-    return Out;
-}
-
-PS_OUTPUT MaskPS(VS_FULL In, float2 pixelPos : VPOS)
-{
-    PS_OUTPUT Out;
-
-    if (g_mBrushMode == 1) {
-        float x = In.TexCoords0.x;
-        float y = In.TexCoords0.y;
-        x = x - int(x);
-        y = y - int(y);
-        Out.Color = tex2D(PixmapSampler, float2(x, y));
-        Out.Color.a = Out.Color.a * In.Diffuse.a;
-    } else if (g_mBrushMode == 2) {
-        Out.Color = tex1D(PixmapSampler, In.TexCoords0.x);
-    } else if (g_mBrushMode == 3) {
-        float t = atan2(In.TexCoords0.y, -In.TexCoords0.x) / (2 * M_PI);
-        Out.Color = tex1D(PixmapSampler, t + 0.5);
-    } else if (g_mBrushMode == 4) {
-        float2 tc = float2(In.TexCoords0.x, abs(In.TexCoords0.y));
-        float a = (tc.x - g_mFocalDist) / tc.y;
-        float b = g_mFocalDist;
-
-        float A = 1 + (a * a);
-        float B = 2.0 * a * b;
-        float C = (b * b) - 1;
-
-        float y = (-B + sqrt(B*B - 4.0*A*C)) / (2.0*A);
-        Out.Color = tex1D(PixmapSampler, (tc.y / y) );
-    } else if (g_mBrushMode == 5) {
-        Out.Color = tex2D(PixmapSampler, In.TexCoords0.xy);
-        Out.Color = Out.Color * In.Diffuse;
-    } else {
-        Out.Color = In.Diffuse;
-    }
-
-    float2 maskcoords = ( (pixelPos + g_mMaskOffset) - 0.5 ) / g_mMaskSize;
-
-    float4 c = tex2D(AAMaskSampler, maskcoords.xy) * Out.Color.a;
-    Out.Color.a  = c.r * g_mChannel[0];
-    Out.Color.a += c.g * g_mChannel[1];
-    Out.Color.a += c.b * g_mChannel[2];
-    Out.Color.a += c.a * g_mChannel[3];
-
-    return Out;
-}
-
-struct VS_NORMAL
-{
-    float4 Position : POSITION;
-    float4 Diffuse : COLOR0;
-    float4 TexCoords : TEXCOORD0;
-};
-
-VS_NORMAL MaskProjectionVS(VS_NORMAL In)
-{
-    VS_NORMAL Output;
-
-    Output.Position = mul(In.Position, g_mMaskProjection);
-    Output.Diffuse = In.Diffuse;
-    Output.TexCoords = In.TexCoords;
-
-    return Output;
-}
-
-float4 DirectSimplePS(float4 Color : COLOR0) : COLOR0
-{
-    return Color;
-}
-
-float4 SimplePS(float4 Color : COLOR0, float4 TexCoords : TEXCOORD0) : COLOR0
-{
-    if (g_mBrushMode == 1) {
-        float opacity = Color.a;
-        float x = TexCoords.x;
-        float y = TexCoords.y;
-        x = x - int(x);
-        y = y - int(y);
-        Color = tex2D(PixmapSampler, float2(x, y));
-        Color.a = Color.a * opacity;
-    } else if (g_mBrushMode == 2) {
-        Color = tex1D(PixmapSampler, TexCoords.x);
-    } else if (g_mBrushMode == 3) {
-        float t = atan2(TexCoords.y, -TexCoords.x) / (2 * M_PI);
-        Color = tex1D(PixmapSampler, t + 0.5);
-    } else if (g_mBrushMode == 4) {
-        float2 tc = float2(TexCoords.x, abs(TexCoords.y));
-        float a = (tc.x - g_mFocalDist) / tc.y;
-        float b = g_mFocalDist;
-
-        float A = 1 + (a * a);
-        float B = 2.0 * a * b;
-        float C = (b * b) - 1;
-
-        float y = (-B + sqrt(B*B - 4.0*A*C)) / (2.0*A);
-        Color = tex1D(PixmapSampler, (tc.y / y) );
-    } else if (g_mBrushMode == 5) {
-        Color = tex2D(PixmapSampler, TexCoords.xy) * Color;
-    }
-
-    return Color;
-}
-
-float4 TextPS(float4 Color : COLOR0, float4 TexCoords : TEXCOORD0) : COLOR0
-{
-    Color.a *= tex2D(TextSampler, TexCoords.xy).a;
-    return Color;
-}
-
-float4 ClearTypePS(float4 Color : COLOR0, float4 TexCoords : TEXCOORD0) : COLOR0
-{
-//     if (g_mUsePixmap) {
-//     float4 MaskColor = tex2D(PixmapSampler, TexCoords.xy);
-//     Color = float4(1.0, 0.0, 0.0, 1.0);
-//     Color.a = (1 - MaskColor.a) + MaskColor.a * Color.a;
-//     Color.r = (1.0 - MaskColor.r) + (MaskColor.r * Color.r);
-//     Color.g = (1.0 - MaskColor.g) + (MaskColor.g * Color.g);
-//     Color.b = (1.0 - MaskColor.b) + (MaskColor.b * Color.b);
-//     Color = MaskColor;
-    return tex2D(PixmapSampler, TexCoords.xy);
-}
-
-VS_NORMAL NoTxAliasedVS(VS_NORMAL In)
-{
-    VS_NORMAL Output;
-
-    Output.Position = mul(In.Position, g_mViewProjection);
-    Output.Diffuse = In.Diffuse;
-    Output.TexCoords = In.TexCoords;
-
-    return Output;
-}
-
-VS_NORMAL AliasedVS(VS_NORMAL In)
-{
-    VS_NORMAL Output;
-
-    Output.Position = mul(In.Position, g_mTransformation);
-    Output.Position = mul(Output.Position, g_mViewProjection);
-    Output.Diffuse = In.Diffuse;
-    Output.TexCoords = In.TexCoords;
-
-    return Output;
-}
-
-VS_NORMAL AliasedLinesVS(VS_NORMAL In)
-{
-    VS_NORMAL Output;
-
-	float4 start = float4(In.Position.x, In.Position.y, 0.5, In.Position.w);
-	float4 end = float4(In.TexCoords.z, In.TexCoords.w, 0.5, In.Position.w);
-	if (g_mCosmeticPen) {
-		start = mul(start, g_mTransformation);
-		end =  mul(end, g_mTransformation);
-	}
-
-    float2 line_vec = end - start;
-    float2 vec = normalize(line_vec);
-    float2 norm = float2(-vec.y, vec.x);
-
-    float pen_width = In.Position.z;
-    norm = norm * pen_width * 0.5;
-    vec = vec * pen_width * 0.5;
-
-    Output.Position.w = In.Position.w;
-    Output.Position.x = start.x + (vec.x * In.TexCoords.x);
-    Output.Position.x = Output.Position.x + (norm.x * In.TexCoords.y);
-    Output.Position.x = Output.Position.x + (line_vec.x * step(0, In.TexCoords.x));
-    Output.Position.y = start.y + (vec.y * In.TexCoords.x);
-    Output.Position.y = Output.Position.y + (norm.y * In.TexCoords.y);
-    Output.Position.y = Output.Position.y + (line_vec.y * step(0, In.TexCoords.x));
-    Output.Position.z = 0.5;
-
-    if (!g_mCosmeticPen) {
-	    Output.Position = mul(Output.Position, g_mTransformation);
-	}
-    Output.Position = mul(Output.Position, g_mViewProjection);
-
-    Output.Diffuse = In.Diffuse;
-    Output.TexCoords = In.TexCoords;
-
-    return Output;
-}
-
-
-technique Antialiased
-{
-    pass PASS_AA_CREATEMASK
-    {
-        StencilEnable = False;
-        ZWriteEnable = False;
-        ColorWriteEnable = 0x0f;
-        ZEnable = False;
-
-        SrcBlend = One;
-        DestBlend = One;
-
-        VertexShader = compile vs_3_0 TrapezoidVS();
-        PixelShader = compile ps_3_0 TrapezoidPS();
-    }
-
-    pass PASS_AA_DRAW
-    {
-        StencilEnable = False;
-        ZFunc = Greater;
-        ZWriteEnable = False;
-        ZEnable = True;
-        ColorWriteEnable = 0x0f;
-
-        VertexShader = compile vs_3_0 ViewProjectionVS();
-        PixelShader = compile ps_3_0 MaskPS();
-    }
-
-    pass PASS_AA_DRAW_DIRECT
-    {
-        StencilEnable = False;
-        ZFunc = Greater;
-        ZEnable = True;
-        ZWriteEnable = False;
-        ColorWriteEnable = 0x0f;
-
-        VertexShader = compile vs_3_0 ViewProjectionVS();
-        PixelShader = compile ps_3_0 DirectMaskPS();
-    }
-}
-
-technique Aliased
-{
-    pass PASS_STENCIL_ODDEVEN
-    {
-        TwoSidedStencilMode = False;
-        StencilEnable = True;
-        StencilPass = Invert;
-        StencilFunc = Always;
-        ColorWriteEnable = 0;
-
-        ZEnable = False;
-        ZWriteEnable = False;
-
-        VertexShader = compile vs_1_1 NoTxAliasedVS();
-        PixelShader = compile ps_2_0 DirectSimplePS();
-    }
-
-    pass PASS_STENCIL_WINDING
-    {
-        TwoSidedStencilMode = True;
-        StencilEnable = True;
-        StencilRef = 0;
-        StencilMask = 0xFFFFFFFF;
-
-        CCW_StencilPass = Incr;
-        CCW_StencilFunc = Always;
-
-        StencilPass = Decr;
-        StencilFunc = Always;
-
-        ColorWriteEnable = 0;
-
-        ZEnable = False;
-        ZWriteEnable = False;
-
-        VertexShader = compile vs_1_1 NoTxAliasedVS();
-        PixelShader = compile ps_2_0 DirectSimplePS();
-    }
-
-    pass PASS_STENCIL_DRAW
-    {
-        TwoSidedStencilMode = False;
-        StencilEnable = True;
-        StencilFunc = NotEqual;
-        StencilMask = 0xFFFFFFFF;
-        StencilRef = 0;
-        StencilPass = Zero;
-        StencilFail = Zero;
-        StencilZFail = Zero;
-
-        ColorWriteEnable = 0x0f;
-        ZEnable = True;
-        ZWriteEnable = False;
-        ZFunc = Greater;
-
-        VertexShader = compile vs_1_1 AliasedVS();
-        PixelShader = compile ps_2_0 SimplePS();
-    }
-
-    pass PASS_STENCIL_DRAW_DIRECT
-    {
-        TwoSidedStencilMode = False;
-        StencilEnable = True;
-        StencilFunc = NotEqual;
-        StencilMask = 0xFFFFFFFF;
-        StencilRef = 0;
-        StencilPass = Zero;
-        StencilFail = Zero;
-        StencilZFail = Zero;
-
-        ColorWriteEnable = 0x0f;
-        ZEnable = True;
-        ZWriteEnable = False;
-        ZFunc = Greater;
-
-        VertexShader = compile vs_1_1 AliasedVS();
-        PixelShader = compile ps_2_0 DirectSimplePS();
-    }
-
-    pass PASS_STENCIL_CLIP
-    {
-        TwoSidedStencilMode = False;
-        StencilEnable = True;
-        StencilFunc = NotEqual;
-        StencilMask = 0xFFFFFFFF;
-        StencilRef = 0;
-        StencilPass = Zero;
-        StencilFail = Zero;
-        StencilZFail = Zero;
-
-        ColorWriteEnable = 0;
-        ZEnable = True;
-        ZWriteEnable = True;
-        ZFunc = Always;
-
-        VertexShader = compile vs_1_1 NoTxAliasedVS();
-        PixelShader = compile ps_2_0 DirectSimplePS();
-    }
-
-    pass PASS_STENCIL_NOSTENCILCHECK
-    {
-        StencilEnable = False;
-
-        ZEnable = True;
-        ZWriteEnable = False;
-        ZFunc = Greater;
-
-        ColorWriteEnable = 0x0f;
-
-        SrcBlend = SrcAlpha;
-        DestBlend = InvSrcAlpha;
-
-        VertexShader = compile vs_1_1 AliasedVS();
-        PixelShader = compile ps_2_0 SimplePS();
-    }
-
-    pass PASS_STENCIL_NOSTENCILCHECK_DIRECT
-    {
-        StencilEnable = False;
-
-        ZEnable = True;
-        ZWriteEnable = False;
-        ZFunc = Greater;
-
-        ColorWriteEnable = 0x0f;
-
-        SrcBlend = SrcAlpha;
-        DestBlend = InvSrcAlpha;
-
-        VertexShader = compile vs_1_1 AliasedVS();
-        PixelShader = compile ps_2_0 DirectSimplePS();
-    }
-
-    pass PASS_TEXT
-    {
-        StencilEnable = False;
-
-        ZEnable = True;
-        ZWriteEnable = False;
-        ZFunc = Greater;
-
-        ColorWriteEnable = 0x0f;
-
-        SrcBlend = SrcAlpha;
-        DestBlend = InvSrcAlpha;
-
-        VertexShader = compile vs_1_1 AliasedVS();
-        PixelShader = compile ps_2_0 TextPS();
-    }
-
-    pass PASS_CLEARTYPE_TEXT
-    {
-        StencilEnable = False;
-
-        ZEnable = True;
-        ZWriteEnable = False;
-        ZFunc = Greater;
-
-        ColorWriteEnable = 0x0f;
-
-//         SrcBlend = SrcAlpha;
-//         DestBlend = InvSrcAlpha;
-
-//        SrcBlend = DestColor;
-//        DestBlend = Zero;
-        SrcBlend = BlendFactor;
-        DestBlend = InvSrcColor;
-
-//         SrcBlend = Zero;
-//         DestBlend = SrcColor;
-
-//         SrcBlend = One;
-//         DestBlend = Zero;
-
-        VertexShader = compile vs_3_0 AliasedVS();
-        PixelShader = compile ps_3_0 ClearTypePS();
-    }
-
-    pass PASS_ALIASED_LINES
-    {
-        TwoSidedStencilMode = False;
-        StencilEnable = True;
-        StencilPass = Invert;
-        StencilFunc = Always;
-        ColorWriteEnable = 0;
-
-        ZEnable = False;
-        ZWriteEnable = False;
-
-        VertexShader = compile vs_1_1 AliasedLinesVS();
-        PixelShader = compile ps_2_0 DirectSimplePS();
-    }
-
-    pass PASS_ALIASED_LINES_DIRECT
-    {
-        StencilEnable = False;
-
-        ZEnable = True;
-        ZWriteEnable = False;
-        ZFunc = Greater;
-
-        ColorWriteEnable = 0x0f;
-
-        SrcBlend = SrcAlpha;
-        DestBlend = InvSrcAlpha;
-
-        VertexShader = compile vs_1_1 AliasedLinesVS();
-        PixelShader = compile ps_2_0 DirectSimplePS();
-    }
-}
-
diff --git a/src/gui/painting/qpaintengine_d3d.qrc b/src/gui/painting/qpaintengine_d3d.qrc
deleted file mode 100644
index c106f2b..0000000
--- a/src/gui/painting/qpaintengine_d3d.qrc
+++ /dev/null
@@ -1,5 +0,0 @@
-<!DOCTYPE RCC><RCC version="1.0">
-<qresource>
-   <file>qpaintengine_d3d.fx</file>
-</qresource>
-</RCC>
diff --git a/src/gui/painting/qpaintengine_d3d_p.h b/src/gui/painting/qpaintengine_d3d_p.h
deleted file mode 100644
index 8fa5cf6..0000000
--- a/src/gui/painting/qpaintengine_d3d_p.h
+++ /dev/null
@@ -1,120 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
-** Beta Release License Agreement.
-**
-** 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.0, included in the file LGPL_EXCEPTION.txt in this
-** package.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3.0 as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU General Public License version 3.0 requirements will be
-** met: http://www.gnu.org/copyleft/gpl.html.
-**
-** If you are unsure which license is appropriate for your use, please
-** contact the sales department at qt-sales@nokia.com.
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef QPAINTENGINE_D3D_P_H
-#define QPAINTENGINE_D3D_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/qpaintengine.h"
-#include <d3d9.h>
-
-QT_BEGIN_NAMESPACE
-
-class QDirect3DPaintEnginePrivate;
-class QDirect3DPaintEngine : public QPaintEngine
-{
-    Q_DECLARE_PRIVATE(QDirect3DPaintEngine)
-public:
-    QDirect3DPaintEngine();
-    ~QDirect3DPaintEngine();
-    bool begin(QPaintDevice *device);
-
-    void drawEllipse(const QRectF &rect);
-    void drawEllipse(const QRect &rect);
-
-    void drawImage(const QRectF &rectangle, const QImage &image, const QRectF &sr,
-        Qt::ImageConversionFlags flags = Qt::AutoColor);
-
-    void drawLines(const QLineF *lines, int lineCount);
-    void drawLines(const QLine *lines, int lineCount);
-
-    void drawPath(const QPainterPath &path);
-
-    void drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr);
-
-    void drawPoints(const QPointF *points, int pointCount);
-    void drawPoints(const QPoint *points, int pointCount);
-
-    void drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode);
-    void drawPolygon(const QPoint *points, int pointCount, PolygonDrawMode mode);
-
-    void drawRects(const QRectF *rects, int rectCount);
-    void drawRects(const QRect * rects, int rectCount);
-
-    void drawTextItem(const QPointF &p, const QTextItem &textItem);
-
-    void drawTiledPixmap(const QRectF &r, const QPixmap &pm, const QPointF &sr);
-
-    bool end();
-
-    Type type() const { return Direct3D; }
-    void updateState(const QPaintEngineState &state);
-
-    void cleanup();
-
-    HDC getDC() const;
-    void setFlushOnEnd(bool flushOnEnd);
-    bool hasDirect3DSupport();
-
-public:
-    void scroll(QPaintDevice *pd, const RECT &srcrect, const RECT &destrect);
-    LPDIRECT3DSWAPCHAIN9 swapChain(QPaintDevice *pd);
-    void releaseSwapChain(QPaintDevice *pd);
-
-private:
-    Q_DISABLE_COPY(QDirect3DPaintEngine)
-    friend class QPixmap;
-    friend class QD3DGlyphCache;
-};
-
-QT_END_NAMESPACE
-
-#endif
diff --git a/src/gui/painting/qpaintengine_p.h b/src/gui/painting/qpaintengine_p.h
index eeba7ec..0b5e175 100644
--- a/src/gui/painting/qpaintengine_p.h
+++ b/src/gui/painting/qpaintengine_p.h
@@ -83,10 +83,12 @@ public:
         if (systemClip.isEmpty())
             return;
 
-        if (systemTransform.type() <= QTransform::TxTranslate)
-            systemClip.translate(qRound(systemTransform.dx()), qRound(systemTransform.dy()));
-        else
-            systemClip = systemTransform.map(systemClip);
+        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) {
@@ -101,7 +103,7 @@ public:
     inline void setSystemTransform(const QTransform &xform)
     {
         systemTransform = xform;
-        if ((hasSystemTransform = !xform.isIdentity()))
+        if ((hasSystemTransform = !xform.isIdentity()) || hasSystemViewport)
             transformSystemClip();
         systemStateChanged();
     }
diff --git a/src/gui/painting/qpaintengine_raster.cpp b/src/gui/painting/qpaintengine_raster.cpp
index d2b1ed7..295abc5 100644
--- a/src/gui/painting/qpaintengine_raster.cpp
+++ b/src/gui/painting/qpaintengine_raster.cpp
@@ -4409,6 +4409,9 @@ void QClipData::fixup()
  */
 void QClipData::setClipRect(const QRect &rect)
 {
+    if (rect == clipRect)
+        return;
+
 //    qDebug() << "setClipRect" << clipSpanHeight << count << allocated << rect;
     hasRectClip = true;
     clipRect = rect;
@@ -4418,6 +4421,11 @@ void QClipData::setClipRect(const QRect &rect)
     ymin = qMin(rect.y(), clipSpanHeight);
     ymax = qMin(rect.y() + rect.height(), clipSpanHeight);
 
+    if (m_spans) {
+        delete m_spans;
+        m_spans = 0;
+    }
+
 //    qDebug() << xmin << xmax << ymin << ymax;
 }
 
@@ -4441,6 +4449,12 @@ void QClipData::setClipRegion(const QRegion &region)
         ymin = rect.y();
         ymax = rect.y() + rect.height();
     }
+
+    if (m_spans) {
+        delete m_spans;
+        m_spans = 0;
+    }
+
 }
 
 /*!
diff --git a/src/gui/painting/qpainter.cpp b/src/gui/painting/qpainter.cpp
index caed293..d9c7937 100644
--- a/src/gui/painting/qpainter.cpp
+++ b/src/gui/painting/qpainter.cpp
@@ -5167,6 +5167,9 @@ void QPainter::drawPixmap(const QPointF &p, const QPixmap &pm)
 
     Q_D(QPainter);
 
+    if (!d->engine)
+        return;
+
 #ifndef QT_NO_DEBUG
     qt_painter_thread_test(d->device->devType(), "drawPixmap()");
 #endif
@@ -5176,9 +5179,6 @@ void QPainter::drawPixmap(const QPointF &p, const QPixmap &pm)
         return;
     }
 
-    if (!d->engine)
-        return;
-
     qreal x = p.x();
     qreal y = p.y();
 
diff --git a/src/gui/painting/qprintengine_win.cpp b/src/gui/painting/qprintengine_win.cpp
index c8674b7..7601beb 100644
--- a/src/gui/painting/qprintengine_win.cpp
+++ b/src/gui/painting/qprintengine_win.cpp
@@ -1532,7 +1532,7 @@ QVariant QWin32PrintEngine::property(PrintEnginePropertyKey key) const
             value = rect;
         } else {
             value = QTransform(1/d->stretch_x, 0, 0, 1/d->stretch_y, 0, 0)
-                    .mapRect(d->fullPage ? d->devPaperRect : d->devPageRect);
+                    .mapRect(d->fullPage ? d->devPhysicalPageRect : d->devPageRect);
         }
         break;
 
diff --git a/src/gui/painting/qprinter.cpp b/src/gui/painting/qprinter.cpp
index 4f3e71c..5161e32 100644
--- a/src/gui/painting/qprinter.cpp
+++ b/src/gui/painting/qprinter.cpp
@@ -834,11 +834,15 @@ void QPrinter::setPrinterName(const QString &name)
 #endif
 
     QList<QPrinterInfo> prnList = QPrinterInfo::availablePrinters();
-    d->validPrinter = false;
-    for (int i = 0; i < prnList.size(); ++i) {
-        if (prnList[i].printerName() == name) {
-            d->validPrinter = true;
-            break;
+    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;
+            }
         }
     }
 
diff --git a/src/gui/painting/qwindowsurface_d3d.cpp b/src/gui/painting/qwindowsurface_d3d.cpp
deleted file mode 100644
index 2b7f633..0000000
--- a/src/gui/painting/qwindowsurface_d3d.cpp
+++ /dev/null
@@ -1,169 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
-** Beta Release License Agreement.
-**
-** 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.0, included in the file LGPL_EXCEPTION.txt in this
-** package.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3.0 as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU General Public License version 3.0 requirements will be
-** met: http://www.gnu.org/copyleft/gpl.html.
-**
-** If you are unsure which license is appropriate for your use, please
-** contact the sales department at qt-sales@nokia.com.
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-//#define D3D_DEBUG_BACKBUFFER
-
-#include <QtGui/QPaintDevice>
-#include <QtGui/QWidget>
-#include "qdebug.h"
-
-#include "qpaintengine_d3d_p.h"
-#include "qwindowsurface_d3d_p.h"
-#include "private/qwidget_p.h"
-#include "private/qbackingstore_p.h"
-
-#include <d3d9.h>
-
-QT_BEGIN_NAMESPACE
-
-extern QDirect3DPaintEngine *qt_d3dEngine();
-
-struct QD3DWindowSurfacePrivate
-{
-    QSize m_lastSize;
-    QWidget *m_widget;
-};
-
-QD3DWindowSurface::QD3DWindowSurface(QWidget *window)
-    : QWindowSurface(window), d_ptr(new QD3DWindowSurfacePrivate)
-{
-    Q_ASSERT(window->isTopLevel());
-    d_ptr->m_widget = window;
-}
-
-
-QD3DWindowSurface::~QD3DWindowSurface()
-{
-    delete d_ptr;
-}
-
-QPaintDevice *QD3DWindowSurface::paintDevice()
-{
-    return d_ptr->m_widget;
-}
-
-
-void QD3DWindowSurface::flush(QWidget *widget, const QRegion &rgn, const QPoint &offset)
-{
-    QPoint wOffset = qt_qwidget_data(widget)->wrect.topLeft();
-
-    QDirect3DPaintEngine *engine = qt_d3dEngine();
-    LPDIRECT3DSWAPCHAIN9 swapchain = engine->swapChain(d_ptr->m_widget);
-
-    if (swapchain) {
-        QRect br = rgn.boundingRect();
-        QRect wbr = br.translated(-wOffset);
-
-        RECT destrect;
-        destrect.left   = wbr.x();
-        destrect.top    = wbr.y();
-        destrect.right  = destrect.left + wbr.width();
-        destrect.bottom = destrect.top  + wbr.height();
-
-        RECT srcrect;
-        srcrect.left    = br.x() + offset.x();
-        srcrect.top     = br.y() + offset.y();
-        srcrect.right   = wbr.width() + srcrect.left;
-        srcrect.bottom  = wbr.height() + srcrect.top;
-        int devwidth = d_ptr->m_lastSize.width();
-        int devheight = d_ptr->m_lastSize.height();
-
-        if (devwidth <= srcrect.right) {
-            int diff = srcrect.right - devwidth;
-            srcrect.right -= diff;
-            destrect.right -= diff;
-            if (srcrect.right <= srcrect.left)
-                return;
-        }
-        if (devheight <= srcrect.bottom) {
-            int diff = srcrect.bottom - devheight;
-            srcrect.bottom -= diff;
-            destrect.bottom -= diff;
-            if (srcrect.bottom <= srcrect.top)
-                return;
-        }
-
-        if (FAILED(swapchain->Present(&srcrect, &destrect, widget->winId(), 0, 0)))
-            qWarning("QDirect3DPaintEngine: failed to present back buffer.");
-
-#ifdef D3D_DEBUG_BACKBUFFER
-        qDebug() << widget << srcrect.left << srcrect.top << wbr.width() << wbr.height() << "Dest: " << destrect.left << destrect.top;
-        IDirect3DSurface9 *surface;
-        swapchain->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &surface);
-        QString filename("C:\\test.bmp");
-        D3DXSaveSurfaceToFile(filename.utf16(), D3DXIFF_BMP, surface, 0, 0);
-        surface->Release();
-#endif
-    }
-}
-
-void QD3DWindowSurface::setGeometry(const QRect &rect)
-{
-    if (rect.isEmpty())
-        qt_d3dEngine()->releaseSwapChain(d_ptr->m_widget);
-
-    d_ptr->m_lastSize = rect.size();
-    QWindowSurface::setGeometry(rect);
-}
-
-
-bool QD3DWindowSurface::scroll(const QRegion &area, int dx, int dy)
-{
-    QDirect3DPaintEngine *engine = qt_d3dEngine();
-    QRect rect = area.boundingRect();
-
-    RECT destrect;
-    destrect.left   = rect.x()+dx;
-    destrect.top    = rect.y()+dy;
-    destrect.right  = rect.width() + destrect.left;
-    destrect.bottom = rect.height() + destrect.top;
-
-    RECT srcrect;
-    srcrect.left    = rect.x();
-    srcrect.top     = rect.y();
-    srcrect.right   = rect.width() + srcrect.left;
-    srcrect.bottom  = rect.height() + srcrect.top;
-
-    engine->scroll(d_ptr->m_widget, srcrect, destrect);
-    return true;
-}
-
-QT_END_NAMESPACE
diff --git a/src/gui/painting/qwindowsurface_d3d_p.h b/src/gui/painting/qwindowsurface_d3d_p.h
deleted file mode 100644
index 9cdfe29..0000000
--- a/src/gui/painting/qwindowsurface_d3d_p.h
+++ /dev/null
@@ -1,84 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
-** Beta Release License Agreement.
-**
-** 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.0, included in the file LGPL_EXCEPTION.txt in this
-** package.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3.0 as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU General Public License version 3.0 requirements will be
-** met: http://www.gnu.org/copyleft/gpl.html.
-**
-** If you are unsure which license is appropriate for your use, please
-** contact the sales department at qt-sales@nokia.com.
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef QWINDOWSURFACE_D3D_P_H
-#define QWINDOWSURFACE_D3D_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"
-
-QT_BEGIN_NAMESPACE
-
-class QPaintDevice;
-class QPoint;
-class QRegion;
-class QWidget;
-struct QD3DWindowSurfacePrivate;
-
-class QD3DWindowSurface : public QWindowSurface
-{
-public:
-    QD3DWindowSurface(QWidget *widget);
-    ~QD3DWindowSurface();
-
-    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:
-    QD3DWindowSurfacePrivate *d_ptr;
-};
-
-QT_END_NAMESPACE
-
-#endif // QWINDOWSURFACE_D3D_P_H
diff --git a/src/gui/styles/gtksymbols.cpp b/src/gui/styles/gtksymbols.cpp
index acb8437..0842ec7 100644
--- a/src/gui/styles/gtksymbols.cpp
+++ b/src/gui/styles/gtksymbols.cpp
@@ -746,9 +746,9 @@ static void setupGtkFileChooser(GtkWidget* gtkFileChooser, QWidget *parent,
         foreach (const QString &rawfilter, filters) {
             GtkFileFilter *gtkFilter = QGtk::gtk_file_filter_new ();
             QString name = rawfilter.left(rawfilter.indexOf(QLatin1Char('(')));
-            QGtk::gtk_file_filter_set_name(gtkFilter, qPrintable(name));
-
             QStringList extensions = extract_filter(rawfilter);
+            QGtk::gtk_file_filter_set_name(gtkFilter, qPrintable(name.isEmpty() ? extensions.join(QLS(", ")) : name));
+
             foreach (const QString &fileExtension, extensions) {
                 QGtk::gtk_file_filter_add_pattern (gtkFilter, qPrintable(fileExtension));
             }
diff --git a/src/gui/styles/qcommonstyle.cpp b/src/gui/styles/qcommonstyle.cpp
index be80d37..f8ae1a6 100644
--- a/src/gui/styles/qcommonstyle.cpp
+++ b/src/gui/styles/qcommonstyle.cpp
@@ -2019,7 +2019,9 @@ void QCommonStyle::drawControl(ControlElement element, const QStyleOption *opt,
                                                           : QIcon::Disabled);
                 QPixmap tabIcon = tabV2.icon.pixmap(iconSize,
                                                     (tabV2.state & State_Enabled) ? QIcon::Normal
-                                                                                  : QIcon::Disabled);
+                                                                                  : QIcon::Disabled,
+                                                    (tabV2.state & State_Selected) ? QIcon::On
+                                                                                   : QIcon::Off);
 
                 int offset = 6;
                 int left = opt->rect.left();
diff --git a/src/gui/styles/qgtkstyle.cpp b/src/gui/styles/qgtkstyle.cpp
index b7fa575..ca71da2 100644
--- a/src/gui/styles/qgtkstyle.cpp
+++ b/src/gui/styles/qgtkstyle.cpp
@@ -951,14 +951,15 @@ void QGtkStyle::drawPrimitive(PrimitiveElement element,
                                "interior-focus", &interior_focus,
                                "focus-line-width", &focus_line_width, NULL);
 
+        // See https://bugzilla.mozilla.org/show_bug.cgi?id=405421 for info about this hack
+        g_object_set_data(G_OBJECT(gtkEntry), "transparent-bg-hint", GINT_TO_POINTER(TRUE));
+
         if (!interior_focus && option->state & State_HasFocus)
             rect.adjust(focus_line_width, focus_line_width, -focus_line_width, -focus_line_width);
-
         gtkPainter.paintShadow(gtkEntry, "entry", rect, option->state & State_Enabled ? 
                                GTK_STATE_NORMAL : GTK_STATE_INSENSITIVE, 
                                GTK_SHADOW_IN, gtkEntry->style,
                                option->state & State_HasFocus ? QLS("focus") : QString());
-
         if (!interior_focus && option->state & State_HasFocus)
             gtkPainter.paintShadow(gtkEntry, "entry", option->rect, option->state & State_Enabled ? 
                                    GTK_STATE_ACTIVE : GTK_STATE_INSENSITIVE,
diff --git a/src/gui/styles/qmacstyle_mac.mm b/src/gui/styles/qmacstyle_mac.mm
index 5d08c58..e32c5e2 100644
--- a/src/gui/styles/qmacstyle_mac.mm
+++ b/src/gui/styles/qmacstyle_mac.mm
@@ -2649,6 +2649,9 @@ int QMacStyle::pixelMetric(PixelMetric metric, const QStyleOption *opt, const QW
     case PM_MenuHMargin:
         ret = 0;
         break;
+    case PM_ToolBarFrameWidth:
+        ret = 0;
+        break;
     default:
         ret = QWindowsStyle::pixelMetric(metric, opt, widget);
         break;
@@ -3679,8 +3682,8 @@ void QMacStyle::drawControl(ControlElement ce, const QStyleOption *opt, QPainter
                         if (tb->toolButtonStyle != Qt::ToolButtonIconOnly) {
                             needText = true;
                             if (tb->toolButtonStyle == Qt::ToolButtonTextUnderIcon) {
-                                pr.setHeight(pixmap.size().height() + 6);
-                                cr.adjust(0, pr.bottom(), 0, -3);
+                                pr.setHeight(pixmap.size().height());
+                                cr.adjust(0, pr.bottom() + 1, 0, 1);
                                 alignment |= Qt::AlignCenter;
                             } else {
                                 pr.setWidth(pixmap.width() + 8);
@@ -3688,7 +3691,7 @@ void QMacStyle::drawControl(ControlElement ce, const QStyleOption *opt, QPainter
                                 alignment |= Qt::AlignLeft | Qt::AlignVCenter;
                             }
                         }
-                        if (down) {
+                        if (opt->state & State_Sunken) {
                             pr.translate(shiftX, shiftY);
                             pixmap = darkenPixmap(pixmap);
                         }
@@ -3718,7 +3721,8 @@ void QMacStyle::drawControl(ControlElement ce, const QStyleOption *opt, QPainter
                         }
                         drawItemText(p, cr, alignment, pal,
                                      tb->state & State_Enabled, tb->text, role);
-                        if (QSysInfo::MacintoshVersion < QSysInfo::MV_10_5 && down) {
+                        if (QSysInfo::MacintoshVersion < QSysInfo::MV_10_5 &&
+                            (tb->state & State_Sunken)) {
                             // Draw a "drop shadow" in earlier versions.
                             drawItemText(p, cr.adjusted(0, 1, 0, 1), alignment,
                                          tb->palette, tb->state & State_Enabled, tb->text);
@@ -4544,9 +4548,10 @@ void QMacStyle::drawControl(ControlElement ce, const QStyleOption *opt, QPainter
     case CE_ToolBar: {
         // For unified tool bars, draw nothing.
         if (w) {
-            if (QMainWindow * mainWindow = qobject_cast<QMainWindow *>(w->window()))
+            if (QMainWindow * mainWindow = qobject_cast<QMainWindow *>(w->window())) {
                 if (mainWindow->unifiedTitleAndToolBarOnMac())
                     break;
+                }
         }
 
         // draw background gradient
@@ -5270,6 +5275,7 @@ void QMacStyle::drawComplexControl(ComplexControl cc, const QStyleOptionComplex
         if (const QStyleOptionToolButton *tb
                 = qstyleoption_cast<const QStyleOptionToolButton *>(opt)) {
             if (widget && qobject_cast<QToolBar *>(widget->parentWidget())) {
+//                p->fillRect(tb->rect, QColor(155, 0, 155, 155));
                 if (tb->subControls & SC_ToolButtonMenu) {
                     QStyleOption arrowOpt(0);
                     arrowOpt.rect = subControlRect(cc, tb, SC_ToolButtonMenu, widget);
@@ -5282,16 +5288,22 @@ void QMacStyle::drawComplexControl(ComplexControl cc, const QStyleOptionComplex
                     drawToolbarButtonArrow(tb->rect, tds, cg);
                 }
                 if (tb->state & State_On) {
-                    QPen oldPen = p->pen();
-                    p->setPen(QColor(0, 0, 0, 0x3a));
-                    p->fillRect(tb->rect.adjusted(1, 1, -1, -1), QColor(0, 0, 0, 0x12));
-                    p->drawLine(tb->rect.left() + 1, tb->rect.top(),
-                                tb->rect.right() - 1, tb->rect.top());
-                    p->drawLine(tb->rect.left() + 1, tb->rect.bottom(),
-                                tb->rect.right() - 1, tb->rect.bottom());
-                    p->drawLine(tb->rect.topLeft(), tb->rect.bottomLeft());
-                    p->drawLine(tb->rect.topRight(), tb->rect.bottomRight());
-                    p->setPen(oldPen);
+                    if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_5) {
+                        static QPixmap pm(QLatin1String(":/trolltech/mac/style/images/leopard-unified-toolbar-on.png"));
+                        p->setRenderHint(QPainter::SmoothPixmapTransform);
+                        QStyleHelper::drawBorderPixmap(pm, p, tb->rect, 2, 2, 2, 2);
+                    } else {
+                        QPen oldPen = p->pen();
+                        p->setPen(QColor(0, 0, 0, 0x3a));
+                        p->fillRect(tb->rect.adjusted(1, 1, -1, -1), QColor(0, 0, 0, 0x12));
+                        p->drawLine(tb->rect.left() + 1, tb->rect.top(),
+                                    tb->rect.right() - 1, tb->rect.top());
+                        p->drawLine(tb->rect.left() + 1, tb->rect.bottom(),
+                                    tb->rect.right() - 1, tb->rect.bottom());
+                        p->drawLine(tb->rect.topLeft(), tb->rect.bottomLeft());
+                        p->drawLine(tb->rect.topRight(), tb->rect.bottomRight());
+                        p->setPen(oldPen);
+                    }
                 }
                 drawControl(CE_ToolButtonLabel, opt, p, widget);
             } else {
@@ -6009,6 +6021,14 @@ QSize QMacStyle::sizeFromContents(ContentsType ct, const QStyleOption *opt,
         }
         break;
     case CT_ToolButton:
+        if (widget && qobject_cast<const QToolBar *>(widget->parentWidget())) {
+            sz.rwidth() += 4;
+            if (sz.height() <= 32) {
+                // Workaround strange HIToolBar bug when getting constraints.
+                sz.rheight() += 1;
+            }
+            return sz;
+        }
         sz.rwidth() += 10;
         sz.rheight() += 10;
         return sz;
diff --git a/src/gui/styles/qstylehelper.cpp b/src/gui/styles/qstylehelper.cpp
index 3320970..69f8cd2 100644
--- a/src/gui/styles/qstylehelper.cpp
+++ b/src/gui/styles/qstylehelper.cpp
@@ -50,9 +50,10 @@
 
 QT_BEGIN_NAMESPACE
 
-const bool QStyleHelper::UsePixmapCache = true;
+namespace QStyleHelper {
+const bool UsePixmapCache = true;
 
-QString QStyleHelper::uniqueName(const QString &key, const QStyleOption *option, const QSize &size)
+QString uniqueName(const QString &key, const QStyleOption *option, const QSize &size)
 {
     QString tmp;
     const QStyleOptionComplex *complexOption = qstyleoption_cast<const QStyleOptionComplex *>(option);
@@ -74,7 +75,7 @@ QString QStyleHelper::uniqueName(const QString &key, const QStyleOption *option,
 
 #ifndef QT_NO_DIAL
 
-int QStyleHelper::calcBigLineSize(int radius)
+int calcBigLineSize(int radius)
 {
     int bigLineSize = radius / 6;
     if (bigLineSize < 4)
@@ -107,7 +108,7 @@ static QPointF calcRadialPos(const QStyleOptionSlider *dial, qreal offset)
     return pos;
 }
 
-qreal QStyleHelper::angle(const QPointF &p1, const QPointF &p2)
+qreal angle(const QPointF &p1, const QPointF &p2)
 {
     static const qreal rad_factor = 180 / Q_PI;
     qreal _angle = 0;
@@ -139,7 +140,7 @@ qreal QStyleHelper::angle(const QPointF &p1, const QPointF &p2)
     return _angle;
 }
 
-QPolygonF QStyleHelper::calcLines(const QStyleOptionSlider *dial)
+QPolygonF calcLines(const QStyleOptionSlider *dial)
 {
     QPolygonF poly;
     int width = dial->rect.width();
@@ -182,7 +183,7 @@ QPolygonF QStyleHelper::calcLines(const QStyleOptionSlider *dial)
 // This will draw a nice and shiny QDial for us. We don't want
 // all the shinyness in QWindowsStyle, hence we place it here
 
-void QStyleHelper::drawDial(const QStyleOptionSlider *option, QPainter *painter)
+void drawDial(const QStyleOptionSlider *option, QPainter *painter)
 {
     QPalette pal = option->palette;
     QColor buttonColor = pal.button().color();
@@ -292,4 +293,61 @@ void QStyleHelper::drawDial(const QStyleOptionSlider *option, QPainter *painter)
 }
 #endif //QT_NO_DIAL
 
+void drawBorderPixmap(const QPixmap &pixmap, QPainter *painter, const QRect &rect,
+                     int left, int top, int right,
+                     int bottom)
+{
+    QSize size = pixmap.size();
+    //painter->setRenderHint(QPainter::SmoothPixmapTransform);
+
+    //top
+    if (top > 0) {
+        painter->drawPixmap(QRect(rect.left() + left, rect.top(), rect.width() -right - left, top), pixmap,
+                            QRect(left, 0, size.width() -right - left, top));
+
+        //top-left
+        if(left > 0)
+            painter->drawPixmap(QRect(rect.left(), rect.top(), left, top), pixmap,
+                                QRect(0, 0, left, top));
+
+        //top-right
+        if (right > 0)
+            painter->drawPixmap(QRect(rect.left() + rect.width() - right, rect.top(), right, top), pixmap,
+                                QRect(size.width() - right, 0, right, top));
+    }
+
+    //left
+    if (left > 0)
+        painter->drawPixmap(QRect(rect.left(), rect.top()+top, left, rect.height() - top - bottom), pixmap,
+                            QRect(0, top, left, size.height() - bottom - top));
+
+    //center
+    painter->drawPixmap(QRect(rect.left() + left, rect.top()+top, rect.width() -right - left,
+                             rect.height() - bottom - top), pixmap,
+                       QRect(left, top, size.width() -right -left,
+                             size.height() - bottom - top));
+    //right
+    if (right > 0)
+        painter->drawPixmap(QRect(rect.left() +rect.width() - right, rect.top()+top, right, rect.height() - top - bottom), pixmap,
+                            QRect(size.width() - right, top, right, size.height() - bottom - top));
+
+    //bottom
+    if (bottom > 0) {
+        painter->drawPixmap(QRect(rect.left() +left, rect.top() + rect.height() - bottom,
+                                 rect.width() - right - left, bottom), pixmap,
+                            QRect(left, size.height() - bottom,
+                                 size.width() - right - left, bottom));
+        //bottom-left
+        if (left > 0)
+            painter->drawPixmap(QRect(rect.left(), rect.top() + rect.height() - bottom, left, bottom), pixmap,
+                                QRect(0, size.height() - bottom, left, bottom));
+
+        //bottom-right
+        if (right > 0)
+            painter->drawPixmap(QRect(rect.left() + rect.width() - right, rect.top() + rect.height() - bottom, right, bottom), pixmap,
+                                QRect(size.width() - right, size.height() - bottom, right, bottom));
+
+    }
+}
+}
 QT_END_NAMESPACE
diff --git a/src/gui/styles/qstylehelper_p.h b/src/gui/styles/qstylehelper_p.h
index d9b2e28..711bd2d 100644
--- a/src/gui/styles/qstylehelper_p.h
+++ b/src/gui/styles/qstylehelper_p.h
@@ -19,6 +19,7 @@
 QT_BEGIN_NAMESPACE
 
 class QPainter;
+class QPixmap;
 class QStyleOptionSlider;
 class QStyleOption;
 
@@ -32,6 +33,9 @@ namespace QStyleHelper
     int calcBigLineSize(int radius);
     void drawDial(const QStyleOptionSlider *dial, QPainter *painter);
 #endif //QT_NO_DIAL
+    void drawBorderPixmap(const QPixmap &pixmap, QPainter *painter, const QRect &rect,
+                     int left = 0, int top = 0, int right = 0,
+                     int bottom = 0);
 }
 
 QT_END_NAMESPACE
diff --git a/src/gui/styles/qstylesheetstyle.cpp b/src/gui/styles/qstylesheetstyle.cpp
index 49ac57a..f480008 100644
--- a/src/gui/styles/qstylesheetstyle.cpp
+++ b/src/gui/styles/qstylesheetstyle.cpp
@@ -2876,12 +2876,6 @@ void QStyleSheetStyle::polish(QWidget *w)
     QRenderRule rule = renderRule(w, PseudoElement_None, PseudoClass_Any);
     if (rule.hasDrawable() || rule.hasBox()) {
         if (w->metaObject() == &QWidget::staticMetaObject
-#ifndef QT_NO_MENUBAR
-              || qobject_cast<QMenuBar *>(w)
-#endif
-#ifndef QT_NO_MENU
-              || qobject_cast<QMenu *>(w)
-#endif
 #ifndef QT_NO_ITEMVIEWS
               || qobject_cast<QHeaderView *>(w)
 #endif
@@ -4164,9 +4158,8 @@ void QStyleSheetStyle::drawControl(ControlElement ce, const QStyleOption *opt, Q
                 rule.configurePalette(&frmOpt.palette, QPalette::Text, QPalette::Base);
                 frmOpt.rect = rule.borderRect(frmOpt.rect);
                 baseStyle()->drawControl(ce, &frmOpt, p, w);
-            } else {
-                rule.drawBorder(p, rule.borderRect(opt->rect));
             }
+            // else, borders are already drawn in PE_Widget
         }
         return;
 
@@ -4220,12 +4213,6 @@ void QStyleSheetStyle::drawPrimitive(PrimitiveElement pe, const QStyleOption *op
     QRect rect = opt->rect;
 
     switch (pe) {
-    case PE_PanelStatusBar:
-        if (rule.hasDrawable()) {
-            rule.drawRule(p, opt->rect);
-            return;
-        }
-        break;
 
     case PE_FrameStatusBar: {
         QRenderRule subRule = renderRule(w->parentWidget(), opt, PseudoElement_Item);
@@ -4337,36 +4324,34 @@ void QStyleSheetStyle::drawPrimitive(PrimitiveElement pe, const QStyleOption *op
         return;
 
     case PE_Widget:
-        if (!rule.hasBackground()) {
+        if (!rule.hasDrawable()) {
             QWidget *container = containerWidget(w);
             if (autoFillDisabledWidgets->contains(container)
-                && (container == w || !renderRule(container, opt).hasBackground())) {
+                && (container == w || !renderRule(container, opt).hasDrawable())) {
                 //we do not have a background, but we disabled the autofillbackground anyway. so fill the background now.
                 // (this may happen if we have rules like :focus)
                 p->fillRect(opt->rect, opt->palette.brush(w->backgroundRole()));
             }
             break;
         }
-
 #ifndef QT_NO_SCROLLAREA
         if (const QAbstractScrollArea *sa = qobject_cast<const QAbstractScrollArea *>(w)) {
             const QAbstractScrollAreaPrivate *sap = sa->d_func();
             rule.drawBackground(p, opt->rect, sap->contentsOffset());
-        } else
-#endif
-        {
-            rule.drawBackground(p, opt->rect);
+            if (rule.hasBorder())
+                rule.drawBorder(p, rule.borderRect(opt->rect));
+            break;
         }
-
-        return;
-
-    case PE_FrameMenu:
+#endif
+    //fall tghought
+    case PE_PanelMenu:
     case PE_PanelMenuBar:
-        if (!rule.hasNativeBorder()) {
-            rule.drawBorder(p, rule.borderRect(opt->rect));
+    case PE_PanelStatusBar:
+        if(rule.hasDrawable()) {
+            rule.drawRule(p, opt->rect);
             return;
         }
-        break;
+    break;
 
     case PE_IndicatorToolBarSeparator:
     case PE_IndicatorToolBarHandle: {
@@ -5887,13 +5872,11 @@ void QStyleSheetStyle::clearWidgetFont(QWidget* w) const
     w->setProperty("_q_styleSheetWidgetFont", QVariant(QVariant::Invalid));
 }
 
-// Returns the palette that should be used when the particular widget is focused.
-// This needs to be called by some widgets that do drawing themselves instead
-// of through the style.
-// ### This should be removed ideally by Qt 4.5, and at least by Qt 5, and fixed
-// for good by letting the style draw everything.
+// Polish palette that should be used for a particular widget, with particular states
+// (eg. :focus, :hover, ...)
+// this is called by widgets that paint themself in their paint event
 // Returns true if there is a new palette in pal.
-bool QStyleSheetStyle::focusPalette(const QWidget* w, const QStyleOption* opt, QPalette* pal)
+bool QStyleSheetStyle::styleSheetPalette(const QWidget* w, const QStyleOption* opt, QPalette* pal)
 {
     if (!w || !opt || !pal)
         return false;
diff --git a/src/gui/styles/qstylesheetstyle_p.h b/src/gui/styles/qstylesheetstyle_p.h
index 1f61445..e057274 100644
--- a/src/gui/styles/qstylesheetstyle_p.h
+++ b/src/gui/styles/qstylesheetstyle_p.h
@@ -131,7 +131,7 @@ public:
     void saveWidgetFont(QWidget* w, const QFont& font) const;
     void clearWidgetFont(QWidget* w) const;
 
-    bool focusPalette(const QWidget* w, const QStyleOption* opt, QPalette* pal);
+    bool styleSheetPalette(const QWidget* w, const QStyleOption* opt, QPalette* pal);
 
 protected Q_SLOTS:
     QIcon standardIconImplementation(StandardPixmap standardIcon, const QStyleOption *opt = 0,
diff --git a/src/gui/widgets/qlabel.cpp b/src/gui/widgets/qlabel.cpp
index 63c1315..016b7c1 100644
--- a/src/gui/widgets/qlabel.cpp
+++ b/src/gui/widgets/qlabel.cpp
@@ -971,6 +971,13 @@ void QLabel::paintEvent(QPaintEvent *)
 #endif
     if (d->isTextLabel) {
         QRectF lr = d->layoutRect();
+        QStyleOption opt;
+        opt.initFrom(this);
+#ifndef QT_NO_STYLE_STYLESHEET
+        if (QStyleSheetStyle* cssStyle = qobject_cast<QStyleSheetStyle*>(style)) {
+            cssStyle->styleSheetPalette(this, &opt, &opt.palette);
+        }
+#endif
         if (d->control) {
 #ifndef QT_NO_SHORTCUT
             const bool underline = (bool)style->styleHint(QStyle::SH_UnderlineShortcut, 0, this, 0);
@@ -984,11 +991,9 @@ void QLabel::paintEvent(QPaintEvent *)
             d->ensureTextLayouted();
 
             QAbstractTextDocumentLayout::PaintContext context;
-            QStyleOption opt(0);
-            opt.init(this);
 
             if (!isEnabled() && style->styleHint(QStyle::SH_EtchDisabledText, &opt, this)) {
-                context.palette = palette();
+                context.palette = opt.palette;
                 context.palette.setColor(QPalette::Text, context.palette.light().color());
                 painter.save();
                 painter.translate(lr.x() + 1, lr.y() + 1);
@@ -999,12 +1004,7 @@ void QLabel::paintEvent(QPaintEvent *)
             }
 
             // Adjust the palette
-            context.palette = palette();
-#ifndef QT_NO_STYLE_STYLESHEET
-            if (QStyleSheetStyle* cssStyle = qobject_cast<QStyleSheetStyle*>(style)) {
-                cssStyle->focusPalette(this, &opt, &context.palette);
-            }
-#endif
+            context.palette = opt.palette;
 
             if (foregroundRole() != QPalette::Text && isEnabled())
                 context.palette.setColor(QPalette::Text, context.palette.color(foregroundRole()));
@@ -1019,12 +1019,10 @@ void QLabel::paintEvent(QPaintEvent *)
             int flags = align;
             if (d->hasShortcut) {
                 flags |= Qt::TextShowMnemonic;
-                QStyleOption opt;
-                opt.initFrom(this);
                 if (!style->styleHint(QStyle::SH_UnderlineShortcut, &opt, this))
                     flags |= Qt::TextHideMnemonic;
             }
-            style->drawItemText(&painter, lr.toRect(), flags, palette(), isEnabled(), d->text, foregroundRole());
+            style->drawItemText(&painter, lr.toRect(), flags, opt.palette, isEnabled(), d->text, foregroundRole());
         }
     } else
 #ifndef QT_NO_PICTURE
diff --git a/src/gui/widgets/qlineedit.cpp b/src/gui/widgets/qlineedit.cpp
index e243ad0..d16ed10 100644
--- a/src/gui/widgets/qlineedit.cpp
+++ b/src/gui/widgets/qlineedit.cpp
@@ -2518,7 +2518,7 @@ void QLineEdit::paintEvent(QPaintEvent *)
     // draw text, selections and cursors
 #ifndef QT_NO_STYLE_STYLESHEET
     if (QStyleSheetStyle* cssStyle = qobject_cast<QStyleSheetStyle*>(style())) {
-        cssStyle->focusPalette(this, &panel, &pal);
+        cssStyle->styleSheetPalette(this, &panel, &pal);
     }
 #endif
     p.setPen(pal.text().color());
diff --git a/src/gui/widgets/qmainwindowlayout_mac.mm b/src/gui/widgets/qmainwindowlayout_mac.mm
index c807afb..53e1ad5 100644
--- a/src/gui/widgets/qmainwindowlayout_mac.mm
+++ b/src/gui/widgets/qmainwindowlayout_mac.mm
@@ -502,11 +502,11 @@ void QMainWindowLayout::fixSizeInUnifiedToolbar(QToolBar *tb) const
         QMacCocoaAutoReleasePool pool;
         QWidgetItem layoutItem(tb);
         QSize size = layoutItem.maximumSize();
-        NSSize nssize = NSMakeSize(size.width(), size.height());
+        NSSize nssize = NSMakeSize(size.width(), size.height() - 2);
         [item setMaxSize:nssize];
         size = layoutItem.minimumSize();
         nssize.width = size.width();
-        nssize.height = size.height();
+        nssize.height = size.height() - 2;
         [item setMinSize:nssize];
     }
 }
diff --git a/src/gui/widgets/qtabbar.cpp b/src/gui/widgets/qtabbar.cpp
index b562b1f..49de8c1 100644
--- a/src/gui/widgets/qtabbar.cpp
+++ b/src/gui/widgets/qtabbar.cpp
@@ -1941,8 +1941,10 @@ void QTabBar::changeEvent(QEvent *event)
     if (event->type() == QEvent::StyleChange) {
         d->elideMode = Qt::TextElideMode(style()->styleHint(QStyle::SH_TabBar_ElideMode, 0, this));
         d->useScrollButtons = !style()->styleHint(QStyle::SH_TabBar_PreferNoArrows, 0, this);
+        d->refresh();
+    } else if (event->type() == QEvent::FontChange) {
+        d->refresh();
     }
-    d->refresh();
     QWidget::changeEvent(event);
 }
 
diff --git a/src/network/access/qhttpnetworkconnection.cpp b/src/network/access/qhttpnetworkconnection.cpp
index 980c0e0..5940fba 100644
--- a/src/network/access/qhttpnetworkconnection.cpp
+++ b/src/network/access/qhttpnetworkconnection.cpp
@@ -265,6 +265,11 @@ bool QHttpNetworkConnectionPrivate::ensureConnection(QAbstractSocket *socket)
     if (socket->state() != QAbstractSocket::ConnectedState) {
         // connect to the host if not already connected.
         int index = indexOf(socket);
+        // resend this request after we receive the disconnected signal
+        if (socket->state() == QAbstractSocket::ClosingState) {
+            channels[index].resendCurrent = true;
+            return false;
+        }
         channels[index].state = ConnectingState;
         channels[index].pendingEncrypt = encrypt;
 
@@ -982,6 +987,9 @@ void QHttpNetworkConnectionPrivate::_q_disconnected()
         channels[i].state = ReadingState;
         if (channels[i].reply)
             receiveReply(socket, channels[i].reply);
+    } else if (channels[i].state == IdleState && channels[i].resendCurrent) {
+        // re-sending request because the socket was in ClosingState
+        QMetaObject::invokeMethod(q, "_q_startNextRequest", Qt::QueuedConnection);
     }
     channels[i].state = IdleState;
 }
diff --git a/src/network/socket/qlocalserver_unix.cpp b/src/network/socket/qlocalserver_unix.cpp
index 065a9de..e7d2252 100644
--- a/src/network/socket/qlocalserver_unix.cpp
+++ b/src/network/socket/qlocalserver_unix.cpp
@@ -148,9 +148,11 @@ void QLocalServerPrivate::closeServer()
         QT_CLOSE(listenSocket);
     listenSocket = -1;
 
-    if (socketNotifier)
+    if (socketNotifier) {
+        socketNotifier->setEnabled(false); // Otherwise, closed socket is checked before deleter runs
         socketNotifier->deleteLater();
-    socketNotifier = 0;
+        socketNotifier = 0;
+    }
 
     if (!fullServerName.isEmpty())
         QFile::remove(fullServerName);
diff --git a/src/network/socket/qlocalsocket_win.cpp b/src/network/socket/qlocalsocket_win.cpp
index e759d0b..39c9284 100644
--- a/src/network/socket/qlocalsocket_win.cpp
+++ b/src/network/socket/qlocalsocket_win.cpp
@@ -298,7 +298,7 @@ qint64 QLocalSocketPrivate::bytesAvailable()
     if (PeekNamedPipe(handle, NULL, 0, NULL, &bytes, NULL)) {
         return bytes;
     } else {
-        if (ERROR_BROKEN_PIPE == GetLastError() && !pipeClosed) {
+        if (!pipeClosed) {
             pipeClosed = true;
             QTimer::singleShot(0, q, SLOT(_q_pipeClosed()));
         }
diff --git a/src/opengl/qgl.cpp b/src/opengl/qgl.cpp
index b8fa133..18d9125 100644
--- a/src/opengl/qgl.cpp
+++ b/src/opengl/qgl.cpp
@@ -2452,6 +2452,10 @@ bool QGLContext::create(const QGLContext* shareContext)
         return false;
     reset();
     d->valid = chooseContext(shareContext);
+    if (d->valid && d->paintDevice->devType() == QInternal::Widget) {
+        QWidgetPrivate *wd = qt_widget_private(static_cast<QWidget *>(d->paintDevice));
+        wd->usesDoubleBufferedGLContext = d->glFormat.doubleBuffer();
+    }
     if (d->sharing)  // ok, we managed to share
         qgl_share_reg()->addShare(this, shareContext);
     return d->valid;
diff --git a/src/opengl/qwindowsurface_gl.cpp b/src/opengl/qwindowsurface_gl.cpp
index 837ccf2..b41adf9 100644
--- a/src/opengl/qwindowsurface_gl.cpp
+++ b/src/opengl/qwindowsurface_gl.cpp
@@ -86,7 +86,7 @@ QT_BEGIN_NAMESPACE
 // QGLGraphicsSystem
 //
 #ifdef Q_WS_WIN
-Q_GUI_EXPORT bool qt_win_owndc_required;
+extern Q_GUI_EXPORT bool qt_win_owndc_required;
 #endif
 QGLGraphicsSystem::QGLGraphicsSystem()
     : QGraphicsSystem()
diff --git a/src/plugins/gfxdrivers/directfb/directfb.pro b/src/plugins/gfxdrivers/directfb/directfb.pro
index 89a289c..1ee9030 100644
--- a/src/plugins/gfxdrivers/directfb/directfb.pro
+++ b/src/plugins/gfxdrivers/directfb/directfb.pro
@@ -3,7 +3,7 @@ include(../../qpluginbase.pri)
 
 QTDIR_build:DESTDIR = $$QT_BUILD_TREE/plugins/gfxdrivers
 
-# These defines might be necessary if your DirectFB driver doesn't 
+# These defines might be necessary if your DirectFB driver doesn't
 # support all of the DirectFB API.
 #
 #DEFINES += QT_NO_DIRECTFB_WM
@@ -14,6 +14,8 @@ QTDIR_build:DESTDIR = $$QT_BUILD_TREE/plugins/gfxdrivers
 #DEFINES += QT_NO_DIRECTFB_KEYBOARD
 #DEFINES += QT_DIRECTFB_TIMING
 #DEFINES += QT_NO_DIRECTFB_OPAQUE_DETECTION
+#DEFINES += QT_DIRECTFB_WARN_ON_RASTERFALLBACKS
+#DEFINES += QT_DIRECTFB_DISABLE_RASTERFALLBACKS
 
 target.path = $$[QT_INSTALL_PLUGINS]/gfxdrivers
 INSTALLS += target
diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbkeyboard.cpp b/src/plugins/gfxdrivers/directfb/qdirectfbkeyboard.cpp
index cd19f69..368b9f9 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbkeyboard.cpp
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbkeyboard.cpp
@@ -173,6 +173,22 @@ void QDirectFBKeyboardHandlerPrivate::readKeyboardData()
 
         Qt::KeyboardModifiers modifiers = Qt::NoModifier;
 
+        // Not implemented:
+        // if (input.modifiers & DIMM_SUPER)
+        // if (input.modifiers & DIMM_HYPER)
+
+        if (!(input.flags & DIEF_KEYSYMBOL) ||
+            !(input.flags & DIEF_KEYID) ||
+            !(input.type & (DIET_KEYPRESS|DIET_KEYRELEASE)))
+        {
+            static bool first = true;
+            if (first) {
+                qWarning("QDirectFBKeyboardHandler - Getting unexpected non-keyboard related events");
+                first = false;
+            }
+            break;
+        }
+
         if (input.flags & DIEF_MODIFIERS) {
             if (input.modifiers & DIMM_SHIFT)
                 modifiers |= Qt::ShiftModifier;
@@ -185,31 +201,15 @@ void QDirectFBKeyboardHandlerPrivate::readKeyboardData()
             if (input.modifiers & DIMM_META)
                 modifiers |= Qt::MetaModifier;
         }
-        // Not implemented:
-        // if (input.modifiers & DIMM_SUPER)
-        // if (input.modifiers & DIMM_HYPER)
 
-        if ( !(input.flags & DIEF_KEYSYMBOL) ||
-             !(input.flags & DIEF_KEYID) ||
-             !(input.type & (DIET_KEYPRESS | DIET_KEYRELEASE)) )
-        {
-            static int warningCount = 0;
-            if (!warningCount) {
-                qWarning("QDirectFBKeyboardHandler - Getting unexpected non-keyboard related events");
-                warningCount = 100;
-            }
-            else
-                warningCount--;
-            break;
-        }
 
-        bool press = input.type & DIET_KEYPRESS;
+        const bool press = input.type & DIET_KEYPRESS;
         DFBInputDeviceKeySymbol symbol = input.key_symbol;
         int unicode = -1;
         int keycode = 0;
 
         keycode = keymap()->value(symbol);
-        if (keycode == 0 && DFB_KEY_TYPE(symbol) == DIKT_UNICODE)
+        if (DFB_KEY_TYPE(symbol) == DIKT_UNICODE)
             unicode = symbol;
 
         if (unicode != -1 || keycode != 0) {
@@ -314,6 +314,100 @@ KeyMap::KeyMap()
     insert(DIKS_DEAD_SEMIVOICED_SOUND , Qt::Key_Dead_Semivoiced_Sound);
     insert(DIKS_DEAD_TILDE            , Qt::Key_Dead_Tilde);
     insert(DIKS_DEAD_VOICED_SOUND     , Qt::Key_Dead_Voiced_Sound);
+    insert(DIKS_SPACE                 , Qt::Key_Space);
+    insert(DIKS_EXCLAMATION_MARK      , Qt::Key_Exclam);
+    insert(DIKS_QUOTATION             , Qt::Key_QuoteDbl);
+    insert(DIKS_NUMBER_SIGN           , Qt::Key_NumberSign);
+    insert(DIKS_DOLLAR_SIGN           , Qt::Key_Dollar);
+    insert(DIKS_PERCENT_SIGN          , Qt::Key_Percent);
+    insert(DIKS_AMPERSAND             , Qt::Key_Ampersand);
+    insert(DIKS_APOSTROPHE            , Qt::Key_Apostrophe);
+    insert(DIKS_PARENTHESIS_LEFT      , Qt::Key_ParenLeft);
+    insert(DIKS_PARENTHESIS_RIGHT     , Qt::Key_ParenRight);
+    insert(DIKS_ASTERISK              , Qt::Key_Asterisk);
+    insert(DIKS_PLUS_SIGN             , Qt::Key_Plus);
+    insert(DIKS_COMMA                 , Qt::Key_Comma);
+    insert(DIKS_MINUS_SIGN            , Qt::Key_Minus);
+    insert(DIKS_PERIOD                , Qt::Key_Period);
+    insert(DIKS_SLASH                 , Qt::Key_Slash);
+    insert(DIKS_0                     , Qt::Key_0);
+    insert(DIKS_1                     , Qt::Key_1);
+    insert(DIKS_2                     , Qt::Key_2);
+    insert(DIKS_3                     , Qt::Key_3);
+    insert(DIKS_4                     , Qt::Key_4);
+    insert(DIKS_5                     , Qt::Key_5);
+    insert(DIKS_6                     , Qt::Key_6);
+    insert(DIKS_7                     , Qt::Key_7);
+    insert(DIKS_8                     , Qt::Key_8);
+    insert(DIKS_9                     , Qt::Key_9);
+    insert(DIKS_COLON                 , Qt::Key_Colon);
+    insert(DIKS_SEMICOLON             , Qt::Key_Semicolon);
+    insert(DIKS_LESS_THAN_SIGN        , Qt::Key_Less);
+    insert(DIKS_EQUALS_SIGN           , Qt::Key_Equal);
+    insert(DIKS_GREATER_THAN_SIGN     , Qt::Key_Greater);
+    insert(DIKS_QUESTION_MARK         , Qt::Key_Question);
+    insert(DIKS_AT                    , Qt::Key_At);
+    insert(DIKS_CAPITAL_A             , Qt::Key_A);
+    insert(DIKS_CAPITAL_B             , Qt::Key_B);
+    insert(DIKS_CAPITAL_C             , Qt::Key_C);
+    insert(DIKS_CAPITAL_D             , Qt::Key_D);
+    insert(DIKS_CAPITAL_E             , Qt::Key_E);
+    insert(DIKS_CAPITAL_F             , Qt::Key_F);
+    insert(DIKS_CAPITAL_G             , Qt::Key_G);
+    insert(DIKS_CAPITAL_H             , Qt::Key_H);
+    insert(DIKS_CAPITAL_I             , Qt::Key_I);
+    insert(DIKS_CAPITAL_J             , Qt::Key_J);
+    insert(DIKS_CAPITAL_K             , Qt::Key_K);
+    insert(DIKS_CAPITAL_L             , Qt::Key_L);
+    insert(DIKS_CAPITAL_M             , Qt::Key_M);
+    insert(DIKS_CAPITAL_N             , Qt::Key_N);
+    insert(DIKS_CAPITAL_O             , Qt::Key_O);
+    insert(DIKS_CAPITAL_P             , Qt::Key_P);
+    insert(DIKS_CAPITAL_Q             , Qt::Key_Q);
+    insert(DIKS_CAPITAL_R             , Qt::Key_R);
+    insert(DIKS_CAPITAL_S             , Qt::Key_S);
+    insert(DIKS_CAPITAL_T             , Qt::Key_T);
+    insert(DIKS_CAPITAL_U             , Qt::Key_U);
+    insert(DIKS_CAPITAL_V             , Qt::Key_V);
+    insert(DIKS_CAPITAL_W             , Qt::Key_W);
+    insert(DIKS_CAPITAL_X             , Qt::Key_X);
+    insert(DIKS_CAPITAL_Y             , Qt::Key_Y);
+    insert(DIKS_CAPITAL_Z             , Qt::Key_Z);
+    insert(DIKS_SQUARE_BRACKET_LEFT   , Qt::Key_BracketLeft);
+    insert(DIKS_BACKSLASH             , Qt::Key_Backslash);
+    insert(DIKS_SQUARE_BRACKET_RIGHT  , Qt::Key_BracketRight);
+    insert(DIKS_CIRCUMFLEX_ACCENT     , Qt::Key_AsciiCircum);
+    insert(DIKS_UNDERSCORE            , Qt::Key_Underscore);
+    insert(DIKS_SMALL_A               , Qt::Key_A);
+    insert(DIKS_SMALL_B               , Qt::Key_B);
+    insert(DIKS_SMALL_C               , Qt::Key_C);
+    insert(DIKS_SMALL_D               , Qt::Key_D);
+    insert(DIKS_SMALL_E               , Qt::Key_E);
+    insert(DIKS_SMALL_F               , Qt::Key_F);
+    insert(DIKS_SMALL_G               , Qt::Key_G);
+    insert(DIKS_SMALL_H               , Qt::Key_H);
+    insert(DIKS_SMALL_I               , Qt::Key_I);
+    insert(DIKS_SMALL_J               , Qt::Key_J);
+    insert(DIKS_SMALL_K               , Qt::Key_K);
+    insert(DIKS_SMALL_L               , Qt::Key_L);
+    insert(DIKS_SMALL_M               , Qt::Key_M);
+    insert(DIKS_SMALL_N               , Qt::Key_N);
+    insert(DIKS_SMALL_O               , Qt::Key_O);
+    insert(DIKS_SMALL_P               , Qt::Key_P);
+    insert(DIKS_SMALL_Q               , Qt::Key_Q);
+    insert(DIKS_SMALL_R               , Qt::Key_R);
+    insert(DIKS_SMALL_S               , Qt::Key_S);
+    insert(DIKS_SMALL_T               , Qt::Key_T);
+    insert(DIKS_SMALL_U               , Qt::Key_U);
+    insert(DIKS_SMALL_V               , Qt::Key_V);
+    insert(DIKS_SMALL_W               , Qt::Key_W);
+    insert(DIKS_SMALL_X               , Qt::Key_X);
+    insert(DIKS_SMALL_Y               , Qt::Key_Y);
+    insert(DIKS_SMALL_Z               , Qt::Key_Z);
+    insert(DIKS_CURLY_BRACKET_LEFT    , Qt::Key_BraceLeft);
+    insert(DIKS_VERTICAL_BAR          , Qt::Key_Bar);
+    insert(DIKS_CURLY_BRACKET_RIGHT   , Qt::Key_BraceRight);
+    insert(DIKS_TILDE                 , Qt::Key_AsciiTilde);
 }
 
 #include "qdirectfbkeyboard.moc"
diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbpaintdevice.cpp b/src/plugins/gfxdrivers/directfb/qdirectfbpaintdevice.cpp
index 2a2ef5c..924090c 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbpaintdevice.cpp
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbpaintdevice.cpp
@@ -56,23 +56,16 @@ IDirectFBSurface *QDirectFBPaintDevice::directFBSurface() const
 }
 
 
-// Locks the dfb surface and creates a QImage (lockedImage) from the pointer
-void QDirectFBPaintDevice::lockDirectFB() {
-
+void QDirectFBPaintDevice::lockDirectFB()
+{
     if (lockedImage)
         return; // Already locked
 
-    void *mem;
-    int w, h;
-    DFBResult result = dfbSurface->Lock(dfbSurface, DSLF_WRITE, &mem, &bpl);
-    if (result != DFB_OK || !mem) {
-        DirectFBError("QDirectFBPixmapData::buffer()", result);
-        return;
+    if (uchar *mem = QDirectFBScreen::lockSurface(dfbSurface, DSLF_WRITE, &bpl)) {
+        const QSize s = size();
+        lockedImage = new QImage(mem, s.width(), s.height(), bpl,
+                                 QDirectFBScreen::getImageFormat(dfbSurface));
     }
-
-    dfbSurface->GetSize(dfbSurface, &w, &h);
-    lockedImage = new QImage(static_cast<uchar*>(mem), w, h, bpl,
-                             QDirectFBScreen::getImageFormat(dfbSurface));
 }
 
 
diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.cpp b/src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.cpp
index d9346fd..ba5d71a 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.cpp
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.cpp
@@ -54,6 +54,70 @@
 #include <private/qpixmapdata_p.h>
 #include <private/qpixmap_raster_p.h>
 
+#ifdef QT_DIRECTFB_WARN_ON_RASTERFALLBACKS
+template <typename T> inline const T *ptr(const T &t) { return &t; }
+template <> inline const bool* ptr<bool>(const bool &) { return 0; }
+template <typename device, typename T1, typename T2, typename T3>
+static void rasterFallbackWarn(const char *msg, const char *func, const device *dev,
+                               bool matrixScale, bool matrixRotShear, bool simplePen,
+                               bool dfbHandledClip, bool forceRasterPrimitives,
+                               const char *nameOne, const T1 &one,
+                               const char *nameTwo, const T2 &two,
+                               const char *nameThree, const T3 &three)
+{
+    QString out;
+    QDebug dbg(&out);
+    dbg << msg << (QByteArray(func) + "()")  << "painting on";
+    if (dev->devType() == QInternal::Widget) {
+        dbg << static_cast<const QWidget*>(dev);
+    } else {
+        dbg << dev << "of type" << dev->devType();
+    }
+
+    dbg << "matrixScale" << matrixScale
+        << "matrixRotShear" << matrixRotShear
+        << "simplePen" << simplePen
+        << "dfbHandledClip" << dfbHandledClip
+        << "forceRasterPrimitives" << forceRasterPrimitives;
+
+    const T1 *t1 = ptr(one);
+    const T2 *t2 = ptr(two);
+    const T3 *t3 = ptr(three);
+
+    if (t1) {
+        dbg << nameOne << *t1;
+        if (t2) {
+            dbg << nameTwo << *t2;
+            if (t3) {
+                dbg << nameThree << *t3;
+            }
+        }
+    }
+    qWarning("%s", qPrintable(out));
+}
+#endif
+
+#if defined QT_DIRECTFB_WARN_ON_RASTERFALLBACKS && defined QT_DIRECTFB_DISABLE_RASTERFALLBACKS
+#define RASTERFALLBACK(one, two, three) rasterFallbackWarn("Disabled raster engine operation", \
+                                                           __FUNCTION__, state()->painter->device(), \
+                                                           d_func()->matrixScale, d_func()->matrixRotShear, \
+                                                           d_func()->simplePen, d_func()->dfbCanHandleClip(), \
+                                                           d_func()->forceRasterPrimitives, \
+                                                           #one, one, #two, two, #three, three); \
+    return;
+#elif defined QT_DIRECTFB_DISABLE_RASTERFALLBACKS
+#define RASTERFALLBACK(one, two, three) return;
+#elif defined QT_DIRECTFB_WARN_ON_RASTERFALLBACKS
+#define RASTERFALLBACK(one, two, three) rasterFallbackWarn("Falling back to raster engine for", \
+                                                           __FUNCTION__, state()->painter->device(), \
+                                                           d_func()->matrixScale, d_func()->matrixRotShear, \
+                                                           d_func()->simplePen, d_func()->dfbCanHandleClip(), \
+                                                           d_func()->forceRasterPrimitives, \
+                                                           #one, one, #two, two, #three, three);
+#else
+#define RASTERFALLBACK(one, two, three)
+#endif
+
 static inline uint ALPHA_MUL(uint x, uint a)
 {
     uint t = x * a;
@@ -181,20 +245,17 @@ public:
     IDirectFBSurface *surface;
 
     QPen pen;
-    QBrush brush;
 
     bool antialiased;
     bool forceRasterPrimitives;
 
     bool simplePen;
-    bool simpleBrush;
 
     bool matrixRotShear;
     bool matrixScale;
 
     void setTransform(const QTransform &m);
     void setPen(const QPen &pen);
-    void setBrush(const QBrush &brush);
     void setCompositionMode(QPainter::CompositionMode mode);
     void setOpacity(quint8 value);
     void setRenderHints(QPainter::RenderHints hints);
@@ -207,6 +268,7 @@ public:
     inline bool dfbCanHandleClip(const QRect &rect) const;
     inline bool dfbCanHandleClip(const QRectF &rect) const;
     inline bool dfbCanHandleClip() const;
+    inline bool isSimpleBrush(const QBrush &brush) const;
 
     void drawLines(const QLine *lines, int count) const;
     void drawLines(const QLineF *lines, int count) const;
@@ -217,6 +279,7 @@ public:
     void fillRects(const QRectF *rects, int count) const;
     void drawRects(const QRectF *rects, int count) const;
 
+
     void drawPixmap(const QRectF &dest,
                     const QPixmap &pixmap, const QRectF &src);
     void drawTiledPixmap(const QRectF &dest, const QPixmap &pixmap);
@@ -253,7 +316,7 @@ private:
 
 QDirectFBPaintEnginePrivate::QDirectFBPaintEnginePrivate(QDirectFBPaintEngine *p)
     : surface(0), antialiased(false), forceRasterPrimitives(false), simplePen(false),
-      simpleBrush(false), matrixRotShear(false), matrixScale(false), lastLockedHeight(-1),
+      matrixRotShear(false), matrixScale(false), lastLockedHeight(-1),
       fbWidth(-1), fbHeight(-1), opacity(255), drawFlagsFromCompositionMode(0),
       blitFlagsFromCompositionMode(0), porterDuffRule(DSPD_SRC_OVER), dirtyClip(true),
       dfbHandledClip(false), dfbDevice(0), q(p)
@@ -287,6 +350,11 @@ bool QDirectFBPaintEnginePrivate::dfbCanHandleClip() const
     return dfbHandledClip;
 }
 
+bool QDirectFBPaintEnginePrivate::isSimpleBrush(const QBrush &brush) const
+{
+    return (brush.style() == Qt::NoBrush) || (brush.style() == Qt::SolidPattern && !antialiased);
+}
+
 void QDirectFBPaintEnginePrivate::setClipDirty()
 {
     dirtyClip = true;
@@ -366,13 +434,6 @@ void QDirectFBPaintEnginePrivate::setPen(const QPen &p)
                  && (pen.widthF() <= 1 && !matrixScale));
 }
 
-void QDirectFBPaintEnginePrivate::setBrush(const QBrush &b)
-{
-    brush = b;
-    simpleBrush = (brush.style() == Qt::NoBrush) ||
-                  (brush.style() == Qt::SolidPattern && !antialiased);
-}
-
 void QDirectFBPaintEnginePrivate::setCompositionMode(QPainter::CompositionMode mode)
 {
     blitFlagsFromCompositionMode = DSBLIT_NOFX;
@@ -755,14 +816,6 @@ void QDirectFBPaintEngine::penChanged()
     QRasterPaintEngine::penChanged();
 }
 
-void QDirectFBPaintEngine::brushChanged()
-{
-    Q_D(QDirectFBPaintEngine);
-    d->setBrush(state()->brush);
-
-    QRasterPaintEngine::brushChanged();
-}
-
 void QDirectFBPaintEngine::opacityChanged()
 {
     Q_D(QDirectFBPaintEngine);
@@ -801,7 +854,6 @@ void QDirectFBPaintEngine::setState(QPainterState *s)
     QRasterPaintEngine::setState(s);
     d->setClipDirty();
     d->setPen(state()->pen);
-    d->setBrush(state()->brush);
     d->setOpacity(quint8(state()->opacity * 255));
     d->setCompositionMode(state()->compositionMode());
     d->setTransform(state()->transform());
@@ -834,8 +886,11 @@ void QDirectFBPaintEngine::drawRects(const QRect *rects, int rectCount)
 {
     Q_D(QDirectFBPaintEngine);
     d->updateClip();
-    if (!d->dfbCanHandleClip() || d->matrixRotShear || !d->simpleBrush
-        || !d->simplePen || d->forceRasterPrimitives) {
+    const QBrush &brush = state()->brush;
+    if (!d->dfbCanHandleClip() || d->matrixRotShear
+        || !d->simplePen || d->forceRasterPrimitives
+        || !d->isSimpleBrush(brush)) {
+        RASTERFALLBACK(rectCount, static_cast<bool>(false), static_cast<bool>(false));
         d->lock();
         QRasterPaintEngine::drawRects(rects, rectCount);
         return;
@@ -843,8 +898,8 @@ void QDirectFBPaintEngine::drawRects(const QRect *rects, int rectCount)
 
     d->unlock();
 
-    if (d->brush != Qt::NoBrush) {
-        d->setDFBColor(d->brush.color());
+    if (brush != Qt::NoBrush) {
+        d->setDFBColor(brush.color());
         d->fillRects(rects, rectCount);
     }
     if (d->pen != Qt::NoPen) {
@@ -857,8 +912,10 @@ void QDirectFBPaintEngine::drawRects(const QRectF *rects, int rectCount)
 {
     Q_D(QDirectFBPaintEngine);
     d->updateClip();
-    if (!d->dfbCanHandleClip() || d->matrixRotShear || !d->simpleBrush
-        || !d->simplePen || d->forceRasterPrimitives) {
+    const QBrush &brush = state()->brush;
+    if (!d->dfbCanHandleClip() || d->matrixRotShear
+        || !d->simplePen || d->forceRasterPrimitives
+        || !d->isSimpleBrush(brush)) {
         d->lock();
         QRasterPaintEngine::drawRects(rects, rectCount);
         return;
@@ -866,8 +923,8 @@ void QDirectFBPaintEngine::drawRects(const QRectF *rects, int rectCount)
 
     d->unlock();
 
-    if (d->brush != Qt::NoBrush) {
-        d->setDFBColor(d->brush.color());
+    if (brush != Qt::NoBrush) {
+        d->setDFBColor(brush.color());
         d->fillRects(rects, rectCount);
     }
     if (d->pen != Qt::NoPen) {
@@ -881,6 +938,7 @@ void QDirectFBPaintEngine::drawLines(const QLine *lines, int lineCount)
     Q_D(QDirectFBPaintEngine);
     d->updateClip();
     if (!d->simplePen || !d->dfbCanHandleClip() || d->forceRasterPrimitives) {
+        RASTERFALLBACK(lineCount, static_cast<bool>(false), static_cast<bool>(false));
         d->lock();
         QRasterPaintEngine::drawLines(lines, lineCount);
         return;
@@ -898,6 +956,7 @@ void QDirectFBPaintEngine::drawLines(const QLineF *lines, int lineCount)
     Q_D(QDirectFBPaintEngine);
     d->updateClip();
     if (!d->simplePen || !d->dfbCanHandleClip() || d->forceRasterPrimitives) {
+        RASTERFALLBACK(lineCount, static_cast<bool>(false), static_cast<bool>(false));
         d->lock();
         QRasterPaintEngine::drawLines(lines, lineCount);
         return;
@@ -923,6 +982,7 @@ void QDirectFBPaintEngine::drawImage(const QRectF &r, const QImage &image,
         || QDirectFBScreen::getSurfacePixelFormat(image.format()) == DSPF_UNKNOWN)
 #endif
     {
+        RASTERFALLBACK(r, image.size(), sr);
         d->lock();
         QRasterPaintEngine::drawImage(r, image, sr, flags);
         return;
@@ -946,9 +1006,11 @@ void QDirectFBPaintEngine::drawPixmap(const QRectF &r, const QPixmap &pixmap,
     d->updateClip();
 
     if (pixmap.pixmapData()->classId() != QPixmapData::DirectFBClass) {
+        // not using RASTERFALLBACK since this is the way we do bitmaps?
         d->lock();
         QRasterPaintEngine::drawPixmap(r, pixmap, sr);
     } else if (!d->dfbCanHandleClip(r) || d->matrixRotShear) {
+        RASTERFALLBACK(r, pixmap.size(), sr);
         const QImage *img = static_cast<QDirectFBPixmapData*>(pixmap.pixmapData())->buffer();
         d->lock();
         QRasterPaintEngine::drawImage(r, *img, sr);
@@ -973,6 +1035,7 @@ void QDirectFBPaintEngine::drawTiledPixmap(const QRectF &r,
         d->lock();
         QRasterPaintEngine::drawTiledPixmap(r, pixmap, sp);
     } else if (!d->dfbCanHandleClip(r) || d->matrixRotShear || !sp.isNull()) {
+        RASTERFALLBACK(r, pixmap.size(), sp);
         const QImage *img = static_cast<QDirectFBPixmapData*>(pixmap.pixmapData())->buffer();
         d->lock();
         QRasterPixmapData *data = new QRasterPixmapData(QPixmapData::PixmapType);
@@ -995,6 +1058,7 @@ void QDirectFBPaintEngine::stroke(const QVectorPath &path, const QPen &pen)
 
 void QDirectFBPaintEngine::drawPath(const QPainterPath &path)
 {
+    RASTERFALLBACK(path.boundingRect(), static_cast<bool>(false), static_cast<bool>(false));
     Q_D(QDirectFBPaintEngine);
     d->lock();
     QRasterPaintEngine::drawPath(path);
@@ -1002,6 +1066,7 @@ void QDirectFBPaintEngine::drawPath(const QPainterPath &path)
 
 void QDirectFBPaintEngine::drawPoints(const QPointF *points, int pointCount)
 {
+    RASTERFALLBACK(pointCount, static_cast<bool>(false), static_cast<bool>(false));
     Q_D(QDirectFBPaintEngine);
     d->lock();
     QRasterPaintEngine::drawPoints(points, pointCount);
@@ -1009,6 +1074,7 @@ void QDirectFBPaintEngine::drawPoints(const QPointF *points, int pointCount)
 
 void QDirectFBPaintEngine::drawPoints(const QPoint *points, int pointCount)
 {
+    RASTERFALLBACK(pointCount, static_cast<bool>(false), static_cast<bool>(false));
     Q_D(QDirectFBPaintEngine);
     d->lock();
     QRasterPaintEngine::drawPoints(points, pointCount);
@@ -1016,6 +1082,7 @@ void QDirectFBPaintEngine::drawPoints(const QPoint *points, int pointCount)
 
 void QDirectFBPaintEngine::drawEllipse(const QRectF &rect)
 {
+    RASTERFALLBACK(rect, static_cast<bool>(false), static_cast<bool>(false));
     Q_D(QDirectFBPaintEngine);
     d->lock();
     QRasterPaintEngine::drawEllipse(rect);
@@ -1024,6 +1091,7 @@ void QDirectFBPaintEngine::drawEllipse(const QRectF &rect)
 void QDirectFBPaintEngine::drawPolygon(const QPointF *points, int pointCount,
                                        PolygonDrawMode mode)
 {
+    RASTERFALLBACK(pointCount, mode, static_cast<bool>(false));
     Q_D(QDirectFBPaintEngine);
     d->lock();
     QRasterPaintEngine::drawPolygon(points, pointCount, mode);
@@ -1032,6 +1100,7 @@ void QDirectFBPaintEngine::drawPolygon(const QPointF *points, int pointCount,
 void QDirectFBPaintEngine::drawPolygon(const QPoint *points, int pointCount,
                                        PolygonDrawMode mode)
 {
+    RASTERFALLBACK(pointCount, mode, static_cast<bool>(false));
     Q_D(QDirectFBPaintEngine);
     d->lock();
     QRasterPaintEngine::drawPolygon(points, pointCount, mode);
@@ -1040,6 +1109,7 @@ void QDirectFBPaintEngine::drawPolygon(const QPoint *points, int pointCount,
 void QDirectFBPaintEngine::drawTextItem(const QPointF &p,
                                         const QTextItem &textItem)
 {
+    RASTERFALLBACK(p, textItem.text(), static_cast<bool>(false));
     Q_D(QDirectFBPaintEngine);
     d->lock();
     QRasterPaintEngine::drawTextItem(p, textItem);
@@ -1047,6 +1117,7 @@ void QDirectFBPaintEngine::drawTextItem(const QPointF &p,
 
 void QDirectFBPaintEngine::fill(const QVectorPath &path, const QBrush &brush)
 {
+    RASTERFALLBACK(path, brush, static_cast<bool>(false));
     Q_D(QDirectFBPaintEngine);
     d->lock();
     QRasterPaintEngine::fill(path, brush);
@@ -1080,6 +1151,7 @@ void QDirectFBPaintEngine::fillRect(const QRectF &rect, const QBrush &brush)
             break;
         }
     }
+    RASTERFALLBACK(rect, brush, static_cast<bool>(false));
     d->lock();
     QRasterPaintEngine::fillRect(rect, brush);
 }
@@ -1089,6 +1161,7 @@ void QDirectFBPaintEngine::fillRect(const QRectF &rect, const QColor &color)
     Q_D(QDirectFBPaintEngine);
     d->updateClip();
     if (!d->dfbCanHandleClip() || d->matrixRotShear || d->forceRasterPrimitives) {
+        RASTERFALLBACK(rect, color, static_cast<bool>(false));
         d->lock();
         QRasterPaintEngine::fillRect(rect, color);
     } else {
@@ -1105,6 +1178,7 @@ void QDirectFBPaintEngine::drawColorSpans(const QSpan *spans, int count,
 {
     Q_D(QDirectFBPaintEngine);
     if (d->forceRasterPrimitives) {
+        RASTERFALLBACK(count, color, static_cast<bool>(false));
         d->lock();
         QRasterPaintEngine::drawColorSpans(spans, count, color);
     } else {
diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.h b/src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.h
index 3c2cefa..e79ec61 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.h
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.h
@@ -96,7 +96,6 @@ public:
 
     virtual void clipEnabledChanged();
     virtual void penChanged();
-    virtual void brushChanged();
     virtual void opacityChanged();
     virtual void compositionModeChanged();
     virtual void renderHintsChanged();
diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbpixmap.cpp b/src/plugins/gfxdrivers/directfb/qdirectfbpixmap.cpp
index 0a1696a..ea9bb3a 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbpixmap.cpp
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbpixmap.cpp
@@ -157,10 +157,13 @@ static bool checkForAlphaPixels(const QImage &img)
     return false;
 }
 
-void QDirectFBPixmapData::fromImage(const QImage &img,
+void QDirectFBPixmapData::fromImage(const QImage &i,
                                     Qt::ImageConversionFlags flags)
 {
-    Q_ASSERT(img.depth() != 1); // these should be handled by QRasterPixmapData
+#ifdef QT_NO_DIRECTFB_OPAQUE_DETECTION
+    Q_UNUSED(flags);
+#endif
+    const QImage img = (i.depth() == 1 ? i.convertToFormat(screen->alphaPixmapFormat()) : i);
     if (img.hasAlphaChannel()
 #ifndef QT_NO_DIRECTFB_OPAQUE_DETECTION
         && (flags & Qt::NoOpaqueDetection || ::checkForAlphaPixels(img))
@@ -267,16 +270,17 @@ void QDirectFBPixmapData::fill(const QColor &color)
     if (forceRaster) {
         // in DSPF_RGB32 all dfb drawing causes the Alpha byte to be
         // set to 0. This causes issues for the raster engine.
-        char *mem;
-        int bpl;
-        const int h = QPixmapData::height();
-        dfbSurface->Lock(dfbSurface, DSLF_WRITE, (void**)&mem, &bpl);
-        const int c = color.rgba();
-        for (int i = 0; i < h; ++i) {
-            memset(mem, c, bpl);
-            mem += bpl;
+        uchar *mem = QDirectFBScreen::lockSurface(dfbSurface, DSLF_WRITE, &bpl);
+        if (mem) {
+            const int h = QPixmapData::height();
+            const int w = QPixmapData::width() * 4; // 4 bytes per 32 bit pixel
+            const int c = color.rgba();
+            for (int i = 0; i < h; ++i) {
+                memset(mem, c, w);
+                mem += bpl;
+            }
+            dfbSurface->Unlock(dfbSurface);
         }
-        dfbSurface->Unlock(dfbSurface);
     } else {
         dfbSurface->Clear(dfbSurface, color.red(), color.green(), color.blue(),
                           color.alpha());
diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbscreen.cpp b/src/plugins/gfxdrivers/directfb/qdirectfbscreen.cpp
index 041d522..3e54e7f 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbscreen.cpp
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbscreen.cpp
@@ -159,15 +159,17 @@ IDirectFBSurface* QDirectFBScreen::createDFBSurface(const QImage &img, SurfaceCr
     IDirectFBSurface *surface = createDFBSurface(&desc, options);
 #ifdef QT_NO_DIRECTFB_PREALLOCATED
     if (surface) {
-        char *mem;
         int bpl;
-        surface->Lock(surface, DSLF_WRITE, (void**)&mem, &bpl);
-        const int h = img.height();
-        for (int i = 0; i < h; ++i) {
-            memcpy(mem, img.scanLine(i), bpl);
-            mem += bpl;
+        uchar *mem = QDirectFBScreen::lockSurface(surface, DSLF_WRITE, &bpl);
+        if (mem) {
+            const int h = img.height();
+            const int w = img.width() * img.depth() / 8;
+            for (int i = 0; i < h; ++i) {
+                memcpy(mem, img.scanLine(i), w);
+                mem += bpl;
+            }
+            surface->Unlock(surface);
         }
-        surface->Unlock(surface);
     }
 #endif
 #ifndef QT_NO_DIRECTFB_PALETTE
@@ -317,15 +319,17 @@ IDirectFBSurface *QDirectFBScreen::copyToDFBSurface(const QImage &img,
     imgSurface->Release(imgSurface);
 #else // QT_NO_DIRECTFB_PREALLOCATED
     Q_ASSERT(image.format() == pixmapFormat);
-    char *mem;
     int bpl;
-    dfbSurface->Lock(dfbSurface, DSLF_WRITE, (void**)&mem, &bpl);
-    const int w = image.width() * image.depth() / 8;
-    for (int i = 0; i < image.height(); ++i) {
-        memcpy(mem, image.scanLine(i), w);
-        mem += bpl;
+    uchar *mem = QDirectFBScreen::lockSurface(dfbSurface, DSLF_WRITE, &bpl);
+    if (mem) {
+        const int h = image.height();
+        const int w = image.width() * image.depth() / 8;
+        for (int i=0; i<h; ++i) {
+            memcpy(mem, image.scanLine(i), w);
+            mem += bpl;
+        }
+        dfbSurface->Unlock(dfbSurface);
     }
-    dfbSurface->Unlock(dfbSurface);
 #endif
     return dfbSurface;
 }
@@ -833,15 +837,15 @@ bool QDirectFBScreen::connect(const QString &displaySpec)
         description.flags = DFBSurfaceDescriptionFlags(description.flags | DSDESC_WIDTH);
     if (::setIntOption(displayArgs, QLatin1String("height"), &description.height))
         description.flags = DFBSurfaceDescriptionFlags(description.flags | DSDESC_HEIGHT);
-    description.caps = DFBSurfaceCapabilities(DSCAPS_PRIMARY
-                                              | DSCAPS_DOUBLE
-                                              | DSCAPS_STATIC_ALLOC);
-    if (displayArgs.contains(QLatin1String("forcepremultiplied"),
-                             Qt::CaseInsensitive)) {
-        description.caps = DFBSurfaceCapabilities(description.caps
-                                                  | DSCAPS_PREMULTIPLIED);
+    uint caps = DSCAPS_PRIMARY|DSCAPS_DOUBLE;
+    if (displayArgs.contains(QLatin1String("static_alloc")))
+        caps |= DSCAPS_STATIC_ALLOC;
+
+    if (displayArgs.contains(QLatin1String("forcepremultiplied"), Qt::CaseInsensitive)) {
+        caps |= DSCAPS_PREMULTIPLIED;
     }
 
+    description.caps = DFBSurfaceCapabilities(caps);
     // We don't track the primary surface as it's released in disconnect
     d_ptr->dfbSurface = createDFBSurface(&description, DontTrackSurface);
     if (!d_ptr->dfbSurface) {
@@ -952,16 +956,15 @@ void QDirectFBScreen::disconnect()
 
 bool QDirectFBScreen::initDevice()
 {
-    QWSServer *server = QWSServer::instance();
 #ifndef QT_NO_DIRECTFB_MOUSE
     if (qgetenv("QWS_MOUSE_PROTO").isEmpty()) {
-        server->setDefaultMouse("None");
+        QWSServer::instance()->setDefaultMouse("None");
         d_ptr->mouse = new QDirectFBMouseHandler;
     }
 #endif
 #ifndef QT_NO_DIRECTFB_KEYBOARD
     if (qgetenv("QWS_KEYBOARD").isEmpty()) {
-        server->setDefaultKeyboard("None");
+        QWSServer::instance()->setDefaultKeyboard("None");
         d_ptr->keyboard = new QDirectFBKeyboardHandler(QString());
     }
 #endif
@@ -1188,23 +1191,23 @@ void QDirectFBScreen::blit(IDirectFBSurface *src, const QPoint &topLeft,
                                  points.data(), n);
 }
 
+// This function is only ever called by QScreen::drawBackground which
+// is only ever called by QScreen::compose which is never called with
+// DirectFB so it's really a noop.
 void QDirectFBScreen::solidFill(const QColor &color, const QRegion &region)
 {
     if (region.isEmpty())
         return;
 
     if (QDirectFBScreen::getImageFormat(d_ptr->dfbSurface) == QImage::Format_RGB32) {
-        uchar *mem;
-        int bpl;
-        d_ptr->dfbSurface->Lock(d_ptr->dfbSurface, DSLF_WRITE, (void**)&mem, &bpl);
-        QImage img(mem, w, h, bpl, QImage::Format_RGB32);
-        QPainter p(&img);
-        p.setBrush(color);
-        p.setPen(Qt::NoPen);
-        const QVector<QRect> rects = region.rects();
-        p.drawRects(rects.constData(), rects.size());
-        p.end();
+        data = QDirectFBScreen::lockSurface(d_ptr->dfbSurface, DSLF_WRITE, &lstep);
+        if (!data)
+            return;
+
+        QScreen::solidFill(color, region);
         d_ptr->dfbSurface->Unlock(d_ptr->dfbSurface);
+        data = 0;
+        lstep = 0;
     } else {
         d_ptr->dfbSurface->SetColor(d_ptr->dfbSurface,
                                     color.red(), color.green(), color.blue(),
@@ -1241,3 +1244,15 @@ bool QDirectFBScreen::initSurfaceDescriptionPixelFormat(DFBSurfaceDescription *d
     }
     return true;
 }
+
+uchar *QDirectFBScreen::lockSurface(IDirectFBSurface *surface, DFBSurfaceLockFlags flags, int *bpl)
+{
+    void *mem;
+    const DFBResult result = surface->Lock(surface, flags, static_cast<void**>(&mem), bpl);
+    if (result != DFB_OK) {
+        DirectFBError("QDirectFBPixmapData::lockSurface()", result);
+    }
+
+    return reinterpret_cast<uchar*>(mem);
+}
+
diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbscreen.h b/src/plugins/gfxdrivers/directfb/qdirectfbscreen.h
index f394ac1..8dd38dc 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbscreen.h
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbscreen.h
@@ -127,6 +127,8 @@ public:
                                      const QImage &image);
 #endif
 
+    static uchar *lockSurface(IDirectFBSurface *surface, DFBSurfaceLockFlags flags, int *bpl = 0);
+
 private:
     void compose(const QRegion &r);
     void blit(IDirectFBSurface *src, const QPoint &topLeft,
diff --git a/src/plugins/gfxdrivers/powervr/QWSWSEGL/pvrqwsdrawable.c b/src/plugins/gfxdrivers/powervr/QWSWSEGL/pvrqwsdrawable.c
index 5c37253..4771d14 100644
--- a/src/plugins/gfxdrivers/powervr/QWSWSEGL/pvrqwsdrawable.c
+++ b/src/plugins/gfxdrivers/powervr/QWSWSEGL/pvrqwsdrawable.c
@@ -72,7 +72,7 @@ static int pvrQwsInitFbScreen(int screen)
     /* Bail out if already initialized, or the number is incorrect */
     if (screen < 0 || screen >= PVRQWS_MAX_SCREENS)
         return 0;
-    if (pvrQwsDisplay.screens[screen].mapped)
+    if (pvrQwsDisplay.screens[screen].initialized)
         return 1;
 
     /* Open the framebuffer and fetch its properties */
@@ -125,26 +125,33 @@ static int pvrQwsInitFbScreen(int screen)
     start = fix.smem_start;
     length = var.xres_virtual * var.yres_virtual * bytesPerPixel;
 
-    /* Map the framebuffer region into memory */
-    mapped = mmap(0, length, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
-    if (!mapped || mapped == (void *)(-1)) {
-        perror("mmap");
-        close(fd);
-        return 0;
-    }
-
-    /* Allocate a PVR2D memory region for the framebuffer */
-    memInfo = 0;
-    if (pvrQwsDisplay.context) {
-        pageAddresses[0] = start & 0xFFFFF000;
-        pageAddresses[1] = 0;
-        if (PVR2DMemWrap
-                (pvrQwsDisplay.context, mapped, PVR2D_WRAPFLAG_CONTIGUOUS,
-                 length, pageAddresses, &memInfo) != PVR2D_OK) {
-            munmap(mapped, length);
+    if (screen == 0) {
+        /* We use PVR2DGetFrameBuffer to map the first screen.
+           On some chipsets it is more reliable than using PVR2DMemWrap */
+        mapped = 0;
+        memInfo = 0;
+    } else {
+        /* Other screens: map the framebuffer region into memory */
+        mapped = mmap(0, length, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+        if (!mapped || mapped == (void *)(-1)) {
+            perror("mmap");
             close(fd);
             return 0;
         }
+
+        /* Allocate a PVR2D memory region for the framebuffer */
+        memInfo = 0;
+        if (pvrQwsDisplay.context) {
+            pageAddresses[0] = start & 0xFFFFF000;
+            pageAddresses[1] = 0;
+            if (PVR2DMemWrap
+                    (pvrQwsDisplay.context, mapped, PVR2D_WRAPFLAG_CONTIGUOUS,
+                     length, pageAddresses, &memInfo) != PVR2D_OK) {
+                munmap(mapped, length);
+                close(fd);
+                return 0;
+            }
+        }
     }
 
     /* We don't need the file descriptor any more */
@@ -158,11 +165,17 @@ static int pvrQwsInitFbScreen(int screen)
     pvrQwsDisplay.screens[screen].screenStride = stride;
     pvrQwsDisplay.screens[screen].pixelFormat = format;
     pvrQwsDisplay.screens[screen].bytesPerPixel = bytesPerPixel;
-    pvrQwsDisplay.screens[screen].frameBuffer = memInfo;
     pvrQwsDisplay.screens[screen].screenDrawable = 0;
-    pvrQwsDisplay.screens[screen].mapped = mapped;
+    if (mapped) {
+        /* Don't set these fields if mapped is 0, because PVR2DGetFrameBuffer
+           may have already been called and set them */
+        pvrQwsDisplay.screens[screen].frameBuffer = memInfo;
+        pvrQwsDisplay.screens[screen].mapped = mapped;
+    }
     pvrQwsDisplay.screens[screen].mappedLength = length;
     pvrQwsDisplay.screens[screen].screenStart = start;
+    pvrQwsDisplay.screens[screen].needsUnmap = (mapped != 0);
+    pvrQwsDisplay.screens[screen].initialized = 1;
     return 1;
 }
 
@@ -209,7 +222,7 @@ static int pvrQwsAddDrawable(void)
 
     /* Create the PVR2DMEMINFO blocks for the active framebuffers */
     for (screen = 0; screen < PVRQWS_MAX_SCREENS; ++screen) {
-        if (pvrQwsDisplay.screens[screen].mapped) {
+        if (screen != 0 && pvrQwsDisplay.screens[screen].mapped) {
             pageAddresses[0]
                 = pvrQwsDisplay.screens[screen].screenStart & 0xFFFFF000;
             pageAddresses[1] = 0;
@@ -224,6 +237,17 @@ static int pvrQwsAddDrawable(void)
                 return 0;
             }
             pvrQwsDisplay.screens[screen].frameBuffer = memInfo;
+        } else if (screen == 0) {
+            if (PVR2DGetFrameBuffer
+                    (pvrQwsDisplay.context,
+                     PVR2D_FB_PRIMARY_SURFACE, &memInfo) != PVR2D_OK) {
+                fprintf(stderr, "QWSWSEGL: could not get the primary framebuffer surface\n");
+                PVR2DDestroyDeviceContext(pvrQwsDisplay.context);
+                pvrQwsDisplay.context = 0;
+                return 0;
+            }
+            pvrQwsDisplay.screens[screen].frameBuffer = memInfo;
+            pvrQwsDisplay.screens[screen].mapped = memInfo->pBase;
         }
     }
 
@@ -330,7 +354,7 @@ void pvrQwsDisplayClose(void)
             pvrQwsDestroyDrawableForced(info->screenDrawable);
         if (info->frameBuffer)
             PVR2DMemFree(pvrQwsDisplay.context, info->frameBuffer);
-        if (info->mapped)
+        if (info->mapped && info->needsUnmap)
             munmap(info->mapped, info->mappedLength);
     }
 
diff --git a/src/plugins/gfxdrivers/powervr/QWSWSEGL/pvrqwsdrawable_p.h b/src/plugins/gfxdrivers/powervr/QWSWSEGL/pvrqwsdrawable_p.h
index d6c42a6..4f3ea90 100644
--- a/src/plugins/gfxdrivers/powervr/QWSWSEGL/pvrqwsdrawable_p.h
+++ b/src/plugins/gfxdrivers/powervr/QWSWSEGL/pvrqwsdrawable_p.h
@@ -76,6 +76,8 @@ typedef struct {
     void               *mapped;
     int                 mappedLength;
     unsigned long       screenStart;
+    int                 needsUnmap;
+    int                 initialized;
 
 } PvrQwsScreenInfo;
 
diff --git a/src/plugins/iconengines/svgiconengine/qsvgiconengine.cpp b/src/plugins/iconengines/svgiconengine/qsvgiconengine.cpp
index 7fdf81f..c7249d3 100644
--- a/src/plugins/iconengines/svgiconengine/qsvgiconengine.cpp
+++ b/src/plugins/iconengines/svgiconengine/qsvgiconengine.cpp
@@ -121,7 +121,7 @@ QSize QSvgIconEngine::actualSize(const QSize &size, QIcon::Mode mode,
         if (!pm.isNull() && pm.size() == size)
             return size;
     }
-    
+
     QSvgRenderer renderer;
     d->loadDataForModeAndState(&renderer, mode, state);
     if (renderer.isValid()) {
@@ -158,9 +158,13 @@ void QSvgIconEnginePrivate::loadDataForModeAndState(QSvgRenderer *renderer, QIco
 
 QPixmap QSvgIconEngine::pixmap(const QSize &size, QIcon::Mode mode,
                                QIcon::State state)
-{   
+{
     QPixmap pm;
 
+    QString pmckey(d->pmcKey(size, mode, state));
+    if (QPixmapCache::find(pmckey, pm))
+        return pm;
+
     if (d->addedPixmaps) {
         pm = d->addedPixmaps->value(d->hashKey(mode, state));
         if (!pm.isNull() && pm.size() == size)
@@ -176,10 +180,6 @@ QPixmap QSvgIconEngine::pixmap(const QSize &size, QIcon::Mode mode,
     if (!actualSize.isNull())
         actualSize.scale(size, Qt::KeepAspectRatio);
 
-    QString pmckey(d->pmcKey(actualSize, mode, state));
-    if (QPixmapCache::find(pmckey, pm))
-        return pm;
-
     QImage img(actualSize, QImage::Format_ARGB32_Premultiplied);
     img.fill(0x00000000);
     QPainter p(&img);
diff --git a/src/plugins/imageformats/ico/qicohandler.cpp b/src/plugins/imageformats/ico/qicohandler.cpp
index aa53370..da5ae15 100644
--- a/src/plugins/imageformats/ico/qicohandler.cpp
+++ b/src/plugins/imageformats/ico/qicohandler.cpp
@@ -80,7 +80,7 @@ typedef struct
 typedef struct {                    // BMP information header
     quint32 biSize;                // size of this struct
     quint32 biWidth;               // pixmap width
-    quint32 biHeight;              // pixmap height
+    quint32 biHeight;              // pixmap height     (specifies the combined height of the XOR and AND masks)
     quint16 biPlanes;              // should be 1
     quint16 biBitCount;            // number of bits per pixel
     quint32 biCompression;         // compression method
@@ -108,7 +108,7 @@ private:
     bool readHeader();
     bool readIconEntry(int index, ICONDIRENTRY * iconEntry);
 
-    bool readBMPHeader(ICONDIRENTRY & iconEntry, BMP_INFOHDR * header);
+    bool readBMPHeader(quint32 imageOffset, BMP_INFOHDR * header);
     void findColorInfo(QImage & image);
     void readColorTable(QImage & image);
 
@@ -343,7 +343,7 @@ bool ICOReader::readHeader()
     return headerRead;
 }
 
-bool ICOReader::readIconEntry(int index, ICONDIRENTRY * iconEntry)
+bool ICOReader::readIconEntry(int index, ICONDIRENTRY *iconEntry)
 {
     if (iod) {
         if (iod->seek(startpos + ICONDIR_SIZE + (index * ICONDIRENTRY_SIZE))) {
@@ -355,37 +355,12 @@ bool ICOReader::readIconEntry(int index, ICONDIRENTRY * iconEntry)
 
 
 
-bool ICOReader::readBMPHeader(ICONDIRENTRY & iconEntry, BMP_INFOHDR * header)
+bool ICOReader::readBMPHeader(quint32 imageOffset, BMP_INFOHDR * header)
 {
-    memset(&icoAttrib, 0, sizeof(IcoAttrib));
     if (iod) {
-        if (iod->seek(startpos + iconEntry.dwImageOffset)) {
+        if (iod->seek(startpos + imageOffset)) {
             if (readBMPInfoHeader(iod, header)) {
-
-                icoAttrib.nbits = header->biBitCount ? header->biBitCount : iconEntry.wBitCount;
-                icoAttrib.h = header->biHeight / 2; // this height is always double the iconEntry height (for the mask)
-                icoAttrib.w = header->biWidth;
-
-                switch (icoAttrib.nbits) {
-                case 32:
-                case 24:
-                case 16:
-                    icoAttrib.depth = 32;
-                    break;
-                case 8:
-                case 4:
-                    icoAttrib.depth = 8;
-                    break;
-                default:
-                    icoAttrib.depth = 1;
-                }
-
-                if ( icoAttrib.depth == 32 )                // there's no colormap
-                    icoAttrib.ncolors = 0;
-                else                    // # colors used
-                    icoAttrib.ncolors = header->biClrUsed ? header->biClrUsed : 1 << icoAttrib.nbits;
-                        //qDebug() << "Bits:" << icoAttrib.nbits << "Depth:" << icoAttrib.depth << "Ncols:" << icoAttrib.ncolors;
-                    return TRUE;
+                return TRUE;
             }
         }
     }
@@ -548,7 +523,28 @@ QImage ICOReader::iconAt(int index)
         if (readIconEntry(index, &iconEntry)) {
 
             BMP_INFOHDR header;
-            if (readBMPHeader(iconEntry, &header)) {
+            if (readBMPHeader(iconEntry.dwImageOffset, &header)) {
+                icoAttrib.nbits = header.biBitCount ? header.biBitCount : iconEntry.wBitCount;
+
+                switch (icoAttrib.nbits) {
+                case 32:
+                case 24:
+                case 16:
+                    icoAttrib.depth = 32;
+                    break;
+                case 8:
+                case 4:
+                    icoAttrib.depth = 8;
+                    break;
+                default:
+                    icoAttrib.depth = 1;
+                }
+                if (icoAttrib.depth == 32)                // there's no colormap
+                    icoAttrib.ncolors = 0;
+                else                    // # colors used
+                    icoAttrib.ncolors = header.biClrUsed ? header.biClrUsed : 1 << icoAttrib.nbits;
+                icoAttrib.w = iconEntry.bWidth;
+                icoAttrib.h = iconEntry.bHeight;
 
                 QImage::Format format = QImage::Format_ARGB32;
                 if (icoAttrib.nbits == 24)
diff --git a/src/plugins/qpluginbase.pri b/src/plugins/qpluginbase.pri
index 446efab..ae39021 100644
--- a/src/plugins/qpluginbase.pri
+++ b/src/plugins/qpluginbase.pri
@@ -1,6 +1,6 @@
 TEMPLATE = lib
 isEmpty(QT_MAJOR_VERSION) {
-   VERSION=4.5.1
+   VERSION=4.5.2
 } else {
    VERSION=$${QT_MAJOR_VERSION}.$${QT_MINOR_VERSION}.$${QT_PATCH_VERSION}
 }
diff --git a/src/svg/qsvgstyle.cpp b/src/svg/qsvgstyle.cpp
index b065395..bd0804c 100644
--- a/src/svg/qsvgstyle.cpp
+++ b/src/svg/qsvgstyle.cpp
@@ -808,6 +808,7 @@ void QSvgGradientStyle::resolveStops()
                     static_cast<QSvgGradientStyle*>(prop);
                 st->resolveStops();
                 m_gradient->setStops(st->qgradient()->stops());
+                m_gradientStopsSet = st->gradientStopsSet();
             }
         }
         m_link = QString();
diff --git a/src/svg/qsvgwidget.cpp b/src/svg/qsvgwidget.cpp
index a4200ca..ac8595f 100644
--- a/src/svg/qsvgwidget.cpp
+++ b/src/svg/qsvgwidget.cpp
@@ -83,18 +83,6 @@ class QSvgWidgetPrivate : public QWidgetPrivate
 {
     Q_DECLARE_PUBLIC(QSvgWidget)
 public:
-    QSvgWidgetPrivate()
-        : QWidgetPrivate()
-    {
-        Q_Q(QSvgWidget);
-        renderer = new QSvgRenderer(q);
-    }
-    QSvgWidgetPrivate(const QString &file)
-        : QWidgetPrivate()
-    {
-        Q_Q(QSvgWidget);
-        renderer = new QSvgRenderer(file, q);
-    }
     QSvgRenderer *renderer;
 };
 
@@ -104,6 +92,7 @@ public:
 QSvgWidget::QSvgWidget(QWidget *parent)
     : QWidget(*new QSvgWidgetPrivate, parent, 0)
 {
+    d_func()->renderer = new QSvgRenderer(this);
     QObject::connect(d_func()->renderer, SIGNAL(repaintNeeded()),
                      this, SLOT(update()));
 }
@@ -113,8 +102,9 @@ QSvgWidget::QSvgWidget(QWidget *parent)
     of the specified \a file.
 */
 QSvgWidget::QSvgWidget(const QString &file, QWidget *parent)
-    : QWidget(*new QSvgWidgetPrivate(file), parent, 0)
+    : QWidget(*new QSvgWidgetPrivate, parent, 0)
 {
+    d_func()->renderer = new QSvgRenderer(file, this);
     QObject::connect(d_func()->renderer, SIGNAL(repaintNeeded()),
                      this, SLOT(update()));
 }
diff --git a/src/testlib/qtestcase.cpp b/src/testlib/qtestcase.cpp
index a9b85e8..936b936 100644
--- a/src/testlib/qtestcase.cpp
+++ b/src/testlib/qtestcase.cpp
@@ -1487,7 +1487,7 @@ int QTest::qExec(QObject *testObject, int argc, char **argv)
     }
 #endif
 
-#if defined(QTEST_NOEXITCODE) || (defined(QT_BUILD_INTERNAL) && !defined(QTEST_FORCE_EXITCODE))
+#if defined(QTEST_NOEXITCODE)
     return 0;
 #else