Merge remote branch 'earth/master' into symbian-socket-engine

Conflicts:
	src/network/access/qhttpnetworkconnectionchannel.cpp
	src/network/socket/qlocalsocket.cpp
	src/s60installs/bwins/QtCoreu.def
	src/s60installs/bwins/QtGuiu.def
	src/s60installs/bwins/QtTestu.def
	src/s60installs/eabi/QtCoreu.def
	src/s60installs/eabi/QtGuiu.def

156 files changed, 3921 insertions, 397 deletions

diff --git a/src/gui/dialogs/qfiledialog.cpp b/src/gui/dialogs/qfiledialog.cpp
index 0c1304f..897a916 100644
--- a/src/gui/dialogs/qfiledialog.cpp
+++ b/src/gui/dialogs/qfiledialog.cpp
@@ -2996,6 +2996,7 @@ void QFileDialogPrivate::_q_useNameFilter(int index)
             const int fileNameExtensionLength = fileNameExtension.count();
             fileName.replace(fileName.count() - fileNameExtensionLength,
                              fileNameExtensionLength, newNameFilterExtension);
+            qFileDialogUi->listView->clearSelection();
             lineEdit()->setText(fileName);
         }
     }
diff --git a/src/gui/dialogs/qfileinfogatherer.cpp b/src/gui/dialogs/qfileinfogatherer.cpp
index 12e77b1..b36b21e 100644
--- a/src/gui/dialogs/qfileinfogatherer.cpp
+++ b/src/gui/dialogs/qfileinfogatherer.cpp
@@ -78,11 +78,11 @@ QFileInfoGatherer::QFileInfoGatherer(QObject *parent)
 #endif
       m_resolveSymlinks(false), m_iconProvider(&defaultProvider)
 {
-#ifndef Q_OS_WIN
+#ifdef Q_OS_WIN
+    m_resolveSymlinks = true;
+#elif !defined(Q_OS_INTEGRITY)
     userId = getuid();
     groupId = getgid();
-#else
-    m_resolveSymlinks = true;
 #endif
 #ifndef QT_NO_FILESYSTEMWATCHER
     watcher = new QFileSystemWatcher(this);
diff --git a/src/gui/embedded/embedded.pri b/src/gui/embedded/embedded.pri
index eb13d8d..31f0bc6 100644
--- a/src/gui/embedded/embedded.pri
+++ b/src/gui/embedded/embedded.pri
@@ -120,6 +120,12 @@ embedded {
                 LIBS += -lgf
         }
 
+        contains( gfx-drivers, integrityfb ) {
+                HEADERS += embedded/qscreenintegrityfb_qws.h
+                SOURCES += embedded/qscreenintegrityfb_qws.cpp
+                LIBS += -lfbdev
+        }
+
 	contains( gfx-drivers, qvfb ) {
 		HEADERS += embedded/qscreenvfb_qws.h
 		SOURCES += embedded/qscreenvfb_qws.cpp
@@ -174,6 +180,11 @@ embedded {
                 SOURCES += embedded/qkbdqnx_qws.cpp
         }
 
+        contains( kbd-drivers, integrity ) {
+                HEADERS += embedded/qkbdintegrity_qws.h
+                SOURCES += embedded/qkbdintegrity_qws.cpp
+        }
+
 #
 # Mouse drivers
 #
@@ -207,4 +218,9 @@ embedded {
                 HEADERS += embedded/qmouseqnx_qws.h
                 SOURCES += embedded/qmouseqnx_qws.cpp
         }
+
+	contains( mouse-drivers, integrity ) {
+                HEADERS += embedded/qmouseintegrity_qws.h
+                SOURCES += embedded/qmouseintegrity_qws.cpp
+        }
 }
diff --git a/src/gui/embedded/qkbddriverfactory_qws.cpp b/src/gui/embedded/qkbddriverfactory_qws.cpp
index 661b073..45825e5 100644
--- a/src/gui/embedded/qkbddriverfactory_qws.cpp
+++ b/src/gui/embedded/qkbddriverfactory_qws.cpp
@@ -49,6 +49,7 @@
 #include "qkbdum_qws.h"
 #include "qkbdvfb_qws.h"
 #include "qkbdqnx_qws.h"
+#include "qkbdintegrity_qws.h"
 #include <stdlib.h>
 #include "private/qfactoryloader_p.h"
 #include "qkbddriverplugin_qws.h"
@@ -106,6 +107,10 @@ QWSKeyboardHandler *QKbdDriverFactory::create(const QString& key, const QString&
     if (driver == QLatin1String("qnx") || driver.isEmpty())
         return new QWSQnxKeyboardHandler(device);
 #endif
+#if defined(Q_OS_INTEGRITY)
+    if (driver == QLatin1String("integrity") || driver.isEmpty())
+        return new QWSIntKeyboardHandler(device);
+#endif
 #ifndef QT_NO_QWS_KEYBOARD
 # ifndef QT_NO_QWS_KBD_TTY
     if (driver == QLatin1String("tty") || driver.isEmpty())
@@ -151,6 +156,9 @@ QStringList QKbdDriverFactory::keys()
 #if defined(Q_OS_QNX) && !defined(QT_NO_QWS_KBD_QNX)
     list << QLatin1String("QNX");
 #endif
+#if defined(Q_OS_INTEGRITY) && !defined(QT_NO_QWS_KBD_INTEGRITY)
+    list << QLatin1String("INTEGRITY");
+#endif
 #ifndef QT_NO_QWS_KBD_TTY
     list << QLatin1String("TTY");
 #endif
diff --git a/src/gui/embedded/qkbdintegrity_qws.cpp b/src/gui/embedded/qkbdintegrity_qws.cpp
new file mode 100644
index 0000000..b2df422
--- /dev/null
+++ b/src/gui/embedded/qkbdintegrity_qws.cpp
@@ -0,0 +1,197 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#if !defined(QT_NO_QWS_KEYBOARD) && !defined(QT_NO_QWS_KBD_INTEGRITY)
+
+#include "qkbdintegrity_qws.h"
+#include <qwindowsystem_qws.h>
+#include <qapplication.h>
+#include <qtimer.h>
+#include <qthread.h>
+
+#include <INTEGRITY.h>
+
+
+//===========================================================================
+
+QT_BEGIN_NAMESPACE
+
+//
+// INTEGRITY keyboard
+//
+
+class QIntKeyboardListenThread;
+
+class QWSIntKbPrivate : public QObject
+{
+    Q_OBJECT
+    friend class QIntKeyboardListenThread;
+public:
+    QWSIntKbPrivate(QWSKeyboardHandler *, const QString &device);
+    ~QWSIntKbPrivate();
+    void dataReady(int amount) { emit kbdDataAvailable(amount); }
+    uint8_t scancodebuf[32 /* USB_SCANCODE_BUF_LEN */ ];
+    uint8_t rxpost;
+    uint8_t rxack;
+
+Q_SIGNALS:
+    void kbdDataAvailable(int amount);
+
+private Q_SLOTS:
+    void readKeyboardData(int amount);
+
+private:
+    QWSKeyboardHandler *handler;
+    QIntKeyboardListenThread *kbdthread;
+};
+class QIntKeyboardListenThread : public QThread
+{
+protected:
+    QWSIntKbPrivate *imp;
+    bool loop;
+public:
+    QIntKeyboardListenThread(QWSIntKbPrivate *im) : QThread(), imp(im) {};
+    ~QIntKeyboardListenThread() {};
+    void run();
+    void stoploop() { loop = false; };
+};
+
+
+QWSIntKeyboardHandler::QWSIntKeyboardHandler(const QString &device)
+    : QWSKeyboardHandler(device)
+{
+    d = new QWSIntKbPrivate(this, device);
+}
+
+QWSIntKeyboardHandler::~QWSIntKeyboardHandler()
+{
+    delete d;
+}
+
+//void QWSIntKeyboardHandler::processKeyEvent(int keycode, bool isPress,
+//                                            bool autoRepeat)
+//{
+//    QWSKeyboardHandler::processKeyEvent(keycode, isPress, autoRepeat);
+//}
+
+void QIntKeyboardListenThread::run(void)
+{
+    Error E;
+    Buffer b;
+    Connection kbdc;
+    bool waitforresource = true;
+    do {
+        E = RequestResource((Object*)&kbdc,
+                "USBKeyboardClient", "!systempassword");
+        if (E == Success) {
+            loop = false;
+        } else {
+            E = RequestResource((Object*)&kbdc,
+                    "KeyboardClient", "!systempassword");
+            if (E == Success) {
+                waitforresource = false;
+            }
+        }
+        if (waitforresource)
+            ::sleep(1);
+    } while (loop && waitforresource);
+    if (!loop)
+        return;
+    b.BufferType = DataBuffer | LastBuffer;
+    b.Length = sizeof(imp->scancodebuf);
+    b.TheAddress = (Address)imp->scancodebuf;
+    do {
+        b.Transferred = 0;
+        b.TheAddress = (Address)imp->scancodebuf + imp->rxpost;
+        CheckSuccess(SynchronousReceive(kbdc, &b));
+        imp->rxpost += b.Transferred;
+        if (imp->rxpost >= 32 /* USB_SCANCODE_BUF_LEN */)
+            imp->rxpost = 0;
+        if (imp->rxpost == (imp->rxack + b.Transferred) % 32 /* USB_SCANCODE_BUF_LEN */) {
+            imp->kbdDataAvailable(b.Transferred);
+        }
+    } while (loop);
+}
+
+void QWSIntKbPrivate::readKeyboardData(int amount)
+{
+    uint16_t keycode;
+    do {
+        if (scancodebuf[rxack] == 0xe0) {
+            keycode = scancodebuf[rxack] << 8;
+            rxack++;
+            if (rxack >= 32 /* USB_SCANCODE_BUF_LEN */)
+                rxack = 0;
+        } else {
+            keycode = 0;
+        }
+
+        handler->processKeycode(keycode + (scancodebuf[rxack] & 0x7f),
+                (scancodebuf[rxack] & 0x80) == 0,
+                scancodebuf[rxack] == 2);
+        rxack++;
+        if (rxack >= 32 /* USB_SCANCODE_BUF_LEN */)
+            rxack = 0;
+    } while (rxack != rxpost);
+}
+
+QWSIntKbPrivate::QWSIntKbPrivate(QWSKeyboardHandler *h, const QString &device) : handler(h)
+{
+    connect(this, SIGNAL(kbdDataAvailable(int)), this, SLOT(readKeyboardData(int)));
+    this->handler = handler;
+    rxack = rxpost = 0;
+    kbdthread = new QIntKeyboardListenThread(this);
+    kbdthread->start();
+}
+
+QWSIntKbPrivate::~QWSIntKbPrivate()
+{
+    kbdthread->stoploop();
+    kbdthread->wait();
+    delete kbdthread;
+}
+
+
+QT_END_NAMESPACE
+
+#include "qkbdintegrity_qws.moc"
+
+#endif // QT_NO_QWS_KEYBOARD || QT_NO_QWS_KBD_TTY
diff --git a/src/gui/embedded/qkbdintegrity_qws.h b/src/gui/embedded/qkbdintegrity_qws.h
new file mode 100644
index 0000000..f9ae4e3
--- /dev/null
+++ b/src/gui/embedded/qkbdintegrity_qws.h
@@ -0,0 +1,81 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QKBDINTEGRITY_QWS_H
+#define QKBDINTEGRITY_QWS_H
+
+#include <QtGui/qkbd_qws.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+#ifndef QT_NO_QWS_KEYBOARD
+
+#ifndef QT_NO_QWS_KBD_INTEGRITY
+
+class QSocketNotifier;
+class QWSIntKbPrivate;
+
+class QWSIntKeyboardHandler : public QWSKeyboardHandler
+{
+public:
+    explicit QWSIntKeyboardHandler(const QString&);
+    virtual ~QWSIntKeyboardHandler();
+
+//protected:
+//    virtual void processKeyEvent(int keycode, bool isPress, bool autoRepeat);
+
+private:
+    QWSIntKbPrivate *d;
+};
+
+#endif // QT_NO_QWS_KBD_INTEGRITY
+
+#endif // QT_NO_QWS_KEYBOARD
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QKBDINTEGRITY_QWS_H
diff --git a/src/gui/embedded/qmousedriverfactory_qws.cpp b/src/gui/embedded/qmousedriverfactory_qws.cpp
index 81e6552..f67284d 100644
--- a/src/gui/embedded/qmousedriverfactory_qws.cpp
+++ b/src/gui/embedded/qmousedriverfactory_qws.cpp
@@ -48,6 +48,7 @@
 #include "qmousevfb_qws.h"
 #include "qmousetslib_qws.h"
 #include "qmouseqnx_qws.h"
+#include "qmouseintegrity_qws.h"
 #include <stdlib.h>
 #include "private/qfactoryloader_p.h"
 #include "qmousedriverplugin_qws.h"
@@ -107,6 +108,10 @@ QWSMouseHandler *QMouseDriverFactory::create(const QString& key, const QString &
     if (driver == QLatin1String("qnx") || driver.isEmpty())
         return new QQnxMouseHandler(key, device);
 #endif
+#if defined(Q_OS_INTEGRITY) && !defined(QT_NO_MOUSE_INTEGRITY)
+    if (driver == QLatin1String("integrity") || driver.isEmpty())
+        return new QIntMouseHandler(key, device);
+#endif
 #ifndef QT_NO_QWS_MOUSE_LINUXTP
     if (driver == QLatin1String("linuxtp") || driver.isEmpty())
         return new QWSLinuxTPMouseHandler(key, device);
@@ -157,6 +162,9 @@ QStringList QMouseDriverFactory::keys()
 #if defined(Q_OS_QNX) && !defined(QT_NO_QWS_MOUSE_QNX)
     list << QLatin1String("QNX");
 #endif
+#if defined(Q_OS_INTEGRITY) && !defined(QT_NO_QWS_MOUSE_INTEGRITY)
+    list << QLatin1String("INTEGRITY");
+#endif
 #ifndef QT_NO_QWS_MOUSE_LINUXTP
     list << QLatin1String("LinuxTP");
 #endif
diff --git a/src/gui/embedded/qmouseintegrity_qws.cpp b/src/gui/embedded/qmouseintegrity_qws.cpp
new file mode 100644
index 0000000..78a8c1b
--- /dev/null
+++ b/src/gui/embedded/qmouseintegrity_qws.cpp
@@ -0,0 +1,271 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QT_NO_QWS_MOUSE_INTEGRITY
+
+#include "qmouseintegrity_qws.h"
+#include <qwindowsystem_qws.h>
+#include <qapplication.h>
+#include <qtimer.h>
+#include <qthread.h>
+
+#include <INTEGRITY.h>
+
+
+typedef Address MOUSEHandler;
+typedef struct MOUSEMessageStruct
+{
+    Value x;
+    Value y;
+    Value z;
+    Value buttons;
+} MOUSEMessage;
+
+static Error MOUSE_Init(MOUSEHandler *handler, Boolean *isabsolute);
+static Error MOUSE_SynchronousGetPosition(MOUSEHandler handler, MOUSEMessage *msg,
+                                          Boolean absolute);
+static Error MOUSE_ShouldFilter(MOUSEHandler handler, Boolean *filter);
+
+QT_BEGIN_NAMESPACE
+
+class QIntMouseListenThread;
+
+class QIntMousePrivate : public QObject
+{
+    Q_OBJECT
+    friend class QIntMouseListenTaskThread;
+Q_SIGNALS:
+    void mouseDataAvailable(int x, int y, int buttons);
+public:
+    QIntMousePrivate(QIntMouseHandler *handler);
+    ~QIntMousePrivate();
+    void dataReady(int x, int y, int buttons) { emit mouseDataAvailable(x, y, buttons); }
+    bool calibrated;
+    bool waitforread;
+    bool suspended;
+    QIntMouseListenThread *mousethread;
+
+private:
+    QIntMouseHandler *handler;
+};
+
+class QIntMouseListenThread : public QThread
+{
+protected:
+    QIntMousePrivate *imp;
+    bool loop;
+public:
+    QIntMouseListenThread(QIntMousePrivate *im) : QThread(), imp(im) {};
+    ~QIntMouseListenThread() {};
+    void run();
+    void stoploop() { loop = false; };
+};
+
+
+QIntMouseHandler::QIntMouseHandler(const QString &driver, const QString &device)
+    : QObject(), QWSCalibratedMouseHandler(driver, device)
+{
+    QPoint test(1,1);
+    d = new QIntMousePrivate(this);
+    connect(d, SIGNAL(mouseDataAvailable(int, int, int)), this, SLOT(readMouseData(int, int, int)));
+
+    d->calibrated = (test != transform(test));
+
+    d->mousethread->start();
+}
+
+QIntMouseHandler::~QIntMouseHandler()
+{
+    disconnect(d, SIGNAL(mouseDataAvailable(int, int, int)), this, SLOT(readMouseData(int, int, int)));
+    delete d;
+}
+
+void QIntMouseHandler::resume()
+{
+    d->suspended = true;
+}
+
+void QIntMouseHandler::suspend()
+{
+    d->suspended = false;
+}
+
+void QIntMouseHandler::readMouseData(int x, int y, int buttons)
+{
+    d->waitforread = false;
+    if (d->suspended)
+        return;
+    if (d->calibrated) {
+        sendFiltered(QPoint(x, y), buttons);
+    } else {
+        QPoint pos;
+        pos = transform(QPoint(x, y));
+        limitToScreen(pos);
+        mouseChanged(pos, buttons, 0);
+    }
+}
+
+void QIntMouseHandler::clearCalibration()
+{
+    QWSCalibratedMouseHandler::clearCalibration();
+}
+
+void QIntMouseHandler::calibrate(const QWSPointerCalibrationData *data)
+{
+    QWSCalibratedMouseHandler::calibrate(data);
+}
+
+void QIntMouseListenThread::run(void)
+{
+    MOUSEHandler handler;
+    MOUSEMessage msg;
+    Boolean filter;
+    Boolean isabsolute;
+    loop = true;
+    CheckSuccess(MOUSE_Init(&handler, &isabsolute));
+    CheckSuccess(MOUSE_ShouldFilter(handler, &filter));
+    if (!filter)
+        imp->calibrated = false;
+    imp->waitforread = false;
+    do {
+        MOUSE_SynchronousGetPosition(handler, &msg, isabsolute);
+        imp->dataReady(msg.x, msg.y, msg.buttons);
+    } while (loop);
+    QThread::exit(0);
+}
+
+QIntMousePrivate::QIntMousePrivate(QIntMouseHandler *handler)
+    : QObject()
+{
+    this->handler = handler;
+    suspended = false;
+    mousethread = new QIntMouseListenThread(this);
+}
+
+QIntMousePrivate::~QIntMousePrivate()
+{
+    mousethread->stoploop();
+    mousethread->wait();
+    delete mousethread;
+}
+
+QT_END_NAMESPACE
+
+#include "qmouseintegrity_qws.moc"
+
+typedef struct USBMouseStruct
+{
+    Connection mouseconn;
+    Buffer mousemsg[2];
+    Value x;
+    Value y;
+} USBMouse;
+
+USBMouse mousedev;
+
+Error MOUSE_Init(MOUSEHandler *handler, Boolean *isabsolute)
+{
+    Error E;
+    bool loop = true;
+    memset((void*)&mousedev, 0, sizeof(USBMouse));
+    mousedev.mousemsg[0].BufferType = DataImmediate;
+    mousedev.mousemsg[1].BufferType = DataImmediate | LastBuffer;
+    do {
+        E = RequestResource((Object*)&mousedev.mouseconn,
+                "MouseClient", "!systempassword");
+        if (E == Success) {
+            *isabsolute = true;
+            loop = false;
+        } else {
+            E = RequestResource((Object*)&mousedev.mouseconn,
+                    "USBMouseClient", "!systempassword");
+            if (E == Success) {
+                *isabsolute = false;
+                loop = false;
+            }
+        }
+        if (loop)
+            sleep(1);
+    } while (loop);
+    *handler = (MOUSEHandler)&mousedev;
+    return Success;
+}
+
+Error MOUSE_SynchronousGetPosition(MOUSEHandler handler, MOUSEMessage *msg,
+        Boolean isabsolute)
+{
+    signed long x;
+    signed long y;
+    USBMouse *mdev = (USBMouse *)handler;
+    mdev->mousemsg[0].Transferred = 0;
+    mdev->mousemsg[1].Transferred = 0;
+    SynchronousReceive(mdev->mouseconn, mdev->mousemsg);
+    if (isabsolute) {
+        x = (signed long)mdev->mousemsg[0].Length;
+        y = (signed long)mdev->mousemsg[1].TheAddress;
+    } else {
+        x = mdev->x + (signed long)mdev->mousemsg[0].Length;
+        y = mdev->y + (signed long)mdev->mousemsg[1].TheAddress;
+    }
+    if (x < 0)
+        mdev->x = 0;
+    else
+        mdev->x = x;
+    if (y < 0)
+        mdev->y = 0;
+    else
+        mdev->y = y;
+    msg->x = mdev->x;
+    msg->y = mdev->y;
+    msg->buttons = mdev->mousemsg[0].TheAddress;
+    return Success;
+}
+
+Error MOUSE_ShouldFilter(MOUSEHandler handler, Boolean *filter)
+{
+    if (filter == NULL)
+        return Failure;
+    *filter = false;
+    return Success;
+}
+
+#endif // QT_NO_QWS_MOUSE_INTEGRITY
+
diff --git a/src/gui/embedded/qmouseintegrity_qws.h b/src/gui/embedded/qmouseintegrity_qws.h
new file mode 100644
index 0000000..46d27a3
--- /dev/null
+++ b/src/gui/embedded/qmouseintegrity_qws.h
@@ -0,0 +1,82 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QMOUSEINTEGRITY_QWS_H
+#define QMOUSEINTEGRITY_QWS_H
+
+#include <QtGui/qmouse_qws.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+#ifndef QT_NO_QWS_MOUSE_INTEGRITY
+
+class QSocketNotifier;
+class QIntMousePrivate;
+
+class QIntMouseHandler : public QObject, public QWSCalibratedMouseHandler {
+    Q_OBJECT
+public:
+    QIntMouseHandler(const QString &driver = QString(),
+            const QString &device = QString());
+    ~QIntMouseHandler();
+
+    void resume();
+    void suspend();
+
+    void calibrate(const QWSPointerCalibrationData *data);
+    void clearCalibration();
+
+private:
+    QIntMousePrivate *d;
+private Q_SLOTS:
+    void readMouseData(int x, int y, int buttons);
+};
+#endif // QT_NO_QWS_MOUSE_INTEGRITY
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QMOUSEINTEGRITY_QWS_H
diff --git a/src/gui/embedded/qscreen_qws.h b/src/gui/embedded/qscreen_qws.h
index d237dd8..17ffbbb 100644
--- a/src/gui/embedded/qscreen_qws.h
+++ b/src/gui/embedded/qscreen_qws.h
@@ -193,7 +193,7 @@ class Q_GUI_EXPORT QScreen {
 public:
     enum ClassId { LinuxFBClass, TransformedClass, VNCClass, MultiClass,
                    VFbClass, DirectFBClass, SvgalibClass, ProxyClass,
-                   GLClass, CustomClass = 1024 };
+                   GLClass, IntfbClass, CustomClass = 1024 };
 
     QScreen(int display_id, ClassId classId);
     explicit QScreen(int display_id);
@@ -358,6 +358,7 @@ private:
     friend class QLinuxFbScreen;
     friend class QVFbScreen;
     friend class QProxyScreen;
+    friend class QIntfbScreen;
 #endif
     friend void qt_solidFill_setup(QScreen*, const QColor&, const QRegion&);
     friend void qt_blit_setup(QScreen *screen, const QImage &image,
diff --git a/src/gui/embedded/qscreendriverfactory_qws.cpp b/src/gui/embedded/qscreendriverfactory_qws.cpp
index c0ae214..ea194e5 100644
--- a/src/gui/embedded/qscreendriverfactory_qws.cpp
+++ b/src/gui/embedded/qscreendriverfactory_qws.cpp
@@ -48,6 +48,7 @@
 #include "qscreenvfb_qws.h"
 #include "qscreenmulti_qws_p.h"
 #include "qscreenqnx_qws.h"
+#include "qscreenintegrityfb_qws.h"
 #include <stdlib.h>
 #include "private/qfactoryloader_p.h"
 #include "qscreendriverplugin_qws.h"
@@ -112,6 +113,10 @@ QScreen *QScreenDriverFactory::create(const QString& key, int displayId)
     if (driver == QLatin1String("qnx") || driver.isEmpty())
         return new QQnxScreen(displayId);
 #endif
+#if defined(Q_OS_INTEGRITY) && !defined(QT_NO_QWS_INTEGRITY)
+    if (driver == QLatin1String("integrityfb") || driver.isEmpty())
+        return new QIntfbScreen(displayId);
+#endif
 #ifndef QT_NO_QWS_QVFB
     if (driver == QLatin1String("qvfb") || driver.isEmpty())
         return new QVFbScreen(displayId);
@@ -159,6 +164,9 @@ QStringList QScreenDriverFactory::keys()
 #if defined(Q_OS_QNX) && !defined(QT_NO_QWS_QNX)
     list << QLatin1String("QNX");
 #endif
+#if defined(Q_OS_INTEGRITY) && !defined(QT_NO_QWS_INTEGRITY)
+    list << QLatin1String("INTEGRITYFB");
+#endif
 #ifndef QT_NO_QWS_QVFB
     list << QLatin1String("QVFb");
 #endif
diff --git a/src/gui/embedded/qscreenintegrityfb_qws.cpp b/src/gui/embedded/qscreenintegrityfb_qws.cpp
new file mode 100644
index 0000000..7b24490
--- /dev/null
+++ b/src/gui/embedded/qscreenintegrityfb_qws.cpp
@@ -0,0 +1,405 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QT_NO_QWS_INTEGRITYFB
+
+#include <qscreenintegrityfb_qws.h>
+#include <qwindowsystem_qws.h>
+#include <qsocketnotifier.h>
+#include <qapplication.h>
+#include <qscreen_qws.h>
+#include "qmouseintegrity_qws.h"
+#include "qkbdintegrity_qws.h"
+#include <qmousedriverfactory_qws.h>
+#include <qkbddriverfactory_qws.h>
+#include <qdebug.h>
+
+#include <INTEGRITY.h>
+#include <device/fbdriver.h>
+
+QT_BEGIN_NAMESPACE
+
+class QIntfbScreenPrivate
+{
+public:
+    QIntfbScreenPrivate();
+    ~QIntfbScreenPrivate();
+
+    FBHandle handle;
+    struct FBInfoStruct fbinfo;
+
+    QWSMouseHandler *mouse;
+#ifndef QT_NO_QWS_KEYBOARD
+    QWSKeyboardHandler *keyboard;
+#endif
+};
+
+QIntfbScreenPrivate::QIntfbScreenPrivate()
+    : mouse(0)
+
+{
+#ifndef QT_NO_QWS_KEYBOARD
+    keyboard = 0;
+#endif
+}
+
+QIntfbScreenPrivate::~QIntfbScreenPrivate()
+{
+    delete mouse;
+#ifndef QT_NO_QWS_KEYBOARD
+    delete keyboard;
+#endif
+}
+
+/*!
+    \internal
+
+    \class QIntfbScreen
+    \ingroup qws
+
+    \brief The QIntfbScreen class implements a screen driver for the
+    INTEGRITY framebuffer drivers.
+
+    Note that this class is only available in \l{Qt for INTEGRITY}.
+    Custom screen drivers can be added by subclassing the
+    QScreenDriverPlugin class, using the QScreenDriverFactory class to
+    dynamically load the driver into the application, but there should
+    only be one screen object per application.
+
+    \sa QScreen, QScreenDriverPlugin, {Running Applications}
+*/
+
+/*!
+    \fn bool QIntfbScreen::connect(const QString & displaySpec)
+    \reimp
+*/
+
+/*!
+    \fn void QIntfbScreen::disconnect()
+    \reimp
+*/
+
+/*!
+    \fn bool QIntfbScreen::initDevice()
+    \reimp
+*/
+
+/*!
+    \fn void QIntfbScreen::restore()
+    \reimp
+*/
+
+/*!
+    \fn void QIntfbScreen::save()
+    \reimp
+*/
+
+/*!
+    \fn void QIntfbScreen::setDirty(const QRect & r)
+    \reimp
+*/
+
+/*!
+    \fn void QIntfbScreen::setMode(int nw, int nh, int nd)
+    \reimp
+*/
+
+/*!
+    \fn void QIntfbScreen::shutdownDevice()
+    \reimp
+*/
+
+/*!
+    \fn QIntfbScreen::QIntfbScreen(int displayId)
+
+    Constructs a QVNCScreen object. The \a displayId argument
+    identifies the Qt for Embedded Linux server to connect to.
+*/
+QIntfbScreen::QIntfbScreen(int display_id)
+    : QScreen(display_id, IntfbClass), d_ptr(new QIntfbScreenPrivate)
+{
+    d_ptr->handle = 0;
+    data = 0;
+}
+
+/*!
+    Destroys this QIntfbScreen object.
+*/
+QIntfbScreen::~QIntfbScreen()
+{
+    delete d_ptr;
+}
+
+static QIntfbScreen *connected = 0;
+
+bool QIntfbScreen::connect(const QString &displaySpec)
+{
+    FBDriver *fbdev;
+
+    CheckSuccess(gh_FB_get_driver(0, &fbdev));
+    CheckSuccess(gh_FB_init_device(fbdev, 0, &d_ptr->handle));
+    CheckSuccess(gh_FB_get_info(d_ptr->handle, &d_ptr->fbinfo));
+
+    data = (uchar *)d_ptr->fbinfo.start;
+
+    d = d_ptr->fbinfo.bitsperpixel;
+    switch (d) {
+    case 1:
+        setPixelFormat(QImage::Format_Mono);
+        break;
+    case 8:
+        setPixelFormat(QImage::Format_Indexed8);
+        break;
+    case 12:
+        setPixelFormat(QImage::Format_RGB444);
+        break;
+    case 15:
+        setPixelFormat(QImage::Format_RGB555);
+        break;
+    case 16:
+        setPixelFormat(QImage::Format_RGB16);
+        break;
+    case 18:
+        setPixelFormat(QImage::Format_RGB666);
+        break;
+    case 24:
+        setPixelFormat(QImage::Format_RGB888);
+#ifdef QT_QWS_DEPTH_GENERIC
+#if Q_BYTE_ORDER != Q_BIG_ENDIAN
+            qt_set_generic_blit(this, 24,
+                    d_ptr->fbinfo.redbits,
+                    d_ptr->fbinfo.greenbits,
+                    d_ptr->fbinfo.bluebits,
+                    d_ptr->fbinfo.alphabits,
+                    d_ptr->fbinfo.redoffset,
+                    d_ptr->fbinfo.greenoffset,
+                    d_ptr->fbinfo.blueoffset,
+                    d_ptr->fbinfo.alphaoffset);
+#else
+            qt_set_generic_blit(this, 24,
+                    d_ptr->fbinfo.redbits,
+                    d_ptr->fbinfo.greenbits,
+                    d_ptr->fbinfo.bluebits,
+                    d_ptr->fbinfo.alphabits,
+                    16 - d_ptr->fbinfo.redoffset,
+                    16 - d_ptr->fbinfo.greenoffset,
+                    16 - d_ptr->fbinfo.blueoffset,
+                    d_ptr->fbinfo.alphaoffset);
+#endif
+#endif
+        break;
+    case 32:
+        setPixelFormat(QImage::Format_ARGB32_Premultiplied);
+#ifdef QT_QWS_DEPTH_GENERIC
+#if Q_BYTE_ORDER != Q_BIG_ENDIAN
+            qt_set_generic_blit(this, 32,
+                    d_ptr->fbinfo.redbits,
+                    d_ptr->fbinfo.greenbits,
+                    d_ptr->fbinfo.bluebits,
+                    d_ptr->fbinfo.alphabits,
+                    d_ptr->fbinfo.redoffset,
+                    d_ptr->fbinfo.greenoffset,
+                    d_ptr->fbinfo.blueoffset,
+                    d_ptr->fbinfo.alphaoffset);
+#else
+            qt_set_generic_blit(this, 32,
+                    d_ptr->fbinfo.redbits,
+                    d_ptr->fbinfo.greenbits,
+                    d_ptr->fbinfo.bluebits,
+                    d_ptr->fbinfo.alphabits,
+                    24 - d_ptr->fbinfo.redoffset,
+                    24 - d_ptr->fbinfo.greenoffset,
+                    24 - d_ptr->fbinfo.blueoffset,
+                    d_ptr->fbinfo.alphaoffset ? 24 - d_ptr->fbinfo.alphaoffset : 0);
+#endif
+#endif
+        break;
+    }
+
+    dw = w = d_ptr->fbinfo.width;
+    dh = h = d_ptr->fbinfo.height;
+
+    /* assumes no padding */
+    lstep = w * ((d + 7) >> 3);
+
+    mapsize = size =  h * lstep;
+
+    /* default values */
+    int dpi = 72;
+    physWidth = qRound(dw * 25.4 / dpi);
+    physHeight = qRound(dh * 25.4 / dpi);
+
+    qDebug("Connected to INTEGRITYfb server: %d x %d x %d %dx%dmm (%dx%ddpi)",
+        w, h, d, physWidth, physHeight, qRound(dw*25.4/physWidth), qRound(dh*25.4/physHeight) );
+
+
+    QWSServer::setDefaultMouse("integrity");
+    QWSServer::setDefaultKeyboard("integrity");
+
+    connected = this;
+
+    return true;
+}
+
+void QIntfbScreen::disconnect()
+{
+    connected = 0;
+}
+
+bool QIntfbScreen::initDevice()
+{
+
+    CheckSuccess(gh_FB_set_info(d_ptr->handle, &d_ptr->fbinfo, false));
+    CheckSuccess(gh_FB_get_info(d_ptr->handle, &d_ptr->fbinfo));
+    data = (uchar *)d_ptr->fbinfo.start;
+    d = d_ptr->fbinfo.bitsperpixel;
+    dw = w = d_ptr->fbinfo.width;
+    dh = h = d_ptr->fbinfo.height;
+    mapsize = d_ptr->fbinfo.length;
+    /* assumes no padding */
+    lstep = w * ((d + 7) >> 3);
+
+    mapsize = size =  h * lstep;
+
+    data = (uchar *)d_ptr->fbinfo.start;
+
+    d = d_ptr->fbinfo.bitsperpixel;
+    switch (d) {
+    case 1:
+        setPixelFormat(QImage::Format_Mono);
+        break;
+    case 8:
+        setPixelFormat(QImage::Format_Indexed8);
+        break;
+    case 12:
+        setPixelFormat(QImage::Format_RGB444);
+        break;
+    case 15:
+        setPixelFormat(QImage::Format_RGB555);
+        break;
+    case 16:
+        setPixelFormat(QImage::Format_RGB16);
+        break;
+    case 18:
+        setPixelFormat(QImage::Format_RGB666);
+        break;
+    case 24:
+        setPixelFormat(QImage::Format_RGB888);
+        break;
+    case 32:
+        setPixelFormat(QImage::Format_ARGB32_Premultiplied);
+        break;
+    }
+#ifdef QT_QWS_DEPTH_GENERIC
+#if defined(__BIG_ENDIAN__)
+       qt_set_generic_blit(this, d,
+               d_ptr->fbinfo.redbits,
+               d_ptr->fbinfo.greenbits,
+               d_ptr->fbinfo.bluebits,
+               d_ptr->fbinfo.alphabits,
+               24 - d_ptr->fbinfo.redoffset,
+               24 - d_ptr->fbinfo.greenoffset,
+               24 - d_ptr->fbinfo.blueoffset,
+               d_ptr->fbinfo.alphaoffset ? 24 - d_ptr->fbinfo.alphaoffset : 0);
+#else
+       qt_set_generic_blit(this, d,
+               d_ptr->fbinfo.redbits,
+               d_ptr->fbinfo.greenbits,
+               d_ptr->fbinfo.bluebits,
+               d_ptr->fbinfo.alphabits,
+               d_ptr->fbinfo.redoffset,
+               d_ptr->fbinfo.greenoffset,
+               d_ptr->fbinfo.blueoffset,
+               d_ptr->fbinfo.alphaoffset);
+#endif
+#endif
+
+#ifndef QT_NO_QWS_CURSOR
+    QScreenCursor::initSoftwareCursor();
+#endif
+    return true;
+}
+
+void QIntfbScreen::shutdownDevice()
+{
+    gh_FB_close(d_ptr->handle);
+}
+
+void QIntfbScreen::setMode(int ,int ,int)
+{
+}
+
+// save the state of the graphics card
+// This is needed so that e.g. we can restore the palette when switching
+// between linux virtual consoles.
+void QIntfbScreen::save()
+{
+    // nothing to do.
+}
+
+// restore the state of the graphics card.
+void QIntfbScreen::restore()
+{
+}
+void QIntfbScreen::setDirty(const QRect& rect)
+{
+    FBRect fbrect;
+    fbrect.dx = rect.x();
+    fbrect.dy = rect.y();
+    fbrect.width = rect.width();
+    fbrect.height = rect.height();
+    gh_FB_expose(d_ptr->handle, &fbrect);
+}
+
+void QIntfbScreen::setBrightness(int b)
+{
+    if (connected) {
+    }
+}
+
+void QIntfbScreen::blank(bool on)
+{
+}
+
+#endif // QT_NO_QWS_INTEGRITYFB
+
+QT_END_NAMESPACE
+
diff --git a/src/gui/embedded/qscreenintegrityfb_qws.h b/src/gui/embedded/qscreenintegrityfb_qws.h
new file mode 100644
index 0000000..06b3967
--- /dev/null
+++ b/src/gui/embedded/qscreenintegrityfb_qws.h
@@ -0,0 +1,83 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QSCREENINTEGRITYFB_QWS_H
+#define QSCREENINTEGRITYFB_QWS_H
+
+#include <QtGui/qscreen_qws.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+#ifndef QT_NO_QWS_INTEGRITYFB
+
+class QIntfbScreenPrivate;
+
+class Q_GUI_EXPORT QIntfbScreen : public QScreen
+{
+public:
+    explicit QIntfbScreen(int display_id);
+    virtual ~QIntfbScreen();
+    virtual bool initDevice();
+    virtual bool connect(const QString &displaySpec);
+    virtual void disconnect();
+    virtual void shutdownDevice();
+    virtual void save();
+    virtual void restore();
+    virtual void setMode(int nw,int nh,int nd);
+    virtual void setDirty(const QRect& r);
+    virtual void blank(bool);
+    static void setBrightness(int b);
+
+private:
+    QIntfbScreenPrivate *d_ptr;
+};
+
+#endif // QT_NO_QWS_INTEGRITYFB
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QSCREENINTEGRITYFB_QWS_H
diff --git a/src/gui/graphicsview/qgraphicsitem.cpp b/src/gui/graphicsview/qgraphicsitem.cpp
index ecc8941..0af36ac 100644
--- a/src/gui/graphicsview/qgraphicsitem.cpp
+++ b/src/gui/graphicsview/qgraphicsitem.cpp
@@ -417,6 +417,11 @@
     click focus to items underneath when being clicked on. This flag
     allows you create a non-focusable item that can be clicked on without
     changing the focus. \endomit
+
+    \omitvalue ItemStopsFocusHandling \omit Same as
+    ItemStopsClickFocusPropagation, but also suppresses focus-out. This flag
+    allows you to completely take over focus handling.
+    This flag was introduced in Qt 4.7.
 */
 
 /*!
@@ -5577,8 +5582,10 @@ void QGraphicsItemPrivate::setSubFocus(QGraphicsItem *rootItem, QGraphicsItem *s
         parent->d_ptr->subFocusItemChange();
     } while (!parent->isPanel() && (parent = parent->d_ptr->parent) && (visible || !parent->d_ptr->visible));
 
-    if (scene && !scene->isActive())
+    if (scene && !scene->isActive()) {
+        scene->d_func()->passiveFocusItem = subFocusItem;
         scene->d_func()->lastFocusItem = subFocusItem;
+    }
 }
 
 /*!
@@ -11555,6 +11562,9 @@ QDebug operator<<(QDebug debug, QGraphicsItem::GraphicsItemFlag flag)
     case QGraphicsItem::ItemStopsClickFocusPropagation:
         str = "ItemStopsClickFocusPropagation";
         break;
+    case QGraphicsItem::ItemStopsFocusHandling:
+        str = "ItemStopsFocusHandling";
+        break;
     }
     debug << str;
     return debug;
diff --git a/src/gui/graphicsview/qgraphicsitem.h b/src/gui/graphicsview/qgraphicsitem.h
index e59a7c9..67c9cd3 100644
--- a/src/gui/graphicsview/qgraphicsitem.h
+++ b/src/gui/graphicsview/qgraphicsitem.h
@@ -107,7 +107,8 @@ public:
         ItemIsPanel = 0x4000,
         ItemIsFocusScope = 0x8000, // internal
         ItemSendsScenePositionChanges = 0x10000,
-        ItemStopsClickFocusPropagation = 0x20000
+        ItemStopsClickFocusPropagation = 0x20000,
+        ItemStopsFocusHandling = 0x40000
         // NB! Don't forget to increase the d_ptr->flags bit field by 1 when adding a new flag.
     };
     Q_DECLARE_FLAGS(GraphicsItemFlags, GraphicsItemFlag)
diff --git a/src/gui/graphicsview/qgraphicsitem_p.h b/src/gui/graphicsview/qgraphicsitem_p.h
index 5c82116..90ff43f 100644
--- a/src/gui/graphicsview/qgraphicsitem_p.h
+++ b/src/gui/graphicsview/qgraphicsitem_p.h
@@ -559,7 +559,7 @@ public:
     quint32 dirtyChildrenBoundingRect : 1;
 
     // Packed 32 bits
-    quint32 flags : 18;
+    quint32 flags : 19;
     quint32 paintedViewBoundingRectsNeedRepaint : 1;
     quint32 dirtySceneTransform : 1;
     quint32 geometryChanged : 1;
@@ -573,9 +573,9 @@ public:
     quint32 sceneTransformTranslateOnly : 1;
     quint32 notifyBoundingRectChanged : 1;
     quint32 notifyInvalidated : 1;
-    quint32 mouseSetsFocus : 1;
 
     // New 32 bits
+    quint32 mouseSetsFocus : 1;
     quint32 explicitActivate : 1;
     quint32 wantsActive : 1;
     quint32 holesInSiblingIndex : 1;
@@ -586,7 +586,7 @@ public:
     quint32 mayHaveChildWithGraphicsEffect : 1;
     quint32 isDeclarativeItem : 1;
     quint32 sendParentChangeNotification : 1;
-    quint32 padding : 22;
+    quint32 padding : 21;
 
     // Optional stacking order
     int globalStackingOrder;
diff --git a/src/gui/graphicsview/qgraphicsscene.cpp b/src/gui/graphicsview/qgraphicsscene.cpp
index 77ccc8e..7932a73 100644
--- a/src/gui/graphicsview/qgraphicsscene.cpp
+++ b/src/gui/graphicsview/qgraphicsscene.cpp
@@ -306,6 +306,7 @@ QGraphicsScenePrivate::QGraphicsScenePrivate()
       rectAdjust(2),
       focusItem(0),
       lastFocusItem(0),
+      passiveFocusItem(0),
       tabFocusFirst(0),
       activePanel(0),
       lastActivePanel(0),
@@ -630,6 +631,8 @@ void QGraphicsScenePrivate::removeItemHelper(QGraphicsItem *item)
         focusItem = 0;
     if (item == lastFocusItem)
         lastFocusItem = 0;
+    if (item == passiveFocusItem)
+        passiveFocusItem = 0;
     if (item == activePanel) {
         // ### deactivate...
         activePanel = 0;
@@ -1317,8 +1320,10 @@ void QGraphicsScenePrivate::mousePressEventHandler(QGraphicsSceneMouseEvent *mou
 
     // Set focus on the topmost enabled item that can take focus.
     bool setFocus = false;
+
     foreach (QGraphicsItem *item, cachedItemsUnderMouse) {
-        if (item->isBlockedByModalPanel()) {
+        if (item->isBlockedByModalPanel()
+            || (item->d_ptr->flags & QGraphicsItem::ItemStopsFocusHandling)) {
             // Make sure we don't clear focus.
             setFocus = true;
             break;
@@ -1331,10 +1336,10 @@ void QGraphicsScenePrivate::mousePressEventHandler(QGraphicsSceneMouseEvent *mou
                 break;
             }
         }
-        if (item->d_ptr->flags & QGraphicsItem::ItemStopsClickFocusPropagation)
-            break;
         if (item->isPanel())
             break;
+        if (item->d_ptr->flags & QGraphicsItem::ItemStopsClickFocusPropagation)
+            break;
     }
 
     // Check for scene modality.
@@ -2980,7 +2985,7 @@ void QGraphicsScene::removeItem(QGraphicsItem *item)
 QGraphicsItem *QGraphicsScene::focusItem() const
 {
     Q_D(const QGraphicsScene);
-    return isActive() ? d->focusItem : d->lastFocusItem;
+    return isActive() ? d->focusItem : d->passiveFocusItem;
 }
 
 /*!
@@ -3054,6 +3059,7 @@ void QGraphicsScene::clearFocus()
     Q_D(QGraphicsScene);
     if (d->hasFocus) {
         d->hasFocus = false;
+        d->passiveFocusItem = d->focusItem;
         setFocusItem(0, Qt::OtherFocusReason);
     }
 }
@@ -3757,9 +3763,9 @@ void QGraphicsScene::focusInEvent(QFocusEvent *focusEvent)
             focusEvent->ignore();
         break;
     default:
-        if (d->lastFocusItem) {
+        if (d->passiveFocusItem) {
             // Set focus on the last focus item
-            setFocusItem(d->lastFocusItem, focusEvent->reason());
+            setFocusItem(d->passiveFocusItem, focusEvent->reason());
         }
         break;
     }
@@ -3778,6 +3784,7 @@ void QGraphicsScene::focusOutEvent(QFocusEvent *focusEvent)
 {
     Q_D(QGraphicsScene);
     d->hasFocus = false;
+    d->passiveFocusItem = d->focusItem;
     setFocusItem(0, focusEvent->reason());
 
     // Remove all popups when the scene loses focus.
@@ -5908,6 +5915,7 @@ bool QGraphicsScenePrivate::sendTouchBeginEvent(QGraphicsItem *origin, QTouchEve
 
     // Set focus on the topmost enabled item that can take focus.
     bool setFocus = false;
+
     foreach (QGraphicsItem *item, cachedItemsUnderMouse) {
         if (item->isEnabled() && ((item->flags() & QGraphicsItem::ItemIsFocusable) && item->d_ptr->mouseSetsFocus)) {
             if (!item->isWidget() || ((QGraphicsWidget *)item)->focusPolicy() & Qt::ClickFocus) {
@@ -5921,6 +5929,11 @@ bool QGraphicsScenePrivate::sendTouchBeginEvent(QGraphicsItem *origin, QTouchEve
             break;
         if (item->d_ptr->flags & QGraphicsItem::ItemStopsClickFocusPropagation)
             break;
+        if (item->d_ptr->flags & QGraphicsItem::ItemStopsFocusHandling) {
+            // Make sure we don't clear focus.
+            setFocus = true;
+            break;
+        }
     }
 
     // If nobody could take focus, clear it.
@@ -5953,7 +5966,8 @@ bool QGraphicsScenePrivate::sendTouchBeginEvent(QGraphicsItem *origin, QTouchEve
         }
         if (item && item->isPanel())
             break;
-        if (item && (item->d_ptr->flags & QGraphicsItem::ItemStopsClickFocusPropagation))
+        if (item && (item->d_ptr->flags
+                     & (QGraphicsItem::ItemStopsClickFocusPropagation | QGraphicsItem::ItemStopsFocusHandling)))
             break;
     }
 
diff --git a/src/gui/graphicsview/qgraphicsscene_p.h b/src/gui/graphicsview/qgraphicsscene_p.h
index 2314e37..9460a4d 100644
--- a/src/gui/graphicsview/qgraphicsscene_p.h
+++ b/src/gui/graphicsview/qgraphicsscene_p.h
@@ -150,6 +150,7 @@ public:
     quint32 rectAdjust;
     QGraphicsItem *focusItem;
     QGraphicsItem *lastFocusItem;
+    QGraphicsItem *passiveFocusItem;
     QGraphicsWidget *tabFocusFirst;
     QGraphicsItem *activePanel;
     QGraphicsItem *lastActivePanel;
diff --git a/src/gui/graphicsview/qgridlayoutengine.cpp b/src/gui/graphicsview/qgridlayoutengine.cpp
index 375c723..b8586ce 100644
--- a/src/gui/graphicsview/qgridlayoutengine.cpp
+++ b/src/gui/graphicsview/qgridlayoutengine.cpp
@@ -1175,7 +1175,7 @@ QSizeF QGridLayoutEngine::sizeHint(const QLayoutStyleInfo &styleInfo, Qt::SizeHi
                 //constraints to find the column widths
                 q_rowData.calculateGeometries(0, rowCount(), height, sizehint_yy.data(), sizehint_heights.data(),
                         0, sizehint_totalBoxes[Ver], q_infos[Ver]);
-                ensureColumnAndRowData(&q_columnData, &sizehint_totalBoxes[Hor], styleInfo, sizehint_yy.data(), sizehint_heights.data(), Qt::Vertical);
+                ensureColumnAndRowData(&q_columnData, &sizehint_totalBoxes[Hor], styleInfo, sizehint_yy.data(), sizehint_heights.data(), Qt::Horizontal);
                 sizeHintCalculated = true;
             }
         }
diff --git a/src/gui/image/image.pri b/src/gui/image/image.pri
index 92ea397..72738c9 100644
--- a/src/gui/image/image.pri
+++ b/src/gui/image/image.pri
@@ -29,7 +29,10 @@ HEADERS += \
         image/qpixmapdata_p.h \
         image/qpixmapdatafactory_p.h \
         image/qpixmapfilter_p.h \
-        image/qimagepixmapcleanuphooks_p.h
+        image/qimagepixmapcleanuphooks_p.h \
+        image/qvolatileimage_p.h \
+        image/qvolatileimagedata_p.h \
+        image/qnativeimagehandleprovider_p.h
 
 SOURCES += \
         image/qbitmap.cpp \
@@ -53,7 +56,8 @@ SOURCES += \
         image/qpixmap_raster.cpp \
         image/qpixmap_blitter.cpp \
         image/qnativeimage.cpp \
-        image/qimagepixmapcleanuphooks.cpp
+        image/qimagepixmapcleanuphooks.cpp \
+        image/qvolatileimage.cpp
 
 win32 {
     SOURCES += image/qpixmap_win.cpp
@@ -77,6 +81,13 @@ else:symbian {
     SOURCES += image/qpixmap_s60.cpp
 }
 
+!symbian|contains(S60_VERSION, 3.1)|contains(S60_VERSION, 3.2) {
+    SOURCES += image/qvolatileimagedata.cpp
+}
+else {
+    SOURCES += image/qvolatileimagedata_symbian.cpp
+}
+
 # Built-in image format support
 HEADERS += \
         image/qbmphandler_p.h \
diff --git a/src/gui/image/qnativeimagehandleprovider_p.h b/src/gui/image/qnativeimagehandleprovider_p.h
new file mode 100644
index 0000000..4e6ed38
--- /dev/null
+++ b/src/gui/image/qnativeimagehandleprovider_p.h
@@ -0,0 +1,69 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QNATIVEIMAGEHANDLEPROVIDER_P_H
+#define QNATIVEIMAGEHANDLEPROVIDER_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtCore/qstring.h>
+
+QT_BEGIN_NAMESPACE
+
+class QNativeImageHandleProvider
+{
+public:
+    virtual void get(void **handle, QString *type) = 0;
+    virtual void release(void *handle, const QString &type) = 0;
+};
+
+QT_END_NAMESPACE
+
+#endif // QNATIVEIMAGEHANDLEPROVIDER_P_H
diff --git a/src/gui/image/qpixmap.cpp b/src/gui/image/qpixmap.cpp
index f896572..34804e5 100644
--- a/src/gui/image/qpixmap.cpp
+++ b/src/gui/image/qpixmap.cpp
@@ -71,6 +71,10 @@
 # include "private/qpixmap_mac_p.h"
 #endif
 
+#ifdef Q_WS_QPA
+# include "qplatformintegration_qpa.h"
+#endif
+
 #if defined(Q_WS_X11)
 # include "qx11info_x11.h"
 # include <private/qt_x11_p.h>
@@ -98,12 +102,26 @@ static bool qt_pixmap_thread_test()
         qFatal("QPixmap: Must construct a QApplication before a QPaintDevice");
         return false;
     }
-#ifndef Q_WS_WIN
-    if (!QApplication::testAttribute(Qt::AA_X11InitThreads) && qApp->thread() != QThread::currentThread()) {
-        qWarning("QPixmap: It is not safe to use pixmaps outside the GUI thread");
-        return false;
-    }
+
+    if (qApp->thread() != QThread::currentThread()) {
+        bool fail = false;
+#if defined (Q_WS_X11)
+        if (!QApplication::testAttribute(Qt::AA_X11InitThreads))
+            fail = true;
+#elif defined (Q_WS_QPA)
+        if (!QApplicationPrivate::platformIntegration()->hasCapability(QPlatformIntegration::ThreadedPixmaps)) {
+            printf("Lighthouse plugin does not support threaded pixmaps!\n");
+            fail = true;
+        }
+#else
+        if (QApplicationPrivate::graphics_system_name != QLatin1String("raster"))
+            fail = true;
 #endif
+        if (fail) {
+            qWarning("QPixmap: It is not safe to use pixmaps outside the GUI thread");
+            return false;
+        }
+    }
     return true;
 }
 
@@ -112,8 +130,16 @@ void QPixmap::init(int w, int h, Type type)
     init(w, h, int(type));
 }
 
+extern QApplication::Type qt_appType;
+
 void QPixmap::init(int w, int h, int type)
 {
+    if (qt_appType == QApplication::Tty) {
+        qWarning("QPixmap: Cannot create a QPixmap when no GUI is being used");
+        data = 0;
+        return;
+    }
+
     if ((w > 0 && h > 0) || type == QPixmapData::BitmapType)
         data = QPixmapData::create(w, h, (QPixmapData::PixelType) type);
     else
@@ -1636,16 +1662,6 @@ QPixmap QPixmap::transformed(const QMatrix &matrix, Qt::TransformationMode mode)
     {Implicit Data Sharing} documentation. QPixmap objects can also be
     streamed.
 
-    Depending on the system, QPixmap is stored using a RGB32 or a
-    premultiplied alpha format. If the image has an alpha channel, and
-    if the system allows, the preferred format is premultiplied alpha.
-    Note also that QPixmap, unlike QImage, may be hardware dependent.
-    On X11, Mac and Symbian, a QPixmap is stored on the server side while
-    a QImage is stored on the client side (on Windows, these two classes
-    have an equivalent internal representation, i.e. both QImage and
-    QPixmap are stored on the client side and don't use any GDI
-    resources).
-
     Note that the pixel data in a pixmap is internal and is managed by
     the underlying window system. Because QPixmap is a QPaintDevice
     subclass, QPainter can be used to draw directly onto pixmaps.
@@ -2012,7 +2028,7 @@ void QPixmap::detach()
     }
 
     if (data->is_cached && data->ref == 1)
-        QImagePixmapCleanupHooks::executePixmapDataModificationHooks(pd);
+        QImagePixmapCleanupHooks::executePixmapDataModificationHooks(data.data());
 
 #if defined(Q_WS_MAC)
     QMacPixmapData *macData = id == QPixmapData::MacClass ? static_cast<QMacPixmapData*>(pd) : 0;
diff --git a/src/gui/image/qpixmap_blitter.cpp b/src/gui/image/qpixmap_blitter.cpp
index e8a7b89..26d3b87 100644
--- a/src/gui/image/qpixmap_blitter.cpp
+++ b/src/gui/image/qpixmap_blitter.cpp
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/image/qpixmap_blitter_p.h b/src/gui/image/qpixmap_blitter_p.h
index 55b5618..9f4260c 100644
--- a/src/gui/image/qpixmap_blitter_p.h
+++ b/src/gui/image/qpixmap_blitter_p.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/image/qpixmap_raster.cpp b/src/gui/image/qpixmap_raster.cpp
index 1e7ff04..a5f42c1 100644
--- a/src/gui/image/qpixmap_raster.cpp
+++ b/src/gui/image/qpixmap_raster.cpp
@@ -386,6 +386,9 @@ int QRasterPixmapData::metric(QPaintDevice::PaintDeviceMetric metric) const
 void QRasterPixmapData::createPixmapForImage(QImage &sourceImage, Qt::ImageConversionFlags flags, bool inPlace)
 {
     QImage::Format format;
+    if (flags & Qt::NoFormatConversion)
+        format = sourceImage.format();
+    else
 #ifdef Q_WS_QWS
     if (pixelType() == BitmapType) {
         format = QImage::Format_Mono;
diff --git a/src/gui/image/qpixmap_s60.cpp b/src/gui/image/qpixmap_s60.cpp
index ca5f133..32d8dd7 100644
--- a/src/gui/image/qpixmap_s60.cpp
+++ b/src/gui/image/qpixmap_s60.cpp
@@ -374,6 +374,8 @@ CFbsBitmap *QPixmap::toSymbianCFbsBitmap() const
     To be sure that QPixmap does not modify your original instance, you should
     make a copy of your \c CFbsBitmap before calling this function.
     If the CFbsBitmap is not valid this function will return a null QPixmap.
+    For performance reasons it is recommended to use a \a bitmap with a display
+    mode of EColor16MAP or EColor16MU whenever possible.
 
     \warning This function is only available on Symbian OS.
 
@@ -599,6 +601,9 @@ bool QS60PixmapData::scroll(int dx, int dy, const QRect &rect)
     return res;
 }
 
+Q_GUI_EXPORT int qt_defaultDpiX();
+Q_GUI_EXPORT int qt_defaultDpiY();
+
 int QS60PixmapData::metric(QPaintDevice::PaintDeviceMetric metric) const
 {
     if (!cfbsBitmap)
@@ -609,28 +614,18 @@ int QS60PixmapData::metric(QPaintDevice::PaintDeviceMetric metric) const
         return cfbsBitmap->SizeInPixels().iWidth;
     case QPaintDevice::PdmHeight:
         return cfbsBitmap->SizeInPixels().iHeight;
-    case QPaintDevice::PdmWidthMM: {
-        TInt twips = cfbsBitmap->SizeInTwips().iWidth;
-        return (int)(twips * (25.4/KTwipsPerInch));
-    }
-    case QPaintDevice::PdmHeightMM: {
-        TInt twips = cfbsBitmap->SizeInTwips().iHeight;
-        return (int)(twips * (25.4/KTwipsPerInch));
-    }
+    case QPaintDevice::PdmWidthMM:
+        return qRound(cfbsBitmap->SizeInPixels().iWidth * 25.4 / qt_defaultDpiX());
+    case QPaintDevice::PdmHeightMM:
+        return qRound(cfbsBitmap->SizeInPixels().iHeight * 25.4 / qt_defaultDpiY());
     case QPaintDevice::PdmNumColors:
         return TDisplayModeUtils::NumDisplayModeColors(cfbsBitmap->DisplayMode());
     case QPaintDevice::PdmDpiX:
-    case QPaintDevice::PdmPhysicalDpiX: {
-        TReal inches = cfbsBitmap->SizeInTwips().iWidth / (TReal)KTwipsPerInch;
-        TInt pixels = cfbsBitmap->SizeInPixels().iWidth;
-        return pixels / inches;
-    }
+    case QPaintDevice::PdmPhysicalDpiX:
+        return qt_defaultDpiX();
     case QPaintDevice::PdmDpiY:
-    case QPaintDevice::PdmPhysicalDpiY: {
-        TReal inches = cfbsBitmap->SizeInTwips().iHeight / (TReal)KTwipsPerInch;
-        TInt pixels = cfbsBitmap->SizeInPixels().iHeight;
-        return pixels / inches;
-    }
+    case QPaintDevice::PdmPhysicalDpiY:
+        return qt_defaultDpiY();
     case QPaintDevice::PdmDepth:
         return TDisplayModeUtils::NumDisplayModeBitsPerPixel(cfbsBitmap->DisplayMode());
     default:
diff --git a/src/gui/image/qpixmapdata_p.h b/src/gui/image/qpixmapdata_p.h
index 5c05c28..6bbce09 100644
--- a/src/gui/image/qpixmapdata_p.h
+++ b/src/gui/image/qpixmapdata_p.h
@@ -71,7 +71,9 @@ public:
 #if defined(Q_OS_SYMBIAN)
     enum NativeType {
         FbsBitmap,
-        SgImage
+        SgImage,
+        VolatileImage,
+        NativeImageHandleProvider
     };
 #endif
     enum ClassId { RasterClass, X11Class, MacClass, DirectFBClass,
diff --git a/src/gui/image/qpnghandler.cpp b/src/gui/image/qpnghandler.cpp
index a9aad51..7e0355a 100644
--- a/src/gui/image/qpnghandler.cpp
+++ b/src/gui/image/qpnghandler.cpp
@@ -492,8 +492,10 @@ bool Q_INTERNAL_WIN_NO_THROW QPngHandlerPrivate::readPngImage(QImage *outImage)
     outImage->setDotsPerMeterX(png_get_x_pixels_per_meter(png_ptr,info_ptr));
     outImage->setDotsPerMeterY(png_get_y_pixels_per_meter(png_ptr,info_ptr));
 
+#ifndef QT_NO_IMAGE_TEXT
     for (int i = 0; i < readTexts.size()-1; i+=2)
         outImage->setText(readTexts.at(i), readTexts.at(i+1));
+#endif
 
     state = ReadingEnd;
     png_read_end(png_ptr, end_info);
diff --git a/src/gui/image/qvolatileimage.cpp b/src/gui/image/qvolatileimage.cpp
new file mode 100644
index 0000000..098e9a1
--- /dev/null
+++ b/src/gui/image/qvolatileimage.cpp
@@ -0,0 +1,318 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qvolatileimage_p.h"
+#include "qvolatileimagedata_p.h"
+#include <QtGui/private/qpaintengine_raster_p.h>
+#include <QtGui/private/qpixmapdata_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QVolatileImagePaintEnginePrivate : public QRasterPaintEnginePrivate
+{
+public:
+    QVolatileImagePaintEnginePrivate() { }
+    QVolatileImage *img;
+};
+
+class QVolatileImagePaintEngine : public QRasterPaintEngine
+{
+    Q_DECLARE_PRIVATE(QVolatileImagePaintEngine)
+
+public:
+    QVolatileImagePaintEngine(QPaintDevice *device, QVolatileImage *img);
+    bool begin(QPaintDevice *device);
+    bool end();
+    void drawPixmap(const QPointF &p, const QPixmap &pm);
+    void drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr);
+};
+
+QVolatileImage::QVolatileImage()
+    : d(new QVolatileImageData)
+{
+}
+
+QVolatileImage::QVolatileImage(int w, int h, QImage::Format format)
+    : d(new QVolatileImageData(w, h, format))
+{
+}
+
+QVolatileImage::QVolatileImage(const QImage &sourceImage)
+    : d(new QVolatileImageData(sourceImage))
+{
+}
+
+QVolatileImage::QVolatileImage(void *nativeImage, void *nativeMask)
+    : d(new QVolatileImageData(nativeImage, nativeMask))
+{
+}
+
+// Need non-inline, non-autogenerated copy ctor, dtor, op= to keep the
+// fwd declared QSharedData working.
+
+QVolatileImage::QVolatileImage(const QVolatileImage &other)
+    : d(other.d)
+{
+}
+
+QVolatileImage::~QVolatileImage()
+{
+}
+
+QVolatileImage &QVolatileImage::operator=(const QVolatileImage &rhs)
+{
+    d = rhs.d;
+    return *this;
+}
+
+bool QVolatileImage::isNull() const
+{
+    return d->image.isNull();
+}
+
+QImage::Format QVolatileImage::format() const
+{
+    return d->image.format();
+}
+
+int QVolatileImage::width() const
+{
+    return d->image.width();
+}
+
+int QVolatileImage::height() const
+{
+    return d->image.height();
+}
+
+int QVolatileImage::bytesPerLine() const
+{
+    return d->image.bytesPerLine();
+}
+
+int QVolatileImage::byteCount() const
+{
+    return d->image.byteCount();
+}
+
+int QVolatileImage::depth() const
+{
+    return d->image.depth();
+}
+
+bool QVolatileImage::hasAlphaChannel() const
+{
+    return d->image.hasAlphaChannel();
+}
+
+void QVolatileImage::beginDataAccess() const
+{
+    d->beginDataAccess();
+}
+
+void QVolatileImage::endDataAccess(bool readOnly) const
+{
+    d->endDataAccess(readOnly);
+}
+
+/*!
+  Access to pixel data via bits() or constBits() should be guarded by
+  begin/endDataAccess().
+ */
+uchar *QVolatileImage::bits()
+{
+    return d->image.bits();
+}
+
+const uchar *QVolatileImage::constBits() const
+{
+    return d->image.constBits();
+}
+
+bool QVolatileImage::ensureFormat(QImage::Format format)
+{
+    return d->ensureFormat(format);
+}
+
+/*!
+  This will always perform a copy of the pixel data.
+ */
+QImage QVolatileImage::toImage() const
+{
+    d->beginDataAccess();
+    QImage newImage = d->image.copy(); // no sharing allowed
+    d->endDataAccess(true);
+    return newImage;
+}
+
+/*!
+  Returns a reference to the image that is potentially using some native
+  buffer internally. Access to the image's pixel data should be guarded by
+  begin/endDataAccess(). Use it when there is a need for QImage APIs not provided
+  by this class. The returned QImage must never be shared or assigned to.
+  */
+QImage &QVolatileImage::imageRef() // non-const, in order to cause a detach
+{
+    d->ensureImage();
+    return d->image;
+}
+
+void *QVolatileImage::duplicateNativeImage() const
+{
+    return d->duplicateNativeImage();
+}
+
+void QVolatileImage::setAlphaChannel(const QPixmap &alphaChannel)
+{
+    ensureFormat(QImage::Format_ARGB32_Premultiplied);
+    beginDataAccess();
+    imageRef().setAlphaChannel(alphaChannel.toImage());
+    endDataAccess();
+    d->ensureImage();
+}
+
+void QVolatileImage::fill(uint pixelValue)
+{
+    beginDataAccess();
+    imageRef().fill(pixelValue);
+    endDataAccess();
+    d->ensureImage();
+}
+
+void QVolatileImage::copyFrom(QVolatileImage *source, const QRect &rect)
+{
+    if (source->isNull()) {
+        return;
+    }
+    QRect r = rect;
+    if (rect.isNull()) {
+        r = QRect(0, 0, source->width(), source->height());
+    }
+    source->beginDataAccess();
+    QImage &srcImgRef(source->imageRef());
+    int srcbpl = srcImgRef.bytesPerLine();
+    int srcbpp = srcImgRef.depth() / 8;
+    const uchar *sptr = srcImgRef.constBits() + r.y() * srcbpl;
+    beginDataAccess();
+    QImage &dstImgRef(imageRef());
+    int dstbpl = dstImgRef.bytesPerLine();
+    uchar *dptr = dstImgRef.bits();
+    for (int y = 0; y < r.height(); ++y) {
+        qMemCopy(dptr, sptr + r.x() * srcbpp, r.width() * srcbpp);
+        sptr += srcbpl;
+        dptr += dstbpl;
+    }
+    endDataAccess();
+    source->endDataAccess(true);
+}
+
+/*!
+    To be called from the PixmapData's paintEngine().
+  */
+QPaintEngine *QVolatileImage::paintEngine()
+{
+    if (!d->pengine) {
+        d->pengine = new QVolatileImagePaintEngine(&imageRef(), this);
+    }
+    return d->pengine;
+}
+
+QVolatileImagePaintEngine::QVolatileImagePaintEngine(QPaintDevice *device,
+                                                             QVolatileImage *img)
+    : QRasterPaintEngine(*(new QVolatileImagePaintEnginePrivate), device)
+{
+    Q_D(QVolatileImagePaintEngine);
+    d->img = img;
+}
+
+bool QVolatileImagePaintEngine::begin(QPaintDevice *device)
+{
+    Q_D(QVolatileImagePaintEngine);
+    d->img->beginDataAccess();
+    return QRasterPaintEngine::begin(device);
+}
+
+bool QVolatileImagePaintEngine::end()
+{
+    Q_D(QVolatileImagePaintEngine);
+    bool ret = QRasterPaintEngine::end();
+    d->img->endDataAccess();
+    return ret;
+}
+
+// For non-RasterClass pixmaps drawPixmap() would call toImage() which is slow in
+// our case. Therefore drawPixmap() is rerouted to drawImage().
+
+void QVolatileImagePaintEngine::drawPixmap(const QPointF &p, const QPixmap &pm)
+{
+#ifdef Q_OS_SYMBIAN
+    void *nativeData = pm.pixmapData()->toNativeType(QPixmapData::VolatileImage);
+    if (nativeData) {
+        QVolatileImage *img = static_cast<QVolatileImage *>(nativeData);
+        img->beginDataAccess();
+        QRasterPaintEngine::drawImage(p, img->imageRef());
+        img->endDataAccess(true);
+    } else {
+        QRasterPaintEngine::drawPixmap(p, pm);
+    }
+#else
+    QRasterPaintEngine::drawPixmap(p, pm);
+#endif
+}
+
+void QVolatileImagePaintEngine::drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr)
+{
+#ifdef Q_OS_SYMBIAN
+    void *nativeData = pm.pixmapData()->toNativeType(QPixmapData::VolatileImage);
+    if (nativeData) {
+        QVolatileImage *img = static_cast<QVolatileImage *>(nativeData);
+        img->beginDataAccess();
+        QRasterPaintEngine::drawImage(r, img->imageRef(), sr);
+        img->endDataAccess(true);
+    } else {
+        QRasterPaintEngine::drawPixmap(r, pm, sr);
+    }
+#else
+    QRasterPaintEngine::drawPixmap(r, pm, sr);
+#endif
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/image/qvolatileimage_p.h b/src/gui/image/qvolatileimage_p.h
new file mode 100644
index 0000000..fc5d6b1
--- /dev/null
+++ b/src/gui/image/qvolatileimage_p.h
@@ -0,0 +1,101 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QVOLATILEIMAGE_P_H
+#define QVOLATILEIMAGE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtGui/qimage.h>
+#include <QtCore/qshareddata.h>
+
+QT_BEGIN_NAMESPACE
+
+class QVolatileImageData;
+
+class Q_GUI_EXPORT QVolatileImage
+{
+public:
+    QVolatileImage();
+    QVolatileImage(int w, int h, QImage::Format format);
+    explicit QVolatileImage(const QImage &sourceImage);
+    explicit QVolatileImage(void *nativeImage, void *nativeMask = 0);
+    QVolatileImage(const QVolatileImage &other);
+    ~QVolatileImage();
+    QVolatileImage &operator=(const QVolatileImage &rhs);
+
+    bool isNull() const;
+    QImage::Format format() const;
+    int width() const;
+    int height() const;
+    int bytesPerLine() const;
+    int byteCount() const;
+    int depth() const;
+    bool hasAlphaChannel() const;
+    void beginDataAccess() const;
+    void endDataAccess(bool readOnly = false) const;
+    uchar *bits();
+    const uchar *constBits() const;
+    bool ensureFormat(QImage::Format format);
+    QImage toImage() const;
+    QImage &imageRef();
+    QPaintEngine *paintEngine();
+    void setAlphaChannel(const QPixmap &alphaChannel);
+    void fill(uint pixelValue);
+    void *duplicateNativeImage() const;
+    void copyFrom(QVolatileImage *source, const QRect &rect);
+
+private:
+    QSharedDataPointer<QVolatileImageData> d;
+};
+
+QT_END_NAMESPACE
+
+#endif // QVOLATILEIMAGE_P_H
diff --git a/src/gui/image/qvolatileimagedata.cpp b/src/gui/image/qvolatileimagedata.cpp
new file mode 100644
index 0000000..51b5995
--- /dev/null
+++ b/src/gui/image/qvolatileimagedata.cpp
@@ -0,0 +1,113 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qvolatileimagedata_p.h"
+#include <QtGui/qpaintengine.h>
+
+QT_BEGIN_NAMESPACE
+
+QVolatileImageData::QVolatileImageData()
+    : pengine(0)
+{
+}
+
+QVolatileImageData::QVolatileImageData(int w, int h, QImage::Format format)
+    : pengine(0)
+{
+    image = QImage(w, h, format);
+}
+
+QVolatileImageData::QVolatileImageData(const QImage &sourceImage)
+    : pengine(0)
+{
+    image = sourceImage;
+}
+
+QVolatileImageData::QVolatileImageData(void *, void *)
+    : pengine(0)
+{
+    // Not supported.
+}
+
+QVolatileImageData::QVolatileImageData(const QVolatileImageData &other)
+{
+    image = other.image;
+    // The detach is not mandatory here but we do it nonetheless in order to
+    // keep the behavior consistent with other platforms.
+    image.detach();
+    pengine = 0;
+}
+
+QVolatileImageData::~QVolatileImageData()
+{
+    delete pengine;
+}
+
+void QVolatileImageData::beginDataAccess() const
+{
+    // nothing to do here
+}
+
+void QVolatileImageData::endDataAccess(bool readOnly) const
+{
+    Q_UNUSED(readOnly);
+    // nothing to do here
+}
+
+bool QVolatileImageData::ensureFormat(QImage::Format format)
+{
+    if (image.format() != format) {
+        image = image.convertToFormat(format);
+    }
+    return true;
+}
+
+void *QVolatileImageData::duplicateNativeImage() const
+{
+    return 0;
+}
+
+void QVolatileImageData::ensureImage()
+{
+    // nothing to do here
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/image/qvolatileimagedata_p.h b/src/gui/image/qvolatileimagedata_p.h
new file mode 100644
index 0000000..dab1685
--- /dev/null
+++ b/src/gui/image/qvolatileimagedata_p.h
@@ -0,0 +1,97 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QVOLATILEIMAGEDATA_P_H
+#define QVOLATILEIMAGEDATA_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtGui/qimage.h>
+#include <QtCore/qshareddata.h>
+
+#ifdef Q_OS_SYMBIAN
+class CFbsBitmap;
+#endif
+
+QT_BEGIN_NAMESPACE
+
+class QVolatileImageData : public QSharedData
+{
+public:
+    QVolatileImageData();
+    QVolatileImageData(int w, int h, QImage::Format format);
+    QVolatileImageData(const QImage &sourceImage);
+    QVolatileImageData(void *nativeImage, void *nativeMask);
+    QVolatileImageData(const QVolatileImageData &other);
+    ~QVolatileImageData();
+
+    void beginDataAccess() const;
+    void endDataAccess(bool readOnly = false) const;
+    bool ensureFormat(QImage::Format format);
+    void *duplicateNativeImage() const;
+    void ensureImage();
+
+#ifdef Q_OS_SYMBIAN
+    void updateImage();
+    void initWithBitmap(CFbsBitmap *source);
+    void applyMask(CFbsBitmap *mask);
+    void ensureBitmap();
+    void release();
+    QVolatileImageData *next;
+    QVolatileImageData *prev;
+    CFbsBitmap *bitmap;
+#endif
+    QImage image;
+    QPaintEngine *pengine;
+};
+
+QT_END_NAMESPACE
+
+#endif // QVOLATILEIMAGEDATA_P_H
diff --git a/src/gui/image/qvolatileimagedata_symbian.cpp b/src/gui/image/qvolatileimagedata_symbian.cpp
new file mode 100644
index 0000000..6e2909b
--- /dev/null
+++ b/src/gui/image/qvolatileimagedata_symbian.cpp
@@ -0,0 +1,474 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qvolatileimagedata_p.h"
+#include <fbs.h>
+#include <QtGui/private/qt_s60_p.h>
+#include <QtGui/qpaintengine.h>
+#include <QtGui/private/qimage_p.h>
+
+QT_BEGIN_NAMESPACE
+
+static CFbsBitmap *rasterizeBitmap(CFbsBitmap *bitmap, TDisplayMode newMode)
+{
+    if (!bitmap) {
+        return 0;
+    }
+    QScopedPointer<CFbsBitmap> newBitmap(new CFbsBitmap);
+    if (newBitmap->Create(bitmap->SizeInPixels(), newMode) != KErrNone) {
+        qWarning("QVolatileImage: Failed to create new bitmap");
+        return 0;
+    }
+    CFbsBitmapDevice *bitmapDevice = 0;
+    CFbsBitGc *bitmapGc = 0;
+    QT_TRAP_THROWING(bitmapDevice = CFbsBitmapDevice::NewL(newBitmap.data()));
+    QScopedPointer<CFbsBitmapDevice> bitmapDevicePtr(bitmapDevice);
+    QT_TRAP_THROWING(bitmapGc = CFbsBitGc::NewL());
+    bitmapGc->Activate(bitmapDevice);
+    bitmapGc->BitBlt(TPoint(), bitmap);
+    delete bitmapGc;
+    return newBitmap.take();
+}
+
+static inline TDisplayMode format2TDisplayMode(QImage::Format format)
+{
+    TDisplayMode mode;
+    switch (format) {
+    case QImage::Format_MonoLSB:
+        mode = EGray2;
+        break;
+    case QImage::Format_Indexed8:
+        mode = EColor256;
+        break;
+    case QImage::Format_RGB444:
+        mode = EColor4K;
+        break;
+    case QImage::Format_RGB16:
+        mode = EColor64K;
+        break;
+    case QImage::Format_RGB888:
+        mode = EColor16M;
+        break;
+    case QImage::Format_RGB32:
+        mode = EColor16MU;
+        break;
+    case QImage::Format_ARGB32:
+        mode = EColor16MA;
+        break;
+    case QImage::Format_ARGB32_Premultiplied:
+        mode = Q_SYMBIAN_ECOLOR16MAP;
+        break;
+    default:
+        mode = ENone;
+        break;
+    }
+    return mode;
+}
+
+static CFbsBitmap *imageToBitmap(const QImage &image)
+{
+    if (image.isNull()) {
+        return 0;
+    }
+    CFbsBitmap *bitmap = new CFbsBitmap;
+    if (bitmap->Create(TSize(image.width(), image.height()),
+                       format2TDisplayMode(image.format())) == KErrNone) {
+        bitmap->BeginDataAccess();
+        uchar *dptr = reinterpret_cast<uchar *>(bitmap->DataAddress());
+        int bmpLineLen = bitmap->DataStride();
+        int imgLineLen = image.bytesPerLine();
+        if (bmpLineLen == imgLineLen) {
+            qMemCopy(dptr, image.constBits(), image.byteCount());
+        } else {
+            int len = qMin(bmpLineLen, imgLineLen);
+            const uchar *sptr = image.constBits();
+            for (int y = 0; y < image.height(); ++y) {
+                qMemCopy(dptr, sptr, len);
+                dptr += bmpLineLen;
+                sptr += imgLineLen;
+            }
+        }
+        bitmap->EndDataAccess();
+    } else {
+        qWarning("QVolatileImage: Failed to create source bitmap");
+        delete bitmap;
+        bitmap = 0;
+    }
+    return bitmap;
+}
+
+static CFbsBitmap *copyData(const QVolatileImageData &source)
+{
+    source.beginDataAccess();
+    CFbsBitmap *bmp = imageToBitmap(source.image);
+    source.endDataAccess();
+    return bmp;
+}
+
+static CFbsBitmap *convertData(const QVolatileImageData &source, QImage::Format newFormat)
+{
+    source.beginDataAccess();
+    QImage img = source.image.convertToFormat(newFormat);
+    CFbsBitmap *bmp = imageToBitmap(img);
+    source.endDataAccess();
+    return bmp;
+}
+
+static CFbsBitmap *duplicateBitmap(const CFbsBitmap &sourceBitmap)
+{
+    CFbsBitmap *bitmap = new CFbsBitmap;
+    if (bitmap->Duplicate(sourceBitmap.Handle()) != KErrNone) {
+        qWarning("QVolatileImage: Failed to duplicate source bitmap");
+        delete bitmap;
+        bitmap = 0;
+    }
+    return bitmap;
+}
+
+static CFbsBitmap *createBitmap(int w, int h, QImage::Format format)
+{
+    CFbsBitmap *bitmap = new CFbsBitmap;
+    if (bitmap->Create(TSize(w, h), format2TDisplayMode(format)) != KErrNone) {
+        qWarning("QVolatileImage: Failed to create source bitmap %d,%d (%d)", w, h, format);
+        delete bitmap;
+        bitmap = 0;
+    }
+    return bitmap;
+}
+
+static inline bool bitmapNeedsCopy(CFbsBitmap *bitmap)
+{
+    bool needsCopy = bitmap->IsCompressedInRAM();
+#ifdef Q_SYMBIAN_HAS_EXTENDED_BITMAP_TYPE
+    needsCopy |= (bitmap->ExtendedBitmapType() != KNullUid);
+#endif
+    return needsCopy;
+}
+
+static bool cleanup_function_registered = false;
+static QVolatileImageData *firstImageData = 0;
+
+static void cleanup()
+{
+    if (RFbsSession::GetSession()) {
+        QVolatileImageData *imageData = firstImageData;
+        while (imageData) {
+            imageData->release();
+            imageData = imageData->next;
+        }
+    }
+}
+
+static void ensureCleanup()
+{
+    // Destroy all underlying bitmaps in a post routine to prevent panics.
+    // This is a must because CFbsBitmap destructor needs the fbs session,
+    // that was used to create the bitmap, to be open still.
+    if (!cleanup_function_registered) {
+        qAddPostRoutine(cleanup);
+        cleanup_function_registered = true;
+    }
+}
+
+static void registerImageData(QVolatileImageData *imageData)
+{
+    ensureCleanup();
+    imageData->next = firstImageData;
+    if (firstImageData) {
+        firstImageData->prev = imageData;
+    }
+    firstImageData = imageData;
+}
+
+static void unregisterImageData(QVolatileImageData *imageData)
+{
+    if (imageData->prev) {
+        imageData->prev->next = imageData->next;
+    } else {
+        firstImageData = imageData->next;
+    }
+    if (imageData->next) {
+        imageData->next->prev = imageData->prev;
+    }
+}
+
+QVolatileImageData::QVolatileImageData()
+    : next(0), prev(0), bitmap(0), pengine(0)
+{
+    registerImageData(this);
+}
+
+QVolatileImageData::QVolatileImageData(int w, int h, QImage::Format format)
+    : next(0), prev(0), bitmap(0), pengine(0)
+{
+    registerImageData(this);
+    bitmap = createBitmap(w, h, format);
+    updateImage();
+}
+
+QVolatileImageData::QVolatileImageData(const QImage &sourceImage)
+    : next(0), prev(0), bitmap(0), pengine(0)
+{
+    registerImageData(this);
+    image = sourceImage;
+    // The following is not mandatory, but we do it here to have a bitmap
+    // created always in order to reduce local heap usage.
+    ensureBitmap();
+}
+
+QVolatileImageData::QVolatileImageData(void *nativeImage, void *nativeMask)
+    : next(0), prev(0), bitmap(0), pengine(0)
+{
+    registerImageData(this);
+    if (nativeImage) {
+        CFbsBitmap *source = static_cast<CFbsBitmap *>(nativeImage);
+        CFbsBitmap *mask = static_cast<CFbsBitmap *>(nativeMask);
+        initWithBitmap(source);
+        if (mask) {
+            applyMask(mask);
+        }
+    }
+}
+
+QVolatileImageData::QVolatileImageData(const QVolatileImageData &other)
+{
+    bitmap = 0;
+    pengine = 0;
+    next = prev = 0;
+    registerImageData(this);
+    if (!other.image.isNull()) {
+        bitmap = copyData(other);
+        updateImage();
+    }
+}
+
+QVolatileImageData::~QVolatileImageData()
+{
+    release();
+    unregisterImageData(this);
+}
+
+void QVolatileImageData::release()
+{
+    delete bitmap;
+    bitmap = 0;
+    delete pengine;
+    pengine = 0;
+}
+
+void QVolatileImageData::beginDataAccess() const
+{
+    if (bitmap) {
+        bitmap->BeginDataAccess();
+    }
+}
+
+void QVolatileImageData::endDataAccess(bool readOnly) const
+{
+    if (bitmap) {
+        bitmap->EndDataAccess(readOnly);
+    }
+}
+
+bool QVolatileImageData::ensureFormat(QImage::Format format)
+{
+    if (image.isNull()) {
+        return false;
+    }
+    if (image.format() != format) {
+        CFbsBitmap *newBitmap = convertData(*this, format);
+        if (newBitmap && newBitmap != bitmap) {
+            delete bitmap;
+            bitmap = newBitmap;
+            updateImage();
+        } else {
+            return false;
+        }
+    }
+    return true;
+}
+
+void *QVolatileImageData::duplicateNativeImage() const
+{
+    const_cast<QVolatileImageData *>(this)->ensureBitmap();
+    if (bitmap) {
+        if (bitmap->DisplayMode() == EColor16M) {
+            // slow path: needs rgb swapping
+            beginDataAccess();
+            QImage tmp = image.rgbSwapped();
+            endDataAccess(true);
+            return imageToBitmap(tmp);
+        } else if (bitmap->DisplayMode() == EGray2) {
+            // slow path: needs inverting pixels
+            beginDataAccess();
+            QImage tmp = image.copy();
+            endDataAccess(true);
+            tmp.invertPixels();
+            return imageToBitmap(tmp);
+        } else {
+            // fast path: just duplicate the bitmap
+            return duplicateBitmap(*bitmap);
+        }
+    }
+    return 0;
+}
+
+void QVolatileImageData::updateImage()
+{
+    if (bitmap) {
+        TSize size = bitmap->SizeInPixels();
+        beginDataAccess();
+        // Use existing buffer, no copy.  The data address never changes so it
+        // is enough to do this whenever we have a new CFbsBitmap.  N.B. never
+        // use const uchar* here, that would create a read-only image data which
+        // would make a copy in detach() even when refcount is 1.
+        image = QImage(reinterpret_cast<uchar *>(bitmap->DataAddress()),
+                       size.iWidth, size.iHeight, bitmap->DataStride(),
+                       qt_TDisplayMode2Format(bitmap->DisplayMode()));
+        endDataAccess(true);
+    } else {
+        image = QImage();
+    }
+}
+
+void QVolatileImageData::initWithBitmap(CFbsBitmap *source)
+{
+    bool needsCopy = bitmapNeedsCopy(source);
+    if (source->DisplayMode() == EColor16M) {
+        // EColor16M is BGR
+        CFbsBitmap *unswappedBmp = source;
+        if (needsCopy) {
+            unswappedBmp = rasterizeBitmap(source, source->DisplayMode());
+        }
+        unswappedBmp->BeginDataAccess();
+        TSize sourceSize = unswappedBmp->SizeInPixels();
+        QImage img((uchar *) unswappedBmp->DataAddress(),
+                   sourceSize.iWidth, sourceSize.iHeight, unswappedBmp->DataStride(),
+                   qt_TDisplayMode2Format(unswappedBmp->DisplayMode()));
+        img = img.rgbSwapped();
+        unswappedBmp->EndDataAccess(true);
+        bitmap = imageToBitmap(img);
+        if (needsCopy) {
+            delete unswappedBmp;
+        }
+    } else if (needsCopy) {
+        // Rasterize extended and compressed bitmaps.
+        bitmap = rasterizeBitmap(source, EColor16MAP);
+    } else if (source->DisplayMode() == EGray2) {
+        // The pixels will be inverted, must make a copy.
+        bitmap = rasterizeBitmap(source, source->DisplayMode());
+    } else {
+        // Efficient path: no pixel data copying. Just duplicate. This of course
+        // means the original bitmap's data may get modified, but that's fine
+        // and is in accordance with the QPixmap::fromSymbianCFbsBitmap() docs.
+        bitmap = duplicateBitmap(*source);
+    }
+    updateImage();
+    if (bitmap && bitmap->DisplayMode() == EGray2) {
+        // Symbian thinks set pixels are white/transparent, Qt thinks they are
+        // foreground/solid. Invert mono bitmaps so that masks work correctly.
+        beginDataAccess();
+        image.invertPixels();
+        endDataAccess();
+    }
+}
+
+void QVolatileImageData::applyMask(CFbsBitmap *mask)
+{
+    ensureFormat(QImage::Format_ARGB32_Premultiplied);
+    bool destroyMask = false;
+    if (bitmapNeedsCopy(mask)) {
+        mask = rasterizeBitmap(mask, EColor16MU);
+        if (!mask) {
+            return;
+        }
+        destroyMask = true;
+    }
+    mask->BeginDataAccess();
+    TSize maskSize = mask->SizeInPixels();
+    QImage maskImg((const uchar *) mask->DataAddress(), maskSize.iWidth, maskSize.iHeight,
+                   mask->DataStride(), qt_TDisplayMode2Format(mask->DisplayMode()));
+    if (mask->DisplayMode() == EGray2) {
+        maskImg = maskImg.copy();
+        maskImg.invertPixels();
+    }
+    beginDataAccess();
+    image.setAlphaChannel(maskImg);
+    endDataAccess();
+    mask->EndDataAccess(true);
+    ensureImage();
+    if (destroyMask) {
+        delete mask;
+    }
+}
+
+void QVolatileImageData::ensureImage()
+{
+    if (bitmap && !image.isNull()) {
+        QImageData *imaged = image.data_ptr();
+        if (imaged->ref != 1 || imaged->ro_data) {
+            // This is bad, the imagedata got shared somehow. Detach, in order to
+            // have the next check fail and thus have 'image' recreated.
+            beginDataAccess();
+            image.detach();
+            endDataAccess(true);
+        }
+    }
+    if (bitmap && image.constBits() != reinterpret_cast<const uchar *>(bitmap->DataAddress())) {
+        // Should not ever get here. If we do it means that either 'image' has
+        // been replaced with a copy (e.g. because some QImage API assigned a
+        // new, regular QImage to *this) or the bitmap's data address changed
+        // unexpectedly.
+        qWarning("QVolatileImageData: Ptr mismatch");
+        // Recover by recreating the image so that it uses the bitmap as its buffer.
+        updateImage();
+    }
+}
+
+void QVolatileImageData::ensureBitmap()
+{
+    if (!bitmap && !image.isNull()) {
+        bitmap = imageToBitmap(image);
+        updateImage();
+    }
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/inputmethod/qcoefepinputcontext_p.h b/src/gui/inputmethod/qcoefepinputcontext_p.h
index 8c8ffd4..de3577f 100644
--- a/src/gui/inputmethod/qcoefepinputcontext_p.h
+++ b/src/gui/inputmethod/qcoefepinputcontext_p.h
@@ -93,6 +93,9 @@ public:
 
     TCoeInputCapabilities inputCapabilities();
 
+    void resetSplitViewWidget(bool keepInputWidget = false);
+    void ensureFocusWidgetVisible(QWidget *widget);
+
 protected:
     void timerEvent(QTimerEvent *timerEvent);
 
@@ -104,9 +107,11 @@ private:
     void queueInputCapabilitiesChanged();
     bool needsInputPanel();
     void commitTemporaryPreeditString();
+    bool isWidgetVisible(QWidget *widget, int offset = 0);
 
 private Q_SLOTS:
     void ensureInputCapabilitiesChanged();
+    void translateInputWidget();
 
     // From MCoeFepAwareTextEditor
 public:
@@ -155,9 +160,15 @@ private:
     QBasicTimer m_tempPreeditStringTimeout;
     bool m_hasTempPreeditString;
 
+    int m_splitViewResizeBy;
+    Qt::WindowStates m_splitViewPreviousWindowStates;
+    QRectF m_transformation;
+
     friend class tst_QInputContext;
 };
 
+Q_GUI_EXPORT void qt_s60_setPartialScreenInputMode(bool enable);
+
 QT_END_NAMESPACE
 
 #endif // QT_NO_IM
diff --git a/src/gui/inputmethod/qcoefepinputcontext_s60.cpp b/src/gui/inputmethod/qcoefepinputcontext_s60.cpp
index 1bef64d..9d8dd41 100644
--- a/src/gui/inputmethod/qcoefepinputcontext_s60.cpp
+++ b/src/gui/inputmethod/qcoefepinputcontext_s60.cpp
@@ -48,6 +48,8 @@
 #include <qgraphicsscene.h>
 #include <qgraphicswidget.h>
 #include <qsymbianevent.h>
+#include <qlayout.h>
+#include <qdesktopwidget.h>
 #include <private/qcore_symbian_p.h>
 
 #include <fepitfr.h>
@@ -67,8 +69,16 @@
 // that support text selection.
 #define QT_EAknEditorFlagSelectionVisible 0x100000
 
+// EAknEditorFlagEnablePartialScreen is only valid from Sym^3 onwards.
+#define QT_EAknEditorFlagEnablePartialScreen 0x200000
+
 QT_BEGIN_NAMESPACE
 
+Q_GUI_EXPORT void qt_s60_setPartialScreenInputMode(bool enable)
+{
+    S60->partial_keyboard = enable;
+}
+
 QCoeFepInputContext::QCoeFepInputContext(QObject *parent)
     : QInputContext(parent),
       m_fepState(q_check_ptr(new CAknEdwinState)),		// CBase derived object needs check on new
@@ -80,13 +90,19 @@ QCoeFepInputContext::QCoeFepInputContext(QObject *parent)
       m_inlinePosition(0),
       m_formatRetriever(0),
       m_pointerHandler(0),
-      m_hasTempPreeditString(false)
+      m_hasTempPreeditString(false),
+      m_splitViewResizeBy(0),
+      m_splitViewPreviousWindowStates(Qt::WindowNoState)
 {
     m_fepState->SetObjectProvider(this);
-    if (QSysInfo::s60Version() > QSysInfo::SV_S60_5_0)
-        m_fepState->SetFlags(EAknEditorFlagDefault | QT_EAknEditorFlagSelectionVisible);
-    else
-        m_fepState->SetFlags(EAknEditorFlagDefault);
+    int defaultFlags = EAknEditorFlagDefault;
+    if (QSysInfo::s60Version() > QSysInfo::SV_S60_5_0) {
+        if (S60->partial_keyboard) {
+            defaultFlags |= QT_EAknEditorFlagEnablePartialScreen;
+        }
+        defaultFlags |= QT_EAknEditorFlagSelectionVisible;
+    }
+    m_fepState->SetFlags(defaultFlags);
     m_fepState->SetDefaultInputMode( EAknEditorTextInputMode );
     m_fepState->SetPermittedInputModes( EAknEditorAllInputModes );
     m_fepState->SetDefaultCase( EAknEditorTextCase );
@@ -210,6 +226,21 @@ bool QCoeFepInputContext::filterEvent(const QEvent *event)
         return false;
 
     switch (event->type()) {
+    case QEvent::MouseButtonPress:
+        // Alphanumeric keypad doesn't like it when we click and text is still getting displayed
+        // It ignores the mouse event, so we need to commit and send a selection event (which will get triggered
+        // after the commit)
+        if (!m_preeditString.isEmpty()) {
+            commitCurrentString(false);
+
+            int pos = focusWidget()->inputMethodQuery(Qt::ImCursorPosition).toInt();
+
+            QList<QInputMethodEvent::Attribute> selectAttributes;
+            selectAttributes << QInputMethodEvent::Attribute(QInputMethodEvent::Selection, pos, 0, QVariant());
+            QInputMethodEvent selectEvent(QLatin1String(""), selectAttributes);
+            sendEvent(selectEvent);
+    }
+        break;
     case QEvent::KeyPress:
         commitTemporaryPreeditString();
         // fall through intended
@@ -343,6 +374,165 @@ TCoeInputCapabilities QCoeFepInputContext::inputCapabilities()
     return TCoeInputCapabilities(m_textCapabilities, this, 0);
 }
 
+void QCoeFepInputContext::resetSplitViewWidget(bool keepInputWidget)
+{
+    QGraphicsView *gv = qobject_cast<QGraphicsView*>(S60->splitViewLastWidget);
+
+    if (!gv) {
+        return;
+    }
+
+    QSymbianControl *symControl = static_cast<QSymbianControl*>(gv->effectiveWinId());
+    symControl->CancelLongTapTimer();
+
+    const bool alwaysResize = (gv->verticalScrollBarPolicy() != Qt::ScrollBarAlwaysOff);
+    QWidget *windowToMove = gv->window();
+
+    bool userResize = gv->testAttribute(Qt::WA_Resized);
+
+    windowToMove->setUpdatesEnabled(false);
+
+    if (!alwaysResize) {
+        if (gv->scene()) {
+            if (gv->scene()->focusItem())
+                disconnect(gv->scene()->focusItem()->toGraphicsObject(), SIGNAL(cursorPositionChanged()), this, SLOT(translateInputWidget()));
+            QGraphicsItem *rootItem;
+            foreach (QGraphicsItem *item, gv->scene()->items()) {
+                if (!item->parentItem()) {
+                    rootItem = item;
+                    break;
+                }
+            }
+            if (rootItem)
+                rootItem->resetTransform();
+        }
+    } else {
+        if (m_splitViewResizeBy)
+            gv->resize(gv->rect().width(), m_splitViewResizeBy);
+    }
+    // Resizing might have led to widget losing its original windowstate.
+    // Restore previous window state.
+
+    if (m_splitViewPreviousWindowStates != windowToMove->windowState())
+        windowToMove->setWindowState(m_splitViewPreviousWindowStates);
+
+    windowToMove->setUpdatesEnabled(true);
+
+    gv->setAttribute(Qt::WA_Resized, userResize); //not a user resize
+
+    m_splitViewResizeBy = 0;
+    if (!keepInputWidget) {
+        m_splitViewPreviousWindowStates = Qt::WindowNoState;
+        S60->splitViewLastWidget = 0;
+    }
+}
+
+// Checks if a given widget is visible in the splitview rect. The offset
+// parameter can be used to validate if moving widget upwards or downwards
+// by the offset would make a difference for the visibility.
+
+bool QCoeFepInputContext::isWidgetVisible(QWidget *widget, int offset)
+{
+    bool visible = false;
+    if (widget) {
+        QRect splitViewRect = qt_TRect2QRect(static_cast<CEikAppUi*>(S60->appUi())->ClientRect());
+        QWidget *window = QApplication::activeWindow();
+        QGraphicsView *gv = qobject_cast<QGraphicsView*>(widget);
+        if (gv && window) {
+            if (QGraphicsScene *scene = gv->scene()) {
+                if (QGraphicsItem *focusItem = scene->focusItem()) {
+                    QPoint cursorPos = window->mapToGlobal(focusItem->cursor().pos());
+                    cursorPos.setY(cursorPos.y() + offset);
+                    if (splitViewRect.contains(cursorPos)) {
+                        visible = true;
+                    }
+                }
+            }
+        }
+    }
+    return visible;
+}
+
+// Ensure that the input widget is visible in the splitview rect.
+
+void QCoeFepInputContext::ensureFocusWidgetVisible(QWidget *widget)
+{
+    // Native side opening and closing its virtual keyboard when it changes the keyboard layout,
+    // has an adverse impact on long tap timer. Cancel the timer when splitview opens to avoid this.
+    QSymbianControl *symControl = static_cast<QSymbianControl*>(widget->effectiveWinId());
+    symControl->CancelLongTapTimer();
+
+    // Graphicsviews that have vertical scrollbars should always be resized to the splitview area.
+    // Graphicsviews without scrollbars should be translated.
+
+    QGraphicsView *gv = qobject_cast<QGraphicsView*>(widget);
+    if (!gv)
+        return;
+
+    const bool alwaysResize = (gv && gv->verticalScrollBarPolicy() != Qt::ScrollBarAlwaysOff);
+    const bool moveWithinVisibleArea = (S60->splitViewLastWidget != 0);
+
+    QWidget *windowToMove = gv ? gv : symControl->widget();
+    if (!windowToMove->isWindow())
+        windowToMove = windowToMove->window();
+    if (!windowToMove) {
+        return;
+    }
+
+    // When opening the keyboard (not moving within the splitview area), save the original
+    // window state. In some cases, ensuring input widget visibility might lead to window
+    // states getting changed.
+
+    if (!moveWithinVisibleArea) {
+        S60->splitViewLastWidget = widget;
+        m_splitViewPreviousWindowStates = windowToMove->windowState();
+    }
+
+    int windowTop = widget->window()->pos().y();
+
+    const bool userResize = widget->testAttribute(Qt::WA_Resized);
+
+    QRect splitViewRect = qt_TRect2QRect(static_cast<CEikAppUi*>(S60->appUi())->ClientRect());
+
+
+    // When resizing a window widget, it will lose its maximized window state.
+    // Native applications hide statuspane in splitview state, so lets move to
+    // fullscreen mode. This makes available area slightly bigger, which helps usability
+    // and greatly reduces event passing in orientation switch cases,
+    // as the statuspane size is not changing.
+
+    if (!(windowToMove->windowState() & Qt::WindowFullScreen)) {
+        windowToMove->setWindowState(
+            (windowToMove->windowState() & ~(Qt::WindowMinimized | Qt::WindowFullScreen)) | Qt::WindowFullScreen);
+    }
+
+    if (alwaysResize) {
+        windowToMove->setUpdatesEnabled(false);
+        if (!moveWithinVisibleArea)
+            m_splitViewResizeBy = widget->height();
+
+        windowTop = widget->geometry().top();
+        widget->resize(widget->width(), splitViewRect.height() - windowTop);
+
+        if (gv->scene()) {
+            const QRectF microFocusRect = gv->scene()->inputMethodQuery(Qt::ImMicroFocus).toRectF();
+            gv->ensureVisible(microFocusRect);
+        }
+        windowToMove->setUpdatesEnabled(true);
+    } else {
+        if (!moveWithinVisibleArea) {
+            // Check if the widget contains cursorPositionChanged signal and connect to it.
+            const char *signal = QMetaObject::normalizedSignature(SIGNAL(cursorPositionChanged())).constData();
+            int index = gv->scene()->focusItem()->toGraphicsObject()->metaObject()->indexOfSignal(signal + 1);
+            if (index != -1)
+                connect(gv->scene()->focusItem()->toGraphicsObject(), SIGNAL(cursorPositionChanged()), this, SLOT(translateInputWidget()));
+        }
+        translateInputWidget();
+    }
+
+    widget->setAttribute(Qt::WA_Resized, userResize); //not a user resize
+}
+
 static QTextCharFormat qt_TCharFormat2QTextCharFormat(const TCharFormat &cFormat, bool validStyleColor)
 {
     QTextCharFormat qFormat;
@@ -474,10 +664,12 @@ void QCoeFepInputContext::applyHints(Qt::InputMethodHints hints)
     m_fepState->SetPermittedCases(flags);
     ReportAknEdStateEvent(MAknEdStateObserver::EAknEdwinStateCaseModeUpdate);
 
-    if (QSysInfo::s60Version() > QSysInfo::SV_S60_5_0)
-        flags = QT_EAknEditorFlagSelectionVisible;
-    else 
-        flags = 0;
+    flags = 0;
+    if (QSysInfo::s60Version() > QSysInfo::SV_S60_5_0) {
+        if (S60->partial_keyboard)
+            flags |= QT_EAknEditorFlagEnablePartialScreen;
+        flags |= QT_EAknEditorFlagSelectionVisible;
+    }
     if (hints & ImhUppercaseOnly && !(hints & ImhLowercaseOnly)
             || hints & ImhLowercaseOnly && !(hints & ImhUppercaseOnly)) {
         flags |= EAknEditorFlagFixedCase;
@@ -604,6 +796,47 @@ void QCoeFepInputContext::ensureInputCapabilitiesChanged()
     m_pendingInputCapabilitiesChanged = false;
 }
 
+void QCoeFepInputContext::translateInputWidget()
+{
+    QGraphicsView *gv = qobject_cast<QGraphicsView *>(S60->splitViewLastWidget);
+    QRect splitViewRect = qt_TRect2QRect(static_cast<CEikAppUi*>(S60->appUi())->ClientRect());
+
+    QRectF cursor = gv->scene()->inputMethodQuery(Qt::ImMicroFocus).toRectF();
+    QPolygon cursorP = gv->mapFromScene(cursor);
+    QRectF vkbRect = QRectF(splitViewRect.bottomLeft(), qApp->desktop()->rect().bottomRight());
+    if (cursor.isEmpty() || vkbRect.isEmpty())
+        return;
+
+    // Fetch root item (i.e. graphicsitem with no parent)
+    QGraphicsItem *rootItem;
+    foreach (QGraphicsItem *item, gv->scene()->items()) {
+        if (!item->parentItem()) {
+            rootItem = item;
+            break;
+        }
+    }
+    if (!rootItem)
+        return;
+
+    m_transformation = (rootItem->transform().isTranslating()) ? QRectF(0,0, gv->width(), rootItem->transform().dy()) : QRectF();
+
+    // Do nothing if the cursor is visible in the splitview area.
+    if (splitViewRect.contains(cursorP.boundingRect()))
+        return;
+
+    // New Y position should be ideally at the center of the splitview area.
+    // If that would expose unpainted canvas, limit the tranformation to the visible scene bottom.
+
+    const qreal maxY = gv->sceneRect().bottom() - splitViewRect.bottom() + m_transformation.height();
+    qreal dy = -(qMin(maxY, (cursor.bottom() - vkbRect.top() / 2)));
+
+    // Do not allow transform above screen top.
+    if (m_transformation.height() + dy > 0)
+        return;
+
+    rootItem->setTransform(QTransform::fromTranslate(0, dy), true);
+}
+
 void QCoeFepInputContext::StartFepInlineEditL(const TDesC& aInitialInlineText,
         TInt aPositionOfInsertionPointInInlineText, TBool aCursorVisibility, const MFormCustomDraw* /*aCustomDraw*/,
         MFepInlineTextFormatRetriever& aInlineTextFormatRetriever,
diff --git a/src/gui/itemviews/qheaderview.cpp b/src/gui/itemviews/qheaderview.cpp
index 6359f0b..d6d9536 100644
--- a/src/gui/itemviews/qheaderview.cpp
+++ b/src/gui/itemviews/qheaderview.cpp
@@ -3274,9 +3274,17 @@ void QHeaderViewPrivate::clear()
 void QHeaderViewPrivate::flipSortIndicator(int section)
 {
     Q_Q(QHeaderView);
-    bool ascending = (sortIndicatorSection != section
-                      || sortIndicatorOrder == Qt::DescendingOrder);
-    q->setSortIndicator(section, ascending ? Qt::AscendingOrder : Qt::DescendingOrder);
+    Qt::SortOrder sortOrder;
+    if (sortIndicatorSection == section) {
+        sortOrder = (sortIndicatorOrder == Qt::DescendingOrder) ? Qt::AscendingOrder : Qt::DescendingOrder;
+    } else {
+        const QVariant value = model->headerData(section, orientation, Qt::InitialSortOrderRole);
+        if (value.canConvert(QVariant::Int))
+            sortOrder = static_cast<Qt::SortOrder>(value.toInt());
+        else
+            sortOrder = Qt::AscendingOrder;
+    }
+    q->setSortIndicator(section, sortOrder);
 }
 
 void QHeaderViewPrivate::cascadingResize(int visual, int newSize)
diff --git a/src/gui/itemviews/qsortfilterproxymodel.cpp b/src/gui/itemviews/qsortfilterproxymodel.cpp
index 3196ba5..eb56f56 100644
--- a/src/gui/itemviews/qsortfilterproxymodel.cpp
+++ b/src/gui/itemviews/qsortfilterproxymodel.cpp
@@ -227,7 +227,7 @@ public:
     void _q_sourceColumnsRemoved(const QModelIndex &source_parent,
                                  int start, int end);
 
-    void clear_mapping();
+    void _q_clearMapping();
 
     void sort();
     bool update_source_sort_column();
@@ -281,7 +281,7 @@ typedef QHash<QModelIndex, QSortFilterProxyModelPrivate::Mapping *> IndexMap;
 void QSortFilterProxyModelPrivate::_q_sourceModelDestroyed()
 {
     QAbstractProxyModelPrivate::_q_sourceModelDestroyed();
-    clear_mapping();
+    _q_clearMapping();
 }
 
 void QSortFilterProxyModelPrivate::remove_from_mapping(const QModelIndex &source_parent)
@@ -293,7 +293,7 @@ void QSortFilterProxyModelPrivate::remove_from_mapping(const QModelIndex &source
     }
 }
 
-void QSortFilterProxyModelPrivate::clear_mapping()
+void QSortFilterProxyModelPrivate::_q_clearMapping()
 {
     // store the persistent indexes
     QModelIndexPairList source_indexes = store_persistent_indexes();
@@ -1225,7 +1225,7 @@ void QSortFilterProxyModelPrivate::_q_sourceReset()
 {
     Q_Q(QSortFilterProxyModel);
     invalidatePersistentIndexes();
-    clear_mapping();
+    _q_clearMapping();
     // All internal structures are deleted in clear()
     q->endResetModel();
     update_source_sort_column();
@@ -1521,6 +1521,7 @@ QSortFilterProxyModel::QSortFilterProxyModel(QObject *parent)
     d->filter_column = 0;
     d->filter_role = Qt::DisplayRole;
     d->dynamic_sortfilter = false;
+    connect(this, SIGNAL(modelReset()), this, SLOT(_q_clearMapping()));
 }
 
 /*!
@@ -1622,7 +1623,7 @@ void QSortFilterProxyModel::setSourceModel(QAbstractItemModel *sourceModel)
     connect(d->model, SIGNAL(modelAboutToBeReset()), this, SLOT(_q_sourceAboutToBeReset()));
     connect(d->model, SIGNAL(modelReset()), this, SLOT(_q_sourceReset()));
 
-    d->clear_mapping();
+    d->_q_clearMapping();
     endResetModel();
     if (d->update_source_sort_column() && d->dynamic_sortfilter)
         d->sort();
@@ -2313,7 +2314,7 @@ void QSortFilterProxyModel::clear()
 {
     Q_D(QSortFilterProxyModel);
     emit layoutAboutToBeChanged();
-    d->clear_mapping();
+    d->_q_clearMapping();
     emit layoutChanged();
 }
 
@@ -2328,7 +2329,7 @@ void QSortFilterProxyModel::invalidate()
 {
     Q_D(QSortFilterProxyModel);
     emit layoutAboutToBeChanged();
-    d->clear_mapping();
+    d->_q_clearMapping();
     emit layoutChanged();
 }
 
diff --git a/src/gui/itemviews/qsortfilterproxymodel.h b/src/gui/itemviews/qsortfilterproxymodel.h
index 09fd20f..afeaa69 100644
--- a/src/gui/itemviews/qsortfilterproxymodel.h
+++ b/src/gui/itemviews/qsortfilterproxymodel.h
@@ -189,6 +189,7 @@ private:
     Q_PRIVATE_SLOT(d_func(), void _q_sourceColumnsInserted(const QModelIndex &source_parent, int start, int end))
     Q_PRIVATE_SLOT(d_func(), void _q_sourceColumnsAboutToBeRemoved(const QModelIndex &source_parent, int start, int end))
     Q_PRIVATE_SLOT(d_func(), void _q_sourceColumnsRemoved(const QModelIndex &source_parent, int start, int end))
+    Q_PRIVATE_SLOT(d_func(), void _q_clearMapping())
 };
 
 QT_END_NAMESPACE
diff --git a/src/gui/kernel/kernel.pri b/src/gui/kernel/kernel.pri
index 0ff3d88..32fa3d3 100644
--- a/src/gui/kernel/kernel.pri
+++ b/src/gui/kernel/kernel.pri
@@ -223,7 +223,8 @@ qpa {
                 kernel/qdesktopwidget_qpa_p.h \
                 kernel/qplatformeventloopintegration_qpa.h \
                 kernel/qplatformcursor_qpa.h \
-                kernel/qplatformclipboard_qpa.h
+                kernel/qplatformclipboard_qpa.h \
+                kernel/qplatformnativeinterface_qpa.h
 
 	SOURCES += \
 		kernel/qapplication_qpa.cpp \
@@ -246,7 +247,8 @@ qpa {
                 kernel/qplatformeventloopintegration_qpa.cpp \
                 kernel/qplatformglcontext_qpa.cpp \
                 kernel/qplatformcursor_qpa.cpp \
-                kernel/qplatformclipboard_qpa.cpp
+                kernel/qplatformclipboard_qpa.cpp \
+                kernel/qplatformnativeinterface_qpa.cpp
 
         contains(QT_CONFIG, glib) {
             SOURCES += \
diff --git a/src/gui/kernel/qapplication_p.h b/src/gui/kernel/qapplication_p.h
index a6815a8..954c6de 100644
--- a/src/gui/kernel/qapplication_p.h
+++ b/src/gui/kernel/qapplication_p.h
@@ -639,6 +639,8 @@ public:
     int pressureSupported;
     int maxTouchPressure;
     QList<QTouchEvent::TouchPoint> appAllTouchPoints;
+
+    bool useTranslucentEGLSurfaces;
 #endif
 
 private:
diff --git a/src/gui/kernel/qapplication_qpa.cpp b/src/gui/kernel/qapplication_qpa.cpp
index cd76adf..cb5439c 100644
--- a/src/gui/kernel/qapplication_qpa.cpp
+++ b/src/gui/kernel/qapplication_qpa.cpp
@@ -51,6 +51,7 @@
 #endif
 
 #include "private/qwidget_p.h"
+#include "private/qevent_p.h"
 
 #include "qgenericpluginfactory_qpa.h"
 #include "qplatformintegrationfactory_qpa_p.h"
@@ -816,8 +817,14 @@ void QApplicationPrivate::processKeyEvent(QWindowSystemInterfacePrivate::KeyEven
     if (app_do_modal && !qt_try_modal(focusW, e->keyType))
         return;
 
-    QKeyEvent ev(e->keyType, e->key, e->modifiers, e->unicode, e->repeat, e->repeatCount);
-    QApplication::sendSpontaneousEvent(focusW, &ev);
+    if (e->nativeScanCode || e->nativeVirtualKey || e->nativeModifiers) {
+        QKeyEventEx ev(e->keyType, e->key, e->modifiers, e->unicode, e->repeat, e->repeatCount,
+                       e->nativeScanCode, e->nativeVirtualKey, e->nativeModifiers);
+        QApplication::sendSpontaneousEvent(focusW, &ev);
+    } else {
+        QKeyEvent ev(e->keyType, e->key, e->modifiers, e->unicode, e->repeat, e->repeatCount);
+        QApplication::sendSpontaneousEvent(focusW, &ev);
+    }
 }
 
 void QApplicationPrivate::processEnterEvent(QWindowSystemInterfacePrivate::EnterEvent *e)
diff --git a/src/gui/kernel/qapplication_qws.cpp b/src/gui/kernel/qapplication_qws.cpp
index f0801e3..642d3e6 100644
--- a/src/gui/kernel/qapplication_qws.cpp
+++ b/src/gui/kernel/qapplication_qws.cpp
@@ -204,6 +204,11 @@ QString qws_dataDir()
     result = QT_VFB_DATADIR(qws_display_id);
     QByteArray dataDir = result.toLocal8Bit();
 
+#if defined(Q_OS_INTEGRITY)
+    /* ensure filesystem is ready before starting requests */
+    WaitForFileSystemInitialization();
+#endif
+
     if (QT_MKDIR(dataDir, 0700)) {
         if (errno != EEXIST) {
             qFatal("Cannot create Qt for Embedded Linux data directory: %s", dataDir.constData());
diff --git a/src/gui/kernel/qapplication_s60.cpp b/src/gui/kernel/qapplication_s60.cpp
index 586869a..3ce597b 100644
--- a/src/gui/kernel/qapplication_s60.cpp
+++ b/src/gui/kernel/qapplication_s60.cpp
@@ -96,6 +96,9 @@ QT_BEGIN_NAMESPACE
 // Goom Events through Window Server
 static const int KGoomMemoryLowEvent = 0x10282DBF;
 static const int KGoomMemoryGoodEvent = 0x20026790;
+// Split view open/close events from AVKON
+static const int KSplitViewOpenEvent = 0x2001E2C0;
+static const int KSplitViewCloseEvent = 0x2001E2C1;
 
 #if defined(QT_DEBUG)
 static bool        appNoGrab        = false;        // Grabbing enabled
@@ -401,6 +404,7 @@ QSymbianControl::QSymbianControl(QWidget *w)
     , m_longTapDetector(0)
     , m_ignoreFocusChanged(0)
     , m_symbianPopupIsOpen(0)
+    , m_inExternalScreenOverride(false)
 {
 }
 
@@ -408,9 +412,11 @@ void QSymbianControl::ConstructL(bool isWindowOwning, bool desktop)
 {
     if (!desktop)
     {
-        if (isWindowOwning || !qwidget->parentWidget())
-            CreateWindowL(S60->windowGroup());
-        else
+        if (isWindowOwning || !qwidget->parentWidget()
+            || qwidget->parentWidget()->windowType() == Qt::Desktop) {
+            RWindowGroup &wg(S60->windowGroup(qwidget));
+            CreateWindowL(wg);
+        } else {
             /**
              * TODO: in order to avoid creating windows for all ancestors of
              * this widget up to the root window, the parameter passed to
@@ -420,6 +426,7 @@ void QSymbianControl::ConstructL(bool isWindowOwning, bool desktop)
              * is created for a widget between this one and the root window.
              */
             CreateWindowL(qwidget->parentWidget()->winId());
+        }
 
         // Necessary in order to be able to track the activation status of
         // the control's window
@@ -452,7 +459,7 @@ void QSymbianControl::ConstructL(bool isWindowOwning, bool desktop)
             windowPurpose = ETfxPurposeSplashScreenWindow;
             break;
         default:
-            windowPurpose = (isWindowOwning || !qwidget->parentWidget())
+            windowPurpose = (isWindowOwning || !qwidget->parentWidget() || qwidget->parentWidget()->windowType() == Qt::Desktop)
                             ? ETfxPurposeWindow : ETfxPurposeChildWindow;
             break;
         }
@@ -983,14 +990,15 @@ TKeyResponse QSymbianControl::handleVirtualMouse(const TKeyEvent& keyEvent,TEven
                 }
             }
             //clip to screen size (window server allows a sprite hotspot to be outside the screen)
+            int screenNumber = S60->screenNumberForWidget(qwidget);
             if (x < 0)
                 x = 0;
-            else if (x >= S60->screenWidthInPixels)
-                x = S60->screenWidthInPixels - 1;
+            else if (x >= S60->screenWidthInPixelsForScreen[screenNumber])
+                x = S60->screenWidthInPixelsForScreen[screenNumber] - 1;
             if (y < 0)
                 y = 0;
-            else if (y >= S60->screenHeightInPixels)
-                y = S60->screenHeightInPixels - 1;
+            else if (y >= S60->screenHeightInPixelsForScreen[screenNumber])
+                y = S60->screenHeightInPixelsForScreen[screenNumber] - 1;
             TPoint epos(x, y);
             TPoint cpos = epos - PositionRelativeToScreen();
             fakeEvent.iPosition = cpos;
@@ -1167,6 +1175,18 @@ void QSymbianControl::SizeChanged()
     QSize newSize(Size().iWidth, Size().iHeight);
 
     if (oldSize != newSize) {
+        const bool isFullscreen = qwidget->windowState() & Qt::WindowFullScreen;
+        const int screenNumber = S60->screenNumberForWidget(qwidget);
+        if (!m_inExternalScreenOverride && isFullscreen && screenNumber > 0) {
+            int screenWidth = S60->screenWidthInPixelsForScreen[screenNumber];
+            int screenHeight = S60->screenHeightInPixelsForScreen[screenNumber];
+            TSize screenSize(screenWidth, screenHeight);
+            if (screenWidth > 0 && screenHeight > 0 && screenSize != Size()) {
+                m_inExternalScreenOverride = true;
+                SetExtent(TPoint(0, 0), screenSize);
+                return;
+            }
+        }
         QRect cr = qwidget->geometry();
         cr.setSize(newSize);
         qwidget->data->crect = cr;
@@ -1189,6 +1209,8 @@ void QSymbianControl::SizeChanged()
         }
     }
 
+    m_inExternalScreenOverride = false;
+
     // CCoeControl::SetExtent calls SizeChanged, but does not call
     // PositionChanged, so we call it here to ensure that the widget's
     // position is updated.
@@ -1224,6 +1246,11 @@ void QSymbianControl::FocusChanged(TDrawNow /* aDrawNow */)
     if (m_ignoreFocusChanged || (qwidget->windowType() & Qt::WindowType_Mask) == Qt::Desktop)
         return;
 
+#ifdef Q_WS_S60
+    if (S60->splitViewLastWidget)
+        return;
+#endif
+
     // Popups never get focused, but still receive the FocusChanged when they are hidden.
     if (QApplicationPrivate::popupWidgets != 0
             || (qwidget->windowType() & Qt::Popup) == Qt::Popup)
@@ -1302,9 +1329,56 @@ void QSymbianControl::handleClientAreaChange()
     }
 }
 
+bool QSymbianControl::isSplitViewWidget(QWidget *widget) {
+    bool returnValue = true;
+    //Ignore events sent to non-active windows, not visible widgets and not parents of input widget.
+    if (!qwidget->isActiveWindow()
+        || !qwidget->isVisible()
+        || !qwidget->isAncestorOf(widget)) {
+
+        returnValue = false;
+    }
+    return returnValue;
+}
+
 void QSymbianControl::HandleResourceChange(int resourceType)
 {
     switch (resourceType) {
+    case KSplitViewCloseEvent: //intentional fall-through
+    case KSplitViewOpenEvent: {
+#if !defined(QT_NO_IM) && defined(Q_WS_S60)
+
+        //Fetch widget getting the text input
+        QWidget *widget = QWidget::keyboardGrabber();
+        if (!widget) {
+            if (QApplicationPrivate::popupWidgets) {
+                widget = QApplication::activePopupWidget()->focusWidget();
+                if (!widget) {
+                    widget = QApplication::activePopupWidget();
+                }
+            } else {
+                widget = QApplicationPrivate::focus_widget;
+                if (!widget) {
+                    widget = qwidget;
+                }
+            }
+        }
+        if (widget) {
+            QCoeFepInputContext *ic = qobject_cast<QCoeFepInputContext *>(widget->inputContext());
+            if (!ic) {
+                ic = qobject_cast<QCoeFepInputContext *>(qApp->inputContext());
+            }
+            if (ic && isSplitViewWidget(widget)) {
+                if (resourceType == KSplitViewCloseEvent) {
+                    ic->resetSplitViewWidget();
+                } else {
+                    ic->ensureFocusWidgetVisible(widget);
+                }
+            }
+        }
+#endif // !defined(QT_NO_IM) && defined(Q_WS_S60)
+    }
+    break;
     case KInternalStatusPaneChange:
         handleClientAreaChange();
         if (IsFocused() && IsVisible()) {
@@ -1592,6 +1666,32 @@ void qt_init(QApplicationPrivate * /* priv */, int)
     QObject::connect(qApp, SIGNAL(aboutToQuit()), qApp, SLOT(_q_aboutToQuit()));
 #endif
 
+#ifdef Q_SYMBIAN_SEMITRANSPARENT_BG_SURFACE
+    QApplicationPrivate::instance()->useTranslucentEGLSurfaces = true;
+
+    const TUid KIvePropertyCat = {0x2726beef};
+    enum TIvePropertyChipType {
+        EVCBCM2727B1 = 0x00000000,
+        EVCBCM2763A0 = 0x04000100,
+        EVCBCM2763B0 = 0x04000102,
+        EVCBCM2763C0 = 0x04000103,
+        EVCBCM2763C1 = 0x04000104,
+        EVCBCMUnknown = 0x7fffffff
+    };
+
+    TInt chipType = EVCBCMUnknown;
+    if (RProperty::Get(KIvePropertyCat, 0 /*chip type*/, chipType) == KErrNone) {
+        if (chipType == EVCBCM2727B1) {
+            // We have only 32MB GPU memory. Use raster surfaces
+            // for transparent TLWs.
+            QApplicationPrivate::instance()->useTranslucentEGLSurfaces = false;
+        }
+    } else {
+        QApplicationPrivate::instance()->useTranslucentEGLSurfaces = false;
+    }
+#else
+    QApplicationPrivate::instance()->useTranslucentEGLSurfaces = false;
+#endif
 /*
  ### Commented out for now as parameter handling not needed in SOS(yet). Code below will break testlib with -o flag
     int argc = priv->argc;
@@ -1988,7 +2088,10 @@ int QApplicationPrivate::symbianProcessWsEvent(const QSymbianEvent *symbianEvent
             return 1;
         }
         break;
-    case EEventScreenDeviceChanged:
+    case EEventScreenDeviceChanged: // fallthrough
+#if defined(Q_SYMBIAN_SUPPORTS_MULTIPLE_SCREENS)
+    case EEventDisplayChanged:
+#endif
         if (callSymbianEventFilters(symbianEvent))
             return 1;
         if (S60)
diff --git a/src/gui/kernel/qclipboard_win.cpp b/src/gui/kernel/qclipboard_win.cpp
index 52b9663..ea41165 100644
--- a/src/gui/kernel/qclipboard_win.cpp
+++ b/src/gui/kernel/qclipboard_win.cpp
@@ -52,6 +52,7 @@
 #include "qt_windows.h"
 #include "qdnd_p.h"
 #include <private/qwidget_p.h>
+#include <private/qsystemlibrary_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -70,6 +71,9 @@ void QtCeFlushClipboard();
 
 #endif
 
+typedef BOOL (WINAPI *PtrIsHungAppWindow)(HWND);
+
+static PtrIsHungAppWindow ptrIsHungAppWindow = 0;
 
 class QClipboardWatcher : public QInternalMimeData {
 public:
@@ -327,9 +331,16 @@ bool QClipboard::event(QEvent *e)
             d->releaseIData();
         propagate = true;
     }
-
     if (propagate && d->nextClipboardViewer) {
-        SendMessage(d->nextClipboardViewer, m->message, m->wParam, m->lParam);
+        if (ptrIsHungAppWindow == 0) {
+            QSystemLibrary library(QLatin1String("User32"));
+            ptrIsHungAppWindow = (PtrIsHungAppWindow)library.resolve("IsHungAppWindow");
+        }
+        if (ptrIsHungAppWindow && ptrIsHungAppWindow(d->nextClipboardViewer)) {
+            qWarning("%s: Cowardly refusing to send clipboard message to hung application...", Q_FUNC_INFO);
+        } else {
+            SendMessage(d->nextClipboardViewer, m->message, m->wParam, m->lParam);
+        }
     }
 
     return true;
diff --git a/src/gui/kernel/qcocoaintrospection_mac.mm b/src/gui/kernel/qcocoaintrospection_mac.mm
index 9b536b7..70c893a 100644
--- a/src/gui/kernel/qcocoaintrospection_mac.mm
+++ b/src/gui/kernel/qcocoaintrospection_mac.mm
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/kernel/qcocoaintrospection_p.h b/src/gui/kernel/qcocoaintrospection_p.h
index b9422e8..1c7d6ac 100644
--- a/src/gui/kernel/qcocoaintrospection_p.h
+++ b/src/gui/kernel/qcocoaintrospection_p.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/kernel/qcocoapanel_mac_p.h b/src/gui/kernel/qcocoapanel_mac_p.h
index b41a4b5..5426159 100644
--- a/src/gui/kernel/qcocoapanel_mac_p.h
+++ b/src/gui/kernel/qcocoapanel_mac_p.h
@@ -60,6 +60,13 @@
 QT_FORWARD_DECLARE_CLASS(QStringList);
 QT_FORWARD_DECLARE_CLASS(QCocoaDropData);
 
+@interface NSPanel (QtIntegration)
+- (NSDragOperation)draggingEntered:(id <NSDraggingInfo>)sender;
+- (NSDragOperation)draggingUpdated:(id <NSDraggingInfo>)sender;
+- (void)draggingExited:(id <NSDraggingInfo>)sender;
+- (BOOL)performDragOperation:(id <NSDraggingInfo>)sender;
+@end
+
 @interface QT_MANGLE_NAMESPACE(QCocoaPanel) : NSPanel {
     QStringList *currentCustomDragTypes;
     QCocoaDropData *dropData;
diff --git a/src/gui/kernel/qcocoaview_mac.mm b/src/gui/kernel/qcocoaview_mac.mm
index ff2dfe7..5e8b37e 100644
--- a/src/gui/kernel/qcocoaview_mac.mm
+++ b/src/gui/kernel/qcocoaview_mac.mm
@@ -983,7 +983,7 @@ static int qCocoaViewCount = 0;
     QString qtText;
     // Cursor position is retrived from the range.
     QList<QInputMethodEvent::Attribute> attrs;
-    attrs<<QInputMethodEvent::Attribute(QInputMethodEvent::Cursor, selRange.location, 1, QVariant());
+    attrs<<QInputMethodEvent::Attribute(QInputMethodEvent::Cursor, selRange.location + selRange.length, 1, QVariant());
     if ([aString isKindOfClass:[NSAttributedString class]]) {
         qtText = QCFString::toQString(reinterpret_cast<CFStringRef>([aString string]));
         composingLength = qtText.length();
diff --git a/src/gui/kernel/qcocoawindow_mac_p.h b/src/gui/kernel/qcocoawindow_mac_p.h
index e6b50f5..d567cab 100644
--- a/src/gui/kernel/qcocoawindow_mac_p.h
+++ b/src/gui/kernel/qcocoawindow_mac_p.h
@@ -74,6 +74,13 @@ QT_FORWARD_DECLARE_CLASS(QCocoaDropData);
 - (QWidget *)QT_MANGLE_NAMESPACE(qt_qwidget);
 @end
 
+@interface NSWindow (QtIntegration)
+- (NSDragOperation)draggingEntered:(id <NSDraggingInfo>)sender;
+- (NSDragOperation)draggingUpdated:(id <NSDraggingInfo>)sender;
+- (void)draggingExited:(id <NSDraggingInfo>)sender;
+- (BOOL)performDragOperation:(id <NSDraggingInfo>)sender;
+@end
+
 @interface QT_MANGLE_NAMESPACE(QCocoaWindow) : NSWindow {
     QStringList *currentCustomDragTypes;
     QCocoaDropData *dropData;
diff --git a/src/gui/kernel/qcursor_mac.mm b/src/gui/kernel/qcursor_mac.mm
index 0d57b85..0afa3ee 100644
--- a/src/gui/kernel/qcursor_mac.mm
+++ b/src/gui/kernel/qcursor_mac.mm
@@ -215,7 +215,7 @@ void qt_mac_update_cursor()
         widgetUnderMouse = qt_button_down;
     } else {
         QPoint localPoint;
-        QPoint globalPoint = QCursor::pos();
+        QPoint globalPoint;
         qt_mac_getTargetForMouseEvent(0, QEvent::None, localPoint, globalPoint, 0, &widgetUnderMouse);
     }
     qt_mac_updateCursorWithWidgetUnderMouse(widgetUnderMouse);
diff --git a/src/gui/kernel/qdesktopwidget_qpa_p.h b/src/gui/kernel/qdesktopwidget_qpa_p.h
index 47ccca2..abee8a1 100644
--- a/src/gui/kernel/qdesktopwidget_qpa_p.h
+++ b/src/gui/kernel/qdesktopwidget_qpa_p.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/kernel/qdesktopwidget_s60.cpp b/src/gui/kernel/qdesktopwidget_s60.cpp
index 3653ae2..62a4d40 100644
--- a/src/gui/kernel/qdesktopwidget_s60.cpp
+++ b/src/gui/kernel/qdesktopwidget_s60.cpp
@@ -44,36 +44,67 @@
 #include "qwidget_p.h"
 #include "qt_s60_p.h"
 #include <w32std.h>
-
-#include "hal.h"
-#include "hal_data.h"
+#if defined(Q_SYMBIAN_SUPPORTS_MULTIPLE_SCREENS)
+#include <graphics/displaycontrol.h>
+#endif
 
 QT_BEGIN_NAMESPACE
 
-class QDesktopWidgetPrivate : public QWidgetPrivate
+extern int qt_symbian_create_desktop_on_screen;
+
+class QSingleDesktopWidget : public QWidget
+{
+public:
+    QSingleDesktopWidget();
+    ~QSingleDesktopWidget();
+};
+
+QSingleDesktopWidget::QSingleDesktopWidget()
+    : QWidget(0, Qt::Desktop)
+{
+}
+
+QSingleDesktopWidget::~QSingleDesktopWidget()
 {
+    const QObjectList &childList = children();
+    for (int i = childList.size(); i > 0 ;) {
+        --i;
+        childList.at(i)->setParent(0);
+    }
+}
 
+class QDesktopWidgetPrivate : public QWidgetPrivate
+{
 public:
     QDesktopWidgetPrivate();
     ~QDesktopWidgetPrivate();
-
     static void init(QDesktopWidget *that);
     static void cleanup();
+    static void init_sys();
 
     static int screenCount;
     static int primaryScreen;
 
     static QVector<QRect> *rects;
     static QVector<QRect> *workrects;
+    static QVector<QWidget *> *screens;
 
     static int refcount;
+
+#if defined(Q_SYMBIAN_SUPPORTS_MULTIPLE_SCREENS)
+    static MDisplayControl *displayControl;
+#endif
 };
 
 int QDesktopWidgetPrivate::screenCount = 1;
 int QDesktopWidgetPrivate::primaryScreen = 0;
 QVector<QRect> *QDesktopWidgetPrivate::rects = 0;
 QVector<QRect> *QDesktopWidgetPrivate::workrects = 0;
+QVector<QWidget *> *QDesktopWidgetPrivate::screens = 0;
 int QDesktopWidgetPrivate::refcount = 0;
+#if defined(Q_SYMBIAN_SUPPORTS_MULTIPLE_SCREENS)
+MDisplayControl *QDesktopWidgetPrivate::displayControl = 0;
+#endif
 
 QDesktopWidgetPrivate::QDesktopWidgetPrivate()
 {
@@ -88,25 +119,55 @@ QDesktopWidgetPrivate::~QDesktopWidgetPrivate()
 
 void QDesktopWidgetPrivate::init(QDesktopWidget *that)
 {
-    Q_UNUSED(that);
-//    int screenCount=0;
-
-    // ### TODO: Implement proper multi-display support
-	QDesktopWidgetPrivate::screenCount = 1;
-//    if (HAL::Get(0, HALData::EDisplayNumberOfScreens, screenCount) == KErrNone)
-//        QDesktopWidgetPrivate::screenCount = screenCount;
-//    else
-//        QDesktopWidgetPrivate::screenCount = 0;
+    // Note that on S^3 devices the screen count retrieved via RWsSession
+    // will always be 2 but the width and height for screen number 1 will
+    // be 0 as long as TV-out is not connected.
+    //
+    // On the other hand a valid size for screen 1 will be reported even
+    // after the cable is disconnected. In order to overcome this, we use
+    // MDisplayControl::NumberOfResolutions() to check if the display is
+    // valid or not.
+
+    screenCount = S60->screenCount();
+#if defined(Q_SYMBIAN_SUPPORTS_MULTIPLE_SCREENS)
+    if (displayControl) {
+        if (displayControl->NumberOfResolutions() < 1)
+            screenCount = 1;
+    }
+#endif
+    if (screenCount < 1) {
+        qWarning("No screen available");
+        screenCount = 1;
+    }
 
     rects = new QVector<QRect>();
     workrects = new QVector<QRect>();
-
-    rects->resize(QDesktopWidgetPrivate::screenCount);
-    workrects->resize(QDesktopWidgetPrivate::screenCount);
-
-    (*rects)[0].setRect(0, 0, S60->screenWidthInPixels, S60->screenHeightInPixels);
-    QRect wr = qt_TRect2QRect(static_cast<CEikAppUi*>(S60->appUi())->ClientRect());
-    (*workrects)[0].setRect(wr.x(), wr.y(), wr.width(), wr.height());
+    screens = new QVector<QWidget *>();
+
+    rects->resize(screenCount);
+    workrects->resize(screenCount);
+    screens->resize(screenCount);
+
+    for (int i = 0; i < screenCount; ++i) {
+        // All screens will have a position of (0, 0) as there is no true virtual desktop
+        // or pointer event support for multiple screens on Symbian.
+        QRect r(0, 0,
+            S60->screenWidthInPixelsForScreen[i], S60->screenHeightInPixelsForScreen[i]);
+        // Stop here if empty and ignore this screen.
+        if (r.isEmpty()) {
+            screenCount = i;
+            break;
+        }
+        (*rects)[i] = r;
+        QRect wr;
+        if (i == 0)
+            wr = qt_TRect2QRect(static_cast<CEikAppUi*>(S60->appUi())->ClientRect());
+        else
+            wr = rects->at(i);
+        (*workrects)[i].setRect(wr.x(), wr.y(), wr.width(), wr.height());
+        (*screens)[i] = 0;
+    }
+    (*screens)[0] = that;
 }
 
 void QDesktopWidgetPrivate::cleanup()
@@ -115,6 +176,29 @@ void QDesktopWidgetPrivate::cleanup()
     rects = 0;
     delete workrects;
     workrects = 0;
+    if (screens) {
+        // First item is the QDesktopWidget so skip it.
+        for (int i = 1; i < screens->count(); ++i)
+            delete screens->at(i);
+    }
+    delete screens;
+    screens = 0;
+}
+
+void QDesktopWidgetPrivate::init_sys()
+{
+#if defined(Q_SYMBIAN_SUPPORTS_MULTIPLE_SCREENS)
+    if (S60->screenCount() > 1) {
+        CWsScreenDevice *dev = S60->screenDevice(1);
+        if (dev) {
+            displayControl = static_cast<MDisplayControl *>(
+                        dev->GetInterface(MDisplayControl::ETypeId));
+            if (displayControl) {
+                displayControl->EnableDisplayChangeEvents(ETrue);
+            }
+        }
+    }
+#endif
 }
 
 
@@ -122,6 +206,7 @@ QDesktopWidget::QDesktopWidget()
     : QWidget(*new QDesktopWidgetPrivate, 0, Qt::Desktop)
 {
     setObjectName(QLatin1String("desktop"));
+    QDesktopWidgetPrivate::init_sys();
     QDesktopWidgetPrivate::init(this);
 }
 
@@ -131,7 +216,7 @@ QDesktopWidget::~QDesktopWidget()
 
 bool QDesktopWidget::isVirtualDesktop() const
 {
-    return true;
+    return false;
 }
 
 int QDesktopWidget::primaryScreen() const
@@ -145,9 +230,23 @@ int QDesktopWidget::numScreens() const
     return QDesktopWidgetPrivate::screenCount;
 }
 
-QWidget *QDesktopWidget::screen(int /* screen */)
+static inline QWidget *newSingleDesktopWidget(int screen)
 {
-    return this;
+    qt_symbian_create_desktop_on_screen = screen;
+    QWidget *w = new QSingleDesktopWidget;
+    qt_symbian_create_desktop_on_screen = -1;
+    return w;
+}
+
+QWidget *QDesktopWidget::screen(int screen)
+{
+    Q_D(QDesktopWidget);
+    if (screen < 0 || screen >= d->screenCount)
+        screen = d->primaryScreen;
+    if (!d->screens->at(screen)
+        || d->screens->at(screen)->windowType() != Qt::Desktop)
+        (*d->screens)[screen] = newSingleDesktopWidget(screen);
+    return (*d->screens)[screen];
 }
 
 const QRect QDesktopWidget::availableGeometry(int screen) const
@@ -168,14 +267,19 @@ const QRect QDesktopWidget::screenGeometry(int screen) const
     return d->rects->at(screen);
 }
 
-int QDesktopWidget::screenNumber(const QWidget * /* widget */) const
+int QDesktopWidget::screenNumber(const QWidget *widget) const
 {
-    return QDesktopWidgetPrivate::primaryScreen;
+    Q_D(const QDesktopWidget);
+    return widget
+        ? S60->screenNumberForWidget(widget)
+        : d->primaryScreen;
 }
 
-int QDesktopWidget::screenNumber(const QPoint & /* point */) const
+int QDesktopWidget::screenNumber(const QPoint &point) const
 {
-    return QDesktopWidgetPrivate::primaryScreen;
+    Q_UNUSED(point);
+    Q_D(const QDesktopWidget);
+    return d->primaryScreen;
 }
 
 void QDesktopWidget::resizeEvent(QResizeEvent *)
@@ -203,6 +307,10 @@ void QDesktopWidget::resizeEvent(QResizeEvent *)
         if (oldrect != newrect)
             emit workAreaResized(j);
     }
+
+    if (oldscreencount != d->screenCount) {
+        emit screenCountChanged(d->screenCount);
+    }
 }
 
 QT_END_NAMESPACE
diff --git a/src/gui/kernel/qevent.cpp b/src/gui/kernel/qevent.cpp
index 698c94b..277a5e8 100644
--- a/src/gui/kernel/qevent.cpp
+++ b/src/gui/kernel/qevent.cpp
@@ -43,6 +43,7 @@
 #include "qcursor.h"
 #include "qapplication.h"
 #include "private/qapplication_p.h"
+#include "private/qevent_p.h"
 #include "private/qkeysequence_p.h"
 #include "qwidget.h"
 #include "qgraphicsview.h"
diff --git a/src/gui/kernel/qeventdispatcher_glib_qpa.cpp b/src/gui/kernel/qeventdispatcher_glib_qpa.cpp
index 01d40ca..603aa2d 100644
--- a/src/gui/kernel/qeventdispatcher_glib_qpa.cpp
+++ b/src/gui/kernel/qeventdispatcher_glib_qpa.cpp
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/kernel/qeventdispatcher_glib_qpa_p.h b/src/gui/kernel/qeventdispatcher_glib_qpa_p.h
index 1c32ab2..701f673 100644
--- a/src/gui/kernel/qeventdispatcher_glib_qpa_p.h
+++ b/src/gui/kernel/qeventdispatcher_glib_qpa_p.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/kernel/qeventdispatcher_mac.mm b/src/gui/kernel/qeventdispatcher_mac.mm
index 15410ad..677a736 100644
--- a/src/gui/kernel/qeventdispatcher_mac.mm
+++ b/src/gui/kernel/qeventdispatcher_mac.mm
@@ -561,6 +561,7 @@ bool QEventDispatcherMac::processEvents(QEventLoop::ProcessEventsFlags flags)
     wakeUp();
     emit awake();
 
+    bool excludeUserEvents = flags & QEventLoop::ExcludeUserInputEvents;
     bool retVal = false;
     forever {
         if (d->interrupt)
@@ -571,7 +572,7 @@ bool QEventDispatcherMac::processEvents(QEventLoop::ProcessEventsFlags flags)
         NSEvent* event = 0;
 
         // First, send all previously excluded input events, if any:
-        if (!(flags & QEventLoop::ExcludeUserInputEvents)) {
+        if (!excludeUserEvents) {
             while (!d->queuedUserInputEvents.isEmpty()) {
                 event = static_cast<NSEvent *>(d->queuedUserInputEvents.takeFirst());
                 if (!filterEvent(event)) {
@@ -586,12 +587,12 @@ bool QEventDispatcherMac::processEvents(QEventLoop::ProcessEventsFlags flags)
         // application, we should not run or stop NSApplication; This will be
         // done from the application itself. And if processEvents is called
         // manually (rather than from a QEventLoop), we cannot enter a tight
-        // loop and block this call, but instead we need to return after one flush:
+        // loop and block this call, but instead we need to return after one flush.
+        // Finally, if we are to exclude user input events, we cannot call [NSApp run]
+        // as we then loose control over which events gets dispatched:
         const bool canExec_3rdParty = d->nsAppRunCalledByQt || ![NSApp isRunning];
-        const bool canExec_Qt =
-                (flags & QEventLoop::DialogExec || flags & QEventLoop::EventLoopExec)
-                && !(flags & QEventLoop::ExcludeUserInputEvents);
-
+        const bool canExec_Qt = !excludeUserEvents &&
+                (flags & QEventLoop::DialogExec || flags & QEventLoop::EventLoopExec) ;
 
         if (canExec_Qt && canExec_3rdParty) {
             // We can use exec-mode, meaning that we can stay in a tight loop until
@@ -619,22 +620,46 @@ bool QEventDispatcherMac::processEvents(QEventLoop::ProcessEventsFlags flags)
             // Instead we will process all current pending events and return.
             d->ensureNSAppInitialized();
             if (NSModalSession session = d->currentModalSession()) {
-                if (flags & QEventLoop::WaitForMoreEvents)
-                    qt_mac_waitForMoreModalSessionEvents();
-                NSInteger status = [NSApp runModalSession:session];
-                if (status != NSRunContinuesResponse && session == d->currentModalSessionCached) {
-                    // INVARIANT: Someone called [NSApp stopModal:] from outside the event
-                    // dispatcher (e.g to stop a native dialog). But that call wrongly stopped
-                    // 'session' as well. As a result, we need to restart all internal sessions:
-                    d->temporarilyStopAllModalSessions();
-                }
-                retVal = true;
-            } else do {
-                event = [NSApp nextEventMatchingMask:NSAnyEventMask
+                // INVARIANT: a modal window is executing.
+                if (!excludeUserEvents) {
+                    // Since we can dispatch all kinds of events, we choose
+                    // to use cocoa's native way of running modal sessions:
+                    if (flags & QEventLoop::WaitForMoreEvents)
+                        qt_mac_waitForMoreModalSessionEvents();
+                    NSInteger status = [NSApp runModalSession:session];
+                    if (status != NSRunContinuesResponse && session == d->currentModalSessionCached) {
+                        // INVARIANT: Someone called [NSApp stopModal:] from outside the event
+                        // dispatcher (e.g to stop a native dialog). But that call wrongly stopped
+                        // 'session' as well. As a result, we need to restart all internal sessions:
+                        d->temporarilyStopAllModalSessions();
+                    }
+                    retVal = true;
+                } else do {
+                    // Dispatch all non-user events (but que non-user events up for later). In
+                    // this case, we need more control over which events gets dispatched, and
+                    // cannot use [NSApp runModalSession:session]:
+                    event = [NSApp nextEventMatchingMask:NSAnyEventMask
                     untilDate:nil
-                    inMode:NSDefaultRunLoopMode
+                    inMode:NSModalPanelRunLoopMode
                     dequeue: YES];
 
+                    if (event) {
+                        if (IsMouseOrKeyEvent(event)) {
+                            [event retain];
+                            d->queuedUserInputEvents.append(event);
+                            continue;
+                        }
+                        if (!filterEvent(event) && qt_mac_send_event(flags, event, 0))
+                            retVal = true;
+                    }
+                } while (!d->interrupt && event != nil);
+            } else do {
+                // INVARIANT: No modal window is executing.
+                event = [NSApp nextEventMatchingMask:NSAnyEventMask
+                untilDate:nil
+                inMode:NSDefaultRunLoopMode
+                dequeue: YES];
+
                 if (event) {
                     if (flags & QEventLoop::ExcludeUserInputEvents) {
                         if (IsMouseOrKeyEvent(event)) {
@@ -648,6 +673,11 @@ bool QEventDispatcherMac::processEvents(QEventLoop::ProcessEventsFlags flags)
                 }
             } while (!d->interrupt && event != nil);
 
+            // Be sure to flush the Qt posted events when not using exec mode
+            // (exec mode will always do this call from the event loop source):
+            if (!d->interrupt)
+                QCoreApplicationPrivate::sendPostedEvents(0, 0, d->threadData);
+
             // Since the window that holds modality might have changed while processing
             // events, we we need to interrupt when we return back the previous process
             // event recursion to ensure that we spin the correct modal session.
diff --git a/src/gui/kernel/qeventdispatcher_qpa.cpp b/src/gui/kernel/qeventdispatcher_qpa.cpp
index 519d2a6..de53618 100644
--- a/src/gui/kernel/qeventdispatcher_qpa.cpp
+++ b/src/gui/kernel/qeventdispatcher_qpa.cpp
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
@@ -172,7 +172,6 @@ public:
     {
         if (qApp && (qApp->thread() == QThread::currentThread())) {
             m_isEventLoopIntegrationRunning = true;
-            QCoreApplication::processEvents(QEventLoop::WaitForMoreEvents);
             eventLoopIntegration->startEventLoop();
         }
     }
diff --git a/src/gui/kernel/qeventdispatcher_qpa_p.h b/src/gui/kernel/qeventdispatcher_qpa_p.h
index 8065c3e..d4d2be1 100644
--- a/src/gui/kernel/qeventdispatcher_qpa_p.h
+++ b/src/gui/kernel/qeventdispatcher_qpa_p.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/kernel/qplatformclipboard_qpa.cpp b/src/gui/kernel/qplatformclipboard_qpa.cpp
index fff4e19..957a4df 100644
--- a/src/gui/kernel/qplatformclipboard_qpa.cpp
+++ b/src/gui/kernel/qplatformclipboard_qpa.cpp
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
@@ -40,6 +40,8 @@
 ****************************************************************************/
 #include "qplatformclipboard_qpa.h"
 
+#ifndef QT_NO_CLIPBOARD
+
 QT_BEGIN_NAMESPACE
 
 class QClipboardData
@@ -99,3 +101,5 @@ bool QPlatformClipboard::supportsMode(QClipboard::Mode mode) const
 }
 
 QT_END_NAMESPACE
+
+#endif //QT_NO_CLIPBOARD
diff --git a/src/gui/kernel/qplatformclipboard_qpa.h b/src/gui/kernel/qplatformclipboard_qpa.h
index 3f7bfbb..3381c06 100644
--- a/src/gui/kernel/qplatformclipboard_qpa.h
+++ b/src/gui/kernel/qplatformclipboard_qpa.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
@@ -44,6 +44,8 @@
 
 #include <qplatformdefs.h>
 
+#ifndef QT_NO_CLIPBOARD
+
 #include <QtGui/QClipboard>
 
 QT_BEGIN_HEADER
@@ -66,5 +68,6 @@ QT_END_NAMESPACE
 
 QT_END_HEADER
 
+#endif // QT_NO_CLIPBOARD
 
 #endif //QPLATFORMCLIPBOARD_QPA_H
diff --git a/src/gui/kernel/qplatformcursor_qpa.cpp b/src/gui/kernel/qplatformcursor_qpa.cpp
index ac557b9..2ea8332 100644
--- a/src/gui/kernel/qplatformcursor_qpa.cpp
+++ b/src/gui/kernel/qplatformcursor_qpa.cpp
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/kernel/qplatformeventloopintegration_qpa.cpp b/src/gui/kernel/qplatformeventloopintegration_qpa.cpp
index fdb3852..0ed43eb 100644
--- a/src/gui/kernel/qplatformeventloopintegration_qpa.cpp
+++ b/src/gui/kernel/qplatformeventloopintegration_qpa.cpp
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/kernel/qplatformeventloopintegration_qpa.h b/src/gui/kernel/qplatformeventloopintegration_qpa.h
index 6e0f984..87df7ae 100644
--- a/src/gui/kernel/qplatformeventloopintegration_qpa.h
+++ b/src/gui/kernel/qplatformeventloopintegration_qpa.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/kernel/qplatformglcontext_qpa.cpp b/src/gui/kernel/qplatformglcontext_qpa.cpp
index 1673aed..86740e8 100644
--- a/src/gui/kernel/qplatformglcontext_qpa.cpp
+++ b/src/gui/kernel/qplatformglcontext_qpa.cpp
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/kernel/qplatformglcontext_qpa.h b/src/gui/kernel/qplatformglcontext_qpa.h
index 807ed3d..a680c85 100644
--- a/src/gui/kernel/qplatformglcontext_qpa.h
+++ b/src/gui/kernel/qplatformglcontext_qpa.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/kernel/qplatformintegration_qpa.cpp b/src/gui/kernel/qplatformintegration_qpa.cpp
index 0cac57d..c45a953 100644
--- a/src/gui/kernel/qplatformintegration_qpa.cpp
+++ b/src/gui/kernel/qplatformintegration_qpa.cpp
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
@@ -102,6 +102,9 @@ QPlatformFontDatabase *QPlatformIntegration::fontDatabase() const
     \sa QPlatformClipboard
 
 */
+
+#ifndef QT_NO_CLIPBOARD
+
 QPlatformClipboard *QPlatformIntegration::clipboard() const
 {
     static QPlatformClipboard *clipboard = 0;
@@ -111,6 +114,13 @@ QPlatformClipboard *QPlatformIntegration::clipboard() const
     return clipboard;
 }
 
+#endif
+
+QPlatformNativeInterface * QPlatformIntegration::nativeInterface() const
+{
+    return 0;
+}
+
 /*!
     \class QPlatformIntegration
     \since 4.8
@@ -211,4 +221,14 @@ QPlatformClipboard *QPlatformIntegration::clipboard() const
     QRect(x,y,width,height).
 */
 
+
+bool QPlatformIntegration::hasCapability(Capability cap) const
+{
+    return false;
+}
+
+
+
+
+
 QT_END_NAMESPACE
diff --git a/src/gui/kernel/qplatformintegration_qpa.h b/src/gui/kernel/qplatformintegration_qpa.h
index 7050245..0aacefa 100644
--- a/src/gui/kernel/qplatformintegration_qpa.h
+++ b/src/gui/kernel/qplatformintegration_qpa.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
@@ -60,12 +60,19 @@ class QWidget;
 class QPlatformEventLoopIntegration;
 class QPlatformFontDatabase;
 class QPlatformClipboard;
+class QPlatformNativeInterface;
 
 class Q_GUI_EXPORT QPlatformIntegration
 {
 public:
+    enum Capability {
+        ThreadedPixmaps = 1,
+    };
+
     virtual ~QPlatformIntegration() { }
 
+    virtual bool hasCapability(Capability cap) const;
+
 // GraphicsSystem functions
     virtual QPixmapData *createPixmapData(QPixmapData::PixelType type) const = 0;
     virtual QPlatformWindow *createPlatformWindow(QWidget *widget, WId winId = 0) const = 0;
@@ -79,7 +86,9 @@ public:
 
 //Deeper window system integrations
     virtual QPlatformFontDatabase *fontDatabase() const;
+#ifndef QT_NO_CLIPBOARD
     virtual QPlatformClipboard *clipboard() const;
+#endif
 
 // Experimental in mainthread eventloop integration
 // This should only be used if it is only possible to do window system event processing in
@@ -89,7 +98,8 @@ public:
 //jl:XXX should it be hasGLContext and do we need it at all?
     virtual bool hasOpenGL() const;
 
-
+// Access native handles. The window handle is already available from Wid;
+    virtual QPlatformNativeInterface *nativeInterface() const;
 };
 
 QT_END_NAMESPACE
diff --git a/src/gui/kernel/qplatformintegrationfactory_qpa.cpp b/src/gui/kernel/qplatformintegrationfactory_qpa.cpp
index 17a130d..4135c9e 100644
--- a/src/gui/kernel/qplatformintegrationfactory_qpa.cpp
+++ b/src/gui/kernel/qplatformintegrationfactory_qpa.cpp
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/kernel/qplatformintegrationfactory_qpa_p.h b/src/gui/kernel/qplatformintegrationfactory_qpa_p.h
index 77e1da1..a6042a8 100644
--- a/src/gui/kernel/qplatformintegrationfactory_qpa_p.h
+++ b/src/gui/kernel/qplatformintegrationfactory_qpa_p.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/kernel/qplatformintegrationplugin_qpa.cpp b/src/gui/kernel/qplatformintegrationplugin_qpa.cpp
index 3bf2474..62920b6 100644
--- a/src/gui/kernel/qplatformintegrationplugin_qpa.cpp
+++ b/src/gui/kernel/qplatformintegrationplugin_qpa.cpp
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/kernel/qplatformintegrationplugin_qpa.h b/src/gui/kernel/qplatformintegrationplugin_qpa.h
index 9c37cf7..17bcba0 100644
--- a/src/gui/kernel/qplatformintegrationplugin_qpa.h
+++ b/src/gui/kernel/qplatformintegrationplugin_qpa.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/kernel/qplatformnativeinterface_qpa.cpp b/src/gui/kernel/qplatformnativeinterface_qpa.cpp
new file mode 100644
index 0000000..ace4a7b
--- /dev/null
+++ b/src/gui/kernel/qplatformnativeinterface_qpa.cpp
@@ -0,0 +1,53 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qplatformnativeinterface_qpa.h"
+
+QT_BEGIN_NAMESPACE
+
+void *QPlatformNativeInterface::nativeResourceForWidget(const QByteArray &resource, QWidget *widget)
+{
+    Q_UNUSED(resource);
+    Q_UNUSED(widget);
+    return 0;
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/kernel/qplatformnativeinterface_qpa.h b/src/gui/kernel/qplatformnativeinterface_qpa.h
new file mode 100644
index 0000000..5ea2c13
--- /dev/null
+++ b/src/gui/kernel/qplatformnativeinterface_qpa.h
@@ -0,0 +1,65 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPLATFORMNATIVEINTERFACE_QPA_H
+#define QPLATFORMNATIVEINTERFACE_QPA_H
+
+#include <QtGui/qwindowdefs.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+class QWidget;
+
+class Q_GUI_EXPORT QPlatformNativeInterface
+{
+public:
+    virtual void *nativeResourceForWidget(const QByteArray &resource, QWidget *widget);
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QPLATFORMNATIVEINTERFACE_QPA_H
diff --git a/src/gui/kernel/qplatformscreen_qpa.cpp b/src/gui/kernel/qplatformscreen_qpa.cpp
index 118835f..c9f3dc6 100644
--- a/src/gui/kernel/qplatformscreen_qpa.cpp
+++ b/src/gui/kernel/qplatformscreen_qpa.cpp
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/kernel/qplatformscreen_qpa.h b/src/gui/kernel/qplatformscreen_qpa.h
index 1f52764..b3bb121 100644
--- a/src/gui/kernel/qplatformscreen_qpa.h
+++ b/src/gui/kernel/qplatformscreen_qpa.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/kernel/qplatformwindow_qpa.cpp b/src/gui/kernel/qplatformwindow_qpa.cpp
index b6b6693..19bf7a9 100644
--- a/src/gui/kernel/qplatformwindow_qpa.cpp
+++ b/src/gui/kernel/qplatformwindow_qpa.cpp
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/kernel/qplatformwindow_qpa.h b/src/gui/kernel/qplatformwindow_qpa.h
index abc35d1..41a4bac 100644
--- a/src/gui/kernel/qplatformwindow_qpa.h
+++ b/src/gui/kernel/qplatformwindow_qpa.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/kernel/qplatformwindowformat_qpa.cpp b/src/gui/kernel/qplatformwindowformat_qpa.cpp
index 44b0698..ddc6239 100644
--- a/src/gui/kernel/qplatformwindowformat_qpa.cpp
+++ b/src/gui/kernel/qplatformwindowformat_qpa.cpp
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/kernel/qplatformwindowformat_qpa.h b/src/gui/kernel/qplatformwindowformat_qpa.h
index 790385b..fa01a8a 100644
--- a/src/gui/kernel/qplatformwindowformat_qpa.h
+++ b/src/gui/kernel/qplatformwindowformat_qpa.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/kernel/qt_cocoa_helpers_mac.mm b/src/gui/kernel/qt_cocoa_helpers_mac.mm
index 98f62ca..f4a1ea5 100644
--- a/src/gui/kernel/qt_cocoa_helpers_mac.mm
+++ b/src/gui/kernel/qt_cocoa_helpers_mac.mm
@@ -184,7 +184,7 @@ struct dndenum_mapper
     bool Qt2Mac;
 };
 
-#ifdef QT_MAC_USE_COCOA && __OBJC__
+#if defined(QT_MAC_USE_COCOA) && defined(__OBJC__)
 
 static dndenum_mapper dnd_enums[] = {
     { NSDragOperationLink,  Qt::LinkAction, true },
@@ -1048,7 +1048,6 @@ QWidget *qt_mac_getTargetForKeyEvent(QWidget *widgetThatReceivedEvent)
 // events
 QWidget *qt_mac_getTargetForMouseEvent(
     // You can call this function without providing an event.
-    // If so, set returnGlobalPoint before the call.
     NSEvent *event,
     QEvent::Type eventType,
     QPoint &returnLocalPoint,
@@ -1057,7 +1056,8 @@ QWidget *qt_mac_getTargetForMouseEvent(
     QWidget **returnWidgetUnderMouse)
 {
     Q_UNUSED(event);
-    returnGlobalPoint = flipPoint([NSEvent mouseLocation]).toPoint();
+    NSPoint nsglobalpoint = event ? [[event window] convertBaseToScreen:[event locationInWindow]] : [NSEvent mouseLocation];
+    returnGlobalPoint = flipPoint(nsglobalpoint).toPoint();
     QWidget *mouseGrabber = QWidget::mouseGrabber();
     bool buttonDownNotBlockedByModal = qt_button_down && !QApplicationPrivate::isBlockedByModal(qt_button_down);
     QWidget *popup = QApplication::activePopupWidget();
diff --git a/src/gui/kernel/qt_s60_p.h b/src/gui/kernel/qt_s60_p.h
index 40697bf..3bb27c3 100644
--- a/src/gui/kernel/qt_s60_p.h
+++ b/src/gui/kernel/qt_s60_p.h
@@ -64,6 +64,7 @@
 #include "qapplication.h"
 #include "qelapsedtimer.h"
 #include "QtCore/qthreadstorage.h"
+#include "qwidget_p.h"
 #include <w32std.h>
 #include <coecntrl.h>
 #include <eikenv.h>
@@ -84,6 +85,8 @@ QT_BEGIN_NAMESPACE
 // system events seems to start with 0x10
 const TInt KInternalStatusPaneChange = 0x50000000;
 
+static const int qt_symbian_max_screens = 4;
+
 //this macro exists because EColor16MAP enum value doesn't exist in Symbian OS 9.2
 #define Q_SYMBIAN_ECOLOR16MAP TDisplayMode(13)
 
@@ -142,7 +145,10 @@ public:
     int avkonComponentsSupportTransparency : 1;
     int menuBeingConstructed : 1;
     int orientationSet : 1;
+    int partial_keyboard : 1;
     QApplication::QS60MainApplicationFactory s60ApplicationFactory; // typedef'ed pointer type
+    QPointer<QWidget> splitViewLastWidget;
+
     static CEikButtonGroupContainer *cba;
 
     enum ScanCodeState {
@@ -154,8 +160,14 @@ public:
 
     static inline void updateScreenSize();
     inline RWsSession& wsSession();
+    static inline int screenCount();
     static inline RWindowGroup& windowGroup();
+    static inline RWindowGroup& windowGroup(const QWidget *widget);
+    static inline RWindowGroup& windowGroup(int screenNumber);
     inline CWsScreenDevice* screenDevice();
+    inline CWsScreenDevice* screenDevice(const QWidget *widget);
+    inline CWsScreenDevice* screenDevice(int screenNumber);
+    static inline int screenNumberForWidget(const QWidget *widget);
     static inline CCoeAppUi* appUi();
     static inline CEikMenuBar* menuBar();
 #ifdef Q_WS_S60
@@ -172,6 +184,11 @@ public:
 #ifdef Q_OS_SYMBIAN
     TTrapHandler *s60InstalledTrapHandler;
 #endif
+
+    int screenWidthInPixelsForScreen[qt_symbian_max_screens];
+    int screenHeightInPixelsForScreen[qt_symbian_max_screens];
+    int screenWidthInTwipsForScreen[qt_symbian_max_screens];
+    int screenHeightInTwipsForScreen[qt_symbian_max_screens];
 };
 
 Q_AUTOTEST_EXPORT QS60Data* qGlobalS60Data();
@@ -252,6 +269,7 @@ private:
 #ifdef QT_SYMBIAN_SUPPORTS_ADVANCED_POINTER
     void translateAdvancedPointerEvent(const TAdvancedPointerEvent *event);
 #endif
+    bool isSplitViewWidget(QWidget *widget);
 
 public:
     void handleClientAreaChange();
@@ -270,6 +288,8 @@ private:
     // Fader object used to fade everything except this menu and the CBA.
     TAknPopupFader popupFader;
 #endif
+
+    bool m_inExternalScreenOverride : 1;
 };
 
 inline QS60Data::QS60Data()
@@ -297,6 +317,7 @@ inline QS60Data::QS60Data()
   avkonComponentsSupportTransparency(0),
   menuBeingConstructed(0),
   orientationSet(0),
+  partial_keyboard(0),
   s60ApplicationFactory(0)
 #ifdef Q_OS_SYMBIAN
   ,s60InstalledTrapHandler(0)
@@ -320,6 +341,17 @@ inline void QS60Data::updateScreenSize()
     S60->defaultDpiY = S60->screenHeightInPixels / inches;
     inches = S60->screenWidthInTwips / (TReal)KTwipsPerInch;
     S60->defaultDpiX = S60->screenWidthInPixels / inches;
+
+    int screens = S60->screenCount();
+    for (int i = 0; i < screens; ++i) {
+        CWsScreenDevice *dev = S60->screenDevice(i);
+        mode = dev->CurrentScreenMode();
+        dev->GetScreenModeSizeAndRotation(mode, params);
+        S60->screenWidthInPixelsForScreen[i] = params.iPixelSize.iWidth;
+        S60->screenHeightInPixelsForScreen[i] = params.iPixelSize.iHeight;
+        S60->screenWidthInTwipsForScreen[i] = params.iTwipsSize.iWidth;
+        S60->screenHeightInTwipsForScreen[i] = params.iTwipsSize.iHeight;
+    }
 }
 
 inline RWsSession& QS60Data::wsSession()
@@ -330,11 +362,38 @@ inline RWsSession& QS60Data::wsSession()
     return tls.localData()->wsSession;
 }
 
+inline int QS60Data::screenCount()
+{
+#if defined(Q_SYMBIAN_SUPPORTS_MULTIPLE_SCREENS)
+    CCoeEnv *env = CCoeEnv::Static();
+    if (env) {
+        return qMin(env->WsSession().NumberOfScreens(), qt_symbian_max_screens);
+    }
+#endif
+    return 1;
+}
+
 inline RWindowGroup& QS60Data::windowGroup()
 {
     return CCoeEnv::Static()->RootWin();
 }
 
+inline RWindowGroup& QS60Data::windowGroup(const QWidget *widget)
+{
+    return windowGroup(screenNumberForWidget(widget));
+}
+
+inline RWindowGroup& QS60Data::windowGroup(int screenNumber)
+{
+#if defined(Q_SYMBIAN_SUPPORTS_MULTIPLE_SCREENS)
+    RWindowGroup *wg = CCoeEnv::Static()->RootWin(screenNumber);
+    return wg ? *wg : windowGroup();
+#else
+    Q_UNUSED(screenNumber);
+    return windowGroup();
+#endif
+}
+
 inline CWsScreenDevice* QS60Data::screenDevice()
 {
     if(!tls.hasLocalData()) {
@@ -343,6 +402,36 @@ inline CWsScreenDevice* QS60Data::screenDevice()
     return tls.localData()->screenDevice;
 }
 
+inline CWsScreenDevice* QS60Data::screenDevice(const QWidget *widget)
+{
+    return screenDevice(screenNumberForWidget(widget));
+}
+
+inline CWsScreenDevice* QS60Data::screenDevice(int screenNumber)
+{
+#if defined(Q_SYMBIAN_SUPPORTS_MULTIPLE_SCREENS)
+    CCoeEnv *env = CCoeEnv::Static();
+    if (env) {
+        CWsScreenDevice *dev = env->ScreenDevice(screenNumber);
+        return dev ? dev : screenDevice();
+    } else {
+        return screenDevice();
+    }
+#else
+    return screenDevice();
+#endif
+}
+
+inline int QS60Data::screenNumberForWidget(const QWidget *widget)
+{
+    if (!widget)
+        return 0;
+    const QWidget *w = widget;
+    while (w->parentWidget())
+        w = w->parentWidget();
+    return qt_widget_private(const_cast<QWidget *>(w))->symbianScreenNumber;
+}
+
 inline CCoeAppUi* QS60Data::appUi()
 {
     return CCoeEnv::Static()-> AppUi();
diff --git a/src/gui/kernel/qwidget.cpp b/src/gui/kernel/qwidget.cpp
index bf9f6f9..adb5fe1 100644
--- a/src/gui/kernel/qwidget.cpp
+++ b/src/gui/kernel/qwidget.cpp
@@ -310,6 +310,8 @@ QWidgetPrivate::QWidgetPrivate(int version)
       , needWindowChange(0)
       , window_event(0)
       , qd_hd(0)
+#elif defined(Q_OS_SYMBIAN)
+      , symbianScreenNumber(0)
 #endif
 {
     if (!qApp) {
@@ -1294,6 +1296,10 @@ void QWidgetPrivate::init(QWidget *parentWidget, Qt::WindowFlags f)
         // programmer specified desktop widget
         xinfo = desktopWidget->d_func()->xinfo;
     }
+#elif defined(Q_OS_SYMBIAN)
+    if (desktopWidget) {
+        symbianScreenNumber = qt_widget_private(desktopWidget)->symbianScreenNumber;
+    }
 #elif defined(Q_WS_QPA)
     if (desktopWidget) {
         int screen = desktopWidget->d_func()->topData()->screenIndex;
@@ -1336,8 +1342,8 @@ void QWidgetPrivate::init(QWidget *parentWidget, Qt::WindowFlags f)
     //give potential windows a bigger "pre-initial" size; create_sys() will give them a new size later
 #ifdef Q_OS_SYMBIAN
     if (isGLWidget) {
-        // Don't waste GPU mem for unnecessary large egl surface
-        data.crect = QRect(0,0,2,2);
+        // Don't waste GPU mem for unnecessary large egl surface until resized by application
+        data.crect = QRect(0,0,1,1);
     } else {
         data.crect = parentWidget ? QRect(0,0,100,30) : QRect(0,0,360,640);
     }
diff --git a/src/gui/kernel/qwidget_mac.mm b/src/gui/kernel/qwidget_mac.mm
index 9a5a5f1..34918e4 100644
--- a/src/gui/kernel/qwidget_mac.mm
+++ b/src/gui/kernel/qwidget_mac.mm
@@ -2476,6 +2476,8 @@ void QWidgetPrivate::createWindow_sys()
 void QWidgetPrivate::create_sys(WId window, bool initializeWindow, bool destroyOldWindow)
 {
     Q_Q(QWidget);
+    QMacCocoaAutoReleasePool pool;
+
     OSViewRef destroyid = 0;
 #ifndef QT_MAC_USE_COCOA
     window_event = 0;
@@ -3239,6 +3241,8 @@ void QWidgetPrivate::setWindowIcon_sys(bool forceReset)
             ReleaseIconRef(previousIcon);
 #else
         QMacCocoaAutoReleasePool pool;
+        if (icon.isNull())
+            return;
         NSButton *iconButton = [qt_mac_window_for(q) standardWindowButton:NSWindowDocumentIconButton];
         if (iconButton == nil) {
             QCFString string(q->windowTitle());
@@ -4421,6 +4425,8 @@ void QWidgetPrivate::adjustWithinMaxAndMinSize(int &w, int &h)
 void QWidgetPrivate::applyMaxAndMinSizeOnWindow()
 {
     Q_Q(QWidget);
+    QMacCocoaAutoReleasePool pool;
+
     const float max_f(20000);
 #ifndef QT_MAC_USE_COCOA
 #define SF(x) ((x > max_f) ? max_f : x)
diff --git a/src/gui/kernel/qwidget_p.h b/src/gui/kernel/qwidget_p.h
index 1083a1f..dd9bb49 100644
--- a/src/gui/kernel/qwidget_p.h
+++ b/src/gui/kernel/qwidget_p.h
@@ -900,6 +900,7 @@ public:
 #elif defined(Q_OS_SYMBIAN) // <--------------------------------------------------------- SYMBIAN
     static QWidget *mouseGrabber;
     static QWidget *keyboardGrabber;
+    int symbianScreenNumber; // only valid for desktop widget and top-levels
     void s60UpdateIsOpaque();
     void reparentChildren();
     void registerTouchWindow();
diff --git a/src/gui/kernel/qwidget_s60.cpp b/src/gui/kernel/qwidget_s60.cpp
index 85164d2..16f28c7 100644
--- a/src/gui/kernel/qwidget_s60.cpp
+++ b/src/gui/kernel/qwidget_s60.cpp
@@ -84,6 +84,8 @@ QWidget *QWidgetPrivate::mouseGrabber = 0;
 QWidget *QWidgetPrivate::keyboardGrabber = 0;
 CEikButtonGroupContainer *QS60Data::cba = 0;
 
+int qt_symbian_create_desktop_on_screen = -1;
+
 static bool isEqual(const QList<QAction*>& a, const QList<QAction*>& b)
 {
     if ( a.count() != b.count())
@@ -349,12 +351,18 @@ void QWidgetPrivate::create_sys(WId window, bool /* initializeWindow */, bool de
     int sh = clientRect.Height();
 
     if (desktop) {
-        TSize screenSize = S60->screenDevice()->SizeInPixels();
+        symbianScreenNumber = qMax(qt_symbian_create_desktop_on_screen, 0);
+        TSize screenSize = S60->screenDevice(symbianScreenNumber)->SizeInPixels();
         data.crect.setRect(0, 0, screenSize.iWidth, screenSize.iHeight);
         q->setAttribute(Qt::WA_DontShowOnScreen);
     } else if (topLevel && !q->testAttribute(Qt::WA_Resized)){
         int width = sw;
         int height = sh;
+        if (symbianScreenNumber > 0) {
+            TSize screenSize = S60->screenDevice(symbianScreenNumber)->SizeInPixels();
+            width = screenSize.iWidth;
+            height = screenSize.iHeight;
+        }
         if (extra) {
             width = qMax(qMin(width, extra->maxw), extra->minw);
             height = qMax(qMin(height, extra->maxh), extra->minh);
@@ -644,7 +652,7 @@ void QWidgetPrivate::raise_sys()
 
         // If toplevel widget, raise app to foreground
         if (q->isWindow())
-            S60->wsSession().SetWindowGroupOrdinalPosition(S60->windowGroup().Identifier(), 0);
+            S60->wsSession().SetWindowGroupOrdinalPosition(S60->windowGroup(q).Identifier(), 0);
     }
 }
 
@@ -656,7 +664,7 @@ void QWidgetPrivate::lower_sys()
     if (q->internalWinId()) {
         // If toplevel widget, lower app to background
         if (q->isWindow())
-            S60->wsSession().SetWindowGroupOrdinalPosition(S60->windowGroup().Identifier(), -1);
+            S60->wsSession().SetWindowGroupOrdinalPosition(S60->windowGroup(q).Identifier(), -1);
         else
             q->internalWinId()->DrawableWindow()->SetOrdinalPosition(-1);
     }
@@ -726,6 +734,11 @@ void QWidgetPrivate::setParent_sys(QWidget *parent, Qt::WindowFlags f)
 {
     Q_Q(QWidget);
 
+    if (parent && parent->windowType() == Qt::Desktop) {
+        symbianScreenNumber = qt_widget_private(parent)->symbianScreenNumber;
+        parent = 0;
+    }
+
     bool wasCreated = q->testAttribute(Qt::WA_WState_Created);
 
     if (q->isVisible() && q->parentWidget() && parent != q->parentWidget())
@@ -804,17 +817,21 @@ void QWidgetPrivate::s60UpdateIsOpaque()
     RWindow *const window = static_cast<RWindow *>(q->effectiveWinId()->DrawableWindow());
 
 #ifdef Q_SYMBIAN_SEMITRANSPARENT_BG_SURFACE
-    window->SetSurfaceTransparency(!isOpaque);
-    extra->topextra->nativeWindowTransparencyEnabled = !isOpaque;
-#else
+    if (QApplicationPrivate::instance()->useTranslucentEGLSurfaces) {
+        window->SetSurfaceTransparency(!isOpaque);
+        extra->topextra->nativeWindowTransparencyEnabled = !isOpaque;
+        return;
+    }
+#endif
     if (!isOpaque) {
         const TDisplayMode displayMode = static_cast<TDisplayMode>(window->SetRequiredDisplayMode(EColor16MA));
         if (window->SetTransparencyAlphaChannel() == KErrNone) {
             window->SetBackgroundColor(TRgb(255, 255, 255, 0));
             extra->topextra->nativeWindowTransparencyEnabled = 1;
 
-            if (extra->topextra->backingStore.data() &&
-                    QApplicationPrivate::graphics_system_name == QLatin1String("openvg")) {
+            if (extra->topextra->backingStore.data() && (
+                    QApplicationPrivate::graphics_system_name == QLatin1String("openvg")
+                    || QApplicationPrivate::graphics_system_name == QLatin1String("opengl"))) {
                 // Semi-transparent EGL surfaces aren't supported. We need to
                 // recreate backing store to get translucent surface (raster surface).
                 extra->topextra->backingStore.create(q);
@@ -825,7 +842,6 @@ void QWidgetPrivate::s60UpdateIsOpaque()
         window->SetTransparentRegion(TRegionFix<1>());
         extra->topextra->nativeWindowTransparencyEnabled = 0;
     }
-#endif
 }
 
 void QWidgetPrivate::setWindowIcon_sys(bool forceReset)
@@ -1041,7 +1057,7 @@ int QWidget::metric(PaintDeviceMetric m) const
     } else if (m == PdmHeight) {
         val = data->crect.height();
     } else {
-        CWsScreenDevice *scr = S60->screenDevice();
+        CWsScreenDevice *scr = S60->screenDevice(this);
         switch(m) {
         case PdmDpiX:
         case PdmPhysicalDpiX:
@@ -1211,7 +1227,16 @@ void QWidget::setWindowState(Qt::WindowStates newstate)
         const bool cbaVisibilityHint = windowFlags() & Qt::WindowSoftkeysVisibleHint;
         if (newstate & Qt::WindowFullScreen && !cbaVisibilityHint) {
             setAttribute(Qt::WA_OutsideWSRange, false);
-            window->SetExtentToWholeScreen();
+            if (d->symbianScreenNumber > 0) {
+                int w = S60->screenWidthInPixelsForScreen[d->symbianScreenNumber];
+                int h = S60->screenHeightInPixelsForScreen[d->symbianScreenNumber];
+                if (w <= 0 || h <= 0)
+                    window->SetExtentToWholeScreen();
+                else
+                    window->SetExtent(TPoint(0, 0), TSize(w, h));
+            } else {
+                window->SetExtentToWholeScreen();
+            }
         } else if (newstate & Qt::WindowMaximized || ((newstate & Qt::WindowFullScreen) && cbaVisibilityHint)) {
             setAttribute(Qt::WA_OutsideWSRange, false);
             TRect maxExtent = qt_QRect2TRect(qApp->desktop()->availableGeometry(this));
diff --git a/src/gui/kernel/qwidget_x11.cpp b/src/gui/kernel/qwidget_x11.cpp
index c6753fc..4f39443 100644
--- a/src/gui/kernel/qwidget_x11.cpp
+++ b/src/gui/kernel/qwidget_x11.cpp
@@ -1333,12 +1333,40 @@ QPoint QWidgetPrivate::mapFromGlobal(const QPoint &pos) const
 QPoint QWidget::mapToGlobal(const QPoint &pos) const
 {
     Q_D(const QWidget);
+    QPoint offset = data->crect.topLeft();
+    const QWidget *w = this;
+    const QWidget *p = w->parentWidget();
+    while (!w->isWindow() && p) {
+        w = p;
+        p = p->parentWidget();
+        offset += w->data->crect.topLeft();
+    }
+
+    const QWidgetPrivate *wd = w->d_func();
+    QTLWExtra *tlw = wd->topData();
+    if (!tlw->embedded)
+        return pos + offset;
+
     return d->mapToGlobal(pos);
 }
 
 QPoint QWidget::mapFromGlobal(const QPoint &pos) const
 {
     Q_D(const QWidget);
+    QPoint offset = data->crect.topLeft();
+    const QWidget *w = this;
+    const QWidget *p = w->parentWidget();
+    while (!w->isWindow() && p) {
+        w = p;
+        p = p->parentWidget();
+        offset += w->data->crect.topLeft();
+    }
+
+    const QWidgetPrivate *wd = w->d_func();
+    QTLWExtra *tlw = wd->topData();
+    if (!tlw->embedded)
+        return pos - offset;
+
     return d->mapFromGlobal(pos);
 }
 
diff --git a/src/gui/kernel/qwindowsysteminterface_qpa.cpp b/src/gui/kernel/qwindowsysteminterface_qpa.cpp
index b6177b0..740bb82 100644
--- a/src/gui/kernel/qwindowsysteminterface_qpa.cpp
+++ b/src/gui/kernel/qwindowsysteminterface_qpa.cpp
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
@@ -150,6 +150,36 @@ void QWindowSystemInterface::handleKeyEvent(QWidget *tlw, ulong timestamp, QEven
     QWindowSystemInterfacePrivate::queueWindowSystemEvent(e);
 }
 
+void QWindowSystemInterface::handleExtendedKeyEvent(QWidget *w, QEvent::Type type, int key, Qt::KeyboardModifiers modifiers,
+                                                    quint32 nativeScanCode, quint32 nativeVirtualKey,
+                                                    quint32 nativeModifiers,
+                                                    const QString& text, bool autorep,
+                                                    ushort count)
+{
+    unsigned long time = QWindowSystemInterfacePrivate::eventTime.elapsed();
+    handleExtendedKeyEvent(w, time, type, key, modifiers, nativeScanCode, nativeVirtualKey, nativeModifiers,
+                           text, autorep, count);
+}
+
+void QWindowSystemInterface::handleExtendedKeyEvent(QWidget *tlw, ulong timestamp, QEvent::Type type, int key,
+                                                    Qt::KeyboardModifiers modifiers,
+                                                    quint32 nativeScanCode, quint32 nativeVirtualKey,
+                                                    quint32 nativeModifiers,
+                                                    const QString& text, bool autorep,
+                                                    ushort count)
+{
+    if (tlw) {
+        QWidgetData *data = qt_qwidget_data(tlw);
+        if (data->in_destructor)
+            tlw = 0;
+    }
+
+    QWindowSystemInterfacePrivate::KeyEvent * e =
+            new QWindowSystemInterfacePrivate::KeyEvent(tlw, timestamp, type, key, modifiers,
+                nativeScanCode, nativeVirtualKey, nativeModifiers, text, autorep, count);
+    QWindowSystemInterfacePrivate::queueWindowSystemEvent(e);
+}
+
 void QWindowSystemInterface::handleWheelEvent(QWidget *w, const QPoint & local, const QPoint & global, int d, Qt::Orientation o) {
     unsigned long time = QWindowSystemInterfacePrivate::eventTime.elapsed();
     handleWheelEvent(w, time, local, global, d, o);
diff --git a/src/gui/kernel/qwindowsysteminterface_qpa.h b/src/gui/kernel/qwindowsysteminterface_qpa.h
index 39c2f79..a882fc1 100644
--- a/src/gui/kernel/qwindowsysteminterface_qpa.h
+++ b/src/gui/kernel/qwindowsysteminterface_qpa.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
@@ -64,6 +64,17 @@ public:
     static void handleKeyEvent(QWidget *w, QEvent::Type t, int k, Qt::KeyboardModifiers mods, const QString & text = QString(), bool autorep = false, ushort count = 1);
     static void handleKeyEvent(QWidget *w, ulong timestamp, QEvent::Type t, int k, Qt::KeyboardModifiers mods, const QString & text = QString(), bool autorep = false, ushort count = 1);
 
+    static void handleExtendedKeyEvent(QWidget *w, QEvent::Type type, int key, Qt::KeyboardModifiers modifiers,
+                                       quint32 nativeScanCode, quint32 nativeVirtualKey,
+                                       quint32 nativeModifiers,
+                                       const QString& text = QString(), bool autorep = false,
+                                       ushort count = 1);
+    static void handleExtendedKeyEvent(QWidget *w, ulong timestamp, QEvent::Type type, int key, Qt::KeyboardModifiers modifiers,
+                                       quint32 nativeScanCode, quint32 nativeVirtualKey,
+                                       quint32 nativeModifiers,
+                                       const QString& text = QString(), bool autorep = false,
+                                       ushort count = 1);
+
     static void handleWheelEvent(QWidget *w, const QPoint & local, const QPoint & global, int d, Qt::Orientation o);
     static void handleWheelEvent(QWidget *w, ulong timestamp, const QPoint & local, const QPoint & global, int d, Qt::Orientation o);
 
diff --git a/src/gui/kernel/qwindowsysteminterface_qpa_p.h b/src/gui/kernel/qwindowsysteminterface_qpa_p.h
index 3491a1a..6be86ad 100644
--- a/src/gui/kernel/qwindowsysteminterface_qpa_p.h
+++ b/src/gui/kernel/qwindowsysteminterface_qpa_p.h
@@ -142,13 +142,23 @@ public:
     public:
         KeyEvent(QWidget *w, ulong time, QEvent::Type t, int k, Qt::KeyboardModifiers mods, const QString & text = QString(), bool autorep = false, ushort count = 1)
             :UserEvent(w, time, Key), key(k), unicode(text), repeat(autorep),
-             repeatCount(count), modifiers(mods), keyType(t) { }
+             repeatCount(count), modifiers(mods), keyType(t),
+             nativeScanCode(0), nativeVirtualKey(0), nativeModifiers(0) { }
+        KeyEvent(QWidget *w, ulong time, QEvent::Type t, int k, Qt::KeyboardModifiers mods,
+                 quint32 nativeSC, quint32 nativeVK, quint32 nativeMods,
+                 const QString & text = QString(), bool autorep = false, ushort count = 1)
+            :UserEvent(w, time, Key), key(k), unicode(text), repeat(autorep),
+             repeatCount(count), modifiers(mods), keyType(t),
+             nativeScanCode(nativeSC), nativeVirtualKey(nativeVK), nativeModifiers(nativeMods) { }
         int key;
         QString unicode;
         bool repeat;
         ushort repeatCount;
         Qt::KeyboardModifiers modifiers;
         QEvent::Type keyType;
+        quint32 nativeScanCode;
+        quint32 nativeVirtualKey;
+        quint32 nativeModifiers;
     };
 
     class TouchEvent : public UserEvent {
diff --git a/src/gui/math3d/qvector2d.cpp b/src/gui/math3d/qvector2d.cpp
index 7f5a937..1fccfc9 100644
--- a/src/gui/math3d/qvector2d.cpp
+++ b/src/gui/math3d/qvector2d.cpp
@@ -60,6 +60,11 @@ QT_BEGIN_NAMESPACE
     The QVector2D class can also be used to represent vertices in 2D space.
     We therefore do not need to provide a separate vertex class.
 
+    \bold{Note:} By design values in the QVector2D instance are stored as \c float.
+    This means that on platforms where the \c qreal arguments to QVector2D
+    functions are represented by \c double values, it is possible to
+    lose precision.
+
     \sa QVector3D, QVector4D, QQuaternion
 */
 
diff --git a/src/gui/math3d/qvector3d.cpp b/src/gui/math3d/qvector3d.cpp
index 2414b5f..7bf0400 100644
--- a/src/gui/math3d/qvector3d.cpp
+++ b/src/gui/math3d/qvector3d.cpp
@@ -63,6 +63,11 @@ QT_BEGIN_NAMESPACE
     The QVector3D class can also be used to represent vertices in 3D space.
     We therefore do not need to provide a separate vertex class.
 
+    \bold{Note:} By design values in the QVector3D instance are stored as \c float.
+    This means that on platforms where the \c qreal arguments to QVector3D
+    functions are represented by \c double values, it is possible to
+    lose precision.
+
     \sa QVector2D, QVector4D, QQuaternion
 */
 
diff --git a/src/gui/math3d/qvector4d.cpp b/src/gui/math3d/qvector4d.cpp
index 74dedc4..23befc0 100644
--- a/src/gui/math3d/qvector4d.cpp
+++ b/src/gui/math3d/qvector4d.cpp
@@ -59,6 +59,11 @@ QT_BEGIN_NAMESPACE
     The QVector4D class can also be used to represent vertices in 4D space.
     We therefore do not need to provide a separate vertex class.
 
+    \bold{Note:} By design values in the QVector4D instance are stored as \c float.
+    This means that on platforms where the \c qreal arguments to QVector4D
+    functions are represented by \c double values, it is possible to
+    lose precision.
+
     \sa QQuaternion, QVector2D, QVector3D
 */
 
diff --git a/src/gui/painting/painting.pri b/src/gui/painting/painting.pri
index 51f2538..65e7af4 100644
--- a/src/gui/painting/painting.pri
+++ b/src/gui/painting/painting.pri
@@ -234,8 +234,10 @@ x11 {
 }
 
 !embedded:!qpa:mac {
-        HEADERS += painting/qwindowsurface_mac_p.h
-        SOURCES += painting/qwindowsurface_mac.cpp
+        HEADERS += painting/qwindowsurface_mac_p.h \
+                   painting/qunifiedtoolbarsurface_mac_p.h
+        SOURCES += painting/qwindowsurface_mac.cpp \
+                   painting/qunifiedtoolbarsurface_mac.cpp
 }
 
 embedded {
@@ -260,12 +262,6 @@ symbian {
         QMAKE_CXXFLAGS.ARMCC *= -O3
 }
 
-mac {
-       HEADERS += painting/qunifiedtoolbarsurface_mac_p.h
-       SOURCES += painting/qunifiedtoolbarsurface_mac.cpp
-}
-
-
 NEON_SOURCES += painting/qdrawhelper_neon.cpp
 NEON_HEADERS += painting/qdrawhelper_neon_p.h
 NEON_ASM += ../3rdparty/pixman/pixman-arm-neon-asm.S painting/qdrawhelper_neon_asm.S
diff --git a/src/gui/painting/qbackingstore.cpp b/src/gui/painting/qbackingstore.cpp
index 129bba5..e5d8abc 100644
--- a/src/gui/painting/qbackingstore.cpp
+++ b/src/gui/painting/qbackingstore.cpp
@@ -1143,6 +1143,11 @@ void QWidgetBackingStore::sync(QWidget *exposedWidget, const QRegion &exposedReg
         return;
     }
 
+    // If there's no partial update support we always need
+    // to do a full repaint before flushing
+    if (!windowSurface->hasPartialUpdateSupport())
+        fullUpdatePending = true;
+
     // Nothing to repaint.
     if (!isDirty()) {
         qt_flush(exposedWidget, exposedRegion, windowSurface, tlw, tlwOffset);
diff --git a/src/gui/painting/qbackingstore_p.h b/src/gui/painting/qbackingstore_p.h
index e2b21c3..47387ab 100644
--- a/src/gui/painting/qbackingstore_p.h
+++ b/src/gui/painting/qbackingstore_p.h
@@ -209,8 +209,9 @@ private:
     {
 #ifdef Q_WS_QWS
         return tlw->frameGeometry();
-#endif
+#else
         return tlw->data->crect;
+#endif
     }
 
     inline void appendDirtyOnScreenWidget(QWidget *widget)
diff --git a/src/gui/painting/qblendfunctions.cpp b/src/gui/painting/qblendfunctions.cpp
index dc90003..10674f8 100644
--- a/src/gui/painting/qblendfunctions.cpp
+++ b/src/gui/painting/qblendfunctions.cpp
@@ -309,7 +309,7 @@ template <typename T> void qt_blend_argb24_on_rgb16(uchar *destPixels, int dbpl,
         const uchar *src = srcPixels + y * sbpl;
         const uchar *srcEnd = src + srcOffset;
         while (src < srcEnd) {
-#if defined(QT_ARCH_ARMV5) || defined(QT_ARCH_POWERPC) || defined(QT_ARCH_SH) || defined(QT_ARCH_AVR32) || (defined(QT_ARCH_WINDOWSCE) && !defined(_X86_)) || (defined(QT_ARCH_SPARC) && defined(Q_CC_GNU))
+#if defined(QT_ARCH_ARMV5) || defined(QT_ARCH_POWERPC) || defined(QT_ARCH_SH) || defined(QT_ARCH_AVR32) || (defined(QT_ARCH_WINDOWSCE) && !defined(_X86_)) || (defined(QT_ARCH_SPARC) && defined(Q_CC_GNU)) || (defined(QT_ARCH_INTEGRITY) && !defined(_X86_))
             // non-16-bit aligned memory access is not possible on PowerPC,
             // ARM <v6 (QT_ARCH_ARMV5) & SH & AVR32 & SPARC w/GCC
             quint16 spix = (quint16(src[2])<<8) + src[1];
diff --git a/src/gui/painting/qblittable.cpp b/src/gui/painting/qblittable.cpp
index f4b84a9..5802531 100644
--- a/src/gui/painting/qblittable.cpp
+++ b/src/gui/painting/qblittable.cpp
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/painting/qblittable_p.h b/src/gui/painting/qblittable_p.h
index cb56cb2..9d0e822 100644
--- a/src/gui/painting/qblittable_p.h
+++ b/src/gui/painting/qblittable_p.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/painting/qdrawingprimitive_sse2_p.h b/src/gui/painting/qdrawingprimitive_sse2_p.h
index 2d61cc5..d8793c3 100644
--- a/src/gui/painting/qdrawingprimitive_sse2_p.h
+++ b/src/gui/painting/qdrawingprimitive_sse2_p.h
@@ -78,7 +78,7 @@ QT_BEGIN_NAMESPACE
     pixelVectorAG = _mm_mullo_epi16(pixelVectorAG, alphaChannel); \
     pixelVectorRB = _mm_mullo_epi16(pixelVectorRB, alphaChannel); \
  \
-    /* 3. devide by 255, that's the tricky part. \
+    /* 3. divide by 255, that's the tricky part. \
        we do it like for BYTE_MUL(), with bit shift: X/255 ~= (X + X/256 + rounding)/256 */ \
     /** so first (X + X/256 + rounding) */\
     pixelVectorRB = _mm_add_epi16(pixelVectorRB, _mm_srli_epi16(pixelVectorRB, 8)); \
@@ -86,7 +86,7 @@ QT_BEGIN_NAMESPACE
     pixelVectorAG = _mm_add_epi16(pixelVectorAG, _mm_srli_epi16(pixelVectorAG, 8)); \
     pixelVectorAG = _mm_add_epi16(pixelVectorAG, half); \
  \
-    /** second devide by 256 */\
+    /** second divide by 256 */\
     pixelVectorRB = _mm_srli_epi16(pixelVectorRB, 8); \
     /** for AG, we could >> 8 to divide followed by << 8 to put the \
         bytes in the correct position. By masking instead, we execute \
diff --git a/src/gui/painting/qgraphicssystem.cpp b/src/gui/painting/qgraphicssystem.cpp
index 8d39b59..171ef46 100644
--- a/src/gui/painting/qgraphicssystem.cpp
+++ b/src/gui/painting/qgraphicssystem.cpp
@@ -89,4 +89,9 @@ QPixmapData *QGraphicsSystem::createPixmapData(QPixmapData *origin)
     return createPixmapData(origin->pixelType());
 }
 
+void QGraphicsSystem::releaseCachedResources()
+{
+    // Do nothing here
+}
+
 QT_END_NAMESPACE
diff --git a/src/gui/painting/qgraphicssystem_p.h b/src/gui/painting/qgraphicssystem_p.h
index 1aa3aa0..0f99a31 100644
--- a/src/gui/painting/qgraphicssystem_p.h
+++ b/src/gui/painting/qgraphicssystem_p.h
@@ -76,6 +76,8 @@ public:
     //### Remove this & change qpixmap.cpp & qbitmap.cpp once every platform is gaurenteed
     //    to have a graphics system.
     static QPixmapData *createDefaultPixmapData(QPixmapData::PixelType type);
+
+    virtual void releaseCachedResources();
 };
 
 QT_END_NAMESPACE
diff --git a/src/gui/painting/qgraphicssystem_runtime.cpp b/src/gui/painting/qgraphicssystem_runtime.cpp
index 5841d40..33652ee 100644
--- a/src/gui/painting/qgraphicssystem_runtime.cpp
+++ b/src/gui/painting/qgraphicssystem_runtime.cpp
@@ -394,7 +394,10 @@ void QRuntimeGraphicsSystem::setGraphicsSystem(const QString &name)
         if(m_windowSurfaceDestroyPolicy == DestroyAfterFirstFlush)
             proxy->m_pendingWindowSurface.reset(proxy->m_windowSurface.take());
 
-        proxy->m_windowSurface.reset(m_graphicsSystem->createWindowSurface(widget));
+        QWindowSurface *newWindowSurface = m_graphicsSystem->createWindowSurface(widget);
+        newWindowSurface->setGeometry(proxy->geometry());
+
+        proxy->m_windowSurface.reset(newWindowSurface);
         qt_widget_private(widget)->invalidateBuffer(widget->rect());
     }
 
diff --git a/src/gui/painting/qpaintengine_blitter.cpp b/src/gui/painting/qpaintengine_blitter.cpp
index 2e8d9dd..500748e 100644
--- a/src/gui/painting/qpaintengine_blitter.cpp
+++ b/src/gui/painting/qpaintengine_blitter.cpp
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/painting/qpaintengine_blitter_p.h b/src/gui/painting/qpaintengine_blitter_p.h
index c8aa536..be8b2bc 100644
--- a/src/gui/painting/qpaintengine_blitter_p.h
+++ b/src/gui/painting/qpaintengine_blitter_p.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/painting/qpaintengine_s60.cpp b/src/gui/painting/qpaintengine_s60.cpp
index 1bc7799..ca303be 100644
--- a/src/gui/painting/qpaintengine_s60.cpp
+++ b/src/gui/painting/qpaintengine_s60.cpp
@@ -41,6 +41,7 @@
 #include <private/qpaintengine_s60_p.h>
 #include <private/qpixmap_s60_p.h>
 #include <private/qt_s60_p.h>
+#include <private/qvolatileimage_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -90,7 +91,15 @@ void QS60PaintEngine::drawPixmap(const QPointF &p, const QPixmap &pm)
         QRasterPaintEngine::drawPixmap(p, pm);
         srcData->endDataAccess();
     } else {
-        QRasterPaintEngine::drawPixmap(p, pm);
+        void *nativeData = pm.pixmapData()->toNativeType(QPixmapData::VolatileImage);
+        if (nativeData) {
+            QVolatileImage *img = static_cast<QVolatileImage *>(nativeData);
+            img->beginDataAccess();
+            QRasterPaintEngine::drawImage(p, img->imageRef());
+            img->endDataAccess(true);
+        } else {
+            QRasterPaintEngine::drawPixmap(p, pm);
+        }
     }
 }
 
@@ -102,7 +111,15 @@ void QS60PaintEngine::drawPixmap(const QRectF &r, const QPixmap &pm, const QRect
         QRasterPaintEngine::drawPixmap(r, pm, sr);
         srcData->endDataAccess();
     } else {
-        QRasterPaintEngine::drawPixmap(r, pm, sr);
+        void *nativeData = pm.pixmapData()->toNativeType(QPixmapData::VolatileImage);
+        if (nativeData) {
+            QVolatileImage *img = static_cast<QVolatileImage *>(nativeData);
+            img->beginDataAccess();
+            QRasterPaintEngine::drawImage(r, img->imageRef(), sr);
+            img->endDataAccess(true);
+        } else {
+            QRasterPaintEngine::drawPixmap(r, pm, sr);
+        }
     }
 }
 
diff --git a/src/gui/painting/qpainterpath.cpp b/src/gui/painting/qpainterpath.cpp
index 8bff021..49f1a5f 100644
--- a/src/gui/painting/qpainterpath.cpp
+++ b/src/gui/painting/qpainterpath.cpp
@@ -1724,7 +1724,7 @@ static void qt_painterpath_isect_line(const QPointF &p1,
 }
 
 static void qt_painterpath_isect_curve(const QBezier &bezier, const QPointF &pt,
-                                       int *winding)
+                                       int *winding, int depth = 0)
 {
     qreal y = pt.y();
     qreal x = pt.x();
@@ -1739,7 +1739,7 @@ static void qt_painterpath_isect_curve(const QBezier &bezier, const QPointF &pt,
         // hit lower limit... This is a rough threshold, but its a
         // tradeoff between speed and precision.
         const qreal lower_bound = qreal(.001);
-        if (bounds.width() < lower_bound && bounds.height() < lower_bound) {
+        if (depth == 32 || (bounds.width() < lower_bound && bounds.height() < lower_bound)) {
             // We make the assumption here that the curve starts to
             // approximate a line after while (i.e. that it doesn't
             // change direction drastically during its slope)
@@ -1752,8 +1752,8 @@ static void qt_painterpath_isect_curve(const QBezier &bezier, const QPointF &pt,
         // split curve and try again...
         QBezier first_half, second_half;
         bezier.split(&first_half, &second_half);
-        qt_painterpath_isect_curve(first_half, pt, winding);
-        qt_painterpath_isect_curve(second_half, pt, winding);
+        qt_painterpath_isect_curve(first_half, pt, winding, depth + 1);
+        qt_painterpath_isect_curve(second_half, pt, winding, depth + 1);
     }
 }
 
diff --git a/src/gui/painting/qprintengine_pdf.cpp b/src/gui/painting/qprintengine_pdf.cpp
index f262144..b7f5160 100644
--- a/src/gui/painting/qprintengine_pdf.cpp
+++ b/src/gui/painting/qprintengine_pdf.cpp
@@ -936,7 +936,7 @@ void QPdfEnginePrivate::writeInfo()
     xprintf("\n/Creator ");
     printString(creator);
     xprintf("\n/Producer ");
-    printString(QString::fromLatin1("Qt " QT_VERSION_STR " (C) 2010 Nokia Corporation and/or its subsidiary(-ies)"));
+    printString(QString::fromLatin1("Qt " QT_VERSION_STR " (C) 2011 Nokia Corporation and/or its subsidiary(-ies)"));
     QDateTime now = QDateTime::currentDateTime().toUTC();
     QTime t = now.time();
     QDate d = now.date();
diff --git a/src/gui/painting/qprinterinfo_p.h b/src/gui/painting/qprinterinfo_p.h
index 7781d59..fcc1acb 100644
--- a/src/gui/painting/qprinterinfo_p.h
+++ b/src/gui/painting/qprinterinfo_p.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/painting/qstroker.cpp b/src/gui/painting/qstroker.cpp
index 80353bc..fca46b4 100644
--- a/src/gui/painting/qstroker.cpp
+++ b/src/gui/painting/qstroker.cpp
@@ -668,26 +668,28 @@ template <class Iterator> bool qt_stroke_side(Iterator *it,
 #endif
             QLineF line(qt_fixed_to_real(prev.x), qt_fixed_to_real(prev.y),
                         qt_fixed_to_real(e.x), qt_fixed_to_real(e.y));
-            QLineF normal = line.normalVector();
-            normal.setLength(offset);
-            line.translate(normal.dx(), normal.dy());
-
-            // If we are starting a new subpath, move to correct starting point.
-            if (first) {
-                if (capFirst)
-                    stroker->joinPoints(prev.x, prev.y, line, stroker->capStyleMode());
-                else
-                    stroker->emitMoveTo(qt_real_to_fixed(line.x1()), qt_real_to_fixed(line.y1()));
-                *startTangent = line;
-                first = false;
-            } else {
-                stroker->joinPoints(prev.x, prev.y, line, stroker->joinStyleMode());
-            }
+            if (line.p1() != line.p2()) {
+                QLineF normal = line.normalVector();
+                normal.setLength(offset);
+                line.translate(normal.dx(), normal.dy());
+
+                // If we are starting a new subpath, move to correct starting point.
+                if (first) {
+                    if (capFirst)
+                        stroker->joinPoints(prev.x, prev.y, line, stroker->capStyleMode());
+                    else
+                        stroker->emitMoveTo(qt_real_to_fixed(line.x1()), qt_real_to_fixed(line.y1()));
+                    *startTangent = line;
+                    first = false;
+                } else {
+                    stroker->joinPoints(prev.x, prev.y, line, stroker->joinStyleMode());
+                }
 
-            // Add the stroke for this line.
-            stroker->emitLineTo(qt_real_to_fixed(line.x2()),
-                                qt_real_to_fixed(line.y2()));
-            prev = e;
+                // Add the stroke for this line.
+                stroker->emitLineTo(qt_real_to_fixed(line.x2()),
+                                    qt_real_to_fixed(line.y2()));
+                prev = e;
+            }
 
         // CurveToElement
         } else if (e.isCurveTo()) {
diff --git a/src/gui/painting/qunifiedtoolbarsurface_mac.cpp b/src/gui/painting/qunifiedtoolbarsurface_mac.cpp
index 02ba8db..e7434c7 100644
--- a/src/gui/painting/qunifiedtoolbarsurface_mac.cpp
+++ b/src/gui/painting/qunifiedtoolbarsurface_mac.cpp
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/painting/qunifiedtoolbarsurface_mac_p.h b/src/gui/painting/qunifiedtoolbarsurface_mac_p.h
index 3bc0404..e1157d7 100644
--- a/src/gui/painting/qunifiedtoolbarsurface_mac_p.h
+++ b/src/gui/painting/qunifiedtoolbarsurface_mac_p.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/styles/qmacstyle_mac.mm b/src/gui/styles/qmacstyle_mac.mm
index ac05789..2d21628 100644
--- a/src/gui/styles/qmacstyle_mac.mm
+++ b/src/gui/styles/qmacstyle_mac.mm
@@ -3084,7 +3084,7 @@ void QMacStyle::drawPrimitive(PrimitiveElement pe, const QStyleOption *opt, QPai
         }
         break;
     case PE_PanelScrollAreaCorner: {
-        const QBrush brush(qApp->palette().brush(QPalette::Base));
+        const QBrush brush(opt->palette.brush(QPalette::Base));
         p->fillRect(opt->rect, brush);
         p->setPen(QPen(QColor(217, 217, 217)));
         p->drawLine(opt->rect.topLeft(), opt->rect.topRight());
@@ -4621,6 +4621,13 @@ void QMacStyle::drawComplexControl(ComplexControl cc, const QStyleOptionComplex
                     tdi.attributes &= ~kThemeTrackShowThumb;
                 if (scrollBarLength < scrollButtonsCutoffSize(scrollButtonsCutoff, sizePolicy))
                     tdi.enableState = kThemeTrackNothingToScroll;
+            } else {
+                if (!(slider->subControls & SC_SliderHandle))
+                    tdi.attributes &= ~kThemeTrackShowThumb;
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
+                if (!(slider->subControls & SC_SliderGroove))
+                    tdi.attributes |= kThemeTrackHideTrack;
+#endif
             }
 
             HIThemeDrawTrack(&tdi, tracking ? 0 : &macRect, cg,
diff --git a/src/gui/styles/qs60style.cpp b/src/gui/styles/qs60style.cpp
index ecc2539..6a35027 100644
--- a/src/gui/styles/qs60style.cpp
+++ b/src/gui/styles/qs60style.cpp
@@ -118,6 +118,7 @@ const short *QS60StylePrivate::m_pmPointer = QS60StylePrivate::data[0];
 
 // theme background texture
 QPixmap *QS60StylePrivate::m_background = 0;
+QPixmap *QS60StylePrivate::m_placeHolderTexture = 0;
 
 // theme palette
 QPalette *QS60StylePrivate::m_themePalette = 0;
@@ -155,6 +156,10 @@ const double KTabFontMul = 0.72;
 QS60StylePrivate::~QS60StylePrivate()
 {
     clearCaches(); //deletes also background image
+    if (m_placeHolderTexture) {
+        delete m_placeHolderTexture;
+        m_placeHolderTexture = 0;
+    }
     deleteThemePalette();
 #ifdef Q_WS_S60
     removeAnimations();
@@ -505,7 +510,10 @@ void QS60StylePrivate::setBackgroundTexture(QApplication *app) const
 {
     Q_UNUSED(app)
     QPalette applicationPalette = QApplication::palette();
-    applicationPalette.setBrush(QPalette::Window, backgroundTexture());
+    // The initial QPalette::Window is just a placeHolder QPixmap to save RAM
+    // if the actual texture is not needed. The real texture is created just before
+    // painting it in qt_s60_fill_background().
+    applicationPalette.setBrush(QPalette::Window, placeHolderTexture());
     setThemePalette(&applicationPalette);
 }
 
@@ -630,25 +638,6 @@ QPixmap QS60StylePrivate::cachedFrame(SkinFrameElements frame, const QSize &size
     return result;
 }
 
-void QS60StylePrivate::refreshUI()
-{
-    QList<QWidget *> widgets = QApplication::allWidgets();
-
-    for (int i = 0; i < widgets.size(); ++i) {
-        QWidget *widget = widgets.at(i);
-        if (widget == 0)
-            continue;
-
-        if (widget->style()) {
-            widget->style()->polish(widget);
-            QEvent event(QEvent::StyleChange);
-            qApp->sendEvent(widget, &event);
-        }
-        widget->update();
-        widget->updateGeometry();
-    }
-}
-
 void QS60StylePrivate::setFont(QWidget *widget) const
 {
     QS60StyleEnums::FontCategories fontCategory = QS60StyleEnums::FC_Undefined;
@@ -719,8 +708,10 @@ void QS60StylePrivate::setThemePalette(QPalette *palette) const
     palette->setColor(QPalette::LinkVisited, palette->color(QPalette::Link).darker());
     palette->setColor(QPalette::Highlight,
         s60Color(QS60StyleEnums::CL_QsnHighlightColors, 2, 0));
-    // set background image as a texture brush
-    palette->setBrush(QPalette::Window, backgroundTexture());
+    // The initial QPalette::Window is just a placeHolder QPixmap to save RAM
+    // if the actual texture is not needed. The real texture is created just before
+    // painting it in qt_s60_fill_background().
+    palette->setBrush(QPalette::Window, placeHolderTexture());
     // set as transparent so that styled full screen theme background is visible
     palette->setBrush(QPalette::Base, Qt::transparent);
     // set button color based on pixel colors
@@ -2643,10 +2634,13 @@ QSize QS60Style::sizeFromContents(ContentsType ct, const QStyleOption *opt,
             sz = QCommonStyle::sizeFromContents( ct, opt, csz, widget);
             //native items have small empty areas at the beginning and end of menu item
             sz.setWidth(sz.width() + 2 * pixelMetric(PM_MenuHMargin) + 2 * QS60StylePrivate::pixelMetric(PM_FrameCornerWidth));
-            if (QS60StylePrivate::isTouchSupported())
+            if (QS60StylePrivate::isTouchSupported()) {
                 //Make itemview easier to use in touch devices
+                sz.setHeight(sz.height() + 2 * pixelMetric(PM_FocusFrameVMargin));
                 //QCommonStyle does not adjust height with horizontal margin, it only adjusts width
-                sz.setHeight(sz.height() + 2 * pixelMetric(PM_FocusFrameVMargin) - 8); //QCommonstyle adds 8 to height that this style handles through PM values
+                if (ct == CT_MenuItem)
+                    sz.setHeight(sz.height() - 8); //QCommonstyle adds 8 to height that this style handles through PM values
+            }
             break;
 #ifndef QT_NO_COMBOBOX
         case CT_ComboBox: {
@@ -3545,10 +3539,12 @@ extern QPoint qt_s60_fill_background_offset(const QWidget *targetWidget);
 
 bool qt_s60_fill_background(QPainter *painter, const QRegion &rgn, const QBrush &brush)
 {
-    const QPixmap backgroundTexture(QS60StylePrivate::backgroundTexture());
-    if (backgroundTexture.cacheKey() != brush.texture().cacheKey())
+    const QPixmap placeHolder(QS60StylePrivate::placeHolderTexture());
+    if (placeHolder.cacheKey() != brush.texture().cacheKey())
         return false;
 
+    const QPixmap backgroundTexture(QS60StylePrivate::backgroundTexture());
+
     const QPaintDevice *target = painter->device();
     if (target->devType() == QInternal::Widget) {
         const QWidget *widget = static_cast<const QWidget *>(target);
diff --git a/src/gui/styles/qs60style_p.h b/src/gui/styles/qs60style_p.h
index 242c451..8c023bf 100644
--- a/src/gui/styles/qs60style_p.h
+++ b/src/gui/styles/qs60style_p.h
@@ -555,6 +555,7 @@ public:
     static QPixmap frame(SkinFrameElements frame, const QSize &size,
         SkinElementFlags flags = KDefaultSkinElementFlags);
     static QPixmap backgroundTexture();
+    static QPixmap placeHolderTexture();
 
 #ifdef Q_WS_S60
     void handleDynamicLayoutVariantSwitch();
@@ -592,8 +593,6 @@ private:
     static QPixmap cachedFrame(SkinFrameElements frame, const QSize &size,
         SkinElementFlags flags = KDefaultSkinElementFlags);
 
-    static void refreshUI();
-
     // set S60 font for widget
     void setFont(QWidget *widget) const;
     void setThemePalette(QWidget *widget) const;
@@ -616,6 +615,9 @@ private:
 
     // Contains background texture.
     static QPixmap *m_background;
+    // Placeholder pixmap for the real background texture.
+    static QPixmap *m_placeHolderTexture;
+
     const static SkinElementFlags KDefaultSkinElementFlags;
     // defined theme palette
     static QPalette *m_themePalette;
diff --git a/src/gui/styles/qs60style_s60.cpp b/src/gui/styles/qs60style_s60.cpp
index 605872e..1ff195d 100644
--- a/src/gui/styles/qs60style_s60.cpp
+++ b/src/gui/styles/qs60style_s60.cpp
@@ -47,6 +47,7 @@
 #include "private/qt_s60_p.h"
 #include "private/qpixmap_s60_p.h"
 #include "private/qcore_symbian_p.h"
+#include "private/qvolatileimage_p.h"
 #include "qapplication.h"
 #include "qsettings.h"
 
@@ -65,7 +66,6 @@
 #include <aknnavi.h>
 #include <gulicon.h>
 #include <AknBitmapAnimation.h>
-
 #include <centralrepository.h>
 
 #if !defined(QT_NO_STYLE_S60) || defined(QT_PLUGIN)
@@ -637,9 +637,22 @@ QPixmap QS60StyleModeSpecifics::fromFbsBitmap(CFbsBitmap *icon, CFbsBitmap *mask
     if (error)
         return QPixmap();
 
-    QPixmap pixmap = QPixmap::fromSymbianCFbsBitmap(icon);
-    if (mask)
-        pixmap.setAlphaChannel(QPixmap::fromSymbianCFbsBitmap(mask));
+    QPixmap pixmap;
+    QScopedPointer<QPixmapData> pd(QPixmapData::create(0, 0, QPixmapData::PixmapType));
+    bool nativeMaskSupported = (pd->toNativeType(QPixmapData::VolatileImage) != 0);
+    if (mask && nativeMaskSupported) {
+        // Efficient path, less copying and conversion.
+        QVolatileImage img(icon, mask);
+        pd->fromNativeType(&img, QPixmapData::VolatileImage);
+        pixmap = QPixmap(pd.take());
+    } else {
+        // Potentially more expensive path.
+        pd->fromNativeType(icon, QPixmapData::FbsBitmap);
+        pixmap = QPixmap(pd.take());
+        if (mask) {
+            pixmap.setAlphaChannel(QPixmap::fromSymbianCFbsBitmap(mask));
+        }
+    }
 
     if ((flags & QS60StylePrivate::SF_PointEast) ||
         (flags & QS60StylePrivate::SF_PointSouth) ||
@@ -795,6 +808,8 @@ QPixmap QS60StyleModeSpecifics::createSkinnedGraphicsLX(
         rotatedBy90or270 ? TSize(size.height(), size.width()) : qt_QSize2TSize(size);
 
     MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance();
+    static const TDisplayMode displayMode = S60->supportsPremultipliedAlpha ? Q_SYMBIAN_ECOLOR16MAP : EColor16MA;
+    static const TInt drawParam = S60->supportsPremultipliedAlpha ? KAknsDrawParamDefault : KAknsDrawParamRGBOnly;
 
     QPixmap result;
 
@@ -833,7 +848,7 @@ QPixmap QS60StyleModeSpecifics::createSkinnedGraphicsLX(
     //        QS60WindowSurface::unlockBitmapHeap();
             CFbsBitmap *background = new (ELeave) CFbsBitmap(); //offscreen
             CleanupStack::PushL(background);
-            User::LeaveIfError(background->Create(targetSize, EColor16MA));
+            User::LeaveIfError(background->Create(targetSize, displayMode));
 
             CFbsBitmapDevice *dev = CFbsBitmapDevice::NewL(background);
             CleanupStack::PushL(dev);
@@ -854,7 +869,7 @@ QPixmap QS60StyleModeSpecifics::createSkinnedGraphicsLX(
                 *gc,
                 TPoint(),
                 targetSize,
-                KAknsDrawParamDefault | KAknsDrawParamRGBOnly);
+                drawParam);
 
             if (drawn)
                 result = fromFbsBitmap(background, NULL, flags, targetSize);
@@ -1392,12 +1407,23 @@ QPixmap QS60StylePrivate::backgroundTexture()
 
     if (createNewBackground) {
         QPixmap background = part(QS60StyleEnums::SP_QsnBgScreen,
-                QSize(applicationRect.Width(), applicationRect.Height()), 0, SkinElementFlags());
+            QSize(applicationRect.Width(), applicationRect.Height()), 0, SkinElementFlags());
         m_background = new QPixmap(background);
     }
     return *m_background;
 }
 
+// Generates 1*1 red pixmap as a placeholder for real texture.
+// The actual theme texture is drawn in qt_s60_fill_background().
+QPixmap QS60StylePrivate::placeHolderTexture()
+{
+    if (!m_placeHolderTexture) {
+        m_placeHolderTexture = new QPixmap(1,1);
+        m_placeHolderTexture->fill(Qt::red);
+    }
+    return *m_placeHolderTexture;
+}
+
 QSize QS60StylePrivate::screenSize()
 {
     return QSize(S60->screenWidthInPixels, S60->screenHeightInPixels);
@@ -1412,8 +1438,8 @@ QS60Style::QS60Style()
 void QS60StylePrivate::handleDynamicLayoutVariantSwitch()
 {
     clearCaches(QS60StylePrivate::CC_LayoutChange);
+    setBackgroundTexture(qApp);
     setActiveLayout();
-    refreshUI();
     foreach (QWidget *widget, QApplication::allWidgets())
         widget->ensurePolished();
 }
diff --git a/src/gui/styles/qstylesheetstyle_default.cpp b/src/gui/styles/qstylesheetstyle_default.cpp
index 002dcff..76ffac8 100644
--- a/src/gui/styles/qstylesheetstyle_default.cpp
+++ b/src/gui/styles/qstylesheetstyle_default.cpp
@@ -151,7 +151,7 @@ StyleSheet QStyleSheetStyle::getDefaultStyleSheet() const
     BasicSelector bSelector;
     Selector selector;
     Declaration decl;
-    Value value;
+    QCss::Value value;
     Pseudo pseudo;
     AttributeSelector attr;
 
diff --git a/src/gui/text/qcssparser.cpp b/src/gui/text/qcssparser.cpp
index 54ca7cc..052dc72 100644
--- a/src/gui/text/qcssparser.cpp
+++ b/src/gui/text/qcssparser.cpp
@@ -649,7 +649,7 @@ bool ValueExtractor::extractOutline(int *borders, QBrush *colors, BorderStyle *s
     return hit;
 }
 
-static Qt::Alignment parseAlignment(const Value *values, int count)
+static Qt::Alignment parseAlignment(const QCss::Value *values, int count)
 {
     Qt::Alignment a[2] = { 0, 0 };
     for (int i = 0; i < qMin(2, count); i++) {
@@ -672,7 +672,7 @@ static Qt::Alignment parseAlignment(const Value *values, int count)
     return a[0] | a[1];
 }
 
-static ColorData parseColorValue(Value v)
+static ColorData parseColorValue(QCss::Value v)
 {
     if (v.type == Value::Identifier || v.type == Value::String) {
         v.variant.convert(QVariant::Color);
@@ -706,7 +706,7 @@ static ColorData parseColorValue(Value v)
     if (!p.testExpr())
         return ColorData();
 
-    QVector<Value> colorDigits;
+    QVector<QCss::Value> colorDigits;
     if (!p.parseExpr(&colorDigits))
         return ColorData();
 
@@ -738,7 +738,7 @@ static QColor colorFromData(const ColorData& c, const QPalette &pal)
     return QColor();
 }
 
-static BrushData parseBrushValue(const Value &v, const QPalette &pal)
+static BrushData parseBrushValue(const QCss::Value &v, const QPalette &pal)
 {
     ColorData c = parseColorValue(v);
     if (c.type == ColorData::Color) {
@@ -780,7 +780,7 @@ static BrushData parseBrushValue(const Value &v, const QPalette &pal)
             return BrushData();
         parser.skipSpace();
         if (attr.compare(QLatin1String("stop"), Qt::CaseInsensitive) == 0) {
-            Value stop, color;
+            QCss::Value stop, color;
             parser.next();
             if (!parser.parseTerm(&stop)) return BrushData();
             parser.skipSpace();
@@ -792,7 +792,7 @@ static BrushData parseBrushValue(const Value &v, const QPalette &pal)
             stops.append(QGradientStop(stop.variant.toReal(), colorFromData(cd, pal)));
         } else {
             parser.next();
-            Value value;
+            QCss::Value value;
             (void)parser.parseTerm(&value);
             if (attr.compare(QLatin1String("spread"), Qt::CaseInsensitive) == 0) {
                 spread = spreads.indexOf(value.variant.toString());
@@ -856,7 +856,7 @@ static QBrush brushFromData(const BrushData& c, const QPalette &pal)
     }
 }
 
-static BorderStyle parseStyleValue(Value v)
+static BorderStyle parseStyleValue(QCss::Value v)
 {
     if (v.type == Value::KnownIdentifier) {
         switch (v.variant.toInt()) {
@@ -941,7 +941,7 @@ void ValueExtractor::borderValue(const Declaration &decl, int *width, QCss::Bord
          decl.d->parsed = QVariant::fromValue<BorderData>(data);
 }
 
-static void parseShorthandBackgroundProperty(const QVector<Value> &values, BrushData *brush, QString *image, Repeat *repeat, Qt::Alignment *alignment, const QPalette &pal)
+static void parseShorthandBackgroundProperty(const QVector<QCss::Value> &values, BrushData *brush, QString *image, Repeat *repeat, Qt::Alignment *alignment, const QPalette &pal)
 {
     *brush = BrushData();
     *image = QString();
@@ -949,7 +949,7 @@ static void parseShorthandBackgroundProperty(const QVector<Value> &values, Brush
     *alignment = Qt::AlignTop | Qt::AlignLeft;
 
     for (int i = 0; i < values.count(); ++i) {
-        const Value &v = values.at(i);
+        const QCss::Value &v = values.at(i);
         if (v.type == Value::Uri) {
             *image = v.variant.toString();
             continue;
@@ -996,7 +996,7 @@ bool ValueExtractor::extractBackground(QBrush *brush, QString *image, Repeat *re
         const Declaration &decl = declarations.at(i);
         if (decl.d->values.isEmpty())
             continue;
-        const Value &val = decl.d->values.at(0);
+        const QCss::Value &val = decl.d->values.at(0);
         switch (decl.d->propertyId) {
             case BackgroundColor:
                     *brush = decl.brushValue();
@@ -1050,7 +1050,7 @@ bool ValueExtractor::extractBackground(QBrush *brush, QString *image, Repeat *re
     return hit;
 }
 
-static bool setFontSizeFromValue(Value value, QFont *font, int *fontSizeAdjustment)
+static bool setFontSizeFromValue(QCss::Value value, QFont *font, int *fontSizeAdjustment)
 {
     if (value.type == Value::KnownIdentifier) {
         bool valid = true;
@@ -1087,7 +1087,7 @@ static bool setFontSizeFromValue(Value value, QFont *font, int *fontSizeAdjustme
     return valid;
 }
 
-static bool setFontStyleFromValue(const Value &value, QFont *font)
+static bool setFontStyleFromValue(const QCss::Value &value, QFont *font)
 {
     if (value.type != Value::KnownIdentifier)
         return false ;
@@ -1100,7 +1100,7 @@ static bool setFontStyleFromValue(const Value &value, QFont *font)
     return false;
 }
 
-static bool setFontWeightFromValue(const Value &value, QFont *font)
+static bool setFontWeightFromValue(const QCss::Value &value, QFont *font)
 {
     if (value.type == Value::KnownIdentifier) {
         switch (value.variant.toInt()) {
@@ -1121,12 +1121,12 @@ static bool setFontWeightFromValue(const Value &value, QFont *font)
  * and set it the \a font
  * \returns true if a family was extracted.
  */
-static bool setFontFamilyFromValues(const QVector<Value> &values, QFont *font, int start = 0)
+static bool setFontFamilyFromValues(const QVector<QCss::Value> &values, QFont *font, int start = 0)
 {
     QString family;
     bool shouldAddSpace = false;
     for (int i = start; i < values.count(); ++i) {
-        const Value &v = values.at(i);
+        const QCss::Value &v = values.at(i);
         if (v.type == Value::TermOperatorComma) {
             family += QLatin1Char(',');
             shouldAddSpace = false;
@@ -1146,7 +1146,7 @@ static bool setFontFamilyFromValues(const QVector<Value> &values, QFont *font, i
     return true;
 }
 
-static void setTextDecorationFromValues(const QVector<Value> &values, QFont *font)
+static void setTextDecorationFromValues(const QVector<QCss::Value> &values, QFont *font)
 {
     for (int i = 0; i < values.count(); ++i) {
         if (values.at(i).type != Value::KnownIdentifier)
@@ -1165,7 +1165,7 @@ static void setTextDecorationFromValues(const QVector<Value> &values, QFont *fon
     }
 }
 
-static void parseShorthandFontProperty(const QVector<Value> &values, QFont *font, int *fontSizeAdjustment)
+static void parseShorthandFontProperty(const QVector<QCss::Value> &values, QFont *font, int *fontSizeAdjustment)
 {
     font->setStyle(QFont::StyleNormal);
     font->setWeight(QFont::Normal);
@@ -1190,7 +1190,7 @@ static void parseShorthandFontProperty(const QVector<Value> &values, QFont *font
     }
 }
 
-static void setFontVariantFromValue(const Value &value, QFont *font)
+static void setFontVariantFromValue(const QCss::Value &value, QFont *font)
 {
     if (value.type == Value::KnownIdentifier) {
         switch (value.variant.toInt()) {
@@ -1201,7 +1201,7 @@ static void setFontVariantFromValue(const Value &value, QFont *font)
     }
 }
 
-static void setTextTransformFromValue(const Value &value, QFont *font)
+static void setTextTransformFromValue(const QCss::Value &value, QFont *font)
 {
     if (value.type == Value::KnownIdentifier) {
         switch (value.variant.toInt()) {
@@ -1226,7 +1226,7 @@ bool ValueExtractor::extractFont(QFont *font, int *fontSizeAdjustment)
         const Declaration &decl = declarations.at(i);
         if (decl.d->values.isEmpty())
             continue;
-        const Value &val = decl.d->values.at(0);
+        const QCss::Value &val = decl.d->values.at(0);
         switch (decl.d->propertyId) {
             case FontSize: setFontSizeFromValue(val, font, fontSizeAdjustment); break;
             case FontStyle: setFontStyleFromValue(val, font); break;
@@ -1411,7 +1411,7 @@ bool Declaration::realValue(qreal *real, const char *unit) const
     return ok;
 }
 
-static bool intValueHelper(const Value &v, int *i, const char *unit)
+static bool intValueHelper(const QCss::Value &v, int *i, const char *unit)
 {
     if (unit && v.type != Value::Length)
         return false;
@@ -1460,7 +1460,7 @@ QRect Declaration::rectValue() const
     if (d->parsed.isValid())
         return qvariant_cast<QRect>(d->parsed);
 
-    const Value &v = d->values.at(0);
+    const QCss::Value &v = d->values.at(0);
     if (v.type != Value::Function)
         return QRect();
     QStringList func = v.variant.toStringList();
diff --git a/src/gui/text/qcssparser_p.h b/src/gui/text/qcssparser_p.h
index 79c46b3..86bafc9 100644
--- a/src/gui/text/qcssparser_p.h
+++ b/src/gui/text/qcssparser_p.h
@@ -71,6 +71,9 @@
 #if defined(Q_OS_VXWORKS) && defined(NONE)
 #  undef NONE
 #endif
+#if defined(Q_OS_INTEGRITY)
+#  undef Value
+#endif
 
 QT_BEGIN_NAMESPACE
 
diff --git a/src/gui/text/qfont.cpp b/src/gui/text/qfont.cpp
index 084b7ac..64eb27a 100644
--- a/src/gui/text/qfont.cpp
+++ b/src/gui/text/qfont.cpp
@@ -139,6 +139,9 @@ bool QFontDef::exactMatch(const QFontDef &other) const
     QFontDatabase::parseFontName(family, this_foundry, this_family);
     QFontDatabase::parseFontName(other.family, other_foundry, other_family);
 
+    this_family = QFontDatabase::resolveFontFamilyAlias(this_family);
+    other_family = QFontDatabase::resolveFontFamilyAlias(other_family);
+
     return (styleHint     == other.styleHint
             && styleStrategy == other.styleStrategy
             && weight        == other.weight
diff --git a/src/gui/text/qfont_qpa.cpp b/src/gui/text/qfont_qpa.cpp
index 7b09b59..ff12da8 100644
--- a/src/gui/text/qfont_qpa.cpp
+++ b/src/gui/text/qfont_qpa.cpp
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/text/qfontdatabase.cpp b/src/gui/text/qfontdatabase.cpp
index 8e92b1a..1e94bf5 100644
--- a/src/gui/text/qfontdatabase.cpp
+++ b/src/gui/text/qfontdatabase.cpp
@@ -1087,6 +1087,12 @@ QT_BEGIN_INCLUDE_NAMESPACE
 #elif defined(Q_OS_SYMBIAN)
 #  include "qfontdatabase_s60.cpp"
 #endif
+#if !defined(Q_WS_X11)
+QString QFontDatabase::resolveFontFamilyAlias(const QString &family)
+{
+    return family;
+}
+#endif
 QT_END_INCLUDE_NAMESPACE
 
 static QtFontStyle *bestStyle(QtFontFoundry *foundry, const QtFontStyle::Key &styleKey)
diff --git a/src/gui/text/qfontdatabase.h b/src/gui/text/qfontdatabase.h
index 3e9483b..ae1130e 100644
--- a/src/gui/text/qfontdatabase.h
+++ b/src/gui/text/qfontdatabase.h
@@ -152,6 +152,7 @@ public:
 private:
     static void createDatabase();
     static void parseFontName(const QString &name, QString &foundry, QString &family);
+    static QString resolveFontFamilyAlias(const QString &family);
 #if defined(Q_WS_QWS) || defined(Q_WS_QPA) || defined(Q_OS_SYMBIAN)
     static QFontEngine *findFont(int script, const QFontPrivate *fp, const QFontDef &request);
 #endif
diff --git a/src/gui/text/qfontdatabase_qpa.cpp b/src/gui/text/qfontdatabase_qpa.cpp
index e6d99c6..7bcce56 100644
--- a/src/gui/text/qfontdatabase_qpa.cpp
+++ b/src/gui/text/qfontdatabase_qpa.cpp
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/text/qfontdatabase_x11.cpp b/src/gui/text/qfontdatabase_x11.cpp
index 2186058..02b0148 100644
--- a/src/gui/text/qfontdatabase_x11.cpp
+++ b/src/gui/text/qfontdatabase_x11.cpp
@@ -1972,17 +1972,6 @@ void QFontDatabase::load(const QFontPrivate *d, int script)
 #ifndef QT_NO_FONTCONFIG
         } else if (X11->has_fontconfig) {
             fe = loadFc(d, script, req);
-            if (fe != 0 && fe->fontDef.pixelSize != req.pixelSize && mainThread && qt_is_gui_used) {
-                QFontEngine *xlfdFontEngine = loadXlfd(d->screen, script, req);
-                if (xlfdFontEngine->fontDef.family == fe->fontDef.family) {
-                    delete fe;
-                    fe = xlfdFontEngine;
-                } else {
-                    delete xlfdFontEngine;
-                }
-            }
-
-
 #endif
         } else if (mainThread && qt_is_gui_used) {
             fe = loadXlfd(d->screen, script, req);
@@ -2131,4 +2120,26 @@ bool QFontDatabase::supportsThreadedFontRendering()
 #endif
 }
 
+QString QFontDatabase::resolveFontFamilyAlias(const QString &family)
+{
+#if defined(QT_NO_FONTCONFIG)
+    return family;
+#else
+    FcPattern *pattern = FcPatternCreate();
+    if (!pattern)
+        return family;
+
+    FcPatternAddString(pattern, FC_FAMILY, (const FcChar8 *) family.toUtf8().data());
+    FcConfigSubstitute(0, pattern, FcMatchPattern);
+    FcDefaultSubstitute(pattern);
+
+    FcChar8 *familyAfterSubstitution;
+    FcPatternGetString(pattern, FC_FAMILY, 0, &familyAfterSubstitution);
+    QString resolved = QString::fromUtf8((const char *) familyAfterSubstitution);
+    FcPatternDestroy(pattern);
+
+    return resolved;
+#endif
+}
+
 QT_END_NAMESPACE
diff --git a/src/gui/text/qfontengine_coretext.mm b/src/gui/text/qfontengine_coretext.mm
index 2ae60b1..526b566 100644
--- a/src/gui/text/qfontengine_coretext.mm
+++ b/src/gui/text/qfontengine_coretext.mm
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
@@ -234,7 +234,8 @@ bool QCoreTextFontEngineMulti::stringToCMap(const QChar *str, int len, QGlyphLay
                 int idx = rtlOffset + rtlSign * i;
                 outGlyphs[idx] = tmpGlyphs[i] | fontIndex;
                 outAdvances_x[idx] = QFixed::fromReal(tmpPoints[i + 1].x - tmpPoints[i].x);
-                outAdvances_y[idx] = QFixed::fromReal(tmpPoints[i + 1].y - tmpPoints[i].y);
+                // Use negative y advance for flipped coordinate system
+                outAdvances_y[idx] = QFixed::fromReal(tmpPoints[i].y - tmpPoints[i + 1].y);
 
                 if (fontDef.styleStrategy & QFont::ForceIntegerMetrics) {
                     outAdvances_x[idx] = outAdvances_x[idx].round();
diff --git a/src/gui/text/qfontengine_coretext_p.h b/src/gui/text/qfontengine_coretext_p.h
index b4450fa..7d17aef 100644
--- a/src/gui/text/qfontengine_coretext_p.h
+++ b/src/gui/text/qfontengine_coretext_p.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/text/qfontengine_mac_p.h b/src/gui/text/qfontengine_mac_p.h
index 5577c76..6967348 100644
--- a/src/gui/text/qfontengine_mac_p.h
+++ b/src/gui/text/qfontengine_mac_p.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/text/qfontengine_qpa.cpp b/src/gui/text/qfontengine_qpa.cpp
index cccbc92..851bb59 100644
--- a/src/gui/text/qfontengine_qpa.cpp
+++ b/src/gui/text/qfontengine_qpa.cpp
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/text/qfontengine_qpa_p.h b/src/gui/text/qfontengine_qpa_p.h
index 467fca6..e15beae 100644
--- a/src/gui/text/qfontengine_qpa_p.h
+++ b/src/gui/text/qfontengine_qpa_p.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/text/qfontengine_qws.cpp b/src/gui/text/qfontengine_qws.cpp
index 4802b94..b71c4a7 100644
--- a/src/gui/text/qfontengine_qws.cpp
+++ b/src/gui/text/qfontengine_qws.cpp
@@ -288,13 +288,16 @@ private:
 #else
     void readNode(QIODevice& f)
     {
-        uchar rw = f.getch();
-        uchar cl = f.getch();
+        char rw;
+        char cl;
+        f.getChar(&rw);
+        f.getChar(&cl);
         min = (rw << 8) | cl;
-        rw = f.getch();
-        cl = f.getch();
+        f.getChar(&rw);
+        f.getChar(&cl);
         max = (rw << 8) | cl;
-        int flags = f.getch();
+        char flags;
+        f.getChar(&flags);
         if ( flags & 1 )
             less = new QPFGlyphTree;
         else
@@ -332,7 +335,7 @@ private:
         int n = max-min+1;
         for (int i=0; i<n; i++) {
             glyph[i].metrics = new QPFGlyphMetrics;
-            f.readBlock((char*)glyph[i].metrics, sizeof(QPFGlyphMetrics));
+            f.read((char*)glyph[i].metrics, sizeof(QPFGlyphMetrics));
         }
         if ( less )
             less->readMetrics(f);
@@ -365,7 +368,7 @@ private:
             //############### s = qt_screen->mapToDevice( s );
             uint datasize = glyph[i].metrics->linestep * s.height();
             glyph[i].data = new uchar[datasize]; // ### deleted?
-            f.readBlock((char*)glyph[i].data, datasize);
+            f.read((char*)glyph[i].data, datasize);
         }
         if ( less )
             less->readData(f);
@@ -385,6 +388,32 @@ public:
     size_t mmapLength;
 };
 
+#if defined(Q_OS_INTEGRITY)
+static void *qt_mmap(void *start, size_t length, int /*prot*/, int /*flags*/, int fd, off_t offset)
+{
+    // INTEGRITY cannot mmap local files - load it into a local buffer
+    if (::lseek(fd, offset, SEEK_SET) == -1) {
+#  if defined(DEBUG_FONTENGINE)
+        perror("lseek failed");
+#  endif
+    }
+    void *buf = malloc(length);
+    if (::read(fd, buf, length) != (ssize_t)length) {
+#  if defined(DEBUG_FONTENGINE)
+        perror("read failed");
+#  endif
+    }
+
+    return buf;
+}
+#else
+static inline void *qt_mmap(void *start, size_t length, int prot, int flags, int fd, off_t offset)
+{
+    return mmap(start, length, prot, flags, fd, offset);
+}
+#endif
+
+
 
 QFontEngineQPF1::QFontEngineQPF1(const QFontDef&, const QString &fn)
 {
@@ -395,16 +424,18 @@ QFontEngineQPF1::QFontEngineQPF1(const QFontDef&, const QString &fn)
     QT_STATBUF st;
     if ( QT_FSTAT( f, &st ) )
         qFatal("Failed to stat %s",QFile::encodeName(fn).data());
-    uchar* data = (uchar*)mmap( 0, // any address
+    uchar* data = (uchar*)qt_mmap( 0, // any address
                                 st.st_size, // whole file
                                 PROT_READ, // read-only memory
-#if !defined(Q_OS_SOLARIS) && !defined(Q_OS_QNX4) && !defined(Q_OS_INTEGRITY) && !defined(Q_OS_VXWORKS)
+#if defined(Q_OS_INTEGRITY)
+	                        0,
+#elif !defined(Q_OS_SOLARIS) && !defined(Q_OS_QNX4) && !defined(Q_OS_VXWORKS)
                                 MAP_FILE | MAP_PRIVATE, // swap-backed map from file
 #else
                                 MAP_PRIVATE,
 #endif
                                 f, 0 ); // from offset 0 of f
-#if defined(Q_OS_QNX4) && !defined(MAP_FAILED)
+#if !defined(MAP_FAILED) && (defined(Q_OS_QNX4) || defined(Q_OS_INTEGRITY))
 #define MAP_FAILED ((void *)-1)
 #endif
     if ( !data || data == (uchar*)MAP_FAILED )
diff --git a/src/gui/text/qglyphs.cpp b/src/gui/text/qglyphs.cpp
index 2447752..affa08a 100644
--- a/src/gui/text/qglyphs.cpp
+++ b/src/gui/text/qglyphs.cpp
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/text/qglyphs.h b/src/gui/text/qglyphs.h
index 282ecb4..5f37136 100644
--- a/src/gui/text/qglyphs.h
+++ b/src/gui/text/qglyphs.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/text/qglyphs_p.h b/src/gui/text/qglyphs_p.h
index c39f5d0..c632e2f 100644
--- a/src/gui/text/qglyphs_p.h
+++ b/src/gui/text/qglyphs_p.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/text/qplatformfontdatabase_qpa.cpp b/src/gui/text/qplatformfontdatabase_qpa.cpp
index afe762a..6fa25e7 100644
--- a/src/gui/text/qplatformfontdatabase_qpa.cpp
+++ b/src/gui/text/qplatformfontdatabase_qpa.cpp
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
@@ -214,7 +214,7 @@ QFontEngine *QPlatformFontDatabase::fontEngine(const QFontDef &fontDef, QUnicode
     Q_UNUSED(handle);
     QByteArray *fileDataPtr = static_cast<QByteArray *>(handle);
     QFontEngineQPA *engine = new QFontEngineQPA(fontDef,*fileDataPtr);
-    qDebug() << fontDef.pixelSize << fontDef.weight << fontDef.style << fontDef.stretch << fontDef.styleHint << fontDef.styleStrategy << fontDef.family << script;
+    //qDebug() << fontDef.pixelSize << fontDef.weight << fontDef.style << fontDef.stretch << fontDef.styleHint << fontDef.styleStrategy << fontDef.family << script;
     return engine;
 }
 
diff --git a/src/gui/text/qplatformfontdatabase_qpa.h b/src/gui/text/qplatformfontdatabase_qpa.h
index a1faea9..e0e4f04 100644
--- a/src/gui/text/qplatformfontdatabase_qpa.h
+++ b/src/gui/text/qplatformfontdatabase_qpa.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/text/qtextcontrol.cpp b/src/gui/text/qtextcontrol.cpp
index 46f1d62..b7a2697 100644
--- a/src/gui/text/qtextcontrol.cpp
+++ b/src/gui/text/qtextcontrol.cpp
@@ -285,7 +285,7 @@ bool QTextControlPrivate::cursorMoveKeyEvent(QKeyEvent *e)
         if (cursor.position() != oldCursorPos)
             emit q->cursorPositionChanged();
         emit q->microFocusChanged();
-    } else if (ignoreNavigationEvents && isNavigationEvent) {
+    } else if (ignoreNavigationEvents && isNavigationEvent && oldSelection.anchor() == cursor.anchor()) {
         return false;
     }
 
@@ -1608,7 +1608,10 @@ void QTextControlPrivate::mouseMoveEvent(QEvent *e, Qt::MouseButton button, cons
     if (!(buttons & Qt::LeftButton))
         return;
 
-    if (!((interactionFlags & Qt::TextSelectableByMouse) || (interactionFlags & Qt::TextEditable)))
+    const bool selectable = interactionFlags & Qt::TextSelectableByMouse;
+    const bool editable = interactionFlags & Qt::TextEditable;
+
+    if (!selectable && !editable)
         return;
 
     if (!(mousePressed
@@ -1624,6 +1627,10 @@ void QTextControlPrivate::mouseMoveEvent(QEvent *e, Qt::MouseButton button, cons
             startDrag();
         return;
     }
+
+    if (!selectable)
+        return;
+
     const qreal mouseX = qreal(mousePos.x());
 
     int newCursorPos = q->hitTest(mousePos, Qt::FuzzyHit);
@@ -1639,7 +1646,7 @@ void QTextControlPrivate::mouseMoveEvent(QEvent *e, Qt::MouseButton button, cons
         extendBlockwiseSelection(newCursorPos);
     else if (selectedWordOnDoubleClick.hasSelection())
         extendWordwiseSelection(newCursorPos, mouseX);
-    else if (interactionFlags & Qt::TextSelectableByMouse)
+    else
         setCursorPosition(newCursorPos, QTextCursor::KeepAnchor);
 
     if (interactionFlags & Qt::TextEditable) {
@@ -1650,8 +1657,10 @@ void QTextControlPrivate::mouseMoveEvent(QEvent *e, Qt::MouseButton button, cons
             emit q->cursorPositionChanged();
         _q_updateCurrentCharFormatAndSelection();
 #ifndef QT_NO_IM
-        if (QInputContext *ic = inputContext()) {
-            ic->update();
+        if (contextWidget) {
+            if (QInputContext *ic = inputContext()) {
+                ic->update();
+            }
         }
 #endif //QT_NO_IM
     } else {
diff --git a/src/gui/text/qtextengine_mac.cpp b/src/gui/text/qtextengine_mac.cpp
index c0a1e64..97e8c5b 100644
--- a/src/gui/text/qtextengine_mac.cpp
+++ b/src/gui/text/qtextengine_mac.cpp
@@ -607,8 +607,9 @@ void QTextEngine::shapeTextMac(int item) const
     bool stringToCMapFailed = false;
     if (!fe->stringToCMap(str, len, &g, &num_glyphs, flags, log_clusters, attributes())) {
         ensureSpace(num_glyphs);
-        stringToCMapFailed = fe->stringToCMap(str, len, &g, &num_glyphs, flags, log_clusters,
-                                              attributes());
+        g = availableGlyphs(&si);
+        stringToCMapFailed = !fe->stringToCMap(str, len, &g, &num_glyphs, flags, log_clusters,
+                                               attributes());
     }
 
     if (!stringToCMapFailed) {
diff --git a/src/gui/text/qtextlayout.cpp b/src/gui/text/qtextlayout.cpp
index 354e8a9..8eff7d2 100644
--- a/src/gui/text/qtextlayout.cpp
+++ b/src/gui/text/qtextlayout.cpp
@@ -1754,6 +1754,7 @@ namespace {
         int glyphCount;
         int maxGlyphs;
         int currentPosition;
+        glyph_t previousGlyph;
 
         QFixed minw;
         QFixed softHyphenWidth;
@@ -1781,6 +1782,15 @@ namespace {
             return glyphs.glyphs[logClusters[currentPosition - 1]];
         }
 
+        inline void saveCurrentGlyph()
+        {
+            previousGlyph = 0;
+            if (currentPosition > 0 &&
+                logClusters[currentPosition - 1] < glyphs.numGlyphs) {
+                previousGlyph = currentGlyph(); // needed to calculate right bearing later
+            }
+        }
+
         inline void adjustRightBearing(glyph_t glyph)
         {
             qreal rb;
@@ -1795,6 +1805,12 @@ namespace {
             adjustRightBearing(currentGlyph());
         }
 
+        inline void adjustPreviousRightBearing()
+        {
+            if (previousGlyph > 0)
+                adjustRightBearing(previousGlyph);
+        }
+
         inline void resetRightBearing()
         {
             rightBearing = QFixed(1); // Any positive number is defined as invalid since only
@@ -1871,22 +1887,7 @@ void QTextLine::layout_helper(int maxGlyphs)
     lbh.manualWrap = (wrapMode == QTextOption::ManualWrap || wrapMode == QTextOption::NoWrap);
 
     int item = -1;
-    int newItem = -1;
-    int left = 0;
-    int right = eng->layoutData->items.size()-1;
-    while(left <= right) {
-        int middle = ((right-left)/2)+left;
-        if (line.from > eng->layoutData->items[middle].position)
-            left = middle+1;
-        else if(line.from < eng->layoutData->items[middle].position)
-            right = middle-1;
-        else {
-            newItem = middle;
-            break;
-        }
-    }
-    if (newItem == -1)
-        newItem = right;
+    int newItem = eng->findItem(line.from);
 
     LB_DEBUG("from: %d: item=%d, total %d, width available %f", line.from, newItem, eng->layoutData->items.size(), line.width.toReal());
 
@@ -1898,6 +1899,7 @@ void QTextLine::layout_helper(int maxGlyphs)
     lbh.currentPosition = line.from;
     int end = 0;
     lbh.logClusters = eng->layoutData->logClustersPtr;
+    lbh.previousGlyph = 0;
 
     while (newItem < eng->layoutData->items.size()) {
         lbh.resetRightBearing();
@@ -1958,6 +1960,7 @@ void QTextLine::layout_helper(int maxGlyphs)
                                current, lbh.logClusters, lbh.glyphs);
             } else {
                 lbh.tmpData.length++;
+                lbh.adjustPreviousRightBearing();
             }
             line += lbh.tmpData;
             goto found;
@@ -1988,9 +1991,7 @@ void QTextLine::layout_helper(int maxGlyphs)
         } else {
             lbh.whiteSpaceOrObject = false;
             bool sb_or_ws = false;
-            glyph_t previousGlyph = 0;
-            if (lbh.currentPosition > 0 && lbh.logClusters[lbh.currentPosition - 1] <lbh.glyphs.numGlyphs)
-                previousGlyph = lbh.currentGlyph(); // needed to calculate right bearing later
+            lbh.saveCurrentGlyph();
             do {
                 addNextCluster(lbh.currentPosition, end, lbh.tmpData, lbh.glyphCount,
                                current, lbh.logClusters, lbh.glyphs);
@@ -2015,7 +2016,7 @@ void QTextLine::layout_helper(int maxGlyphs)
                 //  b) if we are so short of available width that the
                 //     soft hyphen is the first breakable position, then
                 //     we don't want to show it. However we initially
-                //     have to take the width for it into accoun so that
+                //     have to take the width for it into account so that
                 //     the text document layout sees the overflow and
                 //     switch to break-anywhere mode, in which we
                 //     want the soft-hyphen to slip into the next line
@@ -2043,8 +2044,9 @@ void QTextLine::layout_helper(int maxGlyphs)
                     // we are too wide, fix right bearing
                     if (rightBearing <= 0)
                         lbh.rightBearing = rightBearing; // take from cache
-                    else if (previousGlyph > 0)
-                        lbh.adjustRightBearing(previousGlyph);
+                    else
+                        lbh.adjustPreviousRightBearing();
+
                     if (!breakany) {
                         line.textWidth += lbh.softHyphenWidth;
                     }
@@ -2052,6 +2054,7 @@ void QTextLine::layout_helper(int maxGlyphs)
                     goto found;
                 }
             }
+            lbh.saveCurrentGlyph();
         }
         if (lbh.currentPosition == end)
             newItem = item + 1;
diff --git a/src/gui/text/qtextobject.cpp b/src/gui/text/qtextobject.cpp
index c5b6e14..0081550 100644
--- a/src/gui/text/qtextobject.cpp
+++ b/src/gui/text/qtextobject.cpp
@@ -1504,7 +1504,7 @@ QTextBlock QTextBlock::next() const
 */
 QTextBlock QTextBlock::previous() const
 {
-    if (!isValid())
+    if (!p)
         return QTextBlock();
 
     return QTextBlock(p, p->blockMap().previous(n));
diff --git a/src/gui/util/qflickgesture.cpp b/src/gui/util/qflickgesture.cpp
index eb0cc8d..8baca07 100644
--- a/src/gui/util/qflickgesture.cpp
+++ b/src/gui/util/qflickgesture.cpp
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/util/qflickgesture_p.h b/src/gui/util/qflickgesture_p.h
index c3c263b..451b579 100644
--- a/src/gui/util/qflickgesture_p.h
+++ b/src/gui/util/qflickgesture_p.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/util/qscroller.cpp b/src/gui/util/qscroller.cpp
index d60f44e..ac5607c 100644
--- a/src/gui/util/qscroller.cpp
+++ b/src/gui/util/qscroller.cpp
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/util/qscroller.h b/src/gui/util/qscroller.h
index 7d7e1ca..a026be4 100644
--- a/src/gui/util/qscroller.h
+++ b/src/gui/util/qscroller.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/util/qscroller_mac.mm b/src/gui/util/qscroller_mac.mm
index 3203036..4bf69c1 100644
--- a/src/gui/util/qscroller_mac.mm
+++ b/src/gui/util/qscroller_mac.mm
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
@@ -39,12 +39,14 @@
 **
 ****************************************************************************/
 
+#include <QtCore/qglobal.h>
+
+#ifdef Q_WS_MAC
+
 #import <Cocoa/Cocoa.h>
 
 #include "qscroller_p.h"
 
-#ifdef Q_WS_MAC
-
 QPointF QScrollerPrivate::realDpi(int screen)
 {
     NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
diff --git a/src/gui/util/qscroller_p.h b/src/gui/util/qscroller_p.h
index d16eef9..fb2b257 100644
--- a/src/gui/util/qscroller_p.h
+++ b/src/gui/util/qscroller_p.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/util/qscrollerproperties.cpp b/src/gui/util/qscrollerproperties.cpp
index b159e05..85e2e82 100644
--- a/src/gui/util/qscrollerproperties.cpp
+++ b/src/gui/util/qscrollerproperties.cpp
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/util/qscrollerproperties.h b/src/gui/util/qscrollerproperties.h
index e292d8d..75d8932 100644
--- a/src/gui/util/qscrollerproperties.h
+++ b/src/gui/util/qscrollerproperties.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/util/qscrollerproperties_p.h b/src/gui/util/qscrollerproperties_p.h
index 093f615..76d8b0a 100644
--- a/src/gui/util/qscrollerproperties_p.h
+++ b/src/gui/util/qscrollerproperties_p.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
diff --git a/src/gui/util/qsystemtrayicon_win.cpp b/src/gui/util/qsystemtrayicon_win.cpp
index 2b7935b..5a0e179 100644
--- a/src/gui/util/qsystemtrayicon_win.cpp
+++ b/src/gui/util/qsystemtrayicon_win.cpp
@@ -305,6 +305,7 @@ bool QSystemTrayIconSys::winEvent( MSG *m, long *result )
             case WM_CONTEXTMENU:
                 if (q->contextMenu()) {
                     q->contextMenu()->popup(gpos);
+                    q->contextMenu()->activateWindow();
                 }
                 emit q->activated(QSystemTrayIcon::Context);
                 break;
diff --git a/src/gui/widgets/qdialogbuttonbox.cpp b/src/gui/widgets/qdialogbuttonbox.cpp
index 5f17a2b..6fe87b6 100644
--- a/src/gui/widgets/qdialogbuttonbox.cpp
+++ b/src/gui/widgets/qdialogbuttonbox.cpp
@@ -562,6 +562,14 @@ QPushButton *QDialogButtonBoxPrivate::createButton(QDialogButtonBox::StandardBut
     } else {
         qWarning("QDialogButtonBox::createButton: Invalid ButtonRole, button not added");
     }
+
+#ifdef Q_WS_MAC
+    // Since mnemonics is off by default on Mac, we add a Cmd-D
+    // shortcut here to e.g. make the "Don't Save" button work nativly:
+    if (sbutton == QDialogButtonBox::Discard)
+        button->setShortcut(QKeySequence(QLatin1String("Ctrl+D")));
+#endif
+
     return button;
 }
 
diff --git a/src/gui/widgets/qeffects.cpp b/src/gui/widgets/qeffects.cpp
index 8e1e7c3..6b64d48 100644
--- a/src/gui/widgets/qeffects.cpp
+++ b/src/gui/widgets/qeffects.cpp
@@ -55,19 +55,6 @@
 QT_BEGIN_NAMESPACE
 
 /*
-  Internal class to get access to protected QWidget-members
-*/
-
-class QAccessWidget : public QWidget
-{
-    friend class QAlphaWidget;
-    friend class QRollEffect;
-public:
-    QAccessWidget(QWidget* parent=0, Qt::WindowFlags f = 0)
-        : QWidget(parent, f) {}
-};
-
-/*
   Internal class QAlphaWidget.
 
   The QAlphaWidget is shown while the animation lasts
@@ -98,13 +85,12 @@ private:
     QImage backImage;
     QImage frontImage;
     QImage mixedImage;
-    QPointer<QAccessWidget> widget;
+    QPointer<QWidget> widget;
     int duration;
     int elapsed;
     bool showWidget;
     QTimer anim;
     QElapsedTimer checkTime;
-    double windowOpacity;
 };
 
 static QAlphaWidget* q_blend = 0;
@@ -119,8 +105,7 @@ QAlphaWidget::QAlphaWidget(QWidget* w, Qt::WindowFlags f)
     setEnabled(false);
 #endif
     setAttribute(Qt::WA_NoSystemBackground, true);
-    widget = (QAccessWidget*)w;
-    windowOpacity = w->windowOpacity();
+    widget = w;
     alpha = 0;
 }
 
@@ -129,7 +114,7 @@ QAlphaWidget::~QAlphaWidget()
 #if defined(Q_WS_WIN) && !defined(Q_WS_WINCE)
     // Restore user-defined opacity value
     if (widget)
-        widget->setWindowOpacity(windowOpacity);
+        widget->setWindowOpacity(1);
 #endif
 }
 
@@ -268,10 +253,10 @@ void QAlphaWidget::render()
         alpha = 1;
 
 #if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)
-    if (alpha >= windowOpacity || !showWidget) {
+    if (alpha >= 1 || !showWidget) {
         anim.stop();
         qApp->removeEventFilter(this);
-        widget->setWindowOpacity(windowOpacity);
+        widget->setWindowOpacity(1);
         q_blend = 0;
         deleteLater();
     } else {
@@ -370,7 +355,7 @@ private slots:
     void scroll();
 
 private:
-    QPointer<QAccessWidget> widget;
+    QPointer<QWidget> widget;
 
     int currentHeight;
     int currentWidth;
@@ -401,7 +386,7 @@ QRollEffect::QRollEffect(QWidget* w, Qt::WindowFlags f, DirFlags orient)
     setEnabled(false);
 #endif
 
-    widget = (QAccessWidget*) w;
+    widget = w;
     Q_ASSERT(widget);
 
     setAttribute(Qt::WA_NoSystemBackground, true);
diff --git a/src/gui/widgets/qlinecontrol.cpp b/src/gui/widgets/qlinecontrol.cpp
index 023b9ee..3eac64a 100644
--- a/src/gui/widgets/qlinecontrol.cpp
+++ b/src/gui/widgets/qlinecontrol.cpp
@@ -414,13 +414,17 @@ void QLineControl::processInputMethodEvent(QInputMethodEvent *event)
     if (isGettingInput) {
         // If any text is being input, remove selected text.
         priorState = m_undoState;
+        if (echoMode() == QLineEdit::PasswordEchoOnEdit && !passwordEchoEditing()) {
+            updatePasswordEchoEditing(true);
+            m_selstart = 0;
+            m_selend = m_text.length();
+        }
         removeSelectedText();
     }
 
-
     int c = m_cursor; // cursor position after insertion of commit string
     if (event->replacementStart() <= 0)
-        c += event->commitString().length() + qMin(-event->replacementStart(), event->replacementLength());
+        c += event->commitString().length() - qMin(-event->replacementStart(), event->replacementLength());
 
     m_cursor += event->replacementStart();
 
diff --git a/src/gui/widgets/qmdiarea.cpp b/src/gui/widgets/qmdiarea.cpp
index b02db4c..2a486bb 100644
--- a/src/gui/widgets/qmdiarea.cpp
+++ b/src/gui/widgets/qmdiarea.cpp
@@ -674,6 +674,8 @@ QMdiAreaPrivate::QMdiAreaPrivate()
       viewMode(QMdiArea::SubWindowView),
 #ifndef QT_NO_TABBAR
       documentMode(false),
+      tabsClosable(false),
+      tabsMovable(false),
 #endif
 #ifndef QT_NO_TABWIDGET
       tabShape(QTabWidget::Rounded),
@@ -792,6 +794,27 @@ void QMdiAreaPrivate::_q_currentTabChanged(int index)
 #endif // QT_NO_TABBAR
 }
 
+void QMdiAreaPrivate::_q_closeTab(int index)
+{
+#ifdef QT_NO_TABBAR
+    Q_UNUSED(index);
+#else
+    QMdiSubWindow *subWindow = childWindows.at(index);
+    Q_ASSERT(subWindow);
+    subWindow->close();
+#endif // QT_NO_TABBAR
+}
+
+void QMdiAreaPrivate::_q_moveTab(int from, int to)
+{
+#ifdef QT_NO_TABBAR
+    Q_UNUSED(from);
+    Q_UNUSED(to);
+#else
+    childWindows.move(from, to);
+#endif // QT_NO_TABBAR
+}
+
 /*!
     \internal
 */
@@ -1519,6 +1542,8 @@ void QMdiAreaPrivate::setViewMode(QMdiArea::ViewMode mode)
         Q_ASSERT(!tabBar);
         tabBar = new QMdiAreaTabBar(q);
         tabBar->setDocumentMode(documentMode);
+        tabBar->setTabsClosable(tabsClosable);
+        tabBar->setMovable(tabsMovable);
 #ifndef QT_NO_TABWIDGET
         tabBar->setShape(tabBarShapeFrom(tabShape, tabPosition));
 #endif
@@ -1550,6 +1575,8 @@ void QMdiAreaPrivate::setViewMode(QMdiArea::ViewMode mode)
         updateTabBarGeometry();
 
         QObject::connect(tabBar, SIGNAL(currentChanged(int)), q, SLOT(_q_currentTabChanged(int)));
+        QObject::connect(tabBar, SIGNAL(tabCloseRequested(int)), q, SLOT(_q_closeTab(int)));
+        QObject::connect(tabBar, SIGNAL(tabMoved(int,int)), q, SLOT(_q_moveTab(int,int)));
     } else
 #endif // QT_NO_TABBAR
     { // SubWindowView
@@ -1636,6 +1663,8 @@ void QMdiAreaPrivate::refreshTabBar()
         return;
 
     tabBar->setDocumentMode(documentMode);
+    tabBar->setTabsClosable(tabsClosable);
+    tabBar->setMovable(tabsMovable);
 #ifndef QT_NO_TABWIDGET
     tabBar->setShape(tabBarShapeFrom(tabShape, tabPosition));
 #endif
@@ -2114,6 +2143,56 @@ void QMdiArea::setDocumentMode(bool enabled)
     d->documentMode = enabled;
     d->refreshTabBar();
 }
+
+/*!
+    \property QMdiArea::tabsClosable
+    \brief whether the tab bar should place close buttons on each tab in tabbed view mode.
+    \since 4.8
+
+    Tabs are not closable by default.
+
+    \sa QTabBar::tabsClosable, setViewMode()
+*/
+bool QMdiArea::tabsClosable() const
+{
+    Q_D(const QMdiArea);
+    return d->tabsClosable;
+}
+
+void QMdiArea::setTabsClosable(bool closable)
+{
+    Q_D(QMdiArea);
+    if (d->tabsClosable == closable)
+        return;
+
+    d->tabsClosable = closable;
+    d->refreshTabBar();
+}
+
+/*!
+    \property QMdiArea::tabsMovable
+    \brief whether the user can move the tabs within the tabbar area in tabbed view mode.
+    \since 4.8
+
+    Tabs are not movable by default.
+
+    \sa QTabBar::tabsMovable, setViewMode()
+*/
+bool QMdiArea::tabsMovable() const
+{
+    Q_D(const QMdiArea);
+    return d->tabsMovable;
+}
+
+void QMdiArea::setTabsMovable(bool movable)
+{
+    Q_D(QMdiArea);
+    if (d->tabsMovable == movable)
+        return;
+
+    d->tabsMovable = movable;
+    d->refreshTabBar();
+}
 #endif // QT_NO_TABBAR
 
 #ifndef QT_NO_TABWIDGET
diff --git a/src/gui/widgets/qmdiarea.h b/src/gui/widgets/qmdiarea.h
index 809bfe4..a4b357c 100644
--- a/src/gui/widgets/qmdiarea.h
+++ b/src/gui/widgets/qmdiarea.h
@@ -65,6 +65,8 @@ class Q_GUI_EXPORT QMdiArea : public QAbstractScrollArea
     Q_PROPERTY(ViewMode viewMode READ viewMode WRITE setViewMode)
 #ifndef QT_NO_TABBAR
     Q_PROPERTY(bool documentMode READ documentMode WRITE setDocumentMode)
+    Q_PROPERTY(bool tabsClosable READ tabsClosable WRITE setTabsClosable)
+    Q_PROPERTY(bool tabsMovable READ tabsMovable WRITE setTabsMovable)
 #endif
 #ifndef QT_NO_TABWIDGET
     Q_PROPERTY(QTabWidget::TabShape tabShape READ tabShape WRITE setTabShape)
@@ -116,6 +118,12 @@ public:
 #ifndef QT_NO_TABBAR
     bool documentMode() const;
     void setDocumentMode(bool enabled);
+
+    void setTabsClosable(bool closable);
+    bool tabsClosable() const;
+
+    void setTabsMovable(bool movable);
+    bool tabsMovable() const;
 #endif
 #ifndef QT_NO_TABWIDGET
     void setTabShape(QTabWidget::TabShape shape);
@@ -156,7 +164,9 @@ private:
     Q_DECLARE_PRIVATE(QMdiArea)
     Q_PRIVATE_SLOT(d_func(), void _q_deactivateAllWindows())
     Q_PRIVATE_SLOT(d_func(), void _q_processWindowStateChanged(Qt::WindowStates, Qt::WindowStates))
-    Q_PRIVATE_SLOT(d_func(), void _q_currentTabChanged(int index))
+    Q_PRIVATE_SLOT(d_func(), void _q_currentTabChanged(int))
+    Q_PRIVATE_SLOT(d_func(), void _q_closeTab(int))
+    Q_PRIVATE_SLOT(d_func(), void _q_moveTab(int, int))
 };
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(QMdiArea::AreaOptions)
diff --git a/src/gui/widgets/qmdiarea_p.h b/src/gui/widgets/qmdiarea_p.h
index 5d85659..e5e2057 100644
--- a/src/gui/widgets/qmdiarea_p.h
+++ b/src/gui/widgets/qmdiarea_p.h
@@ -165,6 +165,8 @@ public:
     QMdiArea::ViewMode viewMode;
 #ifndef QT_NO_TABBAR
     bool documentMode;
+    bool tabsClosable;
+    bool tabsMovable;
 #endif
 #ifndef QT_NO_TABWIDGET
     QTabWidget::TabShape tabShape;
@@ -189,6 +191,8 @@ public:
     void _q_deactivateAllWindows(QMdiSubWindow *aboutToActivate = 0);
     void _q_processWindowStateChanged(Qt::WindowStates oldState, Qt::WindowStates newState);
     void _q_currentTabChanged(int index);
+    void _q_closeTab(int index);
+    void _q_moveTab(int from, int to);
 
     // Functions.
     void appendChild(QMdiSubWindow *child);
diff --git a/src/gui/widgets/qtoolbarlayout.cpp b/src/gui/widgets/qtoolbarlayout.cpp
index 813ec3e..531acb4 100644
--- a/src/gui/widgets/qtoolbarlayout.cpp
+++ b/src/gui/widgets/qtoolbarlayout.cpp
@@ -647,15 +647,15 @@ QSize QToolBarLayout::expandedSize(const QSize &size) const
 
 void QToolBarLayout::setExpanded(bool exp)
 {
-    if (exp == expanded)
+    QWidget *tb = qobject_cast<QToolBar*>(parentWidget());
+    if (!tb)
+        return;
+    if (exp == expanded && !tb->isWindow())
         return;
 
     expanded = exp;
     extension->setChecked(expanded);
 
-    QToolBar *tb = qobject_cast<QToolBar*>(parentWidget());
-    if (!tb)
-        return;
     if (QMainWindow *win = qobject_cast<QMainWindow*>(tb->parentWidget())) {
 #ifdef QT_NO_DOCKWIDGET
         animating = false;