Merge commit 'origin/4.5'

Conflicts:
	src/gui/graphicsview/qgraphicsitem.cpp
	src/gui/graphicsview/qgraphicsitem_p.h
	src/gui/graphicsview/qgraphicsscene.cpp
	src/gui/painting/qtransform.cpp

6 files changed, 139 insertions, 96 deletions

diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbpaintdevice.cpp b/src/plugins/gfxdrivers/directfb/qdirectfbpaintdevice.cpp
index edbfa7d..2a2ef5c 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbpaintdevice.cpp
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbpaintdevice.cpp
@@ -110,7 +110,6 @@ int QDirectFBPaintDevice::bytesPerLine() const
         QDirectFBPaintDevice* that = const_cast<QDirectFBPaintDevice*>(this);
         that->lockDirectFB();
         Q_ASSERT(bpl != -1);
-        that->unlockDirectFB();
     }
     return bpl;
 }
diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.cpp b/src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.cpp
index 3b6ea80..a93bbf7 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.cpp
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.cpp
@@ -367,7 +367,9 @@ void QDirectFBPaintEnginePrivate::setPen(const QPen &p)
 {
     pen = p;
     simplePen = (pen.style() == Qt::NoPen) ||
-                (pen.style() == Qt::SolidLine && !antialiased
+                (pen.style() == Qt::SolidLine
+                 && !antialiased
+                 && (pen.brush().style() == Qt::SolidPattern)
                  && (pen.widthF() <= 1 && !matrixScale));
 }
 
@@ -556,43 +558,25 @@ void QDirectFBPaintEnginePrivate::fillRegion(const QRegion &region) const
 {
     const QVector<QRect> rects = region.rects();
     const int n = rects.size();
-    QVarLengthArray<DFBRectangle> dfbRects(n);
-
-    for (int i = 0; i < n; ++i) {
-        const QRect r = rects.at(i);
-        dfbRects[i].x = r.x();
-        dfbRects[i].y = r.y();
-        dfbRects[i].w = r.width();
-        dfbRects[i].h = r.height();
-
-    }
-    surface->FillRectangles(surface, dfbRects.data(), n);
+    fillRects(rects.constData(), n);
 }
 
 void QDirectFBPaintEnginePrivate::fillRects(const QRect *rects, int n) const
 {
-    QVarLengthArray<DFBRectangle> dfbRects(n);
     for (int i = 0; i < n; ++i) {
         const QRect r = transform.mapRect(rects[i]);
-        dfbRects[i].x = r.x();
-        dfbRects[i].y = r.y();
-        dfbRects[i].w = r.width();
-        dfbRects[i].h = r.height();
+        surface->FillRectangle(surface, r.x(), r.y(),
+                               r.width(), r.height());
     }
-    surface->FillRectangles(surface, dfbRects.data(), n);
 }
 
 void QDirectFBPaintEnginePrivate::fillRects(const QRectF *rects, int n) const
 {
-    QVarLengthArray<DFBRectangle> dfbRects(n);
     for (int i = 0; i < n; ++i) {
         const QRect r = transform.mapRect(rects[i]).toRect();
-        dfbRects[i].x = r.x();
-        dfbRects[i].y = r.y();
-        dfbRects[i].w = r.width();
-        dfbRects[i].h = r.height();
+        surface->FillRectangle(surface, r.x(), r.y(),
+                               r.width(), r.height());
     }
-    surface->FillRectangles(surface, dfbRects.data(), n);
 }
 
 void QDirectFBPaintEnginePrivate::drawRects(const QRect *rects, int n) const
@@ -907,8 +891,7 @@ void QDirectFBPaintEngine::setState(QPainterState *s)
 {
     Q_D(QDirectFBPaintEngine);
     QRasterPaintEngine::setState(s);
-    if (d->surface)
-        d->updateClip();
+    d->setClipDirty();
     d->setPen(state()->pen);
     d->setBrush(state()->brush);
     d->setOpacity(state()->opacity);
diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbpixmap.cpp b/src/plugins/gfxdrivers/directfb/qdirectfbpixmap.cpp
index 9f5c055..35ab859 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbpixmap.cpp
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbpixmap.cpp
@@ -71,9 +71,9 @@ void QDirectFBPixmapData::resize(int width, int height)
         return;
     }
 
-    dfbSurface = QDirectFBScreen::instance()->createDFBSurface(QSize(width, height),
-                                                               screen->pixelFormat(),
-                                                               QDirectFBScreen::TrackSurface);
+    dfbSurface = screen->createDFBSurface(QSize(width, height),
+                                          screen->pixelFormat(),
+                                          QDirectFBScreen::TrackSurface);
     forceRaster = (screen->pixelFormat() == QImage::Format_RGB32);
     if (!dfbSurface) {
         setSerialNumber(0);
@@ -109,9 +109,10 @@ void QDirectFBPixmapData::copy(const QPixmapData *data, const QRect &rect)
     }
 
     IDirectFBSurface *src = static_cast<const QDirectFBPixmapData*>(data)->directFBSurface();
-    const QImage::Format format = (data->hasAlphaChannel()
-                                   ? QDirectFBScreen::instance()->alphaPixmapFormat()
-                                   : QDirectFBScreen::instance()->pixelFormat());
+    const bool hasAlpha = data->hasAlphaChannel();
+    const QImage::Format format = (hasAlpha
+                                   ? screen->alphaPixmapFormat()
+                                   : screen->pixelFormat());
 
     dfbSurface = screen->createDFBSurface(rect.size(), format,
                                           QDirectFBScreen::TrackSurface);
@@ -122,10 +123,16 @@ void QDirectFBPixmapData::copy(const QPixmapData *data, const QRect &rect)
     }
     forceRaster = (format == QImage::Format_RGB32);
 
-    dfbSurface->SetBlittingFlags(dfbSurface, DSBLIT_NOFX);
+    if (hasAlpha) {
+        dfbSurface->Clear(dfbSurface, 0, 0, 0, 0);
+        dfbSurface->SetBlittingFlags(dfbSurface, DSBLIT_BLEND_ALPHACHANNEL);
+    } else {
+        dfbSurface->SetBlittingFlags(dfbSurface, DSBLIT_NOFX);
+    }
     const DFBRectangle blitRect = { rect.x(), rect.y(),
                                     rect.width(), rect.height() };
     DFBResult result = dfbSurface->Blit(dfbSurface, src, &blitRect, 0, 0);
+    dfbSurface->ReleaseSource(dfbSurface);
     if (result != DFB_OK) {
         DirectFBError("QDirectFBPixmapData::copy()", result);
         setSerialNumber(0);
@@ -144,15 +151,11 @@ void QDirectFBPixmapData::fill(const QColor &color)
     Q_ASSERT(dfbSurface);
 
     if (color.alpha() < 255 && !hasAlphaChannel()) {
-        DFBSurfaceDescription description;
-        description.flags = DFBSurfaceDescriptionFlags(DSDESC_WIDTH |
-                                                       DSDESC_HEIGHT |
-                                                       DSDESC_PIXELFORMAT);
-        dfbSurface->GetSize(dfbSurface, &description.width, &description.height);
-        QDirectFBScreen::initSurfaceDescriptionPixelFormat(&description, screen->alphaPixmapFormat());
-        screen->releaseDFBSurface(dfbSurface); // release old surface
-
-        dfbSurface = screen->createDFBSurface(&description, QDirectFBScreen::TrackSurface);
+
+        QSize size;
+        dfbSurface->GetSize(dfbSurface, &size.rwidth(), &size.rheight());
+        screen->releaseDFBSurface(dfbSurface);
+        dfbSurface = screen->createDFBSurface(size, screen->alphaPixmapFormat(), QDirectFBScreen::TrackSurface);
         forceRaster = false;
         setSerialNumber(++global_ser_no);
         if (!dfbSurface) {
@@ -185,30 +188,13 @@ bool QDirectFBPixmapData::hasAlphaChannel() const
 {
     if (!serialNumber())
         return false;
+    DFBSurfacePixelFormat format;
+    dfbSurface->GetPixelFormat(dfbSurface, &format);
+    return QDirectFBScreen::hasAlpha(format);
 
     // We don't need to ask DFB for this really. Can just keep track
     // of what image format this has. It should always have either
     // QDirectFBScreen::alphaPixmapFormat() or QScreen::pixelFormat()
-
-    DFBSurfacePixelFormat format;
-    dfbSurface->GetPixelFormat(dfbSurface, &format);
-    switch (format) {
-    case DSPF_ARGB1555:
-    case DSPF_ARGB:
-    case DSPF_LUT8:
-    case DSPF_AiRGB:
-    case DSPF_A1:
-    case DSPF_ARGB2554:
-    case DSPF_ARGB4444:
-    case DSPF_AYUV:
-    case DSPF_A4:
-    case DSPF_ARGB1666:
-    case DSPF_ARGB6666:
-    case DSPF_LUT2:
-        return true;
-    default:
-        return false;
-    }
 }
 
 QPixmap QDirectFBPixmapData::transformed(const QTransform &transform,
@@ -235,13 +221,23 @@ QPixmap QDirectFBPixmapData::transformed(const QTransform &transform,
         return QPixmap();
 
     QDirectFBPixmapData *data = new QDirectFBPixmapData(QPixmapData::PixmapType);
-    data->resize(size.width(), size.height());
-
-    IDirectFBSurface *dest = data->dfbSurface;
-    dest->SetBlittingFlags(dest, DSBLIT_NOFX);
+    QImage::Format format = screen->pixelFormat();
+    DFBSurfaceBlittingFlags flags = DSBLIT_NOFX;
+    if (hasAlphaChannel()) {
+        flags = DSBLIT_BLEND_ALPHACHANNEL;
+        format = screen->alphaPixmapFormat();
+    }
+    data->dfbSurface = screen->createDFBSurface(size,
+                                                format,
+                                                QDirectFBScreen::TrackSurface);
+    if (flags & DSBLIT_BLEND_ALPHACHANNEL) {
+        data->dfbSurface->Clear(data->dfbSurface, 0, 0, 0, 0);
+    }
+    data->dfbSurface->SetBlittingFlags(data->dfbSurface, flags);
 
     const DFBRectangle destRect = { 0, 0, size.width(), size.height() };
-    dest->StretchBlit(dest, dfbSurface, 0, &destRect);
+    data->dfbSurface->StretchBlit(data->dfbSurface, dfbSurface, 0, &destRect);
+    data->dfbSurface->ReleaseSource(data->dfbSurface);
 
     return QPixmap(data);
 }
@@ -251,6 +247,17 @@ QImage QDirectFBPixmapData::toImage() const
     if (!dfbSurface)
         return QImage();
 
+#ifndef QT_NO_DIRECTFB_PREALLOCATED
+    QImage ret(size(), QDirectFBScreen::getImageFormat(dfbSurface));
+    if (IDirectFBSurface *imgSurface = screen->createDFBSurface(ret, QDirectFBScreen::DontTrackSurface)) {
+        imgSurface->SetBlittingFlags(imgSurface, hasAlphaChannel() ? DSBLIT_BLEND_ALPHACHANNEL : DSBLIT_NOFX);
+        imgSurface->Blit(imgSurface, dfbSurface, 0, 0, 0);
+        imgSurface->ReleaseSource(imgSurface);
+        imgSurface->Release(imgSurface);
+        return ret;
+    }
+#endif
+
     QDirectFBPixmapData *that = const_cast<QDirectFBPixmapData*>(this);
     const QImage *img = that->buffer();
     return img->copy();
diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbscreen.cpp b/src/plugins/gfxdrivers/directfb/qdirectfbscreen.cpp
index fd6f48a..4ae64f7 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbscreen.cpp
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbscreen.cpp
@@ -171,7 +171,7 @@ IDirectFBSurface* QDirectFBScreen::createDFBSurface(const QImage &img, SurfaceCr
     }
 #endif
 #ifndef QT_NO_DIRECTFB_PALETTE
-    if (img.numColors() != 0)
+    if (img.numColors() != 0 && surface)
         QDirectFBScreen::setSurfaceColorTable(surface, img);
 #endif
     return surface;
@@ -185,9 +185,17 @@ IDirectFBSurface *QDirectFBScreen::copyDFBSurface(IDirectFBSurface *src,
     QSize size;
     src->GetSize(src, &size.rwidth(), &size.rheight());
     IDirectFBSurface *surface = createDFBSurface(size, format, options);
-    surface->SetBlittingFlags(surface, DSBLIT_NOFX);
+    DFBSurfacePixelFormat dspf;
+    src->GetPixelFormat(src, &dspf);
+    DFBSurfaceBlittingFlags flags = QDirectFBScreen::hasAlpha(dspf)
+                                    ? DSBLIT_BLEND_ALPHACHANNEL
+                                    : DSBLIT_NOFX;
+    if (flags & DSBLIT_BLEND_ALPHACHANNEL)
+        surface->Clear(surface, 0, 0, 0, 0);
+
+    surface->SetBlittingFlags(surface, flags);
     surface->Blit(surface, src, 0, 0, 0);
-    surface->ReleaseSource(surface); // ??? Is this always right?
+    surface->ReleaseSource(surface);
     return surface;
 }
 
@@ -218,8 +226,12 @@ IDirectFBSurface* QDirectFBScreen::createDFBSurface(const DFBSurfaceDescription
     if (d_ptr->videoonly && !(desc->flags & DSDESC_PREALLOCATED)) {
         // Add the video only capability. This means the surface will be created in video ram
         DFBSurfaceDescription voDesc = *desc;
-        voDesc.caps = DFBSurfaceCapabilities(voDesc.caps | DSCAPS_VIDEOONLY);
-        voDesc.flags = DFBSurfaceDescriptionFlags(voDesc.flags | DSDESC_CAPS);
+        if (!(voDesc.flags & DSDESC_CAPS)) {
+            voDesc.caps = DSCAPS_VIDEOONLY;
+            voDesc.flags = DFBSurfaceDescriptionFlags(voDesc.flags | DSDESC_CAPS);
+        } else {
+            voDesc.caps = DFBSurfaceCapabilities(voDesc.caps | DSCAPS_VIDEOONLY);
+        }
         result = d_ptr->dfb->CreateSurface(d_ptr->dfb, &voDesc, &newSurface);
     }
 
@@ -257,28 +269,36 @@ IDirectFBSurface *QDirectFBScreen::copyToDFBSurface(const QImage &img,
 #ifdef QT_NO_DIRECTFB_PREALLOCATED
         || image.format() != pixmapFormat
 #endif
+#ifdef QT_NO_DIRECTFB_PALETTE
+        || image.numColors() != 0
+#endif
         ) {
         image = image.convertToFormat(pixmapFormat);
     }
 
-
-    IDirectFBSurface *dfbSurface = createDFBSurface(img.size(), pixmapFormat, options);
+    IDirectFBSurface *dfbSurface = createDFBSurface(image.size(), pixmapFormat, options);
     if (!dfbSurface) {
         qWarning("QDirectFBPixmapData::fromImage() Couldn't create surface");
         return 0;
     }
 
 #ifndef QT_NO_DIRECTFB_PREALLOCATED
-    IDirectFBSurface *imgSurface = createDFBSurface(img, DontTrackSurface);
+    IDirectFBSurface *imgSurface = createDFBSurface(image, DontTrackSurface);
     if (!imgSurface) {
         qWarning("QDirectFBPixmapData::fromImage()");
         QDirectFBScreen::releaseDFBSurface(dfbSurface);
         return 0;
     }
+
     Q_ASSERT(imgSurface);
-    DFBResult result;
-    dfbSurface->SetBlittingFlags(dfbSurface, DSBLIT_NOFX);
-    result = dfbSurface->Blit(dfbSurface, imgSurface, 0, 0, 0);
+    DFBSurfaceBlittingFlags flags = img.hasAlphaChannel()
+                                    ? DSBLIT_BLEND_ALPHACHANNEL
+                                    : DSBLIT_NOFX;
+    if (flags & DSBLIT_BLEND_ALPHACHANNEL)
+        dfbSurface->Clear(dfbSurface, 0, 0, 0, 0);
+
+    dfbSurface->SetBlittingFlags(dfbSurface, flags);
+    DFBResult result = dfbSurface->Blit(dfbSurface, imgSurface, 0, 0, 0);
     if (result != DFB_OK)
         DirectFBError("QDirectFBPixmapData::fromImage()", result);
     dfbSurface->ReleaseSource(dfbSurface);
@@ -364,16 +384,6 @@ DFBSurfacePixelFormat QDirectFBScreen::getSurfacePixelFormat(QImage::Format form
     };
 }
 
-static inline  bool isPremultiplied(IDirectFBSurface *surface)
-{
-    Q_ASSERT(surface);
-    DFBSurfaceCapabilities caps;
-    const DFBResult result = surface->GetCapabilities(surface, &caps);
-    Q_ASSERT(result == DFB_OK);
-    Q_UNUSED(result);
-    return caps & DSCAPS_PREMULTIPLIED;
-}
-
 QImage::Format QDirectFBScreen::getImageFormat(IDirectFBSurface *surface)
 {
     DFBSurfacePixelFormat format;
@@ -1083,6 +1093,7 @@ void QDirectFBScreen::compose(const QRegion &region)
             blit(surface->image(), offset, r);
         }
     }
+    d_ptr->dfbSurface->ReleaseSource(d_ptr->dfbSurface);
 }
 
 // Normally, when using DirectFB to compose the windows (I.e. when
diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbscreen.h b/src/plugins/gfxdrivers/directfb/qdirectfbscreen.h
index a1e93c6..f394ac1 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbscreen.h
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbscreen.h
@@ -119,6 +119,7 @@ public:
     static QImage::Format getImageFormat(IDirectFBSurface *surface);
     static bool initSurfaceDescriptionPixelFormat(DFBSurfaceDescription *description, QImage::Format format);
     static inline bool isPremultiplied(QImage::Format format);
+    static inline bool hasAlpha(DFBSurfacePixelFormat format);
     QImage::Format alphaPixmapFormat() const;
 
 #ifndef QT_NO_DIRECTFB_PALETTE
@@ -151,6 +152,26 @@ inline bool QDirectFBScreen::isPremultiplied(QImage::Format format)
     return false;
 }
 
+inline bool QDirectFBScreen::hasAlpha(DFBSurfacePixelFormat format)
+{
+    switch (format) {
+    case DSPF_ARGB1555:
+    case DSPF_ARGB:
+    case DSPF_LUT8:
+    case DSPF_AiRGB:
+    case DSPF_A1:
+    case DSPF_ARGB2554:
+    case DSPF_ARGB4444:
+    case DSPF_AYUV:
+    case DSPF_A4:
+    case DSPF_ARGB1666:
+    case DSPF_ARGB6666:
+    case DSPF_LUT2:
+        return true;
+    default:
+        return false;
+    }
+}
 
 QT_END_HEADER
 
diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbsurface.cpp b/src/plugins/gfxdrivers/directfb/qdirectfbsurface.cpp
index ef208af..4b8fe0a 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbsurface.cpp
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbsurface.cpp
@@ -94,14 +94,26 @@ bool QDirectFBSurface::isValid() const
 #ifndef QT_NO_DIRECTFB_WM
 void QDirectFBSurface::createWindow()
 {
+#ifdef QT_NO_DIRECTFB_LAYER
+#warning QT_NO_DIRECTFB_LAYER requires QT_NO_DIRECTFB_WM
+#else
     IDirectFBDisplayLayer *layer = screen->dfbDisplayLayer();
     if (!layer)
         qFatal("QDirectFBWindowSurface: Unable to get primary display layer!");
 
-    DFBWindowDescription  description;
-    description.caps = DFBWindowCapabilities(DWCAPS_NODECORATION |
-                                             DWCAPS_ALPHACHANNEL);
-    description.flags = DWDESC_CAPS;
+    DFBWindowDescription description;
+    description.caps = DFBWindowCapabilities(DWCAPS_NODECORATION);
+    description.flags = DFBWindowDescriptionFlags(DWDESC_CAPS
+                                                  |DWDESC_SURFACE_CAPS
+                                                  |DWDESC_PIXELFORMAT);
+
+    description.surface_caps = DSCAPS_NONE;
+    if (screen->preferVideoOnly())
+        description.surface_caps = DFBSurfaceCapabilities(description.surface_caps|DSCAPS_VIDEOONLY);
+    const QImage::Format format = screen->pixelFormat();
+    description.pixelformat = QDirectFBScreen::getSurfacePixelFormat(format);
+    if (QDirectFBScreen::isPremultiplied(format))
+        description.surface_caps = DFBSurfaceCapabilities(DSCAPS_PREMULTIPLIED|description.caps);
 
     DFBResult result = layer->CreateWindow(layer, &description, &dfbWindow);
     if (result != DFB_OK)
@@ -111,6 +123,8 @@ void QDirectFBSurface::createWindow()
         dfbSurface->Release(dfbSurface);
 
     dfbWindow->GetSurface(dfbWindow, &dfbSurface);
+    forceRaster = (format == QImage::Format_RGB32);
+#endif
 }
 #endif // QT_NO_DIRECTFB_WM
 
@@ -143,6 +157,7 @@ void QDirectFBSurface::setGeometry(const QRect &rect, const QRegion &mask)
             IDirectFBSurface *primarySurface = screen->dfbSurface();
             Q_ASSERT(primarySurface);
             result = primarySurface->GetSubSurface(primarySurface, &r, &dfbSurface);
+            forceRaster = (dfbSurface && QDirectFBScreen::getImageFormat(dfbSurface) == QImage::Format_RGB32);
         } else {
 #ifdef QT_NO_DIRECTFB_WM
             if (isResize) {
@@ -162,8 +177,9 @@ void QDirectFBSurface::setGeometry(const QRect &rect, const QRegion &mask)
                 description.width = rect.width();
                 description.height = rect.height();
                 QDirectFBScreen::initSurfaceDescriptionPixelFormat(&description,
-                                                                   QDirectFBScreen::instance()->pixelFormat());
-                dfbSurface = QDirectFBScreen::instance()->createDFBSurface(&description, false);
+                                                                   screen->pixelFormat());
+                dfbSurface = screen->createDFBSurface(&description, false);
+                forceRaster = (dfbSurface && QDirectFBScreen::getImageFormat(dfbSurface) == QImage::Format_RGB32);
             } else {
                 Q_ASSERT(dfbSurface);
             }
@@ -250,7 +266,7 @@ bool QDirectFBSurface::scroll(const QRegion &region, int dx, int dy)
     dfbSurface->SetBlittingFlags(dfbSurface, DSBLIT_NOFX);
     dfbSurface->BatchBlit(dfbSurface, dfbSurface,
                           dfbRects.data(), dfbPoints.data(), n);
-
+    dfbSurface->ReleaseSource(dfbSurface);
     return true;
 }
 
@@ -318,6 +334,12 @@ inline bool isWidgetOpaque(const QWidget *w)
 void QDirectFBSurface::flush(QWidget *widget, const QRegion &region,
                              const QPoint &offset)
 {
+    Q_UNUSED(widget);
+#ifdef QT_NO_DIRECTFB_WM
+    Q_UNUSED(region);
+    Q_UNUSED(offset);
+#endif
+
     QWidget *win = window();
 
     // hw: make sure opacity information is updated before compositing