Merge branch '4.6' of scm.dev.nokia.troll.no:qt/oslo-staging-2 into 4.6-integration

* '4.6' of scm.dev.nokia.troll.no:qt/oslo-staging-2: (26 commits)
  QLocalSocket::isValid on Windows must check for broken connection
  fix pipe handle leak in qlocalsocket_win.cpp
  GraphicsViewBenchmark: Run app in full screen mode on small desktops.
  Fix Thai text on Windows 7
  Fix License headers.
  QTextCodec::codecForName.  Insert in the cache in all cases.
  Prevented calling the pixmap filter implementations with null pixmaps.
  Make it possible to run benchmarks with the "-graphicssystem" switch.
  Add support for running the GraphicsViewBenchmark application manually.
  Bump version to 4.6.3.
  Fixed a GLX warning that occured with some Intel chipsets under X11.
  Fixed compile for maemo6.
  Cleanup QEglContext & EGLDisplays
  Moved 'hasAlpha' property from GL2 engine to GL paint device.
  Remove useless qDebug in QTextCodec autotest
  QTextCodec: Symbian has codec for UCS2, only fallback to UTF16 if UCS2 codec cannot be loaded
  Add caching to QTextCodec::codecForName and QTextCodec::codecForMib
  Add benchmark for QTextCodec
  Fix several bugs with GL texture cache
  Compile fix for OpenGL ES.
  ...

37 files changed, 249 insertions, 178 deletions

diff --git a/src/corelib/codecs/qtextcodec.cpp b/src/corelib/codecs/qtextcodec.cpp
index ff40af5..c0aa342 100644
--- a/src/corelib/codecs/qtextcodec.cpp
+++ b/src/corelib/codecs/qtextcodec.cpp
@@ -80,6 +80,7 @@
 #endif // QT_NO_CODECS
 #include "qlocale.h"
 #include "qmutex.h"
+#include "qhash.h"
 
 #include <stdlib.h>
 #include <ctype.h>
@@ -172,6 +173,7 @@ static QTextCodec *createForMib(int mib)
 }
 
 static QList<QTextCodec*> *all = 0;
+static int clearCaches = 0;  // flags specifying if caches should be invalided: 0x1 codecForName, 0x2 codecForMib
 #ifdef Q_DEBUG_TEXTCODEC
 static bool destroying_is_ok = false;
 #endif
@@ -935,6 +937,7 @@ QTextCodec::~QTextCodec()
         QMutexLocker locker(textCodecsMutex());
 #endif
         all->removeAll(this);
+        clearCaches = 0x1 | 0x2;
     }
 }
 
@@ -961,17 +964,33 @@ QTextCodec *QTextCodec::codecForName(const QByteArray &name)
 #endif
     setup();
 
+    static QHash <QByteArray, QTextCodec *> cache;
+    if (clearCaches & 0x1) {
+        cache.clear();
+        clearCaches &= ~0x1;
+    }
+    QTextCodec *codec = cache.value(name);
+    if (codec)
+        return codec;
+
     for (int i = 0; i < all->size(); ++i) {
         QTextCodec *cursor = all->at(i);
-        if (nameMatch(cursor->name(), name))
+        if (nameMatch(cursor->name(), name)) {
+            cache.insert(name, cursor);
             return cursor;
+        }
         QList<QByteArray> aliases = cursor->aliases();
         for (int y = 0; y < aliases.size(); ++y)
-            if (nameMatch(aliases.at(y), name))
+            if (nameMatch(aliases.at(y), name)) {
+                cache.insert(name, cursor);
                 return cursor;
+            }
     }
 
-    return createForName(name);
+    codec = createForName(name);
+    if (codec)
+        cache.insert(name, codec);
+    return codec;
 }
 
 
@@ -986,19 +1005,34 @@ QTextCodec* QTextCodec::codecForMib(int mib)
 #endif
     setup();
 
-    // Qt 3 used 1000 (mib for UCS2) as its identifier for the utf16 codec. Map
-    // this correctly for compatibility.
-    if (mib == 1000)
-        mib = 1015;
+    static QHash <int, QTextCodec *> cache;
+    if (clearCaches & 0x2) {
+        cache.clear();
+        clearCaches &= ~0x2;
+    }
+    QTextCodec *codec = cache.value(mib);
+    if (codec)
+        return codec;
 
     QList<QTextCodec*>::ConstIterator i;
     for (int i = 0; i < all->size(); ++i) {
         QTextCodec *cursor = all->at(i);
-        if (cursor->mibEnum() == mib)
+        if (cursor->mibEnum() == mib) {
+            cache.insert(mib, cursor);
             return cursor;
+        }
     }
 
-    return createForMib(mib);
+    codec = createForMib(mib);
+
+    // Qt 3 used 1000 (mib for UCS2) as its identifier for the utf16 codec. Map
+    // this correctly for compatibility.
+    if (!codec && mib == 1000)
+        return codecForMib(1015);
+
+    if (codec)
+        cache.insert(mib, codec);
+    return codec;
 }
 
 /*!
diff --git a/src/corelib/global/qglobal.h b/src/corelib/global/qglobal.h
index f51849b..9edf929 100644
--- a/src/corelib/global/qglobal.h
+++ b/src/corelib/global/qglobal.h
@@ -44,11 +44,11 @@
 
 #include <stddef.h>
 
-#define QT_VERSION_STR   "4.6.2"
+#define QT_VERSION_STR   "4.6.3"
 /*
    QT_VERSION is (major << 16) + (minor << 8) + patch.
 */
-#define QT_VERSION 0x040602
+#define QT_VERSION 0x040603
 /*
    can be used like #if (QT_VERSION >= QT_VERSION_CHECK(4, 4, 0))
 */
diff --git a/src/gui/effects/qgraphicseffect.cpp b/src/gui/effects/qgraphicseffect.cpp
index 10ef5ea..7d1d03d 100644
--- a/src/gui/effects/qgraphicseffect.cpp
+++ b/src/gui/effects/qgraphicseffect.cpp
@@ -699,12 +699,17 @@ void QGraphicsColorizeEffect::draw(QPainter *painter)
     if (sourceIsPixmap()) {
         // No point in drawing in device coordinates (pixmap will be scaled anyways).
         const QPixmap pixmap = sourcePixmap(Qt::LogicalCoordinates, &offset, NoPad);
-        d->filter->draw(painter, offset, pixmap);
+        if (!pixmap.isNull())
+            d->filter->draw(painter, offset, pixmap);
+
         return;
     }
 
     // Draw pixmap in deviceCoordinates to avoid pixmap scaling.
     const QPixmap pixmap = sourcePixmap(Qt::DeviceCoordinates, &offset);
+    if (pixmap.isNull())
+        return;
+
     QTransform restoreTransform = painter->worldTransform();
     painter->setWorldTransform(QTransform());
     d->filter->draw(painter, offset, pixmap);
@@ -858,9 +863,11 @@ void QGraphicsBlurEffect::draw(QPainter *painter)
     if (painter->paintEngine()->type() == QPaintEngine::OpenGL2)
         mode = NoPad;
 
-    // Draw pixmap in device coordinates to avoid pixmap scaling.
     QPoint offset;
     QPixmap pixmap = sourcePixmap(Qt::LogicalCoordinates, &offset, mode);
+    if (pixmap.isNull())
+        return;
+
     d->filter->draw(painter, offset, pixmap);
 }
 
@@ -1047,6 +1054,9 @@ void QGraphicsDropShadowEffect::draw(QPainter *painter)
     // Draw pixmap in device coordinates to avoid pixmap scaling.
     QPoint offset;
     const QPixmap pixmap = sourcePixmap(Qt::DeviceCoordinates, &offset, mode);
+    if (pixmap.isNull())
+        return;
+
     QTransform restoreTransform = painter->worldTransform();
     painter->setWorldTransform(QTransform());
     d->filter->draw(painter, offset, pixmap);
diff --git a/src/gui/egl/qegl.cpp b/src/gui/egl/qegl.cpp
index ae3d6c3..4d447cb 100644
--- a/src/gui/egl/qegl.cpp
+++ b/src/gui/egl/qegl.cpp
@@ -54,9 +54,10 @@ QT_BEGIN_NAMESPACE
 static QEglContext * volatile currentGLContext = 0;
 static QEglContext * volatile currentVGContext = 0;
 
+EGLDisplay QEglContext::dpy = EGL_NO_DISPLAY;
+
 QEglContext::QEglContext()
     : apiType(QEgl::OpenGL)
-    , dpy(EGL_NO_DISPLAY)
     , ctx(EGL_NO_CONTEXT)
     , cfg(0)
     , currentSurface(EGL_NO_SURFACE)
@@ -68,7 +69,7 @@ QEglContext::QEglContext()
 
 QEglContext::~QEglContext()
 {
-    destroy();
+    destroyContext();
 
     if (currentGLContext == this)
         currentGLContext = 0;
@@ -86,14 +87,6 @@ bool QEglContext::isCurrent() const
     return current;
 }
 
-// Open the EGL display associated with "device".
-bool QEglContext::openDisplay(QPaintDevice *device)
-{
-    if (dpy == EGL_NO_DISPLAY)
-        dpy = defaultDisplay(device);
-    return (dpy != EGL_NO_DISPLAY);
-}
-
 // Choose a configuration that matches "properties".
 bool QEglContext::chooseConfig
         (const QEglProperties& properties, QEgl::PixelFormatMatch match)
@@ -102,7 +95,7 @@ bool QEglContext::chooseConfig
     do {
         // Get the number of matching configurations for this set of properties.
         EGLint matching = 0;
-        if (!eglChooseConfig(dpy, props.properties(), 0, 0, &matching) || !matching)
+        if (!eglChooseConfig(display(), props.properties(), 0, 0, &matching) || !matching)
             continue;
 
         // If we want the best pixel format, then return the first
@@ -179,7 +172,7 @@ bool QEglContext::createContext(QEglContext *shareContext, const QEglProperties
     if (shareContext && shareContext->ctx == EGL_NO_CONTEXT)
         shareContext = 0;
     if (shareContext) {
-        ctx = eglCreateContext(dpy, cfg, shareContext->ctx, contextProps.properties());
+        ctx = eglCreateContext(display(), cfg, shareContext->ctx, contextProps.properties());
         if (ctx == EGL_NO_CONTEXT) {
             qWarning() << "QEglContext::createContext(): Could not share context:" << errorString(eglGetError());
             shareContext = 0;
@@ -209,7 +202,7 @@ void QEglContext::destroySurface(EGLSurface surface)
 }
 
 // Destroy the context.  Note: this does not destroy the surface.
-void QEglContext::destroy()
+void QEglContext::destroyContext()
 {
     if (ctx != EGL_NO_CONTEXT && ownsContext)
         eglDestroyContext(dpy, ctx);
@@ -248,7 +241,7 @@ bool QEglContext::makeCurrent(EGLSurface surface)
         eglBindAPI(EGL_OPENVG_API);
 #endif
 
-    bool ok = eglMakeCurrent(dpy, surface, surface, ctx);
+    bool ok = eglMakeCurrent(display(), surface, surface, ctx);
     if (!ok)
         qWarning() << "QEglContext::makeCurrent():" << errorString(eglGetError());
     return ok;
@@ -277,7 +270,7 @@ bool QEglContext::doneCurrent()
         eglBindAPI(EGL_OPENVG_API);
 #endif
 
-    bool ok = eglMakeCurrent(dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+    bool ok = eglMakeCurrent(display(), EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
     if (!ok)
         qWarning() << "QEglContext::doneCurrent():" << errorString(eglGetError());
     return ok;
@@ -299,7 +292,7 @@ bool QEglContext::swapBuffers(EGLSurface surface)
     if(ctx == EGL_NO_CONTEXT)
         return false;
 
-    bool ok = eglSwapBuffers(dpy, surface);
+    bool ok = eglSwapBuffers(display(), surface);
     if (!ok)
         qWarning() << "QEglContext::swapBuffers():" << errorString(eglGetError());
     return ok;
@@ -338,7 +331,7 @@ void QEglContext::waitClient()
 // Query the value of a configuration attribute.
 bool QEglContext::configAttrib(int name, EGLint *value) const
 {
-    return eglGetConfigAttrib(dpy, cfg, name, value);
+    return eglGetConfigAttrib(display(), cfg, name, value);
 }
 
 // Retrieve all of the properties on "cfg".  If zero, return
@@ -357,27 +350,38 @@ QEglProperties QEglContext::configProperties(EGLConfig cfg) const
     return props;
 }
 
-// Initialize and return the default display.
-EGLDisplay QEglContext::defaultDisplay(QPaintDevice *device)
+EGLDisplay QEglContext::display()
 {
-    static EGLDisplay dpy = EGL_NO_DISPLAY;
-    if (dpy == EGL_NO_DISPLAY) {
-        dpy = getDisplay(device);
+    static bool openedDisplay = false;
+
+    if (!openedDisplay) {
+        dpy = eglGetDisplay(nativeDisplay());
+        openedDisplay = true;
+        if (dpy == EGL_NO_DISPLAY) {
+            qWarning("QEglContext::display(): Falling back to EGL_DEFAULT_DISPLAY");
+            dpy = eglGetDisplay(EGLNativeDisplayType(EGL_DEFAULT_DISPLAY));
+        }
         if (dpy == EGL_NO_DISPLAY) {
-            qWarning() << "QEglContext::defaultDisplay(): Cannot open EGL display";
+            qWarning("QEglContext::display(): Can't even open the default display");
             return EGL_NO_DISPLAY;
         }
+
         if (!eglInitialize(dpy, NULL, NULL)) {
-            qWarning() << "QEglContext::defaultDisplay(): Cannot initialize EGL display:" << errorString(eglGetError());
+            qWarning() << "QEglContext::display(): Cannot initialize EGL display:" << errorString(eglGetError());
             return EGL_NO_DISPLAY;
         }
-#ifdef EGL_OPENGL_ES_API
-        eglBindAPI(EGL_OPENGL_ES_API);
-#endif
     }
+
     return dpy;
 }
 
+#if !defined(Q_WS_X11) && !defined(Q_WS_WINCE) // WinCE & X11 implement this properly
+EGLNativeDisplayType QEglContext::nativeDisplay()
+{
+    return EGL_DEFAULT_DISPLAY;
+}
+#endif
+
 // Return the error string associated with a specific code.
 QString QEglContext::errorString(EGLint code)
 {
@@ -410,7 +414,7 @@ void QEglContext::dumpAllConfigs()
 {
     QEglProperties props;
     EGLint count = 0;
-    if (!eglGetConfigs(dpy, 0, 0, &count) || count < 1)
+    if (!eglGetConfigs(display(), 0, 0, &count) || count < 1)
         return;
     EGLConfig *configs = new EGLConfig [count];
     eglGetConfigs(dpy, configs, count, &count);
@@ -423,7 +427,7 @@ void QEglContext::dumpAllConfigs()
 
 QString QEglContext::extensions()
 {
-    const char* exts = eglQueryString(QEglContext::defaultDisplay(0), EGL_EXTENSIONS);
+    const char* exts = eglQueryString(QEglContext::display(), EGL_EXTENSIONS);
     return QString(QLatin1String(exts));
 }
 
@@ -431,7 +435,7 @@ bool QEglContext::hasExtension(const char* extensionName)
 {
     QList<QByteArray> extensions =
         QByteArray(reinterpret_cast<const char *>
-            (eglQueryString(QEglContext::defaultDisplay(0), EGL_EXTENSIONS))).split(' ');
+            (eglQueryString(QEglContext::display(), EGL_EXTENSIONS))).split(' ');
     return extensions.contains(extensionName);
 }
 
diff --git a/src/gui/egl/qegl_p.h b/src/gui/egl/qegl_p.h
index a7de9c8..87ed818 100644
--- a/src/gui/egl/qegl_p.h
+++ b/src/gui/egl/qegl_p.h
@@ -86,14 +86,12 @@ public:
     QEgl::API api() const { return apiType; }
     void setApi(QEgl::API api) { apiType = api; }
 
-    bool openDisplay(QPaintDevice *device);
     bool chooseConfig(const QEglProperties& properties, QEgl::PixelFormatMatch match = QEgl::ExactPixelFormat);
     bool createContext(QEglContext *shareContext = 0, const QEglProperties *properties = 0);
+    void destroyContext();
     EGLSurface createSurface(QPaintDevice *device, const QEglProperties *properties = 0);
     void destroySurface(EGLSurface surface);
 
-    void destroy();
-
     bool makeCurrent(EGLSurface surface);
     bool doneCurrent();
     bool lazyDoneCurrent();
@@ -108,7 +106,7 @@ public:
     static EGLint error() { return eglGetError(); }
     static QString errorString(EGLint code);
 
-    EGLDisplay display() const { return dpy; }
+    static EGLDisplay display();
 
     EGLContext context() const { return ctx; }
     void setContext(EGLContext context) { ctx = context; ownsContext = false;}
@@ -118,8 +116,6 @@ public:
 
     QEglProperties configProperties(EGLConfig cfg = 0) const;
 
-    static EGLDisplay defaultDisplay(QPaintDevice *device);
-
     void dumpAllConfigs();
 
     static QString extensions();
@@ -127,7 +123,6 @@ public:
 
 private:
     QEgl::API apiType;
-    EGLDisplay dpy;
     EGLContext ctx;
     EGLConfig cfg;
     EGLSurface currentSurface;
@@ -135,7 +130,8 @@ private:
     bool ownsContext;
     bool sharing;
 
-    static EGLDisplay getDisplay(QPaintDevice *device);
+    static EGLDisplay dpy;
+    static EGLNativeDisplayType nativeDisplay();
 
     static QEglContext *currentContext(QEgl::API api);
     static void setCurrentContext(QEgl::API api, QEglContext *context);
diff --git a/src/gui/egl/qegl_qws.cpp b/src/gui/egl/qegl_qws.cpp
index e999e0b..2a61beb 100644
--- a/src/gui/egl/qegl_qws.cpp
+++ b/src/gui/egl/qegl_qws.cpp
@@ -64,12 +64,6 @@ EGLSurface QEglContext::createSurface(QPaintDevice *device, const QEglProperties
     return EGL_NO_SURFACE;
 }
 
-EGLDisplay QEglContext::getDisplay(QPaintDevice *device)
-{
-    Q_UNUSED(device);
-    return eglGetDisplay(EGLNativeDisplayType(EGL_DEFAULT_DISPLAY));
-}
-
 static QScreen *screenForDevice(QPaintDevice *device)
 {
     QScreen *screen = qt_screen;
diff --git a/src/gui/egl/qegl_symbian.cpp b/src/gui/egl/qegl_symbian.cpp
index 44ecd19..b1c9408 100644
--- a/src/gui/egl/qegl_symbian.cpp
+++ b/src/gui/egl/qegl_symbian.cpp
@@ -86,14 +86,6 @@ EGLSurface QEglContext::createSurface(QPaintDevice *device, const QEglProperties
     return surf;
 }
 
-EGLDisplay QEglContext::getDisplay(QPaintDevice *device)
-{
-    EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
-    if (dpy == EGL_NO_DISPLAY)
-        qWarning("QEglContext::defaultDisplay(): Falling back to EGL_DEFAULT_DISPLAY");
-    return dpy;
-}
-
 // Set pixel format and other properties based on a paint device.
 void QEglProperties::setPaintDeviceFormat(QPaintDevice *dev)
 {
diff --git a/src/gui/egl/qegl_wince.cpp b/src/gui/egl/qegl_wince.cpp
index 026a7b1..c9c9773 100644
--- a/src/gui/egl/qegl_wince.cpp
+++ b/src/gui/egl/qegl_wince.cpp
@@ -87,20 +87,15 @@ EGLSurface QEglContext::createSurface(QPaintDevice *device, const QEglProperties
     return surf;
 }
 
-EGLDisplay QEglContext::getDisplay(QPaintDevice *device)
+EGLNativeDisplayType QEglContext::nativeDisplay()
 {
-    EGLDisplay dpy = 0;
     HWND win = (static_cast<QWidget*>(device))->winId();
     HDC myDc = GetDC(win);
     if (!myDc) {
-        qWarning("QEglContext::defaultDisplay(): WinCE display is not open");
+        qWarning("QEglContext::nativeDisplay(): WinCE display is not open");
+        return EGL_DEFAULT_DISPLAY;
     }
-    dpy = eglGetDisplay(EGLNativeDisplayType(myDc));
-    if (dpy == EGL_NO_DISPLAY) {
-        qWarning("QEglContext::defaultDisplay(): Falling back to EGL_DEFAULT_DISPLAY");
-        dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
-    }
-    return dpy;
+    return EGLNativeDisplayType(myDc);
 }
 
 // Set pixel format and other properties based on a paint device.
diff --git a/src/gui/egl/qegl_x11.cpp b/src/gui/egl/qegl_x11.cpp
index 2cf4e33..634ff13 100644
--- a/src/gui/egl/qegl_x11.cpp
+++ b/src/gui/egl/qegl_x11.cpp
@@ -93,15 +93,14 @@ EGLSurface QEglContext::createSurface(QPaintDevice *device, const QEglProperties
     return surf;
 }
 
-EGLDisplay QEglContext::getDisplay(QPaintDevice *device)
+EGLNativeDisplayType QEglContext::nativeDisplay()
 {
-    Q_UNUSED(device);
     Display *xdpy = QX11Info::display();
     if (!xdpy) {
         qWarning("QEglContext::getDisplay(): X11 display is not open");
-        return EGL_NO_DISPLAY;
+        return EGLNativeDisplayType(EGL_DEFAULT_DISPLAY);
     }
-    return eglGetDisplay(EGLNativeDisplayType(xdpy));
+    return EGLNativeDisplayType(xdpy);
 }
 
 static int countBits(unsigned long mask)
diff --git a/src/gui/egl/qeglproperties.cpp b/src/gui/egl/qeglproperties.cpp
index 2915fb9..236ec37 100644
--- a/src/gui/egl/qeglproperties.cpp
+++ b/src/gui/egl/qeglproperties.cpp
@@ -60,7 +60,7 @@ QEglProperties::QEglProperties(EGLConfig cfg)
     props.append(EGL_NONE);
     for (int name = 0x3020; name <= 0x304F; ++name) {
         EGLint value;
-        if (name != EGL_NONE && eglGetConfigAttrib(QEglContext::defaultDisplay(0), cfg, name, &value))
+        if (name != EGL_NONE && eglGetConfigAttrib(QEglContext::display(), cfg, name, &value))
             setValue(name, value);
     }
     eglGetError();  // Clear the error state.
@@ -273,12 +273,12 @@ static void addTag(QString& str, const QString& tag)
 void QEglProperties::dumpAllConfigs()
 {
     EGLint count = 0;
-    eglGetConfigs(QEglContext::defaultDisplay(0), 0, 0, &count);
+    eglGetConfigs(QEglContext::display(), 0, 0, &count);
     if (count < 1)
         return;
 
     EGLConfig *configs = new EGLConfig [count];
-    eglGetConfigs(QEglContext::defaultDisplay(0), configs, count, &count);
+    eglGetConfigs(QEglContext::display(), configs, count, &count);
     for (EGLint index = 0; index < count; ++index)
         qWarning() << QEglProperties(configs[index]).toString();
     delete [] configs;
diff --git a/src/gui/image/qimagepixmapcleanuphooks.cpp b/src/gui/image/qimagepixmapcleanuphooks.cpp
index ace4bb6..517fcb0 100644
--- a/src/gui/image/qimagepixmapcleanuphooks.cpp
+++ b/src/gui/image/qimagepixmapcleanuphooks.cpp
@@ -122,19 +122,32 @@ void QImagePixmapCleanupHooks::executeImageHooks(qint64 key)
         qt_image_cleanup_hook_64(key);
 }
 
-void QImagePixmapCleanupHooks::enableCleanupHooks(const QPixmap &pixmap)
-{
-    enableCleanupHooks(const_cast<QPixmap &>(pixmap).data_ptr().data());
-}
 
 void QImagePixmapCleanupHooks::enableCleanupHooks(QPixmapData *pixmapData)
 {
     pixmapData->is_cached = true;
 }
 
+void QImagePixmapCleanupHooks::enableCleanupHooks(const QPixmap &pixmap)
+{
+    enableCleanupHooks(const_cast<QPixmap &>(pixmap).data_ptr().data());
+}
+
 void QImagePixmapCleanupHooks::enableCleanupHooks(const QImage &image)
 {
     const_cast<QImage &>(image).data_ptr()->is_cached = true;
 }
 
+bool QImagePixmapCleanupHooks::isImageCached(const QImage &image)
+{
+    return const_cast<QImage &>(image).data_ptr()->is_cached;
+}
+
+bool QImagePixmapCleanupHooks::isPixmapCached(const QPixmap &pixmap)
+{
+    return const_cast<QPixmap&>(pixmap).data_ptr().data()->is_cached;
+}
+
+
+
 QT_END_NAMESPACE
diff --git a/src/gui/image/qimagepixmapcleanuphooks_p.h b/src/gui/image/qimagepixmapcleanuphooks_p.h
index 88dd3a6..eae11f4 100644
--- a/src/gui/image/qimagepixmapcleanuphooks_p.h
+++ b/src/gui/image/qimagepixmapcleanuphooks_p.h
@@ -72,6 +72,9 @@ public:
     static void enableCleanupHooks(const QPixmap &pixmap);
     static void enableCleanupHooks(QPixmapData *pixmapData);
 
+    static bool isImageCached(const QImage &image);
+    static bool isPixmapCached(const QPixmap &pixmap);
+
     // Gets called when a pixmap data is about to be modified:
     void addPixmapDataModificationHook(_qt_pixmap_cleanup_hook_pmd);
 
diff --git a/src/gui/image/qpixmap.cpp b/src/gui/image/qpixmap.cpp
index d1e5c40..1df7946 100644
--- a/src/gui/image/qpixmap.cpp
+++ b/src/gui/image/qpixmap.cpp
@@ -1670,10 +1670,9 @@ QPixmap QPixmap::transformed(const QMatrix &matrix, Qt::TransformationMode mode)
     \o
 
     The hasAlphaChannel() returns true if the pixmap has a format that
-    respects the alpha channel, otherwise returns false, while the
-    hasAlpha() function returns true if the pixmap has an alpha
-    channel \e or a mask (otherwise false). The mask() function returns
-    the mask as a QBitmap object, which can be set using setMask().
+    respects the alpha channel, otherwise returns false. The hasAlpha(),
+    setMask() and mask() functions are legacy and should not be used.
+    They are potentially very slow.
 
     The createHeuristicMask() function creates and returns a 1-bpp
     heuristic mask (i.e. a QBitmap) for this pixmap. It works by
@@ -1760,6 +1759,8 @@ QPixmap QPixmap::transformed(const QMatrix &matrix, Qt::TransformationMode mode)
     Returns true if this pixmap has an alpha channel, \e or has a
     mask, otherwise returns false.
 
+    \warning This is potentially an expensive operation.
+
     \sa hasAlphaChannel(), mask()
 */
 bool QPixmap::hasAlpha() const
diff --git a/src/gui/painting/qcups.cpp b/src/gui/painting/qcups.cpp
index 7903762..ac41692 100644
--- a/src/gui/painting/qcups.cpp
+++ b/src/gui/painting/qcups.cpp
@@ -342,7 +342,9 @@ bool QCUPSSupport::printerHasPPD(const char *printerName)
 {
     if (!isAvailable())
         return false;
-    return _cupsGetPPD(printerName) != 0;
+    const char *ppdFile = _cupsGetPPD(printerName);
+    unlink(ppdFile);
+    return (ppdFile != 0);
 }
 
 QString QCUPSSupport::unicodeString(const char *s)
diff --git a/src/gui/painting/qpainter.cpp b/src/gui/painting/qpainter.cpp
index 3bcaf8c..075c457 100644
--- a/src/gui/painting/qpainter.cpp
+++ b/src/gui/painting/qpainter.cpp
@@ -708,13 +708,14 @@ void QPainterPrivate::updateEmulationSpecifier(QPainterState *s)
         bool penTextureAlpha = false;
         if (penBrush.style() == Qt::TexturePattern)
             penTextureAlpha = qHasPixmapTexture(penBrush)
-                              ? penBrush.texture().hasAlpha()
+                              ? (penBrush.texture().depth() > 1) && penBrush.texture().hasAlpha()
                               : penBrush.textureImage().hasAlphaChannel();
         bool brushTextureAlpha = false;
-        if (s->brush.style() == Qt::TexturePattern)
+        if (s->brush.style() == Qt::TexturePattern) {
             brushTextureAlpha = qHasPixmapTexture(s->brush)
-                                ? s->brush.texture().hasAlpha()
+                                ? (s->brush.texture().depth() > 1) && s->brush.texture().hasAlpha()
                                 : s->brush.textureImage().hasAlphaChannel();
+        }
         if (((penBrush.style() == Qt::TexturePattern && penTextureAlpha)
              || (s->brush.style() == Qt::TexturePattern && brushTextureAlpha))
             && !engine->hasFeature(QPaintEngine::MaskedBrush))
diff --git a/src/gui/text/qfontdatabase_win.cpp b/src/gui/text/qfontdatabase_win.cpp
index 05c8f08..a6ceee1 100644
--- a/src/gui/text/qfontdatabase_win.cpp
+++ b/src/gui/text/qfontdatabase_win.cpp
@@ -336,8 +336,18 @@ void addFontToDatabase(QString familyName, const QString &scriptName,
                 signature->fsCsb[0], signature->fsCsb[1]
             };
             QList<QFontDatabase::WritingSystem> systems = determineWritingSystemsFromTrueTypeBits(unicodeRange, codePageRange);
-            for (int i = 0; i < systems.count(); ++i)
-                family->writingSystems[systems.at(i)] = QtFontFamily::Supported;
+
+            for (int i = 0; i < systems.count(); ++i) {
+                QFontDatabase::WritingSystem writingSystem = systems.at(i);
+
+                // ### Hack to work around problem with Thai text on Windows 7. Segoe UI contains
+                // the symbol for Baht, and Windows thus reports that it supports the Thai script.
+                // Since it's the default UI font on this platform, most widgets will be unable to
+                // display Thai text by default. As a temporary work around, we special case Segoe UI
+                // and remove the Thai script from its list of supported writing systems.
+                if (writingSystem != QFontDatabase::Thai || familyName != QLatin1String("Segoe UI"))
+                    family->writingSystems[writingSystem] = QtFontFamily::Supported;
+            }
         } else if (!family->writingSystemCheck) {
             //qDebug("family='%s' script=%s", family->name.latin1(), script.latin1());
             if (scriptName == QLatin1String("Western")
diff --git a/src/network/socket/qlocalsocket_p.h b/src/network/socket/qlocalsocket_p.h
index 081697b..0f1c23c 100644
--- a/src/network/socket/qlocalsocket_p.h
+++ b/src/network/socket/qlocalsocket_p.h
@@ -128,10 +128,8 @@ public:
     void _q_stateChanged(QAbstractSocket::SocketState newState);
     void _q_error(QAbstractSocket::SocketError newError);
 #elif defined(Q_OS_WIN)
-    ~QLocalSocketPrivate() {
-	CloseHandle(overlapped.hEvent);
-    }
-
+    ~QLocalSocketPrivate();
+    void destroyPipeHandles();
     void setErrorString(const QString &function);
     void _q_notified();
     void _q_canWrite();
diff --git a/src/network/socket/qlocalsocket_win.cpp b/src/network/socket/qlocalsocket_win.cpp
index 1f94df6..3283bf2 100644
--- a/src/network/socket/qlocalsocket_win.cpp
+++ b/src/network/socket/qlocalsocket_win.cpp
@@ -110,6 +110,20 @@ QLocalSocketPrivate::QLocalSocketPrivate() : QIODevicePrivate(),
 {
 }
 
+QLocalSocketPrivate::~QLocalSocketPrivate()
+{
+    destroyPipeHandles();
+    CloseHandle(overlapped.hEvent);
+}
+
+void QLocalSocketPrivate::destroyPipeHandles()
+{
+    if (handle != INVALID_HANDLE_VALUE) {
+        DisconnectNamedPipe(handle);
+        CloseHandle(handle);
+    }
+}
+
 void QLocalSocket::connectToServer(const QString &name, OpenMode openMode)
 {
     Q_D(QLocalSocket);
@@ -388,8 +402,7 @@ void QLocalSocket::close()
     d->readSequenceStarted = false;
     d->pendingReadyRead = false;
     d->pipeClosed = false;
-    DisconnectNamedPipe(d->handle);
-    CloseHandle(d->handle);
+    d->destroyPipeHandles();
     d->handle = INVALID_HANDLE_VALUE;
     ResetEvent(d->overlapped.hEvent);
     d->state = UnconnectedState;
@@ -524,7 +537,10 @@ bool QLocalSocket::waitForDisconnected(int msecs)
 bool QLocalSocket::isValid() const
 {
     Q_D(const QLocalSocket);
-    return (d->handle != INVALID_HANDLE_VALUE);
+    if (d->handle == INVALID_HANDLE_VALUE)
+        return false;
+
+    return PeekNamedPipe(d->handle, NULL, 0, NULL, NULL, NULL);
 }
 
 bool QLocalSocket::waitForReadyRead(int msecs)
diff --git a/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp b/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp
index 07f3159..8235a5c 100644
--- a/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp
+++ b/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp
@@ -1231,14 +1231,14 @@ void QGL2PaintEngineEx::drawTextItem(const QPointF &p, const QTextItem &textItem
                                             ? QFontEngineGlyphCache::Type(ti.fontEngine->glyphFormat)
                                             : d->glyphCacheType;
 
-    if (txtype > QTransform::TxTranslate)
-        glyphType = QFontEngineGlyphCache::Raster_A8;
 
-    if (glyphType == QFontEngineGlyphCache::Raster_RGBMask
-        && state()->composition_mode != QPainter::CompositionMode_Source
-        && state()->composition_mode != QPainter::CompositionMode_SourceOver)
-    {
-        drawCached = false;
+    if (glyphType == QFontEngineGlyphCache::Raster_RGBMask) {
+        if (d->device->alphaRequested() || txtype > QTransform::TxTranslate
+            || (state()->composition_mode != QPainter::CompositionMode_Source
+            && state()->composition_mode != QPainter::CompositionMode_SourceOver))
+        {
+            glyphType = QFontEngineGlyphCache::Raster_A8;
+        }
     }
 
     if (drawCached) {
diff --git a/src/opengl/qgl.cpp b/src/opengl/qgl.cpp
index 0a89412..22b0602 100644
--- a/src/opengl/qgl.cpp
+++ b/src/opengl/qgl.cpp
@@ -1594,18 +1594,18 @@ QGLTextureCache::QGLTextureCache()
     Q_ASSERT(qt_gl_texture_cache == 0);
     qt_gl_texture_cache = this;
 
-    QImagePixmapCleanupHooks::instance()->addPixmapDataModificationHook(cleanupTextures);
+    QImagePixmapCleanupHooks::instance()->addPixmapDataModificationHook(cleanupTexturesForPixampData);
     QImagePixmapCleanupHooks::instance()->addPixmapDataDestructionHook(cleanupBeforePixmapDestruction);
-    QImagePixmapCleanupHooks::instance()->addImageHook(imageCleanupHook);
+    QImagePixmapCleanupHooks::instance()->addImageHook(cleanupTexturesForCacheKey);
 }
 
 QGLTextureCache::~QGLTextureCache()
 {
     qt_gl_texture_cache = 0;
 
-    QImagePixmapCleanupHooks::instance()->removePixmapDataModificationHook(cleanupTextures);
+    QImagePixmapCleanupHooks::instance()->removePixmapDataModificationHook(cleanupTexturesForPixampData);
     QImagePixmapCleanupHooks::instance()->removePixmapDataDestructionHook(cleanupBeforePixmapDestruction);
-    QImagePixmapCleanupHooks::instance()->removeImageHook(imageCleanupHook);
+    QImagePixmapCleanupHooks::instance()->removeImageHook(cleanupTexturesForCacheKey);
 }
 
 void QGLTextureCache::insert(QGLContext* ctx, qint64 key, QGLTexture* texture, int cost)
@@ -1661,32 +1661,25 @@ QGLTextureCache* QGLTextureCache::instance()
   a hook that removes textures from the cache when a pixmap/image
   is deref'ed
 */
-void QGLTextureCache::imageCleanupHook(qint64 cacheKey)
+void QGLTextureCache::cleanupTexturesForCacheKey(qint64 cacheKey)
 {
     // ### remove when the GL texture cache becomes thread-safe
-    if (qApp->thread() != QThread::currentThread())
-        return;
-    QGLTexture *texture = instance()->getTexture(cacheKey);
-    if (texture && texture->options & QGLContext::MemoryManagedBindOption)
+    if (qApp->thread() == QThread::currentThread()) {
         instance()->remove(cacheKey);
+        Q_ASSERT(instance()->getTexture(cacheKey) == 0);
+    }
 }
 
 
-void QGLTextureCache::cleanupTextures(QPixmapData* pmd)
+void QGLTextureCache::cleanupTexturesForPixampData(QPixmapData* pmd)
 {
-    // ### remove when the GL texture cache becomes thread-safe
-    if (qApp->thread() == QThread::currentThread()) {
-        const qint64 cacheKey = pmd->cacheKey();
-        QGLTexture *texture = instance()->getTexture(cacheKey);
-        if (texture && texture->options & QGLContext::MemoryManagedBindOption)
-            instance()->remove(cacheKey);
-    }
+    cleanupTexturesForCacheKey(pmd->cacheKey());
 }
 
 void QGLTextureCache::cleanupBeforePixmapDestruction(QPixmapData* pmd)
 {
     // Remove any bound textures first:
-    cleanupTextures(pmd);
+    cleanupTexturesForPixampData(pmd);
 
 #if defined(Q_WS_X11)
     if (pmd->classId() == QPixmapData::X11Class) {
@@ -2087,8 +2080,9 @@ QGLTexture *QGLContextPrivate::bindTexture(const QImage &image, GLenum target, G
     // NOTE: bindTexture(const QImage&, GLenum, GLint, const qint64, bool) should never return null
     Q_ASSERT(texture);
 
-    if (texture->id > 0)
-        QImagePixmapCleanupHooks::enableCleanupHooks(image);
+    // Enable the cleanup hooks for this image so that the texture cache entry is removed when the
+    // image gets deleted:
+    QImagePixmapCleanupHooks::enableCleanupHooks(image);
 
     return texture;
 }
@@ -2142,6 +2136,7 @@ QGLTexture* QGLContextPrivate::bindTexture(const QImage &image, GLenum target, G
     int tx_h = qt_next_power_of_two(image.height());
 
     QImage img = image;
+
     if (!(QGLExtensions::glExtensions() & QGLExtensions::NPOTTextures)
         && !(QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_ES_Version_2_0)
         && (target == GL_TEXTURE_2D && (tx_w != image.width() || tx_h != image.height())))
@@ -2310,6 +2305,7 @@ QGLTexture* QGLContextPrivate::bindTexture(const QImage &image, GLenum target, G
     int cost = img.width()*img.height()*4/1024;
     QGLTexture *texture = new QGLTexture(q, tx_id, target, options);
     QGLTextureCache::instance()->insert(q, key, texture, cost);
+
     return texture;
 }
 
@@ -2426,7 +2422,7 @@ GLuint QGLContext::bindTexture(const QImage &image, GLenum target, GLint format)
         return 0;
 
     Q_D(QGLContext);
-    QGLTexture *texture = d->bindTexture(image, target, format, false, DefaultBindOption);
+    QGLTexture *texture = d->bindTexture(image, target, format, DefaultBindOption);
     return texture->id;
 }
 
@@ -2566,11 +2562,13 @@ void QGLContext::deleteTexture(GLuint id)
     for (int i = 0; i < ddsKeys.size(); ++i) {
         GLuint texture = dds_cache->value(ddsKeys.at(i));
         if (id == texture) {
-            glDeleteTextures(1, &texture);
             dds_cache->remove(ddsKeys.at(i));
-            return;
+            break;
         }
     }
+
+    // Finally, actually delete the texture ID
+    glDeleteTextures(1, &id);
 }
 
 #ifdef Q_MAC_COMPAT_GL_FUNCTIONS
diff --git a/src/opengl/qgl_p.h b/src/opengl/qgl_p.h
index da0887e..0d5a54a 100644
--- a/src/opengl/qgl_p.h
+++ b/src/opengl/qgl_p.h
@@ -540,8 +540,8 @@ public:
 
     static QGLTextureCache *instance();
     static void deleteIfEmpty();
-    static void imageCleanupHook(qint64 cacheKey);
-    static void cleanupTextures(QPixmapData* pixmap);
+    static void cleanupTexturesForCacheKey(qint64 cacheKey);
+    static void cleanupTexturesForPixampData(QPixmapData* pixmap);
     static void cleanupBeforePixmapDestruction(QPixmapData* pixmap);
 
 private:
diff --git a/src/opengl/qgl_qws.cpp b/src/opengl/qgl_qws.cpp
index d4adc8b..fd17a27 100644
--- a/src/opengl/qgl_qws.cpp
+++ b/src/opengl/qgl_qws.cpp
@@ -198,11 +198,6 @@ bool QGLContext::chooseContext(const QGLContext* shareContext)
     // Get the display and initialize it.
     d->eglContext = new QEglContext();
     d->eglContext->setApi(QEgl::OpenGL);
-    if (!d->eglContext->openDisplay(device())) {
-        delete d->eglContext;
-        d->eglContext = 0;
-        return false;
-    }
 
     // Construct the configuration we need for this surface.
     QEglProperties configProps;
diff --git a/src/opengl/qgl_wince.cpp b/src/opengl/qgl_wince.cpp
index 00a125a..f81115c 100644
--- a/src/opengl/qgl_wince.cpp
+++ b/src/opengl/qgl_wince.cpp
@@ -155,11 +155,6 @@ bool QGLContext::chooseContext(const QGLContext* shareContext)
     // Get the display and initialize it.
     d->eglContext = new QEglContext();
     d->eglContext->setApi(QEgl::OpenGL);
-    if (!d->eglContext->openDisplay(device())) {
-        delete d->eglContext;
-        d->eglContext = 0;
-        return false;
-    }
 
     // Construct the configuration we need for this surface.
     QEglProperties configProps;
diff --git a/src/opengl/qgl_x11.cpp b/src/opengl/qgl_x11.cpp
index 61a16be..f0b06ef5 100644
--- a/src/opengl/qgl_x11.cpp
+++ b/src/opengl/qgl_x11.cpp
@@ -1656,8 +1656,11 @@ static bool qt_resolveTextureFromPixmap(QPaintDevice *paintDevice)
         Display *display = xinfo ? xinfo->display() : X11->display;
         int screen = xinfo ? xinfo->screen() : X11->defaultScreen;
 
-        QGLExtensionMatcher extensions(glXQueryExtensionsString(display, screen));
-        if (extensions.match("GLX_EXT_texture_from_pixmap")) {
+        QGLExtensionMatcher serverExtensions(glXQueryExtensionsString(display, screen));
+        QGLExtensionMatcher clientExtensions(glXGetClientString(display, GLX_EXTENSIONS));
+        if (serverExtensions.match("GLX_EXT_texture_from_pixmap")
+            && clientExtensions.match("GLX_EXT_texture_from_pixmap"))
+        {
             glXBindTexImageEXT = (qt_glXBindTexImageEXT) qglx_getProcAddress("glXBindTexImageEXT");
             glXReleaseTexImageEXT = (qt_glXReleaseTexImageEXT) qglx_getProcAddress("glXReleaseTexImageEXT");
         }
diff --git a/src/opengl/qgl_x11egl.cpp b/src/opengl/qgl_x11egl.cpp
index 572834b..3d183ee 100644
--- a/src/opengl/qgl_x11egl.cpp
+++ b/src/opengl/qgl_x11egl.cpp
@@ -190,11 +190,6 @@ bool QGLContext::chooseContext(const QGLContext* shareContext)
     if (d->eglContext == 0) {
         d->eglContext = new QEglContext();
         d->eglContext->setApi(QEgl::OpenGL);
-        if (!d->eglContext->openDisplay(device())) {
-            delete d->eglContext;
-            d->eglContext = 0;
-            return false;
-        }
 
         // Construct the configuration we need for this surface.
         QEglProperties configProps;
@@ -614,7 +609,7 @@ EGLConfig Q_OPENGL_EXPORT qt_chooseEGLConfigForPixmap(bool hasAlpha, bool readOn
 
         EGLint configCount = 0;
         do {
-            eglChooseConfig(QEglContext::defaultDisplay(0), configAttribs.properties(), targetConfig, 1, &configCount);
+            eglChooseConfig(QEglContext::display(), configAttribs.properties(), targetConfig, 1, &configCount);
             if (configCount > 0) {
                 // Got one
                 qDebug() << "Found an" << (hasAlpha ? "ARGB" : "RGB") << (readOnly ? "readonly" : "target" )
@@ -653,7 +648,7 @@ bool Q_OPENGL_EXPORT qt_createEGLSurfaceForPixmap(QPixmapData* pmd, bool readOnl
         pixmapAttribs.setValue(EGL_TEXTURE_FORMAT, EGL_TEXTURE_RGB);
 
     EGLSurface pixmapSurface;
-    pixmapSurface = eglCreatePixmapSurface(QEglContext::defaultDisplay(0),
+    pixmapSurface = eglCreatePixmapSurface(QEglContext::display(),
                                            pixmapConfig,
                                            (EGLNativePixmapType) pixmapData->handle(),
                                            pixmapAttribs.properties());
@@ -762,7 +757,7 @@ void QGLContextPrivate::destroyGlSurfaceForPixmap(QPixmapData* pmd)
     QX11PixmapData *pixmapData = static_cast<QX11PixmapData*>(pmd);
     if (pixmapData->gl_surface) {
         EGLBoolean success;
-        success = eglDestroySurface(QEglContext::defaultDisplay(0), (EGLSurface)pixmapData->gl_surface);
+        success = eglDestroySurface(QEglContext::display(), (EGLSurface)pixmapData->gl_surface);
         if (success == EGL_FALSE) {
             qWarning() << "destroyGlSurfaceForPixmap() - Error deleting surface: "
                        << QEglContext::errorString(eglGetError());
@@ -777,7 +772,7 @@ void QGLContextPrivate::unbindPixmapFromTexture(QPixmapData* pmd)
     QX11PixmapData *pixmapData = static_cast<QX11PixmapData*>(pmd);
     if (pixmapData->gl_surface) {
         EGLBoolean success;
-        success = eglReleaseTexImage(QEglContext::defaultDisplay(0),
+        success = eglReleaseTexImage(QEglContext::display(),
                                      (EGLSurface)pixmapData->gl_surface,
                                      EGL_BACK_BUFFER);
         if (success == EGL_FALSE) {
diff --git a/src/opengl/qglframebufferobject.cpp b/src/opengl/qglframebufferobject.cpp
index ce80796..dd6a3d5 100644
--- a/src/opengl/qglframebufferobject.cpp
+++ b/src/opengl/qglframebufferobject.cpp
@@ -329,6 +329,13 @@ void QGLFBOGLPaintDevice::setFBO(QGLFramebufferObject* f,
     } else if (attachment == QGLFramebufferObject::Depth) {
         fboFormat.setDepth(true);
     }
+
+    GLenum format = f->format().internalTextureFormat();
+    reqAlpha = (format != GL_RGB
+#ifndef QT_OPENGL_ES
+                && format != GL_RGB5 && format != GL_RGB8
+#endif
+    );
 }
 
 QGLContext *QGLFBOGLPaintDevice::context() const
diff --git a/src/opengl/qglframebufferobject_p.h b/src/opengl/qglframebufferobject_p.h
index d7f96a5..d8ff012 100644
--- a/src/opengl/qglframebufferobject_p.h
+++ b/src/opengl/qglframebufferobject_p.h
@@ -111,14 +111,16 @@ public:
     virtual QSize size() const {return fbo->size();}
     virtual QGLContext* context() const;
     virtual QGLFormat format() const {return fboFormat;}
+    virtual bool alphaRequested() const { return reqAlpha; }
 
     void setFBO(QGLFramebufferObject* f,
                 QGLFramebufferObject::Attachment attachment);
 
 private:
-    bool wasBound;
     QGLFramebufferObject* fbo;
     QGLFormat fboFormat;
+    bool wasBound;
+    bool reqAlpha;
 };
 
 class QGLFramebufferObjectPrivate
diff --git a/src/opengl/qglpaintdevice.cpp b/src/opengl/qglpaintdevice.cpp
index 7697570..8ba0108 100644
--- a/src/opengl/qglpaintdevice.cpp
+++ b/src/opengl/qglpaintdevice.cpp
@@ -128,6 +128,11 @@ QGLFormat QGLPaintDevice::format() const
     return context()->format();
 }
 
+bool QGLPaintDevice::alphaRequested() const
+{
+    return context()->d_func()->reqFormat.alpha();
+}
+
 
 
 
diff --git a/src/opengl/qglpaintdevice_p.h b/src/opengl/qglpaintdevice_p.h
index 9815467..3d669da 100644
--- a/src/opengl/qglpaintdevice_p.h
+++ b/src/opengl/qglpaintdevice_p.h
@@ -75,6 +75,7 @@ public:
     virtual QGLContext* context() const = 0;
     virtual QGLFormat format() const;
     virtual QSize size() const = 0;
+    virtual bool alphaRequested() const;
 
     // returns the QGLPaintDevice for the given QPaintDevice
     static QGLPaintDevice* getDevice(QPaintDevice*);
diff --git a/src/opengl/qglpixelbuffer_egl.cpp b/src/opengl/qglpixelbuffer_egl.cpp
index ca19011..dbe919d 100644
--- a/src/opengl/qglpixelbuffer_egl.cpp
+++ b/src/opengl/qglpixelbuffer_egl.cpp
@@ -65,13 +65,6 @@ bool QGLPixelBufferPrivate::init(const QSize &size, const QGLFormat &f, QGLWidge
     ctx = new QEglContext();
     ctx->setApi(QEgl::OpenGL);
 
-    // Open the EGL display.
-    if (!ctx->openDisplay(0)) {
-        delete ctx;
-        ctx = 0;
-        return false;
-    }
-
     // Find the shared context.
     QEglContext *shareContext = 0;
     if (shareWidget && shareWidget->d_func()->glcx)
@@ -215,7 +208,7 @@ GLuint QGLPixelBuffer::generateDynamicTexture() const
 bool QGLPixelBuffer::hasOpenGLPbuffers()
 {
     // See if we have at least 1 configuration that matches the default format.
-    EGLDisplay dpy = QEglContext::defaultDisplay(0);
+    EGLDisplay dpy = QEglContext::display();
     if (dpy == EGL_NO_DISPLAY)
         return false;
     QEglProperties configProps;
diff --git a/src/opengl/qpixmapdata_gl.cpp b/src/opengl/qpixmapdata_gl.cpp
index aa80664..653e805 100644
--- a/src/opengl/qpixmapdata_gl.cpp
+++ b/src/opengl/qpixmapdata_gl.cpp
@@ -234,6 +234,11 @@ QSize QGLPixmapGLPaintDevice::size() const
     return data->size();
 }
 
+bool QGLPixmapGLPaintDevice::alphaRequested() const
+{
+    return data->m_hasAlpha;
+}
+
 void QGLPixmapGLPaintDevice::setPixmapData(QGLPixmapData* d)
 {
     data = d;
diff --git a/src/opengl/qpixmapdata_gl_p.h b/src/opengl/qpixmapdata_gl_p.h
index e3ba5f8..c239bcb 100644
--- a/src/opengl/qpixmapdata_gl_p.h
+++ b/src/opengl/qpixmapdata_gl_p.h
@@ -88,6 +88,7 @@ public:
     void endPaint();
     QGLContext* context() const;
     QSize size() const;
+    bool alphaRequested() const;
 
     void setPixmapData(QGLPixmapData*);
 private:
diff --git a/src/opengl/qpixmapdata_x11gl_egl.cpp b/src/opengl/qpixmapdata_x11gl_egl.cpp
index 55aa1d0..229f75a 100644
--- a/src/opengl/qpixmapdata_x11gl_egl.cpp
+++ b/src/opengl/qpixmapdata_x11gl_egl.cpp
@@ -96,14 +96,14 @@ bool QX11GLPixmapData::hasX11GLPixmaps()
 #endif
             EGL_NONE
         };
-        qPixmapARGBSharedEglContext = eglCreateContext(QEglContext::defaultDisplay(0),
+        qPixmapARGBSharedEglContext = eglCreateContext(QEglContext::display(),
                                                        argbConfig, 0, contextAttribs);
 
         if (argbConfig == rgbConfig) {
             // If the configs are the same, we can re-use the same context.
             qPixmapRGBSharedEglContext = qPixmapARGBSharedEglContext;
         } else {
-            qPixmapRGBSharedEglContext = eglCreateContext(QEglContext::defaultDisplay(0),
+            qPixmapRGBSharedEglContext = eglCreateContext(QEglContext::display(),
                                                            rgbConfig, 0, contextAttribs);
         }
 
@@ -114,7 +114,7 @@ bool QX11GLPixmapData::hasX11GLPixmaps()
         if (!qt_createEGLSurfaceForPixmap(argbPixmapData, false))
             break;
 
-        haveX11Pixmaps = eglMakeCurrent(QEglContext::defaultDisplay(0),
+        haveX11Pixmaps = eglMakeCurrent(QEglContext::display(),
                                         (EGLSurface)argbPixmapData->gl_surface,
                                         (EGLSurface)argbPixmapData->gl_surface,
                                         qPixmapARGBSharedEglContext);
@@ -134,7 +134,7 @@ bool QX11GLPixmapData::hasX11GLPixmaps()
             if (!qt_createEGLSurfaceForPixmap(rgbPixmapData, false))
                 break;
 
-            haveX11Pixmaps = eglMakeCurrent(QEglContext::defaultDisplay(0),
+            haveX11Pixmaps = eglMakeCurrent(QEglContext::display(),
                                             (EGLSurface)rgbPixmapData->gl_surface,
                                             (EGLSurface)rgbPixmapData->gl_surface,
                                             qPixmapRGBSharedEglContext);
@@ -147,7 +147,7 @@ bool QX11GLPixmapData::hasX11GLPixmaps()
     } while (0);
 
     if (qPixmapARGBSharedEglContext || qPixmapRGBSharedEglContext) {
-        eglMakeCurrent(QEglContext::defaultDisplay(0),
+        eglMakeCurrent(QEglContext::display(),
                        EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
     }
 
@@ -167,12 +167,12 @@ bool QX11GLPixmapData::hasX11GLPixmaps()
     if (!haveX11Pixmaps) {
         // Clean up the context(s) if we can't use X11GL pixmaps
         if (qPixmapARGBSharedEglContext != EGL_NO_CONTEXT)
-            eglDestroyContext(QEglContext::defaultDisplay(0), qPixmapARGBSharedEglContext);
+            eglDestroyContext(QEglContext::display(), qPixmapARGBSharedEglContext);
 
         if (qPixmapRGBSharedEglContext != qPixmapARGBSharedEglContext &&
             qPixmapRGBSharedEglContext != EGL_NO_CONTEXT)
         {
-            eglDestroyContext(QEglContext::defaultDisplay(0), qPixmapRGBSharedEglContext);
+            eglDestroyContext(QEglContext::display(), qPixmapRGBSharedEglContext);
         }
         qPixmapRGBSharedEglContext = EGL_NO_CONTEXT;
         qPixmapARGBSharedEglContext = EGL_NO_CONTEXT;
@@ -212,7 +212,6 @@ QPaintEngine* QX11GLPixmapData::paintEngine() const
         ctx = new QGLContext(glFormat());
         if (ctx->d_func()->eglContext == 0)
             ctx->d_func()->eglContext = new QEglContext();
-        ctx->d_func()->eglContext->openDisplay(0); // ;-)
         ctx->d_func()->eglContext->setApi(QEgl::OpenGL);
         ctx->d_func()->eglContext->setContext(hasAlphaChannel() ? qPixmapARGBSharedEglContext
                                                                 : qPixmapRGBSharedEglContext);
diff --git a/src/openvg/qwindowsurface_vgegl.cpp b/src/openvg/qwindowsurface_vgegl.cpp
index d92870f..9c44545 100644
--- a/src/openvg/qwindowsurface_vgegl.cpp
+++ b/src/openvg/qwindowsurface_vgegl.cpp
@@ -225,10 +225,6 @@ static QEglContext *createContext(QPaintDevice *device)
     // Create the context object and open the display.
     context = new QEglContext();
     context->setApi(QEgl::OpenVG);
-    if (!context->openDisplay(device)) {
-        delete context;
-        return 0;
-    }
 
     // Set the swap interval for the display.
     QByteArray interval = qgetenv("QT_VG_SWAP_INTERVAL");
diff --git a/src/plugins/qpluginbase.pri b/src/plugins/qpluginbase.pri
index 3af8b40..3fd3657 100644
--- a/src/plugins/qpluginbase.pri
+++ b/src/plugins/qpluginbase.pri
@@ -1,6 +1,6 @@
 TEMPLATE = lib
 isEmpty(QT_MAJOR_VERSION) {
-   VERSION=4.6.2
+   VERSION=4.6.3
 } else {
    VERSION=$${QT_MAJOR_VERSION}.$${QT_MINOR_VERSION}.$${QT_PATCH_VERSION}
 }
diff --git a/src/qbase.pri b/src/qbase.pri
index 710a2b6..db55365 100644
--- a/src/qbase.pri
+++ b/src/qbase.pri
@@ -4,7 +4,7 @@ INCLUDEPATH *= $$QMAKE_INCDIR_QT/$$TARGET #just for today to have some compat
 isEmpty(QT_ARCH):!isEmpty(ARCH):QT_ARCH=$$ARCH #another compat that will rot for change #215700
 TEMPLATE	= lib
 isEmpty(QT_MAJOR_VERSION) {
-   VERSION=4.6.2
+   VERSION=4.6.3
 } else {
    VERSION=$${QT_MAJOR_VERSION}.$${QT_MINOR_VERSION}.$${QT_PATCH_VERSION}
 }
diff --git a/src/testlib/qtestcase.cpp b/src/testlib/qtestcase.cpp
index 1c2db2f..5eff8a8 100644
--- a/src/testlib/qtestcase.cpp
+++ b/src/testlib/qtestcase.cpp
@@ -1113,6 +1113,14 @@ static void qParseArgs(int argc, char *argv[])
 #endif
         } else if (strcmp(argv[i], "-qws") == 0) {
             // do nothing
+        } else if (strcmp(argv[i], "-graphicssystem") == 0) {
+            // do nothing
+            if (i + 1 >= argc) {
+                printf("-graphicssystem needs an extra parameter specifying the graphics system\n");
+                exit(1);
+            } else {
+                ++i;
+            }
         } else if (argv[i][0] == '-') {
             printf("Unknown option: '%s'\n\n%s", argv[i], testOptions);
             exit(1);