Merge branch 'master' of git@scm.dev.nokia.troll.no:qt/qt into qtscript-jsc-backend

Conflicts:
	src/script/qscriptclass.cpp
	src/script/qscriptcontext.cpp
	src/script/qscriptengine.cpp
	src/script/qscriptvalue.cpp

4 files changed, 173 insertions, 109 deletions

diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbscreen.cpp b/src/plugins/gfxdrivers/directfb/qdirectfbscreen.cpp
index a1edbd6..774162c 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbscreen.cpp
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbscreen.cpp
@@ -64,13 +64,16 @@ public:
     QPixmapData *createPixmapData(QPixmapData::PixelType type) const;
 
     IDirectFB *dfb;
-    IDirectFBSurface *dfbSurface;
     DFBSurfaceFlipFlags flipFlags;
+    QDirectFBScreen::DirectFBFlags directFBFlags;
+    QImage::Format alphaPixmapFormat;
+    IDirectFBScreen *dfbScreen;
+#ifdef QT_NO_DIRECTFB_WM
+    IDirectFBSurface *primarySurface;
+#endif
 #ifndef QT_NO_DIRECTFB_LAYER
     IDirectFBDisplayLayer *dfbLayer;
 #endif
-    IDirectFBScreen *dfbScreen;
-
     QSet<IDirectFBSurface*> allocatedSurfaces;
 
 #ifndef QT_NO_DIRECTFB_MOUSE
@@ -79,26 +82,26 @@ public:
 #ifndef QT_NO_DIRECTFB_KEYBOARD
     QDirectFBKeyboardHandler *keyboard;
 #endif
-    QDirectFBScreen::DirectFBFlags directFBFlags;
-    QImage::Format alphaPixmapFormat;
     QColor backgroundColor;
     QDirectFBScreen *q;
 };
 
 QDirectFBScreenPrivate::QDirectFBScreenPrivate(QDirectFBScreen *qptr)
-    : QWSGraphicsSystem(qptr), dfb(0), dfbSurface(0), flipFlags(DSFLIP_NONE)
+    : QWSGraphicsSystem(qptr), dfb(0), flipFlags(DSFLIP_NONE),
+      directFBFlags(QDirectFBScreen::NoFlags), alphaPixmapFormat(QImage::Format_Invalid),
+      dfbScreen(0)
+#ifdef QT_NO_DIRECTFB_WM
+    , primarySurface(0)
+#endif
 #ifndef QT_NO_DIRECTFB_LAYER
     , dfbLayer(0)
 #endif
-    , dfbScreen(0)
 #ifndef QT_NO_DIRECTFB_MOUSE
     , mouse(0)
 #endif
 #ifndef QT_NO_DIRECTFB_KEYBOARD
     , keyboard(0)
 #endif
-    , directFBFlags(QDirectFBScreen::NoFlags)
-    , alphaPixmapFormat(QImage::Format_Invalid)
     , q(qptr)
 {
 #ifndef QT_NO_QWS_SIGNALHANDLER
@@ -119,8 +122,10 @@ QDirectFBScreenPrivate::~QDirectFBScreenPrivate()
         (*it)->Release(*it);
     }
 
-    if (dfbSurface)
-        dfbSurface->Release(dfbSurface);
+#ifdef QT_NO_DIRECTFB_WM
+    if (primarySurface)
+        primarySurface->Release(primarySurface);
+#endif
 
 #ifndef QT_NO_DIRECTFB_LAYER
     if (dfbLayer)
@@ -366,10 +371,12 @@ IDirectFB *QDirectFBScreen::dfb()
     return d_ptr->dfb;
 }
 
-IDirectFBSurface *QDirectFBScreen::dfbSurface()
+#ifdef QT_NO_DIRECTFB_WM
+IDirectFBSurface *QDirectFBScreen::primarySurface()
 {
-    return d_ptr->dfbSurface;
+    return d_ptr->primarySurface;
 }
+#endif
 
 #ifndef QT_NO_DIRECTFB_LAYER
 IDirectFBDisplayLayer *QDirectFBScreen::dfbDisplayLayer()
@@ -863,6 +870,36 @@ static inline bool setIntOption(const QStringList &arguments, const QString &var
     return false;
 }
 
+static inline int depth(QImage::Format format)
+{
+    switch (format) {
+    case QImage::Format_Mono:
+    case QImage::Format_MonoLSB:
+        return 1;
+    case QImage::Format_Indexed8:
+        return 8;
+    case QImage::Format_RGB32:
+    case QImage::Format_ARGB32:
+    case QImage::Format_ARGB32_Premultiplied:
+        return 32;
+    case QImage::Format_ARGB8565_Premultiplied:
+    case QImage::Format_RGB666:
+    case QImage::Format_ARGB6666_Premultiplied:
+    case QImage::Format_ARGB8555_Premultiplied:
+    case QImage::Format_RGB888:
+        return 24;
+    case QImage::Format_RGB555:
+    case QImage::Format_RGB444:
+    case QImage::Format_RGB16:
+    case QImage::Format_ARGB4444_Premultiplied:
+        return 16;
+    case QImage::Format_Invalid:
+    case QImage::NImageFormats:
+        break;
+    }
+    return -1;
+}
+
 bool QDirectFBScreen::connect(const QString &displaySpec)
 {
     DFBResult result = DFB_OK;
@@ -923,7 +960,9 @@ bool QDirectFBScreen::connect(const QString &displaySpec)
 
     DFBSurfaceDescription description;
     memset(&description, 0, sizeof(DFBSurfaceDescription));
+    IDirectFBSurface *surface;
 
+#ifdef QT_NO_DIRECTFB_WM
     description.flags = DSDESC_CAPS;
     if (::setIntOption(displayArgs, QLatin1String("width"), &description.width))
         description.flags |= DSDESC_WIDTH;
@@ -952,15 +991,22 @@ bool QDirectFBScreen::connect(const QString &displaySpec)
     }
 
     // We don't track the primary surface as it's released in disconnect
-    d_ptr->dfbSurface = createDFBSurface(description, DontTrackSurface);
-    if (!d_ptr->dfbSurface) {
+    d_ptr->primarySurface = createDFBSurface(description, DontTrackSurface);
+    if (!d_ptr->primarySurface) {
         DirectFBError("QDirectFBScreen: error creating primary surface",
                       result);
         return false;
     }
 
+    surface = d_ptr->primarySurface;
+#else
+    description.flags = DSDESC_WIDTH|DSDESC_HEIGHT;
+    description.width = description.height = 1;
+    surface = createDFBSurface(description, DontTrackSurface);
+#endif
     // Work out what format we're going to use for surfaces with an alpha channel
-    d_ptr->alphaPixmapFormat = QDirectFBScreen::getImageFormat(d_ptr->dfbSurface);
+    d_ptr->alphaPixmapFormat = QDirectFBScreen::getImageFormat(surface);
+
     setPixelFormat(d_ptr->alphaPixmapFormat);
     switch (d_ptr->alphaPixmapFormat) {
     case QImage::Format_RGB666:
@@ -994,31 +1040,11 @@ bool QDirectFBScreen::connect(const QString &displaySpec)
         // works already
         break;
     }
-    d_ptr->dfbSurface->GetSize(d_ptr->dfbSurface, &w, &h);
 
+    QScreen::d = ::depth(pixelFormat());
     data = 0;
     lstep = 0;
     size = 0;
-    dw = w;
-    dh = h;
-
-    DFBSurfacePixelFormat format;
-    result = d_ptr->dfbSurface->GetPixelFormat(d_ptr->dfbSurface, &format);
-    if (result == DFB_OK)
-        QScreen::d = depth(format);
-    else
-        DirectFBError("QDirectFBScreen: error getting surface format", result);
-
-    setPixelFormat(getImageFormat(d_ptr->dfbSurface));
-
-    physWidth = physHeight = -1;
-    ::setIntOption(displayArgs, QLatin1String("mmWidth"), &physWidth);
-    ::setIntOption(displayArgs, QLatin1String("mmHeight"), &physHeight);
-    const int dpi = 72;
-    if (physWidth < 0)
-        physWidth = qRound(dw * 25.4 / dpi);
-    if (physHeight < 0)
-        physHeight = qRound(dh * 25.4 / dpi);
 
 #ifndef QT_NO_DIRECTFB_LAYER
     result = d_ptr->dfb->GetDisplayLayer(d_ptr->dfb, DLID_PRIMARY,
@@ -1037,12 +1063,35 @@ bool QDirectFBScreen::connect(const QString &displaySpec)
                       "Unable to get screen!", result);
         return false;
     }
+    result = d_ptr->dfbScreen->GetSize(d_ptr->dfbScreen, &w, &h);
+    if (result != DFB_OK) {
+        DirectFBError("QDirectFBScreen::connect: "
+                      "Unable to get screen size!", result);
+        return false;
+    }
+
+    dw = w;
+    dh = h;
+
+    Q_ASSERT(dw != 0 && dh != 0);
+
+    physWidth = physHeight = -1;
+    ::setIntOption(displayArgs, QLatin1String("mmWidth"), &physWidth);
+    ::setIntOption(displayArgs, QLatin1String("mmHeight"), &physHeight);
+    const int dpi = 72;
+    if (physWidth < 0)
+        physWidth = qRound(dw * 25.4 / dpi);
+    if (physHeight < 0)
+        physHeight = qRound(dh * 25.4 / dpi);
 
     setGraphicsSystem(d_ptr);
 
 #if (Q_DIRECTFB_VERSION >= 0x000923)
     if (displayArgs.contains(QLatin1String("debug"), Qt::CaseInsensitive))
-        printDirectFBInfo(d_ptr->dfb, d_ptr->dfbSurface);
+        printDirectFBInfo(d_ptr->dfb, surface);
+#endif
+#ifndef QT_NO_DIRECTFB_WM
+    surface->Release(surface);
 #endif
 
     QRegExp backgroundColorRegExp("bgcolor=?(.+)");
@@ -1058,8 +1107,10 @@ bool QDirectFBScreen::connect(const QString &displaySpec)
 
 void QDirectFBScreen::disconnect()
 {
-    d_ptr->dfbSurface->Release(d_ptr->dfbSurface);
-    d_ptr->dfbSurface = 0;
+#ifdef QT_NO_DIRECTFB_WM
+    d_ptr->primarySurface->Release(d_ptr->primarySurface);
+    d_ptr->primarySurface = 0;
+#endif
 
     foreach (IDirectFBSurface *surf, d_ptr->allocatedSurfaces)
         surf->Release(surf);
@@ -1155,25 +1206,9 @@ QWSWindowSurface *QDirectFBScreen::createSurface(const QString &key) const
 // QT_NO_DIRECTFB_WM isn't set), exposeRegion will simply return. If
 // QT_NO_DIRECTFB_WM is set, exposeRegion will compose only non-directFB
 // window surfaces. Normal, directFB surfaces are handled by DirectFB.
-static inline bool needExposeRegion()
-{
-#ifdef QT_NO_DIRECTFB_WM
-    return true;
-#endif
-#ifdef QT_NO_DIRECTFB_LAYER
-#ifndef QT_NO_QWS_CURSOR
-    return true;
-#endif
-#endif
-    return false;
-}
-
 void QDirectFBScreen::exposeRegion(QRegion r, int changing)
 {
-    if (!needExposeRegion()) {
-        return;
-    }
-
+#ifdef QT_NO_DIRECTFB_WM
     const QList<QWSWindow*> windows = QWSServer::instance()->clientWindows();
     if (changing < 0 || changing >= windows.size())
         return;
@@ -1207,9 +1242,9 @@ void QDirectFBScreen::exposeRegion(QRegion r, int changing)
                     const DFBRectangle rect = {
                         source.x(), source.y(), source.width(), source.height()
                     };
-                    d_ptr->dfbSurface->Blit(d_ptr->dfbSurface, surface, &rect,
-                                            windowGeometry.x() + source.x(),
-                                            windowGeometry.y() + source.y());
+                    d_ptr->primarySurface->Blit(d_ptr->primarySurface, surface, &rect,
+                                                windowGeometry.x() + source.x(),
+                                                windowGeometry.y() + source.y());
                 } else {
                     const QVector<QRect> rects = insideWindow.rects();
                     QVarLengthArray<DFBRectangle, 16> dfbRectangles(n);
@@ -1225,8 +1260,8 @@ void QDirectFBScreen::exposeRegion(QRegion r, int changing)
                         dfbPoints[i].x = (windowGeometry.x() + source.x());
                         dfbPoints[i].y = (windowGeometry.y() + source.y());
                     }
-                    d_ptr->dfbSurface->BatchBlit(d_ptr->dfbSurface, surface, dfbRectangles.constData(),
-                                                 dfbPoints.constData(), n);
+                    d_ptr->primarySurface->BatchBlit(d_ptr->primarySurface, surface, dfbRectangles.constData(),
+                                                     dfbPoints.constData(), n);
                 }
             }
         }
@@ -1237,29 +1272,37 @@ void QDirectFBScreen::exposeRegion(QRegion r, int changing)
         if (cursor->isVisible() && !cursor->isAccelerated() && cursorRectangle.intersects(brect)) {
             const QImage image = cursor->image();
             IDirectFBSurface *surface = createDFBSurface(image, QDirectFBScreen::DontTrackSurface);
-            d_ptr->dfbSurface->SetBlittingFlags(d_ptr->dfbSurface, DSBLIT_BLEND_ALPHACHANNEL);
-            d_ptr->dfbSurface->Blit(d_ptr->dfbSurface, surface, 0, cursorRectangle.x(), cursorRectangle.y());
+            d_ptr->primarySurface->SetBlittingFlags(d_ptr->primarySurface, DSBLIT_BLEND_ALPHACHANNEL);
+            d_ptr->primarySurface->Blit(d_ptr->primarySurface, surface, 0, cursorRectangle.x(), cursorRectangle.y());
             surface->Release(surface);
 #if (Q_DIRECTFB_VERSION >= 0x010000)
-            d_ptr->dfbSurface->ReleaseSource(d_ptr->dfbSurface);
+            d_ptr->primarySurface->ReleaseSource(d_ptr->primarySurface);
 #endif
         }
     }
-    flipSurface(d_ptr->dfbSurface, d_ptr->flipFlags, r, QPoint());
+    flipSurface(d_ptr->primarySurface, d_ptr->flipFlags, r, QPoint());
+#else
+    Q_UNUSED(r);
+    Q_UNUSED(changing);
+#endif
 }
 
 void QDirectFBScreen::solidFill(const QColor &color, const QRegion &region)
 {
+#ifdef QT_DIRECTFB_WM
+    Q_UNUSED(color);
+    Q_UNUSED(region);
+#else
     if (region.isEmpty())
         return;
 
-    d_ptr->dfbSurface->SetColor(d_ptr->dfbSurface,
+    d_ptr->primarySurface->SetColor(d_ptr->primarySurface,
                                 color.red(), color.green(), color.blue(),
                                 color.alpha());
     const int n = region.numRects();
     if (n > 1) {
         const QRect r = region.boundingRect();
-        d_ptr->dfbSurface->FillRectangle(d_ptr->dfbSurface, r.x(), r.y(), r.width(), r.height());
+        d_ptr->primarySurface->FillRectangle(d_ptr->primarySurface, r.x(), r.y(), r.width(), r.height());
     } else {
         const QVector<QRect> rects = region.rects();
         QVarLengthArray<DFBRectangle, 32> rectArray(n);
@@ -1270,8 +1313,9 @@ void QDirectFBScreen::solidFill(const QColor &color, const QRegion &region)
             rectArray[i].w = r.width();
             rectArray[i].h = r.height();
         }
-        d_ptr->dfbSurface->FillRectangles(d_ptr->dfbSurface, rectArray.constData(), n);
+        d_ptr->primarySurface->FillRectangles(d_ptr->primarySurface, rectArray.constData(), n);
     }
+#endif
 }
 
 void QDirectFBScreen::erase(const QRegion &region)
diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbscreen.h b/src/plugins/gfxdrivers/directfb/qdirectfbscreen.h
index 78765ac..3f9248e 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbscreen.h
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbscreen.h
@@ -50,6 +50,31 @@ QT_BEGIN_HEADER
 
 QT_MODULE(Gui)
 
+#if !defined QT_NO_DIRECTFB_LAYER && !defined QT_DIRECTFB_LAYER
+#define QT_DIRECTFB_LAYER
+#endif
+#if !defined QT_NO_DIRECTFB_WM && !defined QT_DIRECTFB_WM
+#define QT_DIRECTFB_WM
+#endif
+#if !defined QT_DIRECTFB_IMAGECACHE && !defined QT_NO_DIRECTFB_IMAGECACHE
+#define QT_NO_DIRECTFB_IMAGECACHE
+#endif
+#if !defined QT_NO_DIRECTFB_PALETTE && !defined QT_DIRECTFB_PALETTE
+#define QT_DIRECTFB_PALETTE
+#endif
+#if !defined QT_NO_DIRECTFB_PREALLOCATED && !defined QT_DIRECTFB_PREALLOCATED
+#define QT_DIRECTFB_PREALLOCATED
+#endif
+#if !defined QT_NO_DIRECTFB_MOUSE && !defined QT_DIRECTFB_MOUSE
+#define QT_DIRECTFB_MOUSE
+#endif
+#if !defined QT_NO_DIRECTFB_KEYBOARD && !defined QT_DIRECTFB_KEYBOARD
+#define QT_DIRECTFB_KEYBOARD
+#endif
+#if !defined QT_NO_DIRECTFB_OPAQUE_DETECTION && !defined QT_DIRECTFB_OPAQUE_DETECTION
+#define QT_DIRECTFB_OPAQUE_DETECTION
+#endif
+
 #define Q_DIRECTFB_VERSION ((DIRECTFB_MAJOR_VERSION << 16) | (DIRECTFB_MINOR_VERION << 8) | DIRECTFB_MICRO_VERSION)
 
 #define DIRECTFB_DECLARE_OPERATORS_FOR_FLAGS(F)                         \
@@ -108,7 +133,9 @@ public:
     }
 
     IDirectFB *dfb();
-    IDirectFBSurface *dfbSurface();
+#ifdef QT_NO_DIRECTFB_WM
+    IDirectFBSurface *primarySurface();
+#endif
 #ifndef QT_NO_DIRECTFB_LAYER
     IDirectFBDisplayLayer *dfbDisplayLayer();
 #endif
diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbwindowsurface.cpp b/src/plugins/gfxdrivers/directfb/qdirectfbwindowsurface.cpp
index d837509..584f334 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbwindowsurface.cpp
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbwindowsurface.cpp
@@ -55,14 +55,11 @@ QDirectFBWindowSurface::QDirectFBWindowSurface(DFBSurfaceFlipFlags flip, QDirect
 #ifndef QT_NO_DIRECTFB_WM
     , dfbWindow(0)
 #endif
-    , engineHeight(-1)
     , flipFlags(flip)
     , boundingRectFlip(scr->directFBFlags() & QDirectFBScreen::BoundingRectFlip)
 {
 #ifdef QT_NO_DIRECTFB_WM
     mode = Offscreen;
-#else
-    mode = Window;
 #endif
     setSurfaceFlags(Opaque | Buffered);
 #ifdef QT_DIRECTFB_TIMING
@@ -76,21 +73,21 @@ QDirectFBWindowSurface::QDirectFBWindowSurface(DFBSurfaceFlipFlags flip, QDirect
 #ifndef QT_NO_DIRECTFB_WM
     , dfbWindow(0)
 #endif
-    , engineHeight(-1)
     , flipFlags(flip)
     , boundingRectFlip(scr->directFBFlags() & QDirectFBScreen::BoundingRectFlip)
 {
+#ifdef QT_NO_DIRECTFB_WM
     if (widget && widget->testAttribute(Qt::WA_PaintOnScreen)) {
         setSurfaceFlags(Opaque | RegionReserved);
         mode = Primary;
     } else {
-#ifdef QT_NO_DIRECTFB_WM
         mode = Offscreen;
-#else
-        mode = Window;
-#endif
         setSurfaceFlags(Opaque | Buffered);
     }
+#else
+    setSurfaceFlags(Opaque | Buffered);
+#endif
+
 #ifdef QT_DIRECTFB_TIMING
     frames = 0;
     timer.start();
@@ -172,8 +169,10 @@ static DFBResult setGeometry(IDirectFBWindow *dfbWindow, const QRect &old, const
 
 void QDirectFBWindowSurface::setGeometry(const QRect &rect)
 {
-    IDirectFBSurface *primarySurface = screen->dfbSurface();
+#ifdef QT_NO_DIRECTFB_WM
+    IDirectFBSurface *primarySurface = screen->primarySurface();
     Q_ASSERT(primarySurface);
+#endif
     if (rect.isNull()) {
 #ifndef QT_NO_DIRECTFB_WM
         if (dfbWindow) {
@@ -182,9 +181,10 @@ void QDirectFBWindowSurface::setGeometry(const QRect &rect)
         }
 #endif
         if (dfbSurface) {
-            if (dfbSurface != primarySurface) {
+#ifdef QT_NO_DIRECTFB_WM
+            if (dfbSurface != primarySurface)
+#endif
                 dfbSurface->Release(dfbSurface);
-            }
             dfbSurface = 0;
         }
     } else if (rect != geometry()) {
@@ -192,8 +192,12 @@ void QDirectFBWindowSurface::setGeometry(const QRect &rect)
         DFBResult result = DFB_OK;
         // If we're in a resize, the surface shouldn't be locked
         Q_ASSERT((lockedImage == 0) || (rect.size() == geometry().size()));
-        switch (mode) {
-        case Primary:
+#ifdef QT_DIRECTFB_WM
+        if (!dfbWindow)
+            createWindow();
+        ::setGeometry(dfbWindow, oldRect, rect);
+#else
+        if (mode == Primary) {
             if (dfbSurface && dfbSurface != primarySurface)
                 dfbSurface->Release(dfbSurface);
             if (rect == screen->region().boundingRect()) {
@@ -203,15 +207,7 @@ void QDirectFBWindowSurface::setGeometry(const QRect &rect)
                                          rect.width(), rect.height() };
                 result = primarySurface->GetSubSurface(primarySurface, &r, &dfbSurface);
             }
-            break;
-        case Window:
-#ifndef QT_NO_DIRECTFB_WM
-            if (!dfbWindow)
-                createWindow();
-            ::setGeometry(dfbWindow, oldRect, rect);
-#endif
-            break;
-        case Offscreen: {
+        } else {
             if (!dfbSurface || oldRect.size() != rect.size()) {
                 if (dfbSurface)
                     dfbSurface->Release(dfbSurface);
@@ -220,16 +216,16 @@ void QDirectFBWindowSurface::setGeometry(const QRect &rect)
             const QRegion region = QRegion(oldRect.isEmpty() ? screen->region() : QRegion(oldRect)).subtracted(rect);
             screen->erase(region);
             screen->flipSurface(primarySurface, flipFlags, region, QPoint());
-            break; }
+        }
+#endif
+        if (size() != geometry().size()) {
+            delete engine;
+            engine = 0;
         }
 
         if (result != DFB_OK)
             DirectFBErrorFatal("QDirectFBWindowSurface::setGeometry()", result);
     }
-    if (engine) {
-        delete engine;
-        engine = 0;
-    }
     QWSWindowSurface::setGeometry(rect);
 }
 
@@ -349,7 +345,8 @@ void QDirectFBWindowSurface::flush(QWidget *, const QRegion &region,
     }
 
     const QRect windowGeometry = QDirectFBWindowSurface::geometry();
-    IDirectFBSurface *primarySurface = screen->dfbSurface();
+#ifdef QT_NO_DIRECTFB_WM
+    IDirectFBSurface *primarySurface = screen->primarySurface();
     if (mode == Offscreen) {
         primarySurface->SetBlittingFlags(primarySurface, DSBLIT_NOFX);
         const QRect windowRect(0, 0, windowGeometry.width(), windowGeometry.height());
@@ -401,9 +398,9 @@ void QDirectFBWindowSurface::flush(QWidget *, const QRegion &region,
     }
     if (mode == Offscreen) {
         screen->flipSurface(primarySurface, flipFlags, region, offset + windowGeometry.topLeft());
-    } else {
-        screen->flipSurface(dfbSurface, flipFlags, region, offset);
-    }
+    } else
+#endif
+    screen->flipSurface(dfbSurface, flipFlags, region, offset);
 
 #ifdef QT_DIRECTFB_TIMING
     enum { Secs = 3 };
@@ -419,12 +416,8 @@ void QDirectFBWindowSurface::flush(QWidget *, const QRegion &region,
 
 void QDirectFBWindowSurface::beginPaint(const QRegion &)
 {
-    const int h = height();
-    if (h > engineHeight) {
-        engineHeight = h;
-        delete engine;
+    if (!engine)
         engine = new QDirectFBPaintEngine(this);
-    }
 }
 
 void QDirectFBWindowSurface::endPaint(const QRegion &)
diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbwindowsurface.h b/src/plugins/gfxdrivers/directfb/qdirectfbwindowsurface.h
index 0d6ebc0..64b1920 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbwindowsurface.h
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbwindowsurface.h
@@ -91,13 +91,13 @@ private:
     void createWindow();
     IDirectFBWindow *dfbWindow;
 #endif
-    int engineHeight;
 
+#ifdef QT_NO_DIRECTFB_WM
     enum Mode {
         Primary,
-        Offscreen,
-        Window
+        Offscreen
     } mode;
+#endif
 
     QList<QImage*> bufferImages;
     DFBSurfaceFlipFlags flipFlags;