Changeset 846 for trunk/src/opengl

trunk

Property svn:mergeinfo changed
/branches/vendor/nokia/qt/4.7.2 (added) merged: 845
/branches/vendor/nokia/qt/current merged: 844
/branches/vendor/nokia/qt/4.6.3 removed

trunk/src/opengl/gl2paintengineex/qgl2pexvertexarray.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
+}
-void QGL2PEXVertexArray::addRect(const QRectF &rect)
+{
-    vertexArray << rect.topLeft() << rect.topRight() << rect.bottomRight()
-                << rect.bottomRight() << rect.bottomLeft() << rect.topLeft();
+}
 void QGL2PEXVertexArray::addClosingLine(int index)
+{
+    if (QPointF(vertexArray.at(index)) != QPointF(vertexArray.last()))
+        vertexArray.add(vertexArray.at(index));
+    QPointF point(vertexArray.at(index));
+    if (point != QPointF(vertexArray.last()))
+        vertexArray.add(point);
+}
 …
                 int threshold = qMin<float>(64, qMax(bounds.width(), bounds.height()) * 3.14f / (curveInverseScale * 6));
                 if (threshold < 3) threshold = 3;
                 qreal one_over_threshold_minus_1 = 1.f / (threshold - 1);
+                qreal one_over_threshold_minus_1 = qreal(1) / (threshold - 1);
                 for (int t=0; t<threshold; ++t) {
                     QPointF pt = b.pointAt(t * one_over_threshold_minus_1);

trunk/src/opengl/gl2paintengineex/qgl2pexvertexarray_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     GLfloat bottom;
     operator QRectF() {return QRectF(left, top, right-left, bottom-top);}
+    operator QRectF() const {return QRectF(left, top, right-left, bottom-top);}
 };
 …
 public:
     QGL2PEXVertexArray() :
+        vertexArray(0), vertexArrayStops(0),
         maxX(-2e10), maxY(-2e10), minX(2e10), minY(2e10),
+        boundingRectDirty(true) {}
+        boundingRectDirty(true)
+    { }
+    inline void addRect(const QRectF &rect)
+    {
+        qreal top = rect.top();
+        qreal left = rect.left();
+        qreal bottom = rect.bottom();
+        qreal right = rect.right();
+        vertexArray << QGLPoint(left, top)
+                    << QGLPoint(right, top)
+                    << QGLPoint(right, bottom)
+                    << QGLPoint(right, bottom)
+                    << QGLPoint(left, bottom)
+                    << QGLPoint(left, top);
+    }
+    void addRect(const QRectF &rect);
+    inline void addQuad(const QRectF &rect)
+    {
+        qreal top = rect.top();
+        qreal left = rect.left();
+        qreal bottom = rect.bottom();
+        qreal right = rect.right();
+        vertexArray << QGLPoint(left, top)
+                    << QGLPoint(right, top)
+                    << QGLPoint(left, bottom)
+                    << QGLPoint(right, bottom);
+    }
+    inline void addVertex(const GLfloat x, const GLfloat y)
+    {
+        vertexArray.add(QGLPoint(x, y));
+    }
     void addPath(const QVectorPath &path, GLfloat curveInverseScale, bool outline = true);
     void clear();

trunk/src/opengl/gl2paintengineex/qglcustomshaderstage.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/gl2paintengineex/qglcustomshaderstage_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/gl2paintengineex/qglengineshadermanager.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #include "qglengineshadermanager_p.h"
 #include "qglengineshadersource_p.h"
+#include "qpaintengineex_opengl2_p.h"
 #if defined(QT_DEBUG)
 …
         code[UntransformedPositionVertexShader] = qglslUntransformedPositionVertexShader;
         code[PositionOnlyVertexShader] = qglslPositionOnlyVertexShader;
+        code[ComplexGeometryPositionOnlyVertexShader] = qglslComplexGeometryPositionOnlyVertexShader;
         code[PositionWithPatternBrushVertexShader] = qglslPositionWithPatternBrushVertexShader;
         code[PositionWithLinearGradientBrushVertexShader] = qglslPositionWithLinearGradientBrushVertexShader;
 …
 // The address returned here will only be valid until next time this function is called.
+// The program is return bound.
 QGLEngineShaderProg *QGLEngineSharedShaders::findProgramInCache(const QGLEngineShaderProg &prog)
+{
 …
             // Move the program to the top of the list as a poor-man's cache algo
             cachedPrograms.move(i, 0);
+            cachedProg->program->bind();
             return cachedProg;
+        }
 …
         if (newProg->useOpacityAttribute)
             newProg->program->bindAttributeLocation("opacityArray", QT_OPACITY_ATTR);
         if (newProg->usePmvMatrix) {
+        if (newProg->usePmvMatrixAttribute) {
             newProg->program->bindAttributeLocation("pmvMatrix1", QT_PMV_MATRIX_1_ATTR);
             newProg->program->bindAttributeLocation("pmvMatrix2", QT_PMV_MATRIX_2_ATTR);
 …
             break;
+        }
+        newProg->program->bind();
+        if (newProg->maskFragShader != QGLEngineSharedShaders::NoMaskFragmentShader) {
+            GLuint location = newProg->program->uniformLocation("maskTexture");
+            newProg->program->setUniformValue(location, QT_MASK_TEXTURE_UNIT);
+        }
         if (cachedPrograms.count() > 30) {
             // The cache is full, so delete the last 5 programs in the list.
 …
     : ctx(context),
       shaderProgNeedsChanging(true),
+      complexGeometry(false),
       srcPixelType(Qt::NoBrush),
       opacityMode(NoOpacity),
 …
         "invertedTextureSize",
         "brushTransform",
+        "brushTexture"
+        "brushTexture",
+        "matrix"
     };
 …
     requiredProgram.useTextureCoords = texCoords;
     requiredProgram.useOpacityAttribute = (opacityMode == AttributeOpacity);
+    requiredProgram.usePmvMatrix = true;
+    if (complexGeometry && srcPixelType == Qt::SolidPattern) {
+        requiredProgram.positionVertexShader = QGLEngineSharedShaders::ComplexGeometryPositionOnlyVertexShader;
+        requiredProgram.usePmvMatrixAttribute = false;
+    } else {
+        requiredProgram.usePmvMatrixAttribute = true;
+        // Force complexGeometry off, since we currently don't support that mode for
+        // non-solid brushes
+        complexGeometry = false;
+    }
     // At this point, requiredProgram is fully populated so try to find the program in the cache
     currentShaderProg = sharedShaders->findProgramInCache(requiredProgram);
+    if (currentShaderProg) {
+        currentShaderProg->program->bind();
+        if (useCustomSrc)
+            customSrcStage->setUniforms(currentShaderProg->program);
+    if (currentShaderProg && useCustomSrc) {
+        customSrcStage->setUniforms(currentShaderProg->program);
+    }

trunk/src/opengl/gl2paintengineex/qglengineshadermanager_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     calculations which logically belong in the fragment shader have been moved
     into the vertex shader to improve performance. This is why the position
     calculation is in a seperate shader. Not only does it calculate the
+    calculation is in a separate shader. Not only does it calculate the
     position, but it also calculates some data to be passed to the fragment
     shader as a varying. It is optimal to move as much of the calculation as
 …
         UntransformedPositionVertexShader,
         PositionOnlyVertexShader,
+        ComplexGeometryPositionOnlyVertexShader,
         PositionWithPatternBrushVertexShader,
         PositionWithLinearGradientBrushVertexShader,
 …
     bool                useTextureCoords;
     bool                useOpacityAttribute;
     bool                usePmvMatrix;
+    bool                usePmvMatrixAttribute;
     bool operator==(const QGLEngineShaderProg& other) {
 …
         BrushTransform,
         BrushTexture,
+        Matrix,
         NumUniforms
     };
 …
     };
     // There are optimisations we can do, depending on the brush transform:
+    // There are optimizations we can do, depending on the brush transform:
     //    1) May not have to apply perspective-correction
     //    2) Can use lower precision for matrix
 …
     void useSimpleProgram();
     void useBlitProgram();
+    void setHasComplexGeometry(bool hasComplexGeometry)
+    {
+        complexGeometry = hasComplexGeometry;
+        shaderProgNeedsChanging = true;
+    }
+    bool hasComplexGeometry() const
+    {
+        return complexGeometry;
+    }
     QGLShaderProgram* currentProgram(); // Returns pointer to the shader the manager has chosen
 …
     QGLContext*     ctx;
     bool            shaderProgNeedsChanging;
+    bool            complexGeometry;
     // Current state variables which influence the choice of shader:

trunk/src/opengl/gl2paintengineex/qglengineshadersource_p.h

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
         gl_Position = vec4(transformedPos.xy, 0.0, transformedPos.z); \n\
     }\n";
+static const char* const qglslComplexGeometryPositionOnlyVertexShader = "\n\
+    uniform highp mat3 matrix; \n\
+    attribute highp vec2 vertexCoordsArray; \n\
+    void setPosition(void) \n\
+    { \n\
+      gl_Position = vec4(matrix * vec3(vertexCoordsArray, 1), 1);\n\
+    } \n";
 static const char* const qglslUntransformedPositionVertexShader = "\n\
 …
     uniform   highp   vec2      invertedTextureSize; \n\
     uniform   highp   mat3      brushTransform; \n\
     varying   highp   vec2      textureCoords; \n\
+    varying   highp   vec2      brushTextureCoords; \n\
     void setPosition(void) \n\
     { \n\
 …
         mediump float invertedHTexCoordsZ = 1.0 / hTexCoords.z; \n\
         gl_Position = vec4(gl_Position.xy * invertedHTexCoordsZ, 0.0, invertedHTexCoordsZ); \n\
         textureCoords.xy = (hTexCoords.xy * invertedTextureSize) * gl_Position.w; \n\
+        brushTextureCoords.xy = (hTexCoords.xy * invertedTextureSize) * gl_Position.w; \n\
     }\n";
 …
 // TODO: Special case POT textures which don't need this emulation
 static const char* const qglslTextureBrushSrcFragmentShader = "\n\
     varying highp   vec2      textureCoords; \n\
+    varying highp   vec2      brushTextureCoords; \n\
     uniform lowp    sampler2D brushTexture; \n\
     lowp vec4 srcPixel() { \n\
         return texture2D(brushTexture, fract(textureCoords)); \n\
+        return texture2D(brushTexture, fract(brushTextureCoords)); \n\
     }\n";
 #else
 static const char* const qglslTextureBrushSrcFragmentShader = "\n\
     varying   highp   vec2      textureCoords; \n\
+    varying   highp   vec2      brushTextureCoords; \n\
     uniform   lowp    sampler2D brushTexture; \n\
     lowp vec4 srcPixel() \n\
     { \n\
         return texture2D(brushTexture, textureCoords); \n\
+        return texture2D(brushTexture, brushTextureCoords); \n\
     }\n";
 #endif
 static const char* const qglslTextureBrushSrcWithPatternFragmentShader = "\n\
     varying   highp   vec2      textureCoords; \n\
+    varying   highp   vec2      brushTextureCoords; \n\
     uniform   lowp    vec4      patternColor; \n\
     uniform   lowp    sampler2D brushTexture; \n\
     lowp vec4 srcPixel() \n\
     { \n\
         return patternColor * (1.0 - texture2D(brushTexture, textureCoords).r); \n\
+        return patternColor * (1.0 - texture2D(brushTexture, brushTextureCoords).r); \n\
     }\n";
 …
     lowp vec4 srcPixel() \n\
     { \n"
-#ifdef QT_OPENGL_ES_2
-        // work-around for driver bug
-        "return 1.0 * texture2D(imageTexture, textureCoords); \n"
-#else
         "return texture2D(imageTexture, textureCoords); \n"
-#endif
     "}\n";

trunk/src/opengl/gl2paintengineex/qglgradientcache.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 ****************************************************************************/
+#include "qglgradientcache_p.h"
 #include <private/qdrawhelper_p.h>
 #include <private/qgl_p.h>
-#include "qglgradientcache_p.h"
 QT_BEGIN_NAMESPACE

trunk/src/opengl/gl2paintengineex/qglgradientcache_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 // #define QT_OPENGL_CACHE_AS_VBOS
+#include "qglgradientcache_p.h"
 #include "qpaintengineex_opengl2_p.h"
 …
 #include <private/qpixmapdata_gl_p.h>
 #include <private/qdatabuffer_p.h>
+#include "qglgradientcache_p.h"
+#include <private/qstatictext_p.h>
+#include <private/qtriangulator_p.h>
 #include "qglengineshadermanager_p.h"
 #include "qgl2pexvertexarray_p.h"
 …
 QT_BEGIN_NAMESPACE
+//#define QT_GL_NO_SCISSOR_TEST
+#if defined(Q_OS_SYMBIAN)
+#define QT_GL_NO_SCISSOR_TEST
+#endif
 #if defined(Q_WS_WIN)
 extern Q_GUI_EXPORT bool qt_cleartype_enabled;
 #endif
+extern QImage qt_imageForBrush(int brushStyle, bool invert);
+#ifdef Q_WS_MAC
+extern bool qt_applefontsmoothing_enabled;
+#endif
+Q_DECL_IMPORT extern QImage qt_imageForBrush(int brushStyle, bool invert);
 ////////////////////////////////// Private Methods //////////////////////////////////////////
 …
         e->data = 0;
         e->engine = 0;
+    }
+    if (elementIndicesVBOId != 0) {
+        glDeleteBuffers(1, &elementIndicesVBOId);
+        elementIndicesVBOId = 0;
+    }
+}
 …
     currentBrush = brush;
+    if (!currentBrushPixmap.isNull())
+        currentBrushPixmap = QPixmap();
     brushUniformsDirty = true; // All brushes have at least one uniform
 …
+    }
     else if (style == Qt::TexturePattern) {
+        const QPixmap& texPixmap = currentBrush.texture();
+        currentBrushPixmap = currentBrush.texture();
+        int max_texture_size = ctx->d_func()->maxTextureSize();
+        if (currentBrushPixmap.width() > max_texture_size || currentBrushPixmap.height() > max_texture_size)
+            currentBrushPixmap = currentBrushPixmap.scaled(max_texture_size, max_texture_size, Qt::KeepAspectRatio);
         glActiveTexture(GL_TEXTURE0 + QT_BRUSH_TEXTURE_UNIT);
+        QGLTexture *tex = ctx->d_func()->bindTexture(texPixmap, GL_TEXTURE_2D, GL_RGBA, QGLContext::InternalBindOption);
+        QGLTexture *tex = ctx->d_func()->bindTexture(currentBrushPixmap, GL_TEXTURE_2D, GL_RGBA,
+                                                     QGLContext::InternalBindOption |
+                                                     QGLContext::CanFlipNativePixmapBindOption);
         updateTextureFilter(GL_TEXTURE_2D, GL_REPEAT, q->state()->renderHints & QPainter::SmoothPixmapTransform);
         textureInvertedY = tex->options & QGLContext::InvertedYBindOption ? -1 : 1;
 …
         dy = ceilf(dy - 0.5f);
+    }
+#ifndef Q_OS_SYMBIAN
     if (addOffset) {
         dx += 0.49f;
         dy += 0.49f;
+    }
+#endif
     pmvMatrix[0][0] = (wfactor * transform.m11())  - transform.m13();
     pmvMatrix[1][0] = (wfactor * transform.m21())  - transform.m23();
 …
     matrixDirty = false;
+    matrixUniformDirty = true;
     // Set the PMV matrix attribute. As we use an attributes rather than uniforms, we only
 …
     d->transferMode(BrushDrawingMode);
+    d->nativePaintingActive = true;
     QGLContext *ctx = d->ctx;
     glUseProgram(0);
 …
     float mv_matrix[4][4] =
+    {
         { mtx.m11(), mtx.m12(),     0, mtx.m13() },
         { mtx.m21(), mtx.m22(),     0, mtx.m23() },
         {         0,         0,     1,         0 },
         {  mtx.dx(),  mtx.dy(),     0, mtx.m33() }
+        { float(mtx.m11()), float(mtx.m12()),     0, float(mtx.m13()) },
+        { float(mtx.m21()), float(mtx.m22()),     0, float(mtx.m23()) },
+        {                0,                0,     1,                0 },
+        {  float(mtx.dx()),  float(mtx.dy()),     0, float(mtx.m33()) }
     };
 …
     glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
     glStencilFunc(GL_ALWAYS, 0, 0xff);
     glDisableVertexAttribArray(QT_TEXTURE_COORDS_ATTR);
     glDisableVertexAttribArray(QT_VERTEX_COORDS_ATTR);
     glDisableVertexAttribArray(QT_OPACITY_ATTR);
+    ctx->d_func()->setVertexAttribArrayEnabled(QT_TEXTURE_COORDS_ATTR, false);
+    ctx->d_func()->setVertexAttribArrayEnabled(QT_VERTEX_COORDS_ATTR, false);
+    ctx->d_func()->setVertexAttribArrayEnabled(QT_OPACITY_ATTR, false);
 #ifndef QT_OPENGL_ES_2
     glColor4f(1.0f, 1.0f, 1.0f, 1.0f); // color may have been changed by glVertexAttrib()
 …
     Q_D(QGL2PaintEngineEx);
     d->needsSync = true;
+    d->nativePaintingActive = false;
+}
+void QGL2PaintEngineEx::invalidateState()
+{
+    Q_D(QGL2PaintEngineEx);
+    d->needsSync = true;
+}
+bool QGL2PaintEngineEx::isNativePaintingActive() const {
+    Q_D(const QGL2PaintEngineEx);
+    return d->nativePaintingActive;
+}
 …
     if (newMode == TextDrawingMode) {
+        setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, (GLfloat*)vertexCoordinateArray.data());
+        setVertexAttributePointer(QT_TEXTURE_COORDS_ATTR, (GLfloat*)textureCoordinateArray.data());
+        shaderManager->setHasComplexGeometry(true);
+    } else {
+        shaderManager->setHasComplexGeometry(false);
+    }
 …
 #ifdef QT_OPENGL_CACHE_AS_VBOS
     GLuint vbo;
+    GLuint ibo;
 #else
     float *vertices;
+    void *indices;
 #endif
     int vertexCount;
+    int indexCount;
     GLenum primitiveType;
     qreal iscale;
 …
     Q_ASSERT(engine->type() == QPaintEngine::OpenGL2);
     static_cast<QGL2PaintEngineEx *>(engine)->d_func()->unusedVBOSToClean << c->vbo;
+    if (c->ibo)
+        d->unusedIBOSToClean << c->ibo;
 #else
     Q_UNUSED(engine);
     qFree(c->vertices);
+    qFree(c->indices);
 #endif
     delete c;
 …
             QVectorPath::CacheEntry *data = path.lookupCacheData(q);
             QGL2PEVectorPathCache *cache;
+            bool updateCache = false;
             if (data) {
 …
                         glDeleteBuffers(1, &cache->vbo);
                         cache->vbo = 0;
+                        Q_ASSERT(cache->ibo == 0);
 #else
                         qFree(cache->vertices);
+#endif
+                        cache->vertexCount = 0;
+                        Q_ASSERT(cache->indices == 0);
+#endif
+                        updateCache = true;
+                    }
+                }
             } else {
                 cache = new QGL2PEVectorPathCache;
-                cache->vertexCount = 0;
                 data = const_cast<QVectorPath &>(path).addCacheData(q, cache, cleanupVectorPath);
+                updateCache = true;
+            }
             // Flatten the path at the current scale factor and fill it into the cache struct.
             if (!cache->vertexCount) {
+            if (updateCache) {
                 vertexCoordinateArray.clear();
                 vertexCoordinateArray.addPath(path, inverseScale, false);
 …
                 int floatSizeInBytes = vertexCount * 2 * sizeof(float);
                 cache->vertexCount = vertexCount;
+                cache->indexCount = 0;
                 cache->primitiveType = GL_TRIANGLE_FAN;
                 cache->iscale = inverseScale;
 …
                 glBindBuffer(GL_ARRAY_BUFFER, cache->vbo);
                 glBufferData(GL_ARRAY_BUFFER, floatSizeInBytes, vertexCoordinateArray.data(), GL_STATIC_DRAW);
+                cache->ibo = 0;
 #else
                 cache->vertices = (float *) qMalloc(floatSizeInBytes);
                 memcpy(cache->vertices, vertexCoordinateArray.data(), floatSizeInBytes);
+                cache->indices = 0;
 #endif
+            }
 …
       //        printf(" - Marking path as cachable...\n");
             // Tag it for later so that if the same path is drawn twice, it is assumed to be static and thus cachable
+            // ### Remove before release...
+            static bool do_vectorpath_cache = qgetenv("QT_OPENGL_NO_PATH_CACHE").isEmpty();
+            if (do_vectorpath_cache)
+                path.makeCacheable();
+            path.makeCacheable();
             vertexCoordinateArray.clear();
             vertexCoordinateArray.addPath(path, inverseScale, false);
 …
     } else {
+        // The path is too complicated & needs the stencil technique
+        vertexCoordinateArray.clear();
+        vertexCoordinateArray.addPath(path, inverseScale, false);
+        fillStencilWithVertexArray(vertexCoordinateArray, path.hasWindingFill());
+        glStencilMask(0xff);
+        glStencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
+        if (q->state()->clipTestEnabled) {
+            // Pass when high bit is set, replace stencil value with current clip
+            glStencilFunc(GL_NOTEQUAL, q->state()->currentClip, GL_STENCIL_HIGH_BIT);
+        } else if (path.hasWindingFill()) {
+            // Pass when any bit is set, replace stencil value with 0
+            glStencilFunc(GL_NOTEQUAL, 0, 0xff);
+        bool useCache = path.isCacheable();
+        if (useCache) {
+            QRectF bbox = path.controlPointRect();
+            // If the path doesn't fit within these limits, it is possible that the triangulation will fail.
+            useCache &= (bbox.left() > -0x8000 * inverseScale)
+                     && (bbox.right() < 0x8000 * inverseScale)
+                     && (bbox.top() > -0x8000 * inverseScale)
+                     && (bbox.bottom() < 0x8000 * inverseScale);
+        }
+        if (useCache) {
+            QVectorPath::CacheEntry *data = path.lookupCacheData(q);
+            QGL2PEVectorPathCache *cache;
+            bool updateCache = false;
+            if (data) {
+                cache = (QGL2PEVectorPathCache *) data->data;
+                // Check if scale factor is exceeded for curved paths and generate curves if so...
+                if (path.isCurved()) {
+                    qreal scaleFactor = cache->iscale / inverseScale;
+                    if (scaleFactor < 0.5 || scaleFactor > 2.0) {
+#ifdef QT_OPENGL_CACHE_AS_VBOS
+                        glDeleteBuffers(1, &cache->vbo);
+                        glDeleteBuffers(1, &cache->ibo);
+#else
+                        qFree(cache->vertices);
+                        qFree(cache->indices);
+#endif
+                        updateCache = true;
+                    }
+                }
+            } else {
+                cache = new QGL2PEVectorPathCache;
+                data = const_cast<QVectorPath &>(path).addCacheData(q, cache, cleanupVectorPath);
+                updateCache = true;
+            }
+            // Flatten the path at the current scale factor and fill it into the cache struct.
+            if (updateCache) {
+                QTriangleSet polys = qTriangulate(path, QTransform().scale(1 / inverseScale, 1 / inverseScale));
+                cache->vertexCount = polys.vertices.size() / 2;
+                cache->indexCount = polys.indices.size();
+                cache->primitiveType = GL_TRIANGLES;
+                cache->iscale = inverseScale;
+#ifdef QT_OPENGL_CACHE_AS_VBOS
+                glGenBuffers(1, &cache->vbo);
+                glGenBuffers(1, &cache->ibo);
+                glBindBuffer(GL_ARRAY_BUFFER, cache->vbo);
+                glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cache->ibo);
+                if (QGLExtensions::glExtensions() & QGLExtensions::ElementIndexUint)
+                    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(quint32) * polys.indices.size(), polys.indices.data(), GL_STATIC_DRAW);
+                else
+                    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(quint16) * polys.indices.size(), polys.indices.data(), GL_STATIC_DRAW);
+                QVarLengthArray<float> vertices(polys.vertices.size());
+                for (int i = 0; i < polys.vertices.size(); ++i)
+                    vertices[i] = float(inverseScale * polys.vertices.at(i));
+                glBufferData(GL_ARRAY_BUFFER, sizeof(float) * vertices.size(), vertices.data(), GL_STATIC_DRAW);
+#else
+                cache->vertices = (float *) qMalloc(sizeof(float) * polys.vertices.size());
+                if (QGLExtensions::glExtensions() & QGLExtensions::ElementIndexUint) {
+                    cache->indices = (quint32 *) qMalloc(sizeof(quint32) * polys.indices.size());
+                    memcpy(cache->indices, polys.indices.data(), sizeof(quint32) * polys.indices.size());
+                } else {
+                    cache->indices = (quint16 *) qMalloc(sizeof(quint16) * polys.indices.size());
+                    memcpy(cache->indices, polys.indices.data(), sizeof(quint16) * polys.indices.size());
+                }
+                for (int i = 0; i < polys.vertices.size(); ++i)
+                    cache->vertices[i] = float(inverseScale * polys.vertices.at(i));
+#endif
+            }
+            prepareForDraw(currentBrush.isOpaque());
+#ifdef QT_OPENGL_CACHE_AS_VBOS
+            glBindBuffer(GL_ARRAY_BUFFER, cache->vbo);
+            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cache->ibo);
+            setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, 0);
+            if (QGLExtensions::glExtensions() & QGLExtensions::ElementIndexUint)
+                glDrawElements(cache->primitiveType, cache->indexCount, GL_UNSIGNED_INT, 0);
+            else
+                glDrawElements(cache->primitiveType, cache->indexCount, GL_UNSIGNED_SHORT, 0);
+            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+            glBindBuffer(GL_ARRAY_BUFFER, 0);
+#else
+            setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, cache->vertices);
+            if (QGLExtensions::glExtensions() & QGLExtensions::ElementIndexUint)
+                glDrawElements(cache->primitiveType, cache->indexCount, GL_UNSIGNED_INT, (qint32 *)cache->indices);
+            else
+                glDrawElements(cache->primitiveType, cache->indexCount, GL_UNSIGNED_SHORT, (qint16 *)cache->indices);
+#endif
         } else {
+            // Pass when high bit is set, replace stencil value with 0
+            glStencilFunc(GL_NOTEQUAL, 0, GL_STENCIL_HIGH_BIT);
+        }
+        prepareForDraw(currentBrush.isOpaque());
+        // Stencil the brush onto the dest buffer
+        composite(vertexCoordinateArray.boundingRect());
+        glStencilMask(0);
+        updateClipScissorTest();
+      //        printf(" - Marking path as cachable...\n");
+            // Tag it for later so that if the same path is drawn twice, it is assumed to be static and thus cachable
+            path.makeCacheable();
+            // The path is too complicated & needs the stencil technique
+            vertexCoordinateArray.clear();
+            vertexCoordinateArray.addPath(path, inverseScale, false);
+            fillStencilWithVertexArray(vertexCoordinateArray, path.hasWindingFill());
+            glStencilMask(0xff);
+            glStencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
+            if (q->state()->clipTestEnabled) {
+                // Pass when high bit is set, replace stencil value with current clip
+                glStencilFunc(GL_NOTEQUAL, q->state()->currentClip, GL_STENCIL_HIGH_BIT);
+            } else if (path.hasWindingFill()) {
+                // Pass when any bit is set, replace stencil value with 0
+                glStencilFunc(GL_NOTEQUAL, 0, 0xff);
+            } else {
+                // Pass when high bit is set, replace stencil value with 0
+                glStencilFunc(GL_NOTEQUAL, 0, GL_STENCIL_HIGH_BIT);
+            }
+            prepareForDraw(currentBrush.isOpaque());
+            // Stencil the brush onto the dest buffer
+            composite(vertexCoordinateArray.boundingRect());
+            glStencilMask(0);
+            updateClipScissorTest();
+        }
+    }
+}
 …
         brushUniformsDirty = true;
         opacityUniformDirty = true;
+        matrixUniformDirty = true;
+    }
 …
         shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::GlobalOpacity), (GLfloat)q->state()->opacity);
         opacityUniformDirty = false;
+    }
+    if (matrixUniformDirty && shaderManager->hasComplexGeometry()) {
+        shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::Matrix),
+                                                         pmvMatrix);
+        matrixUniformDirty = false;
+    }
 …
+}
 extern bool qt_scaleForTransform(const QTransform &transform, qreal *scale); // qtransform.cpp
+extern Q_GUI_EXPORT bool qt_scaleForTransform(const QTransform &transform, qreal *scale); // qtransform.cpp
 …
     updateMatrix();
+    QRectF clip = q->state()->matrix.inverted().mapRect(q->state()->clipEnabled
+                                                        ? q->state()->rectangleClip
+                                                        : QRectF(0, 0, width, height));
     if (penStyle == Qt::SolidLine) {
         stroker.process(path, pen);
+        stroker.process(path, pen, clip);
     } else { // Some sort of dash
         dasher.process(path, pen);
+        dasher.process(path, pen, clip);
         QVectorPath dashStroke(dasher.points(),
                                dasher.elementCount(),
                                dasher.elementTypes());
+        stroker.process(dashStroke, pen);
+    }
+        stroker.process(dashStroke, pen, clip);
+    }
+    if (!stroker.vertexCount())
+        return;
     if (opaque) {
 …
+static const QRectF scaleRect(const QRectF &r, qreal sx, qreal sy)
+{
+    return QRectF(r.x() * sx, r.y() * sy, r.width() * sx, r.height() * sy);
+}
 void QGL2PaintEngineEx::drawPixmap(const QRectF& dest, const QPixmap & pixmap, const QRectF & src)
+{
     Q_D(QGL2PaintEngineEx);
+    QGLContext *ctx = d->ctx;
+    int max_texture_size = ctx->d_func()->maxTextureSize();
+    if (pixmap.width() > max_texture_size || pixmap.height() > max_texture_size) {
+        QPixmap scaled = pixmap.scaled(max_texture_size, max_texture_size, Qt::KeepAspectRatio);
+        const qreal sx = scaled.width() / qreal(pixmap.width());
+        const qreal sy = scaled.height() / qreal(pixmap.height());
+        drawPixmap(dest, scaled, scaleRect(src, sx, sy));
+        return;
+    }
     ensureActive();
     d->transferMode(ImageDrawingMode);
-    QGLContext *ctx = d->ctx;
     glActiveTexture(GL_TEXTURE0 + QT_IMAGE_TEXTURE_UNIT);
     QGLTexture *texture =
 …
     bool isBitmap = pixmap.isQBitmap();
     bool isOpaque = !isBitmap && !pixmap.hasAlphaChannel();
+    bool isOpaque = !isBitmap && !pixmap.hasAlpha();
     d->updateTextureFilter(GL_TEXTURE_2D, GL_CLAMP_TO_EDGE,
 …
+{
     Q_D(QGL2PaintEngineEx);
+    QGLContext *ctx = d->ctx;
+    int max_texture_size = ctx->d_func()->maxTextureSize();
+    if (image.width() > max_texture_size || image.height() > max_texture_size) {
+        QImage scaled = image.scaled(max_texture_size, max_texture_size, Qt::KeepAspectRatio);
+        const qreal sx = scaled.width() / qreal(image.width());
+        const qreal sy = scaled.height() / qreal(image.height());
+        drawImage(dest, scaled, scaleRect(src, sx, sy));
+        return;
+    }
     ensureActive();
     d->transferMode(ImageDrawingMode);
-    QGLContext *ctx = d->ctx;
     glActiveTexture(GL_TEXTURE0 + QT_IMAGE_TEXTURE_UNIT);
     QGLTexture *texture = ctx->d_func()->bindTexture(image, GL_TEXTURE_2D, GL_RGBA, QGLContext::InternalBindOption);
     GLuint id = texture->id;
 …
+}
 void QGL2PaintEngineEx::drawTexture(const QRectF &dest, GLuint textureId, const QSize &size, const QRectF &src)
+void QGL2PaintEngineEx::drawStaticTextItem(QStaticTextItem *textItem)
+{
     Q_D(QGL2PaintEngineEx);
+    ensureActive();
+    QFontEngineGlyphCache::Type glyphType = textItem->fontEngine()->glyphFormat >= 0
+                                            ? QFontEngineGlyphCache::Type(textItem->fontEngine()->glyphFormat)
+                                            : d->glyphCacheType;
+    if (glyphType == QFontEngineGlyphCache::Raster_RGBMask) {
+        if (d->device->alphaRequested() || state()->matrix.type() > QTransform::TxTranslate
+            || (state()->composition_mode != QPainter::CompositionMode_Source
+            && state()->composition_mode != QPainter::CompositionMode_SourceOver))
+        {
+            glyphType = QFontEngineGlyphCache::Raster_A8;
+        }
+    }
+    d->drawCachedGlyphs(glyphType, textItem);
+}
+bool QGL2PaintEngineEx::drawTexture(const QRectF &dest, GLuint textureId, const QSize &size, const QRectF &src)
+{
+    Q_D(QGL2PaintEngineEx);
+    if (!d->shaderManager)
+        return false;
     ensureActive();
     d->transferMode(ImageDrawingMode);
 …
                            state()->renderHints & QPainter::SmoothPixmapTransform, textureId);
     d->drawTexture(dest, srcRect, size, false);
+    return true;
+}
 …
     if (drawCached) {
+        d->drawCachedGlyphs(p, glyphType, ti);
+        QVarLengthArray<QFixedPoint> positions;
+        QVarLengthArray<glyph_t> glyphs;
+        QTransform matrix = QTransform::fromTranslate(p.x(), p.y());
+        ti.fontEngine->getGlyphPositions(ti.glyphs, matrix, ti.flags, glyphs, positions);
+        {
+            QStaticTextItem staticTextItem;
+            staticTextItem.chars = const_cast<QChar *>(ti.chars);
+            staticTextItem.setFontEngine(ti.fontEngine);
+            staticTextItem.glyphs = glyphs.data();
+            staticTextItem.numChars = ti.num_chars;
+            staticTextItem.numGlyphs = glyphs.size();
+            staticTextItem.glyphPositions = positions.data();
+            d->drawCachedGlyphs(glyphType, &staticTextItem);
+        }
         return;
+    }
 …
+}
+void QGL2PaintEngineExPrivate::drawCachedGlyphs(const QPointF &p, QFontEngineGlyphCache::Type glyphType,
+                                                const QTextItemInt &ti)
+namespace {
+    class QOpenGLStaticTextUserData: public QStaticTextUserData
+    {
+    public:
+        QOpenGLStaticTextUserData()
+            : QStaticTextUserData(OpenGLUserData), cacheSize(0, 0)
+        {
+        }
+        ~QOpenGLStaticTextUserData()
+        {
+        }
+        QSize cacheSize;
+        QGL2PEXVertexArray vertexCoordinateArray;
+        QGL2PEXVertexArray textureCoordinateArray;
+        QFontEngineGlyphCache::Type glyphType;
+    };
+}
+// #define QT_OPENGL_DRAWCACHEDGLYPHS_INDEX_ARRAY_VBO
+void QGL2PaintEngineExPrivate::drawCachedGlyphs(QFontEngineGlyphCache::Type glyphType,
+                                                QStaticTextItem *staticTextItem)
+{
     Q_Q(QGL2PaintEngineEx);
+    QVarLengthArray<QFixedPoint> positions;
+    QVarLengthArray<glyph_t> glyphs;
+    QTransform matrix = QTransform::fromTranslate(p.x(), p.y());
+    ti.fontEngine->getGlyphPositions(ti.glyphs, matrix, ti.flags, glyphs, positions);
+    QOpenGL2PaintEngineState *s = q->state();
+    bool recreateVertexArrays = false;
     QGLTextureGlyphCache *cache =
+            (QGLTextureGlyphCache *) ti.fontEngine->glyphCache(ctx, glyphType, QTransform());
+        (QGLTextureGlyphCache *) staticTextItem->fontEngine()->glyphCache(ctx, glyphType, QTransform());
     if (!cache || cache->cacheType() != glyphType) {
         cache = new QGLTextureGlyphCache(ctx, glyphType, QTransform());
+        ti.fontEngine->setGlyphCache(ctx, cache);
+    }
+    cache->setPaintEnginePrivate(this);
+    cache->populate(ti, glyphs, positions);
+        staticTextItem->fontEngine()->setGlyphCache(ctx, cache);
+        recreateVertexArrays = true;
+    } else if (cache->context() == 0) { // Old context has been destroyed, new context has same ptr value
+        cache->setContext(ctx);
+    }
+    if (staticTextItem->userDataNeedsUpdate) {
+        recreateVertexArrays = true;
+    } else if (staticTextItem->userData() == 0) {
+        recreateVertexArrays = true;
+    } else if (staticTextItem->userData()->type != QStaticTextUserData::OpenGLUserData) {
+        recreateVertexArrays = true;
+    } else {
+        QOpenGLStaticTextUserData *userData = static_cast<QOpenGLStaticTextUserData *>(staticTextItem->userData());
+        if (userData->glyphType != glyphType)
+            recreateVertexArrays = true;
+    }
+    // We only need to update the cache with new glyphs if we are actually going to recreate the vertex arrays.
+    // If the cache size has changed, we do need to regenerate the vertices, but we don't need to repopulate the
+    // cache so this text is performed before we test if the cache size has changed.
+    if (recreateVertexArrays) {
+        cache->setPaintEnginePrivate(this);
+        if (!cache->populate(staticTextItem->fontEngine(), staticTextItem->numGlyphs,
+                             staticTextItem->glyphs, staticTextItem->glyphPositions)) {
+            // No space in cache. We need to clear the cache and try again
+            cache->clear();
+            cache->populate(staticTextItem->fontEngine(), staticTextItem->numGlyphs,
+                            staticTextItem->glyphs, staticTextItem->glyphPositions);
+        }
+    }
     if (cache->width() == 0 || cache->height() == 0)
 …
     GLfloat dy = 1.0 / cache->height();
+    vertexCoordinateArray.clear();
+    textureCoordinateArray.clear();
+    for (int i=0; i<glyphs.size(); ++i) {
+        const QTextureGlyphCache::Coord &c = cache->coords.value(glyphs[i]);
+        int x = positions[i].x.toInt() + c.baseLineX - margin;
+        int y = positions[i].y.toInt() - c.baseLineY - margin;
+        vertexCoordinateArray.addRect(QRectF(x, y, c.w, c.h));
+        textureCoordinateArray.addRect(QRectF(c.x*dx, c.y*dy, c.w * dx, c.h * dy));
+    }
+    setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, (GLfloat*)vertexCoordinateArray.data());
+    setVertexAttributePointer(QT_TEXTURE_COORDS_ATTR, (GLfloat*)textureCoordinateArray.data());
+    // Use global arrays by default
+    QGL2PEXVertexArray *vertexCoordinates = &vertexCoordinateArray;
+    QGL2PEXVertexArray *textureCoordinates = &textureCoordinateArray;
+    if (staticTextItem->useBackendOptimizations) {
+        QOpenGLStaticTextUserData *userData = 0;
+        if (staticTextItem->userData() == 0
+            || staticTextItem->userData()->type != QStaticTextUserData::OpenGLUserData) {
+            userData = new QOpenGLStaticTextUserData();
+            staticTextItem->setUserData(userData);
+        } else {
+            userData = static_cast<QOpenGLStaticTextUserData*>(staticTextItem->userData());
+        }
+        userData->glyphType = glyphType;
+        // Use cache if backend optimizations is turned on
+        vertexCoordinates = &userData->vertexCoordinateArray;
+        textureCoordinates = &userData->textureCoordinateArray;
+        QSize size(cache->width(), cache->height());
+        if (userData->cacheSize != size) {
+            recreateVertexArrays = true;
+            userData->cacheSize = size;
+        }
+    }
+    if (recreateVertexArrays) {
+        vertexCoordinates->clear();
+        textureCoordinates->clear();
+        for (int i=0; i<staticTextItem->numGlyphs; ++i) {
+            const QTextureGlyphCache::Coord &c = cache->coords.value(staticTextItem->glyphs[i]);
+            int x = staticTextItem->glyphPositions[i].x.toInt() + c.baseLineX - margin;
+            int y = staticTextItem->glyphPositions[i].y.toInt() - c.baseLineY - margin;
+            vertexCoordinates->addQuad(QRectF(x, y, c.w, c.h));
+            textureCoordinates->addQuad(QRectF(c.x*dx, c.y*dy, c.w * dx, c.h * dy));
+        }
+        staticTextItem->userDataNeedsUpdate = false;
+    }
+    if (elementIndices.size() < staticTextItem->numGlyphs*6) {
+        Q_ASSERT(elementIndices.size() % 6 == 0);
+        int j = elementIndices.size() / 6 * 4;
+        while (j < staticTextItem->numGlyphs*4) {
+            elementIndices.append(j + 0);
+            elementIndices.append(j + 0);
+            elementIndices.append(j + 1);
+            elementIndices.append(j + 2);
+            elementIndices.append(j + 3);
+            elementIndices.append(j + 3);
+            j += 4;
+        }
+#if defined(QT_OPENGL_DRAWCACHEDGLYPHS_INDEX_ARRAY_VBO)
+        if (elementIndicesVBOId == 0)
+            glGenBuffers(1, &elementIndicesVBOId);
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementIndicesVBOId);
+        glBufferData(GL_ELEMENT_ARRAY_BUFFER, elementIndices.size() * sizeof(GLushort),
+                     elementIndices.constData(), GL_STATIC_DRAW);
+#endif
+    } else {
+#if defined(QT_OPENGL_DRAWCACHEDGLYPHS_INDEX_ARRAY_VBO)
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementIndicesVBOId);
+#endif
+    }
+    setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, (GLfloat*)vertexCoordinates->data());
+    setVertexAttributePointer(QT_TEXTURE_COORDS_ATTR, (GLfloat*)textureCoordinates->data());
     if (addOffset) {
 …
             updateTextureFilter(GL_TEXTURE_2D, GL_REPEAT, false);
+            shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::MaskTexture), QT_MASK_TEXTURE_UNIT);
+            glDrawArrays(GL_TRIANGLES, 0, 6 * glyphs.size());
+#if defined(QT_OPENGL_DRAWCACHEDGLYPHS_INDEX_ARRAY_VBO)
+            glDrawElements(GL_TRIANGLE_STRIP, 6 * staticTextItem->numGlyphs, GL_UNSIGNED_SHORT, 0);
+#else
+            glDrawElements(GL_TRIANGLE_STRIP, 6 * staticTextItem->numGlyphs, GL_UNSIGNED_SHORT, elementIndices.data());
+#endif
             shaderManager->setMaskType(QGLEngineShaderManager::SubPixelMaskPass2);
 …
     //### TODO: Gamma correction
+    glActiveTexture(GL_TEXTURE0 + QT_MASK_TEXTURE_UNIT);
+    glBindTexture(GL_TEXTURE_2D, cache->texture());
+    updateTextureFilter(GL_TEXTURE_2D, GL_REPEAT, false);
+    shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::MaskTexture), QT_MASK_TEXTURE_UNIT);
+    glDrawArrays(GL_TRIANGLES, 0, 6 * glyphs.size());
+}
+void QGL2PaintEngineEx::drawPixmaps(const QDrawPixmaps::Data *drawingData, int dataCount, const QPixmap &pixmap, QDrawPixmaps::DrawingHints hints)
+    QGLTextureGlyphCache::FilterMode filterMode = (s->matrix.type() > QTransform::TxTranslate)?QGLTextureGlyphCache::Linear:QGLTextureGlyphCache::Nearest;
+    if (lastMaskTextureUsed != cache->texture() || cache->filterMode() != filterMode) {
+        glActiveTexture(GL_TEXTURE0 + QT_MASK_TEXTURE_UNIT);
+        if (lastMaskTextureUsed != cache->texture()) {
+            glBindTexture(GL_TEXTURE_2D, cache->texture());
+            lastMaskTextureUsed = cache->texture();
+        }
+        if (cache->filterMode() != filterMode) {
+            if (filterMode == QGLTextureGlyphCache::Linear) {
+                glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+                glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+            } else {
+                glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+                glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+            }
+            cache->setFilterMode(filterMode);
+        }
+    }
+#if defined(QT_OPENGL_DRAWCACHEDGLYPHS_INDEX_ARRAY_VBO)
+    glDrawElements(GL_TRIANGLE_STRIP, 6 * staticTextItem->numGlyphs, GL_UNSIGNED_SHORT, 0);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+#else
+    glDrawElements(GL_TRIANGLE_STRIP, 6 * staticTextItem->numGlyphs, GL_UNSIGNED_SHORT, elementIndices.data());
+#endif
+}
+void QGL2PaintEngineEx::drawPixmapFragments(const QPainter::PixmapFragment *fragments, int fragmentCount, const QPixmap &pixmap,
+                                            QPainter::PixmapFragmentHints hints)
+{
     Q_D(QGL2PaintEngineEx);
     // Use fallback for extended composition modes.
     if (state()->composition_mode > QPainter::CompositionMode_Plus) {
         QPaintEngineEx::drawPixmaps(drawingData, dataCount, pixmap, hints);
+        QPaintEngineEx::drawPixmapFragments(fragments, fragmentCount, pixmap, hints);
         return;
+    }
     ensureActive();
+    d->drawPixmaps(drawingData, dataCount, pixmap, hints);
+}
+void QGL2PaintEngineExPrivate::drawPixmaps(const QDrawPixmaps::Data *drawingData, int dataCount, const QPixmap &pixmap, QDrawPixmaps::DrawingHints hints)
+    int max_texture_size = d->ctx->d_func()->maxTextureSize();
+    if (pixmap.width() > max_texture_size || pixmap.height() > max_texture_size) {
+        QPixmap scaled = pixmap.scaled(max_texture_size, max_texture_size, Qt::KeepAspectRatio);
+        d->drawPixmapFragments(fragments, fragmentCount, scaled, hints);
+    } else {
+        d->drawPixmapFragments(fragments, fragmentCount, pixmap, hints);
+    }
+}
+void QGL2PaintEngineExPrivate::drawPixmapFragments(const QPainter::PixmapFragment *fragments,
+                                                   int fragmentCount, const QPixmap &pixmap,
+                                                   QPainter::PixmapFragmentHints hints)
+{
     GLfloat dx = 1.0f / pixmap.size().width();
 …
     bool allOpaque = true;
     for (int i = 0; i < dataCount; ++i) {
+    for (int i = 0; i < fragmentCount; ++i) {
         qreal s = 0;
         qreal c = 1;
         if (drawingData[i].rotation != 0) {
             s = qFastSin(drawingData[i].rotation * Q_PI / 180);
             c = qFastCos(drawingData[i].rotation * Q_PI / 180);
+        }
         qreal right = 0.5 * drawingData[i].scaleX * drawingData[i].source.width();
         qreal bottom = 0.5 * drawingData[i].scaleY * drawingData[i].source.height();
+        if (fragments[i].rotation != 0) {
+            s = qFastSin(fragments[i].rotation * Q_PI / 180);
+            c = qFastCos(fragments[i].rotation * Q_PI / 180);
+        }
+        qreal right = 0.5 * fragments[i].scaleX * fragments[i].width;
+        qreal bottom = 0.5 * fragments[i].scaleY * fragments[i].height;
         QGLPoint bottomRight(right * c - bottom * s, right * s + bottom * c);
         QGLPoint bottomLeft(-right * c - bottom * s, -right * s + bottom * c);
+        vertexCoordinateArray.lineToArray(bottomRight.x + drawingData[i].point.x(), bottomRight.y + drawingData[i].point.y());
+        vertexCoordinateArray.lineToArray(-bottomLeft.x + drawingData[i].point.x(), -bottomLeft.y + drawingData[i].point.y());
+        vertexCoordinateArray.lineToArray(-bottomRight.x + drawingData[i].point.x(), -bottomRight.y + drawingData[i].point.y());
+        vertexCoordinateArray.lineToArray(-bottomRight.x + drawingData[i].point.x(), -bottomRight.y + drawingData[i].point.y());
+        vertexCoordinateArray.lineToArray(bottomLeft.x + drawingData[i].point.x(), bottomLeft.y + drawingData[i].point.y());
+        vertexCoordinateArray.lineToArray(bottomRight.x + drawingData[i].point.x(), bottomRight.y + drawingData[i].point.y());
+        QGLRect src(drawingData[i].source.left() * dx, drawingData[i].source.top() * dy,
+                    drawingData[i].source.right() * dx, drawingData[i].source.bottom() * dy);
+        textureCoordinateArray.lineToArray(src.right, src.bottom);
+        textureCoordinateArray.lineToArray(src.right, src.top);
+        textureCoordinateArray.lineToArray(src.left, src.top);
+        textureCoordinateArray.lineToArray(src.left, src.top);
+        textureCoordinateArray.lineToArray(src.left, src.bottom);
+        textureCoordinateArray.lineToArray(src.right, src.bottom);
+        qreal opacity = drawingData[i].opacity * q->state()->opacity;
+        vertexCoordinateArray.addVertex(bottomRight.x + fragments[i].x, bottomRight.y + fragments[i].y);
+        vertexCoordinateArray.addVertex(-bottomLeft.x + fragments[i].x, -bottomLeft.y + fragments[i].y);
+        vertexCoordinateArray.addVertex(-bottomRight.x + fragments[i].x, -bottomRight.y + fragments[i].y);
+        vertexCoordinateArray.addVertex(-bottomRight.x + fragments[i].x, -bottomRight.y + fragments[i].y);
+        vertexCoordinateArray.addVertex(bottomLeft.x + fragments[i].x, bottomLeft.y + fragments[i].y);
+        vertexCoordinateArray.addVertex(bottomRight.x + fragments[i].x, bottomRight.y + fragments[i].y);
+        QGLRect src(fragments[i].sourceLeft * dx, fragments[i].sourceTop * dy,
+                    (fragments[i].sourceLeft + fragments[i].width) * dx,
+                    (fragments[i].sourceTop + fragments[i].height) * dy);
+        textureCoordinateArray.addVertex(src.right, src.bottom);
+        textureCoordinateArray.addVertex(src.right, src.top);
+        textureCoordinateArray.addVertex(src.left, src.top);
+        textureCoordinateArray.addVertex(src.left, src.top);
+        textureCoordinateArray.addVertex(src.left, src.bottom);
+        textureCoordinateArray.addVertex(src.right, src.bottom);
+        qreal opacity = fragments[i].opacity * q->state()->opacity;
         opacityArray << opacity << opacity << opacity << opacity << opacity << opacity;
         allOpaque &= (opacity >= 0.99f);
 …
         // Flip texture y-coordinate.
         QGLPoint *data = textureCoordinateArray.data();
         for (int i = 0; i < 6 * dataCount; ++i)
+        for (int i = 0; i < 6 * fragmentCount; ++i)
             data[i].y = 1 - data[i].y;
+    }
 …
     bool isBitmap = pixmap.isQBitmap();
     bool isOpaque = !isBitmap && (!pixmap.hasAlphaChannel() || (hints & QDrawPixmaps::OpaqueHint)) && allOpaque;
+    bool isOpaque = !isBitmap && (!pixmap.hasAlpha() || (hints & QPainter::OpaqueHint)) && allOpaque;
     updateTextureFilter(GL_TEXTURE_2D, GL_CLAMP_TO_EDGE,
 …
     // Setup for texture drawing
     currentBrush = noBrush;
+    shaderManager->setSrcPixelType(isBitmap ? QGLEngineShaderManager::PatternSrc : QGLEngineShaderManager::ImageSrc);
+    shaderManager->setSrcPixelType(isBitmap ? QGLEngineShaderManager::PatternSrc
+                                            : QGLEngineShaderManager::ImageSrc);
     if (prepareForDraw(isOpaque))
         shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::ImageTexture), QT_IMAGE_TEXTURE_UNIT);
 …
+    }
     glDrawArrays(GL_TRIANGLES, 0, 6 * dataCount);
+    glDrawArrays(GL_TRIANGLES, 0, 6 * fragmentCount);
+}
 …
     d->brushTextureDirty = true;
     d->brushUniformsDirty = true;
+    d->matrixUniformDirty = true;
     d->matrixDirty = true;
     d->compositionModeDirty = true;
 …
 #if defined(Q_WS_WIN)
     if (qt_cleartype_enabled)
+#endif
+#if defined(Q_WS_MAC)
+    if (qt_applefontsmoothing_enabled)
 #endif
         d->glyphCacheType = QFontEngineGlyphCache::Raster_RGBMask;
 …
         d->unusedVBOSToClean.clear();
+    }
+    if (!d->unusedIBOSToClean.isEmpty()) {
+        glDeleteBuffers(d->unusedIBOSToClean.size(), d->unusedIBOSToClean.constData());
+        d->unusedIBOSToClean.clear();
+    }
 #endif
 …
         glViewport(0, 0, d->width, d->height);
         d->needsSync = false;
+        d->lastMaskTextureUsed = 0;
         d->shaderManager->setDirty();
         d->ctx->d_func()->syncGlState();
 …
         QRectF rect(points[0], points[2]);
+        if (state()->matrix.type() <= QTransform::TxScale) {
+        if (state()->matrix.type() <= QTransform::TxScale
+            || (state()->matrix.type() == QTransform::TxRotate
+                && qFuzzyIsNull(state()->matrix.m11())
+                && qFuzzyIsNull(state()->matrix.m22())))
+        {
             state()->rectangleClip = state()->rectangleClip.intersected(state()->matrix.mapRect(rect).toRect());
             d->updateClipScissorTest();

trunk/src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     virtual void transformChanged();
-    virtual void drawTexture(const QRectF &r, GLuint textureId, const QSize &size, const QRectF &sr);
     virtual void drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr);
+    virtual void drawPixmaps(const QDrawPixmaps::Data *drawingData, int dataCount, const QPixmap &pixmap, QDrawPixmaps::DrawingHints hints);
+    virtual void drawPixmapFragments(const QPainter::PixmapFragment *fragments, int fragmentCount, const QPixmap &pixmap,
+                                     QPainter::PixmapFragmentHints hints);
     virtual void drawImage(const QRectF &r, const QImage &pm, const QRectF &sr,
                            Qt::ImageConversionFlags flags = Qt::AutoColor);
 …
     virtual void clip(const QVectorPath &path, Qt::ClipOperation op);
+    virtual void drawStaticTextItem(QStaticTextItem *textItem);
+    bool drawTexture(const QRectF &r, GLuint textureId, const QSize &size, const QRectF &sr);
     Type type() const { return OpenGL2; }
 …
     void endNativePainting();
+    void invalidateState();
     QPixmapFilter *pixmapFilter(int type, const QPixmapFilter *prototype);
     void setRenderTextActive(bool);
+    bool isNativePaintingActive() const;
 private:
     Q_DISABLE_COPY(QGL2PaintEngineEx)
 };
 class QGL2PaintEngineExPrivate : public QPaintEngineExPrivate
 …
             ctx(0),
             useSystemClip(true),
+            elementIndicesVBOId(0),
+            opacityArray(0),
             snapToPixelGrid(false),
             addOffset(false),
+            inverseScale(1)
+            nativePaintingActive(false),
+            inverseScale(1),
+            lastMaskTextureUsed(0)
     { }
 …
     void stroke(const QVectorPath &path, const QPen &pen);
     void drawTexture(const QGLRect& dest, const QGLRect& src, const QSize &textureSize, bool opaque, bool pattern = false);
+    void drawPixmaps(const QDrawPixmaps::Data *drawingData, int dataCount, const QPixmap &pixmap, QDrawPixmaps::DrawingHints hints);
+    void drawCachedGlyphs(const QPointF &p, QFontEngineGlyphCache::Type glyphType, const QTextItemInt &ti);
+    void drawPixmapFragments(const QPainter::PixmapFragment *fragments, int fragmentCount, const QPixmap &pixmap,
+                             QPainter::PixmapFragmentHints hints);
+    void drawCachedGlyphs(QFontEngineGlyphCache::Type glyphType, QStaticTextItem *staticTextItem);
     // Calls glVertexAttributePointer if the pointer has changed
 …
     bool brushUniformsDirty;
     bool opacityUniformDirty;
+    bool matrixUniformDirty;
     bool stencilClean; // Has the stencil not been used for clipping so far?
 …
     const QBrush noBrush;
+    QPixmap currentBrushPixmap;
     QGL2PEXVertexArray vertexCoordinateArray;
     QGL2PEXVertexArray textureCoordinateArray;
+    QVector<GLushort> elementIndices;
+    GLuint elementIndicesVBOId;
     QDataBuffer<GLfloat> opacityArray;
     GLfloat staticVertexCoordinateArray[8];
 …
     bool snapToPixelGrid;
     bool addOffset; // When enabled, adds a 0.49,0.49 offset to matrix in updateMatrix
+    bool nativePaintingActive;
     GLfloat pmvMatrix[3][3];
     GLfloat inverseScale;
     GLuint lastTextureUsed;
+    GLuint lastMaskTextureUsed;
     bool needsSync;
 …
     QSet<QVectorPath::CacheEntry *> pathCaches;
     QVector<GLuint> unusedVBOSToClean;
+    QVector<GLuint> unusedIBOSToClean;
     const GLfloat *vertexAttribPointers[3];

trunk/src/opengl/gl2paintengineex/qtextureglyphcache_gl.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #include "qpaintengineex_opengl2_p.h"
+#if defined QT_OPENGL_ES_2 && !defined(QT_NO_EGL)
+#include "private/qeglcontext_p.h"
+#endif
 QT_BEGIN_NAMESPACE
 …
 QGLTextureGlyphCache::QGLTextureGlyphCache(QGLContext *context, QFontEngineGlyphCache::Type type, const QTransform &matrix)
     : QTextureGlyphCache(type, matrix)
     , ctx(context)
+    : QImageTextureGlyphCache(type, matrix)
+    , ctx(0)
     , m_width(0)
     , m_height(0)
+{
+    glGenFramebuffers(1, &m_fbo);
+    , m_filterMode(Nearest)
+{
+    setContext(context);
+}
+void QGLTextureGlyphCache::setContext(QGLContext *context)
+{
+    ctx = context;
+    // broken FBO readback is a bug in the SGX 1.3 and 1.4 drivers for the N900 where
+    // copying between FBO's is broken if the texture is either GL_ALPHA or POT. The
+    // workaround is to use a system-memory copy of the glyph cache for this device.
+    // Switching to NPOT and GL_RGBA would both cost a lot more graphics memory and
+    // be slower, so that is not desireable.
+    if (!ctx->d_ptr->workaround_brokenFBOReadBack)
+        glGenFramebuffers(1, &m_fbo);
     connect(QGLSignalProxy::instance(), SIGNAL(aboutToDestroyContext(const QGLContext*)),
             SLOT(contextDestroyed(const QGLContext*)));
+}
+QGLTextureGlyphCache::~QGLTextureGlyphCache()
+void QGLTextureGlyphCache::clear()
+{
     if (ctx) {
         QGLShareContextScope scope(ctx);
-        glDeleteFramebuffers(1, &m_fbo);
         if (m_width || m_height)
             glDeleteTextures(1, &m_texture);
+    }
+        m_texture = 0;
+        m_width = 0;
+        m_height = 0;
+        m_w = 0;
+        m_h = 0;
+        m_cx = 0;
+        m_cy = 0;
+        m_currentRowHeight = 0;
+        coords.clear();
+    }
+}
+QGLTextureGlyphCache::~QGLTextureGlyphCache()
+{
+    if (ctx) {
+        QGLShareContextScope scope(ctx);
+        if (!ctx->d_ptr->workaround_brokenFBOReadBack)
+            glDeleteFramebuffers(1, &m_fbo);
+    }
+    clear();
+}
 void QGLTextureGlyphCache::createTextureData(int width, int height)
+{
+    // create in QImageTextureGlyphCache baseclass is meant to be called
+    // only to create the initial image and does not preserve the content,
+    // so we don't call when this function is called from resize.
+    if (ctx->d_ptr->workaround_brokenFBOReadBack && image().isNull())
+        QImageTextureGlyphCache::createTextureData(width, height);
+    // Make the lower glyph texture size 16 x 16.
+    if (width < 16)
+        width = 16;
+    if (height < 16)
+        height = 16;
     glGenTextures(1, &m_texture);
     glBindTexture(GL_TEXTURE_2D, m_texture);
 …
     m_height = height;
+    QVarLengthArray<uchar> data(width * height);
+    for (int i = 0; i < data.size(); ++i)
+        data[i] = 0;
+    if (m_type == QFontEngineGlyphCache::Raster_RGBMask)
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_ALPHA, GL_UNSIGNED_BYTE, &data[0]);
+    else
+    if (m_type == QFontEngineGlyphCache::Raster_RGBMask) {
+        QVarLengthArray<uchar> data(width * height * 4);
+        for (int i = 0; i < data.size(); ++i)
+            data[i] = 0;
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, &data[0]);
+    } else {
+        QVarLengthArray<uchar> data(width * height);
+        for (int i = 0; i < data.size(); ++i)
+            data[i] = 0;
         glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, width, height, 0, GL_ALPHA, GL_UNSIGNED_BYTE, &data[0]);
+    }
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    m_filterMode = Nearest;
+}
 void QGLTextureGlyphCache::resizeTextureData(int width, int height)
+{
+    int oldWidth = m_width;
+    int oldHeight = m_height;
+    // Make the lower glyph texture size 16 x 16.
+    if (width < 16)
+        width = 16;
+    if (height < 16)
+        height = 16;
+    GLuint oldTexture = m_texture;
+    createTextureData(width, height);
+    if (ctx->d_ptr->workaround_brokenFBOReadBack) {
+        QImageTextureGlyphCache::resizeTextureData(width, height);
+        Q_ASSERT(image().depth() == 8);
+        glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, oldHeight, GL_ALPHA, GL_UNSIGNED_BYTE, image().constBits());
+        glDeleteTextures(1, &oldTexture);
+        return;
+    }
     // ### the QTextureGlyphCache API needs to be reworked to allow
     // ### resizeTextureData to fail
-    int oldWidth = m_width;
-    int oldHeight = m_height;
-    GLuint oldTexture = m_texture;
-    createTextureData(width, height);
     glBindFramebuffer(GL_FRAMEBUFFER_EXT, m_fbo);
 …
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    m_filterMode = Nearest;
     glBindTexture(GL_TEXTURE_2D, 0);
     glFramebufferTexture2D(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
 …
     glBindTexture(GL_TEXTURE_2D, m_texture);
-#ifdef QT_OPENGL_ES_2
-    QDataBuffer<uchar> buffer(4*oldWidth*oldHeight);
-    buffer.resize(4*oldWidth*oldHeight);
-    glReadPixels(0, 0, oldWidth, oldHeight, GL_RGBA, GL_UNSIGNED_BYTE, buffer.data());
-    // do an in-place conversion from GL_RGBA to GL_ALPHA
-    for (int i=0; i<oldWidth*oldHeight; ++i)
-        buffer.data()[i] = buffer.at(4*i + 3);
-    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, oldWidth, oldHeight,
-                    GL_ALPHA, GL_UNSIGNED_BYTE, buffer.data());
-#else
     glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, oldWidth, oldHeight);
-#endif
     glFramebufferRenderbuffer(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
 …
 void QGLTextureGlyphCache::fillTexture(const Coord &c, glyph_t glyph)
+{
+    if (ctx->d_ptr->workaround_brokenFBOReadBack) {
+        QImageTextureGlyphCache::fillTexture(c, glyph);
+        glBindTexture(GL_TEXTURE_2D, m_texture);
+        const QImage &texture = image();
+        const uchar *bits = texture.constBits();
+        bits += c.y * texture.bytesPerLine() + c.x;
+        for (int i=0; i<c.h; ++i) {
+            glTexSubImage2D(GL_TEXTURE_2D, 0, c.x, c.y + i, c.w, 1, GL_ALPHA, GL_UNSIGNED_BYTE, bits);
+            bits += texture.bytesPerLine();
+        }
+        return;
+    }
     QImage mask = textureMapForGlyph(glyph);
     const int maskWidth = mask.width();
 …
         glTexSubImage2D(GL_TEXTURE_2D, 0, c.x, c.y, maskWidth, maskHeight, GL_BGRA, GL_UNSIGNED_BYTE, mask.bits());
     } else {
-#ifdef QT_OPENGL_ES2
-        glTexSubImage2D(GL_TEXTURE_2D, 0, c.x, c.y, maskWidth, maskHeight, GL_ALPHA, GL_UNSIGNED_BYTE, mask.bits());
-#else
         // glTexSubImage2D() might cause some garbage to appear in the texture if the mask width is
         // not a multiple of four bytes. The bug appeared on a computer with 32-bit Windows Vista
 …
         for (int i = 0; i < maskHeight; ++i)
             glTexSubImage2D(GL_TEXTURE_2D, 0, c.x, c.y + i, maskWidth, 1, GL_ALPHA, GL_UNSIGNED_BYTE, mask.scanLine(i));
+#endif
+    }
+}
+int QGLTextureGlyphCache::glyphMargin() const
+{
+#if defined(Q_WS_MAC)
+    return 2;
+#elif defined (Q_WS_X11)
+    return 0;
+#else
+    return m_type == QFontEngineGlyphCache::Raster_RGBMask ? 2 : 0;
+#endif
+}
+    }
+}
+int QGLTextureGlyphCache::glyphPadding() const
+{
+    return 1;
+}
+int QGLTextureGlyphCache::maxTextureWidth() const
+{
+    return ctx->d_ptr->maxTextureSize();
+}
+int QGLTextureGlyphCache::maxTextureHeight() const
+{
+    if (ctx->d_ptr->workaround_brokenTexSubImage)
+        return qMin(1024, ctx->d_ptr->maxTextureSize());
+    else
+        return ctx->d_ptr->maxTextureSize();
+}
 QT_END_NAMESPACE

trunk/src/opengl/gl2paintengineex/qtextureglyphcache_gl_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 class QGL2PaintEngineExPrivate;
 class QGLTextureGlyphCache : public QObject, public QTextureGlyphCache
+class Q_OPENGL_EXPORT QGLTextureGlyphCache : public QObject, public QImageTextureGlyphCache
+{
     Q_OBJECT
 …
     virtual void resizeTextureData(int width, int height);
     virtual void fillTexture(const Coord &c, glyph_t glyph);
+    virtual int glyphMargin() const;
+    virtual int glyphPadding() const;
+    virtual int maxTextureWidth() const;
+    virtual int maxTextureHeight() const;
     inline GLuint texture() const { return m_texture; }
 …
     inline void setPaintEnginePrivate(QGL2PaintEngineExPrivate *p) { pex = p; }
+    enum FilterMode {
+        Nearest,
+        Linear
+    };
+    FilterMode filterMode() const { return m_filterMode; }
+    void setFilterMode(FilterMode m) { m_filterMode = m; }
+    void setContext(QGLContext *context);
+    QGLContext *context() const { return ctx; }
 public Q_SLOTS:
 …
                 // destroy the fbo and texture here, but since the context
                 // is about to be destroyed, the GL server will do the
+                // clean up for us anyway
+                // clean up for us anyway. We reset everything, so that the
+                // glyph cache object can be reused later by setting a new
+                // context on it.
                 m_fbo = 0;
                 m_texture = 0;
                 ctx = 0;
+                m_width = 0;
+                m_height = 0;
+                m_w = 0;
+                m_h = 0;
+                m_cx = 0;
+                m_cy = 0;
+                m_currentRowHeight = 0;
+                coords.clear();
             } else {
                 // since the context holding the texture is shared, and
 …
+        }
+    }
+    void clear();
 private:
 …
     QGLShaderProgram *m_program;
+    FilterMode m_filterMode;
 };

trunk/src/opengl/gl2paintengineex/qtriangulatingstroker.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 void QTriangulatingStroker::process(const QVectorPath &path, const QPen &pen)
+void QTriangulatingStroker::process(const QVectorPath &path, const QPen &pen, const QRectF &)
+{
     const qreal *pts = path.points();
 …
     //
     // The curvyness value of PI/14 was based on,
     // arcLength=2*PI*r/4=PI/2 and splitting length into somewhere
+    // arcLength = 2*PI*r/4 = PI*r/2 and splitting length into somewhere
     // between 3 and 8 where 5 seemed to be give pretty good results
     // hence: Q_PI/14. Lower divisors will give more detail at the
 …
 QDashedStrokeProcessor::QDashedStrokeProcessor()
+    : m_dash_stroker(0), m_inv_scale(1)
+    : m_points(0), m_types(0),
+      m_dash_stroker(0), m_inv_scale(1)
+{
     m_dash_stroker.setMoveToHook(qdashprocessor_moveTo);
 …
+}
 void QDashedStrokeProcessor::process(const QVectorPath &path, const QPen &pen)
+void QDashedStrokeProcessor::process(const QVectorPath &path, const QPen &pen, const QRectF &clip)
+{
 …
     int count = path.elementCount();
+    bool cosmetic = pen.isCosmetic();
     m_points.reset();
     m_types.reset();
+    m_points.reserve(path.elementCount());
+    m_types.reserve(path.elementCount());
     qreal width = qpen_widthf(pen);
 …
     m_dash_stroker.setDashPattern(pen.dashPattern());
+    m_dash_stroker.setStrokeWidth(pen.isCosmetic() ? width * m_inv_scale : width);
+    m_dash_stroker.setStrokeWidth(cosmetic ? width * m_inv_scale : width);
+    m_dash_stroker.setDashOffset(pen.dashOffset());
     m_dash_stroker.setMiterLimit(pen.miterLimit());
+    qreal curvyness = sqrt(width) * m_inv_scale / 8;
+    m_dash_stroker.setClipRect(clip);
+    float curvynessAdd, curvynessMul, roundness = 0;
+    // simplfy pens that are thin in device size (2px wide or less)
+    if (width < 2.5 && (cosmetic || m_inv_scale == 1)) {
+        curvynessAdd = 0.5;
+        curvynessMul = CURVE_FLATNESS / m_inv_scale;
+        roundness = 1;
+    } else if (cosmetic) {
+        curvynessAdd= width / 2;
+        curvynessMul= CURVE_FLATNESS;
+        roundness = qMax<int>(4, width * CURVE_FLATNESS);
+    } else {
+        curvynessAdd = width * m_inv_scale;
+        curvynessMul = CURVE_FLATNESS / m_inv_scale;
+        roundness = qMax<int>(4, width * curvynessMul);
+    }
     if (count < 2)
 …
                                                 *(((const QPointF *) pts) + 2));
                 QRectF bounds = b.bounds();
+                int threshold = qMin<float>(64, qMax(bounds.width(), bounds.height()) * curvyness);
+                float rad = qMax(bounds.width(), bounds.height());
+                int threshold = qMin<float>(64, (rad + curvynessAdd) * curvynessMul);
                 if (threshold < 4)
                     threshold = 4;
                 qreal threshold_minus_1 = threshold - 1;
                 for (int i=0; i<threshold; ++i) {

trunk/src/opengl/gl2paintengineex/qtriangulatingstroker_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
+{
 public:
+    void process(const QVectorPath &path, const QPen &pen);
+    QTriangulatingStroker() : m_vertices(0) {}
+    void process(const QVectorPath &path, const QPen &pen, const QRectF &clip);
     inline int vertexCount() const { return m_vertices.size(); }
 …
     QDashedStrokeProcessor();
     void process(const QVectorPath &path, const QPen &pen);
+    void process(const QVectorPath &path, const QPen &pen, const QRectF &clip);
     inline void addElement(QPainterPath::ElementType type, qreal x, qreal y) {

trunk/src/opengl/opengl.pro

-              r651
+              r846
 win32-msvc*|win32-icc:QMAKE_LFLAGS += /BASE:0x63000000
 solaris-cc*:QMAKE_CXXFLAGS_RELEASE -= -O2
+irix-cc*:QMAKE_CXXFLAGS += -no_prelink -ptused
 unix:QMAKE_PKGCONFIG_REQUIRES = QtCore QtGui
 …
 include(../qbase.pri)
 !win32:!embedded:!mac:CONFIG       += x11
+!win32:!embedded:!mac:!symbian:CONFIG      += x11
 contains(QT_CONFIG, opengl):CONFIG += opengl
 contains(QT_CONFIG, opengles1):CONFIG += opengles1
-contains(QT_CONFIG, opengles1cl):CONFIG += opengles1cl
 contains(QT_CONFIG, opengles2):CONFIG += opengles2
 contains(QT_CONFIG, egl):CONFIG += egl
 HEADERS += qgl.h \
            qgl_p.h \
            qglcolormap.h \
            qglpixelbuffer.h \
+           qgl_p.h \
+           qglcolormap.h \
+           qglpixelbuffer.h \
            qglpixelbuffer_p.h \
            qglframebufferobject.h  \
+           qglframebufferobject.h  \
            qglframebufferobject_p.h  \
            qglextensions_p.h \
            qglpaintdevice_p.h \
+           qglbuffer.h \
 SOURCES += qgl.cpp \
            qglcolormap.cpp \
            qglpixelbuffer.cpp \
            qglframebufferobject.cpp \
+           qglcolormap.cpp \
+           qglpixelbuffer.cpp \
+           qglframebufferobject.cpp \
            qglextensions.cpp \
            qglpaintdevice.cpp \
+           qglbuffer.cpp \
 …
+}
 !contains(QT_CONFIG, opengles1):!contains(QT_CONFIG, opengles1cl) {
+!contains(QT_CONFIG, opengles1) {
     HEADERS +=  qglshaderprogram.h \
                 qglpixmapfilter_p.h  \
 …
                 gl2paintengineex/qglcustomshaderstage_p.h \
                 gl2paintengineex/qtriangulatingstroker_p.h \
+                gl2paintengineex/qtriangulator_p.h \
                 gl2paintengineex/qtextureglyphcache_gl_p.h
 …
                 gl2paintengineex/qglcustomshaderstage.cpp \
                 gl2paintengineex/qtriangulatingstroker.cpp \
+                gl2paintengineex/qtriangulator.cpp \
                 gl2paintengineex/qtextureglyphcache_gl.cpp
 …
 x11 {
     contains(QT_CONFIG, opengles1)|contains(QT_CONFIG, opengles1cl)|contains(QT_CONFIG, opengles2) {
+    contains(QT_CONFIG, egl) {
         SOURCES +=  qgl_x11egl.cpp \
                     qglpixelbuffer_egl.cpp \
 …
+}
 win32:!wince*: {
+    DEFINES += QT_NO_EGL
     SOURCES += qgl_win.cpp \
                qglpixelbuffer_win.cpp
+                   qglpixelbuffer_win.cpp
+}
 wince*: {
 …
                qgl_egl.cpp
+    HEADERS += qgl_cl_p.h \
+               qgl_egl_p.h \
+    HEADERS += qgl_egl_p.h
+}
 …
+}
+symbian {
+    SOURCES += qgl_symbian.cpp \
+               qglpixelbuffer_egl.cpp \
+               qgl_egl.cpp
+    HEADERS += qgl_egl_p.h
+    symbian:TARGET.UID3 = 0x2002131A
+}
 INCLUDEPATH += ../3rdparty/harfbuzz/src

trunk/src/opengl/qgl.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #define INT32 dummy_INT32
 #define INT8 dummy_INT8
 #if !defined(QT_OPENGL_ES)
+#ifdef QT_NO_EGL
 # include <GL/glx.h>
 #endif
 …
 #include "qgl_p.h"
 #if !defined(QT_OPENGL_ES_1) && !defined(QT_OPENGL_ES_1_CL)
+#if !defined(QT_OPENGL_ES_1)
 #include "gl2paintengineex/qpaintengineex_opengl2_p.h"
 #endif
 …
 #include "qfile.h"
 #include "qlibrary.h"
+#include <qmutex.h>
 QT_BEGIN_NAMESPACE
+#ifdef QT_OPENGL_ES_1_CL
+#include "qgl_cl_p.h"
+#endif
+#if defined(Q_WS_X11) || defined(Q_WS_MAC) || defined(Q_WS_QWS)
+#if defined(Q_WS_X11) || defined(Q_WS_MAC) || defined(Q_WS_QWS) || defined(Q_OS_SYMBIAN)
 QGLExtensionFuncs QGLContextPrivate::qt_extensionFuncs;
 #endif
 …
 QGLSignalProxy *QGLSignalProxy::instance()
+{
+    return theSignalProxy();
+    QGLSignalProxy *proxy = theSignalProxy();
+    if (proxy && proxy->thread() != qApp->thread()) {
+        if (proxy->thread() == QThread::currentThread())
+            proxy->moveToThread(qApp->thread());
+    }
+    return proxy;
+}
 …
     \value HasOverlay        Enables the use of an overlay.
     \value SampleBuffers     Enables the use of sample buffers.
+    \value DeprecatedFunctions      Enables the use of deprecated functionality for OpenGL 3.x
+                                    contexts. A context with deprecated functionality enabled is
+                                    called a full context in the OpenGL specification.
     \value SingleBuffer      Specifies the use of a single buffer, as opposed to double buffers.
     \value NoDepthBuffer     Disables the use of a depth buffer.
 …
     \value NoOverlay         Disables the use of an overlay.
     \value NoSampleBuffers   Disables the use of sample buffers.
+    \value NoDeprecatedFunctions    Disables the use of deprecated functionality for OpenGL 3.x
+                                    contexts. A context with deprecated functionality disabled is
+                                    called a forward compatible context in the OpenGL specification.
     \sa {Sample Buffers Example}
 …
     flicker-free drawing and often better performance.
+    Note that single buffered contexts are currently not supported
+    with EGL.
     \sa doubleBuffer(), QGLContext::swapBuffers(),
     QGLWidget::swapBuffers()
 …
+    }
     d->numSamples = numSamples;
+    setSampleBuffers(numSamples > 0);
+}
 …
+    }
     d->depthSize = size;
+    setDepth(size > 0);
+}
 …
+    }
     d->alphaSize = size;
     setOption(QGL::AlphaChannel);
+    setAlpha(size > 0);
+}
 …
+    }
     d->accumSize = size;
+    setAccum(size > 0);
+}
 …
+    }
     d->stencilSize = size;
+    setStencil(size > 0);
+}
 …
    return d->stencilSize;
+}
+/*!
+    \since 4.7
+    Set the OpenGL version to the \a major and \a minor numbers. If a
+    context compatible with the requested OpenGL version cannot be
+    created, a context compatible with version 1.x is created instead.
+    \sa majorVersion(), minorVersion()
+*/
+void QGLFormat::setVersion(int major, int minor)
+{
+    if (major < 1 || minor < 0) {
+        qWarning("QGLFormat::setVersion: Cannot set zero or negative version number %d.%d", major, minor);
+        return;
+    }
+    detach();
+    d->majorVersion = major;
+    d->minorVersion = minor;
+}
+/*!
+    \since 4.7
+    Returns the OpenGL major version.
+    \sa setVersion(), minorVersion()
+*/
+int QGLFormat::majorVersion() const
+{
+    return d->majorVersion;
+}
+/*!
+    \since 4.7
+    Returns the OpenGL minor version.
+    \sa setVersion(), majorVersion()
+*/
+int QGLFormat::minorVersion() const
+{
+    return d->minorVersion;
+}
+/*!
+    \enum QGLFormat::OpenGLContextProfile
+    \since 4.7
+    This enum describes the OpenGL context profiles that can be
+    specified for contexts implementing OpenGL version 3.2 or
+    higher. These profiles are different from OpenGL ES profiles.
+    \value NoProfile            OpenGL version is lower than 3.2.
+    \value CoreProfile          Functionality deprecated in OpenGL version 3.0 is not available.
+    \value CompatibilityProfile Functionality from earlier OpenGL versions is available.
+*/
+/*!
+    \since 4.7
+    Set the OpenGL context profile to \a profile. The \a profile is
+    ignored if the requested OpenGL version is less than 3.2.
+    \sa profile()
+*/
+void QGLFormat::setProfile(OpenGLContextProfile profile)
+{
+    detach();
+    d->profile = profile;
+}
+/*!
+    \since 4.7
+    Returns the OpenGL context profile.
+    \sa setProfile()
+*/
+QGLFormat::OpenGLContextProfile QGLFormat::profile() const
+{
+    return d->profile;
+}
 /*!
 …
                         versionFlags |= QGLFormat::OpenGL_ES_Common_Version_1_1 |
                                         QGLFormat::OpenGL_ES_CommonLite_Version_1_1;
+                }
+                else {
+                } else {
                     // Not -CM, must be CL, CommonLite
                     versionFlags |= QGLFormat::OpenGL_ES_CommonLite_Version_1_0;
 …
                         versionFlags |= QGLFormat::OpenGL_ES_CommonLite_Version_1_1;
+                }
+            }
+            else {
+            } else {
                 // OpenGL ES version 2.0 or higher
                 versionFlags |= QGLFormat::OpenGL_ES_Version_2_0;
+            }
+        }
+        else {
+        } else {
             // if < 3 parts to the name, it is an unrecognised OpenGL ES
             qWarning("Unrecognised OpenGL ES version");
+        }
+    }
+    else {
+    } else {
         // not ES, regular OpenGL, the version numbers are first in the string
         if (versionString.startsWith(QLatin1String("1."))) {
 …
                 break;
+            }
+        }
+        else if (versionString.startsWith(QLatin1String("2."))) {
+        } else if (versionString.startsWith(QLatin1String("2."))) {
             versionFlags |= QGLFormat::OpenGL_Version_1_1 |
                             QGLFormat::OpenGL_Version_1_2 |
 …
                             QGLFormat::OpenGL_Version_1_5 |
                             QGLFormat::OpenGL_Version_2_0;
+            QString minorVersion = versionString.section(QLatin1Char(' '), 0, 0).section(QLatin1Char('.'), 1, 1);
+            if (minorVersion == QChar(QLatin1Char('1')))
+            if (versionString[2].toAscii() == '1')
                 versionFlags |= QGLFormat::OpenGL_Version_2_1;
+        } else if (versionString.startsWith(QLatin1String("3."))) {
+            versionFlags |= QGLFormat::OpenGL_Version_1_1 |
+                            QGLFormat::OpenGL_Version_1_2 |
+                            QGLFormat::OpenGL_Version_1_3 |
+                            QGLFormat::OpenGL_Version_1_4 |
+                            QGLFormat::OpenGL_Version_1_5 |
+                            QGLFormat::OpenGL_Version_2_0 |
+                            QGLFormat::OpenGL_Version_2_1 |
+                            QGLFormat::OpenGL_Version_3_0;
+            switch (versionString[2].toAscii()) {
+            case '3':
+                versionFlags |= QGLFormat::OpenGL_Version_3_3;
+            case '2':
+                versionFlags |= QGLFormat::OpenGL_Version_3_2;
+            case '1':
+                versionFlags |= QGLFormat::OpenGL_Version_3_1;
+            case '0':
+                break;
+            default:
+                versionFlags |= QGLFormat::OpenGL_Version_3_1 |
+                                QGLFormat::OpenGL_Version_3_2 |
+                                QGLFormat::OpenGL_Version_3_3;
+                break;
+            }
+        } else if (versionString.startsWith(QLatin1String("4."))) {
+            versionFlags |= QGLFormat::OpenGL_Version_1_1 |
+                            QGLFormat::OpenGL_Version_1_2 |
+                            QGLFormat::OpenGL_Version_1_3 |
+                            QGLFormat::OpenGL_Version_1_4 |
+                            QGLFormat::OpenGL_Version_1_5 |
+                            QGLFormat::OpenGL_Version_2_0 |
+                            QGLFormat::OpenGL_Version_2_1 |
+                            QGLFormat::OpenGL_Version_3_0 |
+                            QGLFormat::OpenGL_Version_3_1 |
+                            QGLFormat::OpenGL_Version_3_2 |
+                            QGLFormat::OpenGL_Version_3_3 |
+                            QGLFormat::OpenGL_Version_4_0;
+        } else {
+            versionFlags |= QGLFormat::OpenGL_Version_1_1 |
+                            QGLFormat::OpenGL_Version_1_2 |
+                            QGLFormat::OpenGL_Version_1_3 |
+                            QGLFormat::OpenGL_Version_1_4 |
+                            QGLFormat::OpenGL_Version_1_5 |
+                            QGLFormat::OpenGL_Version_2_0 |
+                            QGLFormat::OpenGL_Version_2_1 |
+                            QGLFormat::OpenGL_Version_3_0 |
+                            QGLFormat::OpenGL_Version_3_1 |
+                            QGLFormat::OpenGL_Version_3_2 |
+                            QGLFormat::OpenGL_Version_3_3 |
+                            QGLFormat::OpenGL_Version_4_0;
+        }
-        else if (versionString.startsWith(QLatin1String("3."))) {
-         versionFlags |= QGLFormat::OpenGL_Version_1_1 |
-                         QGLFormat::OpenGL_Version_1_2 |
-                         QGLFormat::OpenGL_Version_1_3 |
-                         QGLFormat::OpenGL_Version_1_4 |
-                         QGLFormat::OpenGL_Version_1_5 |
-                         QGLFormat::OpenGL_Version_2_0 |
-                         QGLFormat::OpenGL_Version_2_1 |
-                         QGLFormat::OpenGL_Version_3_0;
+        }
-        else
-            qWarning("Unrecognised OpenGL version");
+    }
     return versionFlags;
 …
     \value OpenGL_Version_3_0  OpenGL version 3.0 or higher is present.
+    \value OpenGL_Version_3_1  OpenGL version 3.1 or higher is present.
+    Note that OpenGL version 3.1 or higher does not necessarily support all the features of
+    version 3.0 and lower.
+    \value OpenGL_Version_3_2  OpenGL version 3.2 or higher is present.
+    \value OpenGL_Version_3_3  OpenGL version 3.3 or higher is present.
+    \value OpenGL_Version_4_0  OpenGL version 4.0 or higher is present.
     \value OpenGL_ES_CommonLite_Version_1_0  OpenGL ES version 1.0 Common Lite or higher is present.
 …
 bool operator==(const QGLFormat& a, const QGLFormat& b)
+{
+    return (int) a.d->opts == (int) b.d->opts && a.d->pln == b.d->pln && a.d->alphaSize == b.d->alphaSize
+        && a.d->accumSize == b.d->accumSize && a.d->stencilSize == b.d->stencilSize
+    return (a.d == b.d) || ((int) a.d->opts == (int) b.d->opts
+        && a.d->pln == b.d->pln
+        && a.d->alphaSize == b.d->alphaSize
+        && a.d->accumSize == b.d->accumSize
+        && a.d->stencilSize == b.d->stencilSize
         && a.d->depthSize == b.d->depthSize
         && a.d->redSize == b.d->redSize
 …
         && a.d->blueSize == b.d->blueSize
         && a.d->numSamples == b.d->numSamples
+        && a.d->swapInterval == b.d->swapInterval;
+}
+        && a.d->swapInterval == b.d->swapInterval
+        && a.d->majorVersion == b.d->majorVersion
+        && a.d->minorVersion == b.d->minorVersion
+        && a.d->profile == b.d->profile);
+}
+#ifndef QT_NO_DEBUG_STREAM
+QDebug operator<<(QDebug dbg, const QGLFormat &f)
+{
+    const QGLFormatPrivate * const d = f.d;
+    dbg.nospace() << "QGLFormat("
+                  << "options " << d->opts
+                  << ", plane " << d->pln
+                  << ", depthBufferSize " << d->depthSize
+                  << ", accumBufferSize " << d->accumSize
+                  << ", stencilBufferSize " << d->stencilSize
+                  << ", redBufferSize " << d->redSize
+                  << ", greenBufferSize " << d->greenSize
+                  << ", blueBufferSize " << d->blueSize
+                  << ", alphaBufferSize " << d->alphaSize
+                  << ", samples " << d->numSamples
+                  << ", swapInterval " << d->swapInterval
+                  << ", majorVersion " << d->majorVersion
+                  << ", minorVersion " << d->minorVersion
+                  << ", profile " << d->profile
+                  << ')';
+    return dbg.space();
+}
+#endif
 …
     return !(a == b);
+}
+struct QGLContextGroupList {
+    void append(QGLContextGroup *group) {
+        QMutexLocker locker(&m_mutex);
+        m_list.append(group);
+    }
+    void remove(QGLContextGroup *group) {
+        QMutexLocker locker(&m_mutex);
+        m_list.removeOne(group);
+    }
+    QList<QGLContextGroup *> m_list;
+    QMutex m_mutex;
+};
+Q_GLOBAL_STATIC(QGLContextGroupList, qt_context_groups)
 /*****************************************************************************
   QGLContext implementation
  *****************************************************************************/
+QGLContextGroup::QGLContextGroup(const QGLContext *context)
+    : m_context(context), m_guards(0), m_refs(1)
+{
+    qt_context_groups()->append(this);
+}
 QGLContextGroup::~QGLContextGroup()
 …
         guard = guard->m_next;
+    }
+    qt_context_groups()->remove(this);
+}
 …
+}
+QGLContextPrivate::QGLContextPrivate(QGLContext *context)
+    : internal_context(false)
+    , q_ptr(context)
+{
+    group = new QGLContextGroup(context);
+    texture_destroyer = new QGLTextureDestroyer;
+    texture_destroyer->moveToThread(qApp->thread());
+}
 QGLContextPrivate::~QGLContextPrivate()
+{
 …
         delete group;
+    }
+    delete texture_destroyer;
+}
 …
     vi = 0;
 #endif
+#if defined(QT_OPENGL_ES)
+#ifndef QT_NO_EGL
+    ownsEglContext = false;
     eglContext = 0;
     eglSurface = EGL_NO_SURFACE;
 …
     default_fbo = 0;
     active_engine = 0;
+    workaround_needsFullClearOnEveryFrame = false;
+    workaround_brokenFBOReadBack = false;
+    workaround_brokenTexSubImage = false;
+    workaroundsCached = false;
+    workaround_brokenTextureFromPixmap = false;
+    workaround_brokenTextureFromPixmap_init = false;
     for (int i = 0; i < QT_GL_VERTEX_ARRAY_TRACKED_COUNT; ++i)
         vertexAttributeArraysEnabledState[i] = false;
 …
     int w = size.width();
     int h = size.height();
 #if !defined(QT_OPENGL_ES_2) && !defined(QT_OPENGL_ES_1) && !defined(QT_OPENGL_ES_1_CL)
+#if !defined(QT_OPENGL_ES_2) && !defined(QT_OPENGL_ES_1)
     //### glGetTexImage not in GL ES 2.0, need to do something else here!
     glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, img.bits());
 …
 extern Q_GUI_EXPORT _qt_image_cleanup_hook_64 qt_image_cleanup_hook_64;
+static QGLTextureCache *qt_gl_texture_cache = 0;
+Q_GLOBAL_STATIC(QGLTextureCache, qt_gl_texture_cache)
 QGLTextureCache::QGLTextureCache()
     : m_cache(64*1024) // cache ~64 MB worth of textures - this is not accurate though
+{
-    Q_ASSERT(qt_gl_texture_cache == 0);
-    qt_gl_texture_cache = this;
     QImagePixmapCleanupHooks::instance()->addPixmapDataModificationHook(cleanupTexturesForPixampData);
     QImagePixmapCleanupHooks::instance()->addPixmapDataDestructionHook(cleanupBeforePixmapDestruction);
 …
 QGLTextureCache::~QGLTextureCache()
+{
-    qt_gl_texture_cache = 0;
     QImagePixmapCleanupHooks::instance()->removePixmapDataModificationHook(cleanupTexturesForPixampData);
     QImagePixmapCleanupHooks::instance()->removePixmapDataDestructionHook(cleanupBeforePixmapDestruction);
 …
 void QGLTextureCache::insert(QGLContext* ctx, qint64 key, QGLTexture* texture, int cost)
+{
+    QWriteLocker locker(&m_lock);
     if (m_cache.totalCost() + cost > m_cache.maxCost()) {
         // the cache is full - make an attempt to remove something
         const QList<qint64> keys = m_cache.keys();
+        const QList<QGLTextureCacheKey> keys = m_cache.keys();
         int i = 0;
         while (i < m_cache.count()
 …
+        }
+    }
+    m_cache.insert(key, texture, cost);
+    const QGLTextureCacheKey cacheKey = {key, QGLContextPrivate::contextGroup(ctx)};
+    m_cache.insert(cacheKey, texture, cost);
+}
+void QGLTextureCache::remove(qint64 key)
+{
+    QWriteLocker locker(&m_lock);
+    QMutexLocker groupLocker(&qt_context_groups()->m_mutex);
+    QList<QGLContextGroup *>::const_iterator it = qt_context_groups()->m_list.constBegin();
+    while (it != qt_context_groups()->m_list.constEnd()) {
+        const QGLTextureCacheKey cacheKey = {key, *it};
+        m_cache.remove(cacheKey);
+        ++it;
+    }
+}
 bool QGLTextureCache::remove(QGLContext* ctx, GLuint textureId)
+{
+    QList<qint64> keys = m_cache.keys();
+    QWriteLocker locker(&m_lock);
+    QList<QGLTextureCacheKey> keys = m_cache.keys();
     for (int i = 0; i < keys.size(); ++i) {
         QGLTexture *tex = m_cache.object(keys.at(i));
 …
 void QGLTextureCache::removeContextTextures(QGLContext* ctx)
+{
+    QList<qint64> keys = m_cache.keys();
+    QWriteLocker locker(&m_lock);
+    QList<QGLTextureCacheKey> keys = m_cache.keys();
     for (int i = 0; i < keys.size(); ++i) {
         const qint64 &key = keys.at(i);
+        const QGLTextureCacheKey &key = keys.at(i);
         if (m_cache.object(key)->context == ctx)
             m_cache.remove(key);
+    }
+}
-QGLTextureCache* QGLTextureCache::instance()
+{
-    if (!qt_gl_texture_cache)
-        qt_gl_texture_cache = new QGLTextureCache;
-    return qt_gl_texture_cache;
+}
 …
 void QGLTextureCache::cleanupTexturesForCacheKey(qint64 cacheKey)
+{
+    // ### remove when the GL texture cache becomes thread-safe
+    if (qApp->thread() == QThread::currentThread()) {
+        instance()->remove(cacheKey);
+        Q_ASSERT(instance()->getTexture(cacheKey) == 0);
+    }
+    qt_gl_texture_cache()->remove(cacheKey);
+}
 …
+}
+void QGLTextureCache::deleteIfEmpty()
+{
+    if (instance()->size() == 0)
+        delete instance();
+QGLTextureCache *QGLTextureCache::instance()
+{
+    return qt_gl_texture_cache();
+}
 …
     \omitvalue CanFlipNativePixmapBindOption Used by x11 from pixmap to choose
     wether or not it can bind the pixmap upside down or not.
+    whether or not it can bind the pixmap upside down or not.
     \omitvalue MemoryManagedBindOption Used by paint engines to
 …
     // remove any textures cached in this context
     QGLTextureCache::instance()->removeContextTextures(this);
-    QGLTextureCache::deleteIfEmpty(); // ### thread safety
     d_ptr->group->cleanupResources(this);
 …
+{
     Q_ASSERT(arrayIndex < QT_GL_VERTEX_ARRAY_TRACKED_COUNT);
+#ifdef glEnableVertexAttribArray
     Q_ASSERT(glEnableVertexAttribArray);
+#endif
     if (vertexAttributeArraysEnabledState[arrayIndex] && !enabled)
 …
 void QGLContextPrivate::syncGlState()
+{
+#ifdef glEnableVertexAttribArray
     Q_ASSERT(glEnableVertexAttribArray);
+#endif
     for (int i = 0; i < QT_GL_VERTEX_ARRAY_TRACKED_COUNT; ++i) {
         if (vertexAttributeArraysEnabledState[i])
 …
 #undef ctx
+#ifdef QT_NO_EGL
+void QGLContextPrivate::swapRegion(const QRegion &)
+{
+    Q_Q(QGLContext);
+    q->swapBuffers();
+}
+#endif
 /*!
 …
+}
+#if defined(Q_WS_X11) || defined(Q_WS_MAC) || defined(Q_WS_QWS) || defined(Q_OS_SYMBIAN)
+QGLExtensionFuncs& QGLContextPrivate::extensionFuncs(const QGLContext *)
+{
+    return qt_extensionFuncs;
+}
+#endif
 QImage QGLContextPrivate::convertToGLFormat(const QImage &image, bool force_premul,
                                             GLenum texture_format)
 …
                                            QGLContext::BindOptions options)
+{
+    Q_Q(QGLContext);
     const qint64 key = image.cacheKey();
     QGLTexture *texture = textureCacheLookup(key, target);
     if (texture) {
+        glBindTexture(target, texture->id);
+        return texture;
+        if (image.paintingActive()) {
+            // A QPainter is active on the image - take the safe route and replace the texture.
+            q->deleteTexture(texture->id);
+            texture = 0;
+        } else {
+            glBindTexture(target, texture->id);
+            return texture;
+        }
+    }
 …
 #ifdef QGL_BIND_TEXTURE_DEBUG
     printf("QGLContextPrivate::bindTexture(), imageSize=(%d,%d), internalFormat =0x%x, options=%x\n",
            image.width(), image.height(), internalFormat, int(options));
+    printf("QGLContextPrivate::bindTexture(), imageSize=(%d,%d), internalFormat =0x%x, options=%x, key=%llx\n",
+           image.width(), image.height(), internalFormat, int(options), key);
     QTime time;
     time.start();
 …
         && (options & QGLContext::MipmapBindOption))
+    {
-#ifdef QGL_BIND_TEXTURE_DEBUG
-        printf(" - generating mipmaps (%d ms)\n", time.elapsed());
-#endif
 #if !defined(QT_OPENGL_ES_2)
         glHint(GL_GENERATE_MIPMAP_HINT_SGIS, GL_NICEST);
 …
         glTexParameterf(target, GL_TEXTURE_MIN_FILTER, options & QGLContext::LinearFilteringBindOption
                         ? GL_LINEAR_MIPMAP_LINEAR : GL_NEAREST_MIPMAP_NEAREST);
+#ifdef QGL_BIND_TEXTURE_DEBUG
+        printf(" - generating mipmaps (%d ms)\n", time.elapsed());
+#endif
     } else {
         glTexParameterf(target, GL_TEXTURE_MIN_FILTER, filtering);
 …
             img = img.convertToFormat(target_format = QImage::Format_ARGB32_Premultiplied);
 #ifdef QGL_BIND_TEXTURE_DEBUG
             printf(" - converting ARGB32 -> ARGB32_Premultiplied (%d ms) \n", time.elapsed());
+            printf(" - converted ARGB32 -> ARGB32_Premultiplied (%d ms) \n", time.elapsed());
 #endif
+        }
 …
             img = img.convertToFormat(target_format = QImage::Format_ARGB32);
 #ifdef QGL_BIND_TEXTURE_DEBUG
             printf(" - converting ARGB32_Premultiplied -> ARGB32 (%d ms)\n", time.elapsed());
+            printf(" - converted ARGB32_Premultiplied -> ARGB32 (%d ms)\n", time.elapsed());
 #endif
+        }
 …
                                       : QImage::Format_ARGB32);
 #ifdef QGL_BIND_TEXTURE_DEBUG
             printf(" - converting to 32-bit alpha format (%d ms)\n", time.elapsed());
+            printf(" - converted to 32-bit alpha format (%d ms)\n", time.elapsed());
 #endif
         } else {
             img = img.convertToFormat(QImage::Format_RGB32);
 #ifdef QGL_BIND_TEXTURE_DEBUG
             printf(" - converting to 32-bit (%d ms)\n", time.elapsed());
+            printf(" - converted to 32-bit (%d ms)\n", time.elapsed());
 #endif
+        }
 …
     if (options & QGLContext::InvertedYBindOption) {
-#ifdef QGL_BIND_TEXTURE_DEBUG
-            printf(" - flipping bits over y (%d ms)\n", time.elapsed());
-#endif
         if (img.isDetached()) {
             int ipl = img.bytesPerLine() / 4;
 …
             img = img.mirrored();
+        }
+#ifdef QGL_BIND_TEXTURE_DEBUG
+            printf(" - flipped bits over y (%d ms)\n", time.elapsed());
+#endif
+    }
     if (externalFormat == GL_RGBA) {
-#ifdef QGL_BIND_TEXTURE_DEBUG
-            printf(" - doing byte swapping (%d ms)\n", time.elapsed());
-#endif
         // The only case where we end up with a depth different from
         // 32 in the switch above is for the RGB16 case, where we set
 …
         Q_ASSERT(img.depth() == 32);
         qgl_byteSwapImage(img, pixel_type);
+#ifdef QGL_BIND_TEXTURE_DEBUG
+            printf(" - did byte swapping (%d ms)\n", time.elapsed());
+#endif
+    }
 #ifdef QT_OPENGL_ES
 …
     GLenum error = glGetError();
     if (error != GL_NO_ERROR) {
         qWarning(" - texture upload failed, error code 0x%x\n", error);
+        qWarning(" - texture upload failed, error code 0x%x, enum: %d (%x)\n", error, target, target);
+    }
 #endif
 …
     static int totalUploadTime = 0;
     totalUploadTime += time.elapsed();
     printf(" - upload done in (%d ms) time=%d\n", time.elapsed(), totalUploadTime);
+    printf(" - upload done in %d ms, (accumulated: %d ms)\n", time.elapsed(), totalUploadTime);
 #endif
 …
+{
     Q_Q(QGLContext);
     QGLTexture *texture = QGLTextureCache::instance()->getTexture(key);
+    QGLTexture *texture = QGLTextureCache::instance()->getTexture(q, key);
     if (texture && texture->target == target
         && (texture->context == q || QGLContext::areSharing(q, texture->context)))
 …
     Q_Q(QGLContext);
     QPixmapData *pd = pixmap.pixmapData();
 #if !defined(QT_OPENGL_ES_1) && !defined(QT_OPENGL_ES_1_CL)
+#if !defined(QT_OPENGL_ES_1)
     if (target == GL_TEXTURE_2D && pd->classId() == QPixmapData::OpenGLClass) {
         const QGLPixmapData *data = static_cast<const QGLPixmapData *>(pd);
 …
 #else
     Q_UNUSED(pd);
-    Q_UNUSED(q);
 #endif
 …
     QGLTexture *texture = textureCacheLookup(key, target);
     if (texture) {
+        glBindTexture(target, texture->id);
+        return texture;
+        if (pixmap.paintingActive()) {
+            // A QPainter is active on the pixmap - take the safe route and replace the texture.
+            q->deleteTexture(texture->id);
+            texture = 0;
+        } else {
+            glBindTexture(target, texture->id);
+            return texture;
+        }
+    }
 …
     const QX11Info *xinfo = qt_x11Info(paintDevice);
     if (pd->classId() == QPixmapData::X11Class && pd->pixelType() == QPixmapData::PixmapType
+        && xinfo && xinfo->screen() == pixmap.x11Info().screen())
+        && xinfo && xinfo->screen() == pixmap.x11Info().screen()
+        && target == GL_TEXTURE_2D)
+    {
+        texture = bindTextureFromNativePixmap(pd, key, options);
+        if (texture) {
+            texture->options |= QGLContext::MemoryManagedBindOption;
+            texture->boundPixmap = pd;
+            boundPixmaps.insert(pd, QPixmap(pixmap));
+        if (!workaround_brokenTextureFromPixmap_init) {
+            workaround_brokenTextureFromPixmap_init = true;
+            const QByteArray versionString(reinterpret_cast<const char*>(glGetString(GL_VERSION)));
+            const int pos = versionString.indexOf("NVIDIA ");
+            if (pos >= 0) {
+                const QByteArray nvidiaVersionString = versionString.mid(pos + strlen("NVIDIA "));
+                if (nvidiaVersionString.startsWith("195") || nvidiaVersionString.startsWith("256"))
+                    workaround_brokenTextureFromPixmap = true;
+            }
+        }
+    }
+#endif
+    if (!texture)
+        texture = bindTexture(pixmap.toImage(), target, format, key, options);
+        if (!workaround_brokenTextureFromPixmap) {
+            texture = bindTextureFromNativePixmap(const_cast<QPixmap*>(&pixmap), key, options);
+            if (texture) {
+                texture->options |= QGLContext::MemoryManagedBindOption;
+                texture->boundPixmap = pd;
+                boundPixmaps.insert(pd, QPixmap(pixmap));
+            }
+        }
+    }
+#endif
+    if (!texture) {
+        QImage image = pixmap.toImage();
+        // If the system depth is 16 and the pixmap doesn't have an alpha channel
+        // then we convert it to RGB16 in the hope that it gets uploaded as a 16
+        // bit texture which is much faster to access than a 32-bit one.
+        if (pixmap.depth() == 16 && !image.hasAlphaChannel() )
+            image = image.convertToFormat(QImage::Format_RGB16);
+        texture = bindTexture(image, target, format, key, options);
+    }
     // NOTE: bindTexture(const QImage&, GLenum, GLint, const qint64, bool) should never return null
     Q_ASSERT(texture);
 …
     Q_D(QGLContext);
     QGLTexture *texture = d->bindTexture(image, target, format, false, options);
+    QGLTexture *texture = d->bindTexture(image, target, format, options);
     return texture->id;
+}
 …
     Q_D(QGLContext);
     QGLTexture *texture = d->bindTexture(image, GLenum(target), GLint(format), false, DefaultBindOption);
+    QGLTexture *texture = d->bindTexture(image, GLenum(target), GLint(format), DefaultBindOption);
     return texture->id;
+}
 …
     Q_D(QGLContext);
     QGLTexture *texture = d->bindTexture(image, GLenum(target), GLint(format), false, options);
+    QGLTexture *texture = d->bindTexture(image, GLenum(target), GLint(format), options);
     return texture->id;
+}
 …
 #endif
 void qt_add_rect_to_array(const QRectF &r, q_vertexType *array)
+void qt_add_rect_to_array(const QRectF &r, GLfloat *array)
+{
     qreal left = r.left();
 …
     qreal bottom = r.bottom();
     array[0] = f2vt(left);
     array[1] = f2vt(top);
     array[2] = f2vt(right);
     array[3] = f2vt(top);
     array[4] = f2vt(right);
     array[5] = f2vt(bottom);
     array[6] = f2vt(left);
     array[7] = f2vt(bottom);
+}
 void qt_add_texcoords_to_array(qreal x1, qreal y1, qreal x2, qreal y2, q_vertexType *array)
+{
     array[0] = f2vt(x1);
     array[1] = f2vt(y1);
     array[2] = f2vt(x2);
     array[3] = f2vt(y1);
     array[4] = f2vt(x2);
     array[5] = f2vt(y2);
     array[6] = f2vt(x1);
     array[7] = f2vt(y2);
+    array[0] = left;
+    array[1] = top;
+    array[2] = right;
+    array[3] = top;
+    array[4] = right;
+    array[5] = bottom;
+    array[6] = left;
+    array[7] = bottom;
+}
+void qt_add_texcoords_to_array(qreal x1, qreal y1, qreal x2, qreal y2, GLfloat *array)
+{
+    array[0] = x1;
+    array[1] = y1;
+    array[2] = x2;
+    array[3] = y1;
+    array[4] = x2;
+    array[5] = y2;
+    array[6] = x1;
+    array[7] = y2;
+}
 …
 static void qDrawTextureRect(const QRectF &target, GLint textureWidth, GLint textureHeight, GLenum textureTarget)
+{
     q_vertexType tx = f2vt(1);
     q_vertexType ty = f2vt(1);
+    GLfloat tx = 1.0f;
+    GLfloat ty = 1.0f;
 #ifdef QT_OPENGL_ES
 …
+        }
         tx = f2vt(textureWidth);
         ty = f2vt(textureHeight);
+    }
 #endif
     q_vertexType texCoordArray[4*2] = {
+        tx = GLfloat(textureWidth);
+        ty = GLfloat(textureHeight);
+    }
+#endif
+    GLfloat texCoordArray[4*2] = {
 , ty, tx, ty, tx, 0, 0, 0
     };
     q_vertexType vertexArray[4*2];
+    GLfloat vertexArray[4*2];
     qt_add_rect_to_array(target, vertexArray);
     glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray);
     glTexCoordPointer(2, q_vertexTypeEnum, 0, texCoordArray);
+    glVertexPointer(2, GL_FLOAT, 0, vertexArray);
+    glTexCoordPointer(2, GL_FLOAT, 0, texCoordArray);
     glEnableClientState(GL_VERTEX_ARRAY);
 …
     \since 4.4
+    Draws the given texture, \a textureId, to the given target rectangle,
+    \a target, in OpenGL model space. The \a textureTarget should be a 2D
+    texture target.
+    \note This function is not supported under OpenGL/ES 2.0.
+    This function supports the following use cases:
+    \list
+    \i On OpenGL and OpenGL ES 1.x it draws the given texture, \a textureId,
+    to the given target rectangle, \a target, in OpenGL model space. The
+    \a textureTarget should be a 2D texture target.
+    \i On OpenGL and OpenGL ES 2.x, if a painter is active, not inside a
+    beginNativePainting / endNativePainting block, and uses the
+    engine with type QPaintEngine::OpenGL2, the function will draw the given
+    texture, \a textureId, to the given target rectangle, \a target,
+    respecting the current painter state. This will let you draw a texture
+    with the clip, transform, render hints, and composition mode set by the
+    painter. Note that the texture target needs to be GL_TEXTURE_2D for this
+    use case, and that this is the only supported use case under OpenGL ES 2.x.
+    \endlist
 */
 void QGLContext::drawTexture(const QRectF &target, GLuint textureId, GLenum textureTarget)
+{
+#if !defined(QT_OPENGL_ES) || defined(QT_OPENGL_ES_2)
+     if (d_ptr->active_engine &&
+         d_ptr->active_engine->type() == QPaintEngine::OpenGL2) {
+         QGL2PaintEngineEx *eng = static_cast<QGL2PaintEngineEx*>(d_ptr->active_engine);
+         if (!eng->isNativePaintingActive()) {
+            QRectF src(0, 0, target.width(), target.height());
+            QSize size(target.width(), target.height());
+            if (eng->drawTexture(target, textureId, size, src))
+                return;
+        }
+     }
+#endif
 #ifndef QT_OPENGL_ES_2
 #ifdef QT_OPENGL_ES
 …
     Q_UNUSED(textureId);
     Q_UNUSED(textureTarget);
     qWarning("drawTexture(const QRectF &target, GLuint textureId, GLenum textureTarget) not supported with OpenGL ES/2.0");
+    qWarning("drawTexture() with OpenGL ES 2.0 requires an active OpenGL2 paint engine");
 #endif
+}
 …
     \since 4.4
+    Draws the given texture at the given \a point in OpenGL model
+    space. The \a textureTarget should be a 2D texture target.
+    \note This function is not supported under OpenGL/ES.
+    This function supports the following use cases:
+    \list
+    \i By default it draws the given texture, \a textureId,
+    at the given \a point in OpenGL model space. The
+    \a textureTarget should be a 2D texture target.
+    \i If a painter is active, not inside a
+    beginNativePainting / endNativePainting block, and uses the
+    engine with type QPaintEngine::OpenGL2, the function will draw the given
+    texture, \a textureId, at the given \a point,
+    respecting the current painter state. This will let you draw a texture
+    with the clip, transform, render hints, and composition mode set by the
+    painter. Note that the texture target needs to be GL_TEXTURE_2D for this
+    use case.
+    \endlist
+    \note This function is not supported under any version of OpenGL ES.
 */
 void QGLContext::drawTexture(const QPointF &point, GLuint textureId, GLenum textureTarget)
+{
-    // this would be ok on OpenGL ES 2.0, but currently we don't have a define for that
 #ifdef QT_OPENGL_ES
     Q_UNUSED(point);
 …
     qWarning("drawTexture(const QPointF &point, GLuint textureId, GLenum textureTarget) not supported with OpenGL ES, use rect version instead");
 #else
     const bool wasEnabled = glIsEnabled(GL_TEXTURE_2D);
     GLint oldTexture;
 …
     glGetTexLevelParameteriv(textureTarget, 0, GL_TEXTURE_WIDTH, &textureWidth);
     glGetTexLevelParameteriv(textureTarget, 0, GL_TEXTURE_HEIGHT, &textureHeight);
+    if (d_ptr->active_engine &&
+        d_ptr->active_engine->type() == QPaintEngine::OpenGL2) {
+        QGL2PaintEngineEx *eng = static_cast<QGL2PaintEngineEx*>(d_ptr->active_engine);
+        if (!eng->isNativePaintingActive()) {
+            QRectF dest(point, QSizeF(textureWidth, textureHeight));
+            QRectF src(0, 0, textureWidth, textureHeight);
+            QSize size(textureWidth, textureHeight);
+            if (eng->drawTexture(dest, textureId, size, src))
+                return;
+        }
+    }
     qDrawTextureRect(QRectF(point, QSizeF(textureWidth, textureHeight)), textureWidth, textureHeight, textureTarget);
 …
     \sa QGLWidget::renderText()
 */
 …
     \l{Overpainting Example}{Overpainting} example.
+    \section1 Threading
+    It is possible to render into a QGLWidget from another thread, but it
+    requires that all access to the GL context is safe guarded. The Qt GUI
+    thread will try to use the context in resizeEvent and paintEvent, so in
+    order for threaded rendering using a GL widget to work, these functions
+    need to be intercepted in the GUI thread and handled accordingly in the
+    application.
     \e{OpenGL is a trademark of Silicon Graphics, Inc. in the United States and other
     countries.}
 …
 #endif
     delete d->glcx;
+#if defined(Q_WGL)
+    d->glcx = 0;
+#if defined(Q_WS_WIN)
     delete d->olcx;
+    d->olcx = 0;
 #endif
 #if defined(GLX_MESA_release_buffers) && defined(QGL_USE_MESA_EXT)
 …
+    }
 #if defined(QT_OPENGL_ES)
+#ifndef QT_NO_EGL
     // A re-parent is likely to destroy the X11 window and re-create it. It is important
     // that we free the EGL surface _before_ the winID changes - otherwise we can leak.
 …
         // The window may have been re-created during re-parent or state change - if so, the EGL
         // surface will need to be re-created.
         d->recreateEglSurface(false);
+        d->recreateEglSurface();
+    }
 #endif
 …
 #  endif
+    }
+#elif defined(Q_OS_SYMBIAN)
+    // prevents errors on some systems, where we get a flush to a
+    // hidden widget
+    if (e->type() == QEvent::Hide) {
+        makeCurrent();
+        glFinish();
+        doneCurrent();
+    } else if (e->type() == QEvent::ParentChange) {
+        // if we've reparented a window that has the current context
+        // bound, we need to rebind that context to the new window id
+        if (d->glcx == QGLContext::currentContext())
+            makeCurrent();
+        if (testAttribute(Qt::WA_TranslucentBackground))
+            setContext(new QGLContext(d->glcx->requestedFormat(), this));
+    }
+    // A re-parent is likely to destroy the Symbian window and re-create it. It is important
+    // that we free the EGL surface _before_ the winID changes - otherwise we can leak.
+    if (e->type() == QEvent::ParentAboutToChange)
+        d->glcx->d_func()->destroyEglSurfaceForDevice();
+    if ((e->type() == QEvent::ParentChange) || (e->type() == QEvent::WindowStateChange)) {
+        // The window may have been re-created during re-parent or state change - if so, the EGL
+        // surface will need to be re-created.
+        d->recreateEglSurface();
+    }
 #endif
 …
     if (!isValid())
         return;
+#ifdef Q_OS_SYMBIAN
+    // Crashes on Symbian if trying to render to invisible surfaces
+    if (!isVisible() && d->glcx->device()->devType() == QInternal::Widget)
+        return;
+#endif
     makeCurrent();
 #ifndef QT_OPENGL_ES
 …
     \since 4.4
+    Draws the given texture, \a textureId to the given target rectangle,
+    \a target, in OpenGL model space. The \a textureTarget should be a 2D
+    texture target.
+    Equivalent to the corresponding QGLContext::drawTexture().
+    Calls the corresponding QGLContext::drawTexture() with
+    \a target, \a textureId, and \a textureTarget for this
+    widget's context.
 */
 void QGLWidget::drawTexture(const QRectF &target, GLuint textureId, GLenum textureTarget)
 …
     \since 4.4
+    Draws the given texture, \a textureId, at the given \a point in OpenGL
+    model space. The \a textureTarget should be a 2D texture target.
+    Equivalent to the corresponding QGLContext::drawTexture().
+    Calls the corresponding QGLContext::drawTexture() with
+    \a point, \a textureId, and \a textureTarget for this
+    widget's context.
 */
 void QGLWidget::drawTexture(const QPointF &point, GLuint textureId, GLenum textureTarget)
 …
 #endif
 #if !defined(QT_OPENGL_ES_1) && !defined(QT_OPENGL_ES_1_CL)
+#ifndef QT_OPENGL_ES_1
 Q_GLOBAL_STATIC(QGL2PaintEngineEx, qt_gl_2_engine)
 #endif
 …
 Q_OPENGL_EXPORT QPaintEngine* qt_qgl_paint_engine()
+{
 #if defined(QT_OPENGL_ES_1) || defined(QT_OPENGL_ES_1_CL)
+#if defined(QT_OPENGL_ES_1)
     return qt_gl_engine();
 #elif defined(QT_OPENGL_ES_2)
 …
     if (extensions.match("GL_ARB_fragment_shader"))
         glExtensions |= FragmentShader;
+    if (extensions.match("GL_ARB_shader_objects"))
+        glExtensions |= FragmentShader;
     if (extensions.match("GL_ARB_texture_mirrored_repeat"))
         glExtensions |= MirroredRepeat;
 …
     if (extensions.match("GL_ARB_pixel_buffer_object"))
         glExtensions |= PixelBufferObject;
+    if (extensions.match("GL_IMG_texture_format_BGRA8888"))
+        glExtensions |= BGRATextureFormat;
 #if defined(QT_OPENGL_ES_2)
     glExtensions |= FramebufferObject;
 …
     glExtensions |= FragmentShader;
 #endif
 #if defined(QT_OPENGL_ES_1) || defined(QT_OPENGL_ES_1_CL)
+#if defined(QT_OPENGL_ES_1)
     if (extensions.match("GL_OES_framebuffer_object"))
         glExtensions |= FramebufferObject;
 …
     if (extensions.match("GL_OES_packed_depth_stencil"))
         glExtensions |= PackedDepthStencil;
+    if (extensions.match("GL_OES_element_index_uint"))
+        glExtensions |= ElementIndexUint;
+    if (extensions.match("GL_OES_depth24"))
+        glExtensions |= Depth24;
+#else
+    glExtensions |= ElementIndexUint;
 #endif
     if (extensions.match("GL_ARB_framebuffer_object")) {
 …
+}
+class QGLDefaultExtensions
+{
+public:
+    QGLDefaultExtensions() {
+        QGLTemporaryContext tempContext;
+        extensions = QGLExtensions::currentContextExtensions();
+    }
+    QGLExtensions::Extensions extensions;
+};
+Q_GLOBAL_STATIC(QGLDefaultExtensions, qtDefaultExtensions)
 /*
     Returns the GL extensions for the current QGLContext. If there is no
 …
 QGLExtensions::Extensions QGLExtensions::glExtensions()
+{
+    QGLTemporaryContext *tmpContext = 0;
+    static bool cachedDefault = false;
+    static Extensions defaultExtensions = 0;
+    Extensions extensionFlags = 0;
     QGLContext *currentCtx = const_cast<QGLContext *>(QGLContext::currentContext());
 …
     if (!currentCtx) {
+        if (cachedDefault) {
+            return defaultExtensions;
+        } else {
+            tmpContext = new QGLTemporaryContext;
+            cachedDefault = true;
+        }
+    }
+    Extensions extensionFlags = currentContextExtensions();
+    if (currentCtx) {
+        extensionFlags = qtDefaultExtensions()->extensions;
+    } else {
+        extensionFlags = currentContextExtensions();
         currentCtx->d_func()->extension_flags_cached = true;
         currentCtx->d_func()->extension_flags = extensionFlags;
+    } else {
+        defaultExtensions = extensionFlags;
+    }
+    if (tmpContext)
+        delete tmpContext;
+    }
     return extensionFlags;
+}
 …
+{
     if (qt_gl_lib_name()->isNull()) {
+#if defined(Q_WS_X11) || defined(Q_WS_QWS)
+#ifdef Q_WS_MAC
+        return QLatin1String("/System/Library/Frameworks/OpenGL.framework/Versions/A/Libraries/libGL.dylib");
+#else
+# if defined(QT_OPENGL_ES_1)
+        return QLatin1String("GLES_CM");
+# elif defined(QT_OPENGL_ES_2)
+        return QLatin1String("GLESv2");
+# else
         return QLatin1String("GL");
+#else // Q_WS_MAC
+        return QLatin1String("/System/Library/Frameworks/OpenGL.framework/Versions/A/Libraries/libGL.dylib");
+#endif
+# endif
+#endif // defined Q_WS_MAC
+    }
     return *qt_gl_lib_name();

trunk/src/opengl/qgl.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 # include <OpenGL/gl.h>
 # include <OpenGL/glu.h>
 #elif defined(QT_OPENGL_ES_1) || defined(QT_OPENGL_ES_1_CL)
+#elif defined(QT_OPENGL_ES_1)
 # include <GLES/gl.h>
 #ifndef GL_DOUBLE
 …
         HasOverlay              = 0x0100,
         SampleBuffers           = 0x0200,
+        DeprecatedFunctions     = 0x0400,
         SingleBuffer            = DoubleBuffer    << 16,
         NoDepthBuffer           = DepthBuffer     << 16,
 …
         IndirectRendering       = DirectRendering << 16,
         NoOverlay               = HasOverlay      << 16,
+        NoSampleBuffers         = SampleBuffers   << 16
+        NoSampleBuffers         = SampleBuffers   << 16,
+        NoDeprecatedFunctions   = DeprecatedFunctions << 16
     };
     Q_DECLARE_FLAGS(FormatOptions, FormatOption)
 …
     static bool hasOpenGLOverlays();
+    enum  OpenGLVersionFlag {
+    void setVersion(int major, int minor);
+    int majorVersion() const;
+    int minorVersion() const;
+    enum OpenGLContextProfile {
+        NoProfile,
+        CoreProfile,
+        CompatibilityProfile
+    };
+    void setProfile(OpenGLContextProfile profile);
+    OpenGLContextProfile profile() const;
+    enum OpenGLVersionFlag {
         OpenGL_Version_None               = 0x00000000,
         OpenGL_Version_1_1                = 0x00000001,
 …
         OpenGL_ES_CommonLite_Version_1_1  = 0x00000400,
         OpenGL_ES_Version_2_0             = 0x00000800,
+        OpenGL_Version_3_0                = 0x00001000
+        OpenGL_Version_3_0                = 0x00001000,
+        OpenGL_Version_3_1                = 0x00002000,
+        OpenGL_Version_3_2                = 0x00004000,
+        OpenGL_Version_3_3                = 0x00008000,
+        OpenGL_Version_4_0                = 0x00010000
     };
     Q_DECLARE_FLAGS(OpenGLVersionFlags, OpenGLVersionFlag)
 …
     friend Q_OPENGL_EXPORT bool operator==(const QGLFormat&, const QGLFormat&);
     friend Q_OPENGL_EXPORT bool operator!=(const QGLFormat&, const QGLFormat&);
+#ifndef QT_NO_DEBUG_STREAM
+    friend Q_OPENGL_EXPORT QDebug operator<<(QDebug, const QGLFormat &);
+#endif
 };
 …
 Q_OPENGL_EXPORT bool operator==(const QGLFormat&, const QGLFormat&);
 Q_OPENGL_EXPORT bool operator!=(const QGLFormat&, const QGLFormat&);
+#ifndef QT_NO_DEBUG_STREAM
+Q_OPENGL_EXPORT QDebug operator<<(QDebug, const QGLFormat &);
+#endif
 class Q_OPENGL_EXPORT QGLContext
 …
     virtual int choosePixelFormat(void* pfd, HDC pdc);
 #endif
 #if defined(Q_WS_X11) && !defined(QT_OPENGL_ES)
+#if defined(Q_WS_X11) && defined(QT_NO_EGL)
     virtual void* tryVisual(const QGLFormat& f, int bufDepth = 1);
     virtual void* chooseVisual();
 …
     friend class QGLPixmapBlurFilter;
     friend class QGLExtensions;
+    friend class QGLTexture;
     friend QGLFormat::OpenGLVersionFlags QGLFormat::openGLVersionFlags();
 #ifdef Q_WS_MAC
 …
     friend class QGLFBOGLPaintDevice;
     friend class QGLPaintDevice;
+    friend class QGLWidgetGLPaintDevice;
     friend class QX11GLPixmapData;
+    friend class QX11GLSharedContexts;
 private:
     Q_DISABLE_COPY(QGLContext)

trunk/src/opengl/qgl_egl.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #include <QtOpenGL/qgl.h>
+#include <QtOpenGL/qglpixelbuffer.h>
 #include "qgl_p.h"
 #include "qgl_egl_p.h"
+#include "qglpixelbuffer_p.h"
+#ifdef Q_WS_X11
+#include <QtGui/private/qpixmap_x11_p.h>
+#endif
 QT_BEGIN_NAMESPACE
+// Set device configuration attributes from a QGLFormat instance.
+void qt_egl_set_format(QEglProperties& props, int deviceType, const QGLFormat& f)
+{
+    if (deviceType == QInternal::Pixmap || deviceType == QInternal::Image)
+        props.setValue(EGL_SURFACE_TYPE, EGL_PIXMAP_BIT);
+    else if (deviceType == QInternal::Pbuffer)
+        props.setValue(EGL_SURFACE_TYPE, EGL_PBUFFER_BIT);
+    else
+        props.setValue(EGL_SURFACE_TYPE, EGL_WINDOW_BIT);
+    // Set the pixel format to that contained in the QGLFormat
+    // if the system hasn't already chosen a fixed format to
+    // match the pixmap, widget, etc.
+    if (props.value(EGL_RED_SIZE) == 0 || f.redBufferSize() != -1)
+        props.setValue(EGL_RED_SIZE, f.redBufferSize() == -1 ? 1 : f.redBufferSize());
+    if (props.value(EGL_GREEN_SIZE) == 0 || f.greenBufferSize() != -1)
+        props.setValue(EGL_GREEN_SIZE, f.greenBufferSize() == -1 ? 1 : f.greenBufferSize());
+    if (props.value(EGL_BLUE_SIZE) == 0 || f.blueBufferSize() != -1)
+        props.setValue(EGL_BLUE_SIZE, f.blueBufferSize() == -1 ? 1 : f.blueBufferSize());
+    if (f.alpha()) {
+        if (props.value(EGL_ALPHA_SIZE) == 0 || f.alphaBufferSize() != -1)
+            props.setValue(EGL_ALPHA_SIZE, f.alphaBufferSize() == -1 ? 1 : f.alphaBufferSize());
+    }
+    if (f.depth())
+        props.setValue(EGL_DEPTH_SIZE, f.depthBufferSize() == -1 ? 1 : f.depthBufferSize());
+    if (f.stencil())
+        props.setValue(EGL_STENCIL_SIZE, f.stencilBufferSize() == -1 ? 1 : f.stencilBufferSize());
+    if (f.sampleBuffers()) {
+        props.setValue(EGL_SAMPLE_BUFFERS, 1);
+        props.setValue(EGL_SAMPLES, f.samples() == -1 ? 1 : f.samples());
+    } else {
+        props.setValue(EGL_SAMPLE_BUFFERS, 0);
+    }
+    if (deviceType == QInternal::Widget)
+        props.setValue(EGL_LEVEL, f.plane());
+void qt_eglproperties_set_glformat(QEglProperties& eglProperties, const QGLFormat& glFormat)
+{
+    int redSize     = glFormat.redBufferSize();
+    int greenSize   = glFormat.greenBufferSize();
+    int blueSize    = glFormat.blueBufferSize();
+    int alphaSize   = glFormat.alphaBufferSize();
+    int depthSize   = glFormat.depthBufferSize();
+    int stencilSize = glFormat.stencilBufferSize();
+    int sampleCount = glFormat.samples();
+    // QGLFormat uses a magic value of -1 to indicate "don't care", even when a buffer of that
+    // type has been requested. So we must check QGLFormat's booleans too if size is -1:
+    if (glFormat.alpha() && alphaSize <= 0)
+        alphaSize = 1;
+    if (glFormat.depth() && depthSize <= 0)
+        depthSize = 1;
+    if (glFormat.stencil() && stencilSize <= 0)
+        stencilSize = 1;
+    if (glFormat.sampleBuffers() && sampleCount <= 0)
+        sampleCount = 1;
+    // We want to make sure 16-bit configs are chosen over 32-bit configs as they will provide
+    // the best performance. The EGL config selection algorithm is a bit stange in this regard:
+    // The selection criteria for EGL_BUFFER_SIZE is "AtLeast", so we can't use it to discard
+    // 32-bit configs completely from the selection. So it then comes to the sorting algorithm.
+    // The red/green/blue sizes have a sort priority of 3, so they are sorted by first. The sort
+    // order is special and described as "by larger _total_ number of color bits.". So EGL will
+    // put 32-bit configs in the list before the 16-bit configs. However, the spec also goes on
+    // to say "If the requested number of bits in attrib_list for a particular component is 0,
+    // then the number of bits for that component is not considered". This part of the spec also
+    // seems to imply that setting the red/green/blue bits to zero means none of the components
+    // are considered and EGL disregards the entire sorting rule. It then looks to the next
+    // highest priority rule, which is EGL_BUFFER_SIZE. Despite the selection criteria being
+    // "AtLeast" for EGL_BUFFER_SIZE, it's sort order is "smaller" meaning 16-bit configs are
+    // put in the list before 32-bit configs. So, to make sure 16-bit is preffered over 32-bit,
+    // we must set the red/green/blue sizes to zero. This has an unfortunate consequence that
+    // if the application sets the red/green/blue size to 5/6/5 on the QGLFormat, they will
+    // probably get a 32-bit config, even when there's an RGB565 config available. Oh well.
+    // Now normalize the values so -1 becomes 0
+    redSize   = redSize   > 0 ? redSize   : 0;
+    greenSize = greenSize > 0 ? greenSize : 0;
+    blueSize  = blueSize  > 0 ? blueSize  : 0;
+    alphaSize = alphaSize > 0 ? alphaSize : 0;
+    depthSize = depthSize > 0 ? depthSize : 0;
+    stencilSize = stencilSize > 0 ? stencilSize : 0;
+    sampleCount = sampleCount > 0 ? sampleCount : 0;
+    eglProperties.setValue(EGL_RED_SIZE,   redSize);
+    eglProperties.setValue(EGL_GREEN_SIZE, greenSize);
+    eglProperties.setValue(EGL_BLUE_SIZE,  blueSize);
+    eglProperties.setValue(EGL_ALPHA_SIZE, alphaSize);
+    eglProperties.setValue(EGL_DEPTH_SIZE, depthSize);
+    eglProperties.setValue(EGL_STENCIL_SIZE, stencilSize);
+    eglProperties.setValue(EGL_SAMPLES, sampleCount);
+    eglProperties.setValue(EGL_SAMPLE_BUFFERS, sampleCount ? 1 : 0);
+}
 // Updates "format" with the parameters of the selected configuration.
+void qt_egl_update_format(const QEglContext& context, QGLFormat& format)
+{
+    EGLint value = 0;
+    if (context.configAttrib(EGL_RED_SIZE, &value))
+        format.setRedBufferSize(value);
+    if (context.configAttrib(EGL_GREEN_SIZE, &value))
+        format.setGreenBufferSize(value);
+    if (context.configAttrib(EGL_BLUE_SIZE, &value))
+        format.setBlueBufferSize(value);
+    if (context.configAttrib(EGL_ALPHA_SIZE, &value)) {
+        format.setAlpha(value != 0);
+        if (format.alpha())
+            format.setAlphaBufferSize(value);
+    }
+    if (context.configAttrib(EGL_DEPTH_SIZE, &value)) {
+        format.setDepth(value != 0);
+        if (format.depth())
+            format.setDepthBufferSize(value);
+    }
+    if (context.configAttrib(EGL_LEVEL, &value))
+        format.setPlane(value);
+    if (context.configAttrib(EGL_SAMPLE_BUFFERS, &value)) {
+        format.setSampleBuffers(value != 0);
+        if (format.sampleBuffers()) {
+            context.configAttrib(EGL_SAMPLES, &value);
+            format.setSamples(value);
+        }
+    }
+    if (context.configAttrib(EGL_STENCIL_SIZE, &value)) {
+        format.setStencil(value != 0);
+        if (format.stencil())
+            format.setStencilBufferSize(value);
+    }
+void qt_glformat_from_eglconfig(QGLFormat& format, const EGLConfig config)
+{
+    EGLint redSize     = 0;
+    EGLint greenSize   = 0;
+    EGLint blueSize    = 0;
+    EGLint alphaSize   = 0;
+    EGLint depthSize   = 0;
+    EGLint stencilSize = 0;
+    EGLint sampleCount = 0;
+    EGLint level       = 0;
+    EGLDisplay display = QEgl::display();
+    eglGetConfigAttrib(display, config, EGL_RED_SIZE,     &redSize);
+    eglGetConfigAttrib(display, config, EGL_GREEN_SIZE,   &greenSize);
+    eglGetConfigAttrib(display, config, EGL_BLUE_SIZE,    &blueSize);
+    eglGetConfigAttrib(display, config, EGL_ALPHA_SIZE,   &alphaSize);
+    eglGetConfigAttrib(display, config, EGL_DEPTH_SIZE,   &depthSize);
+    eglGetConfigAttrib(display, config, EGL_STENCIL_SIZE, &stencilSize);
+    eglGetConfigAttrib(display, config, EGL_SAMPLES,      &sampleCount);
+    eglGetConfigAttrib(display, config, EGL_LEVEL,        &level);
+    format.setRedBufferSize(redSize);
+    format.setGreenBufferSize(greenSize);
+    format.setBlueBufferSize(blueSize);
+    format.setAlphaBufferSize(alphaSize);
+    format.setDepthBufferSize(depthSize);
+    format.setStencilBufferSize(stencilSize);
+    format.setSamples(sampleCount);
+    format.setPlane(level);
+    format.setDirectRendering(true); // All EGL contexts are direct-rendered
+    format.setRgba(true);            // EGL doesn't support colour index rendering
+    format.setStereo(false);         // EGL doesn't support stereo buffers
+    format.setAccumBufferSize(0);    // EGL doesn't support accululation buffers
+    format.setDoubleBuffer(true);    // We don't support single buffered EGL contexts
     // Clear the EGL error state because some of the above may
     // have errored out because the attribute is not applicable
     // to the surface type.  Such errors don't matter.
     context.clearError();
+    eglGetError();
+}
 …
     d->cleanup();
     doneCurrent();
     if (d->eglContext) {
+    if (d->eglContext && d->ownsEglContext) {
         d->destroyEglSurfaceForDevice();
         delete d->eglContext;
+    }
+    d->ownsEglContext = false;
     d->eglContext = 0;
     d->eglSurface = EGL_NO_SURFACE;
 …
+{
     Q_D(QGLContext);
     if (!d->valid || !d->eglContext || d->eglSurface == EGL_NO_SURFACE) {
+    if (!d->valid || !d->eglContext || d->eglSurfaceForDevice() == EGL_NO_SURFACE) {
         qWarning("QGLContext::makeCurrent(): Cannot make invalid context current");
         return;
+    }
     if (d->eglContext->makeCurrent(d->eglSurface))
+    if (d->eglContext->makeCurrent(d->eglSurfaceForDevice())) {
         QGLContextPrivate::setCurrentContext(this);
+        if (!d->workaroundsCached) {
+            d->workaroundsCached = true;
+            const char *renderer = reinterpret_cast<const char *>(glGetString(GL_RENDERER));
+            if (renderer && (strstr(renderer, "SGX") || strstr(renderer, "MBX"))) {
+                // PowerVR MBX/SGX chips needs to clear all buffers when starting to render
+                // a new frame, otherwise there will be a performance penalty to pay for
+                // each frame.
+                d->workaround_needsFullClearOnEveryFrame = true;
+                // Older PowerVR SGX drivers (like the one in the N900) have a
+                // bug which prevents glCopyTexSubImage2D() to work with a POT
+                // or GL_ALPHA texture bound to an FBO. The only way to
+                // identify that driver is to check the EGL version number for it.
+                const char *egl_version = eglQueryString(d->eglContext->display(), EGL_VERSION);
+                if (egl_version && strstr(egl_version, "1.3"))
+                    d->workaround_brokenFBOReadBack = true;
+                else if (egl_version && strstr(egl_version, "1.4"))
+                    d->workaround_brokenTexSubImage = true;
+            }
+        }
+    }
+}
 …
         return;
     d->eglContext->swapBuffers(d->eglSurface);
+    d->eglContext->swapBuffers(d->eglSurfaceForDevice());
+}
 …
+{
     if (eglSurface != EGL_NO_SURFACE) {
+#if defined(Q_WS_X11) || defined(Q_OS_SYMBIAN)
+        // Make sure we don't call eglDestroySurface on a surface which
+        // was created for a different winId. This applies only to QGLWidget
+        // paint device, so make sure this is the one we're operating on
+        // (as opposed to a QGLWindowSurface use case).
+        if (paintDevice && paintDevice->devType() == QInternal::Widget) {
+            QWidget *w = static_cast<QWidget *>(paintDevice);
+            if (QGLWidget *wgl = qobject_cast<QGLWidget *>(w)) {
+                if (wgl->d_func()->eglSurfaceWindowId != wgl->winId()) {
+                    qWarning("WARNING: Potential EGL surface leak! Not destroying surface.");
+                    eglSurface = EGL_NO_SURFACE;
+                    return;
+                }
+            }
+        }
+#endif
+        eglDestroySurface(eglContext->display(), eglSurface);
+        eglSurface = EGL_NO_SURFACE;
+    }
+}
+EGLSurface QGLContextPrivate::eglSurfaceForDevice() const
+{
+    // If a QPixmapData had to create the QGLContext, we don't have a paintDevice
+    if (!paintDevice)
+        return eglSurface;
 #ifdef Q_WS_X11
+        // Make sure we don't call eglDestroySurface on a surface which
+        // was created for a different winId:
+        if (paintDevice->devType() == QInternal::Widget) {
+            QGLWidget* w = static_cast<QGLWidget*>(paintDevice);
+            if (w->d_func()->eglSurfaceWindowId == w->winId())
+                eglDestroySurface(eglContext->display(), eglSurface);
+            else
+                qWarning("WARNING: Potential EGL surface leak!");
+        } else
+    if (paintDevice->devType() == QInternal::Pixmap) {
+        QPixmapData *pmd = static_cast<QPixmap*>(paintDevice)->data_ptr().data();
+        if (pmd->classId() == QPixmapData::X11Class) {
+            QX11PixmapData* x11PixmapData = static_cast<QX11PixmapData*>(pmd);
+            return (EGLSurface)x11PixmapData->gl_surface;
+        }
+    }
 #endif
+            eglDestroySurface(eglContext->display(), eglSurface);
+        eglSurface = EGL_NO_SURFACE;
+    }
+    if (paintDevice->devType() == QInternal::Pbuffer) {
+        QGLPixelBuffer* pbuf = static_cast<QGLPixelBuffer*>(paintDevice);
+        return pbuf->d_func()->pbuf;
+    }
+    return eglSurface;
+}
+void QGLContextPrivate::swapRegion(const QRegion &region)
+{
+    if (!valid || !eglContext)
+        return;
+    eglContext->swapBuffersRegion2NOK(eglSurfaceForDevice(), &region);
+}

trunk/src/opengl/qgl_egl_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #include <QtGui/private/qegl_p.h>
+#include <QtGui/private/qeglcontext_p.h>
+#include <QtGui/private/qeglproperties_p.h>
 QT_BEGIN_NAMESPACE
 …
 class QGLFormat;
+void qt_egl_set_format(QEglProperties& props, int deviceType, const QGLFormat& f);
+void qt_egl_update_format(const QEglContext& context, QGLFormat& format);
+void qt_egl_add_platform_config(QEglProperties& props, QPaintDevice *device);
+void qt_eglproperties_set_glformat(QEglProperties& props, const QGLFormat& format);
+void qt_glformat_from_eglconfig(QGLFormat& format, const EGLConfig config);
 QT_END_NAMESPACE

trunk/src/opengl/qgl_mac.mm

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
         NSView *view = qt_mac_nativeview_for(w);
+        // ideally we would use QWidget::isVisible(), but we get "invalid drawable" errors
+        if (![(NSWindow *)qt_mac_window_for(w) isVisible])
+            return;
+        // Trying to attach the GL context to the NSView will fail with
+        // "invalid drawable" if done too soon, but we have to make sure
+        // the connection is made before the first paint event. Using
+        // the NSView do to this check fails as the NSView is visible
+        // before it's safe to connect, and using the NSWindow fails as
+        // the NSWindow will become visible after the first paint event.
+        // This leaves us with the QWidget, who's visible state seems
+        // to match the point in time when it's safe to connect.
+        if (!w || !w->isVisible())
+            return; // Not safe to attach GL context to view yet
         if ([static_cast<NSOpenGLContext *>(d->cx) view] != view && ![view isHidden])
             [static_cast<NSOpenGLContext *>(d->cx) setView:view];
 …
+{
     CFBundleRef bundle = 0;
+    CFStringRef urlString = QCFString::toCFStringRef(QLatin1String("/System/Library/Frameworks/OpenGL.framework"));
     QCFType<CFURLRef> url = CFURLCreateWithFileSystemPath(kCFAllocatorDefault,
                  QCFString::toCFStringRef(QLatin1String("/System/Library/Frameworks/OpenGL.framework")), kCFURLPOSIXPathStyle, false);
+                 urlString, kCFURLPOSIXPathStyle, false);
     if (url)
         bundle = CFBundleCreate(kCFAllocatorDefault, url);
+    CFRelease(urlString);
     return bundle;
+}
 …
 void *QGLContext::getProcAddress(const QString &proc) const
+{
+    return CFBundleGetFunctionPointerForName(QCFType<CFBundleRef>(qt_getOpenGLBundle()),
+                                             QCFString(proc));
+    CFStringRef procName = QCFString(proc).toCFStringRef(proc);
+    void *result = CFBundleGetFunctionPointerForName(QCFType<CFBundleRef>(qt_getOpenGLBundle()),
+                                             procName);
+    CFRelease(procName);
+    return result;
+}
 #ifndef QT_MAC_USE_COCOA

trunk/src/opengl/qgl_p.h

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #include "qglpaintdevice_p.h"
+#ifndef QT_OPENGL_ES_1_CL
+#define q_vertexType float
+#define q_vertexTypeEnum GL_FLOAT
+#define f2vt(f)     (f)
+#define vt2f(x)     (x)
+#define i2vt(i)     (float(i))
+#else
+#define FLOAT2X(f)      (int( (f) * (65536)))
+#define X2FLOAT(x)      (float(x) / 65536.0f)
+#define f2vt(f)     FLOAT2X(f)
+#define i2vt(i)     ((i)*65536)
+#define vt2f(x)     X2FLOAT(x)
+#define q_vertexType GLfixed
+#define q_vertexTypeEnum GL_FIXED
+#endif //QT_OPENGL_ES_1_CL
+#if defined(QT_OPENGL_ES) || defined(QT_OPENGL_ES_2)
+QT_BEGIN_INCLUDE_NAMESPACE
+#if defined(QT_OPENGL_ES_2)
+#   include <GLES2/gl2.h>
+#endif
+#if defined(QT_GLES_EGL)
+#   include <GLES/egl.h>
+#else
+#   include <EGL/egl.h>
+#endif
+QT_END_INCLUDE_NAMESPACE
+#ifndef QT_NO_EGL
+#include <QtGui/private/qegl_p.h>
 #endif
 …
 # ifdef old_qDebug
 #   undef qDebug
 #   define qDebug QT_QDEBUG_MACRO
+#   define qDebug QT_NO_QDEBUG_MACRO
 #   undef old_qDebug
 # endif
 …
 #endif
 #if defined(QT_OPENGL_ES)
+#ifndef QT_NO_EGL
 class QEglContext;
 #endif
 …
         : ref(1)
+    {
+        opts = QGL::DoubleBuffer | QGL::DepthBuffer | QGL::Rgba | QGL::DirectRendering | QGL::StencilBuffer;
+        opts = QGL::DoubleBuffer | QGL::DepthBuffer | QGL::Rgba | QGL::DirectRendering
+             | QGL::StencilBuffer | QGL::DeprecatedFunctions;
         pln = 0;
         depthSize = accumSize = stencilSize = redSize = greenSize = blueSize = alphaSize = -1;
         numSamples = -1;
         swapInterval = -1;
+        majorVersion = 1;
+        minorVersion = 0;
+        profile = QGLFormat::NoProfile;
+    }
     QGLFormatPrivate(const QGLFormatPrivate *other)
 …
           alphaSize(other->alphaSize),
           numSamples(other->numSamples),
+          swapInterval(other->swapInterval)
+          swapInterval(other->swapInterval),
+          majorVersion(other->majorVersion),
+          minorVersion(other->minorVersion),
+          profile(other->profile)
+    {
+    }
 …
     int numSamples;
     int swapInterval;
+    int majorVersion;
+    int minorVersion;
+    QGLFormat::OpenGLContextProfile profile;
 };
 …
                        , wsurf(0)
 #endif
+#if defined(Q_WS_X11) && defined(QT_OPENGL_ES)
+#if defined(Q_WS_X11) && !defined(QT_NO_EGL)
+                       , eglSurfaceWindowId(0)
+#endif
+#if defined(Q_OS_SYMBIAN)
                        , eglSurfaceWindowId(0)
 #endif
 …
     bool renderCxPm(QPixmap *pixmap);
     void cleanupColormaps();
+    void aboutToDestroy() {
+        if (glcx)
+            glcx->reset();
+    }
     QGLContext *glcx;
 …
 #elif defined(Q_WS_X11)
     QGLOverlayWidget *olw;
 #if defined(QT_OPENGL_ES)
     void recreateEglSurface(bool force);
+#ifndef QT_NO_EGL
+    void recreateEglSurface();
     WId eglSurfaceWindowId;
 #endif
 …
     QWSGLWindowSurface *wsurf;
 #endif
+#ifdef Q_OS_SYMBIAN
+    void recreateEglSurface();
+    WId eglSurfaceWindowId;
+#endif
 };
 …
     static void removeShare(const QGLContext *context);
 private:
     QGLContextGroup(const QGLContext *context) : m_context(context), m_guards(0), m_refs(1) { }
+    QGLContextGroup(const QGLContext *context);
     QGLExtensionFuncs m_extensionFuncs;
 …
         ETC1TextureCompression  = 0x00010000,
         PVRTCTextureCompression = 0x00020000,
+        FragmentShader          = 0x00040000
+        FragmentShader          = 0x00040000,
+        ElementIndexUint        = 0x00080000,
+        Depth24                 = 0x00100000
     };
     Q_DECLARE_FLAGS(Extensions, Extension)
     static Extensions glExtensions();
-private:
     static Extensions currentContextExtensions();
 };
 …
 class QGLTexture;
+class QGLTextureDestroyer;
 // This probably needs to grow to GL_MAX_VERTEX_ATTRIBS, but 3 is ok for now as that's
 …
     Q_DECLARE_PUBLIC(QGLContext)
 public:
     explicit QGLContextPrivate(QGLContext *context) : internal_context(false), q_ptr(context) {group = new QGLContextGroup(context);}
+    explicit QGLContextPrivate(QGLContext *context);
     ~QGLContextPrivate();
     QGLTexture *bindTexture(const QImage &image, GLenum target, GLint format,
 …
     void setVertexAttribArrayEnabled(int arrayIndex, bool enabled = true);
     void syncGlState(); // Makes sure the GL context's state is what we think it is
+    void swapRegion(const QRegion &region);
+#if defined(Q_WS_WIN)
+    void updateFormatVersion();
+#endif
 #if defined(Q_WS_WIN)
 …
     HDC hbitmap_hdc;
 #endif
+#if defined(QT_OPENGL_ES)
+#ifndef QT_NO_EGL
+    uint ownsEglContext : 1;
     QEglContext *eglContext;
     EGLSurface eglSurface;
     void destroyEglSurfaceForDevice();
+    EGLSurface eglSurfaceForDevice() const;
 #elif defined(Q_WS_X11) || defined(Q_WS_MAC)
     void* cx;
 …
     int screen;
     QHash<QPixmapData*, QPixmap> boundPixmaps;
     QGLTexture *bindTextureFromNativePixmap(QPixmapData*, const qint64 key,
+    QGLTexture *bindTextureFromNativePixmap(QPixmap*, const qint64 key,
                                             QGLContext::BindOptions options);
     static void destroyGlSurfaceForPixmap(QPixmapData*);
 …
     uint version_flags_cached : 1;
     uint extension_flags_cached : 1;
+    // workarounds for driver/hw bugs on different platforms
+    uint workaround_needsFullClearOnEveryFrame : 1;
+    uint workaround_brokenFBOReadBack : 1;
+    uint workaround_brokenTexSubImage : 1;
+    uint workaroundsCached : 1;
+    uint workaround_brokenTextureFromPixmap : 1;
+    uint workaround_brokenTextureFromPixmap_init : 1;
     QPaintDevice *paintDevice;
     QColor transpColor;
 …
     GLuint default_fbo;
     QPaintEngine *active_engine;
+    QGLTextureDestroyer *texture_destroyer;
     bool vertexAttributeArraysEnabledState[QT_GL_VERTEX_ARRAY_TRACKED_COUNT];
 …
 #endif
 #if defined(Q_WS_X11) || defined(Q_WS_MAC) || defined(Q_WS_QWS)
+#if defined(Q_WS_X11) || defined(Q_WS_MAC) || defined(Q_WS_QWS) || defined(Q_OS_SYMBIAN)
     static QGLExtensionFuncs qt_extensionFuncs;
     static inline QGLExtensionFuncs& extensionFuncs(const QGLContext *) { return qt_extensionFuncs; }
+    static Q_OPENGL_EXPORT QGLExtensionFuncs& extensionFuncs(const QGLContext *);
 #endif
     static void setCurrentContext(QGLContext *context);
-};
-// ### make QGLContext a QObject in 5.0 and remove the proxy stuff
-class Q_OPENGL_EXPORT QGLSignalProxy : public QObject
+{
-    Q_OBJECT
-public:
-    QGLSignalProxy() : QObject() {}
-    void emitAboutToDestroyContext(const QGLContext *context) {
-        emit aboutToDestroyContext(context);
+    }
-    static QGLSignalProxy *instance();
-Q_SIGNALS:
-    void aboutToDestroyContext(const QGLContext *context);
 };
 …
 };
+class QGLTextureDestroyer : public QObject
+{
+    Q_OBJECT
+public:
+    QGLTextureDestroyer() : QObject() {
+        qRegisterMetaType<GLuint>("GLuint");
+        connect(this, SIGNAL(freeTexture(QGLContext *, QPixmapData *, GLuint)),
+                this, SLOT(freeTexture_slot(QGLContext *, QPixmapData *, GLuint)));
+    }
+    void emitFreeTexture(QGLContext *context, QPixmapData *boundPixmap, GLuint id) {
+        emit freeTexture(context, boundPixmap, id);
+    }
+Q_SIGNALS:
+    void freeTexture(QGLContext *context, QPixmapData *boundPixmap, GLuint id);
+private slots:
+    void freeTexture_slot(QGLContext *context, QPixmapData *boundPixmap, GLuint id) {
+#if defined(Q_WS_X11)
+        if (boundPixmap) {
+            QGLContext *oldContext = const_cast<QGLContext *>(QGLContext::currentContext());
+            context->makeCurrent();
+            // Although glXReleaseTexImage is a glX call, it must be called while there
+            // 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.
+            QGLContextPrivate::unbindPixmapFromTexture(boundPixmap);
+            glDeleteTextures(1, &id);
+            if (oldContext)
+                oldContext->makeCurrent();
+            return;
+        }
+#endif
+        QGLShareContextScope scope(context);
+        glDeleteTextures(1, &id);
+    }
+};
+// ### make QGLContext a QObject in 5.0 and remove the proxy stuff
+class Q_OPENGL_EXPORT QGLSignalProxy : public QObject
+{
+    Q_OBJECT
+public:
+    void emitAboutToDestroyContext(const QGLContext *context) {
+        emit aboutToDestroyContext(context);
+    }
+    static QGLSignalProxy *instance();
+Q_SIGNALS:
+    void aboutToDestroyContext(const QGLContext *context);
+};
 class QGLTexture {
 public:
 …
         if (options & QGLContext::MemoryManagedBindOption) {
             Q_ASSERT(context);
+            QGLShareContextScope scope(context);
+#if defined(Q_WS_X11)
+            // Although glXReleaseTexImage is a glX call, it must be called while there
+            // 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.
+            if (boundPixmap)
+                QGLContextPrivate::unbindPixmapFromTexture(boundPixmap);
+#endif
+            glDeleteTextures(1, &id);
+#if !defined(Q_WS_X11)
+            QPixmapData *boundPixmap = 0;
+#endif
+            context->d_ptr->texture_destroyer->emitFreeTexture(context, boundPixmap, id);
+        }
+     }
 …
 };
+struct QGLTextureCacheKey {
+    qint64 key;
+    QGLContextGroup *group;
+};
+inline bool operator==(const QGLTextureCacheKey &a, const QGLTextureCacheKey &b)
+{
+    return a.key == b.key && a.group == b.group;
+}
+inline uint qHash(const QGLTextureCacheKey &key)
+{
+    return qHash(key.key) ^ qHash(key.group);
+}
 class Q_AUTOTEST_EXPORT QGLTextureCache {
 public:
 …
     void insert(QGLContext *ctx, qint64 key, QGLTexture *texture, int cost);
+    void remove(quint64 key) { m_cache.remove(key); }
+    void remove(qint64 key);
+    inline int size();
+    inline void setMaxCost(int newMax);
+    inline int maxCost();
+    inline QGLTexture* getTexture(QGLContext *ctx, qint64 key);
     bool remove(QGLContext *ctx, GLuint textureId);
     void removeContextTextures(QGLContext *ctx);
-    int size() { return m_cache.size(); }
-    void setMaxCost(int newMax) { m_cache.setMaxCost(newMax); }
-    int maxCost() {return m_cache.maxCost(); }
-    QGLTexture* getTexture(quint64 key) { return m_cache.object(key); }
     static QGLTextureCache *instance();
-    static void deleteIfEmpty();
     static void cleanupTexturesForCacheKey(qint64 cacheKey);
     static void cleanupTexturesForPixampData(QPixmapData* pixmap);
 …
 private:
+    QCache<qint64, QGLTexture> m_cache;
+};
+    QCache<QGLTextureCacheKey, QGLTexture> m_cache;
+    QReadWriteLock m_lock;
+};
+int QGLTextureCache::size() {
+    QReadLocker locker(&m_lock);
+    return m_cache.size();
+}
+void QGLTextureCache::setMaxCost(int newMax)
+{
+    QWriteLocker locker(&m_lock);
+    m_cache.setMaxCost(newMax);
+}
+int QGLTextureCache::maxCost()
+{
+    QReadLocker locker(&m_lock);
+    return m_cache.maxCost();
+}
+QGLTexture* QGLTextureCache::getTexture(QGLContext *ctx, qint64 key)
+{
+    QReadLocker locker(&m_lock);
+    const QGLTextureCacheKey cacheKey = {key, QGLContextPrivate::contextGroup(ctx)};
+    return m_cache.object(cacheKey);
+}
 extern Q_OPENGL_EXPORT QPaintEngine* qt_qgl_paint_engine();

trunk/src/opengl/qgl_qws.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     else
         return false;
+}
-void qt_egl_add_platform_config(QEglProperties& props, QPaintDevice *device)
+{
-    // Find the QGLScreen for this paint device.
-    QGLScreen *glScreen = glScreenForDevice(device);
-    if (!glScreen) {
-        qWarning("QGLContext::chooseContext(): The screen is not a QGLScreen");
-        return;
+    }
-    int devType = device->devType();
-    if (devType == QInternal::Image)
-        props.setPixelFormat(static_cast<QImage *>(device)->format());
-    else
-        props.setPixelFormat(glScreen->pixelFormat());
+}
 …
     // Get the display and initialize it.
     d->eglContext = new QEglContext();
+    d->ownsEglContext = true;
     d->eglContext->setApi(QEgl::OpenGL);
     // Construct the configuration we need for this surface.
     QEglProperties configProps;
+    qt_egl_add_platform_config(configProps, device());
+    qt_egl_set_format(configProps, devType, d->glFormat);
+    qt_eglproperties_set_glformat(configProps, d->glFormat);
+    configProps.setDeviceType(devType);
+    configProps.setPaintDeviceFormat(device());
     configProps.setRenderableType(QEgl::OpenGL);
 …
     // Inform the higher layers about the actual format properties.
     qt_egl_update_format(*(d->eglContext), d->glFormat);
+    qt_glformat_from_eglconfig(d->glFormat, d->eglContext->config());
     // Create a new context for the configuration.

trunk/src/opengl/qgl_win.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #endif
+#ifndef WGL_ARB_create_context
+#define WGL_CONTEXT_MAJOR_VERSION_ARB               0x2091
+#define WGL_CONTEXT_MINOR_VERSION_ARB               0x2092
+#define WGL_CONTEXT_LAYER_PLANE_ARB                 0x2093
+#define WGL_CONTEXT_FLAGS_ARB                       0x2094
+#define WGL_CONTEXT_PROFILE_MASK_ARB                0x9126
+#define WGL_CONTEXT_DEBUG_BIT_ARB                   0x0001
+#define WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB      0x0002
+#define WGL_CONTEXT_CORE_PROFILE_BIT_ARB            0x0001
+#define WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB   0x0002
+// Error codes returned by GetLastError().
+#define ERROR_INVALID_VERSION_ARB                   0x2095
+#define ERROR_INVALID_PROFILE_ARB                   0x2096
+#endif
+#ifndef GL_VERSION_3_2
+#define GL_CONTEXT_PROFILE_MASK                     0x9126
+#define GL_MAJOR_VERSION                            0x821B
+#define GL_MINOR_VERSION                            0x821C
+#define GL_NUM_EXTENSIONS                           0x821D
+#define GL_CONTEXT_FLAGS                            0x821E
+#define GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT      0x0001
+#endif
 QT_BEGIN_NAMESPACE
 …
+}
+static bool qgl_create_context(HDC hdc, QGLContextPrivate *d, QGLContextPrivate *shareContext)
+{
+    d->rc = 0;
+    typedef HGLRC (APIENTRYP PFNWGLCREATECONTEXTATTRIBSARB)(HDC, HGLRC, const int *);
+    PFNWGLCREATECONTEXTATTRIBSARB wglCreateContextAttribsARB =
+        (PFNWGLCREATECONTEXTATTRIBSARB) wglGetProcAddress("wglCreateContextAttribsARB");
+    if (wglCreateContextAttribsARB) {
+        int attributes[11];
+        int attribIndex = 0;
+        const int major = d->reqFormat.majorVersion();
+        const int minor = d->reqFormat.minorVersion();
+        attributes[attribIndex++] = WGL_CONTEXT_MAJOR_VERSION_ARB;
+        attributes[attribIndex++] = major;
+        attributes[attribIndex++] = WGL_CONTEXT_MINOR_VERSION_ARB;
+        attributes[attribIndex++] = minor;
+        if (major >= 3 && !d->reqFormat.testOption(QGL::DeprecatedFunctions)) {
+            attributes[attribIndex++] = WGL_CONTEXT_FLAGS_ARB;
+            attributes[attribIndex++] = WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB;
+        }
+        if ((major == 3 && minor >= 2) || major > 3) {
+            switch (d->reqFormat.profile()) {
+            case QGLFormat::NoProfile:
+                break;
+            case QGLFormat::CoreProfile:
+                attributes[attribIndex++] = WGL_CONTEXT_PROFILE_MASK_ARB;
+                attributes[attribIndex++] = WGL_CONTEXT_CORE_PROFILE_BIT_ARB;
+                break;
+            case QGLFormat::CompatibilityProfile:
+                attributes[attribIndex++] = WGL_CONTEXT_PROFILE_MASK_ARB;
+                attributes[attribIndex++] = WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB;
+                break;
+            default:
+                qWarning("QGLContext::chooseContext(): Context profile not supported.");
+                return false;
+            }
+        }
+        if (d->reqFormat.plane() != 0) {
+            attributes[attribIndex++] = WGL_CONTEXT_LAYER_PLANE_ARB;
+            attributes[attribIndex++] = d->reqFormat.plane();
+        }
+        attributes[attribIndex++] = 0; // Terminate list.
+        d->rc = wglCreateContextAttribsARB(hdc, shareContext && shareContext->valid
+                                           ? shareContext->rc : 0, attributes);
+        if (d->rc) {
+            if (shareContext)
+                shareContext->sharing = d->sharing = true;
+            return true;
+        }
+    }
+    d->rc = wglCreateLayerContext(hdc, d->reqFormat.plane());
+    if (d->rc && shareContext && shareContext->valid)
+        shareContext->sharing = d->sharing = wglShareLists(shareContext->rc, d->rc);
+    return d->rc != 0;
+}
+void QGLContextPrivate::updateFormatVersion()
+{
+    const GLubyte *s = glGetString(GL_VERSION);
+    if (!(s && s[0] >= '0' && s[0] <= '9' && s[1] == '.' && s[2] >= '0' && s[2] <= '9')) {
+        if (!s)
+            qWarning("QGLContext::chooseContext(): OpenGL version string is null.");
+        else
+            qWarning("QGLContext::chooseContext(): Unexpected OpenGL version string format.");
+        glFormat.setVersion(0, 0);
+        glFormat.setProfile(QGLFormat::NoProfile);
+        glFormat.setOption(QGL::DeprecatedFunctions);
+        return;
+    }
+    int major = s[0] - '0';
+    int minor = s[2] - '0';
+    glFormat.setVersion(major, minor);
+    if (major < 3) {
+        glFormat.setProfile(QGLFormat::NoProfile);
+        glFormat.setOption(QGL::DeprecatedFunctions);
+    } else {
+        GLint value = 0;
+        if (major > 3 || minor >= 2)
+            glGetIntegerv(GL_CONTEXT_PROFILE_MASK, &value);
+        switch (value) {
+        case WGL_CONTEXT_CORE_PROFILE_BIT_ARB:
+            glFormat.setProfile(QGLFormat::CoreProfile);
+            break;
+        case WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB:
+            glFormat.setProfile(QGLFormat::CompatibilityProfile);
+            break;
+        default:
+            glFormat.setProfile(QGLFormat::NoProfile);
+            break;
+        }
+        glGetIntegerv(GL_CONTEXT_FLAGS, &value);
+        if (value & GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT)
+            glFormat.setOption(QGL::NoDeprecatedFunctions);
+        else
+            glFormat.setOption(QGL::DeprecatedFunctions);
+    }
+}
 bool QGLContext::chooseContext(const QGLContext* shareContext)
+{
+    QGLContextPrivate *share = shareContext ? const_cast<QGLContext *>(shareContext)->d_func() : 0;
     Q_D(QGLContext);
     // workaround for matrox driver:
 …
+        }
+        d->rc = wglCreateLayerContext(myDc, d->glFormat.plane());
+        if (!d->rc) {
+        if (!qgl_create_context(myDc, d, share)) {
             qwglError("QGLContext::chooseContext()", "CreateLayerContext");
             result = false;
 …
             d->cmap->setEntry(lpfd.crTransparent, qRgb(1, 2, 3));//, QGLCmap::Reserved);
+        }
+        if (shareContext && shareContext->isValid()) {
+            QGLContext *share = const_cast<QGLContext *>(shareContext);
+            d->sharing = (wglShareLists(shareContext->d_func()->rc, d->rc) != 0);
+            share->d_func()->sharing = d->sharing;
+        }
+        goto end;
+    }
+    {
+    } else {
         PIXELFORMATDESCRIPTOR pfd;
         PIXELFORMATDESCRIPTOR realPfd;
 …
+        }
         if (!(d->rc = wglCreateLayerContext(myDc, 0))) {
+        if (!qgl_create_context(myDc, d, share)) {
             qwglError("QGLContext::chooseContext()", "wglCreateContext");
             result = false;
             goto end;
+        }
-        if (shareContext && shareContext->isValid()) {
-            d->sharing = (wglShareLists(shareContext->d_func()->rc, d->rc) != 0);
-            const_cast<QGLContext *>(shareContext)->d_func()->sharing = d->sharing;
+        }
 …
     // vblanking
     wglMakeCurrent(myDc, d->rc);
+    if (d->rc)
+        d->updateFormatVersion();
     typedef BOOL (APIENTRYP PFNWGLSWAPINTERVALEXT) (int interval);
     typedef int (APIENTRYP PFNWGLGETSWAPINTERVALEXT) (void);
 …
         iAttributes[i++] = TRUE;
         iAttributes[i++] = WGL_COLOR_BITS_ARB;
         iAttributes[i++] = 32;
+        iAttributes[i++] = 24;
         iAttributes[i++] = WGL_DOUBLE_BUFFER_ARB;
         iAttributes[i++] = d->glFormat.doubleBuffer();
 …
+{
     Q_D(QGLContext);
     if (d->rc == wglGetCurrentContext() || !d->valid)        // already current
+    if (d->rc == wglGetCurrentContext() || !d->valid)       // already current
         return;
     if (d->win) {
         d->dc = GetDC(d->win);

trunk/src/opengl/qgl_wince.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #include <windows.h>
+#include <private/qegl_p.h>
+#include <private/qeglproperties_p.h>
+#include <private/qeglcontext_p.h>
 #include <private/qgl_egl_p.h>
-#include <private/qgl_cl_p.h>
 …
   QGLFormat Win32/WGL-specific code
  *****************************************************************************/
-void qt_egl_add_platform_config(QEglProperties& props, QPaintDevice *device)
+{
-    int devType = device->devType();
-    if (devType == QInternal::Image)
-        props.setPixelFormat(static_cast<QImage *>(device)->format());
-    else
-        props.setPixelFormat(QImage::Format_RGB16);
+}
 static bool opengl32dll = false;
 …
     // Get the display and initialize it.
     d->eglContext = new QEglContext();
+    d->ownsEglContext = true;
     d->eglContext->setApi(QEgl::OpenGL);
     // Construct the configuration we need for this surface.
     QEglProperties configProps;
+    qt_egl_add_platform_config(configProps, device());
+    qt_egl_set_format(configProps, devType, d->glFormat);
+    qt_eglproperties_set_glformat(configProps, d->glFormat);
+    configProps.setDeviceType(devType);
+    configProps.setPaintDeviceFormat(device());
     configProps.setRenderableType(QEgl::OpenGL);
 …
     // Inform the higher layers about the actual format properties.
     qt_egl_update_format(*(d->eglContext), d->glFormat);
+    qt_glformat_from_eglconfig(d->glFormat, d->eglContext->config());
     // Create a new context for the configuration.

trunk/src/opengl/qgl_x11.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #include <private/qpixmap_x11_p.h>
 #include <private/qimagepixmapcleanuphooks_p.h>
+#include <private/qunicodetables_p.h>
 #ifdef Q_OS_HPUX
 // for GLXPBuffer
 …
 #define GLX_TEXTURE_RECTANGLE_EXT          0x20DD
 #define GLX_FRONT_LEFT_EXT                 0x20DE
+#endif
+#ifndef GLX_ARB_create_context
+#define GLX_CONTEXT_DEBUG_BIT_ARB          0x00000001
+#define GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x00000002
+#define GLX_CONTEXT_MAJOR_VERSION_ARB      0x2091
+#define GLX_CONTEXT_MINOR_VERSION_ARB      0x2092
+#define GLX_CONTEXT_FLAGS_ARB              0x2094
+#endif
+#ifndef GLX_ARB_create_context_profile
+#define GLX_CONTEXT_CORE_PROFILE_BIT_ARB   0x00000001
+#define GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002
+#define GLX_CONTEXT_PROFILE_MASK_ARB       0x9126
 #endif
 …
         find_trans_colors();
     return trans_colors.size() > 0;
+}
+static bool buildSpec(int* spec, const QGLFormat& f, QPaintDevice* paintDevice,
+                      int bufDepth, bool onlyFBConfig = false)
+{
+    int i = 0;
+    spec[i++] = GLX_LEVEL;
+    spec[i++] = f.plane();
+    const QX11Info *xinfo = qt_x11Info(paintDevice);
+    bool useFBConfig = onlyFBConfig;
+#if defined(GLX_VERSION_1_3) && !defined(QT_NO_XRENDER) && !defined(Q_OS_HPUX)
+    /*
+      HPUX defines GLX_VERSION_1_3 but does not implement the corresponding functions.
+      Specifically glXChooseFBConfig and glXGetVisualFromFBConfig are not implemented.
+     */
+    QWidget* widget = 0;
+    if (paintDevice->devType() == QInternal::Widget)
+        widget = static_cast<QWidget*>(paintDevice);
+    // Only use glXChooseFBConfig for widgets if we're trying to get an ARGB visual
+    if (widget && widget->testAttribute(Qt::WA_TranslucentBackground) && X11->use_xrender)
+        useFBConfig = true;
+#endif
+#if defined(GLX_VERSION_1_1) && defined(GLX_EXT_visual_info)
+    static bool useTranspExt = false;
+    static bool useTranspExtChecked = false;
+    if (f.plane() && !useTranspExtChecked && paintDevice) {
+        QGLExtensionMatcher extensions(glXQueryExtensionsString(xinfo->display(), xinfo->screen()));
+        useTranspExt = extensions.match("GLX_EXT_visual_info");
+        //# (A bit simplistic; that could theoretically be a substring)
+        if (useTranspExt) {
+            QByteArray cstr(glXGetClientString(xinfo->display(), GLX_VENDOR));
+            useTranspExt = !cstr.contains("Xi Graphics"); // bug workaround
+            if (useTranspExt) {
+                // bug workaround - some systems (eg. FireGL) refuses to return an overlay
+                // visual if the GLX_TRANSPARENT_TYPE_EXT attribute is specified, even if
+                // the implementation supports transparent overlays
+                int tmpSpec[] = { GLX_LEVEL, f.plane(), GLX_TRANSPARENT_TYPE_EXT,
+                                  f.rgba() ? GLX_TRANSPARENT_RGB_EXT : GLX_TRANSPARENT_INDEX_EXT,
+                                  XNone };
+                XVisualInfo * vinf = glXChooseVisual(xinfo->display(), xinfo->screen(), tmpSpec);
+                if (!vinf) {
+                    useTranspExt = false;
+                }
+            }
+        }
+        useTranspExtChecked = true;
+    }
+    if (f.plane() && useTranspExt && !useFBConfig) {
+        // Required to avoid non-transparent overlay visual(!) on some systems
+        spec[i++] = GLX_TRANSPARENT_TYPE_EXT;
+        spec[i++] = f.rgba() ? GLX_TRANSPARENT_RGB_EXT : GLX_TRANSPARENT_INDEX_EXT;
+    }
+#endif
+#if defined(GLX_VERSION_1_3)  && !defined(Q_OS_HPUX)
+    // GLX_RENDER_TYPE is only in glx >=1.3
+    if (useFBConfig) {
+        spec[i++] = GLX_RENDER_TYPE;
+        spec[i++] = f.rgba() ? GLX_RGBA_BIT : GLX_COLOR_INDEX_BIT;
+    }
+#endif
+    if (f.doubleBuffer())
+        spec[i++] = GLX_DOUBLEBUFFER;
+        if (useFBConfig)
+            spec[i++] = True;
+    if (f.depth()) {
+        spec[i++] = GLX_DEPTH_SIZE;
+        spec[i++] = f.depthBufferSize() == -1 ? 1 : f.depthBufferSize();
+    }
+    if (f.stereo()) {
+        spec[i++] = GLX_STEREO;
+        if (useFBConfig)
+            spec[i++] = True;
+    }
+    if (f.stencil()) {
+        spec[i++] = GLX_STENCIL_SIZE;
+        spec[i++] = f.stencilBufferSize() == -1 ? 1 : f.stencilBufferSize();
+    }
+    if (f.rgba()) {
+        if (!useFBConfig)
+            spec[i++] = GLX_RGBA;
+        spec[i++] = GLX_RED_SIZE;
+        spec[i++] = f.redBufferSize() == -1 ? 1 : f.redBufferSize();
+        spec[i++] = GLX_GREEN_SIZE;
+        spec[i++] = f.greenBufferSize() == -1 ? 1 : f.greenBufferSize();
+        spec[i++] = GLX_BLUE_SIZE;
+        spec[i++] = f.blueBufferSize() == -1 ? 1 : f.blueBufferSize();
+        if (f.alpha()) {
+            spec[i++] = GLX_ALPHA_SIZE;
+            spec[i++] = f.alphaBufferSize() == -1 ? 1 : f.alphaBufferSize();
+        }
+        if (f.accum()) {
+            spec[i++] = GLX_ACCUM_RED_SIZE;
+            spec[i++] = f.accumBufferSize() == -1 ? 1 : f.accumBufferSize();
+            spec[i++] = GLX_ACCUM_GREEN_SIZE;
+            spec[i++] = f.accumBufferSize() == -1 ? 1 : f.accumBufferSize();
+            spec[i++] = GLX_ACCUM_BLUE_SIZE;
+            spec[i++] = f.accumBufferSize() == -1 ? 1 : f.accumBufferSize();
+            if (f.alpha()) {
+                spec[i++] = GLX_ACCUM_ALPHA_SIZE;
+                spec[i++] = f.accumBufferSize() == -1 ? 1 : f.accumBufferSize();
+            }
+        }
+    } else {
+        spec[i++] = GLX_BUFFER_SIZE;
+        spec[i++] = bufDepth;
+    }
+    if (f.sampleBuffers()) {
+        spec[i++] = GLX_SAMPLE_BUFFERS_ARB;
+        spec[i++] = 1;
+        spec[i++] = GLX_SAMPLES_ARB;
+        spec[i++] = f.samples() == -1 ? 4 : f.samples();
+    }
+#if defined(GLX_VERSION_1_3) && !defined(Q_OS_HPUX)
+    if (useFBConfig) {
+        spec[i++] = GLX_DRAWABLE_TYPE;
+        switch(paintDevice->devType()) {
+        case QInternal::Pixmap:
+            spec[i++] = GLX_PIXMAP_BIT;
+            break;
+        case QInternal::Pbuffer:
+            spec[i++] = GLX_PBUFFER_BIT;
+            break;
+        default:
+            qWarning("QGLContext: Unknown paint device type %d", paintDevice->devType());
+            // Fall-through & assume it's a window
+        case QInternal::Widget:
+            spec[i++] = GLX_WINDOW_BIT;
+            break;
+        };
+    }
+#endif
+    spec[i] = XNone;
+    return useFBConfig;
+}
 …
+    }
+    const int major = d->reqFormat.majorVersion();
+    const int minor = d->reqFormat.minorVersion();
+    const int profile = d->reqFormat.profile() == QGLFormat::CompatibilityProfile
+        ? GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB
+        : GLX_CONTEXT_CORE_PROFILE_BIT_ARB;
     d->cx = 0;
+    if (shareContext) {
+#if defined(GLX_VERSION_1_3) && !defined(Q_OS_HPUX)
+    /*
+      HPUX defines GLX_VERSION_1_3 but does not implement the corresponding functions.
+      Specifically glXChooseFBConfig and glXGetVisualFromFBConfig are not implemented.
+     */
+    if ((major == 3 && minor >= 2) || major > 3) {
+        QGLTemporaryContext *tmpContext = 0;
+        if (!QGLContext::currentContext())
+            tmpContext = new QGLTemporaryContext;
+        int attributes[] = { GLX_CONTEXT_MAJOR_VERSION_ARB, major,
+                             GLX_CONTEXT_MINOR_VERSION_ARB, minor,
+                             GLX_CONTEXT_PROFILE_MASK_ARB, profile,
+};
+        typedef GLXContext ( * Q_PFNGLXCREATECONTEXTATTRIBSARBPROC)
+            (Display* dpy, GLXFBConfig config, GLXContext share_context, Bool direct, const int *attrib_list);
+        Q_PFNGLXCREATECONTEXTATTRIBSARBPROC glXCreateContextAttribs =
+            (Q_PFNGLXCREATECONTEXTATTRIBSARBPROC) qglx_getProcAddress("glXCreateContextAttribsARB");
+        if (glXCreateContextAttribs) {
+            int spec[45];
+            glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_BUFFER_SIZE, &res);
+            buildSpec(spec, format(), d->paintDevice, res, true);
+            GLXFBConfig *configs;
+            int configCount = 0;
+            configs = glXChooseFBConfig(disp, xinfo->screen(), spec, &configCount);
+            if (configs && configCount > 0) {
+                d->cx = glXCreateContextAttribs(disp, configs[0],
+                    shareContext ? (GLXContext)shareContext->d_func()->cx : 0, direct, attributes);
+                if (!d->cx && shareContext) {
+                    shareContext = 0;
+                    d->cx = glXCreateContextAttribs(disp, configs[0], 0, direct, attributes);
+                }
+                d->screen = ((XVisualInfo*)d->vi)->screen;
+            }
+            XFree(configs);
+        } else {
+            qWarning("QGLContext::chooseContext(): OpenGL %d.%d is not supported", major, minor);
+        }
+        if (tmpContext)
+            delete tmpContext;
+    }
+#else
+    Q_UNUSED(major);
+    Q_UNUSED(minor);
+    Q_UNUSED(profile);
+#endif
+    if (!d->cx && shareContext) {
         d->cx = glXCreateContext(disp, (XVisualInfo *)d->vi,
                                (GLXContext)shareContext->d_func()->cx, direct);
         d->screen = ((XVisualInfo*)d->vi)->screen;
-        if (d->cx) {
-            QGLContext *share = const_cast<QGLContext *>(shareContext);
-            d->sharing = true;
-            share->d_func()->sharing = true;
+        }
+    }
     if (!d->cx) {
         d->cx = glXCreateContext(disp, (XVisualInfo *)d->vi, NULL, direct);
         d->screen = ((XVisualInfo*)d->vi)->screen;
+    }
+        shareContext = 0;
+    }
+    if (shareContext && d->cx) {
+        QGLContext *share = const_cast<QGLContext *>(shareContext);
+        d->sharing = true;
+        share->d_func()->sharing = true;
+    }
     if (!d->cx)
         return false;
 …
     Q_D(QGLContext);
     int spec[45];
-    int i = 0;
-    spec[i++] = GLX_LEVEL;
-    spec[i++] = f.plane();
     const QX11Info *xinfo = qt_x11Info(d->paintDevice);
+    bool useFBConfig = false;
+#if defined(GLX_VERSION_1_3) && !defined(QT_NO_XRENDER) && !defined(Q_OS_HPUX)
+    /*
+      HPUX defines GLX_VERSION_1_3 but does not implement the corresponding functions.
+      Specifically glXChooseFBConfig and glXGetVisualFromFBConfig are not implemented.
+     */
+    QWidget* widget = 0;
+    if (d->paintDevice->devType() == QInternal::Widget)
+        widget = static_cast<QWidget*>(d->paintDevice);
+    // Only use glXChooseFBConfig for widgets if we're trying to get an ARGB visual
+    if (widget && widget->testAttribute(Qt::WA_TranslucentBackground) && X11->use_xrender)
+        useFBConfig = true;
+#endif
+#if defined(GLX_VERSION_1_1) && defined(GLX_EXT_visual_info)
+    static bool useTranspExt = false;
+    static bool useTranspExtChecked = false;
+    if (f.plane() && !useTranspExtChecked && d->paintDevice) {
+        QGLExtensionMatcher extensions(glXQueryExtensionsString(xinfo->display(), xinfo->screen()));
+        useTranspExt = extensions.match("GLX_EXT_visual_info");
+        //# (A bit simplistic; that could theoretically be a substring)
+        if (useTranspExt) {
+            QByteArray cstr(glXGetClientString(xinfo->display(), GLX_VENDOR));
+            useTranspExt = !cstr.contains("Xi Graphics"); // bug workaround
+            if (useTranspExt) {
+                // bug workaround - some systems (eg. FireGL) refuses to return an overlay
+                // visual if the GLX_TRANSPARENT_TYPE_EXT attribute is specified, even if
+                // the implementation supports transparent overlays
+                int tmpSpec[] = { GLX_LEVEL, f.plane(), GLX_TRANSPARENT_TYPE_EXT,
+                                  f.rgba() ? GLX_TRANSPARENT_RGB_EXT : GLX_TRANSPARENT_INDEX_EXT,
+                                  XNone };
+                XVisualInfo * vinf = glXChooseVisual(xinfo->display(), xinfo->screen(), tmpSpec);
+                if (!vinf) {
+                    useTranspExt = false;
+                }
+            }
+        }
+        useTranspExtChecked = true;
+    }
+    if (f.plane() && useTranspExt && !useFBConfig) {
+        // Required to avoid non-transparent overlay visual(!) on some systems
+        spec[i++] = GLX_TRANSPARENT_TYPE_EXT;
+        spec[i++] = f.rgba() ? GLX_TRANSPARENT_RGB_EXT : GLX_TRANSPARENT_INDEX_EXT;
+    }
+#endif
+#if defined(GLX_VERSION_1_3)  && !defined(Q_OS_HPUX)
+    // GLX_RENDER_TYPE is only in glx >=1.3
+    if (useFBConfig) {
+        spec[i++] = GLX_RENDER_TYPE;
+        spec[i++] = f.rgba() ? GLX_RGBA_BIT : GLX_COLOR_INDEX_BIT;
+    }
+#endif
+    if (f.doubleBuffer())
+        spec[i++] = GLX_DOUBLEBUFFER;
+        if (useFBConfig)
+            spec[i++] = True;
+    if (f.depth()) {
+        spec[i++] = GLX_DEPTH_SIZE;
+        spec[i++] = f.depthBufferSize() == -1 ? 1 : f.depthBufferSize();
+    }
+    if (f.stereo()) {
+        spec[i++] = GLX_STEREO;
+        if (useFBConfig)
+            spec[i++] = True;
+    }
+    if (f.stencil()) {
+        spec[i++] = GLX_STENCIL_SIZE;
+        spec[i++] = f.stencilBufferSize() == -1 ? 1 : f.stencilBufferSize();
+    }
+    if (f.rgba()) {
+        if (!useFBConfig)
+            spec[i++] = GLX_RGBA;
+        spec[i++] = GLX_RED_SIZE;
+        spec[i++] = f.redBufferSize() == -1 ? 1 : f.redBufferSize();
+        spec[i++] = GLX_GREEN_SIZE;
+        spec[i++] = f.greenBufferSize() == -1 ? 1 : f.greenBufferSize();
+        spec[i++] = GLX_BLUE_SIZE;
+        spec[i++] = f.blueBufferSize() == -1 ? 1 : f.blueBufferSize();
+        if (f.alpha()) {
+            spec[i++] = GLX_ALPHA_SIZE;
+            spec[i++] = f.alphaBufferSize() == -1 ? 1 : f.alphaBufferSize();
+        }
+        if (f.accum()) {
+            spec[i++] = GLX_ACCUM_RED_SIZE;
+            spec[i++] = f.accumBufferSize() == -1 ? 1 : f.accumBufferSize();
+            spec[i++] = GLX_ACCUM_GREEN_SIZE;
+            spec[i++] = f.accumBufferSize() == -1 ? 1 : f.accumBufferSize();
+            spec[i++] = GLX_ACCUM_BLUE_SIZE;
+            spec[i++] = f.accumBufferSize() == -1 ? 1 : f.accumBufferSize();
+            if (f.alpha()) {
+                spec[i++] = GLX_ACCUM_ALPHA_SIZE;
+                spec[i++] = f.accumBufferSize() == -1 ? 1 : f.accumBufferSize();
+            }
+        }
+    } else {
+        spec[i++] = GLX_BUFFER_SIZE;
+        spec[i++] = bufDepth;
+    }
+    if (f.sampleBuffers()) {
+        spec[i++] = GLX_SAMPLE_BUFFERS_ARB;
+        spec[i++] = 1;
+        spec[i++] = GLX_SAMPLES_ARB;
+        spec[i++] = f.samples() == -1 ? 4 : f.samples();
+    }
+#if defined(GLX_VERSION_1_3) && !defined(Q_OS_HPUX)
+    if (useFBConfig) {
+        spec[i++] = GLX_DRAWABLE_TYPE;
+        switch(d->paintDevice->devType()) {
+        case QInternal::Pixmap:
+            spec[i++] = GLX_PIXMAP_BIT;
+            break;
+        case QInternal::Pbuffer:
+            spec[i++] = GLX_PBUFFER_BIT;
+            break;
+        default:
+            qWarning("QGLContext: Unknown paint device type %d", d->paintDevice->devType());
+            // Fall-through & assume it's a window
+        case QInternal::Widget:
+            spec[i++] = GLX_WINDOW_BIT;
+            break;
+        };
+    }
+#endif
+    spec[i] = XNone;
+    bool useFBConfig = buildSpec(spec, f, d->paintDevice, bufDepth, false);
     XVisualInfo* chosenVisualInfo = 0;
 …
             break; // fallback to trying glXChooseVisual
         for (i = 0; i < configCount; ++i) {
+        for (int i = 0; i < configCount; ++i) {
             XVisualInfo* vi;
             vi = glXGetVisualFromFBConfig(xinfo->display(), configs[i]);
 …
         ok = glXMakeCurrent(xinfo->display(), (GLXPbuffer)d->pbuf, (GLXContext)d->cx);
     } else if (d->paintDevice->devType() == QInternal::Widget) {
         ok = glXMakeCurrent(xinfo->display(), ((QWidget *)d->paintDevice)->winId(), (GLXContext)d->cx);
+        ok = glXMakeCurrent(xinfo->display(), ((QWidget *)d->paintDevice)->internalWinId(), (GLXContext)d->cx);
+    }
     if (!ok)
 …
 QGLTexture *QGLContextPrivate::bindTextureFromNativePixmap(QPixmapData *pmd, const qint64 key,
+QGLTexture *QGLContextPrivate::bindTextureFromNativePixmap(QPixmap *pixmap, const qint64 key,
                                                            QGLContext::BindOptions options)
+{
 …
     return 0;
 #else
+    // Check we have GLX 1.3, as it is needed for glXCreatePixmap & glXDestroyPixmap
+    int majorVersion = 0;
+    int minorVersion = 0;
+    glXQueryVersion(X11->display, &majorVersion, &minorVersion);
+    if (majorVersion < 1 || (majorVersion == 1 && minorVersion < 3))
+        return 0;
     Q_Q(QGLContext);
+    Q_ASSERT(pmd->classId() == QPixmapData::X11Class);
+    QX11PixmapData *pixmapData = static_cast<QX11PixmapData*>(pixmap->data_ptr().data());
+    Q_ASSERT(pixmapData->classId() == QPixmapData::X11Class);
+    // We can't use TFP if the pixmap has a separate X11 mask
+    if (pixmapData->x11_mask)
+        return 0;
     if (!qt_resolveTextureFromPixmap(paintDevice))
         return 0;
-    QX11PixmapData *pixmapData = static_cast<QX11PixmapData*>(pmd);
     const QX11Info &x11Info = pixmapData->xinfo;
 …
             return 0;
         pixmapData->gl_surface = (Qt::HANDLE)glxPixmap;
+        pixmapData->gl_surface = (void*)glxPixmap;
         // Make sure the cleanup hook gets called so we can delete the glx pixmap
 …
     glBindTexture(GL_TEXTURE_2D, textureId);
+    GLuint filtering = (options & QGLContext::LinearFilteringBindOption) ? GL_LINEAR : GL_NEAREST;
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filtering);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filtering);
     if (!((hasAlpha && RGBAConfigInverted) || (!hasAlpha && RGBConfigInverted)))

trunk/src/opengl/qgl_x11egl.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #include <private/qt_x11_p.h>
 #include <private/qpixmap_x11_p.h>
-#include <private/qimagepixmapcleanuphooks_p.h>
 #include <private/qgl_p.h>
 #include <private/qpaintengine_opengl_p.h>
 …
 #include "qcolormap.h"
 #include <QDebug>
+#include <QPixmap>
 QT_BEGIN_NAMESPACE
-bool qt_egl_setup_x11_visual(XVisualInfo &vi, EGLDisplay display, EGLConfig config,
-                             const QX11Info &x11Info, bool useArgbVisual);
 /*
 …
     int screen = 0;
+    d->display = eglGetDisplay(EGLNativeDisplayType(X11->display));
+    if (!eglInitialize(d->display, NULL, NULL)) {
+        qWarning("QGLTemporaryContext: Unable to initialize EGL display.");
+        return;
+    }
+    d->display = QEgl::display();
     EGLConfig config;
 …
     XVisualInfo *vi;
     int numVisuals;
+    EGLint id = 0;
+    eglGetConfigAttrib(d->display, config, EGL_NATIVE_VISUAL_ID, &id);
+    if (id == 0) {
+        // EGL_NATIVE_VISUAL_ID is optional and might not be supported
+        // on some implementations - we'll have to do it the hard way
+        QX11Info xinfo;
+        qt_egl_setup_x11_visual(visualInfo, d->display, config, xinfo, false);
+    } else {
+        visualInfo.visualid = id;
+    }
+    visualInfo.visualid = QEgl::getCompatibleVisualId(config);
     vi = XGetVisualInfo(X11->display, VisualIDMask, &visualInfo, &numVisuals);
     if (!vi || numVisuals < 1) {
 …
+}
-void qt_egl_add_platform_config(QEglProperties& props, QPaintDevice *device)
+{
-    if (device->devType() == QInternal::Image)
-        props.setPixelFormat(static_cast<QImage *>(device)->format());
+}
 // Chooses the EGL config and creates the EGL context
 bool QGLContext::chooseContext(const QGLContext* shareContext)
 …
     int devType = device()->devType();
+    // Get the display and initialize it.
+    QX11PixmapData *x11PixmapData = 0;
+    if (devType == QInternal::Pixmap) {
+        QPixmapData *pmd = static_cast<QPixmap*>(device())->data_ptr().data();
+        if (pmd->classId() == QPixmapData::X11Class)
+            x11PixmapData = static_cast<QX11PixmapData*>(pmd);
+        else {
+            // TODO: Replace the pixmap's data with a new QX11PixmapData
+            qWarning("WARNING: Creating a QGLContext on a QPixmap is only supported for X11 pixmap backend");
+            return false;
+        }
+    } else if ((devType != QInternal::Widget) && (devType != QInternal::Pbuffer)) {
+        qWarning("WARNING: Creating a QGLContext not supported on device type %d", devType);
+        return false;
+    }
+    // Only create the eglContext if we don't already have one:
     if (d->eglContext == 0) {
         d->eglContext = new QEglContext();
+        d->ownsEglContext = true;
         d->eglContext->setApi(QEgl::OpenGL);
+        // If the device is a widget with WA_TranslucentBackground set, make sure the glFormat
+        // has the alpha channel option set:
+        if (devType == QInternal::Widget) {
+            QWidget* widget = static_cast<QWidget*>(device());
+            if (widget->testAttribute(Qt::WA_TranslucentBackground))
+                d->glFormat.setAlpha(true);
+        }
         // Construct the configuration we need for this surface.
         QEglProperties configProps;
+        qt_egl_set_format(configProps, devType, d->glFormat);
+        qt_egl_add_platform_config(configProps, device());
+        configProps.setDeviceType(devType);
         configProps.setRenderableType(QEgl::OpenGL);
+#if We_have_an_EGL_library_which_bothers_to_check_EGL_BUFFER_SIZE
+        if (device()->depth() == 16 && configProps.value(EGL_ALPHA_SIZE) <= 0) {
+            qDebug("Setting EGL_BUFFER_SIZE to 16");
+            configProps.setValue(EGL_BUFFER_SIZE, 16);
+            configProps.setValue(EGL_ALPHA_SIZE, 0);
+        }
+        qt_eglproperties_set_glformat(configProps, d->glFormat);
+        // Set buffer preserved for regular QWidgets, QGLWidgets are ok with either preserved or destroyed:
+        if ((devType == QInternal::Widget) && qobject_cast<QGLWidget*>(static_cast<QWidget*>(device())) == 0)
+            configProps.setValue(EGL_SWAP_BEHAVIOR, EGL_BUFFER_PRESERVED);
         if (!d->eglContext->chooseConfig(configProps, QEgl::BestPixelFormat)) {
 …
             return false;
+        }
+#else
+        QEgl::PixelFormatMatch matchType = QEgl::BestPixelFormat;
+        if ((device()->depth() == 16) && configProps.value(EGL_ALPHA_SIZE) == 0) {
+            configProps.setValue(EGL_RED_SIZE, 5);
+            configProps.setValue(EGL_GREEN_SIZE, 6);
+            configProps.setValue(EGL_BLUE_SIZE, 5);
+            configProps.setValue(EGL_ALPHA_SIZE, 0);
+            matchType = QEgl::ExactPixelFormat;
+        }
+        // Search for a matching configuration, reducing the complexity
+        // each time until we get something that matches.
+        if (!d->eglContext->chooseConfig(configProps, matchType)) {
+        // Create a new context for the configuration.
+        QEglContext* eglSharedContext = shareContext ? shareContext->d_func()->eglContext : 0;
+        if (!d->eglContext->createContext(eglSharedContext)) {
             delete d->eglContext;
             d->eglContext = 0;
             return false;
+        }
-#endif
-//        qDebug("QGLContext::chooseContext() - using EGL config %d:", d->eglContext->config());
-//        qDebug() << QEglProperties(d->eglContext->config()).toString();
-        // Create a new context for the configuration.
-        if (!d->eglContext->createContext
-                (shareContext ? shareContext->d_func()->eglContext : 0)) {
-            delete d->eglContext;
-            d->eglContext = 0;
-            return false;
+        }
         d->sharing = d->eglContext->isSharing();
         if (d->sharing && shareContext)
             const_cast<QGLContext *>(shareContext)->d_func()->sharing = true;
+#if defined(EGL_VERSION_1_1)
+        if (d->glFormat.swapInterval() != -1 && devType == QInternal::Widget)
+            eglSwapInterval(d->eglContext->display(), d->glFormat.swapInterval());
+#endif
+    }
+    // Inform the higher layers about the actual format properties.
+    qt_egl_update_format(*(d->eglContext), d->glFormat);
+    }
+    // Inform the higher layers about the actual format properties
+    qt_glformat_from_eglconfig(d->glFormat, d->eglContext->config());
+    // Do don't create the EGLSurface for everything.
+    //    QWidget - yes, create the EGLSurface and store it in QGLContextPrivate::eglSurface
+    //    QGLWidget - yes, create the EGLSurface and store it in QGLContextPrivate::eglSurface
+    //    QPixmap - yes, create the EGLSurface but store it in QX11PixmapData::gl_surface
+    //    QGLPixelBuffer - no, it creates the surface itself and stores it in QGLPixelBufferPrivate::pbuf
+    if (devType == QInternal::Widget) {
+        if (d->eglSurface != EGL_NO_SURFACE)
+            eglDestroySurface(d->eglContext->display(), d->eglSurface);
+        d->eglSurface = QEgl::createSurface(device(), d->eglContext->config());
+        XFlush(X11->display);
+        setWindowCreated(true);
+    }
+    if (x11PixmapData) {
+        // TODO: Actually check to see if the existing surface can be re-used
+        if (x11PixmapData->gl_surface)
+            eglDestroySurface(d->eglContext->display(), (EGLSurface)x11PixmapData->gl_surface);
+        x11PixmapData->gl_surface = (void*)QEgl::createSurface(device(), d->eglContext->config());
+    }
     return true;
 …
+}
-//#define QT_DEBUG_X11_VISUAL_SELECTION 1
-bool qt_egl_setup_x11_visual(XVisualInfo &vi, EGLDisplay display, EGLConfig config, const QX11Info &x11Info, bool useArgbVisual)
+{
-    bool foundVisualIsArgb = useArgbVisual;
-#ifdef QT_DEBUG_X11_VISUAL_SELECTION
-    qDebug("qt_egl_setup_x11_visual() - useArgbVisual=%d", useArgbVisual);
-#endif
-    memset(&vi, 0, sizeof(XVisualInfo));
-    EGLint eglConfigColorSize;
-    eglGetConfigAttrib(display, config, EGL_BUFFER_SIZE, &eglConfigColorSize);
-    // Check to see if EGL is suggesting an appropriate visual id:
-    EGLint nativeVisualId;
-    eglGetConfigAttrib(display, config, EGL_NATIVE_VISUAL_ID, &nativeVisualId);
-    vi.visualid = nativeVisualId;
-    if (vi.visualid) {
-        // EGL has suggested a visual id, so get the rest of the visual info for that id:
-        XVisualInfo *chosenVisualInfo;
-        int matchingCount = 0;
-        chosenVisualInfo = XGetVisualInfo(x11Info.display(), VisualIDMask, &vi, &matchingCount);
-        if (chosenVisualInfo) {
-#if !defined(QT_NO_XRENDER)
-            if (useArgbVisual) {
-                // Check to make sure the visual provided by EGL is ARGB
-                XRenderPictFormat *format;
-                format = XRenderFindVisualFormat(x11Info.display(), chosenVisualInfo->visual);
-                if (format->type == PictTypeDirect && format->direct.alphaMask) {
-#ifdef QT_DEBUG_X11_VISUAL_SELECTION
-                    qDebug("Using ARGB X Visual ID (%d) provided by EGL", (int)vi.visualid);
-#endif
-                    foundVisualIsArgb = true;
-                    vi = *chosenVisualInfo;
+                }
-                else {
-                    qWarning("Warning: EGL suggested using X visual ID %d for config %d, but this is not ARGB",
-                             nativeVisualId, (int)config);
-                    vi.visualid = 0;
+                }
-            } else
-#endif
+            {
-                if (eglConfigColorSize == chosenVisualInfo->depth) {
-#ifdef QT_DEBUG_X11_VISUAL_SELECTION
-                    qDebug("Using opaque X Visual ID (%d) provided by EGL", (int)vi.visualid);
-#endif
-                    vi = *chosenVisualInfo;
-                } else
-                    qWarning("Warning: EGL suggested using X visual ID %d (%d bpp) for config %d (%d bpp), but the depths do not match!",
-                             nativeVisualId, chosenVisualInfo->depth, (int)config, eglConfigColorSize);
+            }
-            XFree(chosenVisualInfo);
+        }
-        else {
-            qWarning("Warning: EGL suggested using X visual ID %d for config %d, but this seems to be invalid!",
-                     nativeVisualId, (int)config);
-            vi.visualid = 0;
+        }
+    }
-    // If EGL does not know the visual ID, so try to select an appropriate one ourselves, first
-    // using XRender if we're supposed to have an alpha, then falling back to XGetVisualInfo
-#if !defined(QT_NO_XRENDER)
-    if (vi.visualid == 0 && useArgbVisual) {
-        // Try to use XRender to find an ARGB visual we can use
-        vi.screen  = x11Info.screen();
-        vi.depth   = 32; //### We might at some point (soon) get ARGB4444
-        vi.c_class = TrueColor;
-        XVisualInfo *matchingVisuals;
-        int matchingCount = 0;
-        matchingVisuals = XGetVisualInfo(x11Info.display(),
-                                         VisualScreenMask|VisualDepthMask|VisualClassMask,
-                                         &vi, &matchingCount);
-        for (int i = 0; i < matchingCount; ++i) {
-            XRenderPictFormat *format;
-            format = XRenderFindVisualFormat(x11Info.display(), matchingVisuals[i].visual);
-            if (format->type == PictTypeDirect && format->direct.alphaMask) {
-                vi = matchingVisuals[i];
-                foundVisualIsArgb = true;
-#ifdef QT_DEBUG_X11_VISUAL_SELECTION
-                qDebug("Using X Visual ID (%d) for ARGB visual as provided by XRender", (int)vi.visualid);
-#endif
-                break;
+            }
+        }
-        XFree(matchingVisuals);
+    }
-#endif
-    if (vi.visualid == 0) {
-        EGLint depth;
-        eglGetConfigAttrib(display, config, EGL_BUFFER_SIZE, &depth);
-        int err;
-        err = XMatchVisualInfo(x11Info.display(), x11Info.screen(), depth, TrueColor, &vi);
-        if (err == 0) {
-            qWarning("Warning: Can't find an X visual which matches the EGL config(%d)'s depth (%d)!",
-                     (int)config, depth);
-            depth = x11Info.depth();
-            err = XMatchVisualInfo(x11Info.display(), x11Info.screen(), depth, TrueColor, &vi);
-            if (err == 0) {
-                qWarning("Error: Couldn't get any matching X visual!");
-                return false;
-            } else
-                qWarning("         - Falling back to X11 suggested depth (%d)", depth);
+        }
-#ifdef QT_DEBUG_X11_VISUAL_SELECTION
-        else
-            qDebug("Using X Visual ID (%d) for EGL provided depth (%d)", (int)vi.visualid, depth);
-#endif
-        // Don't try to use ARGB now unless the visual is 32-bit - even then it might stil fail :-(
-        if (useArgbVisual)
-            foundVisualIsArgb = vi.depth == 32; //### We might at some point (soon) get ARGB4444
+    }
-#ifdef QT_DEBUG_X11_VISUAL_SELECTION
-    qDebug("Visual Info:");
-    qDebug("   bits_per_rgb=%d", vi.bits_per_rgb);
-    qDebug("   red_mask=0x%x", vi.red_mask);
-    qDebug("   green_mask=0x%x", vi.green_mask);
-    qDebug("   blue_mask=0x%x", vi.blue_mask);
-    qDebug("   colormap_size=%d", vi.colormap_size);
-    qDebug("   c_class=%d", vi.c_class);
-    qDebug("   depth=%d", vi.depth);
-    qDebug("   screen=%d", vi.screen);
-    qDebug("   visualid=%d", vi.visualid);
-#endif
-    return foundVisualIsArgb;
+}
 void QGLWidget::setContext(QGLContext *context, const QGLContext* shareContext, bool deleteOldContext)
+{
 …
     QGLContext* oldcx = d->glcx;
     d->glcx = context;
-    if (parentWidget()) {
-        // force creation of delay-created widgets
-        parentWidget()->winId();
-        if (parentWidget()->x11Info().screen() != x11Info().screen())
-            d_func()->xinfo = parentWidget()->d_func()->xinfo;
+    }
-    // If the application has set WA_TranslucentBackground and not explicitly set
-    // the alpha buffer size to zero, modify the format so it have an alpha channel
-    QGLFormat& fmt = d->glcx->d_func()->glFormat;
-    const bool tryArgbVisual = testAttribute(Qt::WA_TranslucentBackground) || fmt.alpha();
-    if (tryArgbVisual && fmt.alphaBufferSize() == -1)
-        fmt.setAlphaBufferSize(1);
     bool createFailed = false;
 …
+    }
+    if (d->glcx->windowCreated() || d->glcx->deviceIsPixmap()) {
+        if (deleteOldContext)
+            delete oldcx;
+        return;
+    }
+    bool visible = isVisible();
+    if (visible)
+        hide();
+    XVisualInfo vi;
+    QEglContext *eglContext = d->glcx->d_func()->eglContext;
+    bool usingArgbVisual = qt_egl_setup_x11_visual(vi, eglContext->display(), eglContext->config(),
+                                                   x11Info(), tryArgbVisual);
+    XSetWindowAttributes a;
+    Window p = RootWindow(x11Info().display(), x11Info().screen());
+    if (parentWidget())
+        p = parentWidget()->winId();
+    QColormap colmap = QColormap::instance(vi.screen);
+    a.background_pixel = colmap.pixel(palette().color(backgroundRole()));
+    a.border_pixel = colmap.pixel(Qt::black);
+    unsigned int valueMask = CWBackPixel|CWBorderPixel;
+    if (usingArgbVisual) {
+        a.colormap = XCreateColormap(x11Info().display(), p, vi.visual, AllocNone);
+        valueMask |= CWColormap;
+    }
+    Window w = XCreateWindow(x11Info().display(), p, x(), y(), width(), height(),
+, vi.depth, InputOutput, vi.visual, valueMask, &a);
+    if (deleteOldContext)
+        delete oldcx;
+    oldcx = 0;
+    create(w); // Create with the ID of the window we've just created
+    // Create the EGL surface to draw into.
+    QGLContextPrivate *ctxpriv = d->glcx->d_func();
+    ctxpriv->eglSurface = ctxpriv->eglContext->createSurface(this);
+    if (ctxpriv->eglSurface == EGL_NO_SURFACE) {
+        delete ctxpriv->eglContext;
+        ctxpriv->eglContext = 0;
+        return;
+    }
+    d->eglSurfaceWindowId = w; // Remember the window id we created the surface for
+    if (visible)
+        show();
+    XFlush(X11->display);
+    d->glcx->setWindowCreated(true);
+    d->eglSurfaceWindowId = winId(); // Remember the window id we created the surface for
+}
 …
     initContext(context, shareWidget);
     if(q->isValid() && glcx->format().hasOverlay()) {
+    if (q->isValid() && glcx->format().hasOverlay()) {
         //no overlay
         qWarning("QtOpenGL ES doesn't currently support overlays");
 …
+}
 // Re-creates the EGL surface if the window ID has changed or if force is true
 void QGLWidgetPrivate::recreateEglSurface(bool force)
+// Re-creates the EGL surface if the window ID has changed or if there isn't a surface
+void QGLWidgetPrivate::recreateEglSurface()
+{
     Q_Q(QGLWidget);
 …
     Window currentId = q->winId();
+    if ( force || (currentId != eglSurfaceWindowId) ) {
+        // The window id has changed so we need to re-create the EGL surface
+        QEglContext *ctx = glcx->d_func()->eglContext;
+        EGLSurface surface = glcx->d_func()->eglSurface;
+        if (surface != EGL_NO_SURFACE)
+            ctx->destroySurface(surface); // Will force doneCurrent() if nec.
+        surface = ctx->createSurface(q);
+        if (surface == EGL_NO_SURFACE)
+            qWarning("Error creating EGL window surface: 0x%x", eglGetError());
+        glcx->d_func()->eglSurface = surface;
+    // If the window ID has changed since the surface was created, we need to delete the
+    // old surface before re-creating a new one. Note: This should not be the case as the
+    // surface should be deleted before the old window id.
+    if (glcx->d_func()->eglSurface != EGL_NO_SURFACE && (currentId != eglSurfaceWindowId)) {
+        qWarning("EGL surface for deleted window %x was not destroyed", uint(eglSurfaceWindowId));
+        glcx->d_func()->destroyEglSurfaceForDevice();
+    }
+    if (glcx->d_func()->eglSurface == EGL_NO_SURFACE) {
+        glcx->d_func()->eglSurface = glcx->d_func()->eglContext->createSurface(q);
         eglSurfaceWindowId = currentId;
+    }
+}
+// Selects which configs should be used
+EGLConfig Q_OPENGL_EXPORT qt_chooseEGLConfigForPixmap(bool hasAlpha, bool readOnly)
+{
+    // Cache the configs we select as they wont change:
+    static EGLConfig roPixmapRGBConfig = 0;
+    static EGLConfig roPixmapRGBAConfig = 0;
+    static EGLConfig rwPixmapRGBConfig = 0;
+    static EGLConfig rwPixmapRGBAConfig = 0;
+    EGLConfig* targetConfig;
+    if (hasAlpha) {
+        if (readOnly)
+            targetConfig = &roPixmapRGBAConfig;
+        else
+            targetConfig = &rwPixmapRGBAConfig;
+    }
+    else {
+        if (readOnly)
+            targetConfig = &roPixmapRGBConfig;
+        else
+            targetConfig = &rwPixmapRGBConfig;
+    }
+    if (*targetConfig == 0) {
+        QEglProperties configAttribs;
+        configAttribs.setValue(EGL_SURFACE_TYPE, EGL_PIXMAP_BIT);
+        configAttribs.setRenderableType(QEgl::OpenGL);
+        if (hasAlpha)
+            configAttribs.setValue(EGL_BIND_TO_TEXTURE_RGBA, EGL_TRUE);
+        else
+            configAttribs.setValue(EGL_BIND_TO_TEXTURE_RGB, EGL_TRUE);
+        // If this is going to be a render target, it needs to have a depth, stencil & sample buffer
+        if (!readOnly) {
+            configAttribs.setValue(EGL_DEPTH_SIZE, 1);
+            configAttribs.setValue(EGL_STENCIL_SIZE, 1);
+            configAttribs.setValue(EGL_SAMPLE_BUFFERS, 1);
+        }
+        EGLint configCount = 0;
+        do {
+            eglChooseConfig(QEglContext::display(), configAttribs.properties(), targetConfig, 1, &configCount);
+            if (configCount > 0) {
+                // Got one
+                qDebug() << "Found an" << (hasAlpha ? "ARGB" : "RGB") << (readOnly ? "readonly" : "target" )
+                         << "config (" << int(*targetConfig) << ") to create a pixmap surface:";
+//                QEglProperties configProps(*targetConfig);
+//                qDebug() << configProps.toString();
+                break;
+            }
+            qWarning("choosePixmapConfig() - No suitible config found, reducing requirements");
+        } while (configAttribs.reduceConfiguration());
+    }
+    if (*targetConfig == 0)
+        qWarning("choosePixmapConfig() - Couldn't find a suitable config");
+    return *targetConfig;
+}
+bool Q_OPENGL_EXPORT qt_createEGLSurfaceForPixmap(QPixmapData* pmd, bool readOnly)
+{
+    Q_ASSERT(pmd->classId() == QPixmapData::X11Class);
+    QX11PixmapData* pixmapData = static_cast<QX11PixmapData*>(pmd);
+    bool hasAlpha = pixmapData->hasAlphaChannel();
+    EGLConfig pixmapConfig = qt_chooseEGLConfigForPixmap(hasAlpha, readOnly);
+    QEglProperties pixmapAttribs;
+    // If the pixmap can't be bound to a texture, it's pretty useless
+    pixmapAttribs.setValue(EGL_TEXTURE_TARGET, EGL_TEXTURE_2D);
+    if (hasAlpha)
+        pixmapAttribs.setValue(EGL_TEXTURE_FORMAT, EGL_TEXTURE_RGBA);
+    else
+        pixmapAttribs.setValue(EGL_TEXTURE_FORMAT, EGL_TEXTURE_RGB);
+    EGLSurface pixmapSurface;
+    pixmapSurface = eglCreatePixmapSurface(QEglContext::display(),
+                                           pixmapConfig,
+                                           (EGLNativePixmapType) pixmapData->handle(),
+                                           pixmapAttribs.properties());
+//    qDebug("qt_createEGLSurfaceForPixmap() created surface 0x%x for pixmap 0x%x",
+//           pixmapSurface, pixmapData->handle());
+    if (pixmapSurface == EGL_NO_SURFACE) {
+        qWarning() << "Failed to create a pixmap surface using config" << (int)pixmapConfig
+                   << ":" << QEglContext::errorString(eglGetError());
+        return false;
+    }
+    static bool doneOnce = false;
+    if (!doneOnce) {
+        // Make sure QGLTextureCache is instanciated so it can install cleanup hooks
+        // which cleanup the EGL surface.
+        QGLTextureCache::instance();
+        doneOnce = true;
+    }
+    Q_ASSERT(sizeof(Qt::HANDLE) >= sizeof(EGLSurface)); // Just to make totally sure!
+    pixmapData->gl_surface = (Qt::HANDLE)pixmapSurface;
+    QImagePixmapCleanupHooks::enableCleanupHooks(pixmapData); // Make sure the cleanup hook gets called
+    return true;
+}
+QGLTexture *QGLContextPrivate::bindTextureFromNativePixmap(QPixmapData* pd, const qint64 key,
+QGLTexture *QGLContextPrivate::bindTextureFromNativePixmap(QPixmap *pixmap, const qint64 key,
                                                            QGLContext::BindOptions options)
+{
 …
         return 0;
-    Q_ASSERT(pd->classId() == QPixmapData::X11Class);
     static bool checkedForTFP = false;
     static bool haveTFP = false;
+    static bool checkedForEglImageTFP = false;
+    static bool haveEglImageTFP = false;
+    if (!checkedForEglImageTFP) {
+        checkedForEglImageTFP = true;
+        // We need to be able to create an EGLImage from a native pixmap, which was split
+        // into a separate EGL extension, EGL_KHR_image_pixmap. It is possible to have
+        // eglCreateImageKHR & eglDestroyImageKHR without support for pixmaps, so we must
+        // check we have the EGLImage from pixmap functionality.
+        if (QEgl::hasExtension("EGL_KHR_image") || QEgl::hasExtension("EGL_KHR_image_pixmap")) {
+            // Being able to create an EGLImage from a native pixmap is also pretty useless
+            // without the ability to bind that EGLImage as a texture, which is provided by
+            // the GL_OES_EGL_image extension, which we try to resolve here:
+            haveEglImageTFP = qt_resolve_eglimage_gl_extensions(q);
+            if (haveEglImageTFP)
+                qDebug("Found EGL_KHR_image_pixmap & GL_OES_EGL_image extensions (preferred method)!");
+        }
+    }
     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"))
+        if (QEgl::hasExtension("EGL_NOKIA_texture_from_pixmap") ||
+            QEgl::hasExtension("EGL_EXT_texture_from_pixmap"))
+        {
             qDebug("Found texture_from_pixmap EGL extension!");
 …
+    }
     if (!haveTFP)
+    if (!haveTFP && !haveEglImageTFP)
         return 0;
+    QX11PixmapData *pixmapData = static_cast<QX11PixmapData*>(pd);
+    QX11PixmapData *pixmapData = static_cast<QX11PixmapData*>(pixmap->data_ptr().data());
+    Q_ASSERT(pixmapData->classId() == QPixmapData::X11Class);
     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);
+    }
+    if (pixmapData->gl_surface == 0) {
+        bool success = qt_createEGLSurfaceForPixmap(pixmapData, true);
+        if (!success) {
+            haveTFP = false;
+            return 0;
+        }
+    }
+    Q_ASSERT(pixmapData->gl_surface);
+    bool pixmapHasValidSurface = false;
+    bool textureIsBound = false;
     GLuint textureId;
     glGenTextures(1, &textureId);
     glBindTexture(GL_TEXTURE_2D, textureId);
+    // bind the egl pixmap surface to a texture
+    EGLBoolean success;
+    success = eglBindTexImage(eglContext->display(), (EGLSurface)pixmapData->gl_surface, EGL_BACK_BUFFER);
+    if (success == EGL_FALSE) {
+        qWarning() << "eglBindTexImage() failed:" << eglContext->errorString(eglGetError());
+        eglDestroySurface(eglContext->display(), (EGLSurface)pixmapData->gl_surface);
+        pixmapData->gl_surface = (Qt::HANDLE)EGL_NO_SURFACE;
+        haveTFP = false;
+        return 0;
+    }
+    QGLTexture *texture = new QGLTexture(q, textureId, GL_TEXTURE_2D, options);
+    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);
+    if (haveTFP && pixmapData->gl_surface &&
+        hasAlpha == (pixmapData->flags & QX11PixmapData::GlSurfaceCreatedWithAlpha))
+    {
+        pixmapHasValidSurface = true;
+    }
+    // If we already have a valid EGL surface for the pixmap, we should use it
+    if (pixmapHasValidSurface) {
+        EGLBoolean success;
+        success = eglBindTexImage(QEgl::display(), (EGLSurface)pixmapData->gl_surface, EGL_BACK_BUFFER);
+        if (success == EGL_FALSE) {
+            qWarning() << "eglBindTexImage() failed:" << QEgl::errorString();
+            eglDestroySurface(QEgl::display(), (EGLSurface)pixmapData->gl_surface);
+            pixmapData->gl_surface = (void*)EGL_NO_SURFACE;
+        } else
+            textureIsBound = true;
+    }
+    // If the pixmap doesn't already have a valid surface, try binding it via EGLImage
+    // first, as going through EGLImage should be faster and better supported:
+    if (!textureIsBound && haveEglImageTFP) {
+        EGLImageKHR eglImage;
+        EGLint attribs[] = {
+            EGL_IMAGE_PRESERVED_KHR, EGL_TRUE,
+            EGL_NONE
+        };
+        eglImage = QEgl::eglCreateImageKHR(QEgl::display(), EGL_NO_CONTEXT, EGL_NATIVE_PIXMAP_KHR,
+                                     (EGLClientBuffer)QEgl::nativePixmap(pixmap), attribs);
+        QGLContext* ctx = q;
+        glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, eglImage);
+        GLint err = glGetError();
+        if (err == GL_NO_ERROR)
+            textureIsBound = true;
+        // Once the egl image is bound, the texture becomes a new sibling image and we can safely
+        // destroy the EGLImage we created for the pixmap:
+        if (eglImage != EGL_NO_IMAGE_KHR)
+            QEgl::eglDestroyImageKHR(QEgl::display(), eglImage);
+    }
+    if (!textureIsBound && haveTFP) {
+        // Check to see if the surface is still valid
+        if (pixmapData->gl_surface &&
+            hasAlpha != (pixmapData->flags & QX11PixmapData::GlSurfaceCreatedWithAlpha))
+        {
+            // Surface is invalid!
+            destroyGlSurfaceForPixmap(pixmapData);
+        }
+        if (pixmapData->gl_surface == 0) {
+            EGLConfig config = QEgl::defaultConfig(QInternal::Pixmap,
+                                                   QEgl::OpenGL,
+                                                   hasAlpha ? QEgl::Translucent : QEgl::NoOptions);
+            pixmapData->gl_surface = (void*)QEgl::createSurface(pixmap, config);
+            if (pixmapData->gl_surface == (void*)EGL_NO_SURFACE)
+                return false;
+        }
+        EGLBoolean success;
+        success = eglBindTexImage(QEgl::display(), (EGLSurface)pixmapData->gl_surface, EGL_BACK_BUFFER);
+        if (success == EGL_FALSE) {
+            qWarning() << "eglBindTexImage() failed:" << QEgl::errorString();
+            eglDestroySurface(QEgl::display(), (EGLSurface)pixmapData->gl_surface);
+            pixmapData->gl_surface = (void*)EGL_NO_SURFACE;
+            haveTFP = false; // If TFP isn't working, disable it's use
+        } else
+            textureIsBound = true;
+    }
+    QGLTexture *texture = 0;
+    if (textureIsBound) {
+        texture = new QGLTexture(q, textureId, GL_TEXTURE_2D, options);
+        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);
+    } else
+        glDeleteTextures(1, &textureId);
     return texture;
+}
 void QGLContextPrivate::destroyGlSurfaceForPixmap(QPixmapData* pmd)
 …
     if (pixmapData->gl_surface) {
         EGLBoolean success;
         success = eglDestroySurface(QEglContext::display(), (EGLSurface)pixmapData->gl_surface);
+        success = eglDestroySurface(QEgl::display(), (EGLSurface)pixmapData->gl_surface);
         if (success == EGL_FALSE) {
             qWarning() << "destroyGlSurfaceForPixmap() - Error deleting surface: "
                        << QEglContext::errorString(eglGetError());
+                       << QEgl::errorString();
+        }
         pixmapData->gl_surface = 0;
 …
     if (pixmapData->gl_surface) {
         EGLBoolean success;
         success = eglReleaseTexImage(QEglContext::display(),
+        success = eglReleaseTexImage(QEgl::display(),
                                      (EGLSurface)pixmapData->gl_surface,
                                      EGL_BACK_BUFFER);
         if (success == EGL_FALSE) {
             qWarning() << "unbindPixmapFromTexture() - Unable to release bound texture: "
                        << QEglContext::errorString(eglGetError());
+                       << QEgl::errorString();
+        }
+    }

trunk/src/opengl/qglcolormap.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/qglcolormap.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/qglextensions.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 bool qt_resolve_buffer_extensions(QGLContext *ctx)
+{
+    if (glMapBufferARB && glUnmapBufferARB
+#if !defined(QT_OPENGL_ES_2)
+        && glBindBuffer && glDeleteBuffers && glGenBuffers && glBufferData
+#endif
+        )
+        return true;
+#if !defined(QT_OPENGL_ES_2)
+#if defined(QGL_RESOLVE_BUFFER_FUNCS)
+    if (glBindBuffer && glDeleteBuffers && glGenBuffers && glBufferData
+            && glBufferSubData && glGetBufferParameteriv)
+        return true;
+#endif
+#if defined(QGL_RESOLVE_BUFFER_FUNCS)
     glBindBuffer = (_glBindBuffer) qt_gl_getProcAddressARB(ctx, "glBindBuffer");
     glDeleteBuffers = (_glDeleteBuffers) qt_gl_getProcAddressARB(ctx, "glDeleteBuffers");
     glGenBuffers = (_glGenBuffers) qt_gl_getProcAddressARB(ctx, "glGenBuffers");
     glBufferData = (_glBufferData) qt_gl_getProcAddressARB(ctx, "glBufferData");
+    glBufferSubData = (_glBufferSubData) qt_gl_getProcAddressARB(ctx, "glBufferSubData");
+    glGetBufferSubData = (_glGetBufferSubData) qt_gl_getProcAddressARB(ctx, "glGetBufferSubData");
+    glGetBufferParameteriv = (_glGetBufferParameteriv) qt_gl_getProcAddressARB(ctx, "glGetBufferParameteriv");
 #endif
     glMapBufferARB = (_glMapBufferARB) qt_gl_getProcAddressARB(ctx, "glMapBuffer");
     glUnmapBufferARB = (_glUnmapBufferARB) qt_gl_getProcAddressARB(ctx, "glUnmapBuffer");
+    return glMapBufferARB
+        && glUnmapBufferARB
+#if !defined(QT_OPENGL_ES_2)
+        && glBindBuffer
+#if defined(QGL_RESOLVE_BUFFER_FUNCS)
+    return glBindBuffer
         && glDeleteBuffers
         && glGenBuffers
         && glBufferData
+#endif
+        ;
+}
+        && glBufferSubData
+        && glGetBufferParameteriv;
+        // glGetBufferSubData() is optional
+#else
+    return true;
+#endif
+}
+#ifndef QT_NO_EGL
+bool qt_resolve_eglimage_gl_extensions(QGLContext *ctx)
+{
+    if (glEGLImageTargetTexture2DOES || glEGLImageTargetRenderbufferStorageOES)
+        return true;
+    glEGLImageTargetTexture2DOES = (_glEGLImageTargetTexture2DOES) ctx->getProcAddress(QLatin1String("glEGLImageTargetTexture2DOES"));
+    glEGLImageTargetRenderbufferStorageOES = (_glEGLImageTargetRenderbufferStorageOES) ctx->getProcAddress(QLatin1String("glEGLImageTargetRenderbufferStorageOES"));
+    return glEGLImageTargetTexture2DOES && glEGLImageTargetRenderbufferStorageOES;
+}
+#endif
 bool qt_resolve_glsl_extensions(QGLContext *ctx)
+{
 #if defined(QT_OPENGL_ES_2)
     // The GLSL shader functions are always present in OpenGL/ES 2.0.
 …
     if (glCreateShader)
         return true;
+    // Geometry shaders are optional...
+    glProgramParameteriEXT = (_glProgramParameteriEXT) ctx->getProcAddress(QLatin1String("glProgramParameteriEXT"));
+    glFramebufferTextureEXT = (_glFramebufferTextureEXT) ctx->getProcAddress(QLatin1String("glFramebufferTextureEXT"));
+    glFramebufferTextureLayerEXT = (_glFramebufferTextureLayerEXT) ctx->getProcAddress(QLatin1String("glFramebufferTextureLayerEXT"));
+    glFramebufferTextureFaceEXT = (_glFramebufferTextureFaceEXT) ctx->getProcAddress(QLatin1String("glFramebufferTextureFaceEXT"));
+    // Must at least have the FragmentShader extension to continue.
+    if (!(QGLExtensions::glExtensions() & QGLExtensions::FragmentShader))
+        return false;
     glCreateShader = (_glCreateShader) ctx->getProcAddress(QLatin1String("glCreateShader"));

trunk/src/opengl/qglextensions_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #endif
+#ifndef QT_NO_EGL
+// Needed for EGLImageKHR definition:
+#include <QtGui/private/qegl_p.h>
+#endif
 #include <QtCore/qglobal.h>
 #ifndef GL_ARB_vertex_buffer_object
+typedef ptrdiff_t GLintptrARB;
 typedef ptrdiff_t GLsizeiptrARB;
 #endif
 …
 #endif
 // ARB_pixel_buffer_object
+// ARB_vertex_buffer_object
 typedef void (APIENTRY *_glBindBuffer) (GLenum, GLuint);
 typedef void (APIENTRY *_glDeleteBuffers) (GLsizei, const GLuint *);
 typedef void (APIENTRY *_glGenBuffers) (GLsizei, GLuint *);
 typedef void (APIENTRY *_glBufferData) (GLenum, GLsizeiptrARB, const GLvoid *, GLenum);
+typedef void (APIENTRY *_glBufferSubData) (GLenum, GLintptrARB, GLsizeiptrARB, const GLvoid *);
+typedef void (APIENTRY *_glGetBufferSubData) (GLenum, GLintptrARB, GLsizeiptrARB, GLvoid *);
+typedef void (APIENTRY *_glGetBufferParameteriv) (GLenum, GLenum, GLint *);
 typedef GLvoid* (APIENTRY *_glMapBufferARB) (GLenum, GLenum);
 typedef GLboolean (APIENTRY *_glUnmapBufferARB) (GLenum);
+// We can call the buffer functions directly in OpenGL/ES 1.1 or higher,
+// but all other platforms need to resolve the extensions.
+#if defined(QT_OPENGL_ES)
+#if defined(GL_OES_VERSION_1_0) && !defined(GL_OES_VERSION_1_1)
+#define QGL_RESOLVE_BUFFER_FUNCS 1
+#endif
+#else
+#define QGL_RESOLVE_BUFFER_FUNCS 1
+#endif
 // ARB_fragment_program
 …
                                                                GLenum internalformat, GLsizei width, GLsizei height);
+// GL_EXT_geometry_shader4
+typedef void (APIENTRY *_glProgramParameteriEXT)(GLuint program, GLenum pname, GLint value);
+typedef void (APIENTRY *_glFramebufferTextureEXT)(GLenum target, GLenum attachment,
+                                                  GLuint texture, GLint level);
+typedef void (APIENTRY *_glFramebufferTextureLayerEXT)(GLenum target, GLenum attachment,
+                                                       GLuint texture, GLint level, GLint layer);
+typedef void (APIENTRY *_glFramebufferTextureFaceEXT)(GLenum target, GLenum attachment,
+                                                      GLuint texture, GLint level, GLenum face);
 // ARB_texture_compression
 typedef void (APIENTRY *_glCompressedTexImage2DARB) (GLenum, GLint, GLenum, GLsizei,
                                                      GLsizei, GLint, GLsizei, const GLvoid *);
+#ifndef QT_NO_EGL
+// OES_EGL_image
+// Note: We define these to take EGLImage whereas spec says they take a new GLeglImageOES
+//       type, which the EGL image should be cast to.
+typedef void (APIENTRY *_glEGLImageTargetTexture2DOES) (GLenum, EGLImageKHR);
+typedef void (APIENTRY *_glEGLImageTargetRenderbufferStorageOES) (GLenum, EGLImageKHR);
+#endif
 QT_BEGIN_NAMESPACE
 …
         // Buffer objects:
 #if !defined(QT_OPENGL_ES_2)
+#if defined(QGL_RESOLVE_BUFFER_FUNCS)
         qt_glBindBuffer = 0;
         qt_glDeleteBuffers = 0;
         qt_glGenBuffers = 0;
         qt_glBufferData = 0;
+        qt_glBufferSubData = 0;
+        qt_glGetBufferSubData = 0;
+        qt_glGetBufferParameteriv = 0;
 #endif
         qt_glMapBufferARB = 0;
         qt_glUnmapBufferARB = 0;
+        qt_glProgramParameteriEXT = 0;
+        qt_glFramebufferTextureEXT = 0;
+        qt_glFramebufferTextureLayerEXT = 0;
+        qt_glFramebufferTextureFaceEXT = 0;
 #if !defined(QT_OPENGL_ES)
         // Texture compression
         qt_glCompressedTexImage2DARB = 0;
+#endif
+#ifndef QT_NO_EGL
+        // OES_EGL_image
+        qt_glEGLImageTargetTexture2DOES = 0;
+        qt_glEGLImageTargetRenderbufferStorageOES = 0;
 #endif
+    }
 …
     // Buffer objects
 #if !defined(QT_OPENGL_ES_2)
+#if defined(QGL_RESOLVE_BUFFER_FUNCS)
     _glBindBuffer qt_glBindBuffer;
     _glDeleteBuffers qt_glDeleteBuffers;
     _glGenBuffers qt_glGenBuffers;
     _glBufferData qt_glBufferData;
+    _glBufferSubData qt_glBufferSubData;
+    _glGetBufferSubData qt_glGetBufferSubData;
+    _glGetBufferParameteriv qt_glGetBufferParameteriv;
 #endif
     _glMapBufferARB qt_glMapBufferARB;
     _glUnmapBufferARB qt_glUnmapBufferARB;
+    // Geometry shaders...
+    _glProgramParameteriEXT qt_glProgramParameteriEXT;
+    _glFramebufferTextureEXT qt_glFramebufferTextureEXT;
+    _glFramebufferTextureLayerEXT qt_glFramebufferTextureLayerEXT;
+    _glFramebufferTextureFaceEXT qt_glFramebufferTextureFaceEXT;
 #if !defined(QT_OPENGL_ES)
     // Texture compression
     _glCompressedTexImage2DARB qt_glCompressedTexImage2DARB;
 #endif
+#ifndef QT_NO_EGL
+    // OES_EGL_image
+    _glEGLImageTargetTexture2DOES qt_glEGLImageTargetTexture2DOES;
+    _glEGLImageTargetRenderbufferStorageOES qt_glEGLImageTargetRenderbufferStorageOES;
+#endif
 };
 // OpenGL constants
+#ifndef GL_ARRAY_BUFFER
+#define GL_ARRAY_BUFFER                   0x8892
+#endif
+#ifndef GL_STATIC_DRAW
+#define GL_STATIC_DRAW                    0x88E4
+#endif
 /* NV_texture_rectangle */
 …
 #ifndef GL_RGB16
 #define GL_RGB16 32852
+#define GL_RGB16 0x8054
 #endif
 #ifndef GL_UNSIGNED_SHORT_5_6_5
 #define GL_UNSIGNED_SHORT_5_6_5 33635
+#define GL_UNSIGNED_SHORT_5_6_5 0x8363
 #endif
 …
 #ifndef GL_TEXTURE1
 #define GL_TEXTURE1 0x84C1
+#endif
+#ifndef GL_DEPTH_COMPONENT16
+#define GL_DEPTH_COMPONENT16 0x81A5
+#endif
+#ifndef GL_DEPTH_COMPONENT24_OES
+#define GL_DEPTH_COMPONENT24_OES 0x81A6
 #endif
 …
 #endif
+#ifndef GL_VERSION_1_5
+#define GL_ARRAY_BUFFER                                         0x8892
+#define GL_ELEMENT_ARRAY_BUFFER                                 0x8893
+#define GL_STREAM_DRAW                                          0x88E0
+#define GL_STREAM_READ                                          0x88E1
+#define GL_STREAM_COPY                                          0x88E2
+#define GL_STATIC_DRAW                                          0x88E4
+#define GL_STATIC_READ                                          0x88E5
+#define GL_STATIC_COPY                                          0x88E6
+#define GL_DYNAMIC_DRAW                                         0x88E8
+#define GL_DYNAMIC_READ                                         0x88E9
+#define GL_DYNAMIC_COPY                                         0x88EA
+#endif
 #ifndef GL_VERSION_2_0
 #define GL_FRAGMENT_SHADER 0x8B30
 …
 #endif
+// Geometry shader defines
+#ifndef GL_GEOMETRY_SHADER_EXT
+#  define GL_GEOMETRY_SHADER_EXT 0x8DD9
+#  define GL_GEOMETRY_VERTICES_OUT_EXT 0x8DDA
+#  define GL_GEOMETRY_INPUT_TYPE_EXT 0x8DDB
+#  define GL_GEOMETRY_OUTPUT_TYPE_EXT 0x8DDC
+#  define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT 0x8C29
+#  define GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT 0x8DDD
+#  define GL_MAX_VERTEX_VARYING_COMPONENTS_EXT 0x8DDE
+#  define GL_MAX_VARYING_COMPONENTS_EXT 0x8B4B
+#  define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT 0x8DDF
+#  define GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT 0x8DE0
+#  define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT 0x8DE1
+#  define GL_LINES_ADJACENCY_EXT 0xA
+#  define GL_LINE_STRIP_ADJACENCY_EXT 0xB
+#  define GL_TRIANGLES_ADJACENCY_EXT 0xC
+#  define GL_TRIANGLE_STRIP_ADJACENCY_EXT 0xD
+#  define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT 0x8DA8
+#  define GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT 0x8DA9
+#  define GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT 0x8DA7
+#  define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT 0x8CD4
+#  define GL_PROGRAM_POINT_SIZE_EXT 0x8642
+#endif
 #if !defined(QT_OPENGL_ES_2)
 …
 // Buffer objects
 #if !defined(QT_OPENGL_ES_2)
+#if defined(QGL_RESOLVE_BUFFER_FUNCS)
 #define glBindBuffer QGLContextPrivate::extensionFuncs(ctx).qt_glBindBuffer
 #define glDeleteBuffers QGLContextPrivate::extensionFuncs(ctx).qt_glDeleteBuffers
 #define glGenBuffers QGLContextPrivate::extensionFuncs(ctx).qt_glGenBuffers
 #define glBufferData QGLContextPrivate::extensionFuncs(ctx).qt_glBufferData
+#define glBufferSubData QGLContextPrivate::extensionFuncs(ctx).qt_glBufferSubData
+#define glGetBufferSubData QGLContextPrivate::extensionFuncs(ctx).qt_glGetBufferSubData
+#define glGetBufferParameteriv QGLContextPrivate::extensionFuncs(ctx).qt_glGetBufferParameteriv
 #endif
 #define glMapBufferARB QGLContextPrivate::extensionFuncs(ctx).qt_glMapBufferARB
 …
 #endif
+#define glProgramParameteriEXT QGLContextPrivate::extensionFuncs(ctx).qt_glProgramParameteriEXT
+#define glFramebufferTextureEXT QGLContextPrivate::extensionFuncs(ctx).qt_glFramebufferTextureEXT
+#define glFramebufferTextureLayerEXT QGLContextPrivate::extensionFuncs(ctx).qt_glFramebufferTextureLayerEXT
+#define glFramebufferTextureFaceEXT QGLContextPrivate::extensionFuncs(ctx).qt_glFramebufferTextureFaceEXT
 #if !defined(QT_OPENGL_ES)
 #define glCompressedTexImage2D QGLContextPrivate::extensionFuncs(ctx).qt_glCompressedTexImage2DARB
+#endif
+#ifndef QT_NO_EGL
+// OES_EGL_image
+#define glEGLImageTargetTexture2DOES QGLContextPrivate::extensionFuncs(ctx).qt_glEGLImageTargetTexture2DOES
+#define glEGLImageTargetRenderbufferStorageOES QGLContextPrivate::extensionFuncs(ctx).qt_glEGLImageTargetRenderbufferStorageOES
 #endif
 …
 bool qt_resolve_glsl_extensions(QGLContext *ctx);
+#ifndef QT_NO_EGL
+Q_OPENGL_EXPORT bool qt_resolve_eglimage_gl_extensions(QGLContext *ctx);
+#endif
 QT_END_NAMESPACE

trunk/src/opengl/qglframebufferobject.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #include <qdebug.h>
 #include <private/qgl_p.h>
 #if !defined(QT_OPENGL_ES_1) && !defined(QT_OPENGL_ES_1_CL)
+#if !defined(QT_OPENGL_ES_1)
 #include <private/qpaintengineex_opengl2_p.h>
 #endif
 …
 #include <qlibrary.h>
 #include <qimage.h>
-#ifdef QT_OPENGL_ES_1_CL
-#include "qgl_cl_p.h"
-#endif
 QT_BEGIN_NAMESPACE
 …
     On OpenGL/ES systems, the default internal format is \c GL_RGBA.
     \sa samples(), attachment(), target(), internalTextureFormat()
+    \sa samples(), attachment(), internalTextureFormat()
 */
 …
         glGetIntegerv(GL_MAX_SAMPLES_EXT, &maxSamples);
         samples = qBound(1, int(samples), int(maxSamples));
+        samples = qBound(0, int(samples), int(maxSamples));
         glGenRenderbuffers(1, &color_buffer);
         glBindRenderbuffer(GL_RENDERBUFFER_EXT, color_buffer);
         if (glRenderbufferStorageMultisampleEXT) {
+        if (glRenderbufferStorageMultisampleEXT && samples > 0) {
             glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, samples,
                 internal_format, size.width(), size.height());
 …
+    }
+    // In practice, a combined depth-stencil buffer is supported by all desktop platforms, while a
+    // separate stencil buffer is not. On embedded devices however, a combined depth-stencil buffer
+    // might not be supported while separate buffers are, according to QTBUG-12861.
     if (attachment == QGLFramebufferObject::CombinedDepthStencil
         && (QGLExtensions::glExtensions() & QGLExtensions::PackedDepthStencil)) {
         // depth and stencil buffer needs another extension
         glGenRenderbuffers(1, &depth_stencil_buffer);
         Q_ASSERT(!glIsRenderbuffer(depth_stencil_buffer));
         glBindRenderbuffer(GL_RENDERBUFFER_EXT, depth_stencil_buffer);
         Q_ASSERT(glIsRenderbuffer(depth_stencil_buffer));
+        glGenRenderbuffers(1, &depth_buffer);
+        Q_ASSERT(!glIsRenderbuffer(depth_buffer));
+        glBindRenderbuffer(GL_RENDERBUFFER_EXT, depth_buffer);
+        Q_ASSERT(glIsRenderbuffer(depth_buffer));
         if (samples != 0 && glRenderbufferStorageMultisampleEXT)
             glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, samples,
 …
                 GL_DEPTH24_STENCIL8_EXT, size.width(), size.height());
+        GLint i = 0;
+        glGetRenderbufferParameteriv(GL_RENDERBUFFER_EXT, GL_RENDERBUFFER_DEPTH_SIZE_EXT, &i);
+        stencil_buffer = depth_buffer;
         glFramebufferRenderbuffer(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT,
                                      GL_RENDERBUFFER_EXT, depth_stencil_buffer);
+                                     GL_RENDERBUFFER_EXT, depth_buffer);
         glFramebufferRenderbuffer(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT,
+                                     GL_RENDERBUFFER_EXT, depth_stencil_buffer);
+        fbo_attachment = QGLFramebufferObject::CombinedDepthStencil;
+                                     GL_RENDERBUFFER_EXT, stencil_buffer);
         valid = checkFramebufferStatus();
+        if (!valid)
+            glDeleteRenderbuffers(1, &depth_stencil_buffer);
+    } else if (attachment == QGLFramebufferObject::Depth
+               || attachment == QGLFramebufferObject::CombinedDepthStencil)
+        if (!valid) {
+            glDeleteRenderbuffers(1, &depth_buffer);
+            stencil_buffer = depth_buffer = 0;
+        }
+    }
+    if (depth_buffer == 0 && (attachment == QGLFramebufferObject::CombinedDepthStencil
+        || (attachment == QGLFramebufferObject::Depth)))
+    {
         glGenRenderbuffers(1, &depth_stencil_buffer);
         Q_ASSERT(!glIsRenderbuffer(depth_stencil_buffer));
         glBindRenderbuffer(GL_RENDERBUFFER_EXT, depth_stencil_buffer);
         Q_ASSERT(glIsRenderbuffer(depth_stencil_buffer));
+        glGenRenderbuffers(1, &depth_buffer);
+        Q_ASSERT(!glIsRenderbuffer(depth_buffer));
+        glBindRenderbuffer(GL_RENDERBUFFER_EXT, depth_buffer);
+        Q_ASSERT(glIsRenderbuffer(depth_buffer));
         if (samples != 0 && glRenderbufferStorageMultisampleEXT) {
 #ifdef QT_OPENGL_ES
+#define GL_DEPTH_COMPONENT16 0x81A5
+            glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, samples,
+                GL_DEPTH_COMPONENT16, size.width(), size.height());
+            if (QGLExtensions::glExtensions() & QGLExtensions::Depth24) {
+                glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, samples,
+                    GL_DEPTH_COMPONENT24_OES, size.width(), size.height());
+            } else {
+                glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, samples,
+                    GL_DEPTH_COMPONENT16, size.width(), size.height());
+            }
 #else
             glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, samples,
 …
         } else {
 #ifdef QT_OPENGL_ES
+#define GL_DEPTH_COMPONENT16 0x81A5
+            glRenderbufferStorage(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT16, size.width(), size.height());
+            if (QGLExtensions::glExtensions() & QGLExtensions::Depth24) {
+                glRenderbufferStorage(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24_OES,
+                                        size.width(), size.height());
+            } else {
+                glRenderbufferStorage(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT16,
+                                        size.width(), size.height());
+            }
 #else
             glRenderbufferStorage(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, size.width(), size.height());
 #endif
+        }
-        GLint i = 0;
-        glGetRenderbufferParameteriv(GL_RENDERBUFFER_EXT, GL_RENDERBUFFER_DEPTH_SIZE_EXT, &i);
         glFramebufferRenderbuffer(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT,
+                                     GL_RENDERBUFFER_EXT, depth_stencil_buffer);
+                                     GL_RENDERBUFFER_EXT, depth_buffer);
+        valid = checkFramebufferStatus();
+        if (!valid) {
+            glDeleteRenderbuffers(1, &depth_buffer);
+            depth_buffer = 0;
+        }
+    }
+    if (stencil_buffer == 0 && (attachment == QGLFramebufferObject::CombinedDepthStencil)) {
+        glGenRenderbuffers(1, &stencil_buffer);
+        Q_ASSERT(!glIsRenderbuffer(stencil_buffer));
+        glBindRenderbuffer(GL_RENDERBUFFER_EXT, stencil_buffer);
+        Q_ASSERT(glIsRenderbuffer(stencil_buffer));
+        if (samples != 0 && glRenderbufferStorageMultisampleEXT) {
+#ifdef QT_OPENGL_ES
+            glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, samples,
+                GL_STENCIL_INDEX8_EXT, size.width(), size.height());
+#else
+            glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, samples,
+                GL_STENCIL_INDEX, size.width(), size.height());
+#endif
+        } else {
+#ifdef QT_OPENGL_ES
+            glRenderbufferStorage(GL_RENDERBUFFER_EXT, GL_STENCIL_INDEX8_EXT,
+                                  size.width(), size.height());
+#else
+            glRenderbufferStorage(GL_RENDERBUFFER_EXT, GL_STENCIL_INDEX,
+                                  size.width(), size.height());
+#endif
+        }
+        glFramebufferRenderbuffer(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT,
+                                  GL_RENDERBUFFER_EXT, stencil_buffer);
+        valid = checkFramebufferStatus();
+        if (!valid) {
+            glDeleteRenderbuffers(1, &stencil_buffer);
+            stencil_buffer = 0;
+        }
+    }
+    // The FBO might have become valid after removing the depth or stencil buffer.
+    valid = checkFramebufferStatus();
+    if (depth_buffer && stencil_buffer) {
+        fbo_attachment = QGLFramebufferObject::CombinedDepthStencil;
+    } else if (depth_buffer) {
         fbo_attachment = QGLFramebufferObject::Depth;
-        valid = checkFramebufferStatus();
-        if (!valid)
-            glDeleteRenderbuffers(1, &depth_stencil_buffer);
     } else {
         fbo_attachment = QGLFramebufferObject::NoAttachment;
 …
         else
             glDeleteTextures(1, &texture);
+        if (depth_buffer)
+            glDeleteRenderbuffers(1, &depth_buffer);
+        if (stencil_buffer && depth_buffer != stencil_buffer)
+            glDeleteRenderbuffers(1, &stencil_buffer);
         glDeleteFramebuffers(1, &fbo);
         fbo_guard.setId(0);
 …
         if (d->color_buffer)
             glDeleteRenderbuffers(1, &d->color_buffer);
+        if (d->depth_stencil_buffer)
+            glDeleteRenderbuffers(1, &d->depth_stencil_buffer);
+        if (d->depth_buffer)
+            glDeleteRenderbuffers(1, &d->depth_buffer);
+        if (d->stencil_buffer && d->stencil_buffer != d->depth_buffer)
+            glDeleteRenderbuffers(1, &d->stencil_buffer);
         GLuint fbo = d->fbo();
         glDeleteFramebuffers(1, &fbo);
 …
+}
 #if !defined(QT_OPENGL_ES_1) && !defined(QT_OPENGL_ES_1_CL)
+#if !defined(QT_OPENGL_ES_1)
 Q_GLOBAL_STATIC(QGL2PaintEngineEx, qt_buffer_2_engine)
 #endif
 …
         return d->engine;
 #if !defined(QT_OPENGL_ES_1) && !defined(QT_OPENGL_ES_1_CL)
+#if !defined(QT_OPENGL_ES_1)
 #if !defined (QT_OPENGL_ES_2)
     if (qt_gl_preferGL2Engine()) {
 …
 /*!
+    \fn bool QGLFramebufferObject::bindDefault()
+    \internal
+    Switches rendering back to the default, windowing system provided
+    framebuffer.
+    Returns true upon success, false otherwise.
+    \sa bind(), release()
+*/
+bool QGLFramebufferObject::bindDefault()
+{
+    QGLContext *ctx = const_cast<QGLContext *>(QGLContext::currentContext());
+    if (ctx) {
+        bool ext_detected = (QGLExtensions::glExtensions() & QGLExtensions::FramebufferObject);
+        if (!ext_detected || (ext_detected && !qt_resolve_framebufferobject_extensions(ctx)))
+            return false;
+        ctx->d_ptr->current_fbo = ctx->d_ptr->default_fbo;
+        glBindFramebuffer(GL_FRAMEBUFFER_EXT, ctx->d_ptr->default_fbo);
+#ifdef QT_DEBUG
+    } else {
+        qWarning("QGLFramebufferObject::bindDefault() called without current context.");
+#endif
+    }
+    return ctx != 0;
+}
+/*!
     \fn bool QGLFramebufferObject::hasOpenGLFramebufferObjects()
 …
 #endif
 extern int qt_defaultDpiX();
 extern int qt_defaultDpiY();
+Q_DECL_IMPORT extern int qt_defaultDpiX();
+Q_DECL_IMPORT extern int qt_defaultDpiY();
 /*! \reimp */

trunk/src/opengl/qglframebufferobject.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     GLuint handle() const;
+    static bool bindDefault();
     static bool hasOpenGLFramebufferObjects();

trunk/src/opengl/qglframebufferobject_p.h

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
+{
 public:
     QGLFramebufferObjectPrivate() : fbo_guard(0), texture(0), depth_stencil_buffer(0)
+    QGLFramebufferObjectPrivate() : fbo_guard(0), texture(0), depth_buffer(0), stencil_buffer(0)
                                   , color_buffer(0), valid(false), engine(0) {}
     ~QGLFramebufferObjectPrivate() {}
 …
     QGLSharedResourceGuard fbo_guard;
     GLuint texture;
+    GLuint depth_stencil_buffer;
+    GLuint depth_buffer;
+    GLuint stencil_buffer;
     GLuint color_buffer;
     GLenum target;

trunk/src/opengl/qglpaintdevice.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #endif
 #if !defined(QT_OPENGL_ES_1) && !defined(QT_OPENGL_ES_1_CL)
+#if !defined(QT_OPENGL_ES_1)
 #include <private/qpixmapdata_gl_p.h>
-#endif
-#if defined(QT_OPENGL_ES_1_CL)
-#include "qgl_cl_p.h"
 #endif
 …
+}
+int QGLPaintDevice::metric(QPaintDevice::PaintDeviceMetric metric) const
+{
+    switch(metric) {
+    case PdmWidth:
+        return size().width();
+    case PdmHeight:
+        return size().height();
+    case PdmDepth: {
+        const QGLFormat f = format();
+        return f.redBufferSize() + f.greenBufferSize() + f.blueBufferSize() + f.alphaBufferSize();
+    }
+    default:
+        qWarning("QGLPaintDevice::metric() - metric %d not known", metric);
+        return 0;
+    }
+}
 void QGLPaintDevice::beginPaint()
 …
             glClearColor(c.redF() * alpha, c.greenF() * alpha, c.blueF() * alpha, alpha);
+        }
+        glClear(GL_COLOR_BUFFER_BIT);
+        if (context()->d_func()->workaround_needsFullClearOnEveryFrame)
+            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+        else
+            glClear(GL_COLOR_BUFFER_BIT);
+    }
+}
 …
             break;
         case QInternal::Pixmap: {
 #if !defined(QT_OPENGL_ES_1) && !defined(QT_OPENGL_ES_1_CL)
+#if !defined(QT_OPENGL_ES_1)
             QPixmapData* pmd = static_cast<QPixmap*>(pd)->pixmapData();
             if (pmd->classId() == QPixmapData::OpenGLClass)

trunk/src/opengl/qglpaintdevice_p.h

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 protected:
+    int metric(QPaintDevice::PaintDeviceMetric metric) const;
     GLuint m_previousFBO;
     GLuint m_thisFBO;

trunk/src/opengl/qglpixelbuffer.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
        additional copy operations. This is supported only on Windows
        and Mac OS X systems that provide the \c render_texture
+       extension.
+       extension. Note that under Windows, a multi-sampled pbuffer
+       can't be used in conjunction with the \c render_texture
+       extension. If a multi-sampled pbuffer is requested under
+       Windows, the \c render_texture extension is turned off for that
+       pbuffer.
     \endlist
 …
 #include <QtCore/qglobal.h>
 #if !defined(QT_OPENGL_ES_1) && !defined(QT_OPENGL_ES_1_CL)
+#if !defined(QT_OPENGL_ES_1)
 #include <private/qpaintengineex_opengl2_p.h>
 #endif
 …
         qctx->d_func()->dc = dc;
         qctx->d_func()->rc = ctx;
 #elif (defined(Q_WS_X11) && !defined(QT_OPENGL_ES))
+#elif (defined(Q_WS_X11) && defined(QT_NO_EGL))
         qctx->d_func()->cx = ctx;
         qctx->d_func()->pbuf = (void *) pbuf;
 …
         qctx->d_func()->cx = ctx;
         qctx->d_func()->vi = 0;
 #elif defined(QT_OPENGL_ES)
+#elif !defined(QT_NO_EGL)
         qctx->d_func()->eglContext = ctx;
         qctx->d_func()->eglSurface = pbuf;
 …
 */
 #if (defined(Q_WS_X11) || defined(Q_WS_WIN)) && !defined(QT_OPENGL_ES)
+#if (defined(Q_WS_X11) || defined(Q_WS_WIN)) && defined(QT_NO_EGL)
 GLuint QGLPixelBuffer::generateDynamicTexture() const
+{
 …
+}
 #if !defined(QT_OPENGL_ES_1) && !defined(QT_OPENGL_ES_1_CL)
+#if !defined(QT_OPENGL_ES_1)
 Q_GLOBAL_STATIC(QGL2PaintEngineEx, qt_buffer_2_engine)
 #endif
 …
 QPaintEngine *QGLPixelBuffer::paintEngine() const
+{
 #if defined(QT_OPENGL_ES_1) || defined(QT_OPENGL_ES_1_CL)
+#if defined(QT_OPENGL_ES_1)
     return qt_buffer_engine();
 #elif defined(QT_OPENGL_ES_2)
 …
+}
 extern int qt_defaultDpiX();
 extern int qt_defaultDpiY();
+Q_DECL_IMPORT extern int qt_defaultDpiX();
+Q_DECL_IMPORT extern int qt_defaultDpiY();
 /*! \reimp */

trunk/src/opengl/qglpixelbuffer.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     friend class QGLPaintDevice;
     friend class QGLPBufferGLPaintDevice;
+    friend class QGLContextPrivate;
 };

trunk/src/opengl/qglpixelbuffer_egl.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #include <private/qgl_p.h>
-#ifdef QT_OPENGL_ES_1_CL
-#include "qgl_cl_p.h"
-#endif
 QT_BEGIN_NAMESPACE
 …
         ctx->setConfig(shareContext->config());
 #if QGL_RENDER_TEXTURE
+        EGLint value = EGL_FALSE;
+        if (ctx->configAttrib(EGL_BIND_TO_TEXTURE_RGBA, &value) && value)
+        if (ctx->configAttrib(EGL_BIND_TO_TEXTURE_RGBA) == EGL_TRUE)
             textureFormat = EGL_TEXTURE_RGBA;
         else if (ctx->configAttrib(EGL_BIND_TO_TEXTURE_RGB, &value) && value)
+        else if (ctx->configAttrib(EGL_BIND_TO_TEXTURE_RGB) == EGL_TRUE)
             textureFormat = EGL_TEXTURE_RGB;
 #endif
     } else {
         QEglProperties configProps;
+        qt_egl_set_format(configProps, QInternal::Pbuffer, f);
+        qt_eglproperties_set_glformat(configProps, f);
+        configProps.setDeviceType(QInternal::Pbuffer);
         configProps.setRenderableType(ctx->api());
         bool ok = false;
 …
     // Retrieve the actual format properties.
     qt_egl_update_format(*ctx, format);
+    qt_glformat_from_eglconfig(format, ctx->config());
     // Create the attributes needed for the pbuffer.
 …
 #endif
     if (pbuf == EGL_NO_SURFACE) {
         qWarning() << "QGLPixelBufferPrivate::init(): Unable to create EGL pbuffer surface:" << QEglContext::errorString(eglGetError());
+        qWarning() << "QGLPixelBufferPrivate::init(): Unable to create EGL pbuffer surface:" << QEgl::errorString();
         return false;
+    }
 …
+{
     // See if we have at least 1 configuration that matches the default format.
     EGLDisplay dpy = QEglContext::display();
+    EGLDisplay dpy = QEgl::display();
     if (dpy == EGL_NO_DISPLAY)
         return false;
     QEglProperties configProps;
+    qt_egl_set_format(configProps, QInternal::Pbuffer, QGLFormat::defaultFormat());
+    qt_eglproperties_set_glformat(configProps, QGLFormat::defaultFormat());
+    configProps.setDeviceType(QInternal::Pbuffer);
     configProps.setRenderableType(QEgl::OpenGL);
     do {

trunk/src/opengl/qglpixelbuffer_mac.mm

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/qglpixelbuffer_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #include <private/qglpaintdevice_p.h>
 #if defined(Q_WS_X11) && !defined(QT_OPENGL_ES)
+#if defined(Q_WS_X11) && defined(QT_NO_EGL)
 #include <GL/glx.h>
 …
 #elif defined(Q_WS_WIN)
 DECLARE_HANDLE(HPBUFFERARB);
+#elif defined(QT_OPENGL_ES_2)
+#include <EGL/egl.h>
+#elif defined(QT_OPENGL_ES)
+#include <GLES/egl.h>
+#elif !defined(QT_NO_EGL)
+#include <QtGui/private/qegl_p.h>
 #endif
 QT_END_INCLUDE_NAMESPACE
 …
     QSize req_size;
 #if defined(Q_WS_X11) && !defined(QT_OPENGL_ES)
+#if defined(Q_WS_X11) && defined(QT_NO_EGL)
     GLXPbuffer pbuf;
     GLXContext ctx;
 …
 #  endif
 #endif
 #if defined(QT_OPENGL_ES)
+#ifndef QT_NO_EGL
     EGLSurface pbuf;
     QEglContext *ctx;

trunk/src/opengl/qglpixelbuffer_win.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #endif
+#ifndef WGL_ARB_multisample
+#define WGL_SAMPLE_BUFFERS_ARB         0x2041
+#define WGL_SAMPLES_ARB                0x2042
+#endif
+#ifndef GL_SAMPLES_ARB
+#define GL_SAMPLES_ARB 0x80A9
+#endif
 QGLFormat pfiToQGLFormat(HDC hdc, int pfi);
 …
         attribs[i++] = TRUE;
+    }
+    // sample buffers doesn't work in conjunction with the render_texture extension
+    // so igonre that for now
+    // if (f.sampleBuffers()) {
+    //     attribs[i++] = WGL_SAMPLE_BUFFERS_ARB;
+    //     attribs[i++] = 1;
+    //     attribs[i++] = WGL_SAMPLES_ARB;
+    //     attribs[i++] = f.samples() == -1 ? 16 : f.samples();
+    // }
+    if (f.sampleBuffers()) {
+        attribs[i++] = WGL_SAMPLE_BUFFERS_ARB;
+        attribs[i++] = 1;
+        attribs[i++] = WGL_SAMPLES_ARB;
+        attribs[i++] = f.samples() == -1 ? 16 : f.samples();
+    }
     attribs[i] = 0;
+}
 …
 bool QGLPixelBufferPrivate::init(const QSize &size, const QGLFormat &f, QGLWidget *shareWidget)
+{
+    QGLWidget dmy;
+    dmy.makeCurrent(); // needed for wglGetProcAddress() to succeed
+    QGLTemporaryContext tempContext;
     PFNWGLCREATEPBUFFERARBPROC wglCreatePbufferARB =
 …
         return false;
     dc = GetDC(dmy.winId());
+    dc = wglGetCurrentDC();
     Q_ASSERT(dc);
+    PFNWGLGETEXTENSIONSSTRINGARBPROC wglGetExtensionsStringARB =
+        (PFNWGLGETEXTENSIONSSTRINGARBPROC) wglGetProcAddress("wglGetExtensionsStringARB");
+    if (wglGetExtensionsStringARB) {
+        QString extensions(QLatin1String(wglGetExtensionsStringARB(dc)));
+        has_render_texture = extensions.contains(QLatin1String("WGL_ARB_render_texture"));
+    has_render_texture = false;
+    // sample buffers doesn't work in conjunction with the render_texture extension
+    if (!f.sampleBuffers()) {
+        PFNWGLGETEXTENSIONSSTRINGARBPROC wglGetExtensionsStringARB =
+                (PFNWGLGETEXTENSIONSSTRINGARBPROC) wglGetProcAddress("wglGetExtensionsStringARB");
+        if (wglGetExtensionsStringARB) {
+            QString extensions(QLatin1String(wglGetExtensionsStringARB(dc)));
+            has_render_texture = extensions.contains(QLatin1String("WGL_ARB_render_texture"));
+        }
+    }
 …
     if (num_formats == 0) {
         qWarning("QGLPixelBuffer: Unable to find a pixel format with pbuffer  - giving up.");
-        ReleaseDC(dmy.winId(), dc);
         return false;
+    }
 …
     pbuf = wglCreatePbufferARB(dc, pixel_format, size.width(), size.height(),
                                has_render_texture ? pb_attribs : 0);
     if(!pbuf) {
+    if (!pbuf) {
         // try again without the render_texture extension
         pbuf = wglCreatePbufferARB(dc, pixel_format, size.width(), size.height(), 0);
 …
         if (!pbuf) {
             qWarning("QGLPixelBuffer: Unable to create pbuffer [w=%d, h=%d] - giving up.", size.width(), size.height());
-            ReleaseDC(dmy.winId(), dc);
             return false;
+        }
+    }
-    ReleaseDC(dmy.winId(), dc);
     dc = wglGetPbufferDCARB(pbuf);
     ctx = wglCreateContext(dc);
     if (!dc || !ctx) {
         qWarning("QGLPixelBuffer: Unable to create pbuffer context - giving up.");
         return false;
+    }
+    // Explicitly disable the render_texture extension if we have a
+    // multi-sampled pbuffer context. This seems to be a problem only with
+    // ATI cards if multi-sampling is forced globally in the driver.
+    wglMakeCurrent(dc, ctx);
+    GLint samples = 0;
+    glGetIntegerv(GL_SAMPLES_ARB, &samples);
+    if (has_render_texture && samples != 0)
+        has_render_texture = false;
     HGLRC share_ctx = shareWidget ? shareWidget->d_func()->glcx->d_func()->rc : 0;

trunk/src/opengl/qglpixelbuffer_x11.cpp

r769	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/qglpixmapfilter.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 // qpixmapfilter.cpp
 void qt_blurImage(QImage &blurImage, qreal radius, bool quality, int transposed = 0);
 QImage qt_halfScaled(const QImage &source);
+Q_DECL_IMPORT void qt_blurImage(QImage &blurImage, qreal radius, bool quality, int transposed = 0);
+Q_DECL_IMPORT QImage qt_halfScaled(const QImage &source);
 void QGLPixmapFilterBase::bindTexture(const QPixmap &src) const
 …
+}
 void qt_memrotate90_gl(const quint32 *src, int srcWidth, int srcHeight, int srcStride,
+Q_DECL_IMPORT void qt_memrotate90_gl(const quint32 *src, int srcWidth, int srcHeight, int srcStride,
                        quint32 *dest, int dstStride);

trunk/src/opengl/qglpixmapfilter_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/qglscreen_qws.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/qglscreen_qws.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/qglshaderprogram.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 QT_BEGIN_NAMESPACE
 #if !defined(QT_OPENGL_ES_1_CL) && !defined(QT_OPENGL_ES_1)
+#if !defined(QT_OPENGL_ES_1)
 /*!
 …
     \value Vertex Vertex shader written in the OpenGL Shading Language (GLSL).
     \value Fragment Fragment shader written in the OpenGL Shading Language (GLSL).
+    \value Geometry Geometry shaders written in the OpenGL Shading
+           Language (GLSL), based on the GL_EXT_geometry_shader4 extension.
 */
 …
         if (shaderType == QGLShader::Vertex)
             shader = glCreateShader(GL_VERTEX_SHADER);
+        else if (shaderType == QGLShader::Geometry)
+            shader = glCreateShader(GL_GEOMETRY_SHADER_EXT);
         else
             shader = glCreateShader(GL_FRAGMENT_SHADER);
 …
+}
 #undef ctx
 #define ctx programGuard.context()
 …
         , inited(false)
         , removingShaders(false)
+        , vertexShader(0)
+        , fragmentShader(0)
+        , geometryVertexCount(64)
+        , geometryInputType(0)
+        , geometryOutputType(0)
+    {
+    }
 …
     bool inited;
     bool removingShaders;
+    int geometryVertexCount;
+    GLenum geometryInputType;
+    GLenum geometryOutputType;
     QString log;
     QList<QGLShader *> shaders;
     QList<QGLShader *> anonShaders;
-    QGLShader *vertexShader;
-    QGLShader *fragmentShader;
     bool hasShader(QGLShader::ShaderType type) const;
 …
         d->programGuard.setContext(context);
+    }
     if (!context)
         return false;
 …
     if (!program)
         return false;
     GLint value;
     if (d->shaders.isEmpty()) {
 …
             return true;
+    }
+    // Set up the geometry shader parameters
+    if (glProgramParameteriEXT) {
+        foreach (QGLShader *shader, d->shaders) {
+            if (shader->shaderType() & QGLShader::Geometry) {
+                glProgramParameteriEXT(program, GL_GEOMETRY_INPUT_TYPE_EXT,
+                                       d->geometryInputType);
+                glProgramParameteriEXT(program, GL_GEOMETRY_OUTPUT_TYPE_EXT,
+                                       d->geometryOutputType);
+                glProgramParameteriEXT(program, GL_GEOMETRY_VERTICES_OUT_EXT,
+                                       d->geometryVertexCount);
+                break;
+            }
+        }
+    }
     glLinkProgram(program);
     value = 0;
 …
     Q_UNUSED(d);
     if (location != -1) {
+        GLfloat values[4] = {value.redF(), value.greenF(), value.blueF(), value.alphaF()};
+        GLfloat values[4] = {GLfloat(value.redF()), GLfloat(value.greenF()),
+                             GLfloat(value.blueF()), GLfloat(value.alphaF())};
         glVertexAttrib4fv(location, values);
+    }
 …
 /*!
+    Sets an array of vertex \a values on the attribute at \a location
+    in this shader program.  The \a stride indicates the number of bytes
+    between vertices.  A default \a stride value of zero indicates that
+    the vertices are densely packed in \a values.
+    The \a type indicates the type of elements in the \a values array,
+    usually \c{GL_FLOAT}, \c{GL_UNSIGNED_BYTE}, etc.  The \a tupleSize
+    indicates the number of components per vertex: 1, 2, 3, or 4.
+    The array will become active when enableAttributeArray() is called
+    on the \a location.  Otherwise the value specified with
+    setAttributeValue() for \a location will be used.
+    The setAttributeBuffer() function can be used to set the attribute
+    array to an offset within a vertex buffer.
+    \sa setAttributeValue(), setUniformValue(), enableAttributeArray()
+    \sa disableAttributeArray(), setAttributeBuffer()
+    \since 4.7
+*/
+void QGLShaderProgram::setAttributeArray
+    (int location, GLenum type, const void *values, int tupleSize, int stride)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1) {
+        glVertexAttribPointer(location, tupleSize, type, GL_TRUE,
+                              stride, values);
+    }
+}
+/*!
     \overload
 …
+{
     setAttributeArray(attributeLocation(name), values, stride);
+}
+/*!
+    \overload
+    Sets an array of vertex \a values on the attribute called \a name
+    in this shader program.  The \a stride indicates the number of bytes
+    between vertices.  A default \a stride value of zero indicates that
+    the vertices are densely packed in \a values.
+    The \a type indicates the type of elements in the \a values array,
+    usually \c{GL_FLOAT}, \c{GL_UNSIGNED_BYTE}, etc.  The \a tupleSize
+    indicates the number of components per vertex: 1, 2, 3, or 4.
+    The array will become active when enableAttributeArray() is called
+    on the \a name.  Otherwise the value specified with
+    setAttributeValue() for \a name will be used.
+    The setAttributeBuffer() function can be used to set the attribute
+    array to an offset within a vertex buffer.
+    \sa setAttributeValue(), setUniformValue(), enableAttributeArray()
+    \sa disableAttributeArray(), setAttributeBuffer()
+    \since 4.7
+*/
+void QGLShaderProgram::setAttributeArray
+    (const char *name, GLenum type, const void *values, int tupleSize, int stride)
+{
+    setAttributeArray(attributeLocation(name), type, values, tupleSize, stride);
+}
+/*!
+    Sets an array of vertex values on the attribute at \a location in
+    this shader program, starting at a specific \a offset in the
+    currently bound vertex buffer.  The \a stride indicates the number
+    of bytes between vertices.  A default \a stride value of zero
+    indicates that the vertices are densely packed in the value array.
+    The \a type indicates the type of elements in the vertex value
+    array, usually \c{GL_FLOAT}, \c{GL_UNSIGNED_BYTE}, etc.  The \a
+    tupleSize indicates the number of components per vertex: 1, 2, 3,
+    or 4.
+    The array will become active when enableAttributeArray() is called
+    on the \a location.  Otherwise the value specified with
+    setAttributeValue() for \a location will be used.
+    \sa setAttributeArray()
+    \since 4.7
+*/
+void QGLShaderProgram::setAttributeBuffer
+    (int location, GLenum type, int offset, int tupleSize, int stride)
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1) {
+        glVertexAttribPointer(location, tupleSize, type, GL_TRUE, stride,
+                              reinterpret_cast<const void *>(offset));
+    }
+}
+/*!
+    \overload
+    Sets an array of vertex values on the attribute called \a name
+    in this shader program, starting at a specific \a offset in the
+    currently bound vertex buffer.  The \a stride indicates the number
+    of bytes between vertices.  A default \a stride value of zero
+    indicates that the vertices are densely packed in the value array.
+    The \a type indicates the type of elements in the vertex value
+    array, usually \c{GL_FLOAT}, \c{GL_UNSIGNED_BYTE}, etc.  The \a
+    tupleSize indicates the number of components per vertex: 1, 2, 3,
+    or 4.
+    The array will become active when enableAttributeArray() is called
+    on the \a name.  Otherwise the value specified with
+    setAttributeValue() for \a name will be used.
+    \sa setAttributeArray()
+    \since 4.7
+*/
+void QGLShaderProgram::setAttributeBuffer
+    (const char *name, GLenum type, int offset, int tupleSize, int stride)
+{
+    setAttributeBuffer(attributeLocation(name), type, offset, tupleSize, stride);
+}
 …
     Q_UNUSED(d);
     if (location != -1) {
+        GLfloat values[4] = {color.redF(), color.greenF(), color.blueF(), color.alphaF()};
+        GLfloat values[4] = {GLfloat(color.redF()), GLfloat(color.greenF()),
+                             GLfloat(color.blueF()), GLfloat(color.alphaF())};
         glUniform4fv(location, 1, values);
+    }
 …
     Q_UNUSED(d);
     if (location != -1) {
         GLfloat values[4] = {point.x(), point.y()};
+        GLfloat values[4] = {GLfloat(point.x()), GLfloat(point.y())};
         glUniform2fv(location, 1, values);
+    }
 …
     Q_UNUSED(d);
     if (location != -1) {
         GLfloat values[4] = {point.x(), point.y()};
+        GLfloat values[4] = {GLfloat(point.x()), GLfloat(point.y())};
         glUniform2fv(location, 1, values);
+    }
 …
     Q_UNUSED(d);
     if (location != -1) {
         GLfloat values[4] = {size.width(), size.width()};
+        GLfloat values[4] = {GLfloat(size.width()), GLfloat(size.height())};
         glUniform2fv(location, 1, values);
+    }
 …
     Q_UNUSED(d);
     if (location != -1) {
         GLfloat values[4] = {size.width(), size.height()};
+        GLfloat values[4] = {GLfloat(size.width()), GLfloat(size.height())};
         glUniform2fv(location, 1, values);
+    }
 …
     Sets the uniform variable at \a location in the current context
+    to a 2x2 matrix \a value.  The matrix elements must be specified
+    in column-major order.
+    \sa setAttributeValue()
+    \since 4.7
+*/
+void QGLShaderProgram::setUniformValue(int location, const GLfloat value[2][2])
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1)
+        glUniformMatrix2fv(location, 1, GL_FALSE, value[0]);
+}
+/*!
+    \overload
+    Sets the uniform variable at \a location in the current context
+    to a 3x3 matrix \a value.  The matrix elements must be specified
+    in column-major order.
+    \sa setAttributeValue()
+    \since 4.7
+*/
+void QGLShaderProgram::setUniformValue(int location, const GLfloat value[3][3])
+{
+    Q_D(QGLShaderProgram);
+    Q_UNUSED(d);
+    if (location != -1)
+        glUniformMatrix3fv(location, 1, GL_FALSE, value[0]);
+}
+/*!
+    \overload
+    Sets the uniform variable at \a location in the current context
     to a 4x4 matrix \a value.  The matrix elements must be specified
     in column-major order.
 …
     if (location != -1)
         glUniformMatrix4fv(location, 1, GL_FALSE, value[0]);
+}
+/*!
+    \overload
+    Sets the uniform variable called \a name in the current context
+    to a 2x2 matrix \a value.  The matrix elements must be specified
+    in column-major order.
+    \sa setAttributeValue()
+    \since 4.7
+*/
+void QGLShaderProgram::setUniformValue(const char *name, const GLfloat value[2][2])
+{
+    setUniformValue(uniformLocation(name), value);
+}
+/*!
+    \overload
+    Sets the uniform variable called \a name in the current context
+    to a 3x3 matrix \a value.  The matrix elements must be specified
+    in column-major order.
+    \sa setAttributeValue()
+    \since 4.7
+*/
+void QGLShaderProgram::setUniformValue(const char *name, const GLfloat value[3][3])
+{
+    setUniformValue(uniformLocation(name), value);
+}
 …
     if (location != -1) {
         GLfloat mat[3][3] = {
             {value.m11(), value.m12(), value.m13()},
             {value.m21(), value.m22(), value.m23()},
             {value.m31(), value.m32(), value.m33()}
+            {GLfloat(value.m11()), GLfloat(value.m12()), GLfloat(value.m13())},
+            {GLfloat(value.m21()), GLfloat(value.m22()), GLfloat(value.m23())},
+            {GLfloat(value.m31()), GLfloat(value.m32()), GLfloat(value.m33())}
         };
         glUniformMatrix3fv(location, 1, GL_FALSE, mat[0]);
 …
 /*!
+    Returns the hardware limit for how many vertices a geometry shader
+    can output.
+    \since 4.7
+    \sa setGeometryOutputVertexCount()
+*/
+int QGLShaderProgram::maxGeometryOutputVertices() const
+{
+    GLint n;
+    glGetIntegerv(GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT, &n);
+    return n;
+}
+/*!
+    Sets the maximum number of vertices the current geometry shader
+    program will produce, if active, to \a count.
+    \since 4.7
+    This parameter takes effect the next time the program is linked.
+*/
+void QGLShaderProgram::setGeometryOutputVertexCount(int count)
+{
+#ifndef QT_NO_DEBUG
+    int max = maxGeometryOutputVertices();
+    if (count > max) {
+        qWarning("QGLShaderProgram::setGeometryOutputVertexCount: count: %d higher than maximum: %d",
+                 count, max);
+    }
+#endif
+    d_func()->geometryVertexCount = count;
+}
+/*!
+    Returns the maximum number of vertices the current geometry shader
+    program will produce, if active.
+    \since 4.7
+    This parameter takes effect the ntext time the program is linked.
+*/
+int QGLShaderProgram::geometryOutputVertexCount() const
+{
+    return d_func()->geometryVertexCount;
+}
+/*!
+    Sets the input type from \a inputType.
+    This parameter takes effect the next time the program is linked.
+*/
+void QGLShaderProgram::setGeometryInputType(GLenum inputType)
+{
+    d_func()->geometryInputType = inputType;
+}
+/*!
+    Returns the geometry shader input type, if active.
+    This parameter takes effect the next time the program is linked.
+    \since 4.7
+ */
+GLenum QGLShaderProgram::geometryInputType() const
+{
+    return d_func()->geometryInputType;
+}
+/*!
+    Sets the output type from the geometry shader, if active, to
+    \a outputType.
+    This parameter takes effect the next time the program is linked.
+    \since 4.7
+*/
+void QGLShaderProgram::setGeometryOutputType(GLenum outputType)
+{
+    d_func()->geometryOutputType = outputType;
+}
+/*!
+    Returns the geometry shader output type, if active.
+    This parameter takes effect the next time the program is linked.
+    \since 4.7
+ */
+GLenum QGLShaderProgram::geometryOutputType() const
+{
+    return d_func()->geometryOutputType;
+}
+/*!
     Returns true if shader programs written in the OpenGL Shading
     Language (GLSL) are supported on this system; false otherwise.
 …
+}
+#undef ctx
+#undef context
+/*!
+    Returns true if shader programs of type \a type are supported on
+    this system; false otherwise.
+    The \a context is used to resolve the GLSL extensions.
+    If \a context is null, then QGLContext::currentContext() is used.
+    \since 4.7
+*/
+bool QGLShader::hasOpenGLShaders(ShaderType type, const QGLContext *context)
+{
+    if (!context)
+        context = QGLContext::currentContext();
+    if (!context)
+        return false;
+    if ((type & ~(Geometry | Vertex | Fragment)) || type == 0)
+        return false;
+    bool resolved = qt_resolve_glsl_extensions(const_cast<QGLContext *>(context));
+    if (!resolved)
+        return false;
+    if ((type & Geometry) && !QByteArray((const char *) glGetString(GL_EXTENSIONS)).contains("GL_EXT_geometry_shader4"))
+        return false;
+    return true;
+}
 #ifdef Q_MAC_COMPAT_GL_FUNCTIONS
 /*! \internal */
+void QGLShaderProgram::setAttributeArray
+    (int location, QMacCompatGLenum type, const void *values, int tupleSize, int stride)
+{
+    setAttributeArray(location, GLenum(type), values, tupleSize, stride);
+}
+/*! \internal */
+void QGLShaderProgram::setAttributeArray
+    (const char *name, QMacCompatGLenum type, const void *values, int tupleSize, int stride)
+{
+    setAttributeArray(name, GLenum(type), values, tupleSize, stride);
+}
+/*! \internal */
+void QGLShaderProgram::setAttributeBuffer
+    (int location, QMacCompatGLenum type, int offset, int tupleSize, int stride)
+{
+    setAttributeBuffer(location, GLenum(type), offset, tupleSize, stride);
+}
+/*! \internal */
+void QGLShaderProgram::setAttributeBuffer
+    (const char *name, QMacCompatGLenum type, int offset, int tupleSize, int stride)
+{
+    setAttributeBuffer(name, GLenum(type), offset, tupleSize, stride);
+}
+/*! \internal */
 void QGLShaderProgram::setUniformValue(int location, QMacCompatGLint value)
+{
 …
 #endif
 #endif // !defined(QT_OPENGL_ES_1_CL) && !defined(QT_OPENGL_ES_1)
+#endif // !defined(QT_OPENGL_ES_1)
 QT_END_NAMESPACE

trunk/src/opengl/qglshaderprogram.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 QT_MODULE(OpenGL)
 #if !defined(QT_OPENGL_ES_1_CL) && !defined(QT_OPENGL_ES_1)
+#if !defined(QT_OPENGL_ES_1)
 class QGLShaderProgram;
 …
+    {
         Vertex          = 0x0001,
+        Fragment        = 0x0002
+        Fragment        = 0x0002,
+        Geometry        = 0x0004
     };
     Q_DECLARE_FLAGS(ShaderType, ShaderTypeBit)
 …
     GLuint shaderId() const;
+    static bool hasOpenGLShaders(ShaderType type, const QGLContext *context = 0);
 private:
     friend class QGLShaderProgram;
 …
 class QGLShaderProgramPrivate;
+#ifndef GL_EXT_geometry_shader4
+#  define GL_LINES_ADJACENCY_EXT 0xA
+#  define GL_LINE_STRIP_ADJACENCY_EXT 0xB
+#  define GL_TRIANGLES_ADJACENCY_EXT 0xC
+#  define GL_TRIANGLE_STRIP_ADJACENCY_EXT 0xD
+#endif
 class Q_OPENGL_EXPORT QGLShaderProgram : public QObject
 …
     GLuint programId() const;
+    int maxGeometryOutputVertices() const;
+    void setGeometryOutputVertexCount(int count);
+    int geometryOutputVertexCount() const;
+    void setGeometryInputType(GLenum inputType);
+    GLenum geometryInputType() const;
+    void setGeometryOutputType(GLenum outputType);
+    GLenum geometryOutputType() const;
     void bindAttributeLocation(const char *name, int location);
 …
         (int location, const QVector4D *values, int stride = 0);
     void setAttributeArray
+        (int location, GLenum type, const void *values, int tupleSize, int stride = 0);
+    void setAttributeArray
         (const char *name, const GLfloat *values, int tupleSize, int stride = 0);
     void setAttributeArray
 …
     void setAttributeArray
         (const char *name, const QVector4D *values, int stride = 0);
+    void setAttributeArray
+        (const char *name, GLenum type, const void *values, int tupleSize, int stride = 0);
+    void setAttributeBuffer
+        (int location, GLenum type, int offset, int tupleSize, int stride = 0);
+    void setAttributeBuffer
+        (const char *name, GLenum type, int offset, int tupleSize, int stride = 0);
+#ifdef Q_MAC_COMPAT_GL_FUNCTIONS
+    void setAttributeArray
+        (int location, QMacCompatGLenum type, const void *values, int tupleSize, int stride = 0);
+    void setAttributeArray
+        (const char *name, QMacCompatGLenum type, const void *values, int tupleSize, int stride = 0);
+    void setAttributeBuffer
+        (int location, QMacCompatGLenum type, int offset, int tupleSize, int stride = 0);
+    void setAttributeBuffer
+        (const char *name, QMacCompatGLenum type, int offset, int tupleSize, int stride = 0);
+#endif
     void enableAttributeArray(int location);
 …
     void setUniformValue(int location, const QMatrix4x3& value);
     void setUniformValue(int location, const QMatrix4x4& value);
+    void setUniformValue(int location, const GLfloat value[2][2]);
+    void setUniformValue(int location, const GLfloat value[3][3]);
     void setUniformValue(int location, const GLfloat value[4][4]);
     void setUniformValue(int location, const QTransform& value);
 …
     void setUniformValue(const char *name, const QMatrix4x3& value);
     void setUniformValue(const char *name, const QMatrix4x4& value);
+    void setUniformValue(const char *name, const GLfloat value[2][2]);
+    void setUniformValue(const char *name, const GLfloat value[3][3]);
     void setUniformValue(const char *name, const GLfloat value[4][4]);
     void setUniformValue(const char *name, const QTransform& value);

trunk/src/opengl/qglwindowsurface_qws.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/qglwindowsurface_qws_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/qgraphicsshadereffect.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #include "qgraphicsshadereffect_p.h"
 #if !defined(QT_OPENGL_ES_1) && !defined(QT_OPENGL_ES_1_CL)
+#if !defined(QT_OPENGL_ES_1)
 #include "qglshaderprogram.h"
 #include "gl2paintengineex/qglcustomshaderstage_p.h"

trunk/src/opengl/qgraphicsshadereffect_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/qgraphicssystem_gl.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #include "qgraphicssystem_gl_p.h"
+#include <QGraphicsView>
 #include "private/qpixmap_raster_p.h"
 …
 #include <private/qwindowsurface_raster_p.h>
 #if defined(Q_WS_X11) && defined(QT_OPENGL_ES)
+#if defined(Q_WS_X11) && !defined(QT_NO_EGL)
 #include "private/qpixmapdata_x11gl_p.h"
 #include "private/qwindowsurface_x11gl_p.h"
 …
 QPixmapData *QGLGraphicsSystem::createPixmapData(QPixmapData::PixelType type) const
+{
-#if defined(Q_WS_X11) && defined(QT_OPENGL_ES)
-    if (type == QPixmapData::PixmapType && QX11GLPixmapData::hasX11GLPixmaps())
-        return new QX11GLPixmapData();
-#endif
     return new QGLPixmapData(type);
+}
 …
 #endif
+#if defined(Q_WS_X11) && defined(QT_OPENGL_ES)
+    if (QX11GLPixmapData::hasX11GLPixmaps())
+        return new QX11GLWindowSurface(widget);
+#if defined(Q_WS_X11) && !defined(QT_NO_EGL)
+    if (m_useX11GL && QX11GLPixmapData::hasX11GLPixmaps()) {
+        // If the widget is a QGraphicsView which will be re-drawing the entire
+        // scene each frame anyway, we should use QGLWindowSurface as this may
+        // provide proper buffer flipping, which should be faster than QX11GL's
+        // blitting approach:
+        QGraphicsView* qgv = qobject_cast<QGraphicsView*>(widget);
+        if (qgv && qgv->viewportUpdateMode() == QGraphicsView::FullViewportUpdate)
+            return new QGLWindowSurface(widget);
+        else
+            return new QX11GLWindowSurface(widget);
+    }
 #endif

trunk/src/opengl/qgraphicssystem_gl_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
+{
 public:
     QGLGraphicsSystem();
+    QGLGraphicsSystem(bool useX11GL);
     QPixmapData *createPixmapData(QPixmapData::PixelType type) const;
     QWindowSurface *createWindowSurface(QWidget *widget) const;
+private:
+    bool m_useX11GL;
 };

trunk/src/opengl/qpaintengine_opengl.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #include <private/qbezier_p.h>
 #include <qglframebufferobject.h>
+#include <private/qstatictext_p.h>
 #include "private/qtessellator_p.h"
 …
 #endif
-#ifdef QT_OPENGL_ES_1_CL
-#include "qgl_cl_p.h"
-#endif
 #define QGL_FUNC_CONTEXT QGLContext *ctx = const_cast<QGLContext *>(device->context());
 …
 QT_BEGIN_NAMESPACE
 extern QImage qt_imageForBrush(int brushStyle, bool invert); //in qbrush.cpp
+Q_DECL_IMPORT extern QImage qt_imageForBrush(int brushStyle, bool invert); //in qbrush.cpp
 #ifdef QT_MAC_USE_COCOA
 extern void *qt_current_nsopengl_context(); // qgl_mac.mm
 …
 ////////// GL program cache: start
 typedef struct {
+struct GLProgram {
     int brush; // brush index or mask index
     int mode;  // composition mode index
     bool mask;
     GLuint program;
 } GLProgram;
+};
 typedef QMultiHash<const QGLContext *, GLProgram> QGLProgramHash;
 …
         , shader_ctx(0)
         , grad_palette(0)
+        , tess_points(0)
         , drawable_texture(0)
         , ref_cleaner(this)
 …
     void composite(const QRectF &rect, const QPoint &maskOffset = QPoint());
     void composite(GLuint primitive, const q_vertexType *vertexArray, int vertexCount, const QPoint &maskOffset = QPoint());
+    void composite(GLuint primitive, const GLfloat *vertexArray, int vertexCount, const QPoint &maskOffset = QPoint());
     bool createFragmentPrograms();
 …
     stroker.setJoinStyle(cpen.joinStyle());
     stroker.setMiterLimit(cpen.miterLimit());
+    stroker.setDashOffset(cpen.dashOffset());
     qreal width = cpen.widthF();
 …
     QOpenGLTrapezoidToArrayTessellator() : vertices(0), allocated(0), size(0) {}
     ~QOpenGLTrapezoidToArrayTessellator() { free(vertices); }
     q_vertexType *vertices;
+    GLfloat *vertices;
     int allocated;
     int size;
 …
 #endif
         allocated = qMax(2*allocated, 512);
         vertices = (q_vertexType *)realloc(vertices, allocated * sizeof(q_vertexType));
+        vertices = (GLfloat *)realloc(vertices, allocated * sizeof(GLfloat));
+    }
 …
 #ifndef QT_OPENGL_ES
     vertices[size++] = f2vt(t.topLeftX);
     vertices[size++] = f2vt(t.top);
     vertices[size++] = f2vt(t.topRightX);
     vertices[size++] = f2vt(t.top);
     vertices[size++] = f2vt(t.bottomRightX);
     vertices[size++] = f2vt(t.bottom);
     vertices[size++] = f2vt(t.bottomLeftX);
     vertices[size++] = f2vt(t.bottom);
+    vertices[size++] = t.topLeftX;
+    vertices[size++] = t.top;
+    vertices[size++] = t.topRightX;
+    vertices[size++] = t.top;
+    vertices[size++] = t.bottomRightX;
+    vertices[size++] = t.bottom;
+    vertices[size++] = t.bottomLeftX;
+    vertices[size++] = t.bottom;
 #else
     // First triangle
     vertices[size++] = f2vt(t.topLeftX);
     vertices[size++] = f2vt(t.top);
     vertices[size++] = f2vt(t.topRightX);
     vertices[size++] = f2vt(t.top);
     vertices[size++] = f2vt(t.bottomRightX);
     vertices[size++] = f2vt(t.bottom);
+    vertices[size++] = t.topLeftX;
+    vertices[size++] = t.top;
+    vertices[size++] = t.topRightX;
+    vertices[size++] = t.top;
+    vertices[size++] = t.bottomRightX;
+    vertices[size++] = t.bottom;
     // Second triangle
     vertices[size++] = f2vt(t.bottomLeftX);
     vertices[size++] = f2vt(t.bottom);
     vertices[size++] = f2vt(t.topLeftX);
     vertices[size++] = f2vt(t.top);
     vertices[size++] = f2vt(t.bottomRightX);
     vertices[size++] = f2vt(t.bottom);
+    vertices[size++] = t.bottomLeftX;
+    vertices[size++] = t.bottom;
+    vertices[size++] = t.topLeftX;
+    vertices[size++] = t.top;
+    vertices[size++] = t.bottomRightX;
+    vertices[size++] = t.bottom;
 #endif
+}
 …
         composite(geometry_mode, tessellator.vertices, tessellator.size / 2);
     } else {
         glVertexPointer(2, q_vertexTypeEnum, 0, tessellator.vertices);
+        glVertexPointer(2, GL_FLOAT, 0, tessellator.vertices);
         glEnableClientState(GL_VERTEX_ARRAY);
         glDrawArrays(geometry_mode, 0, tessellator.size/2);
 …
 void QOpenGLPaintEnginePrivate::drawVertexArrays()
+{
+    if (tess_points_stops.count() == 0)
+        return;
     glEnableClientState(GL_VERTEX_ARRAY);
     glVertexPointer(2, GL_DOUBLE, 0, tess_points.data());
 …
+    }
 #if defined(QT_OPENGL_ES_1) || defined(QT_OPENGL_ES_2) || defined(QT_OPENGL_ES_1_CL)
+#if defined(QT_OPENGL_ES_1) || defined(QT_OPENGL_ES_2)
     glClearDepthf(0.0f);
 #else
 …
     // rectangle count * 2 (triangles) * vertex count * component count (Z omitted)
     QDataBuffer<q_vertexType> clipVertex(rects.size()*2*3*2);
+    QDataBuffer<GLfloat> clipVertex(rects.size()*2*3*2);
     for (int i = 0; i < rects.size(); ++i) {
         q_vertexType x = i2vt(rects.at(i).left());
         q_vertexType w = i2vt(rects.at(i).width());
         q_vertexType h = i2vt(rects.at(i).height());
         q_vertexType y = i2vt(rects.at(i).top());
+        GLfloat x = GLfloat(rects.at(i).left());
+        GLfloat w = GLfloat(rects.at(i).width());
+        GLfloat h = GLfloat(rects.at(i).height());
+        GLfloat y = GLfloat(rects.at(i).top());
         // First triangle
 …
         glEnableClientState(GL_VERTEX_ARRAY);
         glVertexPointer(2, q_vertexTypeEnum, 0, clipVertex.data());
+        glVertexPointer(2, GL_FLOAT, 0, clipVertex.data());
         glDrawArrays(GL_TRIANGLES, 0, rects.size()*2*3);
 …
+}
 extern void qt_add_rect_to_array(const QRectF &r, q_vertexType *array);
 extern void qt_add_texcoords_to_array(qreal x1, qreal y1, qreal x2, qreal y2, q_vertexType *array);
+extern void qt_add_rect_to_array(const QRectF &r, GLfloat *array);
+extern void qt_add_texcoords_to_array(qreal x1, qreal y1, qreal x2, qreal y2, GLfloat *array);
 void QGLTrapezoidMaskGenerator::drawMask(const QRect &rect)
 …
     // clear mask
     glBlendFunc(GL_ZERO, GL_ZERO); // clear
     glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray);
+    glVertexPointer(2, GL_FLOAT, 0, vertexArray);
     glEnableClientState(GL_VERTEX_ARRAY);
     glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 …
     QTransform inv_matrix = gl_to_qt * matrix().inverted() * translate;
     float m[3][4] = { { inv_matrix.m11(), inv_matrix.m12(), inv_matrix.m13() },
                       { inv_matrix.m21(), inv_matrix.m22(), inv_matrix.m23() },
                       { inv_matrix.m31(), inv_matrix.m32(), inv_matrix.m33() } };
+    float m[3][4] = { { float(inv_matrix.m11()), float(inv_matrix.m12()), float(inv_matrix.m13()) },
+                      { float(inv_matrix.m21()), float(inv_matrix.m22()), float(inv_matrix.m23()) },
+                      { float(inv_matrix.m31()), float(inv_matrix.m32()), float(inv_matrix.m33()) } };
     QPoint offs(screen_rect.left() - rect.left(), (offscreen->drawableSize().height() - screen_rect.top())
 …
     // last component needs to be 1.0f to avoid Nvidia bug on linux
     float ellipse_offset[4] = { offs.x(), offs.y(), 0.0f, 1.0f };
+    float ellipse_offset[4] = { float(offs.x()), float(offs.y()), 0.0f, 1.0f };
     GLfloat vertexArray[4 * 2];
 …
     glEnableClientState(GL_VERTEX_ARRAY);
     glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray);
+    glVertexPointer(2, GL_FLOAT, 0, vertexArray);
     glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
     glDisableClientState(GL_VERTEX_ARRAY);
 …
     DEBUG_ONCE_STR("QOpenGLPaintEngine::drawRects(): drawing fast rect");
     q_vertexType vertexArray[10];
+    GLfloat vertexArray[10];
     qt_add_rect_to_array(r, vertexArray);
 …
         if (fast_style && has_fast_composition_mode) {
             glEnableClientState(GL_VERTEX_ARRAY);
             glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray);
+            glVertexPointer(2, GL_FLOAT, 0, vertexArray);
             glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
             glDisableClientState(GL_VERTEX_ARRAY);
 …
             vertexArray[9] = vertexArray[1];
             glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray);
+            glVertexPointer(2, GL_FLOAT, 0, vertexArray);
             glEnableClientState(GL_VERTEX_ARRAY);
             glDrawArrays(GL_LINE_STRIP, 0, 5);
 …
+}
 static void addQuadAsTriangle(q_vertexType *quad, q_vertexType *triangle)
+static void addQuadAsTriangle(GLfloat *quad, GLfloat *triangle)
+{
     triangle[0] = quad[0];
 …
     if (d->has_fast_pen) {
         QVarLengthArray<q_vertexType> vertexArray(6 * pointCount);
+        QVarLengthArray<GLfloat> vertexArray(6 * pointCount);
         glMatrixMode(GL_MODELVIEW);
 …
             QPointF mapped = d->matrix.map(points[i]);
+            qreal xf = qRound(mapped.x());
+            qreal yf = qRound(mapped.y());
+            q_vertexType x = f2vt(xf);
+            q_vertexType y = f2vt(yf);
+            GLfloat x = GLfloat(qRound(mapped.x()));
+            GLfloat y = GLfloat(qRound(mapped.y()));
             vertexArray[j++] = x;
             vertexArray[j++] = y - f2vt(0.5);
             vertexArray[j++] = x + f2vt(1.5);
             vertexArray[j++] = y + f2vt(1.0);
+            vertexArray[j++] = y - 0.5f;
+            vertexArray[j++] = x + 1.5f;
+            vertexArray[j++] = y + 1.0f;
             vertexArray[j++] = x;
             vertexArray[j++] = y + f2vt(1.0);
+            vertexArray[j++] = y + 1.0f;
+        }
         glEnableClientState(GL_VERTEX_ARRAY);
         glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray.constData());
+        glVertexPointer(2, GL_FLOAT, 0, vertexArray.constData());
         glDrawArrays(GL_TRIANGLES, 0, pointCount*3);
 …
     else {
         Q_ASSERT(sizeof(QPointF) == 8);
         glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray);
+        glVertexPointer(2, GL_FLOAT, 0, vertexArray);
+    }
 …
+            }
             q_vertexType endCap = f2vt(d->cpen.capStyle() == Qt::FlatCap ? 0 : 0.5);
+            GLfloat endCap = d->cpen.capStyle() == Qt::FlatCap ? 0.0f : 0.5f;
             if (useRects) {
                 QVarLengthArray<q_vertexType> vertexArray(12 * lineCount);
                 q_vertexType quad[8];
+                QVarLengthArray<GLfloat> vertexArray(12 * lineCount);
+                GLfloat quad[8];
                 for (int i = 0; i < lineCount; ++i) {
                     q_vertexType x1 = f2vt(lines[i].x1());
                     q_vertexType x2 = f2vt(lines[i].x2());
                     q_vertexType y1 = f2vt(lines[i].y1());
                     q_vertexType y2 = f2vt(lines[i].y2());
+                    GLfloat x1 = lines[i].x1();
+                    GLfloat x2 = lines[i].x2();
+                    GLfloat y1 = lines[i].y1();
+                    GLfloat y2 = lines[i].y2();
                     if (x1 == x2) {
 …
                             qSwap(y1, y2);
                         quad[0] = x1 - f2vt(0.5);
+                        quad[0] = x1 - 0.5f;
                         quad[1] = y1 - endCap;
                         quad[2] = x1 + f2vt(0.5);
+                        quad[2] = x1 + 0.5f;
                         quad[3] = y1 - endCap;
                         quad[4] = x1 + f2vt(0.5);
+                        quad[4] = x1 + 0.5f;
                         quad[5] = y2 + endCap;
                         quad[6] = x1 - f2vt(0.5);
+                        quad[6] = x1 - 0.5f;
                         quad[7] = y2 + endCap;
                     } else {
 …
                         quad[0] = x1 - endCap;
                         quad[1] = y1 + f2vt(0.5);
+                        quad[1] = y1 + 0.5f;
                         quad[2] = x1 - endCap;
                         quad[3] = y1 - f2vt(0.5);
+                        quad[3] = y1 - 0.5f;
                         quad[4] = x2 + endCap;
                         quad[5] = y1 - f2vt(0.5);
+                        quad[5] = y1 - 0.5f;
                         quad[6] = x2 + endCap;
                         quad[7] = y1 + f2vt(0.5);
+                        quad[7] = y1 + 0.5f;
+                    }
 …
                 glEnableClientState(GL_VERTEX_ARRAY);
                 glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray.constData());
+                glVertexPointer(2, GL_FLOAT, 0, vertexArray.constData());
                 glDrawArrays(GL_TRIANGLES, 0, lineCount*6);
                 glDisableClientState(GL_VERTEX_ARRAY);
             } else {
                 QVarLengthArray<q_vertexType> vertexArray(4 * lineCount);
+                QVarLengthArray<GLfloat> vertexArray(4 * lineCount);
                 for (int i = 0; i < lineCount; ++i) {
                     const QPointF a = lines[i].p1();
                     vertexArray[4*i]   = f2vt(lines[i].x1());
                     vertexArray[4*i+1] = f2vt(lines[i].y1());
                     vertexArray[4*i+2] = f2vt(lines[i].x2());
                     vertexArray[4*i+3] = f2vt(lines[i].y2());
+                    vertexArray[4*i]   = lines[i].x1();
+                    vertexArray[4*i+1] = lines[i].y1();
+                    vertexArray[4*i+2] = lines[i].x2();
+                    vertexArray[4*i+3] = lines[i].y2();
+                }
                 glEnableClientState(GL_VERTEX_ARRAY);
                 glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray.constData());
+                glVertexPointer(2, GL_FLOAT, 0, vertexArray.constData());
                 glDrawArrays(GL_LINES, 0, lineCount*2);
                 glVertexPointer(2, q_vertexTypeEnum, 4*sizeof(q_vertexType), vertexArray.constData() + 2);
+                glVertexPointer(2, GL_FLOAT, 4*sizeof(GLfloat), vertexArray.constData() + 2);
                 glDrawArrays(GL_POINTS, 0, lineCount);
 …
             else {
                 Q_ASSERT(sizeof(QPointF) == 8);
                 glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray);
+                glVertexPointer(2, GL_FLOAT, 0, vertexArray);
+            }
 …
         if (d->has_fast_pen && !d->high_quality_antialiasing) {
             d->setGradientOps(d->cpen.brush(), bounds);
             QVarLengthArray<q_vertexType> vertexArray(pointCount*2 + 2);
             glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray.constData());
+            QVarLengthArray<GLfloat> vertexArray(pointCount*2 + 2);
+            glVertexPointer(2, GL_FLOAT, 0, vertexArray.constData());
             int i;
             for (i=0; i<pointCount; ++i) {
                 vertexArray[i*2] = f2vt(points[i].x());
                 vertexArray[i*2+1] = f2vt(points[i].y());
+                vertexArray[i*2] = points[i].x();
+                vertexArray[i*2+1] = points[i].y();
+            }
 …
+}
 extern bool qt_scaleForTransform(const QTransform &transform, qreal *scale); // qtransform.cpp
+Q_GUI_EXPORT bool qt_scaleForTransform(const QTransform &transform, qreal *scale); // qtransform.cpp
 void QOpenGLPaintEnginePrivate::strokePath(const QPainterPath &path, bool use_cache)
 …
         case QPainterPath::MoveToElement:
             if (i != 0) {
                 glVertexPointer(2, q_vertexTypeEnum, 0, tess_points.data());
+                glVertexPointer(2, GL_FLOAT, 0, tess_points.data());
                 glDrawArrays(GL_LINE_STRIP, 0, tess_points.size());
                 tess_points.reset();
 …
         } // end of switch
+    }
     glVertexPointer(2, q_vertexTypeEnum, 0, tess_points.data());
+    glVertexPointer(2, GL_FLOAT, 0, tess_points.data());
     glDrawArrays(GL_LINE_STRIP, 0, tess_points.size());
     glDisableClientState(GL_VERTEX_ARRAY);
 …
+        }
         q_vertexType vertexArray[4*2];
         q_vertexType texCoordArray[4*2];
+        GLfloat vertexArray[4*2];
+        GLfloat texCoordArray[4*2];
         double offset_x = offset.x() / pm.width();
 …
                                   tc_w + offset_x, tc_h + offset_y, texCoordArray);
         glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray);
         glTexCoordPointer(2, q_vertexTypeEnum, 0, texCoordArray);
+        glVertexPointer(2, GL_FLOAT, 0, vertexArray);
+        glTexCoordPointer(2, GL_FLOAT, 0, texCoordArray);
         glEnableClientState(GL_VERTEX_ARRAY);
 …
+    }
     q_vertexType vertexArray[4*2];
     q_vertexType texCoordArray[4*2];
+    GLfloat vertexArray[4*2];
+    GLfloat texCoordArray[4*2];
     qt_add_rect_to_array(r, vertexArray);
     qt_add_texcoords_to_array(x1, y2, x2, y1, texCoordArray);
     glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray);
     glTexCoordPointer(2, q_vertexTypeEnum, 0, texCoordArray);
+    glVertexPointer(2, GL_FLOAT, 0, vertexArray);
+    glTexCoordPointer(2, GL_FLOAT, 0, texCoordArray);
     glEnableClientState(GL_VERTEX_ARRAY);
 …
     ~QGLGlyphCache();
     QGLGlyphCoord *lookup(QFontEngine *, glyph_t);
     void cacheGlyphs(QGLContext *, const QTextItemInt &, const QVarLengthArray<glyph_t> &);
+    void cacheGlyphs(QGLContext *, QFontEngine *, glyph_t *glyphs, int numGlyphs);
     void cleanCache();
     void allocTexture(int width, int height, GLuint texture);
 …
 #endif
 void QGLGlyphCache::cacheGlyphs(QGLContext *context, const QTextItemInt &ti,
                                 const QVarLengthArray<glyph_t> &glyphs)
+void QGLGlyphCache::cacheGlyphs(QGLContext *context, QFontEngine *fontEngine,
+                                glyph_t *glyphs, int numGlyphs)
+{
     QGLContextHash::const_iterator dev_it = qt_context_cache.constFind(context);
 …
 //         qDebug() << "new context" << context << font_cache;
         qt_context_cache.insert(context, font_cache);
+        if (context->isValid() && context->device()->devType() == QInternal::Widget) {
+            QWidget *widget = static_cast<QWidget *>(context->device());
+            connect(widget, SIGNAL(destroyed(QObject*)), SLOT(widgetDestroyed(QObject*)));
+        if (context->isValid()) {
+            if (context->device()->devType() == QInternal::Widget) {
+                QWidget *widget = static_cast<QWidget *>(context->device());
+                connect(widget, SIGNAL(destroyed(QObject*)), SLOT(widgetDestroyed(QObject*)));
+            }
             connect(QGLSignalProxy::instance(),
                     SIGNAL(aboutToDestroyContext(const QGLContext*)),
 …
     Q_ASSERT(font_cache != 0);
     QGLFontGlyphHash::const_iterator cache_it = font_cache->constFind(ti.fontEngine);
+    QGLFontGlyphHash::const_iterator cache_it = font_cache->constFind(fontEngine);
     QGLGlyphHash *cache = 0;
     if (cache_it == font_cache->constEnd()) {
         cache = new QGLGlyphHash;
         font_cache->insert(ti.fontEngine, cache);
         connect(ti.fontEngine, SIGNAL(destroyed(QObject*)), SLOT(fontEngineDestroyed(QObject*)));
+        font_cache->insert(fontEngine, cache);
+        connect(fontEngine, SIGNAL(destroyed(QObject*)), SLOT(fontEngineDestroyed(QObject*)));
     } else {
         cache = cache_it.value();
 …
     quint64 font_key = (reinterpret_cast<quint64>(context_key ? context_key : context) << 32)
                        | reinterpret_cast<quint64>(ti.fontEngine);
+                       | reinterpret_cast<quint64>(fontEngine);
     QGLFontTexHash::const_iterator it = qt_font_textures.constFind(font_key);
     QGLFontTexture *font_tex;
 …
         GLuint font_texture;
         glGenTextures(1, &font_texture);
         GLint tex_height = qt_next_power_of_two(qRound(ti.ascent.toReal() + ti.descent.toReal())+2);
+        GLint tex_height = qt_next_power_of_two(qRound(fontEngine->ascent().toReal() + fontEngine->descent().toReal())+2);
         GLint tex_width = qt_next_power_of_two(tex_height*30); // ###
         GLint max_tex_size;
 …
+    }
     for (int i=0; i< glyphs.size(); ++i) {
+    for (int i=0; i< numGlyphs; ++i) {
         QGLGlyphHash::const_iterator it = cache->constFind(glyphs[i]);
         if (it == cache->constEnd()) {
             // render new glyph and put it in the cache
             glyph_metrics_t metrics = ti.fontEngine->boundingBox(glyphs[i]);
+            glyph_metrics_t metrics = fontEngine->boundingBox(glyphs[i]);
             int glyph_width = qRound(metrics.width.toReal())+2;
             int glyph_height = qRound(ti.ascent.toReal() + ti.descent.toReal())+2;
+            int glyph_height = qRound(fontEngine->ascent().toReal() + fontEngine->descent().toReal())+2;
             if (font_tex->x_offset + glyph_width + x_margin > font_tex->width) {
                 int strip_height = qt_next_power_of_two(qRound(ti.ascent.toReal() + ti.descent.toReal())+2);
+                int strip_height = qt_next_power_of_two(qRound(fontEngine->ascent().toReal() + fontEngine->descent().toReal())+2);
                 font_tex->x_offset = x_margin;
                 font_tex->y_offset += strip_height;
 …
+            }
             QImage glyph_im(ti.fontEngine->alphaMapForGlyph(glyphs[i]));
+            QImage glyph_im(fontEngine->alphaMapForGlyph(glyphs[i]));
             glyph_im = glyph_im.convertToFormat(QImage::Format_Indexed8);
             glyph_width = glyph_im.width();
 …
+}
+void QOpenGLPaintEngine::drawStaticTextItem(QStaticTextItem *textItem)
+{
+    Q_D(QOpenGLPaintEngine);
+    d->flushDrawQueue();
+    // make sure the glyphs we want to draw are in the cache
+    qt_glyph_cache()->cacheGlyphs(d->device->context(), textItem->fontEngine(), textItem->glyphs,
+                                  textItem->numGlyphs);
+    d->setGradientOps(Qt::SolidPattern, QRectF()); // turns off gradient ops
+    qt_glColor4ubv(d->pen_color);
+    glEnable(GL_TEXTURE_2D);
+#ifdef Q_WS_QWS
+    // XXX: it is necessary to disable alpha writes on GLES/embedded because we don't want
+    // text rendering to update the alpha in the window surface.
+    // XXX: This may not be needed as this behavior does seem to be caused by driver bug
+    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE);
+#endif
+    // do the actual drawing
+    GLfloat vertexArray[4*2];
+    GLfloat texCoordArray[4*2];
+    glVertexPointer(2, GL_FLOAT, 0, vertexArray);
+    glTexCoordPointer(2, GL_FLOAT, 0, texCoordArray);
+    glEnableClientState(GL_VERTEX_ARRAY);
+    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+    bool antialias = !(textItem->fontEngine()->fontDef.styleStrategy & QFont::NoAntialias)
+                                   && (d->matrix.type() > QTransform::TxTranslate);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, antialias ? GL_LINEAR : GL_NEAREST);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, antialias ? GL_LINEAR : GL_NEAREST);
+    for (int i=0; i< textItem->numGlyphs; ++i) {
+        QGLGlyphCoord *g = qt_glyph_cache()->lookup(textItem->fontEngine(), textItem->glyphs[i]);
+        // we don't cache glyphs with no width/height
+        if (!g)
+            continue;
+        qreal x1, x2, y1, y2;
+        x1 = g->x;
+        y1 = g->y;
+        x2 = x1 + g->width;
+        y2 = y1 + g->height;
+        QPointF logical_pos((textItem->glyphPositions[i].x - g->x_offset).toReal(),
+                            (textItem->glyphPositions[i].y + g->y_offset).toReal());
+        qt_add_rect_to_array(QRectF(logical_pos, QSizeF(g->log_width, g->log_height)), vertexArray);
+        qt_add_texcoords_to_array(x1, y1, x2, y2, texCoordArray);
+        glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+    }
+    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+    glDisableClientState(GL_VERTEX_ARRAY);
+    glDisable(GL_TEXTURE_2D);
+#ifdef Q_WS_QWS
+    // XXX: This may not be needed as this behavior does seem to be caused by driver bug
+    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+#endif
+}
 void QOpenGLPaintEngine::drawTextItem(const QPointF &p, const QTextItem &textItem)
+{
 …
+    }
-    d->flushDrawQueue();
     // add the glyphs used to the glyph texture cache
     QVarLengthArray<QFixedPoint> positions;
 …
     ti.fontEngine->getGlyphPositions(ti.glyphs, matrix, ti.flags, glyphs, positions);
+    // make sure the glyphs we want to draw are in the cache
+    qt_glyph_cache()->cacheGlyphs(d->device->context(), ti, glyphs);
+    d->setGradientOps(Qt::SolidPattern, QRectF()); // turns off gradient ops
+    qt_glColor4ubv(d->pen_color);
+    glEnable(GL_TEXTURE_2D);
+#ifdef Q_WS_QWS
+    // XXX: it is necessary to disable alpha writes on GLES/embedded because we don't want
+    // text rendering to update the alpha in the window surface.
+    // XXX: This may not be needed as this behavior does seem to be caused by driver bug
+    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE);
+#endif
+    // do the actual drawing
+    q_vertexType vertexArray[4*2];
+    q_vertexType texCoordArray[4*2];
+    glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray);
+    glTexCoordPointer(2, q_vertexTypeEnum, 0, texCoordArray);
+    glEnableClientState(GL_VERTEX_ARRAY);
+    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+    bool antialias = !(ti.fontEngine->fontDef.styleStrategy & QFont::NoAntialias)
+                   && (d->matrix.type() > QTransform::TxTranslate);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, antialias ? GL_LINEAR : GL_NEAREST);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, antialias ? GL_LINEAR : GL_NEAREST);
+    for (int i=0; i< glyphs.size(); ++i) {
+        QGLGlyphCoord *g = qt_glyph_cache()->lookup(ti.fontEngine, glyphs[i]);
+        // we don't cache glyphs with no width/height
+        if (!g)
+            continue;
+        qreal x1, x2, y1, y2;
+        x1 = g->x;
+        y1 = g->y;
+        x2 = x1 + g->width;
+        y2 = y1 + g->height;
+        QPointF logical_pos((positions[i].x - g->x_offset).toReal(),
+                            (positions[i].y + g->y_offset).toReal());
+        qt_add_rect_to_array(QRectF(logical_pos, QSizeF(g->log_width, g->log_height)), vertexArray);
+        qt_add_texcoords_to_array(x1, y1, x2, y2, texCoordArray);
+        glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+    }
+    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+    glDisableClientState(GL_VERTEX_ARRAY);
+    glDisable(GL_TEXTURE_2D);
+#ifdef Q_WS_QWS
+    // XXX: This may not be needed as this behavior does seem to be caused by driver bug
+    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+#endif
+    {
+        QStaticTextItem staticTextItem;
+        staticTextItem.chars = const_cast<QChar *>(ti.chars);
+        staticTextItem.setFontEngine(ti.fontEngine);
+        staticTextItem.glyphs = glyphs.data();
+        staticTextItem.numChars = ti.num_chars;
+        staticTextItem.numGlyphs = glyphs.size();
+        staticTextItem.glyphPositions = positions.data();
+        drawStaticTextItem(&staticTextItem);
+    }
+}
 …
     Q_UNUSED(maskOffset);
 #else
     q_vertexType vertexArray[8];
+    GLfloat vertexArray[8];
     qt_add_rect_to_array(rect, vertexArray);
 …
 void QOpenGLPaintEnginePrivate::composite(GLuint primitive, const q_vertexType *vertexArray, int vertexCount, const QPoint &maskOffset)
+void QOpenGLPaintEnginePrivate::composite(GLuint primitive, const GLfloat *vertexArray, int vertexCount, const QPoint &maskOffset)
+{
 #ifdef QT_OPENGL_ES
 …
         for (int i = 0; i < vertexCount; ++i) {
             qreal x = vt2f(vertexArray[2 * i]);
             qreal y = vt2f(vertexArray[2 * i + 1]);
+            qreal x = vertexArray[2 * i];
+            qreal y = vertexArray[2 * i + 1];
             qreal tx, ty;
 …
     glEnableClientState(GL_VERTEX_ARRAY);
     glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray);
+    glVertexPointer(2, GL_FLOAT, 0, vertexArray);
     glEnable(GL_FRAGMENT_PROGRAM_ARB);
     GLuint program = qt_gl_program_cache()->getProgram(device->context(),

trunk/src/opengl/qpaintengine_opengl_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
                    Qt::ImageConversionFlags conversionFlags);
     void drawTextItem(const QPointF &p, const QTextItem &ti);
+    void drawStaticTextItem(QStaticTextItem *staticTextItem);
     void drawEllipse(const QRectF &rect);

trunk/src/opengl/qpixmapdata_gl.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 void QGLPixmapData::fromImage(const QImage &image,
                               Qt::ImageConversionFlags /*flags*/)
+                              Qt::ImageConversionFlags flags)
+{
     if (image.size() == QSize(w, h))
 …
             format = QImage::Format_RGB16;
+        if (image.hasAlphaChannel() && const_cast<QImage &>(image).data_ptr()->checkForAlphaPixels())
+        if (image.hasAlphaChannel()
+            && ((flags & Qt::NoOpaqueDetection)
+                || const_cast<QImage &>(image).data_ptr()->checkForAlphaPixels()))
             format = QImage::Format_ARGB32_Premultiplied;;
 …
 void QGLPixmapData::copy(const QPixmapData *data, const QRect &rect)
+{
     if (data->classId() != QPixmapData::OpenGLClass) {
+    if (data->classId() != QPixmapData::OpenGLClass || !static_cast<const QGLPixmapData *>(data)->useFramebufferObjects()) {
         QPixmapData::copy(data, rect);
         return;
+    }
+    // can be optimized to do a framebuffer blit or similar ...
+    QPixmapData::copy(data, rect);
+    const QGLPixmapData *other = static_cast<const QGLPixmapData *>(data);
+    if (other->m_renderFbo) {
+        QGLShareContextScope ctx(qt_gl_share_widget()->context());
+        resize(rect.width(), rect.height());
+        m_hasAlpha = other->m_hasAlpha;
+        ensureCreated();
+        if (!ctx->d_ptr->fbo)
+            glGenFramebuffers(1, &ctx->d_ptr->fbo);
+        glBindFramebuffer(GL_DRAW_FRAMEBUFFER_EXT, ctx->d_ptr->fbo);
+        glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
+                GL_TEXTURE_2D, m_texture.id, 0);
+        if (!other->m_renderFbo->isBound())
+            glBindFramebuffer(GL_READ_FRAMEBUFFER_EXT, other->m_renderFbo->handle());
+        glDisable(GL_SCISSOR_TEST);
+        if (ctx->d_ptr->active_engine && ctx->d_ptr->active_engine->type() == QPaintEngine::OpenGL2)
+            static_cast<QGL2PaintEngineEx *>(ctx->d_ptr->active_engine)->invalidateState();
+        glBlitFramebufferEXT(rect.x(), rect.y(), rect.x() + rect.width(), rect.y() + rect.height(),
+, 0, w, h,
+                GL_COLOR_BUFFER_BIT,
+                GL_NEAREST);
+        glBindFramebuffer(GL_FRAMEBUFFER_EXT, ctx->d_ptr->current_fbo);
+    } else {
+        QPixmapData::copy(data, rect);
+    }
+}
 …
+}
 bool QGLPixmapData::useFramebufferObjects()
+bool QGLPixmapData::useFramebufferObjects() const
+{
     return QGLFramebufferObject::hasOpenGLFramebufferObjects()
            && QGLFramebufferObject::hasOpenGLFramebufferBlit()
+           && qt_gl_preferGL2Engine();
+           && qt_gl_preferGL2Engine()
+           && (w * h > 32*32); // avoid overhead of FBOs for small pixmaps
+}
 …
+}
 extern int qt_defaultDpiX();
 extern int qt_defaultDpiY();
+Q_DECL_IMPORT extern int qt_defaultDpiX();
+Q_DECL_IMPORT extern int qt_defaultDpiY();
 int QGLPixmapData::metric(QPaintDevice::PaintDeviceMetric metric) const

trunk/src/opengl/qpixmapdata_gl_p.h

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 class QGLPixmapData : public QPixmapData
+class Q_OPENGL_EXPORT QGLPixmapData : public QPixmapData
+{
 public:
 …
     QSize size() const { return QSize(w, h); }
     static bool useFramebufferObjects();
+    bool useFramebufferObjects() const;
     QImage fillImage(const QColor &color) const;
 …
     friend class QGLPixmapGLPaintDevice;
+    friend class QMeeGoPixmapData;
+    friend class QMeeGoLivePixmapData;
 };

trunk/src/opengl/qpixmapdata_x11gl_egl.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #include <QDebug>
+#include <private/qgl_p.h>
+#include <private/qegl_p.h>
+#include <private/qeglproperties_p.h>
+#if !defined(QT_OPENGL_ES_1) && !defined(QT_OPENGL_ES_1_CL)
+#include <private/qpaintengineex_opengl2_p.h>
+#include <QtGui/private/qt_x11_p.h>
+#include <QtGui/private/qegl_p.h>
+#include <QtGui/private/qeglproperties_p.h>
+#include <QtGui/private/qeglcontext_p.h>
+#if !defined(QT_OPENGL_ES_1)
+#include <QtOpenGL/private/qpaintengineex_opengl2_p.h>
 #endif
 #ifndef QT_OPENGL_ES_2
+#include <private/qpaintengine_opengl_p.h>
+#endif
+#include <QtOpenGL/private/qpaintengine_opengl_p.h>
+#endif
+#include <QtOpenGL/private/qgl_p.h>
+#include <QtOpenGL/private/qgl_egl_p.h>
 #include "qpixmapdata_x11gl_p.h"
 …
 QT_BEGIN_NAMESPACE
+extern EGLConfig qt_chooseEGLConfigForPixmap(bool hasAlpha, bool readOnly); // in qgl_x11egl.cpp
+extern bool qt_createEGLSurfaceForPixmap(QPixmapData* pmd, bool readOnly); // in qgl_x11egl.cpp
+// On 16bpp systems, RGB & ARGB pixmaps are different bit-depths and therefore need
+// different contexts:
+static EGLContext qPixmapARGBSharedEglContext = EGL_NO_CONTEXT;
+static EGLContext qPixmapRGBSharedEglContext = EGL_NO_CONTEXT;
+bool QX11GLPixmapData::hasX11GLPixmaps()
+{
+    static bool checkedForX11Pixmaps = false;
+    static bool haveX11Pixmaps = false;
+    if (checkedForX11Pixmaps)
+        return haveX11Pixmaps;
+    checkedForX11Pixmaps = true;
+    QX11PixmapData *argbPixmapData = 0;
+    QX11PixmapData *rgbPixmapData = 0;
+    do {
+        if (qgetenv("QT_USE_X11GL_PIXMAPS").isEmpty())
+            break;
+        // Check we actually have EGL configs which support pixmaps
+        EGLConfig argbConfig = qt_chooseEGLConfigForPixmap(true, false);
+        EGLConfig rgbConfig = qt_chooseEGLConfigForPixmap(false, false);
+        if (argbConfig == 0 || rgbConfig == 0)
+            break;
+        // Create the shared contexts:
+        eglBindAPI(EGL_OPENGL_ES_API);
+        EGLint contextAttribs[] = {
+#if defined(QT_OPENGL_ES_2)
+            EGL_CONTEXT_CLIENT_VERSION, 2,
+#endif
+            EGL_NONE
+        };
+        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::display(),
+                                                           rgbConfig, 0, contextAttribs);
+        }
+        argbPixmapData = new QX11PixmapData(QPixmapData::PixmapType);
+        argbPixmapData->resize(100, 100);
+        argbPixmapData->fill(Qt::transparent); // Force ARGB
+        if (!qt_createEGLSurfaceForPixmap(argbPixmapData, false))
+            break;
+        haveX11Pixmaps = eglMakeCurrent(QEglContext::display(),
+                                        (EGLSurface)argbPixmapData->gl_surface,
+                                        (EGLSurface)argbPixmapData->gl_surface,
+                                        qPixmapARGBSharedEglContext);
+        if (!haveX11Pixmaps) {
+            EGLint err = eglGetError();
+            qWarning() << "Unable to make pixmap config current:" << err << QEglContext::errorString(err);
+            break;
+        }
+        // If the ARGB & RGB configs are the same, we don't need to check RGB too
+        if (haveX11Pixmaps && (argbConfig != rgbConfig)) {
+            rgbPixmapData = new QX11PixmapData(QPixmapData::PixmapType);
+            rgbPixmapData->resize(100, 100);
+class QX11GLSharedContexts
+{
+public:
+    QX11GLSharedContexts()
+        : rgbContext(0)
+        , argbContext(0)
+        , sharedQGLContext(0)
+        , sharePixmap(0)
+    {
+        EGLint rgbConfigId;
+        EGLint argbConfigId;
+        do {
+            EGLConfig rgbConfig = QEgl::defaultConfig(QInternal::Pixmap, QEgl::OpenGL, QEgl::Renderable);
+            EGLConfig argbConfig = QEgl::defaultConfig(QInternal::Pixmap, QEgl::OpenGL,
+                                                       QEgl::Renderable | QEgl::Translucent);
+            eglGetConfigAttrib(QEgl::display(), rgbConfig, EGL_CONFIG_ID, &rgbConfigId);
+            eglGetConfigAttrib(QEgl::display(), argbConfig, EGL_CONFIG_ID, &argbConfigId);
+            rgbContext = new QEglContext;
+            rgbContext->setConfig(rgbConfig);
+            rgbContext->createContext();
+            if (!rgbContext->isValid())
+                break;
+            // If the RGB & ARGB configs are the same, use the same egl context for both:
+            if (rgbConfig == argbConfig)
+                argbContext = rgbContext;
+            // Otherwise, create a separate context to be used for ARGB pixmaps:
+            if (!argbContext) {
+                argbContext = new QEglContext;
+                argbContext->setConfig(argbConfig);
+                bool success = argbContext->createContext(rgbContext);
+                if (!success) {
+                    qWarning("QX11GLPixmapData - RGB & ARGB contexts aren't shared");
+                    success = argbContext->createContext();
+                    if (!success)
+                        argbContext = rgbContext; // Might work, worth a shot at least.
+                }
+            }
+            if (!argbContext->isValid())
+                break;
+            // Create the pixmap which will be used to create the egl surface for the share QGLContext
+            QX11PixmapData *rgbPixmapData = new QX11PixmapData(QPixmapData::PixmapType);
+            rgbPixmapData->resize(8, 8);
             rgbPixmapData->fill(Qt::red);
+            // Try to actually create an EGL pixmap surface
+            if (!qt_createEGLSurfaceForPixmap(rgbPixmapData, false))
+                break;
+            haveX11Pixmaps = eglMakeCurrent(QEglContext::display(),
+                                            (EGLSurface)rgbPixmapData->gl_surface,
+                                            (EGLSurface)rgbPixmapData->gl_surface,
+                                            qPixmapRGBSharedEglContext);
+            if (!haveX11Pixmaps) {
+                EGLint err = eglGetError();
+                qWarning() << "Unable to make pixmap config current:" << err << QEglContext::errorString(err);
+            sharePixmap = new QPixmap(rgbPixmapData);
+            EGLSurface sharePixmapSurface = QEgl::createSurface(sharePixmap, rgbConfig);
+            rgbPixmapData->gl_surface = (void*)sharePixmapSurface;
+            // Create the actual QGLContext which will be used for sharing
+            sharedQGLContext = new QGLContext(QX11GLPixmapData::glFormat());
+            sharedQGLContext->d_func()->eglContext = rgbContext;
+            sharedQGLContext->d_func()->eglSurface = sharePixmapSurface;
+            sharedQGLContext->d_func()->valid = true;
+            qt_glformat_from_eglconfig(sharedQGLContext->d_func()->glFormat, rgbConfig);
+            valid = rgbContext->makeCurrent(sharePixmapSurface);
+            // If the ARGB & RGB configs are different, check ARGB works too:
+            if (argbConfig != rgbConfig) {
+                QX11PixmapData *argbPixmapData = new QX11PixmapData(QPixmapData::PixmapType);
+                argbPixmapData->resize(8, 8);
+                argbPixmapData->fill(Qt::transparent); // Force ARGB
+                QPixmap argbPixmap(argbPixmapData); // destroys pixmap data when goes out of scope
+                EGLSurface argbPixmapSurface = QEgl::createSurface(&argbPixmap, argbConfig);
+                valid = argbContext->makeCurrent(argbPixmapSurface);
+                argbContext->doneCurrent();
+                eglDestroySurface(QEgl::display(), argbPixmapSurface);
+                argbPixmapData->gl_surface = 0;
+            }
+            if (!valid) {
+                qWarning() << "Unable to make pixmap surface current:" << QEgl::errorString();
                 break;
+            }
+            // The pixmap surface destruction hooks are installed by QGLTextureCache, so we
+            // must make sure this is instanciated:
+            QGLTextureCache::instance();
+        } while(0);
+        if (!valid)
+            cleanup();
+        else
+            qDebug("Using QX11GLPixmapData with EGL config %d for ARGB and config %d for RGB", argbConfigId, rgbConfigId);
+    }
+    ~QX11GLSharedContexts() {
+        cleanup();
+    }
+    void cleanup() {
+        if (sharedQGLContext) {
+            delete sharedQGLContext;
+            sharedQGLContext = 0;
+        }
+    } while (0);
+    if (qPixmapARGBSharedEglContext || qPixmapRGBSharedEglContext) {
+        eglMakeCurrent(QEglContext::display(),
+                       EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+    }
+    if (argbPixmapData) {
+        if (argbPixmapData->gl_surface)
+            QGLContextPrivate::destroyGlSurfaceForPixmap(argbPixmapData);
+        delete argbPixmapData;
+        argbPixmapData = 0;
+    }
+    if (rgbPixmapData) {
+        if (rgbPixmapData->gl_surface)
+            QGLContextPrivate::destroyGlSurfaceForPixmap(rgbPixmapData);
+        delete rgbPixmapData;
+        rgbPixmapData = 0;
+    }
+    if (!haveX11Pixmaps) {
+        // Clean up the context(s) if we can't use X11GL pixmaps
+        if (qPixmapARGBSharedEglContext != EGL_NO_CONTEXT)
+            eglDestroyContext(QEglContext::display(), qPixmapARGBSharedEglContext);
+        if (qPixmapRGBSharedEglContext != qPixmapARGBSharedEglContext &&
+            qPixmapRGBSharedEglContext != EGL_NO_CONTEXT)
+        {
+            eglDestroyContext(QEglContext::display(), qPixmapRGBSharedEglContext);
+        if (argbContext && argbContext != rgbContext)
+            delete argbContext;
+        argbContext = 0;
+        if (rgbContext) {
+            delete rgbContext;
+            rgbContext = 0;
+        }
+        qPixmapRGBSharedEglContext = EGL_NO_CONTEXT;
+        qPixmapARGBSharedEglContext = EGL_NO_CONTEXT;
+    }
+    if (haveX11Pixmaps)
+        qDebug("QX11GLPixmapData is supported");
+    else
+        qDebug("QX11GLPixmapData is *NOT* being used");
+    return haveX11Pixmaps;
+        // Deleting the QPixmap will fire the pixmap destruction cleanup hooks which in turn
+        // will destroy the egl surface:
+        if (sharePixmap) {
+            delete sharePixmap;
+            sharePixmap = 0;
+        }
+    }
+    bool isValid() { return valid;}
+    // On 16bpp systems, RGB & ARGB pixmaps are different bit-depths and therefore need
+    // different contexts:
+    QEglContext *rgbContext;
+    QEglContext *argbContext;
+    // The share context wraps the rgbContext and is used as the master of the context share
+    // group. As all other contexts will have the same egl context (or a shared one if rgb != argb)
+    // all QGLContexts will actually be sharing and can be in the same context group.
+    QGLContext  *sharedQGLContext;
+private:
+    QPixmap     *sharePixmap;
+    bool         valid;
+};
+static void qt_cleanup_x11gl_share_contexts();
+Q_GLOBAL_STATIC_WITH_INITIALIZER(QX11GLSharedContexts, qt_x11gl_share_contexts,
+                                 {
+                                     qAddPostRoutine(qt_cleanup_x11gl_share_contexts);
+                                 })
+static void qt_cleanup_x11gl_share_contexts()
+{
+    qt_x11gl_share_contexts()->cleanup();
+}
+QX11GLSharedContexts* QX11GLPixmapData::sharedContexts()
+{
+    return qt_x11gl_share_contexts();
+}
+bool QX11GLPixmapData::hasX11GLPixmaps()
+{
+    static bool checkedForX11GLPixmaps = false;
+    static bool haveX11GLPixmaps = false;
+    if (checkedForX11GLPixmaps)
+        return haveX11GLPixmaps;
+    haveX11GLPixmaps = qt_x11gl_share_contexts()->isValid();
+    checkedForX11GLPixmaps = true;
+    return haveX11GLPixmaps;
+}
 …
 QX11GLPixmapData::~QX11GLPixmapData()
+{
+}
+#if !defined(QT_OPENGL_ES_1) && !defined(QT_OPENGL_ES_1_CL)
+    if (ctx)
+        delete ctx;
+}
+void QX11GLPixmapData::fill(const QColor &color)
+{
+    if (ctx) {
+        ctx->makeCurrent();
+        glFinish();
+        eglWaitClient();
+    }
+    QX11PixmapData::fill(color);
+    XSync(X11->display, False);
+    if (ctx) {
+        ctx->makeCurrent();
+        eglWaitNative(EGL_CORE_NATIVE_ENGINE);
+    }
+}
+void QX11GLPixmapData::copy(const QPixmapData *data, const QRect &rect)
+{
+    if (ctx) {
+        ctx->makeCurrent();
+        glFinish();
+        eglWaitClient();
+    }
+    QX11PixmapData::copy(data, rect);
+    XSync(X11->display, False);
+    if (ctx) {
+        ctx->makeCurrent();
+        eglWaitNative(EGL_CORE_NATIVE_ENGINE);
+    }
+}
+bool QX11GLPixmapData::scroll(int dx, int dy, const QRect &rect)
+{
+    if (ctx) {
+        ctx->makeCurrent();
+        glFinish();
+        eglWaitClient();
+    }
+    bool success = QX11PixmapData::scroll(dx, dy, rect);
+    XSync(X11->display, False);
+    if (ctx) {
+        ctx->makeCurrent();
+        eglWaitNative(EGL_CORE_NATIVE_ENGINE);
+    }
+    return success;
+}
+#if !defined(QT_OPENGL_ES_1)
 Q_GLOBAL_STATIC(QGL2PaintEngineEx, qt_gl_pixmap_2_engine)
 #endif
 …
     if (!ctx) {
         ctx = new QGLContext(glFormat());
+        if (ctx->d_func()->eglContext == 0)
+            ctx->d_func()->eglContext = new QEglContext();
+        ctx->d_func()->eglContext->setApi(QEgl::OpenGL);
+        ctx->d_func()->eglContext->setContext(hasAlphaChannel() ? qPixmapARGBSharedEglContext
+                                                                : qPixmapRGBSharedEglContext);
+        Q_ASSERT(ctx->d_func()->eglContext == 0);
+        ctx->d_func()->eglContext = hasAlphaChannel() ? sharedContexts()->argbContext : sharedContexts()->rgbContext;
+        // While we use a separate QGLContext for each pixmap, the underlying QEglContext is
+        // the same. So we must use a "fake" QGLContext and fool the texture cache into thinking
+        // each pixmap's QGLContext is sharing with this central one. The only place this is
+        // going to fail is where we the underlying EGL RGB and ARGB contexts aren't sharing.
+        ctx->d_func()->sharing = true;
+        QGLContextGroup::addShare(ctx, sharedContexts()->sharedQGLContext);
+        // Update the glFormat for the QGLContext:
+        qt_glformat_from_eglconfig(ctx->d_func()->glFormat, ctx->d_func()->eglContext->config());
+    }
     QPaintEngine* engine;
 #if defined(QT_OPENGL_ES_1) || defined(QT_OPENGL_ES_1_CL)
+#if defined(QT_OPENGL_ES_1)
     engine = qt_gl_pixmap_engine();
 #elif defined(QT_OPENGL_ES_2)
 …
         qWarning("Pixmap paint engine already active");
 #if defined(QT_OPENGL_ES_1) || defined(QT_OPENGL_ES_1_CL)
+#if defined(QT_OPENGL_ES_1)
         engine = new QOpenGLPaintEngine;
 #elif defined(QT_OPENGL_ES_2)
 …
+{
 //    qDebug("QX11GLPixmapData::beginPaint()");
+    // TODO: Check to see if the surface is renderable
     if ((EGLSurface)gl_surface == EGL_NO_SURFACE) {
+        qt_createEGLSurfaceForPixmap(this, false);
+        ctx->d_func()->eglSurface = (EGLSurface)gl_surface;
+        ctx->d_func()->valid = true; // ;-)
+        QPixmap tmpPixmap(this);
+        EGLConfig cfg = ctx->d_func()->eglContext->config();
+        Q_ASSERT(cfg != QEGL_NO_CONFIG);
+//        qDebug("QX11GLPixmapData - using EGL Config ID %d", ctx->d_func()->eglContext->configAttrib(EGL_CONFIG_ID));
+        EGLSurface surface = QEgl::createSurface(&tmpPixmap, cfg);
+        if (surface == EGL_NO_SURFACE) {
+            qWarning() << "Error creating EGL surface for pixmap:" << QEgl::errorString();
+            return;
+        }
+        gl_surface = (void*)surface;
+        ctx->d_func()->eglSurface = surface;
+        ctx->d_func()->valid = true;
+    }
     QGLPaintDevice::beginPaint();
+}
-void QX11GLPixmapData::endPaint()
+{
-    glFinish();
-    QGLPaintDevice::endPaint();
+}
 QGLContext* QX11GLPixmapData::context() const
+{

trunk/src/opengl/qpixmapdata_x11gl_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #include <qgl.h>
+#ifndef QT_NO_EGL
+#include <QtGui/private/qeglcontext_p.h>
+#endif
 QT_BEGIN_NAMESPACE
+class QX11GLSharedContexts;
 class QX11GLPixmapData : public QX11PixmapData, public QGLPaintDevice
 …
     virtual ~QX11GLPixmapData();
+    // Re-implemented from QX11PixmapData:
+    void fill(const QColor &color);
+    void copy(const QPixmapData *data, const QRect &rect);
+    bool scroll(int dx, int dy, const QRect &rect);
     // Re-implemented from QGLPaintDevice
     QPaintEngine* paintEngine() const; // Also re-implements QX11PixmapData::paintEngine
     void beginPaint();
-    void endPaint();
     QGLContext* context() const;
     QSize size() const;
 …
     static bool hasX11GLPixmaps();
     static QGLFormat glFormat();
+    static QX11GLSharedContexts* sharedContexts();
 private:
     mutable QGLContext* ctx;

trunk/src/opengl/qwindowsurface_gl.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #endif
+#ifdef QT_OPENGL_ES_1_CL
+#include "qgl_cl_p.h"
+#endif
+#ifdef QT_OPENGL_ES
+#include <private/qegl_p.h>
+#ifndef QT_NO_EGL
+#include <private/qeglcontext_p.h>
 #endif
 …
 extern Q_GUI_EXPORT bool qt_win_owndc_required;
 #endif
 QGLGraphicsSystem::QGLGraphicsSystem()
     : QGraphicsSystem()
+QGLGraphicsSystem::QGLGraphicsSystem(bool useX11GL)
+    : QGraphicsSystem(), m_useX11GL(useX11GL)
+{
 #if defined(Q_WS_X11) && !defined(QT_OPENGL_ES)
 …
         if (!initializing && !widget && !cleanedUp) {
             initializing = true;
+            widget = new QGLWidget;
+            // We dont need this internal widget to appear in QApplication::topLevelWidgets()
+            widget = new QGLWidget(QGLFormat(QGL::SingleBuffer | QGL::NoDepthBuffer | QGL::NoStencilBuffer));
+            widget->resize(1, 1);
+            // We don't need this internal widget to appear in QApplication::topLevelWidgets()
             if (QWidgetPrivate::allWidgets)
                 QWidgetPrivate::allWidgets->remove(widget);
 …
+    }
+    // destroys the share widget and prevents recreation
     void cleanup() {
         QGLWidget *w = widget;
 …
+    }
+    // destroys the share widget, but allows it to be recreated later on
+    void destroy() {
+        if (cleanedUp)
+            return;
+        QGLWidget *w = widget;
+        // prevent potential recursions
+        cleanedUp = true;
+        widget = 0;
+        delete w;
+        cleanedUp = false;
+    }
     static bool cleanedUp;
 …
+}
+void qt_destroy_gl_share_widget()
+{
+    _qt_gl_share_widget()->destroy();
+}
 struct QGLWindowSurfacePrivate
 …
     int destructive_swap_buffers : 1;
     int geometry_updated : 1;
+    int did_paint : 1;
     QGLContext *ctx;
 …
     QRegion paintedRegion;
     QSize size;
+    QSize textureSize;
     QList<QImage> buffers;
 …
 QGLFormat QGLWindowSurface::surfaceFormat;
+QGLWindowSurface::SwapMode QGLWindowSurface::swapBehavior = QGLWindowSurface::AutomaticSwap;
 void QGLWindowSurfaceGLPaintDevice::endPaint()
 …
     d_ptr->fbo = 0;
     d_ptr->ctx = 0;
+    d_ptr->tex_id = 0;
 #if defined (QT_OPENGL_ES_2)
     d_ptr->tried_fbo = true;
 …
     d_ptr->q_ptr = this;
     d_ptr->geometry_updated = false;
+    d_ptr->did_paint = false;
+}
 …
 void QGLWindowSurface::deleted(QObject *object)
+{
-    // Make sure that the fbo is destroyed before destroying its context.
-    delete d_ptr->fbo;
-    d_ptr->fbo = 0;
     QWidget *widget = qobject_cast<QWidget *>(object);
     if (widget) {
+        if (widget == window()) {
+            // Make sure that the fbo is destroyed before destroying its context.
+            delete d_ptr->fbo;
+            d_ptr->fbo = 0;
+        }
         QWidgetPrivate *widgetPrivate = widget->d_func();
         if (widgetPrivate->extraData()) {
 …
         return;
+    QGLContext *ctx = new QGLContext(surfaceFormat, widget);
+    QGLContext *ctx = NULL;
+    // For translucent top-level widgets we need alpha in the format.
+    if (widget->testAttribute(Qt::WA_TranslucentBackground)) {
+        QGLFormat modFormat(surfaceFormat);
+        modFormat.setSampleBuffers(false);
+        modFormat.setSamples(0);
+        modFormat.setAlpha(true);
+        ctx = new QGLContext(modFormat, widget);
+    } else
+        ctx = new QGLContext(surfaceFormat, widget);
     ctx->create(qt_gl_share_widget()->context());
+#if defined(Q_WS_X11) && defined(QT_OPENGL_ES)
+    // Create the EGL surface to draw into.  QGLContext::chooseContext()
+    // does not do this for X11/EGL, but does do it for other platforms.
+    // This probably belongs in qgl_x11egl.cpp.
+    QGLContextPrivate *ctxpriv = ctx->d_func();
+    ctxpriv->eglSurface = ctxpriv->eglContext->createSurface(widget);
+    if (ctxpriv->eglSurface == EGL_NO_SURFACE) {
+        qWarning() << "hijackWindow() could not create EGL surface";
+    }
+    qDebug("QGLWindowSurface - using EGLConfig %d", reinterpret_cast<int>(ctxpriv->eglContext->config()));
+#ifndef QT_NO_EGL
+    static bool checkedForNOKSwapRegion = false;
+    static bool haveNOKSwapRegion = false;
+    if (!checkedForNOKSwapRegion) {
+        haveNOKSwapRegion = QEgl::hasExtension("EGL_NOK_swap_region2");
+        checkedForNOKSwapRegion = true;
+        if (haveNOKSwapRegion)
+            qDebug() << "Found EGL_NOK_swap_region2 extension. Using partial updates.";
+    }
+    if (ctx->d_func()->eglContext->configAttrib(EGL_SWAP_BEHAVIOR) != EGL_BUFFER_PRESERVED &&
+        ! haveNOKSwapRegion)
+        setPartialUpdateSupport(false); // Force full-screen updates
+    else
+        setPartialUpdateSupport(true);
 #endif
 …
     QGLContext *ctx = reinterpret_cast<QGLContext *>(window()->d_func()->extraData()->glContext);
     ctx->makeCurrent();
+    Q_ASSERT(d_ptr->fbo);
     return d_ptr->fbo;
+}
 …
 void QGLWindowSurface::beginPaint(const QRegion &)
+{
+    if (!context())
+        return;
+    int clearFlags = 0;
+    if (context()->d_func()->workaround_needsFullClearOnEveryFrame)
+        clearFlags = GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT;
+    else if (context()->format().alpha())
+        clearFlags = GL_COLOR_BUFFER_BIT;
+    if (clearFlags) {
+        glClearColor(0.0, 0.0, 0.0, 0.0);
+        glClear(clearFlags);
+    }
+    d_ptr->did_paint = true;
+}
 …
+}
+static void blitTexture(QGLContext *ctx, GLuint texture, const QSize &viewport, const QSize &texSize, const QRect &targetRect, const QRect &sourceRect)
+{
+    glDisable(GL_DEPTH_TEST);
+    glDisable(GL_SCISSOR_TEST);
+    glDisable(GL_BLEND);
+    glViewport(0, 0, viewport.width(), viewport.height());
+    QGLShaderProgram *blitProgram =
+        QGLEngineSharedShaders::shadersForContext(ctx)->blitProgram();
+    blitProgram->bind();
+    blitProgram->setUniformValue("imageTexture", 0 /*QT_IMAGE_TEXTURE_UNIT*/);
+    // The shader manager's blit program does not multiply the
+    // vertices by the pmv matrix, so we need to do the effect
+    // of the orthographic projection here ourselves.
+    QRectF r;
+    qreal w = viewport.width();
+    qreal h = viewport.height();
+    r.setLeft((targetRect.left() / w) * 2.0f - 1.0f);
+    if (targetRect.right() == (viewport.width() - 1))
+        r.setRight(1.0f);
+    else
+        r.setRight((targetRect.right() / w) * 2.0f - 1.0f);
+    r.setBottom((targetRect.top() / h) * 2.0f - 1.0f);
+    if (targetRect.bottom() == (viewport.height() - 1))
+        r.setTop(1.0f);
+    else
+        r.setTop((targetRect.bottom() / w) * 2.0f - 1.0f);
+    drawTexture(r, texture, texSize, sourceRect);
+}
 void QGLWindowSurface::flush(QWidget *widget, const QRegion &rgn, const QPoint &offset)
+{
-    if (context() && widget != window()) {
-        qWarning("No native child widget support in GL window surface without FBOs or pixel buffers");
-        return;
+    }
     //### Find out why d_ptr->geometry_updated isn't always false.
     // flush() should not be called when d_ptr->geometry_updated is true. It assumes that either
 …
         return;
+    // did_paint is set to true in ::beginPaint. ::beginPaint means that we
+    // at least cleared the background (= painted something). In EGL API it's a
+    // mistake to call swapBuffers if nothing was painted unless
+    // EGL_BUFFER_PRESERVED is set. This check protects the flush func from
+    // being executed if it's for nothing.
+    if (!hasPartialUpdateSupport() && !d_ptr->did_paint)
+        return;
     QWidget *parent = widget->internalWinId() ? widget : widget->nativeParentWidget();
     Q_ASSERT(parent);
 …
     const GLenum target = GL_TEXTURE_2D;
     Q_UNUSED(target);
+    if (QGLWindowSurface::swapBehavior == QGLWindowSurface::KillSwap)
+        return;
     if (context()) {
 …
+            }
 #endif
+            bool doingPartialUpdate = false;
+            if (QGLWindowSurface::swapBehavior == QGLWindowSurface::AutomaticSwap)
+                doingPartialUpdate = hasPartialUpdateSupport() && br.width() * br.height() < parent->geometry().width() * parent->geometry().height() * 0.2;
+            else if (QGLWindowSurface::swapBehavior == QGLWindowSurface::AlwaysFullSwap)
+                doingPartialUpdate = false;
+            else if (QGLWindowSurface::swapBehavior == QGLWindowSurface::AlwaysPartialSwap)
+                doingPartialUpdate = hasPartialUpdateSupport();
+            QGLContext *ctx = reinterpret_cast<QGLContext *>(parent->d_func()->extraData()->glContext);
+            if (widget != window()) {
+                if (initializeOffscreenTexture(window()->size()))
+                    qWarning() << "QGLWindowSurface: Flushing to native child widget, may lead to significant performance loss";
+                glBindTexture(target, d_ptr->tex_id);
+                const uint bottom = window()->height() - (br.y() + br.height());
+                glCopyTexSubImage2D(target, 0, br.x(), bottom, br.x(), bottom, br.width(), br.height());
+                glBindTexture(target, 0);
+                ctx->makeCurrent();
+                if (doingPartialUpdate)
+                    blitTexture(ctx, d_ptr->tex_id, parent->size(), window()->size(), rect, br);
+                else
+                    blitTexture(ctx, d_ptr->tex_id, parent->size(), window()->size(), parent->rect(), parent->rect().translated(offset + wOffset));
+            }
+            if (doingPartialUpdate)
+                ctx->d_func()->swapRegion(br);
+            else
+                ctx->swapBuffers();
             d_ptr->paintedRegion = QRegion();
-            context()->swapBuffers();
         } else {
             glFlush();
 …
         if (window() == parent || d_ptr->fbo->format().samples() <= 1) {
+            // glBindFramebuffer(GL_DRAW_FRAMEBUFFER_EXT, 0);
+            if (ctx->d_ptr->current_fbo != 0)
+                glBindFramebuffer(GL_DRAW_FRAMEBUFFER_EXT, 0);
             glBindFramebuffer(GL_READ_FRAMEBUFFER_EXT, d_ptr->fbo->handle());
 …
             qgl_fbo_pool()->release(temp);
+        }
+        ctx->d_ptr->current_fbo = 0;
+    }
 #if !defined(QT_OPENGL_ES_2)
 …
         Q_UNUSED(target);
-        GLuint texture = d_ptr->fbo->texture();
-        glDisable(GL_DEPTH_TEST);
         if (d_ptr->fbo->isBound())
             d_ptr->fbo->release();
+        glViewport(0, 0, size.width(), size.height());
+        QGLShaderProgram *blitProgram =
+            QGLEngineSharedShaders::shadersForContext(ctx)->blitProgram();
+        blitProgram->bind();
+        blitProgram->setUniformValue("imageTexture", 0 /*QT_IMAGE_TEXTURE_UNIT*/);
+        // The shader manager's blit program does not multiply the
+        // vertices by the pmv matrix, so we need to do the effect
+        // of the orthographic projection here ourselves.
+        QRectF r;
+        qreal w = size.width() ? size.width() : 1.0f;
+        qreal h = size.height() ? size.height() : 1.0f;
+        r.setLeft((rect.left() / w) * 2.0f - 1.0f);
+        if (rect.right() == (size.width() - 1))
+            r.setRight(1.0f);
+        else
+            r.setRight((rect.right() / w) * 2.0f - 1.0f);
+        r.setBottom((rect.top() / h) * 2.0f - 1.0f);
+        if (rect.bottom() == (size.height() - 1))
+            r.setTop(1.0f);
+        else
+            r.setTop((rect.bottom() / w) * 2.0f - 1.0f);
+        drawTexture(r, texture, window()->size(), br);
+        blitTexture(ctx, d_ptr->fbo->texture(), size, window()->size(), rect, br);
+    }
 #endif
 …
     else
         glFlush();
+    d_ptr->did_paint = false;
+}
 …
     d_ptr->geometry_updated = false;
     QRect rect = geometry();
     hijackWindow(window());
 …
     if (d_ptr->ctx) {
 #ifndef QT_OPENGL_ES_2
+        if (d_ptr->destructive_swap_buffers) {
+            glBindTexture(target, d_ptr->tex_id);
+            glTexImage2D(target, 0, GL_RGBA, rect.width(), rect.height(), 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
+            glBindTexture(target, 0);
+        }
+        if (d_ptr->destructive_swap_buffers)
+            initializeOffscreenTexture(rect.size());
 #endif
         return;
 …
 #ifndef QT_OPENGL_ES_2
+    if (d_ptr->destructive_swap_buffers) {
+        glGenTextures(1, &d_ptr->tex_id);
+        glBindTexture(target, d_ptr->tex_id);
+        glTexImage2D(target, 0, GL_RGBA, rect.width(), rect.height(), 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
+        glTexParameterf(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+        glTexParameterf(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+        glBindTexture(target, 0);
+    }
+    if (d_ptr->destructive_swap_buffers)
+        initializeOffscreenTexture(rect.size());
 #endif
 …
     d_ptr->ctx = ctx;
     d_ptr->ctx->d_ptr->internal_context = true;
+}
+bool QGLWindowSurface::initializeOffscreenTexture(const QSize &size)
+{
+    if (size == d_ptr->textureSize)
+        return false;
+    glGenTextures(1, &d_ptr->tex_id);
+    glBindTexture(GL_TEXTURE_2D, d_ptr->tex_id);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, size.width(), size.height(), 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glBindTexture(GL_TEXTURE_2D, 0);
+    d_ptr->textureSize = size;
+    return true;
+}
 …
+    }
     const q_vertexType tx1 = f2vt(src.left());
     const q_vertexType tx2 = f2vt(src.right());
     const q_vertexType ty1 = f2vt(src.top());
     const q_vertexType ty2 = f2vt(src.bottom());
     q_vertexType texCoordArray[4*2] = {
+    const GLfloat tx1 = src.left();
+    const GLfloat tx2 = src.right();
+    const GLfloat ty1 = src.top();
+    const GLfloat ty2 = src.bottom();
+    GLfloat texCoordArray[4*2] = {
         tx1, ty2, tx2, ty2, tx2, ty1, tx1, ty1
     };
     q_vertexType vertexArray[4*2];
     extern void qt_add_rect_to_array(const QRectF &r, q_vertexType *array); // qpaintengine_opengl.cpp
+    GLfloat vertexArray[4*2];
+    extern void qt_add_rect_to_array(const QRectF &r, GLfloat *array); // qpaintengine_opengl.cpp
     qt_add_rect_to_array(rect, vertexArray);
 #if !defined(QT_OPENGL_ES_2)
     glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray);
     glTexCoordPointer(2, q_vertexTypeEnum, 0, texCoordArray);
+    glVertexPointer(2, GL_FLOAT, 0, vertexArray);
+    glTexCoordPointer(2, GL_FLOAT, 0, texCoordArray);
     glBindTexture(target, tex_id);

trunk/src/opengl/qwindowsurface_gl_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 struct QGLWindowSurfacePrivate;
+Q_OPENGL_EXPORT QGLWidget* qt_gl_share_widget();
+Q_OPENGL_EXPORT void qt_destroy_gl_share_widget();
 class QGLWindowSurfaceGLPaintDevice : public QGLPaintDevice
+{
 …
 };
 class QGLWindowSurface : public QObject, public QWindowSurface // , public QPaintDevice
+class Q_OPENGL_EXPORT QGLWindowSurface : public QObject, public QWindowSurface // , public QPaintDevice
+{
     Q_OBJECT
 …
     static QGLFormat surfaceFormat;
+    enum SwapMode { AutomaticSwap, AlwaysFullSwap, AlwaysPartialSwap, KillSwap };
+    static SwapMode swapBehavior;
 private slots:
     void deleted(QObject *object);
 …
 private:
     void hijackWindow(QWidget *widget);
+    bool initializeOffscreenTexture(const QSize &size);
     QGLWindowSurfacePrivate *d_ptr;

trunk/src/opengl/qwindowsurface_x11gl.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 QX11GLWindowSurface::QX11GLWindowSurface(QWidget* window)
     : QWindowSurface(window), m_GC(0), m_window(window)
+    : QWindowSurface(window), m_windowGC(0), m_pixmapGC(0), m_window(window)
+{
+}
 …
 QX11GLWindowSurface::~QX11GLWindowSurface()
+{
+    if (m_GC)
+        XFree(m_GC);
+    if (m_windowGC)
+        XFree(m_windowGC);
+    if (m_pixmapGC)
+        XFree(m_pixmapGC);
+}
 …
 void QX11GLWindowSurface::flush(QWidget *widget, const QRegion &widgetRegion, const QPoint &offset)
+{
+//    qDebug("QX11GLWindowSurface::flush()");
+    QTime startTime = QTime::currentTime();
+    // We don't need to know the widget which initiated the flush. Instead we just use the offset
+    // to translate the widgetRegion:
+    Q_UNUSED(widget);
     if (m_backBuffer.isNull()) {
         qDebug("QHarmattanWindowSurface::flush() - backBuffer is null, not flushing anything");
+        qDebug("QX11GLWindowSurface::flush() - backBuffer is null, not flushing anything");
         return;
+    }
+    QPoint widgetOffset = qt_qwidget_data(widget)->wrect.topLeft();
+    QRegion windowRegion(widgetRegion);
+    QRect boundingRect = widgetRegion.boundingRect();
+    if (!widgetOffset.isNull())
+        windowRegion.translate(-widgetOffset);
+    QRect windowBoundingRect = windowRegion.boundingRect();
+    Q_ASSERT(window()->size() != m_backBuffer.size());
+    // Wait for all GL rendering to the back buffer pixmap to complete before trying to
+    // copy it to the window. We do this by making sure the pixmap's context is current
+    // and then call eglWaitClient. The EGL 1.4 spec says eglWaitClient doesn't have to
+    // block, just that "All rendering calls...are guaranteed to be executed before native
+    // rendering calls". This makes it potentially less expensive than glFinish.
+    QGLContext* ctx = static_cast<QX11GLPixmapData*>(m_backBuffer.data_ptr().data())->context();
+    if (QGLContext::currentContext() != ctx && ctx && ctx->isValid())
+        ctx->makeCurrent();
+    eglWaitClient();
+    if (m_windowGC == 0) {
+        XGCValues attribs;
+        attribs.graphics_exposures = False;
+        m_windowGC = XCreateGC(X11->display, m_window->handle(), GCGraphicsExposures, &attribs);
+    }
     int rectCount;
     XRectangle *rects = (XRectangle *)qt_getClipRects(windowRegion, rectCount);
+    XRectangle *rects = (XRectangle *)qt_getClipRects(widgetRegion, rectCount);
     if (rectCount <= 0)
         return;
+//         qDebug() << "XSetClipRectangles";
+//         for  (int i = 0; i < num; ++i)
+//             qDebug() << ' ' << i << rects[i].x << rects[i].x << rects[i].y << rects[i].width << rects[i].height;
+    if (m_GC == 0) {
+        m_GC = XCreateGC(X11->display, m_window->handle(), 0, 0);
+        XSetGraphicsExposures(X11->display, m_GC, False);
+    }
+    XSetClipRectangles(X11->display, m_GC, 0, 0, rects, rectCount, YXBanded);
+    XCopyArea(X11->display, m_backBuffer.handle(), m_window->handle(), m_GC,
+              boundingRect.x() + offset.x(), boundingRect.y() + offset.y(),
+              boundingRect.width(), boundingRect.height(),
+              windowBoundingRect.x(), windowBoundingRect.y());
+    XSetClipRectangles(X11->display, m_windowGC, 0, 0, rects, rectCount, YXBanded);
+    QRect dirtyRect = widgetRegion.boundingRect().translated(-offset);
+    XCopyArea(X11->display, m_backBuffer.handle(), m_window->handle(), m_windowGC,
+              dirtyRect.x(), dirtyRect.y(), dirtyRect.width(), dirtyRect.height(),
+              dirtyRect.x(), dirtyRect.y());
+    // Make sure the blit of the update from the back buffer to the window completes
+    // before allowing rendering to start again to the back buffer. Otherwise the GPU
+    // might start rendering to the back buffer again while the blit takes place.
+    eglWaitNative(EGL_CORE_NATIVE_ENGINE);
+}
 …
+{
     if (rect.width() > m_backBuffer.size().width() || rect.height() > m_backBuffer.size().height()) {
+        QX11GLPixmapData *pd = new QX11GLPixmapData;
         QSize newSize = rect.size();
-//        QSize newSize(1024,512);
-        qDebug() << "QX11GLWindowSurface::setGeometry() - creating a pixmap of size" << newSize;
-        QX11GLPixmapData *pd = new QX11GLPixmapData;
         pd->resize(newSize.width(), newSize.height());
         m_backBuffer = QPixmap(pd);
+    }
+//    if (gc)
+//        XFreeGC(X11->display, gc);
+//    gc = XCreateGC(X11->display, d_ptr->device.handle(), 0, 0);
+//    XSetGraphicsExposures(X11->display, gc, False);
+        if (window()->testAttribute(Qt::WA_TranslucentBackground))
+            m_backBuffer.fill(Qt::transparent);
+        if (m_pixmapGC) {
+            XFreeGC(X11->display, m_pixmapGC);
+            m_pixmapGC = 0;
+        }
+    }
     QWindowSurface::setGeometry(rect);
+}
 …
 bool QX11GLWindowSurface::scroll(const QRegion &area, int dx, int dy)
+{
+    Q_UNUSED(area);
+    Q_UNUSED(dx);
+    Q_UNUSED(dy);
+    return false;
+}
+/*
+void QX11GLWindowSurface::beginPaint(const QRegion &region)
+{
+}
+void QX11GLWindowSurface::endPaint(const QRegion &region)
+{
+}
+QImage *QX11GLWindowSurface::buffer(const QWidget *widget)
+{
+}
+*/
+    if (m_backBuffer.isNull())
+        return false;
+    Q_ASSERT(m_backBuffer.data_ptr()->classId() == QPixmapData::X11Class);
+    // Make sure all GL rendering is complete before starting the scroll operation:
+    QGLContext* ctx = static_cast<QX11GLPixmapData*>(m_backBuffer.data_ptr().data())->context();
+    if (QGLContext::currentContext() != ctx && ctx && ctx->isValid())
+        ctx->makeCurrent();
+    eglWaitClient();
+    if (!m_pixmapGC)
+        m_pixmapGC = XCreateGC(X11->display, m_backBuffer.handle(), 0, 0);
+    foreach (const QRect& rect, area.rects()) {
+        XCopyArea(X11->display, m_backBuffer.handle(), m_backBuffer.handle(), m_pixmapGC,
+                  rect.x(), rect.y(), rect.width(), rect.height(),
+                  rect.x()+dx, rect.y()+dy);
+    }
+    // Make sure the scroll operation is complete before allowing GL rendering to resume
+    eglWaitNative(EGL_CORE_NATIVE_ENGINE);
+    return true;
+}
+QPixmap QX11GLWindowSurface::grabWidget(const QWidget *widget, const QRect& rect) const
+{
+    if (!widget || m_backBuffer.isNull())
+        return QPixmap();
+    QRect srcRect;
+    // make sure the rect is inside the widget & clip to widget's rect
+    if (!rect.isEmpty())
+        srcRect = rect & widget->rect();
+    else
+        srcRect = widget->rect();
+    if (srcRect.isEmpty())
+        return QPixmap();
+    // If it's a child widget we have to translate the coordinates
+    if (widget != window())
+        srcRect.translate(widget->mapTo(window(), QPoint(0, 0)));
+    QPixmap::x11SetDefaultScreen(widget->x11Info().screen());
+    QX11PixmapData *pmd = new QX11PixmapData(QPixmapData::PixmapType);
+    pmd->resize(srcRect.width(), srcRect.height());
+    QPixmap px(pmd);
+    GC tmpGc = XCreateGC(X11->display, m_backBuffer.handle(), 0, 0);
+    // Make sure all GL rendering is complete before copying the window
+    QGLContext* ctx = static_cast<QX11GLPixmapData*>(m_backBuffer.pixmapData())->context();
+    if (QGLContext::currentContext() != ctx && ctx && ctx->isValid())
+        ctx->makeCurrent();
+    eglWaitClient();
+    // Copy srcRect from the backing store to the new pixmap
+    XSetGraphicsExposures(X11->display, tmpGc, False);
+    XCopyArea(X11->display, m_backBuffer.handle(), px.handle(), tmpGc,
+              srcRect.x(), srcRect.y(), srcRect.width(), srcRect.height(), 0, 0);
+    XFreeGC(X11->display, tmpGc);
+    // Wait until the copy has finised before allowing more rendering into the back buffer
+    eglWaitNative(EGL_CORE_NATIVE_ENGINE);
+    return px;
+}
 QT_END_NAMESPACE

trunk/src/opengl/qwindowsurface_x11gl_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     void setGeometry(const QRect &rect);
     bool scroll(const QRegion &area, int dx, int dy);
+    QPixmap grabWidget(const QWidget *widget, const QRect& rectangle = QRect()) const;
 private:
+    GC      m_GC;
+    GC      m_windowGC;
+    GC      m_pixmapGC;
     QPixmap m_backBuffer;
     QWidget *m_window;

trunk/src/opengl/util/fragmentprograms_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/opengl/util/generator.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     out << "/****************************************************************************\n"
            "**\n"
            "** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).\n"
+           "** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).\n"
            "** All rights reserved.\n"
            "** Contact: Nokia Corporation (qt-info@nokia.com)\n"

trunk/src/opengl/util/glsl_to_include.sh

r651	r846
2	2	#############################################################################
3	3	##
4		## Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	4	## Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
5	5	## All rights reserved.
6	6	## Contact: Nokia Corporation (qt-info@nokia.com)

/branches/vendor/nokia/qt/4.7.2 (added)	merged: 845
/branches/vendor/nokia/qt/current	merged: 844
/branches/vendor/nokia/qt/4.6.3	removed

Context Navigation

Legend:

Download in other formats: