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

29 files changed, 489 insertions, 371 deletions

diff --git a/src/activeqt/container/qaxwidget.cpp b/src/activeqt/container/qaxwidget.cpp
index 9149320..865c26c 100644
--- a/src/activeqt/container/qaxwidget.cpp
+++ b/src/activeqt/container/qaxwidget.cpp
@@ -1438,9 +1438,6 @@ extern Q_GUI_EXPORT bool qt_win_ignoreNextMouseReleaseEvent;
 
 HRESULT WINAPI QAxClientSite::EnableModeless(BOOL fEnable)
 {
-#if !defined(Q_OS_WINCE)
-    LockWindowUpdate(host->window()->winId());
-#endif
     EnableWindow(host->window()->winId(), fEnable);
 
     if (!fEnable) {
@@ -1451,9 +1448,6 @@ HRESULT WINAPI QAxClientSite::EnableModeless(BOOL fEnable)
             QApplicationPrivate::leaveModal(host);
     }
     qt_win_ignoreNextMouseReleaseEvent = false;
-#if !defined(Q_OS_WINCE)
-    LockWindowUpdate(0);
-#endif
     return S_OK;
 }
 
diff --git a/src/corelib/global/qnamespace.h b/src/corelib/global/qnamespace.h
index 177bee4..bc8d452 100644
--- a/src/corelib/global/qnamespace.h
+++ b/src/corelib/global/qnamespace.h
@@ -299,7 +299,9 @@ public:
         MacWindowToolBarButtonHint = 0x10000000,
         BypassGraphicsProxyWidget = 0x20000000,
         WindowOkButtonHint = 0x00080000,
-        WindowCancelButtonHint = 0x00100000
+        WindowCancelButtonHint = 0x00100000,
+        WindowSoftkeysVisibleHint = 0x40000000,
+        WindowSoftkeysRespondHint = 0x80000000
 
 #ifdef QT3_SUPPORT
         ,
diff --git a/src/corelib/global/qnamespace.qdoc b/src/corelib/global/qnamespace.qdoc
index 392ece3..6968773 100644
--- a/src/corelib/global/qnamespace.qdoc
+++ b/src/corelib/global/qnamespace.qdoc
@@ -2146,6 +2146,14 @@
     \value WindowCancelButtonHint Adds a Cancel button to the window decoration of a dialog.
            Only supported for Windows CE.
 
+    \value WindowSoftkeysVisibleHint Makes softkeys visible when widget is fullscreen.
+           Only supported for Symbian.
+
+    \value WindowSoftkeysRespondHint Makes softkeys to receive key events even
+           when invisible. With this hint the softkey actions are triggered
+           even the softkeys are invisible i.e. the window is displayed with
+           \c showFullscreen(). Only supported for Symbian.
+
     \value WindowType_Mask  A mask for extracting the window type
                             part of the window flags.
 
diff --git a/src/corelib/io/qfsfileengine_unix.cpp b/src/corelib/io/qfsfileengine_unix.cpp
index 9179485..1331f54 100644
--- a/src/corelib/io/qfsfileengine_unix.cpp
+++ b/src/corelib/io/qfsfileengine_unix.cpp
@@ -668,6 +668,16 @@ bool QFSFileEnginePrivate::doStat() const
             could_stat = (QT_FSTAT(QT_FILENO(fh), &st) == 0);
         } else if (fd == -1) {
             // ### actually covers two cases: d->fh and when the file is not open
+#if defined(Q_OS_SYMBIAN)
+            // Optimisation for Symbian where fileFlags() calls both doStat() and isSymlink(), but rarely on real links.
+            // When the filename is not a link, lstat will return the same info as stat, but this also removes
+            // any need for a further call to lstat to check if the file is a link.
+            need_lstat = false;
+            could_stat = (QT_LSTAT(nativeFilePath.constData(), &st) == 0);
+            is_link = could_stat ? S_ISLNK(st.st_mode) : false;
+            // if it turns out this was a link, we can call stat too.
+            if (is_link)
+#endif
             could_stat = (QT_STAT(nativeFilePath.constData(), &st) == 0);
         } else {
             could_stat = (QT_FSTAT(fd, &st) == 0);
@@ -1270,7 +1280,7 @@ uchar *QFSFileEnginePrivate::map(qint64 offset, qint64 size, QFile::MemoryMapFla
     int pageSize = getpagesize();
     int extra = offset % pageSize;
 
-    if (size + extra > (size_t)-1) {
+    if (quint64(size + extra) > quint64((size_t)-1)) {
         q->setError(QFile::UnspecifiedError, qt_error_string(int(EINVAL)));
         return 0;
     }
diff --git a/src/corelib/io/qurl.cpp b/src/corelib/io/qurl.cpp
index 076cc33..ffe8d06 100644
--- a/src/corelib/io/qurl.cpp
+++ b/src/corelib/io/qurl.cpp
@@ -437,17 +437,19 @@ static bool QT_FASTCALL _unreserved(const char **ptr)
 }
 
 // scheme      = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
-static void QT_FASTCALL _scheme(const char **ptr, QUrlParseData *parseData)
+static bool QT_FASTCALL _scheme(const char **ptr, QUrlParseData *parseData)
 {
     bool first = true;
+    bool isSchemeValid = true;
 
     parseData->scheme = *ptr;
     for (;;) {
         char ch = **ptr;
         if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')) {
             ;
-        } else if (!first && ((ch >= '0' && ch <= '9') || ch == '+' || ch == '-' || ch == '.')) {
-            ;
+        } else if ((ch >= '0' && ch <= '9') || ch == '+' || ch == '-' || ch == '.') {
+            if (first)
+                isSchemeValid = false;
         } else {
             break;
         }
@@ -457,11 +459,14 @@ static void QT_FASTCALL _scheme(const char **ptr, QUrlParseData *parseData)
     }
 
     if (**ptr != ':') {
+        isSchemeValid = true;
         *ptr = parseData->scheme;
     } else {
         parseData->schemeLength = *ptr - parseData->scheme;
         ++(*ptr); // skip ':'
     }
+
+    return isSchemeValid;
 }
 
 // IPvFuture  = "v" 1*HEXDIG "." 1*( unreserved / sub-delims / ":" )
@@ -3743,7 +3748,19 @@ void QUrlPrivate::parse(ParseOptions parseOptions) const
 #endif
 
     // optional scheme
-    _scheme(ptr, &parseData);
+    bool isSchemeValid = _scheme(ptr, &parseData);
+
+    if (isSchemeValid == false) {
+        that->isValid = false;
+        char ch = *((*ptr)++);
+        that->errorInfo.setParams(*ptr, QT_TRANSLATE_NOOP(QUrl, "unexpected URL scheme"),
+                                  0, ch);
+        QURL_SETFLAG(that->stateFlags, Validated | Parsed);
+#if defined (QURL_DEBUG)
+        qDebug("QUrlPrivate::parse(), unrecognized: %c%s", ch, *ptr);
+#endif
+        return;
+    }
 
     // hierpart
     _hierPart(ptr, &parseData);
diff --git a/src/corelib/kernel/qobject.cpp b/src/corelib/kernel/qobject.cpp
index 5298fff..689e44c 100644
--- a/src/corelib/kernel/qobject.cpp
+++ b/src/corelib/kernel/qobject.cpp
@@ -3264,12 +3264,14 @@ void QMetaObject::activate(QObject *sender, const QMetaObject *m, int local_sign
 
             const int method = c->method;
             QObjectPrivate::Sender currentSender;
-            currentSender.sender = sender;
-            currentSender.signal = signal_absolute_index;
-            currentSender.ref = 1;
+            const bool receiverInSameThread = currentThreadData == receiver->d_func()->threadData;
             QObjectPrivate::Sender *previousSender = 0;
-            if (currentThreadData == receiver->d_func()->threadData)
+            if (receiverInSameThread) {
+                currentSender.sender = sender;
+                currentSender.signal = signal_absolute_index;
+                currentSender.ref = 1;
                 previousSender = QObjectPrivate::setCurrentSender(receiver, &currentSender);
+            }
             locker.unlock();
 
             if (qt_signal_spy_callback_set.slot_begin_callback != 0) {
@@ -3285,8 +3287,8 @@ void QMetaObject::activate(QObject *sender, const QMetaObject *m, int local_sign
                 metacall(receiver, QMetaObject::InvokeMetaMethod, method, argv ? argv : empty_argv);
             } QT_CATCH(...) {
                 locker.relock();
-
-                QObjectPrivate::resetCurrentSender(receiver, &currentSender, previousSender);
+                if (receiverInSameThread)
+                    QObjectPrivate::resetCurrentSender(receiver, &currentSender, previousSender);
 
                 --connectionLists->inUse;
                 Q_ASSERT(connectionLists->inUse >= 0);
@@ -3301,7 +3303,8 @@ void QMetaObject::activate(QObject *sender, const QMetaObject *m, int local_sign
 
             locker.relock();
 
-            QObjectPrivate::resetCurrentSender(receiver, &currentSender, previousSender);
+            if (receiverInSameThread)
+                QObjectPrivate::resetCurrentSender(receiver, &currentSender, previousSender);
 
             if (connectionLists->orphaned)
                 break;
diff --git a/src/corelib/tools/qregexp.cpp b/src/corelib/tools/qregexp.cpp
index 25255f9..b9e273f 100644
--- a/src/corelib/tools/qregexp.cpp
+++ b/src/corelib/tools/qregexp.cpp
@@ -523,7 +523,7 @@ int qFindString(const QChar *haystack, int haystackLen, int from,
     \endtable
 
     In the mode Wildcard, the wildcard characters cannot be
-    escaped. In the mode WildcardUnix, the character '\' escapes the
+    escaped. In the mode WildcardUnix, the character '\\' escapes the
     wildcard.
 
     For example if we are in wildcard mode and have strings which
@@ -3774,7 +3774,7 @@ static void invalidateEngine(QRegExpPrivate *priv)
 
     \value WildcardUnix This is similar to Wildcard but with the
     behavior of a Unix shell. The wildcard characters can be escaped
-    with the character "\".
+    with the character "\\".
 
     \value FixedString The pattern is a fixed string. This is
     equivalent to using the RegExp pattern on a string in
diff --git a/src/gui/egl/qegl_wince.cpp b/src/gui/egl/qegl_wince.cpp
index c9c9773..dfef39f 100644
--- a/src/gui/egl/qegl_wince.cpp
+++ b/src/gui/egl/qegl_wince.cpp
@@ -89,8 +89,10 @@ EGLSurface QEglContext::createSurface(QPaintDevice *device, const QEglProperties
 
 EGLNativeDisplayType QEglContext::nativeDisplay()
 {
-    HWND win = (static_cast<QWidget*>(device))->winId();
-    HDC myDc = GetDC(win);
+    //HWND win = (static_cast<QWidget*>(device))->winId();
+    //HDC myDc = GetDC(win);    
+    HDC myDc = GetWindowDC(0);
+
     if (!myDc) {
         qWarning("QEglContext::nativeDisplay(): WinCE display is not open");
         return EGL_DEFAULT_DISPLAY;
diff --git a/src/gui/egl/qeglproperties_p.h b/src/gui/egl/qeglproperties_p.h
index feed1d2..43c3393 100644
--- a/src/gui/egl/qeglproperties_p.h
+++ b/src/gui/egl/qeglproperties_p.h
@@ -58,12 +58,17 @@
 
 QT_BEGIN_INCLUDE_NAMESPACE
 
+#if defined(QT_OPENGL_ES_2)
+#   include <GLES2/gl2.h>
+#endif
+
 #if defined(QT_GLES_EGL)
-#include <GLES/egl.h>
+#   include <GLES/egl.h>
 #else
-#include <EGL/egl.h>
+#   include <EGL/egl.h>
 #endif
 
+
 #if defined(Q_WS_X11)
 // If <EGL/egl.h> included <X11/Xlib.h>, then the global namespace
 // may have been polluted with X #define's.  The following makes sure
diff --git a/src/gui/embedded/directfb.pri b/src/gui/embedded/directfb.pri
index bd1d947..1795bbd 100644
--- a/src/gui/embedded/directfb.pri
+++ b/src/gui/embedded/directfb.pri
@@ -15,7 +15,7 @@
 #DEFINES += QT_DIRECTFB_TIMING
 #DEFINES += QT_NO_DIRECTFB_OPAQUE_DETECTION
 #DEFINES += QT_NO_DIRECTFB_STRETCHBLIT
-#DIRECTFB_DRAWINGOPERATIONS=DRAW_RECTS|DRAW_LINES|DRAW_IMAGE|DRAW_PIXMAP|DRAW_TILED_PIXMAP|STROKE_PATH|DRAW_PATH|DRAW_POINTS|DRAW_ELLIPSE|DRAW_POLYGON|DRAW_TEXT|FILL_PATH|FILL_RECT|DRAW_COLORSPANS|DRAW_ROUNDED_RECT
+DIRECTFB_DRAWINGOPERATIONS=DRAW_RECTS|DRAW_LINES|DRAW_IMAGE|DRAW_PIXMAP|DRAW_TILED_PIXMAP|STROKE_PATH|DRAW_PATH|DRAW_POINTS|DRAW_ELLIPSE|DRAW_POLYGON|DRAW_TEXT|FILL_PATH|FILL_RECT|DRAW_COLORSPANS|DRAW_ROUNDED_RECT
 #DEFINES += \"QT_DIRECTFB_WARN_ON_RASTERFALLBACKS=$$DIRECTFB_DRAWINGOPERATIONS\"
 #DEFINES += \"QT_DIRECTFB_DISABLE_RASTERFALLBACKS=$$DIRECTFB_DRAWINGOPERATIONS\"
 
diff --git a/src/gui/graphicsview/qgraphicsscene.cpp b/src/gui/graphicsview/qgraphicsscene.cpp
index 43fa24a..afea082 100644
--- a/src/gui/graphicsview/qgraphicsscene.cpp
+++ b/src/gui/graphicsview/qgraphicsscene.cpp
@@ -801,7 +801,8 @@ void QGraphicsScenePrivate::setFocusItemHelper(QGraphicsItem *item,
             // do it ourselves.
             if (item) {
                 for (int i = 0; i < views.size(); ++i)
-                    views.at(i)->inputContext()->reset();
+                    if (views.at(i)->inputContext())
+                        views.at(i)->inputContext()->reset();
             }
         }
 #endif //QT_NO_IM
diff --git a/src/gui/image/qpixmap.cpp b/src/gui/image/qpixmap.cpp
index 1df7946..7b225eb 100644
--- a/src/gui/image/qpixmap.cpp
+++ b/src/gui/image/qpixmap.cpp
@@ -831,21 +831,14 @@ bool QPixmap::load(const QString &fileName, const char *format, Qt::ImageConvers
     if (QPixmapCache::find(key, *this))
         return true;
 
-    bool ok;
-
-    if (data) {
-        ok = data->fromFile(fileName, format, flags);
-    } else {
-        QScopedPointer<QPixmapData> tmp(QPixmapData::create(0, 0, QPixmapData::PixmapType));
-        ok = tmp->fromFile(fileName, format, flags);
-        if (ok)
-            data = tmp.take();
-    }
-
-    if (ok)
+    QScopedPointer<QPixmapData> tmp(QPixmapData::create(0, 0, data ? data->type : QPixmapData::PixmapType));
+    if (tmp->fromFile(fileName, format, flags)) {
+        data = tmp.take();
         QPixmapCache::insert(key, *this);
+        return true;
+    }
 
-    return ok;
+    return false;
 }
 
 /*!
@@ -2026,12 +2019,16 @@ QPixmap QPixmap::fromImage(const QImage &image, Qt::ImageConversionFlags flags)
     over the one you grab, you get pixels from the overlying window,
     too. The mouse cursor is generally not grabbed.
 
-    Note on X11that if the given \a window doesn't have the same depth
+    Note on X11 that if the given \a window doesn't have the same depth
     as the root window, and another window partially or entirely
     obscures the one you grab, you will \e not get pixels from the
     overlying window.  The contents of the obscured areas in the
     pixmap will be undefined and uninitialized.
 
+    On Windows Vista and above grabbing a layered window, which is
+    created by setting the Qt::WA_TranslucentBackground attribute, will
+    not work. Instead grabbing the desktop widget should work.
+
     \warning In general, grabbing an area outside the screen is not
     safe. This depends on the underlying window system.
 
diff --git a/src/gui/itemviews/qabstractitemview.cpp b/src/gui/itemviews/qabstractitemview.cpp
index adf3ce3..2faf755 100644
--- a/src/gui/itemviews/qabstractitemview.cpp
+++ b/src/gui/itemviews/qabstractitemview.cpp
@@ -2119,6 +2119,11 @@ void QAbstractItemView::focusOutEvent(QFocusEvent *event)
     Q_D(QAbstractItemView);
     QAbstractScrollArea::focusOutEvent(event);
     d->viewport->update();
+
+#ifdef QT_SOFTKEYS_ENABLED
+    if(!hasEditFocus())
+        removeAction(d->doneSoftKey);
+#endif
 }
 
 /*!
@@ -2144,7 +2149,12 @@ void QAbstractItemView::keyPressEvent(QKeyEvent *event)
             if (!hasEditFocus()) {
                 setEditFocus(true);
 #ifdef QT_SOFTKEYS_ENABLED
-                addAction(d->doneSoftKey);
+                // If we can't keypad navigate to any direction, there is no sense to add
+                // "Done" softkey, since it basically does nothing when there is
+                // only one widget in screen
+                if(QWidgetPrivate::canKeypadNavigate(Qt::Horizontal)
+                        || QWidgetPrivate::canKeypadNavigate(Qt::Vertical))
+                    addAction(d->doneSoftKey);
 #endif
                 return;
             }
@@ -2160,6 +2170,26 @@ void QAbstractItemView::keyPressEvent(QKeyEvent *event)
             event->ignore();
         }
         return;
+    case Qt::Key_Down:
+    case Qt::Key_Up:
+        // Let's ignore vertical navigation events, only if there is no other widget
+        // what can take the focus in vertical direction. This means widget can handle navigation events
+        // even the widget don't have edit focus, and there is no other widget in requested direction.
+        if(QApplication::keypadNavigationEnabled() && !hasEditFocus()
+                && QWidgetPrivate::canKeypadNavigate(Qt::Vertical)) {
+            event->ignore();
+            return;
+        }
+        break;
+    case Qt::Key_Left:
+    case Qt::Key_Right:
+        // Similar logic as in up and down events
+        if(QApplication::keypadNavigationEnabled() && !hasEditFocus()
+                && (QWidgetPrivate::canKeypadNavigate(Qt::Horizontal) || QWidgetPrivate::inTabWidget(this))) {
+            event->ignore();
+            return;
+        }
+        break;
     default:
         if (QApplication::keypadNavigationEnabled() && !hasEditFocus()) {
             event->ignore();
@@ -2245,7 +2275,7 @@ void QAbstractItemView::keyPressEvent(QKeyEvent *event)
     case Qt::Key_Down:
     case Qt::Key_Up:
 #ifdef QT_KEYPAD_NAVIGATION
-        if (QApplication::keypadNavigationEnabled()) {
+        if (QApplication::keypadNavigationEnabled() && QWidgetPrivate::canKeypadNavigate(Qt::Vertical)) {
             event->accept(); // don't change focus
             break;
         }
@@ -2253,8 +2283,10 @@ void QAbstractItemView::keyPressEvent(QKeyEvent *event)
     case Qt::Key_Left:
     case Qt::Key_Right:
 #ifdef QT_KEYPAD_NAVIGATION
-        if (QApplication::navigationMode() == Qt::NavigationModeKeypadDirectional) {
-            event->accept(); // don't change horizontal focus in directional mode
+        if (QApplication::navigationMode() == Qt::NavigationModeKeypadDirectional
+                && (QWidgetPrivate::canKeypadNavigate(Qt::Horizontal)
+                || (QWidgetPrivate::inTabWidget(this) && d->model->columnCount(d->root) > 1))) {
+            event->accept(); // don't change focus
             break;
         }
 #endif // QT_KEYPAD_NAVIGATION
@@ -2536,6 +2568,7 @@ void QAbstractItemView::updateEditorGeometries()
     QStyleOptionViewItemV4 option = d->viewOptionsV4();
     QList<QEditorInfo>::iterator it = d->editors.begin();
     QWidgetList editorsToRelease;
+    QWidgetList editorsToHide;
     while (it != d->editors.end()) {
         QModelIndex index = it->index;
         QWidget *editor = it->editor;
@@ -2547,7 +2580,7 @@ void QAbstractItemView::updateEditorGeometries()
                 if (delegate)
                     delegate->updateEditorGeometry(editor, option, index);
             } else {
-                editor->hide();
+                editorsToHide << editor;
             }
             ++it;
         } else {
@@ -2556,8 +2589,11 @@ void QAbstractItemView::updateEditorGeometries()
         }
     }
 
-    //we release the editor outside of the loop because it might change the focus and try
+    //we hide and release the editor outside of the loop because it might change the focus and try
     //to change the d->editors list.
+    for (int i = 0; i < editorsToHide.count(); ++i) {
+        editorsToHide.at(i)->hide();
+    }
     for (int i = 0; i < editorsToRelease.count(); ++i) {
         d->releaseEditor(editorsToRelease.at(i));
     }
@@ -3014,6 +3050,7 @@ void QAbstractItemView::setIndexWidget(const QModelIndex &index, QWidget *widget
     if (!d->isIndexValid(index))
         return;
     if (QWidget *oldWidget = indexWidget(index)) {
+        d->persistent.remove(oldWidget);
         d->removeEditor(oldWidget);
         oldWidget->deleteLater();
     }
diff --git a/src/gui/kernel/qapplication_s60.cpp b/src/gui/kernel/qapplication_s60.cpp
index fdbbeb2..2a90ba6 100644
--- a/src/gui/kernel/qapplication_s60.cpp
+++ b/src/gui/kernel/qapplication_s60.cpp
@@ -597,7 +597,9 @@ TKeyResponse QSymbianControl::OfferKeyEvent(const TKeyEvent& keyEvent, TEventCod
         TUint s60Keysym = QApplicationPrivate::resolveS60ScanCode(keyEvent.iScanCode,
                 keyEvent.iCode);
         int keyCode;
-        if (s60Keysym >= 0x20 && s60Keysym < ENonCharacterKeyBase) {
+        if (s60Keysym == EKeyNull){ //some key events have 0 in iCode, for them iScanCode should be used
+            keyCode = qt_keymapper_private()->mapS60ScanCodesToQt(keyEvent.iScanCode);
+        } else if (s60Keysym >= 0x20 && s60Keysym < ENonCharacterKeyBase) {
             // Normal characters keys.
             keyCode = s60Keysym;
         } else {
@@ -964,13 +966,26 @@ void QSymbianControl::FocusChanged(TDrawNow /* aDrawNow */)
         qwidget->d_func()->setWindowTitle_sys(qwidget->windowTitle());
 #ifdef Q_WS_S60
         // If widget is fullscreen/minimized, hide status pane and button container otherwise show them.
-        CEikStatusPane* statusPane = S60->statusPane();
-        CEikButtonGroupContainer* buttonGroup = S60->buttonGroupContainer();
+        CEikStatusPane *statusPane = S60->statusPane();
+        CEikButtonGroupContainer *buttonGroup = S60->buttonGroupContainer();
         TBool visible = !(qwidget->windowState() & (Qt::WindowFullScreen | Qt::WindowMinimized));
         if (statusPane)
             statusPane->MakeVisible(visible);
-        if (buttonGroup)
-            buttonGroup->MakeVisible(visible);
+        if (buttonGroup) {
+            // Visibility
+            const TBool isFullscreen = qwidget->windowState() & Qt::WindowFullScreen;
+            const TBool cbaVisibilityHint = qwidget->windowFlags() & Qt::WindowSoftkeysVisibleHint;
+            buttonGroup->MakeVisible(visible || (isFullscreen && cbaVisibilityHint));
+
+            // Responsiviness
+            CEikCba *cba = static_cast<CEikCba *>( buttonGroup->ButtonGroup() ); // downcast from MEikButtonGroup
+            TUint cbaFlags = cba->ButtonGroupFlags();
+            if(qwidget->windowFlags() & Qt::WindowSoftkeysRespondHint)
+                cbaFlags |= EAknCBAFlagRespondWhenInvisible;
+            else
+                cbaFlags &= ~EAknCBAFlagRespondWhenInvisible;
+            cba->SetButtonGroupFlags(cbaFlags);
+        }
 #endif
     } else if (QApplication::activeWindow() == qwidget->window()) {
         if (CCoeEnv::Static()->AppUi()->IsDisplayingMenuOrDialog()) {
@@ -1014,6 +1029,16 @@ void QSymbianControl::HandleResourceChange(int resourceType)
         } else if (qwidget->isMaximized()) {
             TRect r = static_cast<CEikAppUi*>(S60->appUi())->ClientRect();
             SetExtent(r.iTl, r.Size());
+        } else if (!qwidget->isMinimized()){ // Normal geometry
+            if (!qwidget->testAttribute(Qt::WA_Resized)) {
+                qwidget->adjustSize();
+                qwidget->setAttribute(Qt::WA_Resized, false); //not a user resize
+            }
+            if (!qwidget->testAttribute(Qt::WA_Moved)) {
+                TRect r = static_cast<CEikAppUi*>(S60->appUi())->ClientRect();
+                SetPosition(r.iTl);
+                qwidget->setAttribute(Qt::WA_Moved, false); // not really an explicit position
+            }
         }
         break;
     }
@@ -1227,7 +1252,7 @@ void qt_init(QApplicationPrivate * /* priv */, int)
             S60->avkonComponentsSupportTransparency = (value==1) ? true : false;
         }
     }
-#endif    
+#endif
 
     if (touch) {
         QApplicationPrivate::navigationMode = Qt::NavigationModeNone;
diff --git a/src/gui/kernel/qapplication_win.cpp b/src/gui/kernel/qapplication_win.cpp
index aac834d..da6869d 100644
--- a/src/gui/kernel/qapplication_win.cpp
+++ b/src/gui/kernel/qapplication_win.cpp
@@ -2524,6 +2524,7 @@ LRESULT CALLBACK QtWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam
             }
             result = false;
             break;
+#if !defined(Q_WS_WINCE) || defined(QT_WINCE_GESTURES)
         case WM_GESTURE: {
             GESTUREINFO gi;
             memset(&gi, 0, sizeof(GESTUREINFO));
@@ -2556,6 +2557,7 @@ LRESULT CALLBACK QtWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam
             result = true;
             break;
         }
+#endif // !defined(Q_WS_WINCE) || defined(QT_WINCE_GESTURES)
         default:
             result = false;                        // event was not processed
             break;
diff --git a/src/gui/kernel/qguifunctions_wince.cpp b/src/gui/kernel/qguifunctions_wince.cpp
index ac4cdc8..f5004b0 100644
--- a/src/gui/kernel/qguifunctions_wince.cpp
+++ b/src/gui/kernel/qguifunctions_wince.cpp
@@ -278,7 +278,14 @@ int qt_wince_get_version()
 
 bool qt_wince_is_windows_mobile_65()
 {
-    return ((qt_wince_get_version() == 52) && (qt_wince_get_build() > 2000));
+    const DWORD dwFirstWM65BuildNumber = 21139;
+    OSVERSIONINFO osvi;
+    osvi.dwOSVersionInfoSize = sizeof(osvi);
+    if (!GetVersionEx(&osvi))
+        return false;
+    return osvi.dwMajorVersion > 5
+        || (osvi.dwMajorVersion == 5 && (osvi.dwMinorVersion > 2 ||
+            (osvi.dwMinorVersion == 2 && osvi.dwBuildNumber >= dwFirstWM65BuildNumber)));
 }
 
 bool qt_wince_is_pocket_pc() {
diff --git a/src/gui/kernel/qkeymapper_p.h b/src/gui/kernel/qkeymapper_p.h
index 09c36c88..3e42d6e 100644
--- a/src/gui/kernel/qkeymapper_p.h
+++ b/src/gui/kernel/qkeymapper_p.h
@@ -207,12 +207,12 @@ public:
     KeyboardLayoutItem *keyLayout[256];
 #elif defined(Q_WS_QWS)
 #elif defined(Q_OS_SYMBIAN)
-private:
-    QHash<TUint, int> s60ToQtKeyMap;
-    void fillKeyMap();
 public:
     QString translateKeyEvent(int keySym, Qt::KeyboardModifiers modifiers);
     int mapS60KeyToQt(TUint s60key);
+    int mapS60ScanCodesToQt(TUint s60key);
+    int mapQtToS60Key(int qtKey);
+    int mapQtToS60ScanCodes(int qtKey);
 #endif
 };
 
diff --git a/src/gui/kernel/qkeymapper_s60.cpp b/src/gui/kernel/qkeymapper_s60.cpp
index 6e21420..fd263ef 100644
--- a/src/gui/kernel/qkeymapper_s60.cpp
+++ b/src/gui/kernel/qkeymapper_s60.cpp
@@ -46,7 +46,6 @@ QT_BEGIN_NAMESPACE
 
 QKeyMapperPrivate::QKeyMapperPrivate()
 {
-    fillKeyMap();
 }
 
 QKeyMapperPrivate::~QKeyMapperPrivate()
@@ -74,174 +73,145 @@ QString QKeyMapperPrivate::translateKeyEvent(int keySym, Qt::KeyboardModifiers /
     return QString(QChar(keySym));
 }
 
-void QKeyMapperPrivate::fillKeyMap()
+#include <e32keys.h>
+struct KeyMapping{
+    TKeyCode s60KeyCode;
+    TStdScanCode s60ScanCode;
+    Qt::Key qtKey;
+};
+
+using namespace Qt;
+
+static const KeyMapping keyMapping[] = {
+    {EKeyBackspace, EStdKeyBackspace, Key_Backspace},
+    {EKeyTab, EStdKeyTab, Key_Tab},
+    {EKeyEnter, EStdKeyEnter, Key_Enter},
+    {EKeyEscape, EStdKeyEscape, Key_Escape},
+    {EKeySpace, EStdKeySpace, Key_Space},
+    {EKeyDelete, EStdKeyDelete, Key_Delete},
+    {EKeyPrintScreen, EStdKeyPrintScreen, Key_SysReq},
+    {EKeyPause, EStdKeyPause, Key_Pause},
+    {EKeyHome, EStdKeyHome, Key_Home},
+    {EKeyEnd, EStdKeyEnd, Key_End},
+    {EKeyPageUp, EStdKeyPageUp, Key_PageUp},
+    {EKeyPageDown, EStdKeyPageDown, Key_PageDown},
+    {EKeyInsert, EStdKeyInsert, Key_Insert},
+    {EKeyLeftArrow, EStdKeyLeftArrow, Key_Left},
+    {EKeyRightArrow, EStdKeyRightArrow, Key_Right},
+    {EKeyUpArrow, EStdKeyUpArrow, Key_Up},
+    {EKeyDownArrow, EStdKeyDownArrow, Key_Down},
+    {EKeyLeftShift, EStdKeyLeftShift, Key_Shift},
+    {EKeyRightShift, EStdKeyRightShift, Key_Shift},
+    {EKeyLeftAlt, EStdKeyLeftAlt, Key_Alt},
+    {EKeyRightAlt, EStdKeyRightAlt, Key_AltGr},
+    {EKeyLeftCtrl, EStdKeyLeftCtrl, Key_Control},
+    {EKeyRightCtrl, EStdKeyRightCtrl, Key_Control},
+    {EKeyLeftFunc, EStdKeyLeftFunc, Key_Super_L},
+    {EKeyRightFunc, EStdKeyRightFunc, Key_Super_R},
+    {EKeyCapsLock, EStdKeyCapsLock, Key_CapsLock},
+    {EKeyNumLock, EStdKeyNumLock, Key_NumLock},
+    {EKeyScrollLock, EStdKeyScrollLock, Key_ScrollLock},
+    {EKeyF1, EStdKeyF1, Key_F1},
+    {EKeyF2, EStdKeyF2, Key_F2},
+    {EKeyF3, EStdKeyF3, Key_F3},
+    {EKeyF4, EStdKeyF4, Key_F4},
+    {EKeyF5, EStdKeyF5, Key_F5},
+    {EKeyF6, EStdKeyF6, Key_F6},
+    {EKeyF7, EStdKeyF7, Key_F7},
+    {EKeyF8, EStdKeyF8, Key_F8},
+    {EKeyF9, EStdKeyF9, Key_F9},
+    {EKeyF10, EStdKeyF10, Key_F10},
+    {EKeyF11, EStdKeyF11, Key_F11},
+    {EKeyF12, EStdKeyF12, Key_F12},
+    {EKeyF13, EStdKeyF13, Key_F13},
+    {EKeyF14, EStdKeyF14, Key_F14},
+    {EKeyF15, EStdKeyF15, Key_F15},
+    {EKeyF16, EStdKeyF16, Key_F16},
+    {EKeyF17, EStdKeyF17, Key_F17},
+    {EKeyF18, EStdKeyF18, Key_F18},
+    {EKeyF19, EStdKeyF19, Key_F19},
+    {EKeyF20, EStdKeyF20, Key_F20},
+    {EKeyF21, EStdKeyF21, Key_F21},
+    {EKeyF22, EStdKeyF22, Key_F22},
+    {EKeyF23, EStdKeyF23, Key_F23},
+    {EKeyF24, EStdKeyF24, Key_F24},
+    {EKeyOff, EStdKeyOff, Key_PowerOff},
+//    {EKeyMenu, EStdKeyMenu, Key_Menu}, // Menu is EKeyApplication0
+    {EKeyHelp, EStdKeyHelp, Key_Help},
+    {EKeyDial, EStdKeyDial, Key_Call},
+    {EKeyIncVolume, EStdKeyIncVolume, Key_VolumeUp},
+    {EKeyDecVolume, EStdKeyDecVolume, Key_VolumeDown},
+    {EKeyDevice0, EStdKeyDevice0, Key_Context1}, // Found by manual testing.
+    {EKeyDevice1, EStdKeyDevice1, Key_Context2}, // Found by manual testing.
+    {EKeyDevice3, EStdKeyDevice3, Key_Select},
+//    {EKeyDevice7, EStdKeyDevice7, Key_Camera},  //not supported by qt yet
+    {EKeyApplication0, EStdKeyApplication0, Key_Menu}, // Found by manual testing.
+    {EKeyApplication1, EStdKeyApplication1, Key_Launch1}, // Found by manual testing.
+    {EKeyApplication2, EStdKeyApplication2, Key_MediaPlay}, // Found by manual testing.
+    {EKeyApplication3, EStdKeyApplication3, Key_MediaStop}, // Found by manual testing.
+    {EKeyApplication4, EStdKeyApplication4, Key_MediaNext}, // Found by manual testing.
+    {EKeyApplication5, EStdKeyApplication5, Key_MediaPrevious}, // Found by manual testing.
+    {EKeyApplication6, EStdKeyApplication6, Key_Launch6},
+    {EKeyApplication7, EStdKeyApplication7, Key_Launch7},
+    {EKeyApplication8, EStdKeyApplication8, Key_Launch8},
+    {EKeyApplication9, EStdKeyApplication9, Key_Launch9},
+    {EKeyApplicationA, EStdKeyApplicationA, Key_LaunchA},
+    {EKeyApplicationB, EStdKeyApplicationB, Key_LaunchB},
+    {EKeyApplicationC, EStdKeyApplicationC, Key_LaunchC},
+    {EKeyApplicationD, EStdKeyApplicationD, Key_LaunchD},
+    {EKeyApplicationE, EStdKeyApplicationE, Key_LaunchE},
+    {EKeyApplicationF, EStdKeyApplicationF, Key_LaunchF},
+//    {EKeyApplication19, EStdKeyApplication19, Key_CameraFocus},  //not supported by qt yet
+    {EKeyYes, EStdKeyYes, Key_Yes},
+    {EKeyNo, EStdKeyNo, Key_No},
+    {TKeyCode(0), TStdScanCode(0), Qt::Key(0)}
+};
+
+int QKeyMapperPrivate::mapS60KeyToQt(TUint s60key)
 {
-    using namespace Qt;
-    static const struct {
-        TUint s60Key;
-        int qtKey;
-    } map[] = {
-        {EKeyBell, Key_unknown},
-        {EKeyBackspace, Key_Backspace},
-        {EKeyTab, Key_Tab},
-        {EKeyLineFeed, Key_unknown},
-        {EKeyVerticalTab, Key_unknown},
-        {EKeyFormFeed, Key_unknown},
-        {EKeyEnter, Key_Enter},
-        {EKeyEscape, Key_Escape},
-        {EKeySpace, Key_Space},
-        {EKeyDelete, Key_Delete},
-        {EKeyPrintScreen, Key_SysReq},
-        {EKeyPause, Key_Pause},
-        {EKeyHome, Key_Home},
-        {EKeyEnd, Key_End},
-        {EKeyPageUp, Key_PageUp},
-        {EKeyPageDown, Key_PageDown},
-        {EKeyInsert, Key_Insert},
-        {EKeyLeftArrow, Key_Left},
-        {EKeyRightArrow, Key_Right},
-        {EKeyUpArrow, Key_Up},
-        {EKeyDownArrow, Key_Down},
-        {EKeyLeftShift, Key_Shift},
-        {EKeyRightShift, Key_Shift},
-        {EKeyLeftAlt, Key_Alt},
-        {EKeyRightAlt, Key_AltGr},
-        {EKeyLeftCtrl, Key_Control},
-        {EKeyRightCtrl, Key_Control},
-        {EKeyLeftFunc, Key_Super_L},
-        {EKeyRightFunc, Key_Super_R},
-        {EKeyCapsLock, Key_CapsLock},
-        {EKeyNumLock, Key_NumLock},
-        {EKeyScrollLock, Key_ScrollLock},
-        {EKeyF1, Key_F1},
-        {EKeyF2, Key_F2},
-        {EKeyF3, Key_F3},
-        {EKeyF4, Key_F4},
-        {EKeyF5, Key_F5},
-        {EKeyF6, Key_F6},
-        {EKeyF7, Key_F7},
-        {EKeyF8, Key_F8},
-        {EKeyF9, Key_F9},
-        {EKeyF10, Key_F10},
-        {EKeyF11, Key_F11},
-        {EKeyF12, Key_F12},
-        {EKeyF13, Key_F13},
-        {EKeyF14, Key_F14},
-        {EKeyF15, Key_F15},
-        {EKeyF16, Key_F16},
-        {EKeyF17, Key_F17},
-        {EKeyF18, Key_F18},
-        {EKeyF19, Key_F19},
-        {EKeyF20, Key_F20},
-        {EKeyF21, Key_F21},
-        {EKeyF22, Key_F22},
-        {EKeyF23, Key_F23},
-        {EKeyF24, Key_F24},
-        {EKeyOff, Key_unknown},
-        {EKeyIncContrast, Key_unknown},
-        {EKeyDecContrast, Key_unknown},
-        {EKeyBacklightOn, Key_unknown},
-        {EKeyBacklightOff, Key_unknown},
-        {EKeyBacklightToggle, Key_unknown},
-        {EKeySliderDown, Key_unknown},
-        {EKeySliderUp, Key_unknown},
-        {EKeyMenu, Key_Menu},
-        {EKeyDictaphonePlay, Key_unknown},
-        {EKeyDictaphoneStop, Key_unknown},
-        {EKeyDictaphoneRecord, Key_unknown},
-        {EKeyHelp, Key_unknown},
-        {EKeyDial, Key_Call},
-        {EKeyScreenDimension0, Key_unknown},
-        {EKeyScreenDimension1, Key_unknown},
-        {EKeyScreenDimension2, Key_unknown},
-        {EKeyScreenDimension3, Key_unknown},
-        {EKeyIncVolume, Key_unknown},
-        {EKeyDecVolume, Key_unknown},
-        {EKeyDevice0, Key_Context1}, // Found by manual testing, left softkey.
-        {EKeyDevice1, Key_Context2}, // Found by manual testing.
-        {EKeyDevice2, Key_unknown},
-        {EKeyDevice3, Key_Select}, // Found by manual testing.
-        {EKeyDevice4, Key_unknown},
-        {EKeyDevice5, Key_unknown},
-        {EKeyDevice6, Key_unknown},
-        {EKeyDevice7, Key_unknown},
-        {EKeyDevice8, Key_unknown},
-        {EKeyDevice9, Key_unknown},
-        {EKeyDeviceA, Key_unknown},
-        {EKeyDeviceB, Key_unknown},
-        {EKeyDeviceC, Key_unknown},
-        {EKeyDeviceD, Key_unknown},
-        {EKeyDeviceE, Key_unknown},
-        {EKeyDeviceF, Key_unknown},
-        {EKeyApplication0, Key_Launch0},
-        {EKeyApplication1, Key_Launch1},
-        {EKeyApplication2, Key_Launch2},
-        {EKeyApplication3, Key_Launch3},
-        {EKeyApplication4, Key_Launch4},
-        {EKeyApplication5, Key_Launch5},
-        {EKeyApplication6, Key_Launch6},
-        {EKeyApplication7, Key_Launch7},
-        {EKeyApplication8, Key_Launch8},
-        {EKeyApplication9, Key_Launch9},
-        {EKeyApplicationA, Key_LaunchA},
-        {EKeyApplicationB, Key_LaunchB},
-        {EKeyApplicationC, Key_LaunchC},
-        {EKeyApplicationD, Key_LaunchD},
-        {EKeyApplicationE, Key_LaunchE},
-        {EKeyApplicationF, Key_LaunchF},
-        {EKeyYes, Key_Yes},
-        {EKeyNo, Key_No},
-        {EKeyIncBrightness, Key_unknown},
-        {EKeyDecBrightness, Key_unknown},
-        {EKeyKeyboardExtend, Key_unknown},
-        {EKeyDevice10, Key_unknown},
-        {EKeyDevice11, Key_unknown},
-        {EKeyDevice12, Key_unknown},
-        {EKeyDevice13, Key_unknown},
-        {EKeyDevice14, Key_unknown},
-        {EKeyDevice15, Key_unknown},
-        {EKeyDevice16, Key_unknown},
-        {EKeyDevice17, Key_unknown},
-        {EKeyDevice18, Key_unknown},
-        {EKeyDevice19, Key_unknown},
-        {EKeyDevice1A, Key_unknown},
-        {EKeyDevice1B, Key_unknown},
-        {EKeyDevice1C, Key_unknown},
-        {EKeyDevice1D, Key_unknown},
-        {EKeyDevice1E, Key_unknown},
-        {EKeyDevice1F, Key_unknown},
-        {EKeyApplication10, Key_unknown},
-        {EKeyApplication11, Key_unknown},
-        {EKeyApplication12, Key_unknown},
-        {EKeyApplication13, Key_unknown},
-        {EKeyApplication14, Key_unknown},
-        {EKeyApplication15, Key_unknown},
-        {EKeyApplication16, Key_unknown},
-        {EKeyApplication17, Key_unknown},
-        {EKeyApplication18, Key_unknown},
-        {EKeyApplication19, Key_unknown},
-        {EKeyApplication1A, Key_unknown},
-        {EKeyApplication1B, Key_unknown},
-        {EKeyApplication1C, Key_unknown},
-        {EKeyApplication1D, Key_unknown},
-        {EKeyApplication1E, Key_unknown},
-        {EKeyApplication1F, Key_unknown}
-    };
-    const int mapSize = int(sizeof(map)/sizeof(map[0]));
-    s60ToQtKeyMap.reserve(mapSize + 5); // +5? docs: Ideally, slightly more than number of items
-    for (int i = 0; i < mapSize; ++i)
-        s60ToQtKeyMap.insert(map[i].s60Key, map[i].qtKey);
+    int res = Qt::Key_unknown;
+    for (int i = 0; keyMapping[i].s60KeyCode != 0; i++) {
+        if (keyMapping[i].s60KeyCode == s60key) {
+            res = keyMapping[i].qtKey;
+            break;
+        }
+    }
+    return res;
 }
 
-int QKeyMapperPrivate::mapS60KeyToQt(TUint s60key)
+int QKeyMapperPrivate::mapS60ScanCodesToQt(TUint s60scanCode)
 {
-    QHash<TUint, int>::const_iterator mapping;
-    mapping = s60ToQtKeyMap.find(s60key);
-    if (mapping != s60ToQtKeyMap.end()) {
-        return *mapping;
-    } else {
-        return Qt::Key_unknown;
+    int res = Qt::Key_unknown;
+    for (int i = 0; keyMapping[i].s60KeyCode != 0; i++) {
+        if (keyMapping[i].s60ScanCode == s60scanCode) {
+            res = keyMapping[i].qtKey;
+            break;
+        }
     }
+    return res;
 }
 
+int QKeyMapperPrivate::mapQtToS60Key(int qtKey)
+{
+    int res = KErrUnknown;
+    for (int i = 0; keyMapping[i].s60KeyCode != 0; i++) {
+        if (keyMapping[i].qtKey == qtKey) {
+            res = keyMapping[i].s60KeyCode;
+            break;
+        }
+    }
+    return res;
+}
+
+int QKeyMapperPrivate::mapQtToS60ScanCodes(int qtKey)
+{
+    int res = KErrUnknown;
+    for (int i = 0; keyMapping[i].s60KeyCode != 0; i++) {
+        if (keyMapping[i].qtKey == qtKey) {
+            res = keyMapping[i].s60ScanCode;
+            break;
+        }
+    }
+    return res;
+}
 QT_END_NAMESPACE
diff --git a/src/gui/kernel/qmime_win.cpp b/src/gui/kernel/qmime_win.cpp
index e191d7b..39633bf 100644
--- a/src/gui/kernel/qmime_win.cpp
+++ b/src/gui/kernel/qmime_win.cpp
@@ -640,14 +640,18 @@ bool QWindowsMimeURI::convertFromMime(const FORMATETC &formatetc, const QMimeDat
         } else if (getCf(formatetc) == CF_INETURL_W) {
             QList<QUrl> urls = mimeData->urls();
             QByteArray result;
-            QString url = urls.at(0).toString();
-            result = QByteArray((const char *)url.utf16(), url.length() * sizeof(ushort));
+            if (!urls.isEmpty()) {
+                QString url = urls.at(0).toString();
+                result = QByteArray((const char *)url.utf16(), url.length() * sizeof(ushort));
+            }
             result.append('\0');
             result.append('\0');
             return setData(result, pmedium);
         } else if (getCf(formatetc) == CF_INETURL) {
             QList<QUrl> urls = mimeData->urls();
-            QByteArray result = urls.at(0).toString().toLocal8Bit();
+            QByteArray result;
+            if (!urls.isEmpty())
+                result = urls.at(0).toString().toLocal8Bit();
             return setData(result, pmedium);
         }
     }
diff --git a/src/gui/kernel/qsoftkeymanager_s60.cpp b/src/gui/kernel/qsoftkeymanager_s60.cpp
index 8ac1e31..2a1ecc5 100644
--- a/src/gui/kernel/qsoftkeymanager_s60.cpp
+++ b/src/gui/kernel/qsoftkeymanager_s60.cpp
@@ -73,11 +73,21 @@ bool QSoftKeyManagerPrivateS60::skipCbaUpdate()
     // Lets not update softkeys if
     // 1. We don't have application panes, i.e. cba
     // 2. Our CBA is not active, i.e. S60 native dialog or menu with custom CBA is shown
+    //    2.1. Except if thre is no current CBA at all and WindowSoftkeysRespondHint is set
+
     // Note: Cannot use IsDisplayingMenuOrDialog since CBA update can be triggered before
     // menu/dialog CBA is actually displayed i.e. it is being costructed.
     CEikButtonGroupContainer *appUiCba = S60->buttonGroupContainer();
+    // CEikButtonGroupContainer::Current returns 0 if CBA is not visible at all
     CEikButtonGroupContainer *currentCba = CEikButtonGroupContainer::Current();
-    if (QApplication::testAttribute(Qt::AA_S60DontConstructApplicationPanes) || appUiCba != currentCba) {
+    // Check if softkey need to be update even they are not visible
+    bool cbaRespondsWhenInvisible = false;
+    QWidget *window = QApplication::activeWindow();
+    if (window && (window->windowFlags() & Qt::WindowSoftkeysRespondHint))
+        cbaRespondsWhenInvisible = true;
+
+    if (QApplication::testAttribute(Qt::AA_S60DontConstructApplicationPanes)
+            || (appUiCba != currentCba && !cbaRespondsWhenInvisible)) {
         return true;
     }
     return false;
diff --git a/src/gui/kernel/qwidget.cpp b/src/gui/kernel/qwidget.cpp
index 850e961..29ae51f 100644
--- a/src/gui/kernel/qwidget.cpp
+++ b/src/gui/kernel/qwidget.cpp
@@ -118,6 +118,10 @@
 #include "private/qgraphicssystem_p.h"
 #include "private/qgesturemanager_p.h"
 
+#ifdef QT_KEYPAD_NAVIGATION
+#include "qtabwidget.h" // Needed in inTabWidget()
+#endif // QT_KEYPAD_NAVIGATION
+
 // widget/widget data creation count
 //#define QWIDGET_EXTRA_DEBUG
 //#define ALIEN_DEBUG
@@ -7925,13 +7929,16 @@ inline void setDisabledStyle(QWidget *w, bool setStyle)
     // set/reset WS_DISABLED style.
     if(w && w->isWindow() && w->isVisible() && w->isEnabled()) {
         LONG dwStyle = GetWindowLong(w->winId(), GWL_STYLE);
+        LONG newStyle = dwStyle;
         if (setStyle)
-            dwStyle |= WS_DISABLED;
+            newStyle |= WS_DISABLED;
         else
-            dwStyle &= ~WS_DISABLED;
-        SetWindowLong(w->winId(), GWL_STYLE, dwStyle);
-        // we might need to repaint in some situations (eg. menu)
-        w->repaint();
+            newStyle &= ~WS_DISABLED;
+        if (newStyle != dwStyle) {
+            SetWindowLong(w->winId(), GWL_STYLE, newStyle);
+            // we might need to repaint in some situations (eg. menu)
+            w->repaint();
+        }
     }
 }
 #endif
@@ -11626,6 +11633,45 @@ QWidget *QWidgetPrivate::widgetInNavigationDirection(Direction direction)
     }
     return targetWidget;
 }
+
+/*!
+    \internal
+
+    Tells us if it there is currently a reachable widget by keypad navigation in
+    a certain \a orientation.
+    If no navigation is possible, occuring key events in that \a orientation may
+    be used to interact with the value in the focussed widget, even though it
+    currently has not the editFocus.
+
+    \sa QWidgetPrivate::widgetInNavigationDirection(), QWidget::hasEditFocus()
+*/
+bool QWidgetPrivate::canKeypadNavigate(Qt::Orientation orientation)
+{
+    return orientation == Qt::Horizontal?
+            (QWidgetPrivate::widgetInNavigationDirection(QWidgetPrivate::DirectionEast)
+                    || QWidgetPrivate::widgetInNavigationDirection(QWidgetPrivate::DirectionWest))
+            :(QWidgetPrivate::widgetInNavigationDirection(QWidgetPrivate::DirectionNorth)
+                    || QWidgetPrivate::widgetInNavigationDirection(QWidgetPrivate::DirectionSouth));
+}
+/*!
+    \internal
+
+    Checks, if the \a widget is inside a QTabWidget. If is is inside
+    one, left/right key events will be used to switch between tabs in keypad
+    navigation. If there is no QTabWidget, the horizontal key events can be used
+to
+    interact with the value in the focussed widget, even though it currently has
+    not the editFocus.
+
+    \sa QWidget::hasEditFocus()
+*/
+bool QWidgetPrivate::inTabWidget(QWidget *widget)
+{
+    for (QWidget *tabWidget = widget; tabWidget; tabWidget = tabWidget->parentWidget())
+        if (qobject_cast<const QTabWidget*>(tabWidget))
+            return true;
+    return false;
+}
 #endif
 
 /*!
diff --git a/src/gui/kernel/qwidget_p.h b/src/gui/kernel/qwidget_p.h
index b421d30..1bbc057 100644
--- a/src/gui/kernel/qwidget_p.h
+++ b/src/gui/kernel/qwidget_p.h
@@ -472,6 +472,8 @@ public:
 #ifdef QT_KEYPAD_NAVIGATION
     static bool navigateToDirection(Direction direction);
     static QWidget *widgetInNavigationDirection(Direction direction);
+    static bool canKeypadNavigate(Qt::Orientation orientation);
+    static bool inTabWidget(QWidget *widget);
 #endif
 
     void setWindowIconText_sys(const QString &cap);
diff --git a/src/gui/kernel/qwidget_s60.cpp b/src/gui/kernel/qwidget_s60.cpp
index ebd289c..7bbc142 100644
--- a/src/gui/kernel/qwidget_s60.cpp
+++ b/src/gui/kernel/qwidget_s60.cpp
@@ -1042,7 +1042,13 @@ void QWidget::setWindowState(Qt::WindowStates newstate)
     Q_D(QWidget);
 
     Qt::WindowStates oldstate = windowState();
-    if (oldstate == newstate)
+
+    const TBool isFullscreen = newstate & Qt::WindowFullScreen;
+    const TBool cbaRequested = windowFlags() & Qt::WindowSoftkeysVisibleHint;
+    const TBool cbaVisible = CEikButtonGroupContainer::Current() ? true : false;
+    const TBool softkeyVisibilityChange = isFullscreen && (cbaRequested != cbaVisible);
+
+    if (oldstate == newstate && !softkeyVisibilityChange)
         return;
 
     if (isWindow()) {
@@ -1058,16 +1064,27 @@ void QWidget::setWindowState(Qt::WindowStates newstate)
 
 #ifdef Q_WS_S60
         // Hide window decoration when switching to fullsccreen / minimized otherwise show decoration.
-        // The window decoration visibility has to be changed before doing actual window state 
-        // change since in that order the availableGeometry will return directly the right size and 
+        // The window decoration visibility has to be changed before doing actual window state
+        // change since in that order the availableGeometry will return directly the right size and
         // we will avoid unnecessarty redraws
-        CEikStatusPane* statusPane = S60->statusPane();
-        CEikButtonGroupContainer* buttonGroup = S60->buttonGroupContainer();
-        TBool visible = !(newstate & (Qt::WindowFullScreen | Qt::WindowMinimized)); 
+        CEikStatusPane *statusPane = S60->statusPane();
+        CEikButtonGroupContainer *buttonGroup = S60->buttonGroupContainer();
+        TBool visible = !(newstate & (Qt::WindowFullScreen | Qt::WindowMinimized));
         if (statusPane)
             statusPane->MakeVisible(visible);
-        if (buttonGroup)
-            buttonGroup->MakeVisible(visible);
+        if (buttonGroup) {
+            // Visibility
+            buttonGroup->MakeVisible(visible || (isFullscreen && cbaRequested));
+
+            // Responsiviness
+            CEikCba *cba = static_cast<CEikCba *>( buttonGroup->ButtonGroup() ); // downcast from MEikButtonGroup
+            TUint cbaFlags = cba->ButtonGroupFlags();
+            if(windowFlags() & Qt::WindowSoftkeysRespondHint)
+                cbaFlags |= EAknCBAFlagRespondWhenInvisible;
+            else
+                cbaFlags &= ~EAknCBAFlagRespondWhenInvisible;
+            cba->SetButtonGroupFlags(cbaFlags);
+        }
 #endif // Q_WS_S60
 
         createWinId();
@@ -1080,7 +1097,7 @@ void QWidget::setWindowState(Qt::WindowStates newstate)
         const QRect normalGeometry = (top->normalGeometry.width() < 0) ? geometry() : top->normalGeometry;
 
         if (newstate & Qt::WindowFullScreen)
-            setGeometry(qApp->desktop()->screenGeometry(this));
+            setGeometry(qApp->desktop()->availableGeometry(this));
         else if (newstate & Qt::WindowMaximized)
             setGeometry(qApp->desktop()->availableGeometry(this));
         else
diff --git a/src/gui/painting/qdrawutil.cpp b/src/gui/painting/qdrawutil.cpp
index 5619a2e..35bf2bf 100644
--- a/src/gui/painting/qdrawutil.cpp
+++ b/src/gui/painting/qdrawutil.cpp
@@ -1361,14 +1361,21 @@ void qDrawPixmaps(QPainter *painter, const QDrawPixmaps::Data *drawingData, int
 
         for (int i = 0; i < dataCount; ++i) {
             QTransform transform = oldTransform;
-            transform.translate(drawingData[i].point.x(), drawingData[i].point.y());
-            transform.rotate(drawingData[i].rotation);
-            painter->setOpacity(oldOpacity * drawingData[i].opacity);
+            qreal xOffset = 0;
+            qreal yOffset = 0;
+            if (drawingData[i].rotation == 0) {
+                xOffset = drawingData[i].point.x();
+                yOffset = drawingData[i].point.y();
+            } else {
+                transform.translate(drawingData[i].point.x(), drawingData[i].point.y());
+                transform.rotate(drawingData[i].rotation);
+            }
             painter->setTransform(transform);
+            painter->setOpacity(oldOpacity * drawingData[i].opacity);
 
             qreal w = drawingData[i].scaleX * drawingData[i].source.width();
             qreal h = drawingData[i].scaleY * drawingData[i].source.height();
-            painter->drawPixmap(QRectF(-0.5 * w, -0.5 * h, w, h), pixmap, drawingData[i].source);
+            painter->drawPixmap(QRectF(-0.5 * w + xOffset, -0.5 * h + yOffset, w, h), pixmap, drawingData[i].source);
         }
 
         painter->setOpacity(oldOpacity);
diff --git a/src/gui/styles/qwindowsmobilestyle.cpp b/src/gui/styles/qwindowsmobilestyle.cpp
index a264b1b..6e77409 100644
--- a/src/gui/styles/qwindowsmobilestyle.cpp
+++ b/src/gui/styles/qwindowsmobilestyle.cpp
@@ -4040,25 +4040,26 @@ enum QSliderDirection { SliderUp, SliderDown, SliderLeft, SliderRight };
 
 void QWindowsMobileStylePrivate::tintImagesButton(QColor color)
 {
-       if (currentTintButton == color)
+    if (currentTintButton == color)
         return;
-
-       imageTabEnd = QImage(tabend_xpm);
-       imageTabSelectedEnd = QImage(tabselectedend_xpm);
-       imageTabSelectedBegin = QImage(tabselectedbeginn_xpm);
-       imageTabMiddle = QImage(tabmiddle_xpm);
-       tintImage(&imageTabEnd, color, 0.0);
-       tintImage(&imageTabSelectedEnd, color, 0.0);
-       tintImage(&imageTabSelectedBegin, color, 0.0);
-       tintImage(&imageTabMiddle, color, 0.0);
-
-       if (!doubleControls) {
-           int height = imageTabMiddle.height() / 2 + 1;
-           imageTabEnd = imageTabEnd.scaledToHeight(height);
-           imageTabMiddle = imageTabMiddle.scaledToHeight(height);
-           imageTabSelectedEnd = imageTabSelectedEnd.scaledToHeight(height);
-           imageTabSelectedBegin = imageTabSelectedBegin.scaledToHeight(height);
-       }
+    currentTintButton = color;
+
+    imageTabEnd = QImage(tabend_xpm);
+    imageTabSelectedEnd = QImage(tabselectedend_xpm);
+    imageTabSelectedBegin = QImage(tabselectedbeginn_xpm);
+    imageTabMiddle = QImage(tabmiddle_xpm);
+    tintImage(&imageTabEnd, color, 0.0);
+    tintImage(&imageTabSelectedEnd, color, 0.0);
+    tintImage(&imageTabSelectedBegin, color, 0.0);
+    tintImage(&imageTabMiddle, color, 0.0);
+
+    if (!doubleControls) {
+        int height = imageTabMiddle.height() / 2 + 1;
+        imageTabEnd = imageTabEnd.scaledToHeight(height);
+        imageTabMiddle = imageTabMiddle.scaledToHeight(height);
+        imageTabSelectedEnd = imageTabSelectedEnd.scaledToHeight(height);
+        imageTabSelectedBegin = imageTabSelectedBegin.scaledToHeight(height);
+    }
 }
 
 void QWindowsMobileStylePrivate::tintImagesHigh(QColor color)
diff --git a/src/gui/widgets/qabstractslider.cpp b/src/gui/widgets/qabstractslider.cpp
index 4bd7b5a..2888490 100644
--- a/src/gui/widgets/qabstractslider.cpp
+++ b/src/gui/widgets/qabstractslider.cpp
@@ -47,9 +47,6 @@
 #ifndef QT_NO_ACCESSIBILITY
 #include "qaccessible.h"
 #endif
-#ifdef QT_KEYPAD_NAVIGATION
-#include "qtabwidget.h" // Needed in inTabWidget()
-#endif // QT_KEYPAD_NAVIGATION
 #include <limits.h>
 
 QT_BEGIN_NAMESPACE
@@ -702,7 +699,7 @@ bool QAbstractSliderPrivate::scrollByDelta(Qt::Orientation orientation, Qt::Keyb
         stepsToScroll = qBound(-pageStep, int(offset * pageStep), pageStep);
         offset_accumulated = 0;
     } else {
-        // Calculate how many lines to scroll. Depending on what delta is (and 
+        // Calculate how many lines to scroll. Depending on what delta is (and
         // offset), we might end up with a fraction (e.g. scroll 1.3 lines). We can
         // only scroll whole lines, so we keep the reminder until next event.
         qreal stepsToScrollF =
@@ -749,45 +746,7 @@ void QAbstractSlider::wheelEvent(QWheelEvent * e)
 }
 
 #endif
-#ifdef QT_KEYPAD_NAVIGATION
-/*!
-    \internal
-
-    Tells us if it there is currently a reachable widget by keypad navigation in
-    a certain \a orientation.
-    If no navigation is possible, occuring key events in that \a orientation may
-    be used to interact with the value in the focussed widget, even though it
-    currently has not the editFocus.
 
-    \sa QWidgetPrivate::widgetInNavigationDirection(), QWidget::hasEditFocus()
-*/
-inline static bool canKeypadNavigate(Qt::Orientation orientation)
-{
-    return orientation == Qt::Horizontal?
-            (QWidgetPrivate::widgetInNavigationDirection(QWidgetPrivate::DirectionEast)
-                    || QWidgetPrivate::widgetInNavigationDirection(QWidgetPrivate::DirectionWest))
-            :(QWidgetPrivate::widgetInNavigationDirection(QWidgetPrivate::DirectionNorth)
-                    || QWidgetPrivate::widgetInNavigationDirection(QWidgetPrivate::DirectionSouth));
-}
-/*!
-    \internal
-
-    Checks, if the \a widget is inside a QTabWidget. If is is inside
-    one, left/right key events will be used to switch between tabs in keypad
-    navigation. If there is no QTabWidget, the horizontal key events can be used to
-    interact with the value in the focussed widget, even though it currently has
-    not the editFocus.
-
-    \sa QWidget::hasEditFocus()
-*/
-inline static bool inTabWidget(QWidget *widget)
-{
-    for (QWidget *tabWidget = widget; tabWidget; tabWidget = tabWidget->parentWidget())
-        if (qobject_cast<const QTabWidget*>(tabWidget))
-            return true;
-    return false;
-}
-#endif // QT_KEYPAD_NAVIGATION
 /*!
     \reimp
 */
@@ -853,7 +812,8 @@ void QAbstractSlider::keyPressEvent(QKeyEvent *ev)
             if (QApplication::keypadNavigationEnabled()
                     && (!hasEditFocus() && QApplication::navigationMode() == Qt::NavigationModeKeypadTabOrder
                     || d->orientation == Qt::Vertical
-                    || !hasEditFocus() && (canKeypadNavigate(Qt::Horizontal) || inTabWidget(this)))) {
+                    || !hasEditFocus()
+                    && (QWidgetPrivate::canKeypadNavigate(Qt::Horizontal) || QWidgetPrivate::inTabWidget(this)))) {
                 ev->ignore();
                 return;
             }
@@ -872,7 +832,8 @@ void QAbstractSlider::keyPressEvent(QKeyEvent *ev)
             if (QApplication::keypadNavigationEnabled()
                     && (!hasEditFocus() && QApplication::navigationMode() == Qt::NavigationModeKeypadTabOrder
                     || d->orientation == Qt::Vertical
-                    || !hasEditFocus() && (canKeypadNavigate(Qt::Horizontal) || inTabWidget(this)))) {
+                    || !hasEditFocus()
+                    && (QWidgetPrivate::canKeypadNavigate(Qt::Horizontal) || QWidgetPrivate::inTabWidget(this)))) {
                 ev->ignore();
                 return;
             }
@@ -892,7 +853,7 @@ void QAbstractSlider::keyPressEvent(QKeyEvent *ev)
             if (QApplication::keypadNavigationEnabled()
                     && (QApplication::navigationMode() == Qt::NavigationModeKeypadTabOrder
                     || d->orientation == Qt::Horizontal
-                    || !hasEditFocus() && canKeypadNavigate(Qt::Vertical))) {
+                    || !hasEditFocus() && QWidgetPrivate::canKeypadNavigate(Qt::Vertical))) {
                 ev->ignore();
                 break;
             }
@@ -905,7 +866,7 @@ void QAbstractSlider::keyPressEvent(QKeyEvent *ev)
             if (QApplication::keypadNavigationEnabled()
                     && (QApplication::navigationMode() == Qt::NavigationModeKeypadTabOrder
                     || d->orientation == Qt::Horizontal
-                    || !hasEditFocus() && canKeypadNavigate(Qt::Vertical))) {
+                    || !hasEditFocus() && QWidgetPrivate::canKeypadNavigate(Qt::Vertical))) {
                 ev->ignore();
                 break;
             }
diff --git a/src/opengl/qgl_p.h b/src/opengl/qgl_p.h
index 0d5a54a..80217c0 100644
--- a/src/opengl/qgl_p.h
+++ b/src/opengl/qgl_p.h
@@ -80,13 +80,19 @@
 #define q_vertexTypeEnum GL_FIXED
 #endif //QT_OPENGL_ES_1_CL
 
-#ifdef QT_OPENGL_ES
+#if defined(QT_OPENGL_ES) || defined(QT_OPENGL_ES_2)
 QT_BEGIN_INCLUDE_NAMESPACE
+
 #if defined(QT_OPENGL_ES_2)
-#include <EGL/egl.h>
+#   include <GLES2/gl2.h>
+#endif
+
+#if defined(QT_GLES_EGL)
+#   include <GLES/egl.h>
 #else
-#include <GLES/egl.h>
+#   include <EGL/egl.h>
 #endif
+
 QT_END_INCLUDE_NAMESPACE
 #endif
 
diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.cpp b/src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.cpp
index 2b11058..388e369 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.cpp
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.cpp
@@ -1,4 +1,4 @@
-/****************************************************************************
+ /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
@@ -68,11 +68,10 @@ public:
     };
 
     enum CompositionModeStatus {
-        PorterDuff_None = 0x00,
-        PorterDuff_SupportedBlits = 0x01,
-        PorterDuff_SupportedPrimitives = 0x02,
-        PorterDuff_SupportedOpaquePrimitives = 0x04,
-        PorterDuff_Dirty = 0x10
+        PorterDuff_None = 0x0,
+        PorterDuff_Supported = 0x1,
+        PorterDuff_PremultiplyColors = 0x2,
+        PorterDuff_AlwaysBlend = 0x4
     };
 
     enum ClipType {
@@ -97,7 +96,6 @@ public:
     inline void unlock();
     static inline void unlock(QDirectFBPaintDevice *device);
 
-    inline bool testCompositionMode(const QPen *pen, const QBrush *brush, const QColor *color = 0) const;
     inline bool isSimpleBrush(const QBrush &brush) const;
 
     void drawTiledPixmap(const QRectF &dest, const QPixmap &pixmap, const QPointF &pos);
@@ -130,6 +128,7 @@ public:
     ClipType clipType;
     QDirectFBPaintDevice *dfbDevice;
     uint compositionModeStatus;
+    bool isPremultiplied;
 
     bool inClip;
     QRect currentClip;
@@ -287,6 +286,7 @@ bool QDirectFBPaintEngine::begin(QPaintDevice *device)
         qFatal("QDirectFBPaintEngine used on an invalid device: 0x%x",
                device->devType());
     }
+    d->isPremultiplied = QDirectFBScreen::isPremultiplied(d->dfbDevice->format());
 
     d->prepare(d->dfbDevice);
     gccaps = AllFeatures;
@@ -413,7 +413,7 @@ void QDirectFBPaintEngine::drawRects(const QRect *rects, int rectCount)
         || !d->simplePen
         || d->clipType == QDirectFBPaintEnginePrivate::ComplexClip
         || !d->isSimpleBrush(brush)
-        || !d->testCompositionMode(&pen, &brush)) {
+        || !(d->compositionModeStatus & QDirectFBPaintEnginePrivate::PorterDuff_Supported)) {
         RASTERFALLBACK(DRAW_RECTS, rectCount, VOID_ARG(), VOID_ARG());
         d->lock();
         QRasterPaintEngine::drawRects(rects, rectCount);
@@ -443,7 +443,7 @@ void QDirectFBPaintEngine::drawRects(const QRectF *rects, int rectCount)
         || !d->simplePen
         || d->clipType == QDirectFBPaintEnginePrivate::ComplexClip
         || !d->isSimpleBrush(brush)
-        || !d->testCompositionMode(&pen, &brush)) {
+        || !(d->compositionModeStatus & QDirectFBPaintEnginePrivate::PorterDuff_Supported)) {
         RASTERFALLBACK(DRAW_RECTS, rectCount, VOID_ARG(), VOID_ARG());
         d->lock();
         QRasterPaintEngine::drawRects(rects, rectCount);
@@ -468,7 +468,7 @@ void QDirectFBPaintEngine::drawLines(const QLine *lines, int lineCount)
     const QPen &pen = state()->pen;
     if (!d->simplePen
         || d->clipType == QDirectFBPaintEnginePrivate::ComplexClip
-        || !d->testCompositionMode(&pen, 0)) {
+        || !(d->compositionModeStatus & QDirectFBPaintEnginePrivate::PorterDuff_Supported)) {
         RASTERFALLBACK(DRAW_LINES, lineCount, VOID_ARG(), VOID_ARG());
         d->lock();
         QRasterPaintEngine::drawLines(lines, lineCount);
@@ -488,7 +488,7 @@ void QDirectFBPaintEngine::drawLines(const QLineF *lines, int lineCount)
     const QPen &pen = state()->pen;
     if (!d->simplePen
         || d->clipType == QDirectFBPaintEnginePrivate::ComplexClip
-        || !d->testCompositionMode(&pen, 0)) {
+        || !(d->compositionModeStatus & QDirectFBPaintEnginePrivate::PorterDuff_Supported)) {
         RASTERFALLBACK(DRAW_LINES, lineCount, VOID_ARG(), VOID_ARG());
         d->lock();
         QRasterPaintEngine::drawLines(lines, lineCount);
@@ -526,7 +526,7 @@ void QDirectFBPaintEngine::drawImage(const QRectF &r, const QImage &image,
     */
 
 #if !defined QT_NO_DIRECTFB_PREALLOCATED || defined QT_DIRECTFB_IMAGECACHE
-    if (!(d->compositionModeStatus & QDirectFBPaintEnginePrivate::PorterDuff_SupportedBlits)
+    if (!(d->compositionModeStatus & QDirectFBPaintEnginePrivate::PorterDuff_Supported)
         || (d->transformationType & QDirectFBPaintEnginePrivate::Matrix_BlitsUnsupported)
         || (d->clipType == QDirectFBPaintEnginePrivate::ComplexClip)
         || (!d->supportsStretchBlit() && state()->matrix.mapRect(r).size() != sr.size())
@@ -575,7 +575,7 @@ void QDirectFBPaintEngine::drawPixmap(const QRectF &r, const QPixmap &pixmap,
         QPixmapData *data = pixmap.pixmapData();
         Q_ASSERT(data->classId() == QPixmapData::DirectFBClass);
         QDirectFBPixmapData *dfbData = static_cast<QDirectFBPixmapData*>(data);
-        if (!(d->compositionModeStatus & QDirectFBPaintEnginePrivate::PorterDuff_SupportedBlits)
+        if (!(d->compositionModeStatus & QDirectFBPaintEnginePrivate::PorterDuff_Supported)
             || (d->transformationType & QDirectFBPaintEnginePrivate::Matrix_BlitsUnsupported)
             || (d->clipType == QDirectFBPaintEnginePrivate::ComplexClip)
             || (!d->supportsStretchBlit() && state()->matrix.mapRect(r).size() != sr.size())) {
@@ -606,7 +606,7 @@ void QDirectFBPaintEngine::drawTiledPixmap(const QRectF &r,
         RASTERFALLBACK(DRAW_TILED_PIXMAP, r, pixmap.size(), offset);
         d->lock();
         QRasterPaintEngine::drawTiledPixmap(r, pixmap, offset);
-    } else if (!(d->compositionModeStatus & QDirectFBPaintEnginePrivate::PorterDuff_SupportedBlits)
+    } else if (!(d->compositionModeStatus & QDirectFBPaintEnginePrivate::PorterDuff_Supported)
                || (d->transformationType & QDirectFBPaintEnginePrivate::Matrix_BlitsUnsupported)
                || (d->clipType == QDirectFBPaintEnginePrivate::ComplexClip)
                || (!d->supportsStretchBlit() && state()->matrix.isScaling())) {
@@ -720,7 +720,7 @@ void QDirectFBPaintEngine::fillRect(const QRectF &rect, const QBrush &brush)
         switch (brush.style()) {
         case Qt::SolidPattern: {
             if (d->transformationType & QDirectFBPaintEnginePrivate::Matrix_RectsUnsupported
-                || !d->testCompositionMode(0, &brush)) {
+                || !(d->compositionModeStatus & QDirectFBPaintEnginePrivate::PorterDuff_Supported)) {
                 break;
             }
             const QColor color = brush.color();
@@ -732,7 +732,7 @@ void QDirectFBPaintEngine::fillRect(const QRectF &rect, const QBrush &brush)
             return; }
 
         case Qt::TexturePattern: {
-            if (!(d->compositionModeStatus & QDirectFBPaintEnginePrivate::PorterDuff_SupportedBlits)
+            if (!(d->compositionModeStatus & QDirectFBPaintEnginePrivate::PorterDuff_Supported)
                 || (d->transformationType & QDirectFBPaintEnginePrivate::Matrix_BlitsUnsupported)
                 || (!d->supportsStretchBlit() && state()->matrix.isScaling())) {
                 break;
@@ -760,7 +760,7 @@ void QDirectFBPaintEngine::fillRect(const QRectF &rect, const QColor &color)
     Q_D(QDirectFBPaintEngine);
     if ((d->transformationType & QDirectFBPaintEnginePrivate::Matrix_RectsUnsupported)
         || (d->clipType == QDirectFBPaintEnginePrivate::ComplexClip)
-        || !d->testCompositionMode(0, 0, &color)) {
+        || !(d->compositionModeStatus & QDirectFBPaintEnginePrivate::PorterDuff_Supported)) {
         RASTERFALLBACK(FILL_RECT, rect, color, VOID_ARG());
         d->lock();
         QRasterPaintEngine::fillRect(rect, color);
@@ -804,7 +804,7 @@ QDirectFBPaintEnginePrivate::QDirectFBPaintEnginePrivate(QDirectFBPaintEngine *p
     : surface(0), antialiased(false), simplePen(false),
       transformationType(0), opacity(255),
       clipType(ClipUnset), dfbDevice(0),
-      compositionModeStatus(0), inClip(false), q(p)
+      compositionModeStatus(0), isPremultiplied(false), inClip(false), q(p)
 {
     fb = QDirectFBScreen::instance()->dfb();
     surfaceCache = new SurfaceCache;
@@ -820,36 +820,6 @@ bool QDirectFBPaintEnginePrivate::isSimpleBrush(const QBrush &brush) const
     return (brush.style() == Qt::NoBrush) || (brush.style() == Qt::SolidPattern && !antialiased);
 }
 
-bool QDirectFBPaintEnginePrivate::testCompositionMode(const QPen *pen, const QBrush *brush, const QColor *color) const
-{
-    Q_ASSERT(!pen || pen->style() == Qt::NoPen || pen->style() == Qt::SolidLine);
-    Q_ASSERT(!brush || brush->style() == Qt::NoBrush || brush->style() == Qt::SolidPattern);
-    switch (compositionModeStatus & (QDirectFBPaintEnginePrivate::PorterDuff_SupportedOpaquePrimitives
-                                     |QDirectFBPaintEnginePrivate::PorterDuff_SupportedPrimitives)) {
-    case QDirectFBPaintEnginePrivate::PorterDuff_SupportedPrimitives:
-        return true;
-    case QDirectFBPaintEnginePrivate::PorterDuff_SupportedOpaquePrimitives:
-        if (pen && pen->style() == Qt::SolidLine && pen->color().alpha() != 255)
-            return false;
-        if (brush) {
-            if (brush->style() == Qt::SolidPattern && brush->color().alpha() != 255) {
-                return false;
-            }
-        } else if (color && color->alpha() != 255) {
-            return false;
-        }
-        return true;
-    case QDirectFBPaintEnginePrivate::PorterDuff_None:
-        return false;
-    default:
-        // ### PorterDuff_SupportedOpaquePrimitives|PorterDuff_SupportedPrimitives can't be combined
-        break;
-    }
-    Q_ASSERT(0);
-    return false;
-}
-
-
 void QDirectFBPaintEnginePrivate::lock()
 {
     // We will potentially get a new pointer to the buffer after a
@@ -912,21 +882,23 @@ void QDirectFBPaintEnginePrivate::setCompositionMode(QPainter::CompositionMode m
 
     static const bool forceRasterFallBack = qgetenv("QT_DIRECTFB_FORCE_RASTER").toInt() > 0;
     if (forceRasterFallBack) {
-        compositionModeStatus = 0;
+        compositionModeStatus = PorterDuff_None;
         return;
     }
 
-    compositionModeStatus = PorterDuff_SupportedBlits;
+    compositionModeStatus = PorterDuff_Supported|PorterDuff_PremultiplyColors|PorterDuff_AlwaysBlend;
     switch (mode) {
     case QPainter::CompositionMode_Clear:
         surface->SetPorterDuff(surface, DSPD_CLEAR);
         break;
     case QPainter::CompositionMode_Source:
         surface->SetPorterDuff(surface, DSPD_SRC);
-        compositionModeStatus |= PorterDuff_SupportedOpaquePrimitives;
+        compositionModeStatus &= ~PorterDuff_AlwaysBlend;
+        if (!isPremultiplied)
+            compositionModeStatus &= ~PorterDuff_PremultiplyColors;
         break;
     case QPainter::CompositionMode_SourceOver:
-        compositionModeStatus |= PorterDuff_SupportedPrimitives;
+        compositionModeStatus &= ~PorterDuff_AlwaysBlend;
         surface->SetPorterDuff(surface, DSPD_SRC_OVER);
         break;
     case QPainter::CompositionMode_DestinationOver:
@@ -934,6 +906,8 @@ void QDirectFBPaintEnginePrivate::setCompositionMode(QPainter::CompositionMode m
         break;
     case QPainter::CompositionMode_SourceIn:
         surface->SetPorterDuff(surface, DSPD_SRC_IN);
+        if (!isPremultiplied)
+            compositionModeStatus &= ~PorterDuff_PremultiplyColors;
         break;
     case QPainter::CompositionMode_DestinationIn:
         surface->SetPorterDuff(surface, DSPD_DST_IN);
@@ -944,6 +918,11 @@ void QDirectFBPaintEnginePrivate::setCompositionMode(QPainter::CompositionMode m
     case QPainter::CompositionMode_DestinationOut:
         surface->SetPorterDuff(surface, DSPD_DST_OUT);
         break;
+#if (Q_DIRECTFB_VERSION >= 0x010200)
+    case QPainter::CompositionMode_Destination:
+        surface->SetPorterDuff(surface, DSPD_DST);
+        break;
+#endif
 #if (Q_DIRECTFB_VERSION >= 0x010000)
     case QPainter::CompositionMode_SourceAtop:
         surface->SetPorterDuff(surface, DSPD_SRC_ATOP);
@@ -959,7 +938,7 @@ void QDirectFBPaintEnginePrivate::setCompositionMode(QPainter::CompositionMode m
         break;
 #endif
     default:
-        compositionModeStatus = 0;
+        compositionModeStatus = PorterDuff_None;
         break;
     }
 }
@@ -981,9 +960,6 @@ void QDirectFBPaintEnginePrivate::prepareForBlit(bool alpha)
     }
     surface->SetColor(surface, 0xff, 0xff, 0xff, opacity);
     surface->SetBlittingFlags(surface, blittingFlags);
-    if (compositionModeStatus & PorterDuff_Dirty) {
-        setCompositionMode(q->state()->composition_mode);
-    }
 }
 
 static inline uint ALPHA_MUL(uint x, uint a)
@@ -996,12 +972,20 @@ static inline uint ALPHA_MUL(uint x, uint a)
 void QDirectFBPaintEnginePrivate::setDFBColor(const QColor &color)
 {
     Q_ASSERT(surface);
+    Q_ASSERT(compositionModeStatus & PorterDuff_Supported);
     const quint8 alpha = (opacity == 255 ?
                           color.alpha() : ALPHA_MUL(color.alpha(), opacity));
-    surface->SetColor(surface, color.red(), color.green(), color.blue(), alpha);
-    surface->SetPorterDuff(surface, DSPD_NONE);
-    surface->SetDrawingFlags(surface, alpha == 255 ? DSDRAW_NOFX : DSDRAW_BLEND);
-    compositionModeStatus |= PorterDuff_Dirty;
+    QColor col;
+    if (compositionModeStatus & PorterDuff_PremultiplyColors) {
+        col = QColor(ALPHA_MUL(color.red(), alpha),
+                     ALPHA_MUL(color.green(), alpha),
+                     ALPHA_MUL(color.blue(), alpha),
+                     alpha);
+    } else {
+        col = QColor(color.red(), color.green(), color.blue(), alpha);
+    }
+    surface->SetColor(surface, col.red(), col.green(), col.blue(), col.alpha());
+    surface->SetDrawingFlags(surface, alpha == 255 && !(compositionModeStatus & PorterDuff_AlwaysBlend) ? DSDRAW_NOFX : DSDRAW_BLEND);
 }
 
 IDirectFBSurface *QDirectFBPaintEnginePrivate::getSurface(const QImage &img, bool *release)
diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbpixmap.cpp b/src/plugins/gfxdrivers/directfb/qdirectfbpixmap.cpp
index ba50329..b5ac67d 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbpixmap.cpp
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbpixmap.cpp
@@ -425,7 +425,7 @@ void QDirectFBPixmapData::fill(const QColor &color)
 
     Q_ASSERT(dfbSurface);
 
-    alpha = (color.alpha() < 255);
+    alpha |= (color.alpha() < 255);
 
     if (alpha && isOpaqueFormat(imageFormat)) {
         QSize size;