Merge branch '4.6' of c:\dev\qt-graphics-4.6

Conflicts:
	tools/qdoc3/test/qt-build-docs.qdocconf
	tools/qdoc3/test/qt-inc.qdocconf

8 files changed, 130 insertions, 157 deletions

diff --git a/src/openvg/qpaintengine_vg.cpp b/src/openvg/qpaintengine_vg.cpp
index da07c1d..047d9d8 100644
--- a/src/openvg/qpaintengine_vg.cpp
+++ b/src/openvg/qpaintengine_vg.cpp
@@ -1178,6 +1178,8 @@ VGPaintType QVGPaintEnginePrivate::setBrush
     case Qt::TexturePattern: {
         // The brush is a texture specified by a QPixmap/QImage.
         QPixmapData *pd = brush.texture().pixmapData();
+        if (!pd)
+            break;  // null QPixmap
         VGImage vgImg;
         bool deref = false;
         if (pd->pixelType() == QPixmapData::BitmapType) {
@@ -2893,6 +2895,8 @@ void qt_vg_drawVGImageStencil
 void QVGPaintEngine::drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr)
 {
     QPixmapData *pd = pm.pixmapData();
+    if (!pd)
+        return; // null QPixmap
     if (pd->classId() == QPixmapData::OpenVGClass) {
         Q_D(QVGPaintEngine);
         QVGPixmapData *vgpd = static_cast<QVGPixmapData *>(pd);
@@ -2910,6 +2914,8 @@ void QVGPaintEngine::drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF
 void QVGPaintEngine::drawPixmap(const QPointF &pos, const QPixmap &pm)
 {
     QPixmapData *pd = pm.pixmapData();
+    if (!pd)
+        return; // null QPixmap
     if (pd->classId() == QPixmapData::OpenVGClass) {
         Q_D(QVGPaintEngine);
         QVGPixmapData *vgpd = static_cast<QVGPixmapData *>(pd);
@@ -2985,6 +2991,8 @@ void QVGPaintEngine::drawPixmaps
     // If the pixmap is not VG, or the transformation is projective,
     // then fall back to the default implementation.
     QPixmapData *pd = pixmap.pixmapData();
+    if (!pd)
+        return; // null QPixmap
     if (pd->classId() != QPixmapData::OpenVGClass || !d->simpleTransform) {
         QPaintEngineEx::drawPixmaps(drawingData, dataCount, pixmap, hints);
         return;
@@ -3455,28 +3463,24 @@ void QVGCompositionHelper::blitWindow
         // Set the image transform.
         QTransform transform;
         int y = screenSize.height() - (rect.bottom() + 1);
-        transform.translate(rect.x() + 0.5f, y + 0.5f);
+        transform.translate(rect.x() - 0.5f, y - 0.5f);
         d->setTransform(VG_MATRIX_IMAGE_USER_TO_SURFACE, transform);
 
         // Enable opacity for image drawing if necessary.
-        if (opacity < 255) {
-            if (opacity != d->paintOpacity) {
-                VGfloat values[4];
-                values[0] = 1.0f;
-                values[1] = 1.0f;
-                values[2] = 1.0f;
-                values[3] = ((VGfloat)opacity) / 255.0f;
-                vgSetParameterfv(d->opacityPaint, VG_PAINT_COLOR, 4, values);
-                d->paintOpacity = values[3];
-            }
-            if (d->fillPaint != d->opacityPaint) {
-                vgSetPaint(d->opacityPaint, VG_FILL_PATH);
-                d->fillPaint = d->opacityPaint;
-            }
-            d->setImageMode(VG_DRAW_IMAGE_MULTIPLY);
-        } else {
-            d->setImageMode(VG_DRAW_IMAGE_NORMAL);
+        if (opacity != d->paintOpacity) {
+            VGfloat values[4];
+            values[0] = 1.0f;
+            values[1] = 1.0f;
+            values[2] = 1.0f;
+            values[3] = ((VGfloat)opacity) / 255.0f;
+            vgSetParameterfv(d->opacityPaint, VG_PAINT_COLOR, 4, values);
+            d->paintOpacity = values[3];
         }
+        if (d->fillPaint != d->opacityPaint) {
+            vgSetPaint(d->opacityPaint, VG_FILL_PATH);
+            d->fillPaint = d->opacityPaint;
+        }
+        d->setImageMode(VG_DRAW_IMAGE_MULTIPLY);
 
         // Draw the child image.
         vgDrawImage(child);
@@ -3527,74 +3531,101 @@ static void fillBackgroundRect(const QRect& rect, QVGPaintEnginePrivate *d)
 void QVGCompositionHelper::fillBackground
     (const QRegion& region, const QBrush& brush)
 {
-    // Set the path transform to the default viewport transformation.
-    VGfloat devh = screenSize.height() - 1;
-    QTransform viewport(1.0f, 0.0f, 0.0f,
-                        0.0f, -1.0f, 0.0f,
-                        0.5f, devh + 0.5f, 1.0f);
-    d->setTransform(VG_MATRIX_PATH_USER_TO_SURFACE, viewport);
-
-    // Set the brush to use to fill the background.
-    d->ensureBrush(brush);
-    d->setFillRule(VG_EVEN_ODD);
+    if (brush.style() == Qt::SolidPattern) {
+        // Use vgClear() to quickly fill the background.
+        QColor color = brush.color();
+        if (d->clearColor != color || d->clearOpacity != 1.0f) {
+            VGfloat values[4];
+            values[0] = color.redF();
+            values[1] = color.greenF();
+            values[2] = color.blueF();
+            values[3] = color.alphaF();
+            vgSetfv(VG_CLEAR_COLOR, 4, values);
+            d->clearColor = color;
+            d->clearOpacity = 1.0f;
+        }
+        if (region.numRects() == 1) {
+            QRect r = region.boundingRect();
+            vgClear(r.x(), screenSize.height() - r.y() - r.height(),
+                    r.width(), r.height());
+        } else {
+            const QVector<QRect> rects = region.rects();
+            for (int i = 0; i < rects.size(); ++i) {
+                QRect r = rects.at(i);
+                vgClear(r.x(), screenSize.height() - r.y() - r.height(),
+                        r.width(), r.height());
+            }
+        }
 
-    if (region.numRects() == 1) {
-        fillBackgroundRect(region.boundingRect(), d);
     } else {
-        const QVector<QRect> rects = region.rects();
-        for (int i = 0; i < rects.size(); ++i)
-            fillBackgroundRect(rects.at(i), d);
-    }
+        // Set the path transform to the default viewport transformation.
+        VGfloat devh = screenSize.height() - 1;
+        QTransform viewport(1.0f, 0.0f, 0.0f,
+                            0.0f, -1.0f, 0.0f,
+                            -0.5f, devh + 0.5f, 1.0f);
+        d->setTransform(VG_MATRIX_PATH_USER_TO_SURFACE, viewport);
+
+        // Set the brush to use to fill the background.
+        d->ensureBrush(brush);
+        d->setFillRule(VG_EVEN_ODD);
+
+        if (region.numRects() == 1) {
+            fillBackgroundRect(region.boundingRect(), d);
+        } else {
+            const QVector<QRect> rects = region.rects();
+            for (int i = 0; i < rects.size(); ++i)
+                fillBackgroundRect(rects.at(i), d);
+        }
 
-    // We will need to reset the path transform during the next paint.
-    d->pathTransformSet = false;
+        // We will need to reset the path transform during the next paint.
+        d->pathTransformSet = false;
+    }
 }
 
-void QVGCompositionHelper::drawCursorImage
-    (const QImage& image, const QPoint& offset)
+void QVGCompositionHelper::drawCursorPixmap
+    (const QPixmap& pixmap, const QPoint& offset)
 {
-    QImage img = image.convertToFormat(QImage::Format_ARGB32_Premultiplied);
+    VGImage vgImage = VG_INVALID_HANDLE;
 
-    VGImage vgImg = vgCreateImage
-        (VG_sARGB_8888_PRE, img.width(), img.height(),
-         VG_IMAGE_QUALITY_FASTER);
-    vgImageSubData
-        (vgImg, img.bits() + img.bytesPerLine() * (img.height() - 1),
-         -(img.bytesPerLine()), VG_sARGB_8888_PRE, 0, 0,
-         img.width(), img.height());
+    // Fetch the VGImage from the pixmap if possible.
+    QPixmapData *pd = pixmap.pixmapData();
+    if (!pd)
+        return; // null QPixmap
+    if (pd->classId() == QPixmapData::OpenVGClass) {
+        QVGPixmapData *vgpd = static_cast<QVGPixmapData *>(pd);
+        if (vgpd->isValid())
+            vgImage = vgpd->toVGImage();
+    }
 
-    QTransform transform;
-    int y = screenSize.height() - (offset.y() + img.height());
-    transform.translate(offset.x() + 0.5f, y + 0.5f);
+    // Set the image transformation and modes.
+    VGfloat devh = screenSize.height() - 1;
+    QTransform transform(1.0f, 0.0f, 0.0f,
+                         0.0f, -1.0f, 0.0f,
+                         -0.5f, devh + 0.5f, 1.0f);
+    transform.translate(offset.x(), offset.y());
     d->setTransform(VG_MATRIX_IMAGE_USER_TO_SURFACE, transform);
-
     d->setImageMode(VG_DRAW_IMAGE_NORMAL);
-    vgDrawImage(vgImg);
 
-    vgDestroyImage(vgImg);
-}
+    // Draw the VGImage.
+    if (vgImage != VG_INVALID_HANDLE) {
+        vgDrawImage(vgImage);
+    } else {
+        QImage img = pixmap.toImage().convertToFormat
+            (QImage::Format_ARGB32_Premultiplied);
 
-void QVGCompositionHelper::drawCursorPixmap
-    (const QPixmap& pixmap, const QPoint& offset)
-{
-    QPixmapData *pd = pixmap.pixmapData();
-    if (pd->classId() == QPixmapData::OpenVGClass) {
-        QVGPixmapData *vgpd = static_cast<QVGPixmapData *>(pd);
-        if (vgpd->isValid()) {
-            VGfloat devh = screenSize.height() - 1;
-            QTransform transform(1.0f, 0.0f, 0.0f,
-                                 0.0f, -1.0f, 0.0f,
-                                 0.5f, devh + 0.5f, 1.0f);
-            transform.translate(offset.x(), offset.y());
-            d->setTransform(VG_MATRIX_IMAGE_USER_TO_SURFACE, transform);
-
-            d->setImageMode(VG_DRAW_IMAGE_NORMAL);
-            vgDrawImage(vgpd->toVGImage());
+        vgImage = vgCreateImage
+            (VG_sARGB_8888_PRE, img.width(), img.height(),
+             VG_IMAGE_QUALITY_FASTER);
+        if (vgImage == VG_INVALID_HANDLE)
             return;
-        }
-    }
+        vgImageSubData
+            (vgImage, img.bits() + img.bytesPerLine() * (img.height() - 1),
+             -(img.bytesPerLine()), VG_sARGB_8888_PRE, 0, 0,
+             img.width(), img.height());
 
-    drawCursorImage(pixmap.toImage(), offset);
+        vgDrawImage(vgImage);
+        vgDestroyImage(vgImage);
+    }
 }
 
 void QVGCompositionHelper::setScissor(const QRegion& region)
diff --git a/src/openvg/qpixmapdata_vg.cpp b/src/openvg/qpixmapdata_vg.cpp
index f86e116..3254aa3 100644
--- a/src/openvg/qpixmapdata_vg.cpp
+++ b/src/openvg/qpixmapdata_vg.cpp
@@ -369,6 +369,8 @@ QImage::Format QVGPixmapData::sourceFormat() const
 Q_OPENVG_EXPORT VGImage qPixmapToVGImage(const QPixmap& pixmap)
 {
     QPixmapData *pd = pixmap.pixmapData();
+    if (!pd)
+        return VG_INVALID_HANDLE; // null QPixmap
     if (pd->classId() == QPixmapData::OpenVGClass) {
         QVGPixmapData *vgpd = static_cast<QVGPixmapData *>(pd);
         if (vgpd->isValid())
diff --git a/src/openvg/qpixmapfilter_vg.cpp b/src/openvg/qpixmapfilter_vg.cpp
index 8e104db..e17c728 100644
--- a/src/openvg/qpixmapfilter_vg.cpp
+++ b/src/openvg/qpixmapfilter_vg.cpp
@@ -65,6 +65,9 @@ void QVGPixmapConvolutionFilter::draw
         (QPainter *painter, const QPointF &dest,
          const QPixmap &src, const QRectF &srcRect) const
 {
+    if (src.isNull())
+        return;
+
     if (src.pixmapData()->classId() != QPixmapData::OpenVGClass) {
         // The pixmap data is not an instance of QVGPixmapData, so fall
         // back to the default convolution filter implementation.
@@ -135,6 +138,9 @@ QVGPixmapColorizeFilter::~QVGPixmapColorizeFilter()
 
 void QVGPixmapColorizeFilter::draw(QPainter *painter, const QPointF &dest, const QPixmap &src, const QRectF &srcRect) const
 {
+    if (src.isNull())
+        return;
+
     if (src.pixmapData()->classId() != QPixmapData::OpenVGClass) {
         // The pixmap data is not an instance of QVGPixmapData, so fall
         // back to the default colorize filter implementation.
@@ -225,6 +231,9 @@ QVGPixmapDropShadowFilter::~QVGPixmapDropShadowFilter()
 
 void QVGPixmapDropShadowFilter::draw(QPainter *painter, const QPointF &dest, const QPixmap &src, const QRectF &srcRect) const
 {
+    if (src.isNull())
+        return;
+
     if (src.pixmapData()->classId() != QPixmapData::OpenVGClass) {
         // The pixmap data is not an instance of QVGPixmapData, so fall
         // back to the default drop shadow filter implementation.
@@ -290,6 +299,9 @@ QVGPixmapBlurFilter::~QVGPixmapBlurFilter()
 
 void QVGPixmapBlurFilter::draw(QPainter *painter, const QPointF &dest, const QPixmap &src, const QRectF &srcRect) const
 {
+    if (src.isNull())
+        return;
+
     if (src.pixmapData()->classId() != QPixmapData::OpenVGClass) {
         // The pixmap data is not an instance of QVGPixmapData, so fall
         // back to the default blur filter implementation.
diff --git a/src/openvg/qpixmapfilter_vg_p.h b/src/openvg/qpixmapfilter_vg_p.h
index efbbc7b..29dd37e 100644
--- a/src/openvg/qpixmapfilter_vg_p.h
+++ b/src/openvg/qpixmapfilter_vg_p.h
@@ -61,7 +61,7 @@ QT_BEGIN_NAMESPACE
 
 #if !defined(QT_SHIVAVG)
 
-class Q_OPENVG_EXPORT QVGPixmapConvolutionFilter : public QPixmapConvolutionFilter
+class QVGPixmapConvolutionFilter : public QPixmapConvolutionFilter
 {
     Q_OBJECT
 public:
@@ -71,7 +71,7 @@ public:
     void draw(QPainter *painter, const QPointF &dest, const QPixmap &src, const QRectF &srcRect) const;
 };
 
-class Q_OPENVG_EXPORT QVGPixmapColorizeFilter : public QPixmapColorizeFilter
+class QVGPixmapColorizeFilter : public QPixmapColorizeFilter
 {
     Q_OBJECT
 public:
@@ -81,7 +81,7 @@ public:
     void draw(QPainter *painter, const QPointF &dest, const QPixmap &src, const QRectF &srcRect) const;
 };
 
-class Q_OPENVG_EXPORT QVGPixmapDropShadowFilter : public QPixmapDropShadowFilter
+class QVGPixmapDropShadowFilter : public QPixmapDropShadowFilter
 {
     Q_OBJECT
 public:
@@ -91,7 +91,7 @@ public:
     void draw(QPainter *p, const QPointF &pos, const QPixmap &px, const QRectF &src) const;
 };
 
-class Q_OPENVG_EXPORT QVGPixmapBlurFilter : public QPixmapBlurFilter
+class QVGPixmapBlurFilter : public QPixmapBlurFilter
 {
     Q_OBJECT
 public:
diff --git a/src/openvg/qvgcompositionhelper_p.h b/src/openvg/qvgcompositionhelper_p.h
index 6317c3f..3afe31e 100644
--- a/src/openvg/qvgcompositionhelper_p.h
+++ b/src/openvg/qvgcompositionhelper_p.h
@@ -74,7 +74,6 @@ public:
     void blitWindow(QVGEGLWindowSurfacePrivate *surface, const QRect& rect,
                     const QPoint& topLeft, int opacity);
     void fillBackground(const QRegion& region, const QBrush& brush);
-    void drawCursorImage(const QImage& image, const QPoint& offset);
     void drawCursorPixmap(const QPixmap& pixmap, const QPoint& offset);
     void setScissor(const QRegion& region);
     void clearScissor();
diff --git a/src/openvg/qwindowsurface_vg.cpp b/src/openvg/qwindowsurface_vg.cpp
index 661e06a..f8486a6 100644
--- a/src/openvg/qwindowsurface_vg.cpp
+++ b/src/openvg/qwindowsurface_vg.cpp
@@ -54,8 +54,8 @@ QT_BEGIN_NAMESPACE
 QVGWindowSurface::QVGWindowSurface(QWidget *window)
     : QWindowSurface(window)
 {
-    d_ptr = QVGEGLWindowSurfacePrivate::create
-        (QVGEGLWindowSurfacePrivate::WindowSurface, this);
+    // Create the default type of EGL window surface for windows.
+    d_ptr = new QVGEGLWindowSurfaceDirect(this);
 }
 
 QVGWindowSurface::QVGWindowSurface
diff --git a/src/openvg/qwindowsurface_vgegl.cpp b/src/openvg/qwindowsurface_vgegl.cpp
index d622c1f..29d82c8 100644
--- a/src/openvg/qwindowsurface_vgegl.cpp
+++ b/src/openvg/qwindowsurface_vgegl.cpp
@@ -101,18 +101,6 @@ QImage::Format qt_vg_config_to_image_format(QEglContext *context)
         return argbFormat;       // XXX
 }
 
-static void copySubImage(QImage *image, VGImage vgImage, const QRect& rect)
-{
-    vgGetImageSubData
-        (vgImage,
-         image->bits() + rect.bottom() * image->bytesPerLine() +
-            rect.x() * (image->depth() / 8),
-         -(image->bytesPerLine()),
-         qt_vg_image_to_vg_format(image->format()),
-         rect.x(), (image->height() - 1) - rect.bottom(),
-         rect.width(), rect.height());
-}
-
 #if !defined(QVG_NO_SINGLE_CONTEXT)
 
 class QVGSharedContext
@@ -205,6 +193,13 @@ static QEglContext *createContext(QPaintDevice *device)
         return 0;
     }
 
+    // Set the swap interval for the display.
+    QByteArray interval = qgetenv("QT_VG_SWAP_INTERVAL");
+    if (!interval.isEmpty())
+        eglSwapInterval(context->display(), interval.toInt());
+    else
+        eglSwapInterval(context->display(), 1);
+
     // Choose an appropriate configuration for rendering into the device.
     QEglProperties configProps;
     configProps.setPaintDeviceFormat(device);
@@ -336,20 +331,6 @@ QVGEGLWindowSurfacePrivate::~QVGEGLWindowSurfacePrivate()
     destroyPaintEngine();
 }
 
-QVGEGLWindowSurfacePrivate *QVGEGLWindowSurfacePrivate::create
-    (SurfaceType type, QWindowSurface *win)
-{
-#if defined(QVG_VGIMAGE_BACKBUFFERS)
-    if (type == VGImageSurface)
-        return new QVGEGLWindowSurfaceVGImage(win);
-    else if (type == QImageSurface)
-        return new QVGEGLWindowSurfaceQImage(win);
-#endif
-    if (type == WindowSurface)
-        return new QVGEGLWindowSurfaceDirect(win);
-    return 0;
-}
-
 QVGPaintEngine *QVGEGLWindowSurfacePrivate::paintEngine()
 {
     if (!engine)
@@ -514,39 +495,6 @@ EGLSurface QVGEGLWindowSurfaceVGImage::mainSurface() const
         return qt_vg_shared_surface();
 }
 
-QVGEGLWindowSurfaceQImage::QVGEGLWindowSurfaceQImage(QWindowSurface *win)
-    : QVGEGLWindowSurfaceVGImage(win)
-{
-}
-
-QVGEGLWindowSurfaceQImage::~QVGEGLWindowSurfaceQImage()
-{
-}
-
-void QVGEGLWindowSurfaceQImage::endPaint
-        (QWidget *widget, const QRegion& region, QImage *image)
-{
-    QEglContext *context = ensureContext(widget);
-    if (context) {
-        if (backBufferSurface != EGL_NO_SURFACE) {
-            if (isPaintingActive)
-                vgFlush();
-            context->makeCurrent(mainSurface());
-            QRegion rgn = region.intersected
-                (QRect(0, 0, image->width(), image->height()));
-            if (rgn.numRects() == 1) {
-                copySubImage(image, backBuffer, rgn.boundingRect());
-            } else {
-                QVector<QRect> rects = rgn.rects();
-                for (int index = 0; index < rects.size(); ++index)
-                    copySubImage(image, backBuffer, rects[index]);
-            }
-            context->lazyDoneCurrent();
-        }
-        isPaintingActive = false;
-    }
-}
-
 #endif // QVG_VGIMAGE_BACKBUFFERS
 
 QVGEGLWindowSurfaceDirect::QVGEGLWindowSurfaceDirect(QWindowSurface *win)
diff --git a/src/openvg/qwindowsurface_vgegl_p.h b/src/openvg/qwindowsurface_vgegl_p.h
index fa36b94..7fa60ea 100644
--- a/src/openvg/qwindowsurface_vgegl_p.h
+++ b/src/openvg/qwindowsurface_vgegl_p.h
@@ -70,16 +70,6 @@ public:
     QVGEGLWindowSurfacePrivate(QWindowSurface *win);
     virtual ~QVGEGLWindowSurfacePrivate();
 
-    enum SurfaceType
-    {
-        WindowSurface,
-        VGImageSurface,
-        QImageSurface
-    };
-
-    static QVGEGLWindowSurfacePrivate *create
-        (SurfaceType type, QWindowSurface *win);
-
     QVGPaintEngine *paintEngine();
     virtual QEglContext *ensureContext(QWidget *widget) = 0;
     virtual void beginPaint(QWidget *widget) = 0;
@@ -126,15 +116,6 @@ protected:
     EGLSurface mainSurface() const;
 };
 
-class Q_OPENVG_EXPORT QVGEGLWindowSurfaceQImage : public QVGEGLWindowSurfaceVGImage
-{
-public:
-    QVGEGLWindowSurfaceQImage(QWindowSurface *win);
-    virtual ~QVGEGLWindowSurfaceQImage();
-
-    void endPaint(QWidget *widget, const QRegion& region, QImage *image);
-};
-
 #endif // EGL_OPENVG_IMAGE
 
 class Q_OPENVG_EXPORT QVGEGLWindowSurfaceDirect : public QVGEGLWindowSurfacePrivate