Merge branch 'texture_from_pixmap'

16 files changed, 586 insertions, 142 deletions

diff --git a/src/gui/egl/qegl.cpp b/src/gui/egl/qegl.cpp
index 89d9d1b..ebdac9a 100644
--- a/src/gui/egl/qegl.cpp
+++ b/src/gui/egl/qegl.cpp
@@ -400,4 +400,15 @@ void QEglContext::dumpAllConfigs()
     delete [] configs;
 }
 
+QString QEglContext::extensions()
+{
+    const char* exts = eglQueryString(dpy, EGL_EXTENSIONS);
+    return QString(QLatin1String(exts));
+}
+
+bool QEglContext::hasExtension(const char* extensionName)
+{
+    return extensions().contains(QLatin1String(extensionName));
+}
+
 QT_END_NAMESPACE
diff --git a/src/gui/egl/qegl_p.h b/src/gui/egl/qegl_p.h
index ddf7d27..3ae1489 100644
--- a/src/gui/egl/qegl_p.h
+++ b/src/gui/egl/qegl_p.h
@@ -122,6 +122,9 @@ public:
 
     void dumpAllConfigs();
 
+    QString extensions();
+    bool hasExtension(const char* extensionName);
+
 private:
     QEgl::API apiType;
     EGLDisplay dpy;
diff --git a/src/gui/image/image.pri b/src/gui/image/image.pri
index bf348af..b9c36dc 100644
--- a/src/gui/image/image.pri
+++ b/src/gui/image/image.pri
@@ -25,7 +25,9 @@ HEADERS += \
 	image/qpixmapcache_p.h \
         image/qpixmapdata_p.h \
         image/qpixmapdatafactory_p.h \
-        image/qpixmapfilter_p.h
+        image/qpixmapfilter_p.h \
+        image/qimagepixmapcleanuphooks_p.h \
+
 
 SOURCES += \
         image/qbitmap.cpp \
@@ -47,6 +49,8 @@ SOURCES += \
         image/qmovie.cpp \
         image/qpixmap_raster.cpp \
         image/qnativeimage.cpp \
+        image/qimagepixmapcleanuphooks.cpp \
+
 
 win32 {
     SOURCES += image/qpixmap_win.cpp
diff --git a/src/gui/image/qimage.cpp b/src/gui/image/qimage.cpp
index e8ca7a9..bb77fb5 100644
--- a/src/gui/image/qimage.cpp
+++ b/src/gui/image/qimage.cpp
@@ -49,6 +49,7 @@
 #include "qimagewriter.h"
 #include "qstringlist.h"
 #include "qvariant.h"
+#include "qimagepixmapcleanuphooks_p.h"
 #include <ctype.h>
 #include <stdlib.h>
 #include <limits.h>
@@ -106,14 +107,6 @@ static inline bool checkPixelSize(const QImage::Format format)
     }
 
 
-// ### Qt 5: remove
-typedef void (*_qt_image_cleanup_hook)(int);
-Q_GUI_EXPORT _qt_image_cleanup_hook qt_image_cleanup_hook = 0;
-
-// ### Qt 5: rename
-typedef void (*_qt_image_cleanup_hook_64)(qint64);
-Q_GUI_EXPORT _qt_image_cleanup_hook_64 qt_image_cleanup_hook_64 = 0;
-
 static QImage rotated90(const QImage &src);
 static QImage rotated180(const QImage &src);
 static QImage rotated270(const QImage &src);
@@ -257,8 +250,8 @@ QImageData * QImageData::create(const QSize &size, QImage::Format format, int nu
 
 QImageData::~QImageData()
 {
-    if (is_cached && qt_image_cleanup_hook_64)
-        qt_image_cleanup_hook_64((((qint64) ser_no) << 32) | ((qint64) detach_no));
+    if (is_cached)
+        QImagePixmapCleanupHooks::executeImageHooks((((qint64) ser_no) << 32) | ((qint64) detach_no));
     delete paintEngine;
     if (data && own_data)
         free(data);
@@ -1342,8 +1335,8 @@ QImage::operator QVariant() const
 void QImage::detach()
 {
     if (d) {
-        if (d->is_cached && qt_image_cleanup_hook_64 && d->ref == 1)
-            qt_image_cleanup_hook_64(cacheKey());
+        if (d->is_cached && d->ref == 1)
+            QImagePixmapCleanupHooks::executeImageHooks(cacheKey());
 
         if (d->ref != 1 || d->ro_data)
             *this = copy();
diff --git a/src/gui/image/qimagepixmapcleanuphooks.cpp b/src/gui/image/qimagepixmapcleanuphooks.cpp
new file mode 100644
index 0000000..7d1c5fb
--- /dev/null
+++ b/src/gui/image/qimagepixmapcleanuphooks.cpp
@@ -0,0 +1,110 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the 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 http://www.qtsoftware.com/contact.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qimagepixmapcleanuphooks_p.h"
+#include "qpixmapdata_p.h"
+
+
+// Legacy, single instance hooks: ### Qt 5: remove
+typedef void (*_qt_pixmap_cleanup_hook)(int);
+typedef void (*_qt_pixmap_cleanup_hook_64)(qint64);
+typedef void (*_qt_image_cleanup_hook)(int);
+Q_GUI_EXPORT _qt_pixmap_cleanup_hook qt_pixmap_cleanup_hook = 0;
+Q_GUI_EXPORT _qt_pixmap_cleanup_hook_64 qt_pixmap_cleanup_hook_64 = 0;
+Q_GUI_EXPORT _qt_image_cleanup_hook qt_image_cleanup_hook = 0;
+Q_GUI_EXPORT _qt_image_cleanup_hook_64 qt_image_cleanup_hook_64 = 0;
+
+
+QImagePixmapCleanupHooks* qt_image_and_pixmap_cleanup_hooks = 0;
+
+
+QImagePixmapCleanupHooks::QImagePixmapCleanupHooks()
+{
+    qt_image_and_pixmap_cleanup_hooks = this;
+}
+
+QImagePixmapCleanupHooks *QImagePixmapCleanupHooks::instance()
+{
+    if (!qt_image_and_pixmap_cleanup_hooks)
+        qt_image_and_pixmap_cleanup_hooks = new QImagePixmapCleanupHooks;
+    return qt_image_and_pixmap_cleanup_hooks;
+}
+
+void QImagePixmapCleanupHooks::addPixmapHook(_qt_pixmap_cleanup_hook_pm hook)
+{
+    pixmapHooks.append(hook);
+}
+
+void QImagePixmapCleanupHooks::addImageHook(_qt_image_cleanup_hook_64 hook)
+{
+    imageHooks.append(hook);
+}
+
+void QImagePixmapCleanupHooks::removePixmapHook(_qt_pixmap_cleanup_hook_pm hook)
+{
+    pixmapHooks.removeAll(hook);
+}
+
+void QImagePixmapCleanupHooks::removeImageHook(_qt_image_cleanup_hook_64 hook)
+{
+    imageHooks.removeAll(hook);
+}
+
+
+void QImagePixmapCleanupHooks::executePixmapHooks(QPixmap* pm)
+{
+    for (int i = 0; i < qt_image_and_pixmap_cleanup_hooks->pixmapHooks.count(); ++i)
+        qt_image_and_pixmap_cleanup_hooks->pixmapHooks[i](pm);
+
+    if (qt_pixmap_cleanup_hook_64)
+        qt_pixmap_cleanup_hook_64(pm->cacheKey());
+}
+
+
+void QImagePixmapCleanupHooks::executeImageHooks(qint64 key)
+{
+    for (int i = 0; i < qt_image_and_pixmap_cleanup_hooks->imageHooks.count(); ++i)
+        qt_image_and_pixmap_cleanup_hooks->imageHooks[i](key);
+
+    if (qt_image_cleanup_hook_64)
+        qt_image_cleanup_hook_64(key);
+}
+
diff --git a/src/gui/image/qimagepixmapcleanuphooks_p.h b/src/gui/image/qimagepixmapcleanuphooks_p.h
new file mode 100644
index 0000000..e765e69
--- /dev/null
+++ b/src/gui/image/qimagepixmapcleanuphooks_p.h
@@ -0,0 +1,89 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the 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 http://www.qtsoftware.com/contact.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QIMAGEPIXMAP_CLEANUPHOOKS_P_H
+#define QIMAGEPIXMAP_CLEANUPHOOKS_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtGui/qpixmap.h>
+
+QT_BEGIN_NAMESPACE
+
+typedef void (*_qt_image_cleanup_hook_64)(qint64);
+typedef void (*_qt_pixmap_cleanup_hook_pm)(QPixmap*);
+
+class QImagePixmapCleanupHooks;
+extern QImagePixmapCleanupHooks* qt_image_and_pixmap_cleanup_hooks;
+
+class Q_GUI_EXPORT QImagePixmapCleanupHooks
+{
+public:
+    QImagePixmapCleanupHooks();
+
+    static QImagePixmapCleanupHooks *instance();
+
+    void addPixmapHook(_qt_pixmap_cleanup_hook_pm);
+    void addImageHook(_qt_image_cleanup_hook_64);
+
+    void removePixmapHook(_qt_pixmap_cleanup_hook_pm);
+    void removeImageHook(_qt_image_cleanup_hook_64);
+
+    static void executePixmapHooks(QPixmap*);
+    static void executeImageHooks(qint64 key);
+
+private:
+    QList<_qt_image_cleanup_hook_64> imageHooks;
+    QList<_qt_pixmap_cleanup_hook_pm> pixmapHooks;
+};
+
+QT_END_NAMESPACE
+
+#endif // QIMAGEPIXMAP_CLEANUPHOOKS_P_H
diff --git a/src/gui/image/qpixmap.cpp b/src/gui/image/qpixmap.cpp
index 18829f4..82835d5 100644
--- a/src/gui/image/qpixmap.cpp
+++ b/src/gui/image/qpixmap.cpp
@@ -43,6 +43,7 @@
 
 #include "qpixmap.h"
 #include "qpixmapdata_p.h"
+#include "qimagepixmapcleanuphooks_p.h"
 
 #include "qbitmap.h"
 #include "qcolormap.h"
@@ -81,14 +82,6 @@
 QT_BEGIN_NAMESPACE
 
 // ### Qt 5: remove
-typedef void (*_qt_pixmap_cleanup_hook)(int);
-Q_GUI_EXPORT _qt_pixmap_cleanup_hook qt_pixmap_cleanup_hook = 0;
-
-// ### Qt 5: rename
-typedef void (*_qt_pixmap_cleanup_hook_64)(qint64);
-Q_GUI_EXPORT _qt_pixmap_cleanup_hook_64 qt_pixmap_cleanup_hook_64 = 0;
-
-// ### Qt 5: remove
 Q_GUI_EXPORT qint64 qt_pixmap_id(const QPixmap &pixmap)
 {
     return pixmap.cacheKey();
@@ -656,7 +649,7 @@ void QPixmap::resize_helper(const QSize &s)
     QX11PixmapData *x11Data = data->classId() == QPixmapData::X11Class ? static_cast<QX11PixmapData*>(data) : 0;
     if (x11Data) {
         pm.x11SetScreen(x11Data->xinfo.screen());
-        uninit = x11Data->uninit;
+        uninit = x11Data->flags & QX11PixmapData::Uninitialized;
     }
 #elif defined(Q_WS_MAC)
     QMacPixmapData *macData = data->classId() == QPixmapData::MacClass ? static_cast<QMacPixmapData*>(data) : 0;
@@ -1357,8 +1350,8 @@ bool QPixmap::isDetached() const
 void QPixmap::deref()
 {
     if (data && !data->ref.deref()) { // Destroy image if last ref
-        if (data->is_cached && qt_pixmap_cleanup_hook_64)
-            qt_pixmap_cleanup_hook_64(cacheKey());
+        if (data->is_cached)
+            QImagePixmapCleanupHooks::executePixmapHooks(this);
         delete data;
         data = 0;
     }
@@ -1897,9 +1890,6 @@ int QPixmap::defaultDepth()
 #endif
 }
 
-typedef void (*_qt_pixmap_cleanup_hook_64)(qint64);
-extern _qt_pixmap_cleanup_hook_64 qt_pixmap_cleanup_hook_64;
-
 /*!
     Detaches the pixmap from shared pixmap data.
 
@@ -1925,8 +1915,8 @@ void QPixmap::detach()
         rasterData->image.detach();
     }
 
-    if (data->is_cached && qt_pixmap_cleanup_hook_64 && data->ref == 1)
-        qt_pixmap_cleanup_hook_64(cacheKey());
+    if (data->is_cached && data->ref == 1)
+        QImagePixmapCleanupHooks::executePixmapHooks(this);
 
 #if defined(Q_WS_MAC)
     QMacPixmapData *macData = id == QPixmapData::MacClass ? static_cast<QMacPixmapData*>(data) : 0;
@@ -1946,7 +1936,7 @@ void QPixmap::detach()
 #if defined(Q_WS_X11)
     if (data->classId() == QPixmapData::X11Class) {
         QX11PixmapData *d = static_cast<QX11PixmapData*>(data);
-        d->uninit = false;
+        d->flags &= ~QX11PixmapData::Uninitialized;
 
         // reset the cache data
         if (d->hd2) {
diff --git a/src/gui/image/qpixmap_x11.cpp b/src/gui/image/qpixmap_x11.cpp
index 86cf515..be3d070 100644
--- a/src/gui/image/qpixmap_x11.cpp
+++ b/src/gui/image/qpixmap_x11.cpp
@@ -313,7 +313,7 @@ int Q_GUI_EXPORT qt_x11_preferred_pixmap_depth = 0;
 
 QX11PixmapData::QX11PixmapData(PixelType type)
     : QPixmapData(type, X11Class), hd(0),
-      uninit(true), read_only(false), x11_mask(0), picture(0), mask_picture(0), hd2(0),
+      flags(Uninitialized), x11_mask(0), picture(0), mask_picture(0), hd2(0), gl_surface(0),
       share_mode(QPixmap::ImplicitlyShared), pengine(0)
 {
 }
@@ -1217,7 +1217,7 @@ void QX11PixmapData::release()
             XFreePixmap(xinfo.display(), hd2);
             hd2 = 0;
         }
-        if (!read_only)
+        if (!(flags & Readonly))
             XFreePixmap(xinfo.display(), hd);
         hd = 0;
     }
@@ -1876,7 +1876,7 @@ QPixmap QX11PixmapData::transformed(const QTransform &transform,
     } else {                                        // color pixmap
         QPixmap pm;
         QX11PixmapData *x11Data = static_cast<QX11PixmapData*>(pm.data);
-        x11Data->uninit = false;
+        x11Data->flags &= ~QX11PixmapData::Uninitialized;
         x11Data->xinfo = xinfo;
         x11Data->d = d;
         x11Data->w = w;
@@ -2018,7 +2018,7 @@ QPixmap QPixmap::grabWindow(WId window, int x, int y, int w, int h)
 
     QPixmap pm(data);
 
-    data->uninit = false;
+    data->flags &= ~QX11PixmapData::Uninitialized;
     pm.x11SetScreen(scr);
 
     GC gc = XCreateGC(dpy, pm.handle(), 0, 0);
@@ -2060,7 +2060,7 @@ QPaintEngine* QX11PixmapData::paintEngine() const
 {
     QX11PixmapData *that = const_cast<QX11PixmapData*>(this);
 
-    if (read_only && share_mode == QPixmap::ImplicitlyShared) {
+    if ((flags & Readonly) && share_mode == QPixmap::ImplicitlyShared) {
         // if someone wants to draw onto us, copy the shared contents
         // and turn it into a fully fledged QPixmap
         ::Pixmap hd_copy = XCreatePixmap(X11->display, RootWindow(X11->display, xinfo.screen()),
@@ -2082,7 +2082,7 @@ QPaintEngine* QX11PixmapData::paintEngine() const
             XFreeGC(X11->display, gc);
         }
         that->hd = hd_copy;
-        that->read_only = false;
+        that->flags &= ~QX11PixmapData::Readonly;
     }
 
     if (!that->pengine)
@@ -2133,7 +2133,7 @@ void QX11PixmapData::copy(const QPixmapData *data, const QRect &rect)
 
     setSerialNumber(++qt_pixmap_serial);
 
-    uninit = false;
+    flags &= ~Uninitialized;
     xinfo = x11Data->xinfo;
     d = x11Data->d;
     w = rect.width();
@@ -2201,7 +2201,7 @@ void QX11PixmapData::convertToARGB32(bool preserveContents)
         return;
 
     // Q_ASSERT(count == 1);
-    if (read_only && share_mode == QPixmap::ExplicitlyShared)
+    if ((flags & Readonly) && share_mode == QPixmap::ExplicitlyShared)
         return;
 
     Pixmap pm = XCreatePixmap(X11->display, RootWindow(X11->display, xinfo.screen()),
@@ -2211,10 +2211,10 @@ void QX11PixmapData::convertToARGB32(bool preserveContents)
     if (picture) {
         if (preserveContents)
             XRenderComposite(X11->display, PictOpSrc, picture, 0, p, 0, 0, 0, 0, 0, 0, w, h);
-        if (!read_only)
+        if (!(flags & Readonly))
             XRenderFreePicture(X11->display, picture);
     }
-    if (hd && !read_only)
+    if (hd && !(flags & Readonly))
         XFreePixmap(X11->display, hd);
     if (x11_mask) {
         XFreePixmap(X11->display, x11_mask);
@@ -2252,9 +2252,8 @@ QPixmap QPixmap::fromX11Pixmap(Qt::HANDLE pixmap, QPixmap::ShareMode mode)
 
     QX11PixmapData *data = new QX11PixmapData(depth == 1 ? QPixmapData::BitmapType : QPixmapData::PixmapType);
     data->setSerialNumber(++qt_pixmap_serial);
-    data->read_only = true;
+    data->flags = QX11PixmapData::Readonly;
     data->share_mode = mode;
-    data->uninit = false;
     data->w = width;
     data->h = height;
     data->is_null = (width <= 0 || height <= 0);
diff --git a/src/gui/image/qpixmap_x11_p.h b/src/gui/image/qpixmap_x11_p.h
index 3de9a0f..835fea4 100644
--- a/src/gui/image/qpixmap_x11_p.h
+++ b/src/gui/image/qpixmap_x11_p.h
@@ -99,6 +99,7 @@ private:
     friend class QX11PaintEngine;
     friend class QX11WindowSurface;
     friend class QRasterWindowSurface;
+    friend class QGLContextPrivate; // Needs to access xinfo, gl_surface & flags
 
     void release();
 
@@ -108,14 +109,21 @@ private:
 
     Qt::HANDLE hd;
 
-    uint uninit : 1;
-    uint read_only : 1;
+    enum Flag {
+         NoFlags = 0x0,
+         Uninitialized = 0x1,
+         Readonly = 0x2,
+         InvertedWhenBoundToTexture = 0x4,
+         GlSurfaceCreatedWithAlpha = 0x8
+    };
+    uint flags;
 
     QX11Info xinfo;
     Qt::HANDLE x11_mask;
     Qt::HANDLE picture;
     Qt::HANDLE mask_picture;
     Qt::HANDLE hd2; // sorted in the default display depth
+    Qt::HANDLE gl_surface;
 #ifndef QT_NO_XRENDER
     void convertToARGB32(bool preserveContents = true);
 #endif
diff --git a/src/gui/image/qpixmapdata_p.h b/src/gui/image/qpixmapdata_p.h
index 29dafaf..32b419e 100644
--- a/src/gui/image/qpixmapdata_p.h
+++ b/src/gui/image/qpixmapdata_p.h
@@ -116,6 +116,7 @@ private:
     friend class QPixmap;
     friend class QGLContextPrivate;
     friend class QX11PixmapData;
+    friend class QGLTextureCache; //Needs to check the reference count
 
     QAtomicInt ref;
     int detach_no;
diff --git a/src/gui/painting/qwindowsurface_x11.cpp b/src/gui/painting/qwindowsurface_x11.cpp
index d8b0d9e..95f6ce3 100644
--- a/src/gui/painting/qwindowsurface_x11.cpp
+++ b/src/gui/painting/qwindowsurface_x11.cpp
@@ -154,7 +154,7 @@ void QX11WindowSurface::setGeometry(const QRect &rect)
 
         QX11PixmapData *oldData = static_cast<QX11PixmapData *>(d_ptr->device.pixmapData());
         Q_ASSERT(oldData);
-        if (!oldData->uninit && hasStaticContents()) {
+        if (!(oldData->flags & QX11PixmapData::Uninitialized) && hasStaticContents()) {
             // Copy the content of the old pixmap into the new one.
             QX11PixmapData *newData = new QX11PixmapData(QPixmapData::PixmapType);
             newData->resize(size.width(), size.height());
@@ -175,7 +175,7 @@ void QX11WindowSurface::setGeometry(const QRect &rect)
                       dx, dy, qMin(boundingRect.width(), size.width()),
                       qMin(boundingRect.height(), size.height()), dx, dy);
             XFreeGC(X11->display, tmpGc);
-            newData->uninit = false;
+            newData->flags &= ~QX11PixmapData::Uninitialized;
 
             d_ptr->device = QPixmap(newData);
         } else {
diff --git a/src/opengl/qgl.cpp b/src/opengl/qgl.cpp
index f6bfcbe..48d09ce 100644
--- a/src/opengl/qgl.cpp
+++ b/src/opengl/qgl.cpp
@@ -86,6 +86,7 @@
 #include <private/qpixmapdata_gl_p.h>
 #include <private/qglpixelbuffer_p.h>
 #include <private/qwindowsurface_gl_p.h>
+#include <private/qimagepixmapcleanuphooks_p.h>
 #include "qcolormap.h"
 #include "qfile.h"
 #include "qlibrary.h"
@@ -1407,15 +1408,17 @@ QGLTextureCache::QGLTextureCache()
 {
     Q_ASSERT(qt_gl_texture_cache == 0);
     qt_gl_texture_cache = this;
-    qt_pixmap_cleanup_hook_64 = cleanupHook;
-    qt_image_cleanup_hook_64 = cleanupHook;
+
+    QImagePixmapCleanupHooks::instance()->addPixmapHook(pixmapCleanupHook);
+    QImagePixmapCleanupHooks::instance()->addImageHook(imageCleanupHook);
 }
 
 QGLTextureCache::~QGLTextureCache()
 {
     qt_gl_texture_cache = 0;
-    qt_pixmap_cleanup_hook_64 = 0;
-    qt_image_cleanup_hook_64 = 0;
+
+    QImagePixmapCleanupHooks::instance()->removePixmapHook(pixmapCleanupHook);
+    QImagePixmapCleanupHooks::instance()->removeImageHook(imageCleanupHook);
 }
 
 void QGLTextureCache::insert(QGLContext* ctx, qint64 key, QGLTexture* texture, int cost)
@@ -1471,7 +1474,7 @@ QGLTextureCache* QGLTextureCache::instance()
   a hook that removes textures from the cache when a pixmap/image
   is deref'ed
 */
-void QGLTextureCache::cleanupHook(qint64 cacheKey)
+void QGLTextureCache::imageCleanupHook(qint64 cacheKey)
 {
     // ### remove when the GL texture cache becomes thread-safe
     if (qApp->thread() != QThread::currentThread())
@@ -1481,6 +1484,24 @@ void QGLTextureCache::cleanupHook(qint64 cacheKey)
         instance()->remove(cacheKey);
 }
 
+
+void QGLTextureCache::pixmapCleanupHook(QPixmap* pixmap)
+{
+    // ### remove when the GL texture cache becomes thread-safe
+    if (qApp->thread() == QThread::currentThread()) {
+        const qint64 cacheKey = pixmap->cacheKey();
+        QGLTexture *texture = instance()->getTexture(cacheKey);
+        if (texture && texture->clean)
+            instance()->remove(cacheKey);
+    }
+#if defined(Q_WS_X11)
+    QPixmapData *pd = pixmap->data_ptr();
+    // Only need to delete the gl surface if the pixmap is about to be deleted
+    if (pd->ref == 0)
+        QGLContextPrivate::destroyGlSurfaceForPixmap(pd);
+#endif
+}
+
 void QGLTextureCache::deleteIfEmpty()
 {
     if (instance()->size() == 0)
@@ -2021,11 +2042,11 @@ QGLTexture *QGLContextPrivate::bindTexture(const QPixmap &pixmap, GLenum target,
 #if defined(Q_WS_X11)
     // Try to use texture_from_pixmap
     if (pd->classId() == QPixmapData::X11Class) {
-        QPixmap *thatPixmap = const_cast<QPixmap*>(&pixmap);
-        texture = bindTextureFromNativePixmap(thatPixmap, key, canInvert);
+        texture = bindTextureFromNativePixmap(pd, key, canInvert);
         if (texture) {
             texture->clean = clean;
-            boundPixmaps.insert(thatPixmap->data_ptr(), QPixmap(pixmap));
+            texture->boundPixmap = pd;
+            boundPixmaps.insert(pd, QPixmap(pixmap));
         }
     }
 #endif
diff --git a/src/opengl/qgl_p.h b/src/opengl/qgl_p.h
index 85dae0d..f21ab93 100644
--- a/src/opengl/qgl_p.h
+++ b/src/opengl/qgl_p.h
@@ -241,7 +241,9 @@ public:
     quint32 gpm;
     int screen;
     QHash<QPixmapData*, QPixmap> boundPixmaps;
-    QGLTexture *bindTextureFromNativePixmap(QPixmap *pm, const qint64 key, bool internal);
+    QGLTexture *bindTextureFromNativePixmap(QPixmapData*, const qint64 key, bool canInvert);
+    static void destroyGlSurfaceForPixmap(QPixmapData*);
+    static void unbindPixmapFromTexture(QPixmapData*);
 #endif
 #if defined(Q_WS_MAC)
     bool update;
@@ -423,7 +425,8 @@ public:
             // is a current context - the context the pixmap was bound to a texture in.
             // Otherwise the release doesn't do anything and you get BadDrawable errors
             // when you come to delete the context.
-            deleteBoundPixmap();
+            if (boundPixmap)
+                QGLContextPrivate::unbindPixmapFromTexture(boundPixmap);
 #endif
             glDeleteTextures(1, &id);
             if (switch_context && current)
@@ -437,9 +440,9 @@ public:
     bool clean;
     bool yInverted; // NOTE: Y-Inverted textures are for internal use only!
 #if defined(Q_WS_X11)
-    Qt::HANDLE boundPixmap;
-    void deleteBoundPixmap(); // in qgl_x11.cpp/qgl_x11egl.cpp
+    QPixmapData* boundPixmap;
 #endif
+
 };
 
 class QGLTextureCache {
@@ -458,7 +461,8 @@ public:
 
     static QGLTextureCache *instance();
     static void deleteIfEmpty();
-    static void cleanupHook(qint64 cacheKey);
+    static void imageCleanupHook(qint64 cacheKey);
+    static void pixmapCleanupHook(QPixmap* pixmap);
 
 private:
     QCache<qint64, QGLTexture> m_cache;
diff --git a/src/opengl/qgl_x11.cpp b/src/opengl/qgl_x11.cpp
index cf70991..4509a64 100644
--- a/src/opengl/qgl_x11.cpp
+++ b/src/opengl/qgl_x11.cpp
@@ -58,11 +58,16 @@
 #include <private/qglpixelbuffer_p.h>
 #endif
 
+// We always define GLX_EXT_texture_from_pixmap ourselves because
+// we can't trust system headers to do it properly
+#define GLX_EXT_texture_from_pixmap 1
+
 #define INT8  dummy_INT8
 #define INT32 dummy_INT32
 #include <GL/glx.h>
 #undef  INT8
 #undef  INT32
+
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #include <X11/Xos.h>
@@ -90,7 +95,7 @@ extern const QX11Info *qt_x11Info(const QPaintDevice *pd);
 #define GLX_SAMPLES_ARB         100001
 #endif
 
-#ifndef GLX_EXT_texture_from_pixmap
+#ifndef GLX_TEXTURE_2D_BIT_EXT
 #define GLX_TEXTURE_2D_BIT_EXT             0x00000002
 #define GLX_TEXTURE_RECTANGLE_BIT_EXT      0x00000004
 #define GLX_BIND_TO_TEXTURE_RGB_EXT        0x20D0
@@ -1548,38 +1553,26 @@ void QGLExtensions::init()
     }
 }
 
-#if !defined(glXBindTexImageEXT)
+// Solaris defines glXBindTexImageEXT as part of the GL library
+#if defined(GLX_VERSION_1_3) && !defined(Q_OS_HPUX)
 typedef void (*qt_glXBindTexImageEXT)(Display*, GLXDrawable, int, const int*);
-static qt_glXBindTexImageEXT glXBindTexImageEXT = 0;
-#endif
-#if !defined(glXReleaseTexImageEXT)
 typedef void (*qt_glXReleaseTexImageEXT)(Display*, GLXDrawable, int);
+static qt_glXBindTexImageEXT glXBindTexImageEXT = 0;
 static qt_glXReleaseTexImageEXT glXReleaseTexImageEXT = 0;
-#endif
-static bool qt_resolved_texture_from_pixmap = false;
 
-QGLTexture *QGLContextPrivate::bindTextureFromNativePixmap(QPixmap *pm, const qint64 key, bool canInvert)
+bool qt_resolveTextureFromPixmap()
 {
-#if !defined(Q_OS_LINUX)
-    return 0;
-#else
-    Q_Q(QGLContext);
-
-    if (pm->data_ptr()->classId() != QPixmapData::X11Class)
-        return 0;
-    QX11PixmapData *pixmapData = static_cast<QX11PixmapData*>(pm->data_ptr());
-    const QX11Info *x11Info = qt_x11Info(pm);
+    static bool resolvedTextureFromPixmap = false;
 
+    if (!resolvedTextureFromPixmap) {
+        resolvedTextureFromPixmap = true;
 
-    // Check to see if we have NPOT texture support
-    // TODO: Use GLX_TEXTURE_RECTANGLE_EXT texture target on systems without npot textures
-    if ( !(QGLExtensions::glExtensions & QGLExtensions::NPOTTextures) &&
-         !(QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_2_0))
-        return 0;
-
-
-    if (!qt_resolved_texture_from_pixmap) {
-        qt_resolved_texture_from_pixmap = true;
+        // Check to see if we have NPOT texture support
+        if ( !(QGLExtensions::glExtensions & QGLExtensions::NPOTTextures) &&
+             !(QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_2_0))
+        {
+            return false; // Can't use TFP without NPOT
+        }
 
         QString glxExt = QLatin1String(glXGetClientString(QX11Info::display(), GLX_EXTENSIONS));
         if (glxExt.contains(QLatin1String("GLX_EXT_texture_from_pixmap"))) {
@@ -1601,81 +1594,139 @@ QGLTexture *QGLContextPrivate::bindTextureFromNativePixmap(QPixmap *pm, const qi
         }
     }
 
-    if (!glXBindTexImageEXT)
-        return 0;
+    return glXBindTexImageEXT && glXReleaseTexImageEXT;
+}
+#endif //defined(GLX_VERSION_1_3) && !defined(Q_OS_HPUX)
 
+
+QGLTexture *QGLContextPrivate::bindTextureFromNativePixmap(QPixmapData *pmd, const qint64 key, bool canInvert)
+{
 #if !defined(GLX_VERSION_1_3) || defined(Q_OS_HPUX)
     return 0;
 #else
-    GLXFBConfig    *configList = 0;
-    GLXFBConfig     glxPixmapConfig;
-    int             configCount = 0;
-    bool            hasAlpha = pixmapData->hasAlphaChannel();
-
-    int configAttribs[] = {
-        hasAlpha ? GLX_BIND_TO_TEXTURE_RGBA_EXT : GLX_BIND_TO_TEXTURE_RGB_EXT, True,
-        GLX_DRAWABLE_TYPE, GLX_PIXMAP_BIT,
-        GLX_BIND_TO_TEXTURE_TARGETS_EXT, GLX_TEXTURE_2D_BIT_EXT,
-        // QGLContext::bindTexture() can't return an inverted texture, but QPainter::drawPixmap() can:
-        GLX_Y_INVERTED_EXT, canInvert ? GLX_DONT_CARE : False,
-        XNone
-//        GLX_BIND_TO_MIPMAP_TEXTURE_EXT, False,
-//        GLX_BIND_TO_TEXTURE_TARGETS_EXT, GLX_TEXTURE_1D_BIT_EXT or GLX_TEXTURE_2D_BIT_EXT or GLX_TEXTURE_RECTANGLE_BIT_EXT
-    };
-    configList = glXChooseFBConfig(x11Info->display(), x11Info->screen(), configAttribs, &configCount);
-    if (!configList)
-        return 0;
-    glxPixmapConfig = configList[0];
-    XFree(configList);
-
-    GLXPixmap glxPixmap;
-    int pixmapAttribs[] = {
-        GLX_TEXTURE_FORMAT_EXT, hasAlpha ? GLX_TEXTURE_FORMAT_RGBA_EXT : GLX_TEXTURE_FORMAT_RGB_EXT,
-        GLX_TEXTURE_TARGET_EXT, GLX_TEXTURE_2D_EXT,
-        GLX_MIPMAP_TEXTURE_EXT, False,
-        XNone
-//        GLX_TEXTURE_FORMAT_EXT, GLX_TEXTURE_FORMAT_RGBA_EXT or GLX_TEXTURE_FORMAT_RGB_EXT or GLX_TEXTURE_FORMAT_NONE_EXT,
-//        GLX_TEXTURE_TARGET_EXT, GLX_TEXTURE_2D_EXT or GLX_TEXTURE_RECTANGLE_EXT,
-//        GLX_MIPMAP_TEXTURE_EXT, True or False,
-    };
+    Q_Q(QGLContext);
 
-    // Wrap the X Pixmap into a GLXPixmap:
-    glxPixmap = glXCreatePixmap(x11Info->display(), glxPixmapConfig, pixmapData->handle(), pixmapAttribs);
+    Q_ASSERT(pmd->classId() == QPixmapData::X11Class);
 
-    if (!glxPixmap)
+    if (!qt_resolveTextureFromPixmap())
         return 0;
 
-    int yInverted;
-    glXGetFBConfigAttrib(x11Info->display(), glxPixmapConfig, GLX_Y_INVERTED_EXT, &yInverted);
+    QX11PixmapData *pixmapData = static_cast<QX11PixmapData*>(pmd);
+    const QX11Info &x11Info = pixmapData->xinfo;
+
+    // Store the configs (Can be static because configs aren't dependent on current context)
+    static GLXFBConfig glxRGBPixmapConfig = 0;
+    static bool RGBConfigInverted = false;
+    static GLXFBConfig glxRGBAPixmapConfig = 0;
+    static bool RGBAConfigInverted = false;
+
+    bool hasAlpha = pixmapData->hasAlphaChannel();
+
+    // Check to see if we need a config
+    if ( (hasAlpha && !glxRGBAPixmapConfig) || (!hasAlpha && !glxRGBPixmapConfig) ) {
+        GLXFBConfig    *configList = 0;
+        int             configCount = 0;
+
+        int configAttribs[] = {
+            hasAlpha ? GLX_BIND_TO_TEXTURE_RGBA_EXT : GLX_BIND_TO_TEXTURE_RGB_EXT, True,
+            GLX_DRAWABLE_TYPE, GLX_PIXMAP_BIT,
+            GLX_BIND_TO_TEXTURE_TARGETS_EXT, GLX_TEXTURE_2D_BIT_EXT,
+            // QGLContext::bindTexture() can't return an inverted texture, but QPainter::drawPixmap() can:
+            GLX_Y_INVERTED_EXT, canInvert ? GLX_DONT_CARE : False,
+            XNone
+        };
+        configList = glXChooseFBConfig(x11Info.display(), x11Info.screen(), configAttribs, &configCount);
+        if (!configList)
+            return 0;
+
+        int yInv;
+        glXGetFBConfigAttrib(x11Info.display(), configList[0], GLX_Y_INVERTED_EXT, &yInv);
+
+        if (hasAlpha) {
+            glxRGBAPixmapConfig = configList[0];
+            RGBAConfigInverted = yInv;
+        }
+        else {
+            glxRGBPixmapConfig = configList[0];
+            RGBConfigInverted = yInv;
+        }
+
+        XFree(configList);
+    }
+
+    // Check to see if the surface is still valid
+    if (pixmapData->gl_surface &&
+        hasAlpha != (pixmapData->flags & QX11PixmapData::GlSurfaceCreatedWithAlpha))
+    {
+        // Surface is invalid!
+        destroyGlSurfaceForPixmap(pixmapData);
+    }
+
+    // Check to see if we need a surface
+    if (!pixmapData->gl_surface) {
+        GLXPixmap glxPixmap;
+        int pixmapAttribs[] = {
+            GLX_TEXTURE_FORMAT_EXT, hasAlpha ? GLX_TEXTURE_FORMAT_RGBA_EXT : GLX_TEXTURE_FORMAT_RGB_EXT,
+            GLX_TEXTURE_TARGET_EXT, GLX_TEXTURE_2D_EXT,
+            GLX_MIPMAP_TEXTURE_EXT, False, // Maybe needs to be don't care
+            XNone
+        };
+
+        // Wrap the X Pixmap into a GLXPixmap:
+        glxPixmap = glXCreatePixmap(x11Info.display(),
+                                    hasAlpha ? glxRGBAPixmapConfig : glxRGBPixmapConfig,
+                                    pixmapData->handle(), pixmapAttribs);
+
+        if (!glxPixmap)
+            return 0;
+
+        pixmapData->gl_surface = (Qt::HANDLE)glxPixmap;
+
+        // Make sure the cleanup hook gets called so we can delete the glx pixmap
+        pixmapData->is_cached = true;
+    }
 
     GLuint textureId;
     glGenTextures(1, &textureId);
     glBindTexture(GL_TEXTURE_2D, textureId);
-    glXBindTexImageEXT(x11Info->display(), glxPixmap, GLX_FRONT_LEFT_EXT, 0);
+    glXBindTexImageEXT(x11Info.display(), (GLXPixmap)pixmapData->gl_surface, GLX_FRONT_LEFT_EXT, 0);
 
     glBindTexture(GL_TEXTURE_2D, textureId);
 
-    QGLTexture *texture = new QGLTexture(q, textureId, GL_TEXTURE_2D, canInvert, yInverted);
-    texture->boundPixmap = glxPixmap;
+    QGLTexture *texture = new QGLTexture(q, textureId, GL_TEXTURE_2D, canInvert, false);
+    texture->yInverted = (hasAlpha && RGBAConfigInverted) || (!hasAlpha && RGBConfigInverted);
+    if (texture->yInverted)
+        pixmapData->flags |= QX11PixmapData::InvertedWhenBoundToTexture;
 
     // We assume the cost of bound pixmaps is zero
     QGLTextureCache::instance()->insert(q, key, texture, 0);
 
     return texture;
 #endif //!defined(GLX_VERSION_1_3) || defined(Q_OS_HPUX)
-#endif //!defined(Q_OS_LINUX
 }
 
-void QGLTexture::deleteBoundPixmap()
+
+void QGLContextPrivate::destroyGlSurfaceForPixmap(QPixmapData* pmd)
 {
-#if defined(GLX_VERSION_1_3) && !defined(Q_OS_HPUX) && defined(Q_OS_LINUX)
-    if (boundPixmap) {
-        glXReleaseTexImageEXT(QX11Info::display(), boundPixmap, GLX_FRONT_LEFT_EXT);
-        glXDestroyPixmap(QX11Info::display(), boundPixmap);
-        boundPixmap = 0;
+#if defined(GLX_VERSION_1_3) && !defined(Q_OS_HPUX)
+    Q_ASSERT(pmd->classId() == QPixmapData::X11Class);
+    QX11PixmapData *pixmapData = static_cast<QX11PixmapData*>(pmd);
+    if (pixmapData->gl_surface) {
+        glXDestroyPixmap(QX11Info::display(), (GLXPixmap)pixmapData->gl_surface);
+        pixmapData->gl_surface = 0;
     }
 #endif
 }
 
+void QGLContextPrivate::unbindPixmapFromTexture(QPixmapData* pmd)
+{
+#if defined(GLX_VERSION_1_3) && !defined(Q_OS_HPUX)
+    Q_ASSERT(pmd->classId() == QPixmapData::X11Class);
+    Q_ASSERT(QGLContext::currentContext());
+    QX11PixmapData *pixmapData = static_cast<QX11PixmapData*>(pmd);
+    if (pixmapData->gl_surface)
+        glXReleaseTexImageEXT(QX11Info::display(), (GLXPixmap)pixmapData->gl_surface, GLX_FRONT_LEFT_EXT);
+#endif
+}
 
 QT_END_NAMESPACE
diff --git a/src/opengl/qgl_x11egl.cpp b/src/opengl/qgl_x11egl.cpp
index c6904fe..5ab3647 100644
--- a/src/opengl/qgl_x11egl.cpp
+++ b/src/opengl/qgl_x11egl.cpp
@@ -41,15 +41,16 @@
 
 #include "qgl.h"
 #include <private/qt_x11_p.h>
+#include <private/qpixmap_x11_p.h>
 #include <private/qgl_p.h>
 #include <private/qpaintengine_opengl_p.h>
 #include "qgl_egl_p.h"
 #include "qcolormap.h"
+#include <QDebug>
 
 
 QT_BEGIN_NAMESPACE
 
-
 bool QGLFormat::hasOpenGL()
 {
     return true;
@@ -486,15 +487,175 @@ void QGLWidgetPrivate::recreateEglSurface(bool force)
     }
 }
 
-QGLTexture *QGLContextPrivate::bindTextureFromNativePixmap(QPixmap *pm, const qint64 key, bool canInvert)
+
+QGLTexture *QGLContextPrivate::bindTextureFromNativePixmap(QPixmapData* pd, const qint64 key, bool canInvert)
 {
-    // TODO
-    return 0;
+    Q_Q(QGLContext);
+
+    Q_ASSERT(pd->classId() == QPixmapData::X11Class);
+
+    static bool checkedForTFP = false;
+    static bool haveTFP = false;
+
+    if (!checkedForTFP) {
+        // Check for texture_from_pixmap egl extension
+        checkedForTFP = true;
+        if (eglContext->hasExtension("EGL_NOKIA_texture_from_pixmap") ||
+            eglContext->hasExtension("EGL_EXT_texture_from_pixmap"))
+        {
+            qDebug("Found texture_from_pixmap EGL extension!");
+            haveTFP = true;
+        }
+    }
+
+    if (!haveTFP)
+        return 0;
+
+    QX11PixmapData *pixmapData = static_cast<QX11PixmapData*>(pd);
+
+    bool hasAlpha = pixmapData->hasAlphaChannel();
+
+    // Check to see if the surface is still valid
+    if (pixmapData->gl_surface &&
+        hasAlpha != (pixmapData->flags & QX11PixmapData::GlSurfaceCreatedWithAlpha))
+    {
+        // Surface is invalid!
+        destroyGlSurfaceForPixmap(pixmapData);
+    }
+
+    EGLint pixmapAttribs[] = {
+        EGL_TEXTURE_TARGET, EGL_TEXTURE_2D,
+        EGL_TEXTURE_FORMAT, hasAlpha ? EGL_TEXTURE_RGBA : EGL_TEXTURE_RGB,
+        EGL_NONE
+    };
+    Q_ASSERT(sizeof(Qt::HANDLE) >= sizeof(EGLSurface)); // Just to make totally sure!
+    if (pixmapData->gl_surface == 0)
+        pixmapData->gl_surface = (Qt::HANDLE)EGL_NO_SURFACE;
+    EGLSurface pixmapSurface = (EGLSurface)pixmapData->gl_surface;
+    static EGLConfig pixmapRGBConfig = 0;
+    static EGLConfig pixmapRGBAConfig = 0;
+
+    // Check to see if we need to find a config
+    if ((hasAlpha && !pixmapRGBAConfig) || (!hasAlpha && !pixmapRGBConfig) ) {
+        const EGLint configAttribs[] = {
+            EGL_SURFACE_TYPE,           EGL_PIXMAP_BIT,
+            EGL_RENDERABLE_TYPE,	EGL_OPENGL_ES2_BIT,
+            EGL_DEPTH_SIZE,		0,
+            hasAlpha ? EGL_BIND_TO_TEXTURE_RGBA : EGL_BIND_TO_TEXTURE_RGB, EGL_TRUE,
+            EGL_NONE
+        };
+
+        EGLint configCount = 0;
+        eglChooseConfig(eglContext->display(), configAttribs, 0, 256, &configCount);
+        if (configCount == 0) {
+            haveTFP = false;
+            qWarning("bindTextureFromNativePixmap() - Couldn't find a suitable config");
+            return 0;
+        }
+
+        EGLConfig *configList = new EGLConfig[configCount];
+        eglChooseConfig(eglContext->display(), configAttribs, configList, configCount, &configCount);
+        Q_ASSERT(configCount);
+
+        // Try to create a pixmap surface for each config until one works
+        for (int i = 0; i < configCount; ++i) {
+            pixmapSurface = eglCreatePixmapSurface(eglContext->display(), configList[i],
+                                                   (EGLNativePixmapType) pixmapData->handle(),
+                                                   pixmapAttribs);
+            if (pixmapSurface != EGL_NO_SURFACE) {
+                // Got one!
+                qDebug() << "Found an" << (hasAlpha ? "ARGB" : "RGB")
+                         << "config (" << int(configList[i]) << ") to create a pixmap surface";
+                if (hasAlpha)
+                    pixmapRGBAConfig = configList[i];
+                else
+                    pixmapRGBConfig = configList[i];
+                pixmapData->gl_surface = (Qt::HANDLE)pixmapSurface;
+                break;
+            }
+        }
+        delete configList;
+
+        if ((hasAlpha && !pixmapRGBAConfig) || (!hasAlpha && !pixmapRGBConfig) ) {
+            qDebug("Couldn't create a pixmap surface with any of the provided configs");
+            haveTFP = false;
+            return 0;
+        }
+    }
+
+    if (pixmapSurface == EGL_NO_SURFACE) {
+        pixmapSurface = eglCreatePixmapSurface(eglContext->display(),
+                                               hasAlpha? pixmapRGBAConfig : pixmapRGBConfig,
+                                               (EGLNativePixmapType) pixmapData->handle(),
+                                               pixmapAttribs);
+        if (pixmapSurface == EGL_NO_SURFACE) {
+            qWarning("Failed to create a pixmap surface using config %d",
+                        (int)(hasAlpha? pixmapRGBAConfig : pixmapRGBConfig));
+            haveTFP = false;
+            return 0;
+        }
+        pixmapData->gl_surface = (Qt::HANDLE)pixmapSurface;
+    }
+
+    // Make sure the cleanup hook gets called so we can delete the glx pixmap
+    pixmapData->is_cached = true;
+    Q_ASSERT(pixmapData->gl_surface);
+
+    GLuint textureId;
+    glGenTextures(1, &textureId);
+    glEnable(GL_TEXTURE_2D);
+    glBindTexture(GL_TEXTURE_2D, textureId);
+
+    // bind the egl pixmap surface to a texture
+    EGLBoolean success;
+    success = eglBindTexImage(eglContext->display(), pixmapSurface, EGL_BACK_BUFFER);
+    if (success == EGL_FALSE) {
+        qWarning() << "eglBindTexImage() failed:" << eglContext->errorString(eglGetError());
+        eglDestroySurface(eglContext->display(), pixmapSurface);
+        pixmapData->gl_surface = (Qt::HANDLE)EGL_NO_SURFACE;
+        haveTFP = false;
+        return 0;
+    }
+
+    QGLTexture *texture = new QGLTexture(q, textureId, GL_TEXTURE_2D, canInvert, true);
+    pixmapData->flags |= QX11PixmapData::InvertedWhenBoundToTexture;
+
+    // We assume the cost of bound pixmaps is zero
+    QGLTextureCache::instance()->insert(q, key, texture, 0);
+
+    glBindTexture(GL_TEXTURE_2D, textureId);
+    return texture;
 }
 
-void QGLTexture::deleteBoundPixmap()
+void QGLContextPrivate::destroyGlSurfaceForPixmap(QPixmapData* pmd)
 {
-    //TODO
+    Q_ASSERT(pmd->classId() == QPixmapData::X11Class);
+    QX11PixmapData *pixmapData = static_cast<QX11PixmapData*>(pmd);
+    if (pixmapData->gl_surface) {
+        EGLBoolean success;
+        success = eglDestroySurface(QEglContext::defaultDisplay(0), (EGLSurface)pixmapData->gl_surface);
+        if (success == EGL_FALSE) {
+            qWarning() << "destroyGlSurfaceForPixmap() - Error deleting surface: "
+                       << QEglContext::errorString(eglGetError());
+        }
+        pixmapData->gl_surface = 0;
+    }
+}
+
+void QGLContextPrivate::unbindPixmapFromTexture(QPixmapData* pmd)
+{
+    Q_ASSERT(pmd->classId() == QPixmapData::X11Class);
+    QX11PixmapData *pixmapData = static_cast<QX11PixmapData*>(pmd);
+    if (pixmapData->gl_surface) {
+        EGLBoolean success;
+        success = eglReleaseTexImage(QEglContext::defaultDisplay(0),
+                                     (EGLSurface)pixmapData->gl_surface,
+                                     EGL_BACK_BUFFER);
+        if (success == EGL_FALSE) {
+            qWarning() << "unbindPixmapFromTexture() - Unable to release bound texture: "
+                       << QEglContext::errorString(eglGetError());
+        }
+    }
 }
 
 QT_END_NAMESPACE
diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.cpp b/src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.cpp
index b264ac0..2ed890b 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.cpp
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.cpp
@@ -53,6 +53,7 @@
 #include <qmath.h>
 #include <private/qpixmapdata_p.h>
 #include <private/qpixmap_raster_p.h>
+#include <private/qimagepixmapcleanuphooks_p.h>
 
 class SurfaceCache;
 class QDirectFBPaintEnginePrivate : public QRasterPaintEnginePrivate
@@ -699,9 +700,7 @@ void QDirectFBPaintEngine::initImageCache(int size)
 {
     Q_ASSERT(size >= 0);
     imageCache.setMaxCost(size);
-    typedef void (*_qt_image_cleanup_hook_64)(qint64);
-    extern Q_GUI_EXPORT _qt_image_cleanup_hook_64 qt_image_cleanup_hook_64;
-    qt_image_cleanup_hook_64 = ::cachedImageCleanupHook;
+    QImagePixmapCleanupHooks::instance()->addImageHook(cachedImageCleanupHook);
 }
 
 #endif // QT_DIRECTFB_IMAGECACHE