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

* '4.7' of scm.dev.nokia.troll.no:qt/oslo-staging-2:
  Fixed potential crash when loading corrupt GIFs.
  Work around an ATI driver problem with mutli-sampled pbuffers.
  tst_qstatemachine.cpp: fix compilation with Sun Studio
  Fixed regression in clipping.qps autotest on 64-bit.
  Fixed crash when using Qt::WA_DeleteOnClose on a QPrintDialog on Mac.
  Fixed performance regression in curve stroking.
  Don't disable texture_from_pixmap on GLX/X11 by default.
  Avoid creating copy of an image in memory when storing as png
  Doc update for the support of MSVC 2010 64-bit
  fix documentation of drawText(int, int, int, int, ...
  Optimization of pixel conversion when storing jpeg
  Don't pretend to support single buffered EGL surfaces.
  Named anonymous struct in the OpenGL paint engine.
  Fixes gray_raster incorrectly reporting out of memory error.

15 files changed, 141 insertions, 100 deletions

diff --git a/src/gui/dialogs/qprintdialog_mac.mm b/src/gui/dialogs/qprintdialog_mac.mm
index 84a72db..82e4db5 100644
--- a/src/gui/dialogs/qprintdialog_mac.mm
+++ b/src/gui/dialogs/qprintdialog_mac.mm
@@ -140,11 +140,6 @@ QT_USE_NAMESPACE
 
     QPrintDialogPrivate *d = static_cast<QPrintDialogPrivate *>(contextInfo);
     QPrintDialog *dialog = d->printDialog();
-    // temporary hack to work around bug in deleteLater() in Qt/Mac Cocoa
-#if 1
-    bool deleteDialog = dialog->testAttribute(Qt::WA_DeleteOnClose);
-    dialog->setAttribute(Qt::WA_DeleteOnClose, false);
-#endif
 
     if (returnCode == NSOKButton) {
         UInt32 frompage, topage;
@@ -192,10 +187,6 @@ QT_USE_NAMESPACE
     }
 
     dialog->done((returnCode == NSOKButton) ? QDialog::Accepted : QDialog::Rejected);
-#if 1
-    if (deleteDialog)
-        delete dialog;
-#endif
 }
 @end
 
diff --git a/src/gui/image/qgifhandler.cpp b/src/gui/image/qgifhandler.cpp
index 124d27b..a050baf 100644
--- a/src/gui/image/qgifhandler.cpp
+++ b/src/gui/image/qgifhandler.cpp
@@ -505,17 +505,26 @@ int QGIFFormat::decode(QImage *image, const uchar *buffer, int length,
                             code=oldcode;
                         }
                         while (code>=clear_code+2) {
+                            if (code >= max_code) {
+                                state = Error;
+                                return -1;
+                            }
                             *sp++=table[1][code];
                             if (code==table[0][code]) {
                                 state=Error;
-                                break;
+                                return -1;
                             }
                             if (sp-stack>=(1<<(max_lzw_bits))*2) {
                                 state=Error;
-                                break;
+                                return -1;
                             }
                             code=table[0][code];
                         }
+                        if (code < 0) {
+                            state = Error;
+                            return -1;
+                        }
+
                         *sp++=firstcode=table[1][code];
                         code=max_code;
                         if (code<(1<<max_lzw_bits)) {
diff --git a/src/gui/image/qjpeghandler.cpp b/src/gui/image/qjpeghandler.cpp
index b9eda05..d47cc82 100644
--- a/src/gui/image/qjpeghandler.cpp
+++ b/src/gui/image/qjpeghandler.cpp
@@ -648,22 +648,28 @@ static bool write_jpeg_image(const QImage &image, QIODevice *device, int sourceQ
                 break;
             case QImage::Format_RGB32:
             case QImage::Format_ARGB32:
-            case QImage::Format_ARGB32_Premultiplied: {
-                const QRgb* rgb = (const QRgb*)image.constScanLine(cinfo.next_scanline);
-                for (int i=0; i<w; i++) {
-                    *row++ = qRed(*rgb);
-                    *row++ = qGreen(*rgb);
-                    *row++ = qBlue(*rgb);
-                    ++rgb;
+            case QImage::Format_ARGB32_Premultiplied:
+                {
+                    const QRgb* rgb = (const QRgb*)image.constScanLine(cinfo.next_scanline);
+                    for (int i=0; i<w; i++) {
+                        *row++ = qRed(*rgb);
+                        *row++ = qGreen(*rgb);
+                        *row++ = qBlue(*rgb);
+                        ++rgb;
+                    }
                 }
                 break;
-            }
             default:
-                for (int i=0; i<w; i++) {
-                    QRgb pix = image.pixel(i, cinfo.next_scanline);
-                    *row++ = qRed(pix);
-                    *row++ = qGreen(pix);
-                    *row++ = qBlue(pix);
+                {
+                    // (Testing shows that this way is actually faster than converting to RGB888 + memcpy)
+                    QImage rowImg = image.copy(0, cinfo.next_scanline, w, 1).convertToFormat(QImage::Format_RGB32);
+                    const QRgb* rgb = (const QRgb*)rowImg.constScanLine(0);
+                    for (int i=0; i<w; i++) {
+                        *row++ = qRed(*rgb);
+                        *row++ = qGreen(*rgb);
+                        *row++ = qBlue(*rgb);
+                        ++rgb;
+                    }
                 }
                 break;
             }
diff --git a/src/gui/image/qpnghandler.cpp b/src/gui/image/qpnghandler.cpp
index dc54313..935aba0 100644
--- a/src/gui/image/qpnghandler.cpp
+++ b/src/gui/image/qpnghandler.cpp
@@ -678,41 +678,19 @@ bool QPNGImageWriter::writeImage(const QImage& image, int off_x, int off_y)
     return writeImage(image, -1, QString(), off_x, off_y);
 }
 
-bool Q_INTERNAL_WIN_NO_THROW QPNGImageWriter::writeImage(const QImage& image_in, int quality_in, const QString &description,
+bool Q_INTERNAL_WIN_NO_THROW QPNGImageWriter::writeImage(const QImage& image, int quality_in, const QString &description,
                                  int off_x_in, int off_y_in)
 {
 #ifdef QT_NO_IMAGE_TEXT
     Q_UNUSED(description);
 #endif
 
-    QImage image;
-    switch (image_in.format()) {
-    case QImage::Format_ARGB32_Premultiplied:
-    case QImage::Format_ARGB4444_Premultiplied:
-    case QImage::Format_ARGB8555_Premultiplied:
-    case QImage::Format_ARGB8565_Premultiplied:
-    case QImage::Format_ARGB6666_Premultiplied:
-        image = image_in.convertToFormat(QImage::Format_ARGB32);
-        break;
-    case QImage::Format_RGB16:
-    case QImage::Format_RGB444:
-    case QImage::Format_RGB555:
-    case QImage::Format_RGB666:
-    case QImage::Format_RGB888:
-        image = image_in.convertToFormat(QImage::Format_RGB32);
-        break;
-    default:
-        image = image_in;
-        break;
-    }
-
     QPoint offset = image.offset();
     int off_x = off_x_in + offset.x();
     int off_y = off_y_in + offset.y();
 
     png_structp png_ptr;
     png_infop info_ptr;
-    png_bytep* row_pointers;
 
     png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,0,0,0);
     if (!png_ptr) {
@@ -743,13 +721,18 @@ bool Q_INTERNAL_WIN_NO_THROW QPNGImageWriter::writeImage(const QImage& image_in,
 
     png_set_write_fn(png_ptr, (void*)this, qpiw_write_fn, qpiw_flush_fn);
 
+
+    int color_type = 0;
+    if (image.colorCount())
+        color_type = PNG_COLOR_TYPE_PALETTE;
+    else if (image.hasAlphaChannel())
+        color_type = PNG_COLOR_TYPE_RGB_ALPHA;
+    else
+        color_type = PNG_COLOR_TYPE_RGB;
+
     png_set_IHDR(png_ptr, info_ptr, image.width(), image.height(),
-        image.depth() == 1 ? 1 : 8 /* per channel */,
-        image.depth() == 32
-            ? image.format() == QImage::Format_RGB32
-                ? PNG_COLOR_TYPE_RGB
-                : PNG_COLOR_TYPE_RGB_ALPHA
-            : PNG_COLOR_TYPE_PALETTE, 0, 0, 0);  // also sets #channels
+                 image.depth() == 1 ? 1 : 8, // per channel
+                 color_type, 0, 0, 0);       // sets #channels
 
     if (gamma != 0.0) {
         png_set_gAMA(png_ptr, info_ptr, 1.0/gamma);
@@ -794,8 +777,9 @@ bool Q_INTERNAL_WIN_NO_THROW QPNGImageWriter::writeImage(const QImage& image_in,
         png_set_swap_alpha(png_ptr);
     }
 
-    // Qt==ARGB==Big(ARGB)==Little(BGRA)
-    if (QSysInfo::ByteOrder == QSysInfo::LittleEndian) {
+    // Qt==ARGB==Big(ARGB)==Little(BGRA). But RGB888 is RGB regardless
+    if (QSysInfo::ByteOrder == QSysInfo::LittleEndian
+        && image.format() != QImage::Format_RGB888) {
         png_set_bgr(png_ptr);
     }
 
@@ -820,7 +804,7 @@ bool Q_INTERNAL_WIN_NO_THROW QPNGImageWriter::writeImage(const QImage& image_in,
     if (image.depth() != 1)
         png_set_packing(png_ptr);
 
-    if (image.format() == QImage::Format_RGB32)
+    if (color_type == PNG_COLOR_TYPE_RGB && image.format() != QImage::Format_RGB888)
         png_set_filler(png_ptr, 0,
             QSysInfo::ByteOrder == QSysInfo::BigEndian ?
                 PNG_FILLER_BEFORE : PNG_FILLER_AFTER);
@@ -841,22 +825,36 @@ bool Q_INTERNAL_WIN_NO_THROW QPNGImageWriter::writeImage(const QImage& image_in,
         png_write_chunk(png_ptr, (png_byte*)"gIFg", data, 4);
     }
 
-    png_uint_32 width;
-    png_uint_32 height;
-    int bit_depth;
-    int color_type;
-    png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
-        0, 0, 0);
-
-    const uchar *data = (static_cast<const QImage *>(&image))->bits();
-    int bpl = image.bytesPerLine();
-    row_pointers = new png_bytep[height];
-    uint y;
-    for (y=0; y<height; y++) {
-        row_pointers[y] = (png_bytep)(data + y * bpl);
+    int height = image.height();
+    int width = image.width();
+    switch (image.format()) {
+    case QImage::Format_Mono:
+    case QImage::Format_MonoLSB:
+    case QImage::Format_Indexed8:
+    case QImage::Format_RGB32:
+    case QImage::Format_ARGB32:
+    case QImage::Format_RGB888:
+        {
+            png_bytep* row_pointers = new png_bytep[height];
+            for (int y=0; y<height; y++)
+                row_pointers[y] = (png_bytep)image.constScanLine(y);
+            png_write_image(png_ptr, row_pointers);
+            delete [] row_pointers;
+        }
+        break;
+    default:
+        {
+            QImage::Format fmt = image.hasAlphaChannel() ? QImage::Format_ARGB32 : QImage::Format_RGB32;
+            QImage row;
+            png_bytep row_pointers[1];
+            for (int y=0; y<height; y++) {
+                row = image.copy(0, y, width, 1).convertToFormat(fmt);
+                row_pointers[0] = png_bytep(row.constScanLine(0));
+                png_write_rows(png_ptr, row_pointers, 1);
+            }
+        }
+        break;
     }
-    png_write_image(png_ptr, row_pointers);
-    delete [] row_pointers;
 
     png_write_end(png_ptr, info_ptr);
     frames_written++;
diff --git a/src/gui/painting/qgrayraster.c b/src/gui/painting/qgrayraster.c
index 94039fb..19cef49 100644
--- a/src/gui/painting/qgrayraster.c
+++ b/src/gui/painting/qgrayraster.c
@@ -324,6 +324,7 @@
   {
     void*    buffer;
     long     buffer_size;
+    long     buffer_allocated_size;
     int      band_size;
     void*    memory;
     PWorker  worker;
@@ -1767,7 +1768,7 @@
     // If raster object and raster buffer are allocated, but
     // raster size isn't of the minimum size, indicate out of
     // memory.
-    if (raster && raster->buffer && raster->buffer_size < MINIMUM_POOL_SIZE )
+    if (raster->buffer_allocated_size < MINIMUM_POOL_SIZE )
       return ErrRaster_OutOfMemory;
 
     /* return immediately if the outline is empty */
@@ -1906,6 +1907,7 @@
         rast->buffer_size = 0;
         rast->worker      = NULL;
       }
+      rast->buffer_allocated_size = pool_size;
     }
   }
 
diff --git a/src/gui/painting/qpaintengineex.cpp b/src/gui/painting/qpaintengineex.cpp
index 1e857e4..c1e3d66 100644
--- a/src/gui/painting/qpaintengineex.cpp
+++ b/src/gui/painting/qpaintengineex.cpp
@@ -517,7 +517,7 @@ void QPaintEngineEx::stroke(const QVectorPath &path, const QPen &pen)
             QPainterPath painterPath = state()->matrix.map(path.convertToPainterPath());
             d->activeStroker->strokePath(painterPath, d->strokeHandler, QTransform());
         } else {
-            d->activeStroker->setCurveThresholdFromTransform(state()->matrix);
+            d->activeStroker->setCurveThresholdFromTransform(QTransform());
             d->activeStroker->begin(d->strokeHandler);
             if (types) {
                 while (points < lastPoint) {
diff --git a/src/gui/painting/qpainter.cpp b/src/gui/painting/qpainter.cpp
index 12be93e..376d68b 100644
--- a/src/gui/painting/qpainter.cpp
+++ b/src/gui/painting/qpainter.cpp
@@ -6185,7 +6185,7 @@ void QPainter::drawText(const QRectF &r, int flags, const QString &str, QRectF *
 
     By default, QPainter draws text anti-aliased.
 
-    \note The y-position is used as the baseline of the font.
+    \note The y-position is used as the top of the font.
 
     \sa Qt::AlignmentFlag, Qt::TextFlag
 */
diff --git a/src/gui/painting/qrasterdefs_p.h b/src/gui/painting/qrasterdefs_p.h
index 19a0b16..4d803c7 100644
--- a/src/gui/painting/qrasterdefs_p.h
+++ b/src/gui/painting/qrasterdefs_p.h
@@ -100,7 +100,7 @@ QT_FT_BEGIN_HEADER
   /*    distances in integer font units, or 16,16, or 26.6 fixed float     */
   /*    pixel coordinates.                                                 */
   /*                                                                       */
-  typedef signed long  QT_FT_Pos;
+  typedef signed int  QT_FT_Pos;
 
 
   /*************************************************************************/
diff --git a/src/gui/painting/qstroker.cpp b/src/gui/painting/qstroker.cpp
index 9cff339..9decf41 100644
--- a/src/gui/painting/qstroker.cpp
+++ b/src/gui/painting/qstroker.cpp
@@ -190,6 +190,7 @@ static inline qreal adapted_angle_on_x(const QLineF &line)
 QStrokerOps::QStrokerOps()
     : m_elements(0)
     , m_curveThreshold(qt_real_to_fixed(0.25))
+    , m_dashThreshold(qt_real_to_fixed(0.25))
     , m_customData(0)
     , m_moveTo(0)
     , m_lineTo(0)
@@ -243,7 +244,7 @@ void QStrokerOps::strokePath(const QPainterPath &path, void *customData, const Q
     if (path.isEmpty())
         return;
 
-    setCurveThresholdFromTransform(matrix);
+    setCurveThresholdFromTransform(QTransform());
     begin(customData);
     int count = path.elementCount();
     if (matrix.isIdentity()) {
@@ -315,7 +316,7 @@ void QStrokerOps::strokePolygon(const QPointF *points, int pointCount, bool impl
     if (!pointCount)
         return;
 
-    setCurveThresholdFromTransform(matrix);
+    setCurveThresholdFromTransform(QTransform());
     begin(data);
     if (matrix.isIdentity()) {
         moveTo(qt_real_to_fixed(points[0].x()), qt_real_to_fixed(points[0].y()));
@@ -356,7 +357,7 @@ void QStrokerOps::strokeEllipse(const QRectF &rect, void *data, const QTransform
         }
     }
 
-    setCurveThresholdFromTransform(matrix);
+    setCurveThresholdFromTransform(QTransform());
     begin(data);
     moveTo(qt_real_to_fixed(start.x()), qt_real_to_fixed(start.y()));
     for (int i=0; i<12; i+=3) {
@@ -1142,7 +1143,7 @@ void QDashStroker::processCurrentSubpath()
 
     QPainterPath dashPath;
 
-    QSubpathFlatIterator it(&m_elements, m_curveThreshold);
+    QSubpathFlatIterator it(&m_elements, m_dashThreshold);
     qfixed2d prev = it.next();
 
     bool clipping = !m_clip_rect.isEmpty();
diff --git a/src/gui/painting/qstroker_p.h b/src/gui/painting/qstroker_p.h
index d646135..5607a8e 100644
--- a/src/gui/painting/qstroker_p.h
+++ b/src/gui/painting/qstroker_p.h
@@ -168,7 +168,7 @@ public:
     {
         qreal scale;
         qt_scaleForTransform(transform, &scale);
-        setCurveThreshold(scale == 0 ? qreal(0.5) : (qreal(0.5) / scale));
+        m_dashThreshold = scale == 0 ? qreal(0.5) : (qreal(0.5) / scale);
     }
 
     void setCurveThreshold(qfixed threshold) { m_curveThreshold = threshold; }
@@ -184,6 +184,7 @@ protected:
 
     QRectF m_clip_rect;
     qfixed m_curveThreshold;
+    qfixed m_dashThreshold;
 
     void *m_customData;
     qStrokerMoveToHook m_moveTo;
diff --git a/src/opengl/qgl.cpp b/src/opengl/qgl.cpp
index 0d1a66e..9e74e04 100644
--- a/src/opengl/qgl.cpp
+++ b/src/opengl/qgl.cpp
@@ -509,6 +509,9 @@ QGLFormat::~QGLFormat()
     exchange the screen contents with the buffer. The result is
     flicker-free drawing and often better performance.
 
+    Note that single buffered contexts are currently not supported
+    with EGL.
+
     \sa doubleBuffer(), QGLContext::swapBuffers(),
     QGLWidget::swapBuffers()
 */
@@ -1689,6 +1692,9 @@ void QGLContextPrivate::init(QPaintDevice *dev, const QGLFormat &format)
     workaround_brokenFBOReadBack = 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;
 }
@@ -2574,18 +2580,34 @@ QGLTexture *QGLContextPrivate::bindTexture(const QPixmap &pixmap, GLenum target,
         }
     }
 
-#if defined(Q_WS_X11) && !defined(QT_NO_EGL)
-    // Only try to use texture_from_pixmap under X11/EGL
+#if defined(Q_WS_X11)
+    // Try to use texture_from_pixmap
     const QX11Info *xinfo = qt_x11Info(paintDevice);
     if (pd->classId() == QPixmapData::X11Class && pd->pixelType() == QPixmapData::PixmapType
         && xinfo && xinfo->screen() == pixmap.x11Info().screen()
         && target == GL_TEXTURE_2D)
     {
-        texture = bindTextureFromNativePixmap(const_cast<QPixmap*>(&pixmap), 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;
+            }
+        }
+
+        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
diff --git a/src/opengl/qgl_egl.cpp b/src/opengl/qgl_egl.cpp
index ebd1169..c79c4cd 100644
--- a/src/opengl/qgl_egl.cpp
+++ b/src/opengl/qgl_egl.cpp
@@ -143,6 +143,7 @@ void qt_glformat_from_eglconfig(QGLFormat& format, const EGLConfig config)
     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
diff --git a/src/opengl/qgl_p.h b/src/opengl/qgl_p.h
index 6323ce2..623eeaf 100644
--- a/src/opengl/qgl_p.h
+++ b/src/opengl/qgl_p.h
@@ -401,6 +401,9 @@ public:
     uint workaround_brokenFBOReadBack : 1;
     uint workaroundsCached : 1;
 
+    uint workaround_brokenTextureFromPixmap : 1;
+    uint workaround_brokenTextureFromPixmap_init : 1;
+
     QPaintDevice *paintDevice;
     QColor transpColor;
     QGLContext *q_ptr;
diff --git a/src/opengl/qglpixelbuffer_win.cpp b/src/opengl/qglpixelbuffer_win.cpp
index b55f383..c61d9bf 100644
--- a/src/opengl/qglpixelbuffer_win.cpp
+++ b/src/opengl/qglpixelbuffer_win.cpp
@@ -172,6 +172,10 @@ typedef BOOL (WINAPI * PFNWGLSETPBUFFERATTRIBARBPROC) (HPBUFFERARB hPbuffer, con
 #define WGL_SAMPLES_ARB                0x2042
 #endif
 
+#ifndef GL_SAMPLES_ARB
+#define GL_SAMPLES_ARB 0x80A9
+#endif
+
 QGLFormat pfiToQGLFormat(HDC hdc, int pfi);
 
 static void qt_format_to_attrib_list(bool has_render_texture, const QGLFormat &f, int attribs[])
@@ -242,8 +246,7 @@ static void qt_format_to_attrib_list(bool has_render_texture, const QGLFormat &f
 
 bool QGLPixelBufferPrivate::init(const QSize &size, const QGLFormat &f, QGLWidget *shareWidget)
 {
-    QGLWidget dmy;
-    dmy.makeCurrent(); // needed for wglGetProcAddress() to succeed
+    QGLTemporaryContext tempContext;
 
     PFNWGLCREATEPBUFFERARBPROC wglCreatePbufferARB =
         (PFNWGLCREATEPBUFFERARBPROC) wglGetProcAddress("wglCreatePbufferARB");
@@ -257,13 +260,12 @@ bool QGLPixelBufferPrivate::init(const QSize &size, const QGLFormat &f, QGLWidge
     if (!wglCreatePbufferARB) // assumes that if one can be resolved, all of them can
         return false;
 
-    dc = GetDC(dmy.winId());
+    dc = wglGetCurrentDC();
     Q_ASSERT(dc);
+    has_render_texture = false;
 
     // sample buffers doesn't work in conjunction with the render_texture extension
-    if (f.sampleBuffers()) {
-        has_render_texture = false;
-    } else {
+    if (!f.sampleBuffers()) {
         PFNWGLGETEXTENSIONSSTRINGARBPROC wglGetExtensionsStringARB =
                 (PFNWGLGETEXTENSIONSSTRINGARBPROC) wglGetProcAddress("wglGetExtensionsStringARB");
 
@@ -292,7 +294,6 @@ bool QGLPixelBufferPrivate::init(const QSize &size, const QGLFormat &f, QGLWidge
 
     if (num_formats == 0) {
         qWarning("QGLPixelBuffer: Unable to find a pixel format with pbuffer  - giving up.");
-        ReleaseDC(dmy.winId(), dc);
         return false;
     }
     format = pfiToQGLFormat(dc, pixel_format);
@@ -305,26 +306,32 @@ bool QGLPixelBufferPrivate::init(const QSize &size, const QGLFormat &f, QGLWidge
 
     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);
         has_render_texture = false;
         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;
     if (share_ctx && !wglShareLists(share_ctx, ctx))
         qWarning("QGLPixelBuffer: Unable to share display lists - with share widget.");
diff --git a/src/opengl/qpaintengine_opengl.cpp b/src/opengl/qpaintengine_opengl.cpp
index 58778ea..2f17aa6 100644
--- a/src/opengl/qpaintengine_opengl.cpp
+++ b/src/opengl/qpaintengine_opengl.cpp
@@ -506,12 +506,12 @@ struct QDrawQueueItem
 
 ////////// 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;