Merge branch 'lighthouse' of scm.dev.nokia.troll.no:qt/qt-lighthouse into lighthouse

9 files changed, 249 insertions, 103 deletions

diff --git a/src/plugins/graphicssystems/minimaldfb/minimaldfb.pro b/src/plugins/graphicssystems/minimaldfb/minimaldfb.pro
index d4c93fd..c3f20ff 100644
--- a/src/plugins/graphicssystems/minimaldfb/minimaldfb.pro
+++ b/src/plugins/graphicssystems/minimaldfb/minimaldfb.pro
@@ -1,13 +1,20 @@
 TARGET = qminimaldfb
 include(../../qpluginbase.pri)
-
 QTDIR_build:DESTDIR = $$QT_BUILD_TREE/plugins/graphicssystems
-
-QMAKE_CXXFLAGS += -I/usr/include/directfb
-LIBS += -ldirectfb -lfusion -ldirect -lpthread
-
-SOURCES = main.cpp qgraphicssystem_minimaldfb.cpp qwindowsurface_minimaldfb.cpp
-HEADERS = qgraphicssystem_minimaldfb.h qwindowsurface_minimaldfb.h
-
+QMAKE_CXXFLAGS += -I/usr/local/include/directfb
+LIBS += -L/usr/local/lib \
+    -ldirectfb \
+    -lfusion \
+    -ldirect \
+    -lpthread
+SOURCES = main.cpp \
+    qgraphicssystem_minimaldfb.cpp \
+    qwindowsurface_minimaldfb.cpp \
+    qblitter_directfb.cpp \
+    qdirectfbconvenience.cpp
+HEADERS = qgraphicssystem_minimaldfb.h \
+    qwindowsurface_minimaldfb.h \
+    qblitter_directfb.h \
+    qdirectfbconvenience.h
 target.path += $$[QT_INSTALL_PLUGINS]/graphicssystems
 INSTALLS += target
diff --git a/src/plugins/graphicssystems/minimaldfb/qblitter_directfb.cpp b/src/plugins/graphicssystems/minimaldfb/qblitter_directfb.cpp
new file mode 100644
index 0000000..05221ce
--- /dev/null
+++ b/src/plugins/graphicssystems/minimaldfb/qblitter_directfb.cpp
@@ -0,0 +1,88 @@
+#include "qblitter_directfb.h"
+#include "qgraphicssystem_minimaldfb.h"
+#include "qdirectfbconvenience.h"
+
+#include <QtGui/private/qpixmap_blitter_p.h>
+
+#include <QDebug>
+
+#include <directfb.h>
+
+QDirectFbBlitter::QDirectFbBlitter(const QRect &rect, IDirectFBSurface *surface)
+        : QBlittable(rect, QBlittable::Capabilities(QBlittable::SolidRectCapability
+                                                          |QBlittable::SourcePixmapCapability
+                                                          |QBlittable::SourceOverPixmapCapability
+                                                          |QBlittable::SourceOverScaledPixmapCapability))
+{
+    if (surface) {
+        m_surface = surface;
+    } else {
+        DFBSurfaceDescription surfaceDesc;
+        surfaceDesc.width = rect.width();
+        surfaceDesc.height = rect.height();
+        surfaceDesc.flags = DFBSurfaceDescriptionFlags(DSDESC_WIDTH | DSDESC_HEIGHT);
+
+        IDirectFB *dfb = QDirectFbConvenience::dfbInterface();
+        dfb->CreateSurface(dfb,&surfaceDesc, &m_surface);
+    }
+}
+
+void QDirectFbBlitter::fillRect(const QRectF &rect, const QColor &color)
+{
+    m_surface->SetColor(m_surface, color.red(), color.green(), color.blue(), color.alpha());
+    m_surface->SetDrawingFlags(m_surface, DSDRAW_NOFX);
+    m_surface->FillRectangle(m_surface, rect.x(), rect.y(),
+                              rect.width(), rect.height());
+}
+
+void QDirectFbBlitter::drawPixmap(const QRectF &rect, const QPixmap &pixmap, const QRectF &srcRect)
+{
+    quint32 blittingFlags = pixmap.hasAlphaChannel() ? DSBLIT_BLEND_ALPHACHANNEL : DSBLIT_NOFX;
+
+    m_surface->SetBlittingFlags(m_surface, DFBSurfaceBlittingFlags(blittingFlags));
+    m_surface->SetColor(m_surface, 0xff, 0xff, 0xff, 255);
+
+    QPixmapData *data = pixmap.pixmapData();
+    Q_ASSERT(data->classId() == QPixmapData::BlitterClass);
+    QBlittablePixmapData *blitPm = static_cast<QBlittablePixmapData*>(data);
+    QDirectFbBlitter *dfbBlitter = static_cast<QDirectFbBlitter *>(blitPm->blittable());
+
+    IDirectFBSurface *s = dfbBlitter->m_surface;
+    const DFBRectangle sRect = { srcRect.x(), srcRect.y(), rect.width(), rect.height() };
+
+    DFBResult result;
+    if (rect.width() == srcRect.width() && rect.height() == srcRect.height())
+        result = m_surface->Blit(m_surface, s, &sRect, rect.x(), rect.y());
+    else {
+        const DFBRectangle dRect = { rect.x(), rect.y(), rect.width(), rect.height() };
+        result = m_surface->StretchBlit(m_surface, s, &sRect, &dRect);
+    }
+    if (result != DFB_OK)
+        DirectFBError("QDirectFBBlitter::drawPixmap()", result);
+
+}
+
+QImage *QDirectFbBlitter::doLock()
+{
+    Q_ASSERT(m_surface);
+    Q_ASSERT(rect().isValid());
+
+    void *mem;
+    int bpl;
+    const DFBResult result = m_surface->Lock(m_surface, DFBSurfaceLockFlags(DSLF_WRITE|DSLF_READ), static_cast<void**>(&mem), &bpl);
+    if (result == DFB_OK) {
+        QImage::Format format = QDirectFbConvenience::imageFormatFromSurface(m_surface);
+        int w, h;
+        m_surface->GetSize(m_surface,&w,&h);
+        m_image = QImage(static_cast<uchar *>(mem),w,h,format);
+    } else {
+        DirectFBError("Failed to lock image", result);
+    }
+
+    return &m_image;
+}
+
+void QDirectFbBlitter::doUnlock()
+{
+    m_surface->Unlock(m_surface);
+}
diff --git a/src/plugins/graphicssystems/minimaldfb/qblitter_directfb.h b/src/plugins/graphicssystems/minimaldfb/qblitter_directfb.h
new file mode 100644
index 0000000..252bf80
--- /dev/null
+++ b/src/plugins/graphicssystems/minimaldfb/qblitter_directfb.h
@@ -0,0 +1,25 @@
+#ifndef QDIRECTFBBLITTER_H
+#define QDIRECTFBBLITTER_H
+
+#include <private/qpaintengine_blitter_p.h>
+
+#include <directfb/directfb.h>
+
+class QDirectFbBlitter : public QBlittable
+{
+public:
+    QDirectFbBlitter(const QRect &rect, IDirectFBSurface *surface = 0);
+    virtual ~QDirectFbBlitter(){ }
+
+    virtual void fillRect(const QRectF &rect, const QColor &color);
+    virtual void drawPixmap(const QRectF &rect, const QPixmap &pixmap, const QRectF &subrect);
+
+protected:
+    virtual QImage *doLock();
+    virtual void doUnlock();
+
+    IDirectFBSurface *m_surface;
+    QImage m_image;
+};
+
+#endif // QDIRECTFBBLITTER_H
diff --git a/src/plugins/graphicssystems/minimaldfb/qdirectfbconvenience.cpp b/src/plugins/graphicssystems/minimaldfb/qdirectfbconvenience.cpp
new file mode 100644
index 0000000..d958482
--- /dev/null
+++ b/src/plugins/graphicssystems/minimaldfb/qdirectfbconvenience.cpp
@@ -0,0 +1,43 @@
+#include "qdirectfbconvenience.h"
+
+IDirectFB *QDirectFbConvenience::dfb = 0;
+
+QImage::Format QDirectFbConvenience::imageFormatFromSurface(IDirectFBSurface *surface)
+{
+    DFBSurfacePixelFormat format;
+    surface->GetPixelFormat(surface, &format);
+
+    switch (format) {
+    case DSPF_LUT8:
+        return QImage::Format_Indexed8;
+    case DSPF_RGB24:
+        return QImage::Format_RGB888;
+    case DSPF_ARGB4444:
+        return QImage::Format_ARGB4444_Premultiplied;
+    case DSPF_RGB444:
+        return QImage::Format_RGB444;
+    case DSPF_RGB555:
+    case DSPF_ARGB1555:
+        return QImage::Format_RGB555;
+    case DSPF_RGB16:
+        return QImage::Format_RGB16;
+    case DSPF_ARGB6666:
+        return QImage::Format_ARGB6666_Premultiplied;
+    case DSPF_RGB18:
+        return QImage::Format_RGB666;
+    case DSPF_RGB32:
+        return QImage::Format_RGB32;
+    case DSPF_ARGB: {
+            DFBSurfaceCapabilities caps;
+            const DFBResult result = surface->GetCapabilities(surface, &caps);
+            Q_ASSERT(result == DFB_OK);
+            Q_UNUSED(result);
+            return (caps & DSCAPS_PREMULTIPLIED
+                    ? QImage::Format_ARGB32_Premultiplied
+                        : QImage::Format_ARGB32); }
+    default:
+        break;
+    }
+    return QImage::Format_Invalid;
+
+}
diff --git a/src/plugins/graphicssystems/minimaldfb/qdirectfbconvenience.h b/src/plugins/graphicssystems/minimaldfb/qdirectfbconvenience.h
new file mode 100644
index 0000000..7e426db
--- /dev/null
+++ b/src/plugins/graphicssystems/minimaldfb/qdirectfbconvenience.h
@@ -0,0 +1,22 @@
+#ifndef QDIRECTFBCONVENIENCE_H
+#define QDIRECTFBCONVENIENCE_H
+
+#include <QtGui/qimage.h>
+
+#include <directfb/directfb.h>
+
+class QDirectFbConvenience
+{
+public:
+    static QImage::Format imageFormatFromSurface(IDirectFBSurface *surface);
+
+    //This is set by the graphicssystem constructor
+    static IDirectFB *dfbInterface() { return dfb; }
+
+private:
+    static void setDfbInterface(IDirectFB *dfbInterface) {dfb = dfbInterface;}
+    static IDirectFB *dfb;
+    friend class QDirectFbGraphicsSystem;
+};
+
+#endif // QDIRECTFBCONVENIENCE_H
diff --git a/src/plugins/graphicssystems/minimaldfb/qgraphicssystem_minimaldfb.cpp b/src/plugins/graphicssystems/minimaldfb/qgraphicssystem_minimaldfb.cpp
index bf46d4c..117e4b5 100644
--- a/src/plugins/graphicssystems/minimaldfb/qgraphicssystem_minimaldfb.cpp
+++ b/src/plugins/graphicssystems/minimaldfb/qgraphicssystem_minimaldfb.cpp
@@ -41,7 +41,14 @@
 
 #include "qgraphicssystem_minimaldfb.h"
 #include "qwindowsurface_minimaldfb.h"
-#include <QtGui/private/qpixmap_raster_p.h>
+#include "qblitter_directfb.h"
+#include "qdirectfbconvenience.h"
+
+#include <private/qwindowsurface_raster_p.h>
+#include <private/qpixmap_raster_p.h>
+
+#include <private/qpixmap_blitter_p.h>
+#include <private/qpixmapdata_p.h>
 #include <QCoreApplication>
 #include <directfb.h>
 
@@ -51,7 +58,7 @@ QDirectFbGraphicsSystemScreen::QDirectFbGraphicsSystemScreen(IDirectFB *dfb, int
 {
     DFBResult result  = dfb->GetDisplayLayer(dfb, DLID_PRIMARY, &m_layer);
     if (result != DFB_OK) {
-        DirectFBError("QDirectFbGraphicsSystemScreen::connect: "
+        DirectFBError("QDirectFbGraphicsSystemScreen "
                       "Unable to get primary display layer!", result);
     }
     m_layer->SetCooperativeLevel(m_layer,DLSCL_SHARED);
@@ -59,7 +66,7 @@ QDirectFbGraphicsSystemScreen::QDirectFbGraphicsSystemScreen(IDirectFB *dfb, int
     IDirectFBSurface *topLevelSurface;
     //This line gives a warning
     m_layer->GetSurface(m_layer, &topLevelSurface);
-    m_format = QDirectFbGraphicsSystem::imageFormatFromSurface(topLevelSurface);
+    m_format = QDirectFbConvenience::imageFormatFromSurface(topLevelSurface);
 
     result = m_layer->GetScreen(m_layer,&m_screen);
     if (result != DFB_OK) {
@@ -67,9 +74,9 @@ QDirectFbGraphicsSystemScreen::QDirectFbGraphicsSystemScreen(IDirectFB *dfb, int
     }
 
     int w(0),h(0);
+
     //Asking the screen for its size gives the desktop geometry on X11
-    //Thats not something we want, so as the topLevelSorface instead
-//    m_screen->GetSize(m_screen,&w,&h);
+    //Thats not something we want, so ask the topLevelSorface instead
     topLevelSurface->GetSize(topLevelSurface,&w,&h);
 
     m_geometry = QRect(0,0,w,h);
@@ -106,31 +113,32 @@ IDirectFBWindow *QDirectFbGraphicsSystemScreen::createWindow(const QRect &rect)
     return window;
 }
 
+
 QDirectFbGraphicsSystem::QDirectFbGraphicsSystem()
 {
+    IDirectFB *dfb;
     DFBResult result = DFB_OK;
 
-    {   // pass command line arguments to DirectFB
-        const QStringList args = QCoreApplication::arguments();
-        int argc = args.size();
-        char **argv = new char*[argc];
+    const QStringList args = QCoreApplication::arguments();
+    int argc = args.size();
+    char **argv = new char*[argc];
 
-        for (int i = 0; i < argc; ++i)
-            argv[i] = qstrdup(args.at(i).toLocal8Bit().constData());
+    for (int i = 0; i < argc; ++i)
+        argv[i] = qstrdup(args.at(i).toLocal8Bit().constData());
 
-        result = DirectFBInit(&argc, &argv);
-        if (result != DFB_OK) {
-            DirectFBError("QDirectFBScreen: error initializing DirectFB",
-                          result);
-        }
-        delete[] argv;
+    result = DirectFBInit(&argc, &argv);
+    if (result != DFB_OK) {
+        DirectFBError("QDirectFBScreen: error initializing DirectFB",
+                      result);
     }
+    delete[] argv;
 
     result = DirectFBCreate(&dfb);
     if (result != DFB_OK) {
         DirectFBError("QDirectFBScreen: error creating DirectFB interface",
                       result);
     }
+    QDirectFbConvenience::setDfbInterface(dfb);
 
     mPrimaryScreen = new QDirectFbGraphicsSystemScreen(dfb,0);
     mScreens.append(mPrimaryScreen);
@@ -138,7 +146,7 @@ QDirectFbGraphicsSystem::QDirectFbGraphicsSystem()
 
 QPixmapData *QDirectFbGraphicsSystem::createPixmapData(QPixmapData::PixelType type) const
 {
-    return new QRasterPixmapData(type);
+    return new QBlittablePixmapData(type);
 }
 
 QWindowSurface *QDirectFbGraphicsSystem::createWindowSurface(QWidget *widget) const
@@ -146,44 +154,9 @@ QWindowSurface *QDirectFbGraphicsSystem::createWindowSurface(QWidget *widget) co
     return new QDirectFbWindowSurface (mPrimaryScreen, widget);
 }
 
-QImage::Format QDirectFbGraphicsSystem::imageFormatFromSurface(IDirectFBSurface *surface)
+QBlittable *QDirectFbGraphicsSystem::createBlittable(const QRect &rect) const
 {
-    DFBSurfacePixelFormat format;
-    surface->GetPixelFormat(surface, &format);
-
-    switch (format) {
-    case DSPF_LUT8:
-        return QImage::Format_Indexed8;
-    case DSPF_RGB24:
-        return QImage::Format_RGB888;
-    case DSPF_ARGB4444:
-        return QImage::Format_ARGB4444_Premultiplied;
-    case DSPF_RGB444:
-        return QImage::Format_RGB444;
-    case DSPF_RGB555:
-    case DSPF_ARGB1555:
-        return QImage::Format_RGB555;
-    case DSPF_RGB16:
-        return QImage::Format_RGB16;
-    case DSPF_ARGB6666:
-        return QImage::Format_ARGB6666_Premultiplied;
-    case DSPF_RGB18:
-        return QImage::Format_RGB666;
-    case DSPF_RGB32:
-        return QImage::Format_RGB32;
-    case DSPF_ARGB: {
-            DFBSurfaceCapabilities caps;
-            const DFBResult result = surface->GetCapabilities(surface, &caps);
-            Q_ASSERT(result == DFB_OK);
-            Q_UNUSED(result);
-            return (caps & DSCAPS_PREMULTIPLIED
-                    ? QImage::Format_ARGB32_Premultiplied
-                        : QImage::Format_ARGB32); }
-    default:
-        break;
-    }
-    return QImage::Format_Invalid;
-
+    return new QDirectFbBlitter(rect);
 }
 
 QT_END_NAMESPACE
diff --git a/src/plugins/graphicssystems/minimaldfb/qgraphicssystem_minimaldfb.h b/src/plugins/graphicssystems/minimaldfb/qgraphicssystem_minimaldfb.h
index fbc5498..462e963 100644
--- a/src/plugins/graphicssystems/minimaldfb/qgraphicssystem_minimaldfb.h
+++ b/src/plugins/graphicssystems/minimaldfb/qgraphicssystem_minimaldfb.h
@@ -77,13 +77,13 @@ public:
 
     QPixmapData *createPixmapData(QPixmapData::PixelType type) const;
     QWindowSurface *createWindowSurface(QWidget *widget) const;
+    QBlittable *createBlittable(const QRect &rect) const;
 
     QList<QGraphicsSystemScreen *> screens() const { return mScreens; }
 
-    static QImage::Format imageFormatFromSurface(IDirectFBSurface *surface);
+
 
 private:
-    IDirectFB *dfb;
     QDirectFbGraphicsSystemScreen *mPrimaryScreen;
     QList<QGraphicsSystemScreen *> mScreens;
 };
diff --git a/src/plugins/graphicssystems/minimaldfb/qwindowsurface_minimaldfb.cpp b/src/plugins/graphicssystems/minimaldfb/qwindowsurface_minimaldfb.cpp
index e75a43c..3dcf5be 100644
--- a/src/plugins/graphicssystems/minimaldfb/qwindowsurface_minimaldfb.cpp
+++ b/src/plugins/graphicssystems/minimaldfb/qwindowsurface_minimaldfb.cpp
@@ -41,6 +41,9 @@
 
 #include "qwindowsurface_minimaldfb.h"
 #include "qgraphicssystem_minimaldfb.h"
+#include "qblitter_directfb.h"
+#include <private/qpixmap_blitter_p.h>
+
 #include <QtCore/qdebug.h>
 
 QT_BEGIN_NAMESPACE
@@ -55,6 +58,15 @@ QDirectFbWindowSurface::QDirectFbWindowSurface
     if (result != DFB_OK) {
         DirectFBError("QDirectFbWindowSurface::QDirectFbWindowSurface: unable to get windows surface",result);
     }
+    QDirectFbBlitter *blitter = new QDirectFbBlitter(window->rect(), m_dfbSurface);
+    pmdata = new QBlittablePixmapData(QPixmapData::PixmapType);
+    int width,height;
+    m_dfbSurface->GetSize(m_dfbSurface, &width, &height);
+    pmdata->resize(width,height);
+    pmdata->setBlittable(blitter);
+
+    m_pixmap = new QPixmap(pmdata);
+
 }
 
 QDirectFbWindowSurface::~QDirectFbWindowSurface()
@@ -63,7 +75,7 @@ QDirectFbWindowSurface::~QDirectFbWindowSurface()
 
 QPaintDevice *QDirectFbWindowSurface::paintDevice()
 {
-    return m_image;
+    return m_pixmap;
 }
 
 void QDirectFbWindowSurface::flush(QWidget *widget, const QRegion &region, const QPoint &offset)
@@ -71,6 +83,7 @@ void QDirectFbWindowSurface::flush(QWidget *widget, const QRegion &region, const
     Q_UNUSED(widget);
     Q_UNUSED(offset);
 
+    m_dfbSurface->Unlock(m_dfbSurface);
     const quint8 windowOpacity = quint8(widget->windowOpacity() * 0xff);
     m_dfbWindow->SetOpacity(m_dfbWindow,windowOpacity);
 
@@ -84,24 +97,21 @@ void QDirectFbWindowSurface::flush(QWidget *widget, const QRegion &region, const
 
 void QDirectFbWindowSurface::setGeometry(const QRect &rect)
 {
-//    qDebug() << "QDirectF.bWindowSurface::setGeometry:" << (long)this << rect;
-    bool wasLocked = false;
-    if (m_lock){
-        m_dfbSurface->Unlock(m_dfbSurface);
-        wasLocked = true;
-    }
     m_dfbSurface->Release(m_dfbSurface);
     QWindowSurface::setGeometry(rect);
     m_dfbWindow->SetBounds(m_dfbWindow, rect.x(),rect.y(),
                            rect.width(), rect.height());
-//    m_dfbWindow->Resize(m_dfbWindow,rect.width(),rect.height());
-//    m_dfbWindow->MoveTo(m_dfbWindow,rect.x(),rect.y());
     DFBResult result = m_dfbWindow->GetSurface(m_dfbWindow,&m_dfbSurface);
     if (result != DFB_OK)
-        qDebug() << "could not resurface";
+        DirectFBError("QDirectFbWindowSurface::setGeometry() failed to retrieve new surface",result);
+
+    QPixmap *oldpixmap = m_pixmap;
+    QDirectFbBlitter *blitter = new QDirectFbBlitter(rect, m_dfbSurface);
+    pmdata->resize(rect.width(),rect.height());
+    pmdata->setBlittable(blitter);
+    m_pixmap = new QPixmap(pmdata);
+    delete oldpixmap;
 
-    if (wasLocked)
-        lockSurfaceToImage();
 }
 
 bool QDirectFbWindowSurface::scroll(const QRegion &area, int dx, int dy)
@@ -112,36 +122,11 @@ bool QDirectFbWindowSurface::scroll(const QRegion &area, int dx, int dy)
 void QDirectFbWindowSurface::beginPaint(const QRegion &region)
 {
     Q_UNUSED(region);
-    if (!m_lock)
-        lockSurfaceToImage();
 }
 
 void QDirectFbWindowSurface::endPaint(const QRegion &region)
 {
     Q_UNUSED(region);
-    if (m_lock){
-        m_dfbSurface->Unlock(m_dfbSurface);
-        m_lock = false;
-    }
-}
-
-void QDirectFbWindowSurface::lockSurfaceToImage()
-{
-    if (m_lock)
-        return;
-    m_lock = true;
-
-    int w,h;
-    m_dfbSurface->GetSize(m_dfbSurface,&w,&h);
-    uchar *data;
-    int bpl;
-    DFBResult result = m_dfbSurface->Lock(m_dfbSurface,static_cast<DFBSurfaceLockFlags>(DSLF_READ|DSLF_WRITE),reinterpret_cast<void **>(&data),&bpl);
-    if (!result == DFB_OK) {
-        DirectFBError("QDirectFbWindowSurface::lockSurfaceToImage() failed to lock surface",result);
-        return;
-    }
-    QImage::Format format = QDirectFbGraphicsSystem::imageFormatFromSurface(m_dfbSurface);
-    m_image = new QImage(data,w,h,bpl,format);
 }
 
 QT_END_NAMESPACE
diff --git a/src/plugins/graphicssystems/minimaldfb/qwindowsurface_minimaldfb.h b/src/plugins/graphicssystems/minimaldfb/qwindowsurface_minimaldfb.h
index fe88878..98575ff 100644
--- a/src/plugins/graphicssystems/minimaldfb/qwindowsurface_minimaldfb.h
+++ b/src/plugins/graphicssystems/minimaldfb/qwindowsurface_minimaldfb.h
@@ -43,6 +43,8 @@
 #define QWINDOWSURFACE_MINIMAL_H
 
 #include <QtGui/private/qwindowsurface_p.h>
+#include <private/qpixmap_blitter_p.h>
+
 #include <directfb.h>
 
 QT_BEGIN_NAMESPACE
@@ -68,7 +70,8 @@ private:
     void lockSurfaceToImage();
 
     QDirectFbGraphicsSystemScreen *m_screen;
-    QImage *m_image;
+    QPixmap *m_pixmap;
+    QBlittablePixmapData *pmdata;
     bool m_lock;
 
     IDirectFBWindow *m_dfbWindow;