Merge branch '4.6' of git@scm.dev.nokia.troll.no:qt/qt-graphics-team into 4.6

13 files changed, 554 insertions, 352 deletions

diff --git a/src/gui/dialogs/qprintdialog_unix.cpp b/src/gui/dialogs/qprintdialog_unix.cpp
index 6fc270d..9d6cd55 100644
--- a/src/gui/dialogs/qprintdialog_unix.cpp
+++ b/src/gui/dialogs/qprintdialog_unix.cpp
@@ -835,9 +835,6 @@ void QUnixPrintWidgetPrivate::setOptionsPane(QPrintDialogPrivate *pane)
 
 void QUnixPrintWidgetPrivate::_q_btnBrowseClicked()
 {
-    const int prevPrinter = widget.printers->currentIndex();
-    widget.printers->setCurrentIndex(widget.printers->count() - 2); // the pdf one
-
     QString filename = widget.filename->text();
 #ifndef QT_NO_FILEDIALOG
     filename = QFileDialog::getSaveFileName(parent, QPrintDialog::tr("Print To File ..."), filename,
@@ -849,9 +846,11 @@ void QUnixPrintWidgetPrivate::_q_btnBrowseClicked()
         widget.filename->setText(filename);
         if (filename.endsWith(QString::fromLatin1(".ps"), Qt::CaseInsensitive))
             widget.printers->setCurrentIndex(widget.printers->count() - 1); // the postscript one
+        else if (filename.endsWith(QString::fromLatin1(".pdf"), Qt::CaseInsensitive))
+            widget.printers->setCurrentIndex(widget.printers->count() - 2); // the pdf one
+        else if (widget.printers->currentIndex() != widget.printers->count() - 1) // if ps is not selected, pdf is default
+            widget.printers->setCurrentIndex(widget.printers->count() - 2); // the pdf one
     }
-    else
-        widget.printers->setCurrentIndex(prevPrinter);
 }
 
 void QUnixPrintWidgetPrivate::applyPrinterProperties(QPrinter *p)
diff --git a/src/gui/egl/qegl.cpp b/src/gui/egl/qegl.cpp
index 39291d3..c0e4890 100644
--- a/src/gui/egl/qegl.cpp
+++ b/src/gui/egl/qegl.cpp
@@ -62,6 +62,7 @@ QEglContext::QEglContext()
     , currentSurface(EGL_NO_SURFACE)
     , current(false)
     , ownsContext(true)
+    , sharing(false)
 {
 }
 
@@ -174,6 +175,7 @@ bool QEglContext::createContext(QEglContext *shareContext, const QEglProperties
     if (apiType == QEgl::OpenGL)
         contextProps.setValue(EGL_CONTEXT_CLIENT_VERSION, 2);
 #endif
+    sharing = false;
     if (shareContext && shareContext->ctx == EGL_NO_CONTEXT)
         shareContext = 0;
     if (shareContext) {
@@ -181,6 +183,8 @@ bool QEglContext::createContext(QEglContext *shareContext, const QEglProperties
         if (ctx == EGL_NO_CONTEXT) {
             qWarning() << "QEglContext::createContext(): Could not share context:" << errorString(eglGetError());
             shareContext = 0;
+        } else {
+            sharing = true;
         }
     }
     if (ctx == EGL_NO_CONTEXT) {
diff --git a/src/gui/egl/qegl_p.h b/src/gui/egl/qegl_p.h
index 16b5b16..51bdbbe 100644
--- a/src/gui/egl/qegl_p.h
+++ b/src/gui/egl/qegl_p.h
@@ -81,6 +81,7 @@ public:
 
     bool isValid() const;
     bool isCurrent() const;
+    bool isSharing() const { return sharing; }
 
     QEgl::API api() const { return apiType; }
     void setApi(QEgl::API api) { apiType = api; }
@@ -132,6 +133,7 @@ private:
     EGLSurface currentSurface;
     bool current;
     bool ownsContext;
+    bool sharing;
 
     static EGLDisplay getDisplay(QPaintDevice *device);
 
diff --git a/src/opengl/qgl_qws.cpp b/src/opengl/qgl_qws.cpp
index 5e59975..a189c20 100644
--- a/src/opengl/qgl_qws.cpp
+++ b/src/opengl/qgl_qws.cpp
@@ -206,6 +206,9 @@ bool QGLContext::chooseContext(const QGLContext* shareContext)
         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)
diff --git a/src/opengl/qgl_wince.cpp b/src/opengl/qgl_wince.cpp
index fea2d3a..2553110 100644
--- a/src/opengl/qgl_wince.cpp
+++ b/src/opengl/qgl_wince.cpp
@@ -166,6 +166,9 @@ bool QGLContext::chooseContext(const QGLContext* shareContext)
         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)
diff --git a/src/opengl/qgl_x11egl.cpp b/src/opengl/qgl_x11egl.cpp
index 9b20297..b51c239 100644
--- a/src/opengl/qgl_x11egl.cpp
+++ b/src/opengl/qgl_x11egl.cpp
@@ -115,6 +115,9 @@ bool QGLContext::chooseContext(const QGLContext* shareContext)
         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)
diff --git a/src/plugins/imageformats/jpeg/qjpeghandler.cpp b/src/plugins/imageformats/jpeg/qjpeghandler.cpp
index 3b23e56..e5e5e80 100644
--- a/src/plugins/imageformats/jpeg/qjpeghandler.cpp
+++ b/src/plugins/imageformats/jpeg/qjpeghandler.cpp
@@ -196,52 +196,52 @@ inline QRgb *QImageSmoothScaler::scanLine(const int line, const QImage *src)
 
 QImage QImageSmoothScaler::scale()
 {
-    long    SCALE;
-    long    HALFSCALE;
-    QRgb    *xelrow = 0;
-    QRgb    *tempxelrow = 0;
-    QRgb    *xP;
-    QRgb    *nxP;
-    int	    row, rowsread;
-    int	    col, needtoreadrow;
-    uchar   maxval = 255;
-    qreal  xscale, yscale;
-    long    sxscale, syscale;
-    long    fracrowtofill, fracrowleft;
-    long    *as;
-    long    *rs;
-    long    *gs;
-    long    *bs;
-    int	    rowswritten = 0;
-    QImage  dst;
+    long SCALE;
+    long HALFSCALE;
+    QRgb *xelrow = 0;
+    QRgb *tempxelrow = 0;
+    QRgb *xP;
+    QRgb *nxP;
+    int row, rowsread;
+    int col, needtoreadrow;
+    uchar maxval = 255;
+    qreal xscale, yscale;
+    long sxscale, syscale;
+    long fracrowtofill, fracrowleft;
+    long *as;
+    long *rs;
+    long *gs;
+    long *bs;
+    int rowswritten = 0;
+    QImage dst;
 
     if (d->cols > 4096) {
-	SCALE = 4096;
-	HALFSCALE = 2048;
+        SCALE = 4096;
+        HALFSCALE = 2048;
     } else {
-	int fac = 4096;
-	while (d->cols * fac > 4096) {
-	    fac /= 2;
-	}
+        int fac = 4096;
+        while (d->cols * fac > 4096)
+            fac /= 2;
 
-	SCALE = fac * d->cols;
-	HALFSCALE = fac * d->cols / 2;
+        SCALE = fac * d->cols;
+        HALFSCALE = fac * d->cols / 2;
     }
 
-    xscale = (qreal) d->newcols / (qreal) d->cols;
-    yscale = (qreal) d->newrows / (qreal) d->rows;
+    xscale = (qreal)d->newcols / (qreal)d->cols;
+    yscale = (qreal)d->newrows / (qreal)d->rows;
     sxscale = (long)(xscale * SCALE);
     syscale = (long)(yscale * SCALE);
 
-    if ( d->newrows != d->rows )	/* shortcut Y scaling if possible */
-	tempxelrow = new QRgb[d->cols];
+    // shortcut Y scaling if possible
+    if (d->newrows != d->rows)
+        tempxelrow = new QRgb[d->cols];
 
-    if ( d->hasAlpha ) {
-	as = new long[d->cols];
-	for ( col = 0; col < d->cols; ++col )
-	    as[col] = HALFSCALE;
+    if (d->hasAlpha) {
+        as = new long[d->cols];
+        for (col = 0; col < d->cols; ++col)
+            as[col] = HALFSCALE;
     } else {
-	as = 0;
+        as = 0;
     }
     rs = new long[d->cols];
     gs = new long[d->cols];
@@ -249,205 +249,217 @@ QImage QImageSmoothScaler::scale()
     rowsread = 0;
     fracrowleft = syscale;
     needtoreadrow = 1;
-    for ( col = 0; col < d->cols; ++col )
-	rs[col] = gs[col] = bs[col] = HALFSCALE;
+    for (col = 0; col < d->cols; ++col)
+        rs[col] = gs[col] = bs[col] = HALFSCALE;
     fracrowtofill = SCALE;
 
-    dst = QImage( d->newcols, d->newrows, d->hasAlpha ? QImage::Format_ARGB32 : QImage::Format_RGB32 );
-
-    for ( row = 0; row < d->newrows; ++row ) {
-	/* First scale Y from xelrow into tempxelrow. */
-	if ( d->newrows == d->rows ) {
-	    /* shortcut Y scaling if possible */
-	    tempxelrow = xelrow = scanLine(rowsread++, d->src);
-	} else {
-	    while ( fracrowleft < fracrowtofill ) {
-		if ( needtoreadrow && rowsread < d->rows ) {
-		    xelrow = scanLine(rowsread++, d->src);
-		}
-		for ( col = 0, xP = xelrow; col < d->cols; ++col, ++xP ) {
-		    if (as) {
-			as[col] += fracrowleft * qAlpha( *xP );
-			rs[col] += fracrowleft * qRed( *xP ) * qAlpha( *xP ) / 255;
-			gs[col] += fracrowleft * qGreen( *xP ) * qAlpha( *xP ) / 255;
-			bs[col] += fracrowleft * qBlue( *xP ) * qAlpha( *xP ) / 255;
-		    } else {
-			rs[col] += fracrowleft * qRed( *xP );
-			gs[col] += fracrowleft * qGreen( *xP );
-			bs[col] += fracrowleft * qBlue( *xP );
-		    }
-		}
-		fracrowtofill -= fracrowleft;
-		fracrowleft = syscale;
-		needtoreadrow = 1;
-	    }
-	    /* Now fracrowleft is >= fracrowtofill, so we can produce a row. */
-	    if ( needtoreadrow && rowsread < d->rows) {
-		xelrow = scanLine(rowsread++, d->src);
-		needtoreadrow = 0;
-	    }
-	    for ( col = 0, xP = xelrow, nxP = tempxelrow;
-		  col < d->cols; ++col, ++xP, ++nxP )
-	    {
-		register long a, r, g, b;
-
-		if ( as ) {
-		    r = rs[col] + fracrowtofill * qRed( *xP ) * qAlpha( *xP ) / 255;
-		    g = gs[col] + fracrowtofill * qGreen( *xP ) * qAlpha( *xP ) / 255;
-		    b = bs[col] + fracrowtofill * qBlue( *xP ) * qAlpha( *xP ) / 255;
-		    a = as[col] + fracrowtofill * qAlpha( *xP );
-		    if ( a ) {
-			r = r * 255 / a * SCALE;
-			g = g * 255 / a * SCALE;
-			b = b * 255 / a * SCALE;
-		    }
-		} else {
-		    r = rs[col] + fracrowtofill * qRed( *xP );
-		    g = gs[col] + fracrowtofill * qGreen( *xP );
-		    b = bs[col] + fracrowtofill * qBlue( *xP );
-		    a = 0; // unwarn
-		}
-		r /= SCALE;
-		if ( r > maxval ) r = maxval;
-		g /= SCALE;
-		if ( g > maxval ) g = maxval;
-		b /= SCALE;
-		if ( b > maxval ) b = maxval;
-		if ( as ) {
-		    a /= SCALE;
-		    if ( a > maxval ) a = maxval;
-		    *nxP = qRgba( (int)r, (int)g, (int)b, (int)a );
-		    as[col] = HALFSCALE;
-		} else {
-		    *nxP = qRgb( (int)r, (int)g, (int)b );
-		}
-		rs[col] = gs[col] = bs[col] = HALFSCALE;
-	    }
-	    fracrowleft -= fracrowtofill;
-	    if ( fracrowleft == 0 ) {
-		fracrowleft = syscale;
-		needtoreadrow = 1;
-	    }
-	    fracrowtofill = SCALE;
-	}
+    dst = QImage(d->newcols, d->newrows, d->hasAlpha ? QImage::Format_ARGB32 : QImage::Format_RGB32);
 
-	/* Now scale X from tempxelrow into dst and write it out. */
-	if ( d->newcols == d->cols ) {
-	    /* shortcut X scaling if possible */
-	    memcpy(dst.scanLine(rowswritten++), tempxelrow, d->newcols*4);
-	} else {
-	    register long a, r, g, b;
-	    register long fraccoltofill, fraccolleft = 0;
-	    register int needcol;
-
-	    nxP = (QRgb*)dst.scanLine(rowswritten++);
-	    fraccoltofill = SCALE;
-	    a = r = g = b = HALFSCALE;
-	    needcol = 0;
-	    for ( col = 0, xP = tempxelrow; col < d->cols; ++col, ++xP ) {
-		fraccolleft = sxscale;
-		while ( fraccolleft >= fraccoltofill ) {
-		    if ( needcol ) {
-			++nxP;
-			a = r = g = b = HALFSCALE;
-		    }
-		    if ( as ) {
-			r += fraccoltofill * qRed( *xP ) * qAlpha( *xP ) / 255;
-			g += fraccoltofill * qGreen( *xP ) * qAlpha( *xP ) / 255;
-			b += fraccoltofill * qBlue( *xP ) * qAlpha( *xP ) / 255;
-			a += fraccoltofill * qAlpha( *xP );
-			if ( a ) {
-			    r = r * 255 / a * SCALE;
-			    g = g * 255 / a * SCALE;
-			    b = b * 255 / a * SCALE;
-			}
-		    } else {
-			r += fraccoltofill * qRed( *xP );
-			g += fraccoltofill * qGreen( *xP );
-			b += fraccoltofill * qBlue( *xP );
-		    }
-		    r /= SCALE;
-		    if ( r > maxval ) r = maxval;
-		    g /= SCALE;
-		    if ( g > maxval ) g = maxval;
-		    b /= SCALE;
-		    if ( b > maxval ) b = maxval;
-		    if (as) {
-			a /= SCALE;
-			if ( a > maxval ) a = maxval;
-			*nxP = qRgba( (int)r, (int)g, (int)b, (int)a );
-		    } else {
-			*nxP = qRgb( (int)r, (int)g, (int)b );
-		    }
-		    fraccolleft -= fraccoltofill;
-		    fraccoltofill = SCALE;
-		    needcol = 1;
-		}
-		if ( fraccolleft > 0 ) {
-		    if ( needcol ) {
-			++nxP;
-			a = r = g = b = HALFSCALE;
-			needcol = 0;
-		    }
-		    if (as) {
-			a += fraccolleft * qAlpha( *xP );
-			r += fraccolleft * qRed( *xP ) * qAlpha( *xP ) / 255;
-			g += fraccolleft * qGreen( *xP ) * qAlpha( *xP ) / 255;
-			b += fraccolleft * qBlue( *xP ) * qAlpha( *xP ) / 255;
-		    } else {
-			r += fraccolleft * qRed( *xP );
-			g += fraccolleft * qGreen( *xP );
-			b += fraccolleft * qBlue( *xP );
-		    }
-		    fraccoltofill -= fraccolleft;
-		}
-	    }
-	    if ( fraccoltofill > 0 ) {
-		--xP;
-		if (as) {
-		    a += fraccolleft * qAlpha( *xP );
-		    r += fraccoltofill * qRed( *xP ) * qAlpha( *xP ) / 255;
-		    g += fraccoltofill * qGreen( *xP ) * qAlpha( *xP ) / 255;
-		    b += fraccoltofill * qBlue( *xP ) * qAlpha( *xP ) / 255;
-		    if ( a ) {
-			r = r * 255 / a * SCALE;
-			g = g * 255 / a * SCALE;
-			b = b * 255 / a * SCALE;
-		    }
-		} else {
-		    r += fraccoltofill * qRed( *xP );
-		    g += fraccoltofill * qGreen( *xP );
-		    b += fraccoltofill * qBlue( *xP );
-		}
-	    }
-	    if ( ! needcol ) {
-		r /= SCALE;
-		if ( r > maxval ) r = maxval;
-		g /= SCALE;
-		if ( g > maxval ) g = maxval;
-		b /= SCALE;
-		if ( b > maxval ) b = maxval;
-		if (as) {
-		    a /= SCALE;
-		    if ( a > maxval ) a = maxval;
-		    *nxP = qRgba( (int)r, (int)g, (int)b, (int)a );
-		} else {
-		    *nxP = qRgb( (int)r, (int)g, (int)b );
-		}
-	    }
-	}
+    for (row = 0; row < d->newrows; ++row) {
+        // First scale Y from xelrow into tempxelrow.
+        if (d->newrows == d->rows) {
+            // shortcut Y scaling if possible
+            tempxelrow = xelrow = scanLine(rowsread++, d->src);
+        } else {
+            while (fracrowleft < fracrowtofill) {
+                if (needtoreadrow && rowsread < d->rows)
+                    xelrow = scanLine(rowsread++, d->src);
+                for (col = 0, xP = xelrow; col < d->cols; ++col, ++xP) {
+                    if (as) {
+                        as[col] += fracrowleft * qAlpha(*xP);
+                        rs[col] += fracrowleft * qRed(*xP) * qAlpha(*xP) / 255;
+                        gs[col] += fracrowleft * qGreen(*xP) * qAlpha(*xP) / 255;
+                        bs[col] += fracrowleft * qBlue(*xP) * qAlpha(*xP) / 255;
+                    } else {
+                        rs[col] += fracrowleft * qRed(*xP);
+                        gs[col] += fracrowleft * qGreen(*xP);
+                        bs[col] += fracrowleft * qBlue(*xP);
+                    }
+                }
+                fracrowtofill -= fracrowleft;
+                fracrowleft = syscale;
+                needtoreadrow = 1;
+            }
+            // Now fracrowleft is >= fracrowtofill, so we can produce a row.
+            if (needtoreadrow && rowsread < d->rows) {
+                xelrow = scanLine(rowsread++, d->src);
+                needtoreadrow = 0;
+            }
+            for (col = 0, xP = xelrow, nxP = tempxelrow; col < d->cols; ++col, ++xP, ++nxP) {
+                register long a, r, g, b;
+
+                if (as) {
+                    r = rs[col] + fracrowtofill * qRed(*xP) * qAlpha(*xP) / 255;
+                    g = gs[col] + fracrowtofill * qGreen(*xP) * qAlpha(*xP) / 255;
+                    b = bs[col] + fracrowtofill * qBlue(*xP) * qAlpha(*xP) / 255;
+                    a = as[col] + fracrowtofill * qAlpha(*xP);
+                    if (a) {
+                        r = r * 255 / a * SCALE;
+                        g = g * 255 / a * SCALE;
+                        b = b * 255 / a * SCALE;
+                    }
+                } else {
+                    r = rs[col] + fracrowtofill * qRed(*xP);
+                    g = gs[col] + fracrowtofill * qGreen(*xP);
+                    b = bs[col] + fracrowtofill * qBlue(*xP);
+                    a = 0; // unwarn
+                }
+                r /= SCALE;
+                if (r > maxval)
+                    r = maxval;
+                g /= SCALE;
+                if (g > maxval)
+                    g = maxval;
+                b /= SCALE;
+                if (b > maxval)
+                    b = maxval;
+                if (as) {
+                    a /= SCALE;
+                    if (a > maxval)
+                        a = maxval;
+                    *nxP = qRgba((int)r, (int)g, (int)b, (int)a);
+                    as[col] = HALFSCALE;
+                } else {
+                    *nxP = qRgb((int)r, (int)g, (int)b);
+                }
+                rs[col] = gs[col] = bs[col] = HALFSCALE;
+            }
+            fracrowleft -= fracrowtofill;
+            if (fracrowleft == 0) {
+                fracrowleft = syscale;
+                needtoreadrow = 1;
+            }
+            fracrowtofill = SCALE;
+        }
+
+        // Now scale X from tempxelrow into dst and write it out.
+        if (d->newcols == d->cols) {
+            // shortcut X scaling if possible
+            memcpy(dst.scanLine(rowswritten++), tempxelrow, d->newcols * 4);
+        } else {
+            register long a, r, g, b;
+            register long fraccoltofill, fraccolleft = 0;
+            register int needcol;
+
+            nxP = (QRgb *)dst.scanLine(rowswritten++);
+            QRgb *nxPEnd = nxP + d->newcols;
+            fraccoltofill = SCALE;
+            a = r = g = b = HALFSCALE;
+            needcol = 0;
+            for (col = 0, xP = tempxelrow; col < d->cols; ++col, ++xP) {
+                fraccolleft = sxscale;
+                while (fraccolleft >= fraccoltofill) {
+                    if (needcol) {
+                        ++nxP;
+                        a = r = g = b = HALFSCALE;
+                    }
+                    if (as) {
+                        r += fraccoltofill * qRed(*xP) * qAlpha(*xP) / 255;
+                        g += fraccoltofill * qGreen(*xP) * qAlpha(*xP) / 255;
+                        b += fraccoltofill * qBlue(*xP) * qAlpha(*xP) / 255;
+                        a += fraccoltofill * qAlpha(*xP);
+                        if (a) {
+                            r = r * 255 / a * SCALE;
+                            g = g * 255 / a * SCALE;
+                            b = b * 255 / a * SCALE;
+                        }
+                    } else {
+                        r += fraccoltofill * qRed(*xP);
+                        g += fraccoltofill * qGreen(*xP);
+                        b += fraccoltofill * qBlue(*xP);
+                    }
+                    r /= SCALE;
+                    if (r > maxval)
+                        r = maxval;
+                    g /= SCALE;
+                    if (g > maxval)
+                        g = maxval;
+                    b /= SCALE;
+                    if (b > maxval)
+                        b = maxval;
+                    if (as) {
+                        a /= SCALE;
+                        if (a > maxval)
+                            a = maxval;
+                        *nxP = qRgba((int)r, (int)g, (int)b, (int)a);
+                    } else {
+                        *nxP = qRgb((int)r, (int)g, (int)b);
+                    }
+                    fraccolleft -= fraccoltofill;
+                    fraccoltofill = SCALE;
+                    needcol = 1;
+                }
+                if (fraccolleft > 0) {
+                    if (needcol) {
+                        ++nxP;
+                        a = r = g = b = HALFSCALE;
+                        needcol = 0;
+                    }
+                    if (as) {
+                        a += fraccolleft * qAlpha(*xP);
+                        r += fraccolleft * qRed(*xP) * qAlpha(*xP) / 255;
+                        g += fraccolleft * qGreen(*xP) * qAlpha(*xP) / 255;
+                        b += fraccolleft * qBlue(*xP) * qAlpha(*xP) / 255;
+                    } else {
+                        r += fraccolleft * qRed(*xP);
+                        g += fraccolleft * qGreen(*xP);
+                        b += fraccolleft * qBlue(*xP);
+                    }
+                    fraccoltofill -= fraccolleft;
+                }
+            }
+            if (fraccoltofill > 0) {
+                --xP;
+                if (as) {
+                    a += fraccolleft * qAlpha(*xP);
+                    r += fraccoltofill * qRed(*xP) * qAlpha(*xP) / 255;
+                    g += fraccoltofill * qGreen(*xP) * qAlpha(*xP) / 255;
+                    b += fraccoltofill * qBlue(*xP) * qAlpha(*xP) / 255;
+                    if (a) {
+                        r = r * 255 / a * SCALE;
+                        g = g * 255 / a * SCALE;
+                        b = b * 255 / a * SCALE;
+                    }
+                } else {
+                    r += fraccoltofill * qRed(*xP);
+                    g += fraccoltofill * qGreen(*xP);
+                    b += fraccoltofill * qBlue(*xP);
+                }
+            }
+            if (nxP < nxPEnd) {
+                r /= SCALE;
+                if (r > maxval)
+                    r = maxval;
+                g /= SCALE;
+                if (g > maxval)
+                    g = maxval;
+                b /= SCALE;
+                if (b > maxval)
+                    b = maxval;
+                if (as) {
+                    a /= SCALE;
+                    if (a > maxval)
+                        a = maxval;
+                    *nxP = qRgba((int)r, (int)g, (int)b, (int)a);
+                } else {
+                    *nxP = qRgb((int)r, (int)g, (int)b);
+                }
+                while (++nxP != nxPEnd)
+                    nxP[0] = nxP[-1];
+            }
+        }
     }
 
-    if ( d->newrows != d->rows && tempxelrow )// Robust, tempxelrow might be 0 1 day
-	delete [] tempxelrow;
-    if ( as )				// Avoid purify complaint
-	delete [] as;
-    if ( rs )				// Robust, rs might be 0 one day
-	delete [] rs;
-    if ( gs )				// Robust, gs might be 0 one day
-	delete [] gs;
-    if ( bs )				// Robust, bs might be 0 one day
-	delete [] bs;
+    if (d->newrows != d->rows && tempxelrow)// Robust, tempxelrow might be 0 1 day
+        delete [] tempxelrow;
+    if (as)				// Avoid purify complaint
+        delete [] as;
+    if (rs)				// Robust, rs might be 0 one day
+        delete [] rs;
+    if (gs)				// Robust, gs might be 0 one day
+        delete [] gs;
+    if (bs)				// Robust, bs might be 0 one day
+        delete [] bs;
 
     return dst;
 }
diff --git a/src/plugins/imageformats/tiff/qtiffhandler.cpp b/src/plugins/imageformats/tiff/qtiffhandler.cpp
index 3669be7..9538745 100644
--- a/src/plugins/imageformats/tiff/qtiffhandler.cpp
+++ b/src/plugins/imageformats/tiff/qtiffhandler.cpp
@@ -192,7 +192,14 @@ bool QTiffHandler::read(QImage *image)
         return false;
     }
 
-    if (photometric == PHOTOMETRIC_MINISBLACK || photometric == PHOTOMETRIC_MINISWHITE) {
+    uint16 bitPerSample;
+    if (!TIFFGetField(tiff, TIFFTAG_BITSPERSAMPLE, &bitPerSample)) {
+        TIFFClose(tiff);
+        return false;
+    }
+
+    bool grayscale = photometric == PHOTOMETRIC_MINISBLACK || photometric == PHOTOMETRIC_MINISWHITE;
+    if (grayscale && bitPerSample == 1) {
         if (image->size() != QSize(width, height) || image->format() != QImage::Format_Mono)
             *image = QImage(width, height, QImage::Format_Mono);
         QVector<QRgb> colortable(2);
@@ -208,42 +215,43 @@ bool QTiffHandler::read(QImage *image)
         if (!image->isNull()) {
             for (uint32 y=0; y<height; ++y) {
                 if (TIFFReadScanline(tiff, image->scanLine(y), y, 0) < 0) {
-                        TIFFClose(tiff);
-                        return false;
+                    TIFFClose(tiff);
+                    return false;
                 }
             }
         }
     } else {
-        uint16 bitPerSample;
-        if (!TIFFGetField(tiff, TIFFTAG_BITSPERSAMPLE, &bitPerSample)) {
-            TIFFClose(tiff);
-            return false;
-        }
-        if (photometric == PHOTOMETRIC_PALETTE && bitPerSample == 8) {
+        if ((grayscale || photometric == PHOTOMETRIC_PALETTE) && bitPerSample == 8) {
             if (image->size() != QSize(width, height) || image->format() != QImage::Format_Indexed8)
                 *image = QImage(width, height, QImage::Format_Indexed8);
             if (!image->isNull()) {
-                // create the color table
                 const uint16 tableSize = 256;
-                uint16 *redTable = static_cast<uint16 *>(qMalloc(tableSize * sizeof(uint16)));
-                uint16 *greenTable = static_cast<uint16 *>(qMalloc(tableSize * sizeof(uint16)));
-                uint16 *blueTable = static_cast<uint16 *>(qMalloc(tableSize * sizeof(uint16)));
-                if (!redTable || !greenTable || !blueTable) {
-                    TIFFClose(tiff);
-                    return false;
-                }
-                if (!TIFFGetField(tiff, TIFFTAG_COLORMAP, &redTable, &greenTable, &blueTable)) {
-                    TIFFClose(tiff);
-                    return false;
-                }
-
                 QVector<QRgb> qtColorTable(tableSize);
-                for (int i = 0; i<tableSize ;++i) {
-                    const int red = redTable[i] / 257;
-                    const int green = greenTable[i] / 257;
-                    const int blue = blueTable[i] / 257;
-                    qtColorTable[i] = qRgb(red, green, blue);
+                if (grayscale) {
+                    for (int i = 0; i<tableSize; ++i) {
+                        const int c = (photometric == PHOTOMETRIC_MINISBLACK) ? i : (255 - i);
+                        qtColorTable[i] = qRgb(c, c, c);
+                    }
+                } else {
+                    // create the color table
+                    uint16 *redTable = static_cast<uint16 *>(qMalloc(tableSize * sizeof(uint16)));
+                    uint16 *greenTable = static_cast<uint16 *>(qMalloc(tableSize * sizeof(uint16)));
+                    uint16 *blueTable = static_cast<uint16 *>(qMalloc(tableSize * sizeof(uint16)));
+                    if (!redTable || !greenTable || !blueTable) {
+                        TIFFClose(tiff);
+                        return false;
+                    }
+                    if (!TIFFGetField(tiff, TIFFTAG_COLORMAP, &redTable, &greenTable, &blueTable)) {
+                        TIFFClose(tiff);
+                        return false;
+                    }
 
+                    for (int i = 0; i<tableSize ;++i) {
+                        const int red = redTable[i] / 257;
+                        const int green = greenTable[i] / 257;
+                        const int blue = blueTable[i] / 257;
+                        qtColorTable[i] = qRgb(red, green, blue);
+                    }
                 }
 
                 image->setColorTable(qtColorTable);
@@ -371,6 +379,20 @@ bool QTiffHandler::read(QImage *image)
     return true;
 }
 
+static bool checkGrayscale(const QVector<QRgb> &colorTable)
+{
+    if (colorTable.size() != 256)
+        return false;
+
+    const bool increasing = (colorTable.at(0) == 0xff000000);
+    for (int i = 0; i < 256; ++i) {
+        if (increasing && colorTable.at(i) != qRgb(i, i, i)
+            || !increasing && colorTable.at(i) != qRgb(255 - i, 255 - i, 255 - i))
+            return false;
+    }
+    return true;
+}
+
 bool QTiffHandler::write(const QImage &image)
 {
     if (!device()->isWritable())
@@ -425,7 +447,8 @@ bool QTiffHandler::write(const QImage &image)
         if (image.colorTable().at(0) == 0xffffffff)
             photometric = PHOTOMETRIC_MINISWHITE;
         if (!TIFFSetField(tiff, TIFFTAG_PHOTOMETRIC, photometric)
-            || !TIFFSetField(tiff, TIFFTAG_COMPRESSION, compression == NoCompression ? COMPRESSION_NONE : COMPRESSION_CCITTRLE)) {
+            || !TIFFSetField(tiff, TIFFTAG_COMPRESSION, compression == NoCompression ? COMPRESSION_NONE : COMPRESSION_CCITTRLE)
+            || !TIFFSetField(tiff, TIFFTAG_BITSPERSAMPLE, 1)) {
             TIFFClose(tiff);
             return false;
         }
@@ -450,43 +473,55 @@ bool QTiffHandler::write(const QImage &image)
         }
         TIFFClose(tiff);
     } else if (format == QImage::Format_Indexed8) {
-        if (!TIFFSetField(tiff, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_PALETTE)
-            || !TIFFSetField(tiff, TIFFTAG_COMPRESSION, compression == NoCompression ? COMPRESSION_NONE : COMPRESSION_PACKBITS)
-            || !TIFFSetField(tiff, TIFFTAG_BITSPERSAMPLE, 8)) {
-            TIFFClose(tiff);
-            return false;
-        }
-        //// write the color table
-        // allocate the color tables
-        uint16 *redTable = static_cast<uint16 *>(qMalloc(256 * sizeof(uint16)));
-        uint16 *greenTable = static_cast<uint16 *>(qMalloc(256 * sizeof(uint16)));
-        uint16 *blueTable = static_cast<uint16 *>(qMalloc(256 * sizeof(uint16)));
-        if (!redTable || !greenTable || !blueTable) {
-            TIFFClose(tiff);
-            return false;
-        }
-
-        // set the color table
         const QVector<QRgb> colorTable = image.colorTable();
+        bool isGrayscale = checkGrayscale(colorTable);
+        if (isGrayscale) {
+            uint16 photometric = PHOTOMETRIC_MINISBLACK;
+            if (image.colorTable().at(0) == 0xffffffff)
+                photometric = PHOTOMETRIC_MINISWHITE;
+            if (!TIFFSetField(tiff, TIFFTAG_PHOTOMETRIC, photometric)
+                    || !TIFFSetField(tiff, TIFFTAG_COMPRESSION, compression == NoCompression ? COMPRESSION_NONE : COMPRESSION_PACKBITS)
+                    || !TIFFSetField(tiff, TIFFTAG_BITSPERSAMPLE, 8)) {
+                TIFFClose(tiff);
+                return false;
+            }
+        } else {
+            if (!TIFFSetField(tiff, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_PALETTE)
+                    || !TIFFSetField(tiff, TIFFTAG_COMPRESSION, compression == NoCompression ? COMPRESSION_NONE : COMPRESSION_PACKBITS)
+                    || !TIFFSetField(tiff, TIFFTAG_BITSPERSAMPLE, 8)) {
+                TIFFClose(tiff);
+                return false;
+            }
+            //// write the color table
+            // allocate the color tables
+            uint16 *redTable = static_cast<uint16 *>(qMalloc(256 * sizeof(uint16)));
+            uint16 *greenTable = static_cast<uint16 *>(qMalloc(256 * sizeof(uint16)));
+            uint16 *blueTable = static_cast<uint16 *>(qMalloc(256 * sizeof(uint16)));
+            if (!redTable || !greenTable || !blueTable) {
+                TIFFClose(tiff);
+                return false;
+            }
 
-        const int tableSize = colorTable.size();
-        Q_ASSERT(tableSize <= 256);
-        for (int i = 0; i<tableSize; ++i) {
-            const QRgb color = colorTable.at(i);
-            redTable[i] = qRed(color) * 257;
-            greenTable[i] = qGreen(color) * 257;
-            blueTable[i] = qBlue(color) * 257;
-        }
+            // set the color table
+            const int tableSize = colorTable.size();
+            Q_ASSERT(tableSize <= 256);
+            for (int i = 0; i<tableSize; ++i) {
+                const QRgb color = colorTable.at(i);
+                redTable[i] = qRed(color) * 257;
+                greenTable[i] = qGreen(color) * 257;
+                blueTable[i] = qBlue(color) * 257;
+            }
 
-        const bool setColorTableSuccess = TIFFSetField(tiff, TIFFTAG_COLORMAP, redTable, greenTable, blueTable);
+            const bool setColorTableSuccess = TIFFSetField(tiff, TIFFTAG_COLORMAP, redTable, greenTable, blueTable);
 
-        qFree(redTable);
-        qFree(greenTable);
-        qFree(blueTable);
+            qFree(redTable);
+            qFree(greenTable);
+            qFree(blueTable);
 
-        if (!setColorTableSuccess) {
-            TIFFClose(tiff);
-            return false;
+            if (!setColorTableSuccess) {
+                TIFFClose(tiff);
+                return false;
+            }
         }
 
         //// write the data
diff --git a/tests/auto/qgl/tst_qgl.cpp b/tests/auto/qgl/tst_qgl.cpp
index c680dec..ccb08c3 100644
--- a/tests/auto/qgl/tst_qgl.cpp
+++ b/tests/auto/qgl/tst_qgl.cpp
@@ -76,6 +76,7 @@ private slots:
     void partialGLWidgetUpdates_data();
     void partialGLWidgetUpdates();
     void glWidgetRendering();
+    void glFBOSimpleRendering();
     void glFBORendering();
     void multipleFBOInterleavedRendering();
     void glFBOUseInGLWidget();
@@ -711,6 +712,79 @@ void tst_QGL::openGLVersionCheck()
 #endif //QT_BUILD_INTERNAL
 }
 
+static bool fuzzyComparePixels(const QRgb testPixel, const QRgb refPixel, const char* file, int line, int x = -1, int y = -1)
+{
+    static int maxFuzz = 1;
+    static bool maxFuzzSet = false;
+
+    // On 16 bpp systems, we need to allow for more fuzz:
+    if (!maxFuzzSet) {
+        maxFuzzSet = true;
+        if (appDefaultDepth() < 24)
+            maxFuzz = 32;
+    }
+
+    int redFuzz = qAbs(qRed(testPixel) - qRed(refPixel));
+    int greenFuzz = qAbs(qGreen(testPixel) - qGreen(refPixel));
+    int blueFuzz = qAbs(qBlue(testPixel) - qBlue(refPixel));
+    int alphaFuzz = qAbs(qAlpha(testPixel) - qAlpha(refPixel));
+
+    if (refPixel != 0 && testPixel == 0) {
+        QString msg;
+        if (x >= 0) {
+            msg = QString("Test pixel [%1, %2] is null (black) when it should be (%3,%4,%5,%6)")
+                            .arg(x).arg(y)
+                            .arg(qRed(refPixel)).arg(qGreen(refPixel)).arg(qBlue(refPixel)).arg(qAlpha(refPixel));
+        } else {
+            msg = QString("Test pixel is null (black) when it should be (%2,%3,%4,%5)")
+                            .arg(qRed(refPixel)).arg(qGreen(refPixel)).arg(qBlue(refPixel)).arg(qAlpha(refPixel));
+        }
+
+        QTest::qFail(msg.toLatin1(), file, line);
+        return false;
+    }
+
+    if (redFuzz > maxFuzz || greenFuzz > maxFuzz || blueFuzz > maxFuzz || alphaFuzz > maxFuzz) {
+        QString msg;
+
+        if (x >= 0)
+            msg = QString("Pixel [%1,%2]: ").arg(x).arg(y);
+        else
+            msg = QString("Pixel ");
+
+        msg += QString("Max fuzz (%1) exceeded: (%2,%3,%4,%5) vs (%6,%7,%8,%9)")
+                      .arg(maxFuzz)
+                      .arg(qRed(testPixel)).arg(qGreen(testPixel)).arg(qBlue(testPixel)).arg(qAlpha(testPixel))
+                      .arg(qRed(refPixel)).arg(qGreen(refPixel)).arg(qBlue(refPixel)).arg(qAlpha(refPixel));
+        QTest::qFail(msg.toLatin1(), file, line);
+        return false;
+    }
+    return true;
+}
+
+static void fuzzyCompareImages(const QImage &testImage, const QImage &referenceImage, const char* file, int line)
+{
+    QCOMPARE(testImage.width(), referenceImage.width());
+    QCOMPARE(testImage.height(), referenceImage.height());
+
+    for (int y = 0; y < testImage.height(); y++) {
+        for (int x = 0; x < testImage.width(); x++) {
+            if (!fuzzyComparePixels(testImage.pixel(x, y), referenceImage.pixel(x, y), file, line, x, y)) {
+                // Might as well save the images for easier debugging:
+                referenceImage.save("referenceImage.png");
+                testImage.save("testImage.png");
+                return;
+            }
+        }
+    }
+}
+
+#define QFUZZY_COMPARE_IMAGES(A,B) \
+            fuzzyCompareImages(A, B, __FILE__, __LINE__)
+
+#define QFUZZY_COMPARE_PIXELS(A,B) \
+            fuzzyComparePixels(A, B, __FILE__, __LINE__)
+
 class UnclippedWidget : public QWidget
 {
 public:
@@ -723,8 +797,6 @@ public:
 
 void tst_QGL::graphicsViewClipping()
 {
-    if (appDefaultDepth() < 24)
-        QSKIP("This test won't work for bit depths < 24", SkipAll);
     const int size = 64;
     UnclippedWidget *widget = new UnclippedWidget;
     widget->setFixedSize(size, size);
@@ -734,6 +806,9 @@ void tst_QGL::graphicsViewClipping()
     scene.addWidget(widget)->setPos(0, 0);
 
     QGraphicsView view(&scene);
+#ifdef Q_WS_QWS
+    view.setWindowFlags(Qt::FramelessWindowHint);
+#endif
     view.resize(2*size, 2*size);
 
     QGLWidget *viewport = new QGLWidget;
@@ -758,7 +833,7 @@ void tst_QGL::graphicsViewClipping()
     p.fillRect(QRect(0, 0, size, size), Qt::black);
     p.end();
 
-    QCOMPARE(image, expected);
+    QFUZZY_COMPARE_IMAGES(image, expected);
 }
 
 void tst_QGL::partialGLWidgetUpdates_data()
@@ -849,7 +924,7 @@ void tst_QGL::glPBufferRendering()
     p.fillRect(32, 32, 64, 64, Qt::blue);
     p.end();
 
-    QCOMPARE(fb, reference);
+    QFUZZY_COMPARE_IMAGES(fb, reference);
 }
 
 class GLWidget : public QGLWidget
@@ -868,8 +943,8 @@ public:
 
         // This test only ensures it's possible to paint onto a QGLWidget. Full
         // paint engine feature testing is way out of scope!
+        p.fillRect(-1, -1, width()+2, height()+2, Qt::red);
 
-        p.fillRect(0, 0, width(), height(), Qt::red);
         // No p.end() or swap buffers, should be done automatically
     }
 
@@ -877,9 +952,11 @@ public:
 
 void tst_QGL::glWidgetRendering()
 {
-    if (appDefaultDepth() < 24)
-        QSKIP("This test won't work for bit depths < 24", SkipAll);
     GLWidget w;
+#ifdef Q_WS_QWS
+    w.setWindowFlags(Qt::FramelessWindowHint);
+#endif
+    w.setGeometry(100, 100, 200, 200);
     w.show();
 
 #ifdef Q_WS_X11
@@ -894,7 +971,37 @@ void tst_QGL::glWidgetRendering()
     QImage reference(fb.size(), QImage::Format_RGB32);
     reference.fill(0xffff0000);
 
-    QCOMPARE(fb, reference);
+    QFUZZY_COMPARE_IMAGES(fb, reference);
+}
+
+void tst_QGL::glFBOSimpleRendering()
+{
+    if (!QGLFramebufferObject::hasOpenGLFramebufferObjects())
+        QSKIP("QGLFramebufferObject not supported on this platform", SkipSingle);
+
+    QGLWidget glw;
+    glw.makeCurrent();
+
+    // No multisample with combined depth/stencil attachment:
+    QGLFramebufferObjectFormat fboFormat;
+    fboFormat.setAttachment(QGLFramebufferObject::NoAttachment);
+
+    // Don't complicate things by using NPOT:
+    QGLFramebufferObject *fbo = new QGLFramebufferObject(256, 128, fboFormat);
+
+    fbo->bind();
+
+    glClearColor(1.0, 0.0, 0.0, 1.0);
+    glClear(GL_COLOR_BUFFER_BIT);
+    glFinish();
+
+    QImage fb = fbo->toImage().convertToFormat(QImage::Format_RGB32);
+    QImage reference(fb.size(), QImage::Format_RGB32);
+    reference.fill(0xffff0000);
+
+    QFUZZY_COMPARE_IMAGES(fb, reference);
+
+    delete fbo;
 }
 
 // NOTE: This tests that CombinedDepthStencil attachment works by assuming the
@@ -949,14 +1056,14 @@ void tst_QGL::glFBORendering()
     // As we're doing more than trivial painting, we can't just compare to
     // an image rendered with raster. Instead, we sample at well-defined
     // test-points:
-    QCOMPARE(fb.pixel(39, 64), QColor(Qt::red).rgb());
-    QCOMPARE(fb.pixel(89, 64), QColor(Qt::red).rgb());
-    QCOMPARE(fb.pixel(64, 39), QColor(Qt::blue).rgb());
-    QCOMPARE(fb.pixel(64, 89), QColor(Qt::blue).rgb());
-
-    QCOMPARE(fb.pixel(167, 39), QColor(Qt::red).rgb());
-    QCOMPARE(fb.pixel(217, 39), QColor(Qt::red).rgb());
-    QCOMPARE(fb.pixel(192, 64), QColor(Qt::green).rgb());
+    QFUZZY_COMPARE_PIXELS(fb.pixel(39, 64), QColor(Qt::red).rgb());
+    QFUZZY_COMPARE_PIXELS(fb.pixel(89, 64), QColor(Qt::red).rgb());
+    QFUZZY_COMPARE_PIXELS(fb.pixel(64, 39), QColor(Qt::blue).rgb());
+    QFUZZY_COMPARE_PIXELS(fb.pixel(64, 89), QColor(Qt::blue).rgb());
+
+    QFUZZY_COMPARE_PIXELS(fb.pixel(167, 39), QColor(Qt::red).rgb());
+    QFUZZY_COMPARE_PIXELS(fb.pixel(217, 39), QColor(Qt::red).rgb());
+    QFUZZY_COMPARE_PIXELS(fb.pixel(192, 64), QColor(Qt::green).rgb());
 }
 
 
@@ -1047,29 +1154,29 @@ void tst_QGL::multipleFBOInterleavedRendering()
     // As we're doing more than trivial painting, we can't just compare to
     // an image rendered with raster. Instead, we sample at well-defined
     // test-points:
-    QCOMPARE(fb1.pixel(39, 64), QColor(Qt::red).rgb());
-    QCOMPARE(fb1.pixel(89, 64), QColor(Qt::red).rgb());
-    QCOMPARE(fb1.pixel(64, 39), QColor(Qt::blue).rgb());
-    QCOMPARE(fb1.pixel(64, 89), QColor(Qt::blue).rgb());
-    QCOMPARE(fb1.pixel(167, 39), QColor(Qt::red).rgb());
-    QCOMPARE(fb1.pixel(217, 39), QColor(Qt::red).rgb());
-    QCOMPARE(fb1.pixel(192, 64), QColor(Qt::green).rgb());
-
-    QCOMPARE(fb2.pixel(39, 64), QColor(Qt::green).rgb());
-    QCOMPARE(fb2.pixel(89, 64), QColor(Qt::green).rgb());
-    QCOMPARE(fb2.pixel(64, 39), QColor(Qt::red).rgb());
-    QCOMPARE(fb2.pixel(64, 89), QColor(Qt::red).rgb());
-    QCOMPARE(fb2.pixel(167, 39), QColor(Qt::green).rgb());
-    QCOMPARE(fb2.pixel(217, 39), QColor(Qt::green).rgb());
-    QCOMPARE(fb2.pixel(192, 64), QColor(Qt::blue).rgb());
-
-    QCOMPARE(fb3.pixel(39, 64), QColor(Qt::blue).rgb());
-    QCOMPARE(fb3.pixel(89, 64), QColor(Qt::blue).rgb());
-    QCOMPARE(fb3.pixel(64, 39), QColor(Qt::green).rgb());
-    QCOMPARE(fb3.pixel(64, 89), QColor(Qt::green).rgb());
-    QCOMPARE(fb3.pixel(167, 39), QColor(Qt::blue).rgb());
-    QCOMPARE(fb3.pixel(217, 39), QColor(Qt::blue).rgb());
-    QCOMPARE(fb3.pixel(192, 64), QColor(Qt::red).rgb());
+    QFUZZY_COMPARE_PIXELS(fb1.pixel(39, 64), QColor(Qt::red).rgb());
+    QFUZZY_COMPARE_PIXELS(fb1.pixel(89, 64), QColor(Qt::red).rgb());
+    QFUZZY_COMPARE_PIXELS(fb1.pixel(64, 39), QColor(Qt::blue).rgb());
+    QFUZZY_COMPARE_PIXELS(fb1.pixel(64, 89), QColor(Qt::blue).rgb());
+    QFUZZY_COMPARE_PIXELS(fb1.pixel(167, 39), QColor(Qt::red).rgb());
+    QFUZZY_COMPARE_PIXELS(fb1.pixel(217, 39), QColor(Qt::red).rgb());
+    QFUZZY_COMPARE_PIXELS(fb1.pixel(192, 64), QColor(Qt::green).rgb());
+
+    QFUZZY_COMPARE_PIXELS(fb2.pixel(39, 64), QColor(Qt::green).rgb());
+    QFUZZY_COMPARE_PIXELS(fb2.pixel(89, 64), QColor(Qt::green).rgb());
+    QFUZZY_COMPARE_PIXELS(fb2.pixel(64, 39), QColor(Qt::red).rgb());
+    QFUZZY_COMPARE_PIXELS(fb2.pixel(64, 89), QColor(Qt::red).rgb());
+    QFUZZY_COMPARE_PIXELS(fb2.pixel(167, 39), QColor(Qt::green).rgb());
+    QFUZZY_COMPARE_PIXELS(fb2.pixel(217, 39), QColor(Qt::green).rgb());
+    QFUZZY_COMPARE_PIXELS(fb2.pixel(192, 64), QColor(Qt::blue).rgb());
+
+    QFUZZY_COMPARE_PIXELS(fb3.pixel(39, 64), QColor(Qt::blue).rgb());
+    QFUZZY_COMPARE_PIXELS(fb3.pixel(89, 64), QColor(Qt::blue).rgb());
+    QFUZZY_COMPARE_PIXELS(fb3.pixel(64, 39), QColor(Qt::green).rgb());
+    QFUZZY_COMPARE_PIXELS(fb3.pixel(64, 89), QColor(Qt::green).rgb());
+    QFUZZY_COMPARE_PIXELS(fb3.pixel(167, 39), QColor(Qt::blue).rgb());
+    QFUZZY_COMPARE_PIXELS(fb3.pixel(217, 39), QColor(Qt::blue).rgb());
+    QFUZZY_COMPARE_PIXELS(fb3.pixel(192, 64), QColor(Qt::red).rgb());
 }
 
 class FBOUseInGLWidget : public QGLWidget
@@ -1089,11 +1196,11 @@ protected:
 
         QPainter fboPainter;
         fboPainterBeginOk = fboPainter.begin(fbo);
-        fboPainter.fillRect(0, 0, 128, 128, Qt::red);
+        fboPainter.fillRect(-1, -1, 130, 130, Qt::red);
         fboPainter.end();
         fboImage = fbo->toImage();
 
-        widgetPainter.fillRect(rect(), Qt::blue);
+        widgetPainter.fillRect(-1, -1, width()+2, width()+2, Qt::blue);
 
         delete fbo;
     }
@@ -1102,12 +1209,13 @@ protected:
 
 void tst_QGL::glFBOUseInGLWidget()
 {
-    if (appDefaultDepth() < 24)
-        QSKIP("This test won't work for bit depths < 24", SkipAll);
     if (!QGLFramebufferObject::hasOpenGLFramebufferObjects())
         QSKIP("QGLFramebufferObject not supported on this platform", SkipSingle);
 
     FBOUseInGLWidget w;
+#ifdef Q_WS_QWS
+    w.setWindowFlags(Qt::FramelessWindowHint);
+#endif
     w.resize(128, 128);
     w.show();
 
@@ -1122,17 +1230,15 @@ void tst_QGL::glFBOUseInGLWidget()
     QImage widgetFB = w.grabFrameBuffer(false);
     QImage widgetReference(widgetFB.size(), widgetFB.format());
     widgetReference.fill(0xff0000ff);
-    QCOMPARE(widgetFB, widgetReference);
+    QFUZZY_COMPARE_IMAGES(widgetFB, widgetReference);
 
     QImage fboReference(w.fboImage.size(), w.fboImage.format());
     fboReference.fill(0xffff0000);
-    QCOMPARE(w.fboImage, fboReference);
+    QFUZZY_COMPARE_IMAGES(w.fboImage, fboReference);
 }
 
 void tst_QGL::glWidgetReparent()
 {
-    if (appDefaultDepth() < 24)
-        QSKIP("This test won't work for bit depths < 24", SkipAll);
     // Try it as a top-level first:
     GLWidget *widget = new GLWidget;
     widget->setGeometry(0, 0, 200, 30);
@@ -1222,7 +1328,7 @@ void tst_QGL::glWidgetRenderPixmap()
     QImage reference(fb.size(), QImage::Format_RGB32);
     reference.fill(0xffff0000);
 
-    QCOMPARE(fb, reference);
+    QFUZZY_COMPARE_IMAGES(fb, reference);
 }
 
 class ColormapExtended : public QGLColormap
@@ -1495,9 +1601,10 @@ protected:
 
 void tst_QGL::replaceClipping()
 {
-    if (appDefaultDepth() < 24)
-        QSKIP("This test won't work for bit depths < 24", SkipAll);
     ReplaceClippingGLWidget glw;
+#ifdef Q_WS_QWS
+    glw.setWindowFlags(Qt::FramelessWindowHint);
+#endif
     glw.resize(300, 300);
     glw.show();
 
@@ -1513,7 +1620,13 @@ void tst_QGL::replaceClipping()
 
     const QImage widgetFB = glw.grabFrameBuffer(false).convertToFormat(QImage::Format_RGB32);
 
-    QCOMPARE(widgetFB, reference);
+    // Sample pixels in a grid pattern which avoids false failures due to
+    // off-by-one pixel errors on some buggy GL implementations
+    for (int x = 25; x < reference.width(); x += 50) {
+        for (int y = 25; y < reference.width(); y += 50) {
+            QFUZZY_COMPARE_PIXELS(widgetFB.pixel(x, y), reference.pixel(x, y));
+        }
+    }
 }
 
 class ClipTestGLWidget : public QGLWidget
@@ -1521,7 +1634,7 @@ class ClipTestGLWidget : public QGLWidget
 public:
     void paint(QPainter *painter)
     {
-        painter->fillRect(rect(), Qt::white);
+        painter->fillRect(-1, -1, width()+2, height()+2, Qt::white);
         painter->setClipRect(10, 10, width()-20, height()-20);
         painter->fillRect(rect(), Qt::cyan);
 
@@ -1622,9 +1735,10 @@ protected:
 
 void tst_QGL::clipTest()
 {
-    if (appDefaultDepth() < 24)
-        QSKIP("This test won't work for bit depths < 24", SkipAll);
     ClipTestGLWidget glw;
+#ifdef Q_WS_QWS
+    glw.setWindowFlags(Qt::FramelessWindowHint);
+#endif
     glw.resize(220, 220);
     glw.show();
 
@@ -1640,7 +1754,13 @@ void tst_QGL::clipTest()
 
     const QImage widgetFB = glw.grabFrameBuffer(false).convertToFormat(QImage::Format_RGB32);
 
-    QCOMPARE(widgetFB, reference);
+    // Sample pixels in a grid pattern which avoids false failures due to
+    // off-by-one pixel errors on some buggy GL implementations
+    for (int x = 2; x < reference.width(); x += 5) {
+        for (int y = 2; y < reference.width(); y += 5) {
+            QFUZZY_COMPARE_PIXELS(widgetFB.pixel(x, y), reference.pixel(x, y));
+        }
+    }
 }
 
 void tst_QGL::destroyFBOAfterContext()
@@ -1728,6 +1848,7 @@ void tst_QGL::shareRegister()
         delete glw1;
         QSKIP("Context sharing is not supported", SkipSingle);
     }
+    QVERIFY(glw1->isSharing());
     QVERIFY(glw1->context() != glw2->context());
 
     // Check that the first context's resource is also on the second.
diff --git a/tests/auto/qimagereader/images/grayscale-ref.tif b/tests/auto/qimagereader/images/grayscale-ref.tif
new file mode 100644
index 0000000..960531e
--- /dev/null
+++ b/tests/auto/qimagereader/images/grayscale-ref.tif
diff --git a/tests/auto/qimagereader/images/grayscale.tif b/tests/auto/qimagereader/images/grayscale.tif
new file mode 100644
index 0000000..5f4e114
--- /dev/null
+++ b/tests/auto/qimagereader/images/grayscale.tif
diff --git a/tests/auto/qimagereader/tst_qimagereader.cpp b/tests/auto/qimagereader/tst_qimagereader.cpp
index 05b506c..15b1c1c 100644
--- a/tests/auto/qimagereader/tst_qimagereader.cpp
+++ b/tests/auto/qimagereader/tst_qimagereader.cpp
@@ -157,6 +157,8 @@ private slots:
 
     void tiffOrientation_data();
     void tiffOrientation();
+
+    void tiffGrayscale();
 #endif
 
     void autoDetectImageFormat();
@@ -1376,6 +1378,13 @@ void tst_QImageReader::tiffOrientation()
     QCOMPARE(expectedImage, orientedImage);
 }
 
+void tst_QImageReader::tiffGrayscale()
+{
+    QImage actualImage(prefix + "grayscale.tif");
+    QImage expectedImage(prefix + "grayscale-ref.tif");
+
+    QCOMPARE(expectedImage, actualImage.convertToFormat(expectedImage.format()));
+}
 #endif
 
 void tst_QImageReader::dotsPerMeter_data()
diff --git a/tests/auto/qimagewriter/tst_qimagewriter.cpp b/tests/auto/qimagewriter/tst_qimagewriter.cpp
index 584a060..5ec287d3 100644
--- a/tests/auto/qimagewriter/tst_qimagewriter.cpp
+++ b/tests/auto/qimagewriter/tst_qimagewriter.cpp
@@ -391,16 +391,27 @@ void tst_QImageWriter::readWriteNonDestructive_data()
 {
     QTest::addColumn<QImage::Format>("format");
     QTest::addColumn<QImage::Format>("expectedFormat");
-    QTest::newRow("tiff mono") << QImage::Format_Mono << QImage::Format_Mono;
-    QTest::newRow("tiff indexed") << QImage::Format_Indexed8 << QImage::Format_Indexed8;
-    QTest::newRow("tiff rgb32") << QImage::Format_ARGB32 << QImage::Format_ARGB32;
+    QTest::addColumn<bool>("grayscale");
+    QTest::newRow("tiff mono") << QImage::Format_Mono << QImage::Format_Mono << false;
+    QTest::newRow("tiff indexed") << QImage::Format_Indexed8 << QImage::Format_Indexed8 << false;
+    QTest::newRow("tiff rgb32") << QImage::Format_ARGB32 << QImage::Format_ARGB32 << false;
+    QTest::newRow("tiff grayscale") << QImage::Format_Indexed8 << QImage::Format_Indexed8 << true;
 }
 
 void tst_QImageWriter::readWriteNonDestructive()
 {
     QFETCH(QImage::Format, format);
     QFETCH(QImage::Format, expectedFormat);
+    QFETCH(bool, grayscale);
     QImage image = QImage(prefix + "colorful.bmp").convertToFormat(format);
+
+    if (grayscale) {
+        QVector<QRgb> colors;
+        for (int i = 0; i < 256; ++i)
+            colors << qRgb(i, i, i);
+        image.setColorTable(colors);
+    }
+
     QVERIFY(image.save(prefix + "gen-readWriteNonDestructive.tiff"));
 
     QImage image2 = QImage(prefix + "gen-readWriteNonDestructive.tiff");