Merge remote-tracking branch 'origin/master' into lighthouse-master

116 files changed, 4423 insertions, 1700 deletions

diff --git a/src/gui/dialogs/qfiledialog.cpp b/src/gui/dialogs/qfiledialog.cpp
index e81773b..0c1304f 100644
--- a/src/gui/dialogs/qfiledialog.cpp
+++ b/src/gui/dialogs/qfiledialog.cpp
@@ -1770,7 +1770,7 @@ QString QFileDialog::getOpenFileName(QWidget *parent,
 
     On Symbian^3 the parameter \a selectedFilter has no meaning and the
     \a options parameter is only used to define if the native file dialog is
-    used.
+    used. On Symbian^3, this function can only return a single filename.
 
     \warning Do not delete \a parent during the execution of the dialog. If you
     want to do this, you should create the dialog yourself using one of the
diff --git a/src/gui/dialogs/qfiledialog_symbian.cpp b/src/gui/dialogs/qfiledialog_symbian.cpp
index e7197bd..ed98950 100644
--- a/src/gui/dialogs/qfiledialog_symbian.cpp
+++ b/src/gui/dialogs/qfiledialog_symbian.cpp
@@ -54,6 +54,9 @@
 
 QT_BEGIN_NAMESPACE
 
+extern QStringList qt_make_filter_list(const QString &filter); // defined in qfiledialog.cpp
+extern QStringList qt_clean_filter_list(const QString &filter); // defined in qfiledialog.cpp
+
 enum DialogMode { DialogOpen, DialogSave, DialogFolder };
 #if defined(Q_WS_S60) && defined(SYMBIAN_VERSION_SYMBIAN3)
 class CExtensionFilter : public MAknFileFilter
@@ -61,56 +64,39 @@ class CExtensionFilter : public MAknFileFilter
 public:
     void setFilter(const QString filter)
     {
-        filterList.clear();
-        if (filter.left(2) == QLatin1String("*.")) {
-            //Filter has only extensions
-            filterList << filter.split(QLatin1String(" "));
-            return;
-        } else {
-            //Extensions are in parenthesis and there may be several filters
-            QStringList separatedFilters(filter.split(QLatin1String(";;")));
-            for (int i = 0; i < separatedFilters.size(); i++) {
-                if (separatedFilters.at(i).contains(QLatin1String("(*)"))) {
-                    filterList << QLatin1String("(*)");
-                    return;
-                }
-            }
-            QRegExp rx(QLatin1String("\\(([^\\)]*)\\)"));
-            int pos = 0;
-            while ((pos = rx.indexIn(filter, pos)) != -1) {
-                filterList << rx.cap(1).split(QLatin1String(" "));
-                pos += rx.matchedLength();
-            }
+        QStringList unparsedFiltersList = qt_make_filter_list(filter);
+        QStringList filterList;
+        filterRxList.clear();
+
+        foreach (QString unparsedFilter, unparsedFiltersList) {
+            filterList << qt_clean_filter_list(unparsedFilter);
+        }
+        foreach (QString currentFilter, filterList) {
+            QRegExp filterRx(currentFilter, Qt::CaseInsensitive, QRegExp::Wildcard);
+            filterRxList << filterRx;
         }
     }
 
     TBool Accept(const TDesC &/*aDriveAndPath*/, const TEntry &aEntry) const
     {
-        if (aEntry.IsDir())
-            return ETrue;
-
         //If no filter for files, all can be accepted
-        if (filterList.isEmpty())
+        if (filterRxList.isEmpty())
             return ETrue;
 
-        if (filterList == QStringList(QLatin1String("(*)")))
+        if (aEntry.IsDir())
             return ETrue;
 
-        for (int i = 0; i < filterList.size(); ++i) {
-            QString extension = filterList.at(i);
-            //remove '*' from the beginning of the extension
-            if (extension.at(0) == QLatin1Char('*'))
-                extension = extension.mid(1);
-
+        foreach (QRegExp rx, filterRxList) {
             QString fileName = qt_TDesC2QString(aEntry.iName);
-            if (fileName.endsWith(extension))
+            if (rx.exactMatch(fileName))
                 return ETrue;
         }
+
         return EFalse;
     }
 
 private:
-    QStringList filterList;
+    QList<QRegExp> filterRxList;
 };
 #endif
 
@@ -140,11 +126,13 @@ static QString launchSymbianDialog(const QString dialogCaption, const QString st
                 CleanupStack::PushL(extensionFilter);
                 extensionFilter->setFilter(filter);
                 select = AknCommonDialogsDynMem::RunSelectDlgLD(types, target,
-                         startFolder, NULL, NULL, titlePtr, extensionFilter);
+                         startFolder, 0, 0, titlePtr, extensionFilter);
                 CleanupStack::Pop(extensionFilter);
             } else if (dialogMode == DialogSave) {
+                QString defaultFileName = QFileDialogPrivate::initialSelection(startDirectory);
+                target = qt_QString2TPtrC(defaultFileName);
                 select = AknCommonDialogsDynMem::RunSaveDlgLD(types, target,
-                         startFolder, NULL, NULL, titlePtr);
+                         startFolder, 0, 0, titlePtr);
             } else if (dialogMode == DialogFolder) {
                 select = AknCommonDialogsDynMem::RunFolderSelectDlgLD(types, target, startFolder,
                             0, 0, titlePtr, NULL, NULL);
@@ -160,8 +148,10 @@ static QString launchSymbianDialog(const QString dialogCaption, const QString st
             startFolder = qt_QString2TPtrC(dir);
         }
     }
-    if (select)
-        selection.append(qt_TDesC2QString(target));
+    if (select) {
+        QFileInfo fi(qt_TDesC2QString(target));
+        selection = fi.absoluteFilePath();
+    }
 #endif
     return selection;
 }
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/dialogs/qpagesetupdialog.cpp b/src/gui/dialogs/qpagesetupdialog.cpp
index 2a7847e..4037e1c 100644
--- a/src/gui/dialogs/qpagesetupdialog.cpp
+++ b/src/gui/dialogs/qpagesetupdialog.cpp
@@ -107,10 +107,10 @@ class QPageSetupDialogPrivate : public QAbstractPageSetupDialogPrivate
 
     This value is obsolete and does nothing since Qt 4.5:
 
-    \value DontUseSheet In previous versions of Qt, exec() the page setup dialog
-    would create a sheet by default if the dialog was given a parent.
-    This is no longer supported in Qt 4.5.  If you want to use sheets, use
-    QPageSetupDialog::open() instead.
+    \value DontUseSheet In previous versions of QDialog::exec() the
+    page setup dialog would create a sheet by default if the dialog
+    was given a parent.  This is no longer supported from Qt 4.5.  If
+    you want to use sheets, use QPageSetupDialog::open() instead.
 
     \omitvalue None
     \omitvalue OwnsPrinter
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.cpp b/src/gui/embedded/qscreen_qws.cpp
index 4656af8..e207ed1 100644
--- a/src/gui/embedded/qscreen_qws.cpp
+++ b/src/gui/embedded/qscreen_qws.cpp
@@ -1768,7 +1768,7 @@ QImage::Format QScreenPrivate::preferredImageFormat() const
     This function is called by every \l{Qt for Embedded Linux}
     application on startup, and must be implemented to map in the
     framebuffer and the accelerated drivers that the graphics card
-    control registers.  Note that coonnect must be called \e before
+    control registers.  Note that connect must be called \e before
     the initDevice() function.
 
     Ensure that true is returned if a connection to the screen device
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/qgraphicsanchorlayout.cpp b/src/gui/graphicsview/qgraphicsanchorlayout.cpp
index b059bd2..014b61b 100644
--- a/src/gui/graphicsview/qgraphicsanchorlayout.cpp
+++ b/src/gui/graphicsview/qgraphicsanchorlayout.cpp
@@ -56,9 +56,9 @@
     Items that are anchored are automatically added to the layout, and if items
     are removed, all their anchors will be automatically removed.
 
-    \beginfloatleft
+    \div {float-left}
     \inlineimage simpleanchorlayout-example.png Using an anchor layout to align simple colored widgets.
-    \endfloat
+    \enddiv
 
     Anchors are always set up between edges of an item, where the "center" is also considered to
     be an edge. Consider the following example:
diff --git a/src/gui/graphicsview/qgraphicsitem.cpp b/src/gui/graphicsview/qgraphicsitem.cpp
index 01fed8c..ecc8941 100644
--- a/src/gui/graphicsview/qgraphicsitem.cpp
+++ b/src/gui/graphicsview/qgraphicsitem.cpp
@@ -7689,11 +7689,13 @@ void QGraphicsObject::updateMicroFocus()
 
 void QGraphicsItemPrivate::children_append(QDeclarativeListProperty<QGraphicsObject> *list, QGraphicsObject *item)
 {
-    QGraphicsObject *graphicsObject = static_cast<QGraphicsObject *>(list->object);
-    if (QGraphicsItemPrivate::get(graphicsObject)->sendParentChangeNotification) {
-        item->setParentItem(graphicsObject);
-    } else {
-        QGraphicsItemPrivate::get(item)->setParentItemHelper(graphicsObject, 0, 0);
+    if (item) {
+        QGraphicsObject *graphicsObject = static_cast<QGraphicsObject *>(list->object);
+        if (QGraphicsItemPrivate::get(graphicsObject)->sendParentChangeNotification) {
+            item->setParentItem(graphicsObject);
+        } else {
+            QGraphicsItemPrivate::get(item)->setParentItemHelper(graphicsObject, 0, 0);
+        }
     }
 }
 
diff --git a/src/gui/graphicsview/qgraphicsscene.cpp b/src/gui/graphicsview/qgraphicsscene.cpp
index 7b87239..77ccc8e 100644
--- a/src/gui/graphicsview/qgraphicsscene.cpp
+++ b/src/gui/graphicsview/qgraphicsscene.cpp
@@ -130,7 +130,7 @@
     item on the scene gains focus, the scene automatically gains focus. If the
     scene has focus, hasFocus() will return true, and key events will be
     forwarded to the focus item, if any. If the scene loses focus, (i.e.,
-    someone calls clearFocus(),) while an item has focus, the scene will
+    someone calls clearFocus()) while an item has focus, the scene will
     maintain its item focus information, and once the scene regains focus, it
     will make sure the last focus item regains focus.
 
@@ -806,28 +806,23 @@ void QGraphicsScenePrivate::setFocusItemHelper(QGraphicsItem *item,
     }
 
     if (focusItem) {
-        QFocusEvent event(QEvent::FocusOut, focusReason);
         lastFocusItem = focusItem;
-        focusItem = 0;
-        sendEvent(lastFocusItem, &event);
 
 #ifndef QT_NO_IM
         if (lastFocusItem
             && (lastFocusItem->flags() & QGraphicsItem::ItemAcceptsInputMethod)) {
-            // Reset any visible preedit text
-            QInputMethodEvent imEvent;
-            sendEvent(lastFocusItem, &imEvent);
-
             // Close any external input method panel. This happens
             // automatically by removing WA_InputMethodEnabled on
             // the views, but if we are changing focus, we have to
             // do it ourselves.
-            if (item) {
-                for (int i = 0; i < views.size(); ++i)
-                    if (views.at(i)->inputContext())
-                        views.at(i)->inputContext()->reset();
-            }
+            for (int i = 0; i < views.size(); ++i)
+                if (views.at(i)->inputContext())
+                    views.at(i)->inputContext()->reset();
         }
+
+        focusItem = 0;
+        QFocusEvent event(QEvent::FocusOut, focusReason);
+        sendEvent(lastFocusItem, &event);
 #endif //QT_NO_IM
     }
 
@@ -3104,8 +3099,8 @@ bool QGraphicsScene::stickyFocus() const
     \list
     \o If the item receives a mouse release event when there are no other
     buttons pressed, it loses the mouse grab.
-    \o If the item becomes invisible (i.e., someone calls \c {item->setVisible(false))},
-    or if it becomes disabled (i.e., someone calls \c {item->setEnabled(false))},
+    \o If the item becomes invisible (i.e., someone calls \c {item->setVisible(false)}),
+    or if it becomes disabled (i.e., someone calls \c {item->setEnabled(false)}),
     it loses the mouse grab.
     \o If the item is removed from the scene, it loses the mouse grab.
     \endlist
@@ -5924,6 +5919,8 @@ bool QGraphicsScenePrivate::sendTouchBeginEvent(QGraphicsItem *origin, QTouchEve
         }
         if (item->isPanel())
             break;
+        if (item->d_ptr->flags & QGraphicsItem::ItemStopsClickFocusPropagation)
+            break;
     }
 
     // If nobody could take focus, clear it.
@@ -5956,6 +5953,8 @@ bool QGraphicsScenePrivate::sendTouchBeginEvent(QGraphicsItem *origin, QTouchEve
         }
         if (item && item->isPanel())
             break;
+        if (item && (item->d_ptr->flags & QGraphicsItem::ItemStopsClickFocusPropagation))
+            break;
     }
 
     touchEvent->setAccepted(eventAccepted);
diff --git a/src/gui/graphicsview/qgridlayoutengine.cpp b/src/gui/graphicsview/qgridlayoutengine.cpp
index 41ede20..375c723 100644
--- a/src/gui/graphicsview/qgridlayoutengine.cpp
+++ b/src/gui/graphicsview/qgridlayoutengine.cpp
@@ -194,7 +194,8 @@ void QGridLayoutRowData::distributeMultiCells(const QGridLayoutRowInfo &rowInfo)
 
         for (int k = 0; k < span; ++k) {
             boxes[start + k].combine(extras[k]);
-            stretches[start + k] = qMax(stretches[start + k], stretch);
+            if (stretch != 0)
+                stretches[start + k] = qMax(stretches[start + k], stretch);
         }
     }
     multiCellMap.clear();
@@ -1481,7 +1482,7 @@ void QGridLayoutEngine::fillRowData(QGridLayoutRowData *rowData, const QLayoutSt
                     QGridLayoutBox *box;
                     if (effectiveRowSpan == 1) {
                         box = &rowBox;
-                        if (!userRowStretch)
+                        if (!userRowStretch && itemStretch != 0)
                             rowStretch = qMax(rowStretch, itemStretch);
                     } else {
                         QGridLayoutMultiCellData &multiCell =
diff --git a/src/gui/gui.pro b/src/gui/gui.pro
index fe1a595..076fe0a 100644
--- a/src/gui/gui.pro
+++ b/src/gui/gui.pro
@@ -65,15 +65,14 @@ symbian {
 neon:*-g++* {
     DEFINES += QT_HAVE_NEON
     HEADERS += $$NEON_HEADERS
-    SOURCES += $$NEON_SOURCES
 
     DRAWHELPER_NEON_ASM_FILES = $$NEON_ASM
 
-    neon_compiler.commands = $$QMAKE_CXX -c -mfpu=neon
-    neon_compiler.commands += $(CXXFLAGS) $(INCPATH) ${QMAKE_FILE_IN} -o ${QMAKE_FILE_OUT}
+    neon_compiler.commands = $$QMAKE_CXX -c
+    neon_compiler.commands += $(CXXFLAGS) -mfpu=neon $(INCPATH) ${QMAKE_FILE_IN} -o ${QMAKE_FILE_OUT}
     neon_compiler.dependency_type = TYPE_C
     neon_compiler.output = ${QMAKE_VAR_OBJECTS_DIR}${QMAKE_FILE_BASE}$${first(QMAKE_EXT_OBJ)}
-    neon_compiler.input = DRAWHELPER_NEON_ASM_FILES
+    neon_compiler.input = DRAWHELPER_NEON_ASM_FILES NEON_SOURCES
     neon_compiler.variable_out = OBJECTS
     neon_compiler.name = compiling[neon] ${QMAKE_FILE_IN}
     silent:neon_compiler.commands = @echo compiling[neon] ${QMAKE_FILE_IN} && $$neon_compiler.commands
diff --git a/src/gui/image/qbmphandler.cpp b/src/gui/image/qbmphandler.cpp
index 09c086a..6dea9d9 100644
--- a/src/gui/image/qbmphandler.cpp
+++ b/src/gui/image/qbmphandler.cpp
@@ -246,6 +246,8 @@ static bool read_dib_body(QDataStream &s, const BMP_INFOHDR &bi, int offset, int
 
     if (depth != 32) {
         ncols = bi.biClrUsed ? bi.biClrUsed : 1 << nbits;
+        if (ncols > 256) // sanity check - don't run out of mem if color table is broken
+            return false;
         image.setColorCount(ncols);
     }
 
diff --git a/src/gui/image/qgifhandler.cpp b/src/gui/image/qgifhandler.cpp
index 4dd4743..7cb7373 100644
--- a/src/gui/image/qgifhandler.cpp
+++ b/src/gui/image/qgifhandler.cpp
@@ -1046,7 +1046,7 @@ QGifHandler::QGifHandler()
 {
     gifFormat = new QGIFFormat;
     nextDelay = 100;
-    loopCnt = 1;
+    loopCnt = -1;
     frameNumber = -1;
     scanIsCached = false;
 }
@@ -1192,7 +1192,13 @@ int QGifHandler::loopCount() const
         QGIFFormat::scan(device(), &imageSizes, &loopCnt);
         scanIsCached = true;
     }
-    return loopCnt-1; // In GIF, loop count is iteration count, so subtract one
+
+    if (loopCnt == 0)
+        return -1;
+    else if (loopCnt == -1)
+        return 0;
+    else
+        return loopCnt;
 }
 
 int QGifHandler::currentImageNumber() const
diff --git a/src/gui/image/qimage.cpp b/src/gui/image/qimage.cpp
index 91ee697..d992dd5 100644
--- a/src/gui/image/qimage.cpp
+++ b/src/gui/image/qimage.cpp
@@ -477,12 +477,12 @@ bool QImageData::checkForAlphaPixels() const
     function. For example:
 
     \table
+    \header
+    \o {2,1}32-bit
     \row
     \o \inlineimage qimage-32bit_scaled.png
     \o
     \snippet doc/src/snippets/code/src_gui_image_qimage.cpp 0
-    \header
-    \o {2,1}32-bit
     \endtable
 
     In case of a 8-bit and monchrome images, the pixel value is only
@@ -498,12 +498,12 @@ bool QImageData::checkForAlphaPixels() const
     example:
 
     \table
+    \header
+    \o {2,1} 8-bit
     \row
     \o \inlineimage qimage-8bit_scaled.png
     \o
     \snippet doc/src/snippets/code/src_gui_image_qimage.cpp 1
-    \header
-    \o {2,1} 8-bit
     \endtable
 
     QImage also provide the scanLine() function which returns a
diff --git a/src/gui/image/qnativeimage.cpp b/src/gui/image/qnativeimage.cpp
index 01baa36..8face87 100644
--- a/src/gui/image/qnativeimage.cpp
+++ b/src/gui/image/qnativeimage.cpp
@@ -181,15 +181,17 @@ QNativeImage::QNativeImage(int width, int height, QImage::Format format,bool /*
     if (ok) {
         xshmimg->data = (char*)shmat(xshminfo.shmid, 0, 0);
         xshminfo.shmaddr = xshmimg->data;
-        if (shmctl(xshminfo.shmid, IPC_RMID, 0) == -1)
-            qWarning() << "Error while marking the shared memory segment to be destroyed";
         ok = (xshminfo.shmaddr != (char*)-1);
         if (ok)
             image = QImage((uchar *)xshmimg->data, width, height, format);
     }
     xshminfo.readOnly = false;
-    if (ok)
+    if (ok) {
         ok = XShmAttach(X11->display, &xshminfo);
+        XSync(X11->display, False);
+        if (shmctl(xshminfo.shmid, IPC_RMID, 0) == -1)
+            qWarning() << "Error while marking the shared memory segment to be destroyed";
+    }
     if (!ok) {
         qWarning() << "QNativeImage: Unable to attach to shared memory segment.";
         if (xshmimg->data) {
diff --git a/src/gui/image/qpixmap_s60.cpp b/src/gui/image/qpixmap_s60.cpp
index dbe8177..ca5f133 100644
--- a/src/gui/image/qpixmap_s60.cpp
+++ b/src/gui/image/qpixmap_s60.cpp
@@ -1012,6 +1012,33 @@ void QS60PixmapData::fromNativeType(void* pixmap, NativeType nativeType)
     }
 }
 
+void QS60PixmapData::convertToDisplayMode(int mode)
+{
+    const TDisplayMode displayMode = static_cast<TDisplayMode>(mode);
+    if (!cfbsBitmap || cfbsBitmap->DisplayMode() == displayMode)
+        return;
+    if (image.depth() != TDisplayModeUtils::NumDisplayModeBitsPerPixel(displayMode)) {
+        qWarning("Cannot convert display mode due to depth mismatch");
+        return;
+    }
+
+    const TSize size = cfbsBitmap->SizeInPixels();
+    QScopedPointer<CFbsBitmap> newBitmap(createSymbianCFbsBitmap(size, displayMode));
+
+    const uchar *sptr = const_cast<const QImage &>(image).bits();
+    symbianBitmapDataAccess->beginDataAccess(newBitmap.data());
+    uchar *dptr = (uchar*)newBitmap->DataAddress();
+    Mem::Copy(dptr, sptr, image.byteCount());
+    symbianBitmapDataAccess->endDataAccess(newBitmap.data());
+
+    QSymbianFbsHeapLock lock(QSymbianFbsHeapLock::Unlock);
+    delete cfbsBitmap;
+    lock.relock();
+    cfbsBitmap = newBitmap.take();
+    setSerialNumber(cfbsBitmap->Handle());
+    UPDATE_BUFFER();
+}
+
 QPixmapData *QS60PixmapData::createCompatiblePixmapData() const
 {
     return new QS60PixmapData(pixelType());
diff --git a/src/gui/image/qpixmap_s60_p.h b/src/gui/image/qpixmap_s60_p.h
index e4060dc..c440bbc 100644
--- a/src/gui/image/qpixmap_s60_p.h
+++ b/src/gui/image/qpixmap_s60_p.h
@@ -107,6 +107,8 @@ public:
     void* toNativeType(NativeType type);
     void fromNativeType(void* pixmap, NativeType type);
 
+    void convertToDisplayMode(int mode);
+
 private:
     void release();
     void fromSymbianBitmap(CFbsBitmap* bitmap, bool lockFormat=false);
diff --git a/src/gui/image/qxpmhandler.cpp b/src/gui/image/qxpmhandler.cpp
index ffad75b..075d5da 100644
--- a/src/gui/image/qxpmhandler.cpp
+++ b/src/gui/image/qxpmhandler.cpp
@@ -864,7 +864,7 @@ static bool read_xpm_body(
     QByteArray buf(200, 0);
     int i;
 
-    if (cpp > 15)
+    if (cpp < 0 || cpp > 15)
         return false;
 
     // For > 256 colors, we delay creation of the image until
diff --git a/src/gui/inputmethod/qcoefepinputcontext_s60.cpp b/src/gui/inputmethod/qcoefepinputcontext_s60.cpp
index ff199b1..1bef64d 100644
--- a/src/gui/inputmethod/qcoefepinputcontext_s60.cpp
+++ b/src/gui/inputmethod/qcoefepinputcontext_s60.cpp
@@ -706,6 +706,7 @@ void QCoeFepInputContext::CancelFepInlineEdit()
     QInputMethodEvent event(QLatin1String(""), attributes);
     event.setCommitString(QLatin1String(""), 0, 0);
     m_preeditString.clear();
+    m_inlinePosition = 0;
     sendEvent(event);
 }
 
@@ -853,6 +854,7 @@ void QCoeFepInputContext::commitCurrentString(bool cancelFepTransaction)
     QInputMethodEvent event(QLatin1String(""), attributes);
     event.setCommitString(m_preeditString, 0, 0);
     m_preeditString.clear();
+    m_inlinePosition = 0;
     sendEvent(event);
 
     m_hasTempPreeditString = false;
diff --git a/src/gui/itemviews/qabstractitemview.cpp b/src/gui/itemviews/qabstractitemview.cpp
index 4dd0aa3..291ec6e 100644
--- a/src/gui/itemviews/qabstractitemview.cpp
+++ b/src/gui/itemviews/qabstractitemview.cpp
@@ -657,9 +657,9 @@ QAbstractItemView::~QAbstractItemView()
     deleteLater() functions to explicitly delete them.
 
     The view \e{does not} take ownership of the model unless it is the model's
-    parent object because the view may be shared between many different views.
+    parent object because the model may be shared between many different views.
 
-  \sa selectionModel(), setSelectionModel()
+    \sa selectionModel(), setSelectionModel()
 */
 void QAbstractItemView::setModel(QAbstractItemModel *model)
 {
diff --git a/src/gui/itemviews/qtreeview.cpp b/src/gui/itemviews/qtreeview.cpp
index d03babb..21c9d3b 100644
--- a/src/gui/itemviews/qtreeview.cpp
+++ b/src/gui/itemviews/qtreeview.cpp
@@ -2744,6 +2744,7 @@ int QTreeView::indexRowSizeHint(const QModelIndex &index) const
 
     int start = -1;
     int end = -1;
+    int indexRow = index.row();
     int count = d->header->count();
     bool emptyHeader = (count == 0);
     QModelIndex parent = index.parent();
@@ -2780,7 +2781,7 @@ int QTreeView::indexRowSizeHint(const QModelIndex &index) const
         int logicalColumn = emptyHeader ? column : d->header->logicalIndex(column);
         if (d->header->isSectionHidden(logicalColumn))
             continue;
-        QModelIndex idx = d->model->index(index.row(), logicalColumn, parent);
+        QModelIndex idx = d->model->index(indexRow, logicalColumn, parent);
         if (idx.isValid()) {
             QWidget *editor = d->editorForIndex(idx).widget.data();
             if (editor && d->persistent.contains(editor)) {
@@ -3215,14 +3216,14 @@ int QTreeViewPrivate::itemHeight(int item) const
     if (viewItems.isEmpty())
         return 0;
     const QModelIndex &index = viewItems.at(item).index;
+    if (!index.isValid())
+        return 0;
     int height = viewItems.at(item).height;
-    if (height <= 0 && index.isValid()) {
+    if (height <= 0) {
         height = q_func()->indexRowSizeHint(index);
         viewItems[item].height = height;
     }
-    if (!index.isValid() || height < 0)
-        return 0;
-    return height;
+    return qMax(height, 0);
 }
 
 
diff --git a/src/gui/kernel/qapplication.cpp b/src/gui/kernel/qapplication.cpp
index 5c4a314..e91fe04 100644
--- a/src/gui/kernel/qapplication.cpp
+++ b/src/gui/kernel/qapplication.cpp
@@ -2771,7 +2771,7 @@ void QApplicationPrivate::dispatchEnterLeave(QWidget* enter, QWidget* leave) {
     for (int i = 0; i < leaveList.size(); ++i) {
         w = leaveList.at(i);
         if (!QApplication::activeModalWidget() || QApplicationPrivate::tryModalHelper(w, 0)) {
-#if defined(Q_WS_WIN) || defined(Q_WS_X11)
+#if defined(Q_WS_WIN) || defined(Q_WS_X11) || defined(Q_WS_MAC)
             if (leaveAfterRelease == w)
                 leaveAfterRelease = 0;
 #endif
@@ -3142,13 +3142,11 @@ bool QApplicationPrivate::sendMouseEvent(QWidget *receiver, QMouseEvent *event,
         // Dispatch enter/leave if:
         // 1) the mouse grabber is an alien widget
         // 2) the button is released on an alien widget
-
         QWidget *enter = 0;
         if (nativeGuard)
             enter = alienGuard ? alienWidget : nativeWidget;
         else // The receiver is typically deleted on mouse release with drag'n'drop.
             enter = QApplication::widgetAt(event->globalPos());
-
         dispatchEnterLeave(enter, leaveAfterRelease);
         leaveAfterRelease = 0;
         lastMouseReceiver = enter;
@@ -3695,15 +3693,6 @@ void QApplication::changeOverrideCursor(const QCursor &cursor)
     if (qApp->d_func()->cursor_list.isEmpty())
         return;
     qApp->d_func()->cursor_list.removeFirst();
-#ifdef QT_MAC_USE_COCOA
-    // We use native NSCursor stacks in Cocoa. The currentCursor is the
-    // top of this stack. So to avoid flickering of cursor, we have to
-    // change the cusor instead of pop-ing the existing OverrideCursor
-    // and pushing the new one.
-    qApp->d_func()->cursor_list.prepend(cursor);
-    qt_cocoaChangeOverrideCursor(cursor);
-    return;
-#endif
     setOverrideCursor(cursor);
 }
 #endif
@@ -4434,6 +4423,24 @@ bool QApplication::notify(QObject *receiver, QEvent *e)
         break;
     }
 #endif // QT_NO_GESTURES
+#ifdef QT_MAC_USE_COCOA
+    case QEvent::Enter:
+        if (receiver->isWidgetType()) {
+            QWidget *w = static_cast<QWidget *>(receiver);
+            if (w->testAttribute(Qt::WA_AcceptTouchEvents))
+                qt_widget_private(w)->registerTouchWindow(true);
+        }
+        res = d->notify_helper(receiver, e);
+    break;
+    case QEvent::Leave:
+        if (receiver->isWidgetType()) {
+            QWidget *w = static_cast<QWidget *>(receiver);
+            if (w->testAttribute(Qt::WA_AcceptTouchEvents))
+                qt_widget_private(w)->registerTouchWindow(false);
+        }
+        res = d->notify_helper(receiver, e);
+    break;
+#endif
     default:
         res = d->notify_helper(receiver, e);
         break;
diff --git a/src/gui/kernel/qapplication_mac.mm b/src/gui/kernel/qapplication_mac.mm
index b22a6b3..f607a72 100644
--- a/src/gui/kernel/qapplication_mac.mm
+++ b/src/gui/kernel/qapplication_mac.mm
@@ -165,6 +165,7 @@ QT_BEGIN_NAMESPACE
 //for qt_mac.h
 QPaintDevice *qt_mac_safe_pdev = 0;
 QList<QMacWindowChangeEvent*> *QMacWindowChangeEvent::change_events = 0;
+QPointer<QWidget> topLevelAt_cache = 0;
 
 /*****************************************************************************
   Internal variables and functions
@@ -192,7 +193,6 @@ static bool qt_mac_previous_press_in_popup_mode = false;
 static bool qt_mac_no_click_through_mode = false;
 static int tablet_button_state = 0;
 #endif
-QPointer<QWidget> qt_mouseover;
 #if defined(QT_DEBUG)
 static bool        appNoGrab        = false;        // mouse/keyboard grabbing
 #endif
@@ -216,11 +216,12 @@ extern bool qt_mac_can_clickThrough(const QWidget *); //qwidget_mac.cpp
 extern bool qt_mac_is_macdrawer(const QWidget *); //qwidget_mac.cpp
 extern OSWindowRef qt_mac_window_for(const QWidget*); //qwidget_mac.cpp
 extern QWidget *qt_mac_find_window(OSWindowRef); //qwidget_mac.cpp
-extern void qt_mac_set_cursor(const QCursor *, const QPoint &); //qcursor_mac.cpp
+extern void qt_mac_set_cursor(const QCursor *); //qcursor_mac.cpp
 extern bool qt_mac_is_macsheet(const QWidget *); //qwidget_mac.cpp
 extern QString qt_mac_from_pascal_string(const Str255); //qglobal.cpp
 extern void qt_mac_command_set_enabled(MenuRef, UInt32, bool); //qmenu_mac.cpp
 extern bool qt_sendSpontaneousEvent(QObject *obj, QEvent *event); // qapplication.cpp
+extern void qt_mac_update_cursor(); // qcursor_mac.mm
 
 // Forward Decls
 void onApplicationWindowChangedActivation( QWidget*widget, bool activated );
@@ -1364,43 +1365,16 @@ void QApplication::setMainWidget(QWidget *mainWidget)
 /*****************************************************************************
   QApplication cursor stack
  *****************************************************************************/
-#ifdef QT_MAC_USE_COCOA
-void QApplicationPrivate::disableUsageOfCursorRects(bool disable)
-{
-    // In Cocoa there are two competing ways of setting the cursor; either
-    // by using cursor rects (see qcocoaview_mac.mm), or by pushing/popping
-    // the cursor manually. When we use override cursors, it makes most sense
-    // to use the latter. But then we need to tell cocoa to stop using the
-    // first approach so it doesn't change the cursor back when hovering over
-    // a cursor rect:
-    QWidgetList topLevels = qApp->topLevelWidgets();
-    for (int i=0; i<topLevels.size(); ++i) {
-        if (NSWindow *window = qt_mac_window_for(topLevels.at(i)))
-            disable ? [window disableCursorRects] : [window enableCursorRects];
-    }
-}
-
-void QApplicationPrivate::updateOverrideCursor()
-{
-    // Sometimes Cocoa forgets that we have set a Cursor
-    // manually. In those cases, remind it again:
-    if (QCursor *override = qApp->overrideCursor())
-        [static_cast<NSCursor *>(qt_mac_nsCursorForQCursor(*override)) set];
-}
-#endif
 
 void QApplication::setOverrideCursor(const QCursor &cursor)
 {
     qApp->d_func()->cursor_list.prepend(cursor);
 
 #ifdef QT_MAC_USE_COCOA
-    QMacCocoaAutoReleasePool pool;
-    if (qApp->d_func()->cursor_list.size() == 1)
-        qApp->d_func()->disableUsageOfCursorRects(true);
-    [static_cast<NSCursor *>(qt_mac_nsCursorForQCursor(cursor)) push];
+    qt_mac_update_cursor();
 #else
     if (qApp && qApp->activeWindow())
-        qt_mac_set_cursor(&qApp->d_func()->cursor_list.first(), QCursor::pos());
+        qt_mac_set_cursor(&qApp->d_func()->cursor_list.first());
 #endif
 }
 
@@ -1411,14 +1385,11 @@ void QApplication::restoreOverrideCursor()
     qApp->d_func()->cursor_list.removeFirst();
 
 #ifdef QT_MAC_USE_COCOA
-    QMacCocoaAutoReleasePool pool;
-    [NSCursor pop];
-    if (qApp->d_func()->cursor_list.isEmpty())
-        qApp->d_func()->disableUsageOfCursorRects(false);
+    qt_mac_update_cursor();
 #else
     if (qApp && qApp->activeWindow()) {
         const QCursor def(Qt::ArrowCursor);
-        qt_mac_set_cursor(qApp->d_func()->cursor_list.isEmpty() ? &def : &qApp->d_func()->cursor_list.first(), QCursor::pos());
+        qt_mac_set_cursor(qApp->d_func()->cursor_list.isEmpty() ? &def : &qApp->d_func()->cursor_list.first());
     }
 #endif
 }
@@ -1431,30 +1402,54 @@ QWidget *QApplication::topLevelAt(const QPoint &p)
     qt_mac_window_at(p.x(), p.y(), &widget);
     return widget;
 #else
+    // Use a cache to avoid iterate through the whole list of windows for all
+    // calls to to topLevelAt. We e.g. do this for each and every mouse
+    // move since we need to find the widget under mouse:
+    if (topLevelAt_cache && topLevelAt_cache->frameGeometry().contains(p))
+        return topLevelAt_cache;
+
+    // INVARIANT: Cache miss. Go through the list if windows instead:
+    QMacCocoaAutoReleasePool pool;
+    NSPoint cocoaPoint = flipPoint(p);
     NSInteger windowCount;
     NSCountWindows(&windowCount);
     if (windowCount <= 0)
         return 0;  // There's no window to find!
-    QMacCocoaAutoReleasePool pool;
-    NSPoint cocoaPoint = flipPoint(p);
+
     QVarLengthArray<NSInteger> windowList(windowCount);
     NSWindowList(windowCount, windowList.data());
+    int firstQtWindowFound = -1;
     for (int i = 0; i < windowCount; ++i) {
         NSWindow *window = [NSApp windowWithWindowNumber:windowList[i]];
-        if (window && NSPointInRect(cocoaPoint, [window frame])) {
+        if (window) {
             QWidget *candidateWindow = [window QT_MANGLE_NAMESPACE(qt_qwidget)];
-            // Check to see if there's a hole in the window where the mask is.
-            // If there is, we should just continue to see if there is a window below.
-            if (candidateWindow && !candidateWindow->mask().isEmpty()) {
-                QPoint localPoint = candidateWindow->mapFromGlobal(p);
-                if (!candidateWindow->mask().contains(localPoint)) {
-                    continue;
+            if (candidateWindow && firstQtWindowFound == -1)
+                firstQtWindowFound = i;
+
+            if (NSPointInRect(cocoaPoint, [window frame])) {
+                // Check to see if there's a hole in the window where the mask is.
+                // If there is, we should just continue to see if there is a window below.
+                if (candidateWindow && !candidateWindow->mask().isEmpty()) {
+                    QPoint localPoint = candidateWindow->mapFromGlobal(p);
+                    if (!candidateWindow->mask().contains(localPoint))
+                        continue;
+                    else
+                        return candidateWindow;
+                } else {
+                    if (i == firstQtWindowFound) {
+                        // The cache will only work when the window under mouse is
+                        // top most (that is, not partially obscured by other windows.
+                        // And we only set it if no mask is present to optimize for the common case:
+                        topLevelAt_cache = candidateWindow;
+                    }
+                    return candidateWindow;
                 }
             }
-            return candidateWindow;
         }
     }
-    return 0; // Couldn't find a window at this point
+
+    topLevelAt_cache = 0;
+    return 0;
 #endif
 }
 
@@ -1480,8 +1475,8 @@ void QApplicationPrivate::enterModal_sys(QWidget *widget)
     if (!qt_modal_stack)
         qt_modal_stack = new QWidgetList;
 
-    dispatchEnterLeave(0, qt_mouseover);
-    qt_mouseover = 0;
+    dispatchEnterLeave(0, qt_last_mouse_receiver);
+    qt_last_mouse_receiver = 0;
 
     qt_modal_stack->insert(0, widget);
     if (!app_do_modal)
@@ -1512,8 +1507,8 @@ void QApplicationPrivate::leaveModal_sys(QWidget *widget)
                 w = grabber;
             else
                 w = QApplication::widgetAt(p.x(), p.y());
-            dispatchEnterLeave(w, qt_mouseover); // send synthetic enter event
-            qt_mouseover = w;
+            dispatchEnterLeave(w, qt_last_mouse_receiver); // send synthetic enter event
+            qt_last_mouse_receiver = w;
         }
 #ifdef QT_MAC_USE_COCOA
         if (!qt_mac_is_macsheet(widget))
@@ -1938,7 +1933,7 @@ QApplicationPrivate::globalEventProcessor(EventHandlerCallRef er, EventRef event
                     }
                 }
             }
-            qt_mac_set_cursor(&cursor, QPoint(where.h, where.v));
+            qt_mac_set_cursor(&cursor);
         }
 
         //This mouse button state stuff looks like this on purpose
@@ -2132,20 +2127,20 @@ QApplicationPrivate::globalEventProcessor(EventHandlerCallRef er, EventRef event
             QWidget * const enterLeaveWidget = (inPopupMode || ekind == kEventMouseUp) ?
                     QApplication::widgetAt(where.h, where.v) :  static_cast<QWidget*>(widget);
 
-            if ((QWidget *) qt_mouseover != enterLeaveWidget || inNonClientArea) {
+            if ((QWidget *) qt_last_mouse_receiver != enterLeaveWidget || inNonClientArea) {
 #ifdef DEBUG_MOUSE_MAPS
                 qDebug("Entering: %p - %s (%s), Leaving %s (%s)", (QWidget*)enterLeaveWidget,
                        enterLeaveWidget ? enterLeaveWidget->metaObject()->className() : "none",
                        enterLeaveWidget ? enterLeaveWidget->objectName().toLocal8Bit().constData() : "",
-                       qt_mouseover ? qt_mouseover->metaObject()->className() : "none",
-                       qt_mouseover ? qt_mouseover->objectName().toLocal8Bit().constData() : "");
+                       qt_last_mouse_receiver ? qt_last_mouse_receiver->metaObject()->className() : "none",
+                       qt_last_mouse_receiver ? qt_last_mouse_receiver->objectName().toLocal8Bit().constData() : "");
 #endif
 
                 QWidget * const mouseGrabber = QWidget::mouseGrabber();
 
                 if (inPopupMode) {
                     QWidget *enter = enterLeaveWidget;
-                    QWidget *leave = qt_mouseover;
+                    QWidget *leave = qt_last_mouse_receiver;
                     if (mouseGrabber) {
                         QWidget * const popupWidget = qApp->activePopupWidget();
                         if (leave == popupWidget)
@@ -2155,15 +2150,15 @@ QApplicationPrivate::globalEventProcessor(EventHandlerCallRef er, EventRef event
                         if ((enter == mouseGrabber && leave == popupWidget)
                             || (leave == mouseGrabber  && enter == popupWidget)) {
                             QApplicationPrivate::dispatchEnterLeave(enter, leave);
-                            qt_mouseover = enter;
+                            qt_last_mouse_receiver = enter;
                         }
                     } else {
                         QApplicationPrivate::dispatchEnterLeave(enter, leave);
-                        qt_mouseover = enter;
+                        qt_last_mouse_receiver = enter;
                     }
-                } else if ((!qt_button_down || !qt_mouseover) && !mouseGrabber && !leaveAfterRelease) {
-                    QApplicationPrivate::dispatchEnterLeave(enterLeaveWidget, qt_mouseover);
-                    qt_mouseover = enterLeaveWidget;
+                } else if ((!qt_button_down || !qt_last_mouse_receiver) && !mouseGrabber && !leaveAfterRelease) {
+                    QApplicationPrivate::dispatchEnterLeave(enterLeaveWidget, qt_last_mouse_receiver);
+                    qt_last_mouse_receiver = enterLeaveWidget;
                 }
             }
             break; }
@@ -2240,7 +2235,7 @@ QApplicationPrivate::globalEventProcessor(EventHandlerCallRef er, EventRef event
             if (leaveAfterRelease) {
                 QWidget *enter = QApplication::widgetAt(where.h, where.v);
                 QApplicationPrivate::dispatchEnterLeave(enter, leaveAfterRelease);
-                qt_mouseover = enter;
+                qt_last_mouse_receiver = enter;
                 leaveAfterRelease = 0;
             }
 
@@ -2503,7 +2498,7 @@ QApplicationPrivate::globalEventProcessor(EventHandlerCallRef er, EventRef event
 void QApplicationPrivate::qt_initAfterNSAppStarted()
 {
     setupAppleEvents();
-    updateOverrideCursor();
+    qt_mac_update_cursor();
 }
 
 void QApplicationPrivate::setupAppleEvents()
@@ -3080,7 +3075,7 @@ void onApplicationWindowChangedActivation(QWidget *widget, bool activated)
     }
 
     QMenuBar::macUpdateMenuBar();
-    QApplicationPrivate::updateOverrideCursor();
+    qt_mac_update_cursor();
 #else
     Q_UNUSED(widget);
     Q_UNUSED(activated);
@@ -3115,6 +3110,7 @@ void onApplicationChangedActivation( bool activated )
                 app->setActiveWindow(tmp_w);
         }
         QMenuBar::macUpdateMenuBar();
+        qt_mac_update_cursor();
     } else { // de-activated
         QApplicationPrivate *priv = [[QT_MANGLE_NAMESPACE(QCocoaApplicationDelegate) sharedDelegate] qAppPrivate];
         while (priv->inPopupMode())
diff --git a/src/gui/kernel/qapplication_p.h b/src/gui/kernel/qapplication_p.h
index 1a511a8..a6815a8 100644
--- a/src/gui/kernel/qapplication_p.h
+++ b/src/gui/kernel/qapplication_p.h
@@ -489,8 +489,6 @@ public:
 #ifdef QT_MAC_USE_COCOA
     static void qt_initAfterNSAppStarted();
     static void setupAppleEvents();
-    static void updateOverrideCursor();
-    static void disableUsageOfCursorRects(bool disable);
 #endif
     static bool qt_mac_apply_settings();
 #endif
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 3a70dd5..586869a 100644
--- a/src/gui/kernel/qapplication_s60.cpp
+++ b/src/gui/kernel/qapplication_s60.cpp
@@ -87,7 +87,7 @@
 #include <hal.h>
 #include <hal_data.h>
 
-#ifdef SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS
+#ifdef Q_SYMBIAN_TRANSITION_EFFECTS
 #include <graphics/wstfxconst.h>
 #endif
 
@@ -432,7 +432,7 @@ void QSymbianControl::ConstructL(bool isWindowOwning, bool desktop)
         DrawableWindow()->SetPointerGrab(ETrue);
     }
 
-#ifdef SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS
+#ifdef Q_SYMBIAN_TRANSITION_EFFECTS
     if (OwnsWindow()) {
         TTfxWindowPurpose windowPurpose(ETfxPurposeNone);
         switch (qwidget->windowType()) {
@@ -1245,12 +1245,14 @@ void QSymbianControl::FocusChanged(TDrawNow /* aDrawNow */)
 #ifdef Q_WS_S60
         // If widget is fullscreen/minimized, hide status pane and button container otherwise show them.
         QWidget *const window = qwidget->window();
-        const bool visible = !(window->windowState() & (Qt::WindowFullScreen | Qt::WindowMinimized));
-        const bool statusPaneVisibility = visible;
-        const bool isFullscreen = window->windowState() & Qt::WindowFullScreen;
-        const bool cbaVisibilityHint = window->windowFlags() & Qt::WindowSoftkeysVisibleHint;
-        const bool buttonGroupVisibility = (visible || (isFullscreen && cbaVisibilityHint));
-        S60->setStatusPaneAndButtonGroupVisibility(statusPaneVisibility, buttonGroupVisibility);
+        if (!window->parentWidget()) { // Only top level native windows have control over cba/status pane
+            const bool decorationsVisible = !(window->windowState() & (Qt::WindowFullScreen | Qt::WindowMinimized));
+            const bool statusPaneVisibility = decorationsVisible;
+            const bool isFullscreen = window->windowState() & Qt::WindowFullScreen;
+            const bool cbaVisibilityHint = window->windowFlags() & Qt::WindowSoftkeysVisibleHint;
+            const bool buttonGroupVisibility = (decorationsVisible || (isFullscreen && cbaVisibilityHint));
+            S60->setStatusPaneAndButtonGroupVisibility(statusPaneVisibility, buttonGroupVisibility);
+        }
 #endif
     } else if (QApplication::activeWindow() == qwidget->window()) {
         bool focusedControlFound = false;
@@ -1545,6 +1547,8 @@ void qt_init(QApplicationPrivate * /* priv */, int)
     repository = 0;
 #endif
 
+    qt_keymapper_private()->updateInputLanguage();
+
 #ifdef QT_KEYPAD_NAVIGATION
     if (touch) {
         QApplicationPrivate::navigationMode = Qt::NavigationModeNone;
@@ -1584,7 +1588,7 @@ void qt_init(QApplicationPrivate * /* priv */, int)
     systemFont.setFamily(systemFont.defaultFamily());
     QApplicationPrivate::setSystemFont(systemFont);
 
-#ifdef SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS
+#ifdef Q_SYMBIAN_TRANSITION_EFFECTS
     QObject::connect(qApp, SIGNAL(aboutToQuit()), qApp, SLOT(_q_aboutToQuit()));
 #endif
 
@@ -1616,7 +1620,9 @@ void qt_init(QApplicationPrivate * /* priv */, int)
     qRegisterMetaType<WId>("WId");
 }
 
-extern void qt_cleanup_symbianFontDatabaseExtras(); // qfontdatabase_s60.cpp
+#ifdef QT_NO_FREETYPE
+extern void qt_cleanup_symbianFontDatabase(); // qfontdatabase_s60.cpp
+#endif
 
 /*****************************************************************************
   qt_cleanup() - cleans up when the application is finished
@@ -1633,7 +1639,9 @@ void qt_cleanup()
     QFontCache::cleanup(); // Has to happen now, since QFontEngineS60 has FBS handles
     QPixmapCache::clear(); // Has to happen now, since QS60PixmapData has FBS handles
 
-    qt_cleanup_symbianFontDatabaseExtras();
+#ifdef QT_NO_FREETYPE
+    qt_cleanup_symbianFontDatabase();
+#endif
 // S60 structure and window server session are freed in eventdispatcher destructor as they are needed there
 
     // It's important that this happens here, before the event dispatcher gets
@@ -1687,7 +1695,7 @@ bool QApplicationPrivate::modalState()
 
 void QApplicationPrivate::enterModal_sys(QWidget *widget)
 {
-#ifdef SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS
+#ifdef Q_SYMBIAN_TRANSITION_EFFECTS
     S60->wsSession().SendEffectCommand(ETfxCmdAppModalModeEnter);
 #endif
     if (widget) {
@@ -1705,7 +1713,7 @@ void QApplicationPrivate::enterModal_sys(QWidget *widget)
 
 void QApplicationPrivate::leaveModal_sys(QWidget *widget)
 {
-#ifdef SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS
+#ifdef Q_SYMBIAN_TRANSITION_EFFECTS
     S60->wsSession().SendEffectCommand(ETfxCmdAppModalModeExit);
 #endif
     if (widget) {
@@ -2019,6 +2027,9 @@ int QApplicationPrivate::symbianProcessWsEvent(const QSymbianEvent *symbianEvent
                 S60->wsSession().SetPointerCursorMode(EPointerCursorNormal);
         }
 #endif
+#ifdef QT_SOFTKEYS_ENABLED
+        QSoftKeyManager::updateSoftKeys();
+#endif
         break;
     case EEventFocusLost:
         if (callSymbianEventFilters(symbianEvent))
@@ -2085,6 +2096,13 @@ int QApplicationPrivate::symbianProcessWsEvent(const QSymbianEvent *symbianEvent
         }
         break;
 #endif
+
+#ifdef Q_WS_S60
+    case KEikInputLanguageChange:
+        qt_keymapper_private()->updateInputLanguage();
+        break;
+#endif
+
     default:
         break;
     }
@@ -2383,7 +2401,7 @@ void QApplication::restoreOverrideCursor()
 
 void QApplicationPrivate::_q_aboutToQuit()
 {
-#ifdef SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS
+#ifdef Q_SYMBIAN_TRANSITION_EFFECTS
     // Send the shutdown tfx command
     S60->wsSession().SendEffectCommand(ETfxCmdAppShutDown);
 #endif
diff --git a/src/gui/kernel/qapplication_x11.cpp b/src/gui/kernel/qapplication_x11.cpp
index 2c51722..589b12e 100644
--- a/src/gui/kernel/qapplication_x11.cpp
+++ b/src/gui/kernel/qapplication_x11.cpp
@@ -5227,14 +5227,15 @@ bool QETWidget::translateConfigEvent(const XEvent *event)
         bool trust = isVisible()
                      && (d->topData()->parentWinId == XNone ||
                          d->topData()->parentWinId == QX11Info::appRootWindow());
+        bool isCPos = false;
 
         if (event->xconfigure.send_event || trust) {
             // if a ConfigureNotify comes from a real sendevent request, we can
             // trust its values.
             newCPos.rx() = event->xconfigure.x + event->xconfigure.border_width;
             newCPos.ry() = event->xconfigure.y + event->xconfigure.border_width;
+            isCPos = true;
         }
-
         if (isVisible())
             QApplication::syncX();
 
@@ -5260,6 +5261,7 @@ bool QETWidget::translateConfigEvent(const XEvent *event)
                                    otherEvent.xconfigure.border_width;
                     newCPos.ry() = otherEvent.xconfigure.y +
                                    otherEvent.xconfigure.border_width;
+                    isCPos = true;
                 }
             }
 #ifndef QT_NO_XSYNC
@@ -5272,6 +5274,19 @@ bool QETWidget::translateConfigEvent(const XEvent *event)
 #endif // QT_NO_XSYNC
         }
 
+        if (!isCPos) {
+            // we didn't get an updated position of the toplevel.
+            // either we haven't moved or there is a bug in the window manager.
+            // anyway, let's query the position to be certain.
+            int x, y;
+            Window child;
+            XTranslateCoordinates(X11->display, internalWinId(),
+                                  QApplication::desktop()->screen(d->xinfo.screen())->internalWinId(),
+                                  0, 0, &x, &y, &child);
+            newCPos.rx() = x;
+            newCPos.ry() = y;
+        }
+
         QRect cr (geometry());
         if (newCPos != cr.topLeft()) { // compare with cpos (exluding frame)
             QPoint oldPos = geometry().topLeft();
@@ -5314,18 +5329,6 @@ bool QETWidget::translateConfigEvent(const XEvent *event)
     }
 
     if (wasResize) {
-        static bool slowResize = qgetenv("QT_SLOW_TOPLEVEL_RESIZE").toInt();
-        if (d->extra->compress_events && !slowResize && !data->in_show && isVisible()) {
-            QApplication::syncX();
-            XEvent otherEvent;
-            while (XCheckTypedWindowEvent(X11->display, internalWinId(), ConfigureNotify, &otherEvent)
-                   && !qt_x11EventFilter(&otherEvent) && !x11Event(&otherEvent)
-                   && otherEvent.xconfigure.event == otherEvent.xconfigure.window) {
-                data->crect.setWidth(otherEvent.xconfigure.width);
-                data->crect.setHeight(otherEvent.xconfigure.height);
-            }
-        }
-
         if (isVisible() && data->crect.size() != oldSize) {
             Q_ASSERT(d->extra->topextra);
             QWidgetBackingStore *bs = d->extra->topextra->backingStore.data();
@@ -5334,7 +5337,7 @@ bool QETWidget::translateConfigEvent(const XEvent *event)
             // resize optimization in order to get invalidated regions for resized widgets.
             // The optimization discards all invalidateBuffer() calls since we're going to
             // repaint everything anyways, but that's not the case with static contents.
-            if (!slowResize && !hasStaticContents)
+            if (!hasStaticContents)
                 d->extra->topextra->inTopLevelResize = true;
             QResizeEvent e(data->crect.size(), oldSize);
             QApplication::sendSpontaneousEvent(this, &e);
@@ -5658,10 +5661,21 @@ static void sm_performSaveYourself(QSessionManagerPrivate* smd)
     sm_setProperty(QString::fromLatin1(SmProgram), argument0);
     // tell the session manager about our user as well.
     struct passwd *entryPtr = 0;
-#if !defined(QT_NO_THREAD) && defined(_POSIX_THREAD_SAFE_FUNCTIONS) && !defined(Q_OS_OPENBSD)
-    QVarLengthArray<char, 1024> buf(sysconf(_SC_GETPW_R_SIZE_MAX));
+#if defined(_POSIX_THREAD_SAFE_FUNCTIONS) && (_POSIX_THREAD_SAFE_FUNCTIONS - 0 > 0)
+    QVarLengthArray<char, 1024> buf(qMax<long>(sysconf(_SC_GETPW_R_SIZE_MAX), 1024L));
     struct passwd entry;
-    getpwuid_r(geteuid(), &entry, buf.data(), buf.size(), &entryPtr);
+    while (getpwuid_r(geteuid(), &entry, buf.data(), buf.size(), &entryPtr) == ERANGE) {
+        if (buf.size() >= 32768) {
+            // too big already, fail
+            static char badusername[] = "";
+            entryPtr = &entry;
+            entry.pw_name = badusername;
+            break;
+        }
+
+        // retry with a bigger buffer
+        buf.resize(buf.size() * 2);
+    }
 #else
     entryPtr = getpwuid(geteuid());
 #endif
diff --git a/src/gui/kernel/qcocoaapplicationdelegate_mac.mm b/src/gui/kernel/qcocoaapplicationdelegate_mac.mm
index bf4d9e5..77cd890 100644
--- a/src/gui/kernel/qcocoaapplicationdelegate_mac.mm
+++ b/src/gui/kernel/qcocoaapplicationdelegate_mac.mm
@@ -90,6 +90,10 @@
 QT_BEGIN_NAMESPACE
 extern void onApplicationChangedActivation(bool); // qapplication_mac.mm
 extern void qt_release_apple_event_handler(); //qapplication_mac.mm
+extern QPointer<QWidget> qt_last_mouse_receiver; // qapplication_mac.cpp
+extern QPointer<QWidget> qt_last_native_mouse_receiver; // qt_cocoa_helpers_mac.mm
+extern QPointer<QWidget> qt_button_down; // qapplication_mac.cpp
+
 QT_END_NAMESPACE
 
 QT_FORWARD_DECLARE_CLASS(QDesktopWidgetImplementation)
@@ -254,7 +258,20 @@ static void cleanupCocoaApplicationDelegate()
     if (reflectionDelegate
         && [reflectionDelegate respondsToSelector:@selector(applicationDidBecomeActive:)])
         [reflectionDelegate applicationDidBecomeActive:notification];
+
     onApplicationChangedActivation(true);
+
+    if (!QWidget::mouseGrabber()){
+        // Update enter/leave immidiatly, don't wait for a move event. But only
+        // if no grab exists (even if the grab points to this widget, it seems, ref X11)
+        QPoint qlocal, qglobal;
+        QWidget *widgetUnderMouse = 0;
+        qt_mac_getTargetForMouseEvent(0, QEvent::Enter, qlocal, qglobal, 0, &widgetUnderMouse);
+        QApplicationPrivate::dispatchEnterLeave(widgetUnderMouse, 0);
+        qt_last_mouse_receiver = widgetUnderMouse;
+        qt_last_native_mouse_receiver = widgetUnderMouse ?
+            (widgetUnderMouse->internalWinId() ? widgetUnderMouse : widgetUnderMouse->nativeParentWidget()) : 0;
+    }
 }
 
 - (void)applicationDidResignActive:(NSNotification *)notification
@@ -262,7 +279,14 @@ static void cleanupCocoaApplicationDelegate()
     if (reflectionDelegate
         && [reflectionDelegate respondsToSelector:@selector(applicationDidResignActive:)])
         [reflectionDelegate applicationDidResignActive:notification];
+
     onApplicationChangedActivation(false);
+
+    if (!QWidget::mouseGrabber())
+        QApplicationPrivate::dispatchEnterLeave(0, qt_last_mouse_receiver);
+    qt_last_mouse_receiver = 0;
+    qt_last_native_mouse_receiver = 0;
+    qt_button_down = 0;
 }
 
 - (void)applicationDidChangeScreenParameters:(NSNotification *)notification
diff --git a/src/gui/kernel/qcocoapanel_mac.mm b/src/gui/kernel/qcocoapanel_mac.mm
index a0f17bc..67a12e2 100644
--- a/src/gui/kernel/qcocoapanel_mac.mm
+++ b/src/gui/kernel/qcocoapanel_mac.mm
@@ -47,9 +47,10 @@
 #import <private/qcocoaview_mac_p.h>
 #import <private/qcocoawindowcustomthemeframe_mac_p.h>
 #import <private/qcocoaapplication_mac_p.h>
-#include <private/qapplication_p.h>
-#include <private/qbackingstore_p.h>
-
+#import <private/qmultitouch_mac_p.h>
+#import <private/qapplication_p.h>
+#import <private/qbackingstore_p.h>
+#import <private/qdnd_p.h>
 
 #include <QtGui/QWidget>
 
diff --git a/src/gui/kernel/qcocoapanel_mac_p.h b/src/gui/kernel/qcocoapanel_mac_p.h
index e4dd73b..b41a4b5 100644
--- a/src/gui/kernel/qcocoapanel_mac_p.h
+++ b/src/gui/kernel/qcocoapanel_mac_p.h
@@ -50,20 +50,27 @@
 // We mean it.
 //
 
+#ifndef QCOCOAPANEL_MAC_P
+#define QCOCOAPANEL_MAC_P
+
 #include "qmacdefines_mac.h"
 #ifdef QT_MAC_USE_COCOA
 #import <Cocoa/Cocoa.h>
 
 QT_FORWARD_DECLARE_CLASS(QStringList);
+QT_FORWARD_DECLARE_CLASS(QCocoaDropData);
 
 @interface QT_MANGLE_NAMESPACE(QCocoaPanel) : NSPanel {
-    bool leftButtonIsRightButton;
     QStringList *currentCustomDragTypes;
+    QCocoaDropData *dropData;
+    NSInteger dragEnterSequence;
 }
 
 + (Class)frameViewClassForStyleMask:(NSUInteger)styleMask;
 - (void)registerDragTypes;
+- (void)drawRectOriginal:(NSRect)rect;
 
 @end
 #endif
 
+#endif
diff --git a/src/gui/kernel/qcocoasharedwindowmethods_mac_p.h b/src/gui/kernel/qcocoasharedwindowmethods_mac_p.h
index df0f24e..c4b74c6 100644
--- a/src/gui/kernel/qcocoasharedwindowmethods_mac_p.h
+++ b/src/gui/kernel/qcocoasharedwindowmethods_mac_p.h
@@ -62,7 +62,6 @@ extern void qt_event_request_window_change(QWidget *); // qapplication_mac.mm
 extern void qt_mac_send_posted_gl_updates(QWidget *widget); // qapplication_mac.mm
 
 Q_GLOBAL_STATIC(QPointer<QWidget>, currentDragTarget);
-
 QT_END_NAMESPACE
 
 - (id)initWithContentRect:(NSRect)contentRect
@@ -89,6 +88,8 @@ QT_END_NAMESPACE
     QWidget *widget = [self QT_MANGLE_NAMESPACE(qt_qwidget)];
     if (!widget)
         return NO; // This should happen only for qt_root_win
+    if (QApplicationPrivate::isBlockedByModal(widget))
+        return NO;
 
     bool isToolTip = (widget->windowType() == Qt::ToolTip);
     bool isPopup = (widget->windowType() == Qt::Popup);
@@ -100,6 +101,8 @@ QT_END_NAMESPACE
     QWidget *widget = [self QT_MANGLE_NAMESPACE(qt_qwidget)];
     if (!widget)
         return NO; // This should happen only for qt_root_win
+    if ([self isSheet])
+        return NO;
 
     bool isToolTip = (widget->windowType() == Qt::ToolTip);
     bool isPopup = (widget->windowType() == Qt::Popup);
@@ -145,66 +148,27 @@ QT_END_NAMESPACE
 
 - (void)sendEvent:(NSEvent *)event
 {
-    QWidget *widget = [[QT_MANGLE_NAMESPACE(QCocoaWindowDelegate) sharedDelegate] qt_qwidgetForWindow:self];
-    // Cocoa can hold onto the window after we've disavowed its knowledge. So,
-    // if we get sent an event afterwards just have it go through the super's
-    // version and don't do any stuff with Qt.
-    if (!widget) {
-        [super sendEvent:event];
-        return;
-    }
-
     [self retain];
-    QT_MANGLE_NAMESPACE(QCocoaView) *view = static_cast<QT_MANGLE_NAMESPACE(QCocoaView) *>(qt_mac_nativeview_for(widget));
-    Qt::MouseButton mouseButton = cocoaButton2QtButton([event buttonNumber]);
 
     bool handled = false;
-    // sometimes need to redirect mouse events to the popup.
-    QWidget *popup = qAppInstance()->activePopupWidget();
-    if (popup && popup != widget) {
-        switch([event type])
-        {
-        case NSLeftMouseDown:
-            if (!qt_button_down)
-                qt_button_down = widget;
-            handled = qt_mac_handleMouseEvent(view, event, QEvent::MouseButtonPress, mouseButton);
-            // Don't call super here. This prevents us from getting the mouseUp event,
-            // which we need to send even if the mouseDown event was not accepted.
-            // (this is standard Qt behavior.)
-            break;
-        case NSRightMouseDown:
-        case NSOtherMouseDown:
-            if (!qt_button_down)
-                qt_button_down = widget;
-            handled = qt_mac_handleMouseEvent(view, event, QEvent::MouseButtonPress, mouseButton);
-            break;
-        case NSLeftMouseUp:
-        case NSRightMouseUp:
-        case NSOtherMouseUp:
-            handled = qt_mac_handleMouseEvent(view, event, QEvent::MouseButtonRelease, mouseButton);
-            qt_button_down = 0;
-            break;
-        case NSMouseMoved:
-            handled = qt_mac_handleMouseEvent(view, event, QEvent::MouseMove, Qt::NoButton);
-            break;
-        case NSLeftMouseDragged:
-        case NSRightMouseDragged:
-        case NSOtherMouseDragged:
-            [QT_MANGLE_NAMESPACE(QCocoaView) currentMouseEvent]->view = view;
-            [QT_MANGLE_NAMESPACE(QCocoaView) currentMouseEvent]->theEvent = event;
-            handled = qt_mac_handleMouseEvent(view, event, QEvent::MouseMove, mouseButton);
-            break;
-        default:
-            [super sendEvent:event];
-            break;
-        }
-    } else {
-        [super sendEvent:event];
+    switch([event type]) {
+    case NSMouseMoved:
+        // Cocoa sends move events to a parent and all its children under the mouse, much
+        // like Qt handles hover events. But we only want to handle the move event once, so
+        // to optimize a bit (since we subscribe for move event for all views), we handle it
+        // here before this logic happends. Note: it might be tempting to do this shortcut for
+        // all mouse events. The problem is that Cocoa does more than just find the correct view
+        // when sending the event, like raising windows etc. So avoid it as much as possible:
+        handled = qt_mac_handleMouseEvent(event, QEvent::MouseMove, Qt::NoButton, 0);
+        break;
+    default:
+        break;
     }
 
-    if (!handled)
-        qt_mac_dispatchNCMouseMessage(self, event, [self QT_MANGLE_NAMESPACE(qt_qwidget)], leftButtonIsRightButton);
-
+    if (!handled) {
+        [super sendEvent:event];
+        qt_mac_handleNonClientAreaMouseEvent(self, event);
+    }
     [self release];
 }
 
@@ -237,6 +201,56 @@ QT_END_NAMESPACE
     return [super frameViewClassForStyleMask:styleMask];
 }
 
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
+- (void)touchesBeganWithEvent:(NSEvent *)event;
+{
+    QPoint qlocal, qglobal;
+    QWidget *widgetToGetTouch = 0;
+    qt_mac_getTargetForMouseEvent(event, QEvent::Gesture, qlocal, qglobal, 0, &widgetToGetTouch);
+    if (!widgetToGetTouch)
+        return;
+
+    bool all = widgetToGetTouch->testAttribute(Qt::WA_TouchPadAcceptSingleTouchEvents);
+    qt_translateRawTouchEvent(widgetToGetTouch, QTouchEvent::TouchPad, QCocoaTouch::getCurrentTouchPointList(event, all));
+}
+
+- (void)touchesMovedWithEvent:(NSEvent *)event;
+{
+    QPoint qlocal, qglobal;
+    QWidget *widgetToGetTouch = 0;
+    qt_mac_getTargetForMouseEvent(event, QEvent::Gesture, qlocal, qglobal, 0, &widgetToGetTouch);
+    if (!widgetToGetTouch)
+        return;
+
+    bool all = widgetToGetTouch->testAttribute(Qt::WA_TouchPadAcceptSingleTouchEvents);
+    qt_translateRawTouchEvent(widgetToGetTouch, QTouchEvent::TouchPad, QCocoaTouch::getCurrentTouchPointList(event, all));
+}
+
+- (void)touchesEndedWithEvent:(NSEvent *)event;
+{
+    QPoint qlocal, qglobal;
+    QWidget *widgetToGetTouch = 0;
+    qt_mac_getTargetForMouseEvent(event, QEvent::Gesture, qlocal, qglobal, 0, &widgetToGetTouch);
+    if (!widgetToGetTouch)
+        return;
+
+    bool all = widgetToGetTouch->testAttribute(Qt::WA_TouchPadAcceptSingleTouchEvents);
+    qt_translateRawTouchEvent(widgetToGetTouch, QTouchEvent::TouchPad, QCocoaTouch::getCurrentTouchPointList(event, all));
+}
+
+- (void)touchesCancelledWithEvent:(NSEvent *)event;
+{
+    QPoint qlocal, qglobal;
+    QWidget *widgetToGetTouch = 0;
+    qt_mac_getTargetForMouseEvent(event, QEvent::Gesture, qlocal, qglobal, 0, &widgetToGetTouch);
+    if (!widgetToGetTouch)
+        return;
+
+    bool all = widgetToGetTouch->testAttribute(Qt::WA_TouchPadAcceptSingleTouchEvents);
+    qt_translateRawTouchEvent(widgetToGetTouch, QTouchEvent::TouchPad, QCocoaTouch::getCurrentTouchPointList(event, all));
+}
+#endif // MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
+
 -(void)registerDragTypes
 {
     // Calling registerForDraggedTypes below is slow, so only do
@@ -259,21 +273,47 @@ QT_END_NAMESPACE
                        NSMultipleTextSelectionPboardType, mimeTypeGeneric, nil];
         // Add custom types supported by the application.
         for (int i = 0; i < customTypes.size(); i++) {
-           [supportedTypes addObject:reinterpret_cast<const NSString *>(QCFString::toCFStringRef(customTypes[i]))];
+           [supportedTypes addObject:qt_mac_QStringToNSString(customTypes[i])];
         }
         [self registerForDraggedTypes:supportedTypes];
     }
 }
 
-- (QWidget *)dragTargetHitTest:(id <NSDraggingInfo>)sender
+- (void)removeDropData
 {
-    // Do a hittest to find the NSView under the
-    // mouse, and return the corresponding QWidget:
-    NSPoint windowPoint = [sender draggingLocation];
-    NSView *candidateView = [[self contentView] hitTest:windowPoint];
-    if (![candidateView isKindOfClass:[QT_MANGLE_NAMESPACE(QCocoaView) class]])
-        return 0;
-    return [static_cast<QT_MANGLE_NAMESPACE(QCocoaView) *>(candidateView) qt_qwidget];
+    if (dropData) {
+        delete dropData;
+        dropData = 0;
+    }
+}
+
+- (void)addDropData:(id <NSDraggingInfo>)sender
+{
+    [self removeDropData];
+    CFStringRef dropPasteboard = (CFStringRef) [[sender draggingPasteboard] name];
+    dropData = new QCocoaDropData(dropPasteboard);
+}
+
+- (void)changeDraggingCursor:(NSDragOperation)newOperation
+{
+    static SEL action = nil;
+    static bool operationSupported = false;
+    if (action == nil) {
+        action = NSSelectorFromString(@"operationNotAllowedCursor");
+        if ([NSCursor respondsToSelector:action]) {
+            operationSupported = true;
+        }
+    }
+    if (operationSupported) {
+        NSCursor *notAllowedCursor = [NSCursor performSelector:action];
+        bool isNotAllowedCursor = ([NSCursor currentCursor] == notAllowedCursor);
+        if (newOperation == NSDragOperationNone && !isNotAllowedCursor) {
+            [notAllowedCursor push];
+        } else if (newOperation != NSDragOperationNone && isNotAllowedCursor) {
+            [notAllowedCursor pop];
+        }
+
+    }
 }
 
 - (NSDragOperation)draggingEntered:(id <NSDraggingInfo>)sender
@@ -286,64 +326,211 @@ QT_END_NAMESPACE
     // registerForDraggedTypes on the views will severly degrade initialization time
     // for an application that uses a lot of drag subscribing widgets.
 
-    QWidget *target = [self dragTargetHitTest:sender];
-    if (!target)
+    NSPoint nswindowPoint = [sender draggingLocation];
+    NSPoint nsglobalPoint = [[sender draggingDestinationWindow] convertBaseToScreen:nswindowPoint];
+    QPoint globalPoint = flipPoint(nsglobalPoint).toPoint();
+
+    QWidget *qwidget = QApplication::widgetAt(globalPoint);
+    *currentDragTarget() = qwidget;
+    if (!qwidget)
         return [super draggingEntered:sender];
-    if (target->testAttribute(Qt::WA_DropSiteRegistered) == false)
+    if (qwidget->testAttribute(Qt::WA_DropSiteRegistered) == false)
         return NSDragOperationNone;
 
-    *currentDragTarget() = target;
-    return [reinterpret_cast<NSView *>((*currentDragTarget())->winId()) draggingEntered:sender];
+    [self addDropData:sender];
+
+    QMimeData *mimeData = dropData;
+    if (QDragManager::self()->source())
+        mimeData = QDragManager::self()->dragPrivate()->data;
+
+    NSDragOperation nsActions = [sender draggingSourceOperationMask];
+    Qt::DropActions qtAllowed = qt_mac_mapNSDragOperations(nsActions);
+    QT_PREPEND_NAMESPACE(qt_mac_dnd_answer_rec.lastOperation) = nsActions;
+    Qt::KeyboardModifiers modifiers = Qt::NoModifier;
+
+    if ([sender draggingSource] != nil) {
+        // modifier flags might have changed, update it here since we don't send any input events.
+        QApplicationPrivate::modifier_buttons = qt_cocoaModifiers2QtModifiers([[NSApp currentEvent] modifierFlags]);
+        modifiers = QApplication::keyboardModifiers();
+    } else {
+        // when the source is from another application the above technique will not work.
+        modifiers = qt_cocoaDragOperation2QtModifiers(nsActions);
+    }
+
+    // send the drag enter event to the widget.
+    QPoint localPoint(qwidget->mapFromGlobal(globalPoint));
+    QDragEnterEvent qDEEvent(localPoint, qtAllowed, mimeData, QApplication::mouseButtons(), modifiers);
+    QApplication::sendEvent(qwidget, &qDEEvent);
+
+    if (!qDEEvent.isAccepted()) {
+        // The enter event was not accepted. We mark this by removing
+        // the drop data so we don't send subsequent drag move events:
+        [self removeDropData];
+        [self changeDraggingCursor:NSDragOperationNone];
+        return NSDragOperationNone;
+    } else {
+        // Send a drag move event immediately after a drag enter event (as per documentation).
+        QDragMoveEvent qDMEvent(localPoint, qtAllowed, mimeData, QApplication::mouseButtons(), modifiers);
+        qDMEvent.setDropAction(qDEEvent.dropAction());
+        qDMEvent.accept(); // accept by default, since enter event was accepted.
+        QApplication::sendEvent(qwidget, &qDMEvent);
+
+        if (!qDMEvent.isAccepted() || qDMEvent.dropAction() == Qt::IgnoreAction) {
+            // Since we accepted the drag enter event, the widget expects
+            // future drage move events.
+            nsActions = NSDragOperationNone;
+            // Save as ignored in the answer rect.
+            qDMEvent.setDropAction(Qt::IgnoreAction);
+        } else {
+            nsActions = QT_PREPEND_NAMESPACE(qt_mac_mapDropAction)(qDMEvent.dropAction());
+        }
+
+        QT_PREPEND_NAMESPACE(qt_mac_copy_answer_rect)(qDMEvent);
+        [self changeDraggingCursor:nsActions];
+        return nsActions;
+    }
  }
 
-- (NSDragOperation)draggingUpdated:(id < NSDraggingInfo >)sender
+- (NSDragOperation)draggingUpdated:(id <NSDraggingInfo>)sender
 {
-    QWidget *target = [self dragTargetHitTest:sender];
-    if (!target)
-        return [super draggingUpdated:sender];
-
-    if (target == *currentDragTarget()) {
-        // The drag continues to move over the widget that we have sendt
-        // a draggingEntered message to. So just update the view:
-        return [reinterpret_cast<NSView *>((*currentDragTarget())->winId()) draggingUpdated:sender];
-    } else {
-        // The widget under the mouse has changed.
-        // So we need to fake enter/leave events:
-        if (*currentDragTarget())
-            [reinterpret_cast<NSView *>((*currentDragTarget())->winId()) draggingExited:sender];
-        if (target->testAttribute(Qt::WA_DropSiteRegistered) == false) {
-            *currentDragTarget() = 0;
-            return NSDragOperationNone;
+    NSPoint nswindowPoint = [sender draggingLocation];
+    NSPoint nsglobalPoint = [[sender draggingDestinationWindow] convertBaseToScreen:nswindowPoint];
+    QPoint globalPoint = flipPoint(nsglobalPoint).toPoint();
+
+    QWidget *qwidget = QApplication::widgetAt(globalPoint);
+    if (!qwidget)
+        return [super draggingEntered:sender];
+
+    // First, check if the widget under the mouse has changed since the
+    // last drag move events. If so, we need to change target, and dispatch
+    // syntetic drag enter/leave events:
+    if (qwidget != *currentDragTarget()) {
+        if (*currentDragTarget() && dropData) {
+            QDragLeaveEvent de;
+            QApplication::sendEvent(*currentDragTarget(), &de);
+            [self removeDropData];
         }
-        *currentDragTarget() = target;
-        return [reinterpret_cast<NSView *>((*currentDragTarget())->winId()) draggingEntered:sender];
+        return [self draggingEntered:sender];
+    }
+
+    if (qwidget->testAttribute(Qt::WA_DropSiteRegistered) == false)
+        return NSDragOperationNone;
+
+    // If we have no drop data (which will be assigned inside draggingEntered), it means
+    // that the current drag target did not accept the enter event. If so, we ignore
+    // subsequent move events as well:
+    if (dropData == 0) {
+        [self changeDraggingCursor:NSDragOperationNone];
+        return NSDragOperationNone;
+    }
+
+    // If the mouse is still within the accepted rect (provided by
+    // the application on a previous event), we follow the optimization
+    // and just return the answer given at that point:
+    NSDragOperation nsActions = [sender draggingSourceOperationMask];
+    QPoint localPoint(qwidget->mapFromGlobal(globalPoint));
+    if (qt_mac_mouse_inside_answer_rect(localPoint)
+        && QT_PREPEND_NAMESPACE(qt_mac_dnd_answer_rec.lastOperation) == nsActions) {
+        NSDragOperation operation = QT_PREPEND_NAMESPACE(qt_mac_mapDropActions)(QT_PREPEND_NAMESPACE(qt_mac_dnd_answer_rec.lastAction));
+        [self changeDraggingCursor:operation];
+        return operation;
     }
+
+    QT_PREPEND_NAMESPACE(qt_mac_dnd_answer_rec.lastOperation) = nsActions;
+    Qt::DropActions qtAllowed = QT_PREPEND_NAMESPACE(qt_mac_mapNSDragOperations)(nsActions);
+    Qt::KeyboardModifiers modifiers  = Qt::NoModifier;
+
+    // Update modifiers:
+    if ([sender draggingSource] != nil) {
+        QApplicationPrivate::modifier_buttons = qt_cocoaModifiers2QtModifiers([[NSApp currentEvent] modifierFlags]);
+        modifiers = QApplication::keyboardModifiers();
+    } else {
+        modifiers = qt_cocoaDragOperation2QtModifiers(nsActions);
+    }
+
+    QMimeData *mimeData = dropData;
+    if (QDragManager::self()->source())
+        mimeData = QDragManager::self()->dragPrivate()->data;
+
+    // Insert the same drop action on the event according to
+    // what the application told us it should be on the previous event:
+    QDragMoveEvent qDMEvent(localPoint, qtAllowed, mimeData, QApplication::mouseButtons(), modifiers);
+    if (QT_PREPEND_NAMESPACE(qt_mac_dnd_answer_rec).lastAction != Qt::IgnoreAction
+        && QT_PREPEND_NAMESPACE(qt_mac_dnd_answer_rec).buttons == qDMEvent.mouseButtons()
+        && QT_PREPEND_NAMESPACE(qt_mac_dnd_answer_rec).modifiers == qDMEvent.keyboardModifiers())
+        qDMEvent.setDropAction(QT_PREPEND_NAMESPACE(qt_mac_dnd_answer_rec).lastAction);
+
+    // Now, end the drag move event to the widget:
+    qDMEvent.accept();
+    QApplication::sendEvent(qwidget, &qDMEvent);
+
+    NSDragOperation operation = qt_mac_mapDropAction(qDMEvent.dropAction());
+    if (!qDMEvent.isAccepted() || qDMEvent.dropAction() == Qt::IgnoreAction) {
+        // Ignore this event (we will still receive further
+        // notifications), save as ignored in the answer rect:
+        operation = NSDragOperationNone;
+        qDMEvent.setDropAction(Qt::IgnoreAction);
+    }
+
+    qt_mac_copy_answer_rect(qDMEvent);
+    [self changeDraggingCursor:operation];
+
+    return operation;
 }
 
-- (void)draggingExited:(id < NSDraggingInfo >)sender
+- (void)draggingExited:(id <NSDraggingInfo>)sender
 {
-    QWidget *target = [self dragTargetHitTest:sender];
-    if (!target)
+    NSPoint nswindowPoint = [sender draggingLocation];
+    NSPoint nsglobalPoint = [[sender draggingDestinationWindow] convertBaseToScreen:nswindowPoint];
+    QPoint globalPoint = flipPoint(nsglobalPoint).toPoint();
+
+    QWidget *qwidget = *currentDragTarget();
+    if (!qwidget)
         return [super draggingExited:sender];
 
-    if (*currentDragTarget()) {
-        [reinterpret_cast<NSView *>((*currentDragTarget())->winId()) draggingExited:sender];
-        *currentDragTarget() = 0;
+    if (dropData) {
+        QDragLeaveEvent de;
+        QApplication::sendEvent(qwidget, &de);
+        [self removeDropData];
     }
+
+    // Clean-up:
+    [self removeDropData];
+    *currentDragTarget() = 0;
+    [self changeDraggingCursor:NSDragOperationEvery];
 }
 
-- (BOOL)performDragOperation:(id < NSDraggingInfo >)sender
+- (BOOL)performDragOperation:(id <NSDraggingInfo>)sender
 {
-    QWidget *target = [self dragTargetHitTest:sender];
-    if (!target)
-        return [super performDragOperation:sender];
-
-    BOOL dropResult = NO;
-    if (*currentDragTarget()) {
-        dropResult = [reinterpret_cast<NSView *>((*currentDragTarget())->winId()) performDragOperation:sender];
-        *currentDragTarget() = 0;
-    }
-    return dropResult;
+    QWidget *qwidget = *currentDragTarget();
+    if (!qwidget)
+        return NO;
+
+    *currentDragTarget() = 0;
+    NSPoint nswindowPoint = [sender draggingLocation];
+    NSPoint nsglobalPoint = [[sender draggingDestinationWindow] convertBaseToScreen:nswindowPoint];
+    QPoint globalPoint = flipPoint(nsglobalPoint).toPoint();
+
+    [self addDropData:sender];
+
+    NSDragOperation nsActions = [sender draggingSourceOperationMask];
+    Qt::DropActions qtAllowed = qt_mac_mapNSDragOperations(nsActions);
+    QMimeData *mimeData = dropData;
+
+    if (QDragManager::self()->source())
+        mimeData = QDragManager::self()->dragPrivate()->data;
+    if (QDragManager::self()->object)
+        QDragManager::self()->dragPrivate()->target = qwidget;
+
+    QPoint localPoint(qwidget->mapFromGlobal(globalPoint));
+    QDropEvent de(localPoint, qtAllowed, mimeData,
+                  QApplication::mouseButtons(), QApplication::keyboardModifiers());
+    QApplication::sendEvent(qwidget, &de);
+
+    if (QDragManager::self()->object)
+        QDragManager::self()->dragPrivate()->executed_action = de.dropAction();
+
+    return de.isAccepted();
 }
 
 - (void)displayIfNeeded
@@ -394,8 +581,8 @@ static bool firstDrawingInvocation = true;
 - (void)drawRectSpecial:(NSRect)rect
 {
     // Call the original drawing method.
-    [self drawRectOriginal:rect];
-    NSWindow *window = [self window];
+    [id(self) drawRectOriginal:rect];
+    NSWindow *window = [id(self) window];
     NSToolbar *toolbar = [window toolbar];
     if(!toolbar) {
         // There is no toolbar, we have to draw a line on top of the line drawn by Cocoa.
@@ -415,3 +602,11 @@ static bool firstDrawingInvocation = true;
         }
     }
 }
+
+- (void)drawRectOriginal:(NSRect)rect
+{
+    Q_UNUSED(rect)
+    // This method implementation is here to silenct the compiler.
+    // See drawRectSpecial for information.
+}
+
diff --git a/src/gui/kernel/qcocoaview_mac.mm b/src/gui/kernel/qcocoaview_mac.mm
index 5ea893c..ff2dfe7 100644
--- a/src/gui/kernel/qcocoaview_mac.mm
+++ b/src/gui/kernel/qcocoaview_mac.mm
@@ -49,7 +49,6 @@
 #include <private/qt_cocoa_helpers_mac_p.h>
 #include <private/qdnd_p.h>
 #include <private/qmacinputcontext_p.h>
-#include <private/qmultitouch_mac_p.h>
 #include <private/qevent_p.h>
 #include <private/qbackingstore_p.h>
 
@@ -76,70 +75,16 @@
 
 QT_BEGIN_NAMESPACE
 
-Q_GLOBAL_STATIC(DnDParams, qMacDnDParams);
-
-extern void qt_mac_update_cursor_at_global_pos(const QPoint &globalPos); // qcursor_mac.mm
+extern void qt_mac_update_cursor(); // qcursor_mac.mm
 extern bool qt_sendSpontaneousEvent(QObject *, QEvent *); // qapplication.cpp
+extern QPointer<QWidget> qt_last_mouse_receiver; // qapplication_mac.cpp
+extern QPointer<QWidget> qt_last_native_mouse_receiver; // qt_cocoa_helpers_mac.mm
 extern OSViewRef qt_mac_nativeview_for(const QWidget *w); // qwidget_mac.mm
-extern QPointer<QWidget> qt_mouseover; //qapplication_mac.mm
+extern OSViewRef qt_mac_effectiveview_for(const QWidget *w); // qwidget_mac.mm
 extern QPointer<QWidget> qt_button_down; //qapplication_mac.cpp
 extern Qt::MouseButton cocoaButton2QtButton(NSInteger buttonNum);
-
-struct dndenum_mapper
-{
-    NSDragOperation mac_code;
-    Qt::DropAction qt_code;
-    bool Qt2Mac;
-};
-
-static dndenum_mapper dnd_enums[] = {
-    { NSDragOperationLink,  Qt::LinkAction, true },
-    { NSDragOperationMove,  Qt::MoveAction, true },
-    { NSDragOperationCopy,  Qt::CopyAction, true },
-    { NSDragOperationGeneric,  Qt::CopyAction, false },
-    { NSDragOperationEvery, Qt::ActionMask, false },
-    { NSDragOperationNone, Qt::IgnoreAction, false }
-};
-
-static NSDragOperation qt_mac_mapDropAction(Qt::DropAction action)
-{
-    for (int i=0; dnd_enums[i].qt_code; i++) {
-        if (dnd_enums[i].Qt2Mac && (action & dnd_enums[i].qt_code)) {
-            return dnd_enums[i].mac_code;
-        }
-    }
-    return NSDragOperationNone;
-}
-
-static NSDragOperation qt_mac_mapDropActions(Qt::DropActions actions)
-{
-    NSDragOperation nsActions = NSDragOperationNone;
-    for (int i=0; dnd_enums[i].qt_code; i++) {
-        if (dnd_enums[i].Qt2Mac && (actions & dnd_enums[i].qt_code))
-            nsActions |= dnd_enums[i].mac_code;
-    }
-    return nsActions;
-}
-
-static Qt::DropAction qt_mac_mapNSDragOperation(NSDragOperation nsActions)
-{
-    Qt::DropAction action = Qt::IgnoreAction;
-    for (int i=0; dnd_enums[i].mac_code; i++) {
-        if (nsActions & dnd_enums[i].mac_code)
-            return dnd_enums[i].qt_code;
-    }
-    return action;
-}
-
-static Qt::DropActions qt_mac_mapNSDragOperations(NSDragOperation nsActions)
-{
-    Qt::DropActions actions = Qt::IgnoreAction;
-    for (int i=0; dnd_enums[i].mac_code; i++) {
-        if (nsActions & dnd_enums[i].mac_code)
-            actions |= dnd_enums[i].qt_code;
-    }
-    return actions;
-}
+extern QWidget *mac_mouse_grabber;
+extern bool qt_mac_clearDirtyOnWidgetInsideDrawWidget; // qwidget.cpp
 
 static QColor colorFrom(NSColor *color)
 {
@@ -185,6 +130,7 @@ extern "C" {
     extern NSString *NSTextInputReplacementRangeAttributeName;
 }
 
+//#define ALIEN_DEBUG 1
 #ifdef ALIEN_DEBUG
 static int qCocoaViewCount = 0;
 #endif
@@ -202,12 +148,14 @@ static int qCocoaViewCount = 0;
 
 #ifdef ALIEN_DEBUG
     ++qCocoaViewCount;
-    qDebug() << "init: qCocoaViewCount is" << qCocoaViewCount;
+    qDebug() << "Alien: create native view for" << widget << ". qCocoaViewCount is:" << qCocoaViewCount;
 #endif
 
     composing = false;
     sendKeyEvents = true;
     fromKeyDownEvent = false;
+    alienTouchCount = 0;
+
     [self setHidden:YES];
     return self;
 }
@@ -222,246 +170,15 @@ static int qCocoaViewCount = 0;
                                                object:self];
 }
 
-- (void)resetCursorRects
-{
-    // [NSView addCursorRect] is slow, so bail out early if we can:
-    if (NSIsEmptyRect([self visibleRect]))
-        return;
-
-    QWidget *cursorWidget = qwidget;
-
-    if (cursorWidget->testAttribute(Qt::WA_TransparentForMouseEvents))
-        cursorWidget = QApplication::widgetAt(qwidget->mapToGlobal(qwidget->rect().center()));
-
-    if (cursorWidget == 0)
-        return;
-
-    if (!cursorWidget->testAttribute(Qt::WA_SetCursor)) {
-        [super resetCursorRects];
-        return;
-    }
-
-    QRegion mask = qt_widget_private(cursorWidget)->extra->mask;
-    NSCursor *nscursor = static_cast<NSCursor *>(qt_mac_nsCursorForQCursor(cursorWidget->cursor()));
-    // The mask could have the WA_MouseNoMask attribute set and that means that we have to ignore the mask.
-    if (mask.isEmpty() || cursorWidget->testAttribute(Qt::WA_MouseNoMask)) {
-        [self addCursorRect:[qt_mac_nativeview_for(cursorWidget) visibleRect] cursor:nscursor];
-    } else {
-        const QVector<QRect> &rects = mask.rects();
-        for (int i = 0; i < rects.size(); ++i) {
-            const QRect &rect = rects.at(i);
-            [self addCursorRect:NSMakeRect(rect.x(), rect.y(), rect.width(), rect.height()) cursor:nscursor];
-        }
-    }
-}
-
-- (void)removeDropData
-{
-    if (dropData) {
-        delete dropData;
-        dropData = 0;
-    }
-}
-
-- (void)addDropData:(id <NSDraggingInfo>)sender
-{
-    [self removeDropData];
-    CFStringRef dropPasteboard = (CFStringRef) [[sender draggingPasteboard] name];
-    dropData = new QCocoaDropData(dropPasteboard);
-}
-
-- (void)changeDraggingCursor:(NSDragOperation)newOperation
-{
-    static SEL action = nil;
-    static bool operationSupported = false;
-    if (action == nil) {
-        action = NSSelectorFromString(@"operationNotAllowedCursor");
-        if ([NSCursor respondsToSelector:action]) {
-            operationSupported = true;
-        }
-    }
-    if (operationSupported) {
-        NSCursor *notAllowedCursor = [NSCursor performSelector:action];
-        bool isNotAllowedCursor = ([NSCursor currentCursor] == notAllowedCursor);
-        if (newOperation == NSDragOperationNone && !isNotAllowedCursor) {
-            [notAllowedCursor push];
-        } else if (newOperation != NSDragOperationNone && isNotAllowedCursor) {
-            [notAllowedCursor pop];
-        }
-
-    }
-}
-
-- (NSDragOperation)draggingEntered:(id <NSDraggingInfo>)sender
-{
-    // NB: This function is called from QCoocaWindow/QCocoaPanel rather than directly
-    // from Cocoa. They modify the drag target, and might fake enter/leave events.
-    NSPoint windowPoint = [sender draggingLocation];
-    dragEnterSequence = [sender draggingSequenceNumber];
-    [self addDropData:sender];
-    QMimeData *mimeData = dropData;
-    if (QDragManager::self()->source())
-        mimeData = QDragManager::self()->dragPrivate()->data;
-    NSPoint localPoint = [self convertPoint:windowPoint fromView:nil];
-    QPoint posDrag(localPoint.x, localPoint.y);
-    NSDragOperation nsActions = [sender draggingSourceOperationMask];
-    Qt::DropActions qtAllowed = qt_mac_mapNSDragOperations(nsActions);
-    QT_PREPEND_NAMESPACE(qt_mac_dnd_answer_rec.lastOperation) = nsActions;
-    Qt::KeyboardModifiers modifiers  = Qt::NoModifier;
-    if ([sender draggingSource] != nil) {
-        // modifier flags might have changed, update it here since we don't send any input events.
-        QApplicationPrivate::modifier_buttons = qt_cocoaModifiers2QtModifiers([[NSApp currentEvent] modifierFlags]);
-        modifiers = QApplication::keyboardModifiers();
-    } else {
-        // when the source is from another application the above technique will not work.
-        modifiers = qt_cocoaDragOperation2QtModifiers(nsActions);
-    }
-    // send the drag enter event to the widget.
-    QDragEnterEvent qDEEvent(posDrag, qtAllowed, mimeData, QApplication::mouseButtons(), modifiers);
-    QApplication::sendEvent(qwidget, &qDEEvent);
-    if (!qDEEvent.isAccepted()) {
-        // widget is not interested in this drag, so ignore this drop data.
-        [self removeDropData];
-        [self changeDraggingCursor:NSDragOperationNone];
-        return NSDragOperationNone;
-    } else {
-        // save the mouse position, used by draggingExited handler.
-        DnDParams *dndParams = [QT_MANGLE_NAMESPACE(QCocoaView) currentMouseEvent];
-        dndParams->activeDragEnterPos = windowPoint;
-        // send a drag move event immediately after a drag enter event (as per documentation).
-        QDragMoveEvent qDMEvent(posDrag, qtAllowed, mimeData, QApplication::mouseButtons(), modifiers);
-        qDMEvent.setDropAction(qDEEvent.dropAction());
-        qDMEvent.accept(); // accept by default, since enter event was accepted.
-        QApplication::sendEvent(qwidget, &qDMEvent);
-        if (!qDMEvent.isAccepted() || qDMEvent.dropAction() == Qt::IgnoreAction) {
-            // since we accepted the drag enter event, the widget expects
-            // future drage move events.
-            // ### check if we need to treat this like the drag enter event.
-            nsActions = NSDragOperationNone;
-            // Save as ignored in the answer rect.
-            qDMEvent.setDropAction(Qt::IgnoreAction);
-        } else {
-            nsActions = QT_PREPEND_NAMESPACE(qt_mac_mapDropAction)(qDMEvent.dropAction());
-        }
-        QT_PREPEND_NAMESPACE(qt_mac_copy_answer_rect)(qDMEvent);
-        [self changeDraggingCursor:nsActions];
-        return nsActions;
-    }
- }
-- (NSDragOperation)draggingUpdated:(id < NSDraggingInfo >)sender
-{
-    // NB: This function is called from QCoocaWindow/QCocoaPanel rather than directly
-    // from Cocoa. They modify the drag target, and might fake enter/leave events.
-    NSPoint windowPoint = [sender draggingLocation];
-    // in cases like QFocusFrame, the view under the mouse might
-    // not have received the drag enter. Generate a synthetic
-    // drag enter event for that view.
-    if (dragEnterSequence != [sender draggingSequenceNumber])
-        [self draggingEntered:sender];
-    // drag enter event was rejected, so ignore the move event.
-    if (dropData == 0) {
-        [self changeDraggingCursor:NSDragOperationNone];
-        return NSDragOperationNone;
-    }
-    // return last value, if we are still in the answerRect.
-    NSPoint localPoint = [self convertPoint:windowPoint fromView:nil];
-    NSDragOperation nsActions = [sender draggingSourceOperationMask];
-    QPoint posDrag(localPoint.x, localPoint.y);
-    if (qt_mac_mouse_inside_answer_rect(posDrag)
-        && QT_PREPEND_NAMESPACE(qt_mac_dnd_answer_rec.lastOperation) == nsActions) {
-        NSDragOperation operation = QT_PREPEND_NAMESPACE(qt_mac_mapDropActions)(QT_PREPEND_NAMESPACE(qt_mac_dnd_answer_rec.lastAction));
-        [self changeDraggingCursor:operation];
-        return operation;
-    }
-    // send drag move event to the widget
-    QT_PREPEND_NAMESPACE(qt_mac_dnd_answer_rec.lastOperation) = nsActions;
-    Qt::DropActions qtAllowed = QT_PREPEND_NAMESPACE(qt_mac_mapNSDragOperations)(nsActions);
-    Qt::KeyboardModifiers modifiers  = Qt::NoModifier;
-    if ([sender draggingSource] != nil) {
-        // modifier flags might have changed, update it here since we don't send any input events.
-        QApplicationPrivate::modifier_buttons = qt_cocoaModifiers2QtModifiers([[NSApp currentEvent] modifierFlags]);
-        modifiers = QApplication::keyboardModifiers();
-    } else {
-        // when the source is from another application the above technique will not work.
-        modifiers = qt_cocoaDragOperation2QtModifiers(nsActions);
-    }
-    QMimeData *mimeData = dropData;
-    if (QDragManager::self()->source())
-        mimeData = QDragManager::self()->dragPrivate()->data;
-    QDragMoveEvent qDMEvent(posDrag, qtAllowed, mimeData, QApplication::mouseButtons(), modifiers);
-    if (QT_PREPEND_NAMESPACE(qt_mac_dnd_answer_rec).lastAction != Qt::IgnoreAction
-        && QT_PREPEND_NAMESPACE(qt_mac_dnd_answer_rec).buttons == qDMEvent.mouseButtons()
-        && QT_PREPEND_NAMESPACE(qt_mac_dnd_answer_rec).modifiers == qDMEvent.keyboardModifiers())
-        qDMEvent.setDropAction(QT_PREPEND_NAMESPACE(qt_mac_dnd_answer_rec).lastAction);
-    qDMEvent.accept();
-    QApplication::sendEvent(qwidget, &qDMEvent);
-
-    NSDragOperation operation = qt_mac_mapDropAction(qDMEvent.dropAction());
-    if (!qDMEvent.isAccepted() || qDMEvent.dropAction() == Qt::IgnoreAction) {
-        // ignore this event (we will still receive further notifications)
-        operation = NSDragOperationNone;
-        // Save as ignored in the answer rect.
-        qDMEvent.setDropAction(Qt::IgnoreAction);
-    }
-    qt_mac_copy_answer_rect(qDMEvent);
-    [self changeDraggingCursor:operation];
-    return operation;
-}
-
-- (void)draggingExited:(id < NSDraggingInfo >)sender
-{
-    // NB: This function is called from QCoocaWindow/QCocoaPanel rather than directly
-    // from Cocoa. They modify the drag target, and might fake enter/leave events.
-    Q_UNUSED(sender);
-    dragEnterSequence = -1;
-    // drag enter event was rejected, so ignore the move event.
-    if (dropData) {
-        QDragLeaveEvent de;
-        QApplication::sendEvent(qwidget, &de);
-        [self removeDropData];
-    }
-    [self changeDraggingCursor:NSDragOperationEvery];
-
-}
-
-- (BOOL)performDragOperation:(id <NSDraggingInfo>)sender
-{
-    // NB: This function is called from QCoocaWindow/QCocoaPanel rather than directly
-    // from Cocoa. They modify the drag target, and might fake enter/leave events.
-    NSPoint windowPoint = [sender draggingLocation];
-    dragEnterSequence = -1;
-    [self addDropData:sender];
-
-    NSPoint localPoint = [self convertPoint:windowPoint fromView:nil];
-    QPoint posDrop(localPoint.x, localPoint.y);
-
-    NSDragOperation nsActions = [sender draggingSourceOperationMask];
-    Qt::DropActions qtAllowed = qt_mac_mapNSDragOperations(nsActions);
-    QMimeData *mimeData = dropData;
-    if (QDragManager::self()->source())
-        mimeData = QDragManager::self()->dragPrivate()->data;
-    // send the drop event to the widget.
-    QDropEvent de(posDrop, qtAllowed, mimeData,
-                  QApplication::mouseButtons(), QApplication::keyboardModifiers());
-    if (QDragManager::self()->object)
-        QDragManager::self()->dragPrivate()->target = qwidget;
-    QApplication::sendEvent(qwidget, &de);
-    if (QDragManager::self()->object)
-        QDragManager::self()->dragPrivate()->executed_action = de.dropAction();
-    if (!de.isAccepted())
-        return NO;
-    else
-        return YES;
-}
-
 - (void)dealloc
 {
+    QMacCocoaAutoReleasePool pool;
     delete composingText;
     [[NSNotificationCenter defaultCenter] removeObserver:self];
 
 #ifdef ALIEN_DEBUG
     --qCocoaViewCount;
-    qDebug() << "qCocoaViewCount is" << qCocoaViewCount;
+    qDebug() << "Alien: widget deallocated. qCocoaViewCount is:" << qCocoaViewCount;
 #endif
 
     [super dealloc];
@@ -529,9 +246,8 @@ static int qCocoaViewCount = 0;
 {
     if (!qwidget)
         return;
-
-    // We use a different graphics system.
     if (QApplicationPrivate::graphicsSystem() != 0 && !qwidgetprivate->isInUnifiedToolbar) {
+        // INVARIANT: We use a different graphics system.
 
         // Qt handles the painting occuring inside the window.
         // Cocoa also keeps track of all widgets as NSView and therefore might
@@ -558,7 +274,7 @@ static int qCocoaViewCount = 0;
     qwidgetprivate->hd = cg;
 
     // We steal the CGContext for flushing in the unified toolbar with the raster engine.
-    if (QApplicationPrivate::graphicsSystem() != 0 && qwidgetprivate->isInUnifiedToolbar) {
+    if (QApplicationPrivate::graphicsSystem() != 0 && qwidgetprivate->isInUnifiedToolbar && qwidgetprivate->unifiedSurface) {
         qwidgetprivate->cgContext = cg;
         qwidgetprivate->hasOwnContext = true;
         qwidgetprivate->unifiedSurface->flush(qwidget, qwidgetprivate->ut_rg, qwidgetprivate->ut_pt);
@@ -574,13 +290,13 @@ static int qCocoaViewCount = 0;
         const QRect qrect = QRect(aRect.origin.x, aRect.origin.y, aRect.size.width, aRect.size.height);
         QRegion qrgn;
 
-	const NSRect *rects;
-	NSInteger count;
-	[self getRectsBeingDrawn:&rects count:&count];
-	for (int i = 0; i < count; ++i) {
-	    QRect tmpRect = QRect(rects[i].origin.x, rects[i].origin.y, rects[i].size.width, rects[i].size.height);
-	    qrgn += tmpRect;
-	}
+        const NSRect *rects;
+        NSInteger count;
+        [self getRectsBeingDrawn:&rects count:&count];
+        for (int i = 0; i < count; ++i) {
+            QRect tmpRect = QRect(rects[i].origin.x, rects[i].origin.y, rects[i].size.width, rects[i].size.height);
+            qrgn += tmpRect;
+        }
 
         if (!qwidget->isWindow() && !qobject_cast<QAbstractScrollArea *>(qwidget->parent())) {
             const QRegion &parentMask = qwidget->window()->mask();
@@ -610,38 +326,27 @@ static int qCocoaViewCount = 0;
         }
 
         if (qwidget->isWindow() && !qwidgetprivate->isOpaque
-                && !qwidget->testAttribute(Qt::WA_MacBrushedMetal)) {
+            && !qwidget->testAttribute(Qt::WA_MacBrushedMetal)) {
             CGContextClearRect(cg, NSRectToCGRect(aRect));
         }
 
-        // Check for alien widgets, use qwidgetPrivate->drawWidget() to draw the widget if this
-        // is the case. This makes sure child widgets are drawn as well, Cocoa does not know about
-        // those and wont send them drawRect calls.
-        if (qwidget->testAttribute(Qt::WA_NativeWindow) && qt_widget_private(qwidget)->hasAlienChildren == false) {
-        if ((engine && !qwidget->testAttribute(Qt::WA_NoSystemBackground)
-             && (qwidget->isWindow() || qwidget->autoFillBackground()))
-                || qwidget->testAttribute(Qt::WA_TintedBackground)
-                || qwidget->testAttribute(Qt::WA_StyledBackground)) {
-#ifdef DEBUG_WIDGET_PAINT
-            if(doDebug)
-                qDebug(" Handling erase for [%s::%s]", qwidget->metaObject()->className(),
-                       qwidget->objectName().local8Bit().data());
-#endif
-            QPainter p(qwidget);
-            qwidgetprivate->paintBackground(&p, qrgn,
-                                            qwidget->isWindow() ? QWidgetPrivate::DrawAsRoot : 0);
-            p.end();
-        }
-        QPaintEvent e(qrgn);
-#ifdef QT3_SUPPORT
-        e.setErased(true);
-#endif
-        qt_sendSpontaneousEvent(qwidget, &e);
-        } else {
-           qwidget->setAttribute(Qt::WA_WState_InPaintEvent, false); // QWidgetPrivate::drawWidget sets this
-           QWidgetPrivate *qwidgetPrivate = qt_widget_private(qwidget);
-           qwidgetPrivate->drawWidget(qwidget, qrgn, QPoint(), QWidgetPrivate::DrawAsRoot | QWidgetPrivate::DrawPaintOnScreen | QWidgetPrivate::DrawRecursive, 0);
-        }
+        qwidget->setAttribute(Qt::WA_WState_InPaintEvent, false);
+        QWidgetPrivate *qwidgetPrivate = qt_widget_private(qwidget);
+
+        // We specify that we want to draw the widget itself, and
+        // all its children recursive. But we skip native children, because
+        // they will receive drawRect calls by themselves as needed:
+        int flags = QWidgetPrivate::DrawPaintOnScreen
+            | QWidgetPrivate::DrawRecursive
+            | QWidgetPrivate::DontDrawNativeChildren;
+
+        if (qwidget->isWindow())
+            flags |= QWidgetPrivate::DrawAsRoot;
+
+        // Start to draw:
+        qt_mac_clearDirtyOnWidgetInsideDrawWidget = true;
+        qwidgetPrivate->drawWidget(qwidget, qrgn, QPoint(), flags, 0);
+        qt_mac_clearDirtyOnWidgetInsideDrawWidget = false;
 
         if (!redirectionOffset.isNull())
             QPainter::restoreRedirected(qwidget);
@@ -650,7 +355,7 @@ static int qCocoaViewCount = 0;
         qwidget->setAttribute(Qt::WA_WState_InPaintEvent, false);
         if(!qwidget->testAttribute(Qt::WA_PaintOutsidePaintEvent) && qwidget->paintingActive())
             qWarning("QWidget: It is dangerous to leave painters active on a"
-                     " widget outside of the PaintEvent");
+            " widget outside of the PaintEvent");
     }
     qwidgetprivate->hd = 0;
     CGContextRestoreGState(cg);
@@ -659,11 +364,13 @@ static int qCocoaViewCount = 0;
 
 - (BOOL)acceptsFirstMouse:(NSEvent *)theEvent
 {
-    if (!qwidget)
+    // Find the widget that should receive the event:
+    QPoint qlocal, qglobal;
+    QWidget *widgetToGetMouse = qt_mac_getTargetForMouseEvent(theEvent, QEvent::MouseButtonPress, qlocal, qglobal, qwidget, 0);
+    if (!widgetToGetMouse)
         return NO;
 
-    Q_UNUSED(theEvent);
-    return !qwidget->testAttribute(Qt::WA_MacNoClickThrough);
+    return !widgetToGetMouse->testAttribute(Qt::WA_MacNoClickThrough);
 }
 
 - (NSView *)hitTest:(NSPoint)aPoint
@@ -714,161 +421,120 @@ static int qCocoaViewCount = 0;
 
 - (void)mouseEntered:(NSEvent *)event
 {
-    if (!qwidget)
-        return;
-    if (qwidgetprivate->data.in_destructor)
-        return;
-
-    if (!qAppInstance()->activeModalWidget() || QApplicationPrivate::tryModalHelper(qwidget, 0)) {
-        QEvent enterEvent(QEvent::Enter);
-        NSPoint windowPoint = [event locationInWindow];
-        NSPoint globalPoint = [[event window] convertBaseToScreen:windowPoint];
-        NSPoint viewPoint = [self convertPoint:windowPoint fromView:nil];
-        QApplication::sendEvent(qwidget, &enterEvent);
-        qt_mouseover = qwidget;
-
-        // Update cursor icon:
-        qt_mac_update_cursor_at_global_pos(flipPoint(globalPoint).toPoint());
-
-        // Send mouse move and hover events as well:
-        if (!qAppInstance()->activePopupWidget() || qAppInstance()->activePopupWidget() == qwidget->window()) {
-            // This mouse move event should be sendt, even when mouse
-            // tracking is switched off (to trigger tooltips):
-            NSEvent *mouseEvent = [NSEvent mouseEventWithType:NSMouseMoved
-                location:windowPoint modifierFlags:[event modifierFlags] timestamp:[event timestamp]
-                windowNumber:[event windowNumber] context:[event context] eventNumber:[event eventNumber]
-                clickCount:0 pressure:0];
-            qt_mac_handleMouseEvent(self, mouseEvent, QEvent::MouseMove, Qt::NoButton);
-
-            if (qwidget->testAttribute(Qt::WA_Hover)) {
-                QHoverEvent he(QEvent::HoverEnter, QPoint(viewPoint.x, viewPoint.y), QPoint(-1, -1));
-                QApplicationPrivate::instance()->notify_helper(qwidget, &he);
-            }
-        }
-    }
+    // Cocoa will not send a move event on mouseEnter. But since
+    // Qt expect this, we fake one now. See also mouseExited below
+    // for info about enter/leave event handling
+    NSEvent *nsmoveEvent = [NSEvent
+        mouseEventWithType:NSMouseMoved
+        location:[[self window] mouseLocationOutsideOfEventStream]
+        modifierFlags: [event modifierFlags]
+        timestamp: [event timestamp]
+        windowNumber: [event windowNumber]
+        context: [event context]
+        eventNumber: [event eventNumber]
+        clickCount: 0
+        pressure: 0];
+
+    // Important: Cocoa sends us mouseEnter on all views under the mouse
+    // and not just the one on top. Therefore, to we cannot use qwidget
+    // as native widget for this case. Instead, we let qt_mac_handleMouseEvent
+    // resolve it (last argument set to 0):
+    qt_mac_handleMouseEvent(nsmoveEvent, QEvent::MouseMove, Qt::NoButton, 0);
 }
 
 - (void)mouseExited:(NSEvent *)event
 {
-    if (!qwidget)
-        return;
-
-    QEvent leaveEvent(QEvent::Leave);
-    NSPoint globalPoint = [[event window] convertBaseToScreen:[event locationInWindow]];
-    if (!qAppInstance()->activeModalWidget() || QApplicationPrivate::tryModalHelper(qwidget, 0)) {
-        QApplication::sendEvent(qwidget, &leaveEvent);
-
-        // ### Think about if it is necessary to update the cursor, should only be for a few cases.
-        qt_mac_update_cursor_at_global_pos(flipPoint(globalPoint).toPoint());
-        if (qwidget->testAttribute(Qt::WA_Hover)
-            && (!qAppInstance()->activePopupWidget() || qAppInstance()->activePopupWidget() == qwidget->window())) {
-            QHoverEvent he(QEvent::HoverLeave, QPoint(-1, -1),
-                           qwidget->mapFromGlobal(QApplicationPrivate::instance()->hoverGlobalPos));
-            QApplicationPrivate::instance()->notify_helper(qwidget, &he);
+    // Note: normal enter/leave handling is done from within mouseMove. This handler
+    // catches the case when the mouse moves out of the window (which mouseMove do not).
+    // Updating the mouse cursor follows the same logic as enter/leave. And we update
+    // neither if a grab exists (even if the grab points to this widget, it seems, ref X11)
+    Q_UNUSED(event);
+    if (self == [[self window] contentView] && !qt_button_down && !QWidget::mouseGrabber()) {
+        qt_mac_update_cursor();
+        // If the mouse exits the content view, but qt_mac_getTargetForMouseEvent still
+        // reports a target, it means that either there is a grab involved, or the mouse
+        // hovered over another window in the application. In both cases, move events will
+        // cause qt_mac_handleMouseEvent to be called, which will handle enter/leave.
+        QPoint qlocal, qglobal;
+        QWidget *widgetUnderMouse = 0;
+        qt_mac_getTargetForMouseEvent(event, QEvent::Leave, qlocal, qglobal, qwidget, &widgetUnderMouse);
+
+        if (widgetUnderMouse == 0) {
+            QApplicationPrivate::dispatchEnterLeave(0, qt_last_mouse_receiver);
+            qt_last_mouse_receiver = 0;
+            qt_last_native_mouse_receiver = 0;
         }
     }
 }
 
 - (void)flagsChanged:(NSEvent *)theEvent
 {
-    if (!qwidget)
+    QWidget *widgetToGetKey = qt_mac_getTargetForKeyEvent(qwidget);
+    if (!widgetToGetKey)
         return;
 
-    QWidget *widgetToGetKey = qwidget;
-
-    QWidget *popup = qAppInstance()->activePopupWidget();
-    if (popup && popup != qwidget->window())
-        widgetToGetKey = popup->focusWidget() ? popup->focusWidget() : popup;
     qt_dispatchModifiersChanged(theEvent, widgetToGetKey);
     [super flagsChanged:theEvent];
 }
 
 - (void)mouseMoved:(NSEvent *)theEvent
 {
-    if (!qwidget)
-        return;
-
-    // We always enable mouse tracking for all QCocoaView-s. In cases where we have
-    // child views, we will receive mouseMoved for both parent & the child (if
-    // mouse is over the child). We need to ignore the parent mouseMoved in such
-    // cases.
-    NSPoint windowPoint = [theEvent locationInWindow];
-    NSView *candidateView = [[[self window] contentView] hitTest:windowPoint];
-    if (candidateView && candidateView == self) {
-        qt_mac_handleMouseEvent(self, theEvent, QEvent::MouseMove, Qt::NoButton);
-    }
+    // Important: this method will only be called when the view's window is _not_ inside
+    // QCocoaWindow/QCocoaPanel. Otherwise, [QCocoaWindow sendEvent] will handle the event
+    // before it ends up here. So, this method is added for supporting QMacNativeWidget.
+    // TODO: Cocoa send move events to all views under the mouse. So make sure we only
+    // handle the event for the widget on top when using QMacNativeWidget.
+    qt_mac_handleMouseEvent(theEvent, QEvent::MouseMove, Qt::NoButton, qwidget);
 }
 
 - (void)mouseDown:(NSEvent *)theEvent
 {
-    if (!qt_button_down)
-        qt_button_down = qwidget;
-
-    qt_mac_handleMouseEvent(self, theEvent, QEvent::MouseButtonPress, Qt::LeftButton);
+    qt_mac_handleMouseEvent(theEvent, QEvent::MouseButtonPress, Qt::LeftButton, qwidget);
     // Don't call super here. This prevents us from getting the mouseUp event,
     // which we need to send even if the mouseDown event was not accepted.
     // (this is standard Qt behavior.)
 }
 
-
 - (void)mouseUp:(NSEvent *)theEvent
 {
-    qt_mac_handleMouseEvent(self, theEvent, QEvent::MouseButtonRelease, Qt::LeftButton);
-
-    qt_button_down = 0;
+    qt_mac_handleMouseEvent(theEvent, QEvent::MouseButtonRelease, Qt::LeftButton, qwidget);
 }
 
 - (void)rightMouseDown:(NSEvent *)theEvent
 {
-    if (!qt_button_down)
-        qt_button_down = qwidget;
-
-    qt_mac_handleMouseEvent(self, theEvent, QEvent::MouseButtonPress, Qt::RightButton);
+    qt_mac_handleMouseEvent(theEvent, QEvent::MouseButtonPress, Qt::RightButton, qwidget);
 }
 
 - (void)rightMouseUp:(NSEvent *)theEvent
 {
-    qt_mac_handleMouseEvent(self, theEvent, QEvent::MouseButtonRelease, Qt::RightButton);
-
-    qt_button_down = 0;
+    qt_mac_handleMouseEvent(theEvent, QEvent::MouseButtonRelease, Qt::RightButton, qwidget);
 }
 
 - (void)otherMouseDown:(NSEvent *)theEvent
 {
-    if (!qt_button_down)
-        qt_button_down = qwidget;
-
     Qt::MouseButton mouseButton = cocoaButton2QtButton([theEvent buttonNumber]);
-    qt_mac_handleMouseEvent(self, theEvent, QEvent::MouseButtonPress, mouseButton);
+    qt_mac_handleMouseEvent(theEvent, QEvent::MouseButtonPress, mouseButton, qwidget);
 }
 
 - (void)otherMouseUp:(NSEvent *)theEvent
 {
     Qt::MouseButton mouseButton = cocoaButton2QtButton([theEvent buttonNumber]);
-    qt_mac_handleMouseEvent(self, theEvent,  QEvent::MouseButtonRelease, mouseButton);
-
-    qt_button_down = 0;
+    qt_mac_handleMouseEvent(theEvent,  QEvent::MouseButtonRelease, mouseButton, qwidget);
 }
 
 - (void)mouseDragged:(NSEvent *)theEvent
 {
-    qMacDnDParams()->view = self;
-    qMacDnDParams()->theEvent = theEvent;
-    qt_mac_handleMouseEvent(self, theEvent, QEvent::MouseMove, Qt::NoButton);
+    qt_mac_handleMouseEvent(theEvent, QEvent::MouseMove, Qt::NoButton, qwidget);
 }
 
 - (void)rightMouseDragged:(NSEvent *)theEvent
 {
-    qMacDnDParams()->view = self;
-    qMacDnDParams()->theEvent = theEvent;
-    qt_mac_handleMouseEvent(self, theEvent, QEvent::MouseMove, Qt::NoButton);
+    qt_mac_handleMouseEvent(theEvent, QEvent::MouseMove, Qt::NoButton, qwidget);
 }
 
 - (void)otherMouseDragged:(NSEvent *)theEvent
 {
-    qMacDnDParams()->view = self;
-    qMacDnDParams()->theEvent = theEvent;
-    qt_mac_handleMouseEvent(self, theEvent, QEvent::MouseMove, Qt::NoButton);
+    qt_mac_handleMouseEvent(theEvent, QEvent::MouseMove, Qt::NoButton, qwidget);
 }
 
 - (void)scrollWheel:(NSEvent *)theEvent
@@ -879,21 +545,14 @@ static int qCocoaViewCount = 0;
         [currentIManager handleMouseEvent:theEvent];
     }
 
-    NSPoint windowPoint = [theEvent locationInWindow];
-    NSPoint globalPoint = [[theEvent window] convertBaseToScreen:windowPoint];
-    NSPoint localPoint = [self convertPoint:windowPoint fromView:nil];
-    QPoint qlocal = QPoint(localPoint.x, localPoint.y);
-    QPoint qglobal = QPoint(globalPoint.x, flipYCoordinate(globalPoint.y));
     Qt::MouseButtons buttons = QApplication::mouseButtons();
-    bool wheelOK = false;
     Qt::KeyboardModifiers keyMods = qt_cocoaModifiers2QtModifiers([theEvent modifierFlags]);
-    QWidget *widgetToGetMouse = qwidget;
-    // if popup is open it should get wheel events if the cursor is over the popup,
-    // otherwise the event should be ignored.
-    if (QWidget *popup = qAppInstance()->activePopupWidget()) {
-        if (!popup->geometry().contains(qglobal))
-            return;
-    }
+
+    // Find the widget that should receive the event:
+    QPoint qlocal, qglobal;
+    QWidget *widgetToGetMouse = qt_mac_getTargetForMouseEvent(theEvent, QEvent::Wheel, qlocal, qglobal, qwidget, 0);
+    if (!widgetToGetMouse)
+        return;
 
     int deltaX = 0;
     int deltaY = 0;
@@ -922,46 +581,30 @@ static int qCocoaViewCount = 0;
     }
 
 #ifndef QT_NO_WHEELEVENT
+    // ### Qt 5: Send one QWheelEvent with dx, dy and dz
+
+    if (deltaX != 0 && deltaY != 0)
+        QMacScrollOptimization::initDelayedScroll();
+
     if (deltaX != 0) {
         QWheelEvent qwe(qlocal, qglobal, deltaX, buttons, keyMods, Qt::Horizontal);
         qt_sendSpontaneousEvent(widgetToGetMouse, &qwe);
-        wheelOK = qwe.isAccepted();
-        if (!wheelOK && QApplicationPrivate::focus_widget
-            && QApplicationPrivate::focus_widget != widgetToGetMouse) {
-            QWheelEvent qwe2(QApplicationPrivate::focus_widget->mapFromGlobal(qglobal), qglobal,
-                             deltaX, buttons, keyMods, Qt::Horizontal);
-            qt_sendSpontaneousEvent(QApplicationPrivate::focus_widget, &qwe2);
-            wheelOK = qwe2.isAccepted();
-        }
     }
 
-    if (deltaY) {
+    if (deltaY != 0) {
         QWheelEvent qwe(qlocal, qglobal, deltaY, buttons, keyMods, Qt::Vertical);
         qt_sendSpontaneousEvent(widgetToGetMouse, &qwe);
-        wheelOK = qwe.isAccepted();
-        if (!wheelOK && QApplicationPrivate::focus_widget
-            && QApplicationPrivate::focus_widget != widgetToGetMouse) {
-            QWheelEvent qwe2(QApplicationPrivate::focus_widget->mapFromGlobal(qglobal), qglobal,
-                             deltaY, buttons, keyMods, Qt::Vertical);
-            qt_sendSpontaneousEvent(QApplicationPrivate::focus_widget, &qwe2);
-            wheelOK = qwe2.isAccepted();
-        }
     }
 
-    if (deltaZ) {
+    if (deltaZ != 0) {
         // Qt doesn't explicitly support wheels with a Z component. In a misguided attempt to
         // try to be ahead of the pack, I'm adding this extra value.
         QWheelEvent qwe(qlocal, qglobal, deltaZ, buttons, keyMods, (Qt::Orientation)3);
         qt_sendSpontaneousEvent(widgetToGetMouse, &qwe);
-        wheelOK = qwe.isAccepted();
-        if (!wheelOK && QApplicationPrivate::focus_widget
-            && QApplicationPrivate::focus_widget != widgetToGetMouse) {
-            QWheelEvent qwe2(QApplicationPrivate::focus_widget->mapFromGlobal(qglobal), qglobal,
-                             deltaZ, buttons, keyMods, (Qt::Orientation)3);
-            qt_sendSpontaneousEvent(QApplicationPrivate::focus_widget, &qwe2);
-            wheelOK = qwe2.isAccepted();
-        }
     }
+
+    if (deltaX != 0 && deltaY != 0)
+        QMacScrollOptimization::performDelayedScroll();
 #endif //QT_NO_WHEELEVENT
 }
 
@@ -976,35 +619,14 @@ static int qCocoaViewCount = 0;
         [super tabletPoint:tabletEvent];
 }
 
-#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
-- (void)touchesBeganWithEvent:(NSEvent *)event
-{
-    bool all = qwidget->testAttribute(Qt::WA_TouchPadAcceptSingleTouchEvents);
-    qt_translateRawTouchEvent(qwidget, QTouchEvent::TouchPad, QCocoaTouch::getCurrentTouchPointList(event, all));
-}
-
-- (void)touchesMovedWithEvent:(NSEvent *)event
-{
-    bool all = qwidget->testAttribute(Qt::WA_TouchPadAcceptSingleTouchEvents);
-    qt_translateRawTouchEvent(qwidget, QTouchEvent::TouchPad, QCocoaTouch::getCurrentTouchPointList(event, all));
-}
-
-- (void)touchesEndedWithEvent:(NSEvent *)event
-{
-    bool all = qwidget->testAttribute(Qt::WA_TouchPadAcceptSingleTouchEvents);
-    qt_translateRawTouchEvent(qwidget, QTouchEvent::TouchPad, QCocoaTouch::getCurrentTouchPointList(event, all));
-}
-
-- (void)touchesCancelledWithEvent:(NSEvent *)event
-{
-    bool all = qwidget->testAttribute(Qt::WA_TouchPadAcceptSingleTouchEvents);
-    qt_translateRawTouchEvent(qwidget, QTouchEvent::TouchPad, QCocoaTouch::getCurrentTouchPointList(event, all));
-}
-#endif // MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
-
 - (void)magnifyWithEvent:(NSEvent *)event
 {
-    if (!QApplicationPrivate::tryModalHelper(qwidget, 0))
+    QPoint qlocal, qglobal;
+    QWidget *widgetToGetGesture = 0;
+    qt_mac_getTargetForMouseEvent(event, QEvent::Gesture, qlocal, qglobal, qwidget, &widgetToGetGesture);
+    if (!widgetToGetGesture)
+        return;
+    if (!QApplicationPrivate::tryModalHelper(widgetToGetGesture, 0))
         return;
 
 #ifndef QT_NO_GESTURES
@@ -1013,13 +635,18 @@ static int qCocoaViewCount = 0;
     NSPoint p = [[event window] convertBaseToScreen:[event locationInWindow]];
     qNGEvent.position = flipPoint(p).toPoint();
     qNGEvent.percentage = [event magnification];
-    qt_sendSpontaneousEvent(qwidget, &qNGEvent);
+    qt_sendSpontaneousEvent(widgetToGetGesture, &qNGEvent);
 #endif // QT_NO_GESTURES
 }
 
 - (void)rotateWithEvent:(NSEvent *)event
 {
-    if (!QApplicationPrivate::tryModalHelper(qwidget, 0))
+    QPoint qlocal, qglobal;
+    QWidget *widgetToGetGesture = 0;
+    qt_mac_getTargetForMouseEvent(event, QEvent::Gesture, qlocal, qglobal, qwidget, &widgetToGetGesture);
+    if (!widgetToGetGesture)
+        return;
+    if (!QApplicationPrivate::tryModalHelper(widgetToGetGesture, 0))
         return;
 
 #ifndef QT_NO_GESTURES
@@ -1028,13 +655,18 @@ static int qCocoaViewCount = 0;
     NSPoint p = [[event window] convertBaseToScreen:[event locationInWindow]];
     qNGEvent.position = flipPoint(p).toPoint();
     qNGEvent.percentage = -[event rotation];
-    qt_sendSpontaneousEvent(qwidget, &qNGEvent);
+    qt_sendSpontaneousEvent(widgetToGetGesture, &qNGEvent);
 #endif // QT_NO_GESTURES
 }
 
 - (void)swipeWithEvent:(NSEvent *)event
 {
-    if (!QApplicationPrivate::tryModalHelper(qwidget, 0))
+    QPoint qlocal, qglobal;
+    QWidget *widgetToGetGesture = 0;
+    qt_mac_getTargetForMouseEvent(event, QEvent::Gesture, qlocal, qglobal, qwidget, &widgetToGetGesture);
+    if (!widgetToGetGesture)
+        return;
+    if (!QApplicationPrivate::tryModalHelper(widgetToGetGesture, 0))
         return;
 
 #ifndef QT_NO_GESTURES
@@ -1050,13 +682,18 @@ static int qCocoaViewCount = 0;
         qNGEvent.angle = 90.0f;
     else if ([event deltaY] == -1)
         qNGEvent.angle = 270.0f;
-    qt_sendSpontaneousEvent(qwidget, &qNGEvent);
+    qt_sendSpontaneousEvent(widgetToGetGesture, &qNGEvent);
 #endif // QT_NO_GESTURES
 }
 
 - (void)beginGestureWithEvent:(NSEvent *)event
 {
-    if (!QApplicationPrivate::tryModalHelper(qwidget, 0))
+    QPoint qlocal, qglobal;
+    QWidget *widgetToGetGesture = 0;
+    qt_mac_getTargetForMouseEvent(event, QEvent::Gesture, qlocal, qglobal, qwidget, &widgetToGetGesture);
+    if (!widgetToGetGesture)
+        return;
+    if (!QApplicationPrivate::tryModalHelper(widgetToGetGesture, 0))
         return;
 
 #ifndef QT_NO_GESTURES
@@ -1064,13 +701,18 @@ static int qCocoaViewCount = 0;
     qNGEvent.gestureType = QNativeGestureEvent::GestureBegin;
     NSPoint p = [[event window] convertBaseToScreen:[event locationInWindow]];
     qNGEvent.position = flipPoint(p).toPoint();
-    qt_sendSpontaneousEvent(qwidget, &qNGEvent);
+    qt_sendSpontaneousEvent(widgetToGetGesture, &qNGEvent);
 #endif // QT_NO_GESTURES
 }
 
 - (void)endGestureWithEvent:(NSEvent *)event
 {
-    if (!QApplicationPrivate::tryModalHelper(qwidget, 0))
+    QPoint qlocal, qglobal;
+    QWidget *widgetToGetGesture = 0;
+    qt_mac_getTargetForMouseEvent(event, QEvent::Gesture, qlocal, qglobal, qwidget, &widgetToGetGesture);
+    if (!widgetToGetGesture)
+        return;
+    if (!QApplicationPrivate::tryModalHelper(widgetToGetGesture, 0))
         return;
 
 #ifndef QT_NO_GESTURES
@@ -1078,9 +720,9 @@ static int qCocoaViewCount = 0;
     qNGEvent.gestureType = QNativeGestureEvent::GestureEnd;
     NSPoint p = [[event window] convertBaseToScreen:[event locationInWindow]];
     qNGEvent.position = flipPoint(p).toPoint();
-    qt_sendSpontaneousEvent(qwidget, &qNGEvent);
-#endif // QT_NO_GESTURES
+    qt_sendSpontaneousEvent(widgetToGetGesture, &qNGEvent);
 }
+#endif // QT_NO_GESTURES
 
 - (void)frameDidChange:(NSNotification *)note
 {
@@ -1123,27 +765,46 @@ static int qCocoaViewCount = 0;
 {
     if (!qwidget)
         return NO;
-    // disabled widget shouldn't get focus even if it's a window.
+
+    // Disabled widget shouldn't get focus even if it's a window.
     // hence disabled windows will not get any key or mouse events.
     if (!qwidget->isEnabled())
         return NO;
-    // Before accepting the focus for a window, we check that
-    // the focusWidget (if any) is not contained in the same window.
-    if (qwidget->isWindow() && !qt_widget_private(qwidget)->topData()->embedded
-        && (!qApp->focusWidget() || qApp->focusWidget()->window() != qwidget)) {
-        return YES;  // Always do it, so that windows can accept key press events.
+
+    if (qwidget->isWindow() && !qt_widget_private(qwidget)->topData()->embedded) {
+        QWidget *focusWidget = qApp->focusWidget();
+        if (!focusWidget) {
+            // There is no focus widget, but we still want to receive key events
+            // for shortcut handling etc. So we accept first responer for the
+            // content view as a last resort:
+            return YES;
+        }
+        if (!focusWidget->internalWinId() && focusWidget->nativeParentWidget() == qwidget) {
+            // The current focus widget is alien, and hence, cannot get acceptsFirstResponder
+            // calls. Since the focus widget is a child of qwidget, we let this view say YES:
+            return YES;
+        }
+        if (focusWidget->window() != qwidget) {
+            // The current focus widget is in another window. Since cocoa
+            // suggest that this window should be key now, we accept:
+            return YES;
+        }
     }
+
     return qwidget->focusPolicy() != Qt::NoFocus;
 }
 
 - (BOOL)resignFirstResponder
 {
     if (!qwidget)
-        return NO;
+        return YES;
+
     // Seems like the following test only triggers if this
     // view is inside a QMacNativeWidget:
-    if (qwidget == QApplication::focusWidget())
-        qwidget->clearFocus();
+//    if (QWidget *fw = QApplication::focusWidget()) {
+//        if (qwidget == fw || qwidget == fw->nativeParentWidget())
+//            fw->clearFocus();
+//    }
     return YES;
 }
 
@@ -1172,11 +833,11 @@ static int qCocoaViewCount = 0;
 {
     Q_UNUSED(anImage);
     Q_UNUSED(aPoint);
-    qMacDnDParams()->performedAction = operation;
+    macCurrentDnDParameters()->performedAction = operation;
     if (QDragManager::self()->object
         && QDragManager::self()->dragPrivate()->executed_action != Qt::ActionMask) {
-        qMacDnDParams()->performedAction =
-                qt_mac_mapDropAction(QDragManager::self()->dragPrivate()->executed_action);
+        macCurrentDnDParameters()->performedAction =
+            qt_mac_mapDropAction(QDragManager::self()->dragPrivate()->executed_action);
     }
 }
 
@@ -1191,51 +852,37 @@ static int qCocoaViewCount = 0;
     qwidgetprivate = 0;
 }
 
-- (BOOL)qt_leftButtonIsRightButton
-{
-    return leftButtonIsRightButton;
-}
-
-- (void)qt_setLeftButtonIsRightButton:(BOOL)isSwapped
-{
-    leftButtonIsRightButton = isSwapped;
-}
-
-+ (DnDParams*)currentMouseEvent
-{
-    return qMacDnDParams();
-}
-
 - (void)keyDown:(NSEvent *)theEvent
 {
-    sendKeyEvents = true;
-
-    QWidget *widgetToGetKey = qwidget;
+    if (!qwidget)
+        return;
+    QWidget *widgetToGetKey = qt_mac_getTargetForKeyEvent(qwidget);
+    if (!widgetToGetKey)
+        return;
 
-    QWidget *popup = qAppInstance()->activePopupWidget();
-    bool sendToPopup = false;
-    if (popup && popup != qwidget->window()) {
-        widgetToGetKey = popup->focusWidget() ? popup->focusWidget() : popup;
-        sendToPopup = true;
-    }
+    sendKeyEvents = true;
 
     if (widgetToGetKey->testAttribute(Qt::WA_InputMethodEnabled)
             && !(widgetToGetKey->inputMethodHints() & Qt::ImhDigitsOnly
                  || widgetToGetKey->inputMethodHints() & Qt::ImhFormattedNumbersOnly
                  || widgetToGetKey->inputMethodHints() & Qt::ImhHiddenText)) {
         fromKeyDownEvent = true;
-        [qt_mac_nativeview_for(widgetToGetKey) interpretKeyEvents:[NSArray arrayWithObject: theEvent]];
+        [qt_mac_nativeview_for(qwidget) interpretKeyEvents:[NSArray arrayWithObject: theEvent]];
         fromKeyDownEvent = false;
     }
+
     if (sendKeyEvents && !composing) {
-        bool keyOK = qt_dispatchKeyEvent(theEvent, widgetToGetKey);
-        if (!keyOK && !sendToPopup) {
-            // find the first responder that is not created by Qt and forward
-            // the event to it (for example if Qt widget is embedded into native).
+        bool keyEventEaten = qt_dispatchKeyEvent(theEvent, widgetToGetKey);
+        if (!keyEventEaten && qwidget) {
+            // The event is not yet eaten, and if Qt is embedded inside a native
+            // cocoa application, send it to first responder not owned by Qt.
+            // The exception is if widgetToGetKey was redirected to a popup.
             QWidget *toplevel = qwidget->window();
-            if (toplevel && qt_widget_private(toplevel)->topData()->embedded) {
-                if (NSResponder *w = [qt_mac_nativeview_for(toplevel) superview])
-                    [w keyDown:theEvent];
+            if (toplevel == widgetToGetKey->window()) {
+                if (qt_widget_private(toplevel)->topData()->embedded) {
+                    if (NSResponder *w = [qt_mac_nativeview_for(toplevel) superview])
+                        [w keyDown:theEvent];
+                }
             }
         }
     }
@@ -1245,12 +892,21 @@ static int qCocoaViewCount = 0;
 - (void)keyUp:(NSEvent *)theEvent
 {
     if (sendKeyEvents) {
-        bool keyOK = qt_dispatchKeyEvent(theEvent, qwidget);
-        if (!keyOK) {
+        QWidget *widgetToGetKey = qt_mac_getTargetForKeyEvent(qwidget);
+        if (!widgetToGetKey)
+            return;
+
+        bool keyEventEaten = qt_dispatchKeyEvent(theEvent, widgetToGetKey);
+        if (!keyEventEaten && qwidget) {
+            // The event is not yet eaten, and if Qt is embedded inside a native
+            // cocoa application, send it to first responder not owned by Qt.
+            // The exception is if widgetToGetKey was redirected to a popup.
             QWidget *toplevel = qwidget->window();
-            if (toplevel && qt_widget_private(toplevel)->topData()->embedded) {
-                if (NSResponder *w = [qt_mac_nativeview_for(toplevel) superview])
-                    [w keyUp:theEvent];
+            if (toplevel == widgetToGetKey->window()) {
+                if (qt_widget_private(toplevel)->topData()->embedded) {
+                    if (NSResponder *w = [qt_mac_nativeview_for(toplevel) superview])
+                        [w keyUp:theEvent];
+                }
             }
         }
     }
@@ -1298,13 +954,14 @@ static int qCocoaViewCount = 0;
     // When entering characters through Character Viewer or Keyboard Viewer, the text is passed
     // through this insertText method. Since we dont receive a keyDown Event in such cases, the
     // composing flag will be false.
-    if (([aString length] && composing) ||  !fromKeyDownEvent) {
+    if (([aString length] && composing) || !fromKeyDownEvent) {
         // Send the commit string to the widget.
         composing = false;
         sendKeyEvents = false;
         QInputMethodEvent e;
         e.setCommitString(commitText);
-        qt_sendSpontaneousEvent(qwidget, &e);
+        if (QWidget *widgetToGetKey = qt_mac_getTargetForKeyEvent(qwidget))
+            qt_sendSpontaneousEvent(widgetToGetKey, &e);
     } else {
         // The key sequence "`q" on a French Keyboard will generate two calls to insertText before
         // it returns from interpretKeyEvents. The first call will turn off 'composing' and accept
@@ -1368,8 +1025,11 @@ static int qCocoaViewCount = 0;
                                             0, composingLength, format);
     }
     *composingText = qtText;
+
     QInputMethodEvent e(qtText, attrs);
-    qt_sendSpontaneousEvent(qwidget, &e);
+    if (QWidget *widgetToGetKey = qt_mac_getTargetForKeyEvent(qwidget))
+        qt_sendSpontaneousEvent(widgetToGetKey, &e);
+
     if (!composingLength)
         composing = false;
 }
@@ -1379,7 +1039,8 @@ static int qCocoaViewCount = 0;
     if (composing) {
         QInputMethodEvent e;
         e.setCommitString(*composingText);
-        qt_sendSpontaneousEvent(qwidget, &e);
+        if (QWidget *widgetToGetKey = qt_mac_getTargetForKeyEvent(qwidget))
+            qt_sendSpontaneousEvent(widgetToGetKey, &e);
     }
     composingText->clear();
     composing = false;
@@ -1452,8 +1113,12 @@ static int qCocoaViewCount = 0;
 {
     Q_UNUSED(theRange);
     // The returned rect is always based on the internal cursor.
-    QRect mr(qwidget->inputMethodQuery(Qt::ImMicroFocus).toRect());
-    QPoint mp(qwidget->mapToGlobal(QPoint(mr.bottomLeft())));
+    QWidget *widgetToGetKey = qt_mac_getTargetForKeyEvent(qwidget);
+    if (!widgetToGetKey)
+        return NSZeroRect;
+
+    QRect mr(widgetToGetKey->inputMethodQuery(Qt::ImMicroFocus).toRect());
+    QPoint mp(widgetToGetKey->mapToGlobal(QPoint(mr.bottomLeft())));
     NSRect rect ;
     rect.origin.x = mp.x();
     rect.origin.y = flipYCoordinate(mp.y());
@@ -1471,10 +1136,11 @@ static int qCocoaViewCount = 0;
 
 - (NSArray*) validAttributesForMarkedText
 {
-    if (qwidget == 0)
+    QWidget *widgetToGetKey = qt_mac_getTargetForKeyEvent(qwidget);
+    if (!widgetToGetKey)
         return nil;
 
-    if (!qwidget->testAttribute(Qt::WA_InputMethodEnabled))
+    if (!widgetToGetKey->testAttribute(Qt::WA_InputMethodEnabled))
         return nil;  // Not sure if that's correct, but it's saves a malloc.
 
     // Support only underline color/style.
@@ -1488,7 +1154,7 @@ void QMacInputContext::reset()
 {
     QWidget *w = QInputContext::focusWidget();
     if (w) {
-        NSView *view = qt_mac_nativeview_for(w);
+        NSView *view = qt_mac_effectiveview_for(w);
         if ([view isKindOfClass:[QT_MANGLE_NAMESPACE(QCocoaView) class]]) {
             QMacCocoaAutoReleasePool pool;
             QT_MANGLE_NAMESPACE(QCocoaView) *qc = static_cast<QT_MANGLE_NAMESPACE(QCocoaView) *>(view);
@@ -1505,7 +1171,7 @@ bool QMacInputContext::isComposing() const
 {
     QWidget *w = QInputContext::focusWidget();
     if (w) {
-        NSView *view = qt_mac_nativeview_for(w);
+        NSView *view = qt_mac_effectiveview_for(w);
         if ([view isKindOfClass:[QT_MANGLE_NAMESPACE(QCocoaView) class]]) {
             return [static_cast<QT_MANGLE_NAMESPACE(QCocoaView) *>(view) isComposing];
         }
@@ -1598,38 +1264,45 @@ Qt::DropAction QDragManager::drag(QDrag *o)
     } else {
         hotspot = dragPrivate()->hotspot;
     }
-    // convert the image to NSImage.
+
+    // Convert the image to NSImage:
     NSImage *image = (NSImage *)qt_mac_create_nsimage(pix);
     [image retain];
-    DnDParams dndParams = *[QT_MANGLE_NAMESPACE(QCocoaView) currentMouseEvent];
-    // save supported actions
-    [dndParams.view setSupportedActions: qt_mac_mapDropActions(dragPrivate()->possible_actions)];
-    NSPoint imageLoc = {dndParams.localPoint.x - hotspot.x(),
-                        dndParams.localPoint.y + pix.height() - hotspot.y()};
+
+    DnDParams *dndParams = macCurrentDnDParameters();
+    QT_MANGLE_NAMESPACE(QCocoaView) *theView = static_cast<QT_MANGLE_NAMESPACE(QCocoaView) *>(dndParams->view);
+
+    // Save supported actions:
+    [theView setSupportedActions: qt_mac_mapDropActions(dragPrivate()->possible_actions)];
+    QPoint pointInView = [theView qt_qwidget]->mapFromGlobal(dndParams->globalPoint);
+    NSPoint imageLoc = {pointInView.x() - hotspot.x(), pointInView.y() + pix.height() - hotspot.y()};
     NSSize mouseOffset = {0.0, 0.0};
     NSPasteboard *pboard = [NSPasteboard pasteboardWithName:NSDragPboard];
     dragPrivate()->executed_action = Qt::ActionMask;
-    // do the drag
-    [dndParams.view retain];
-    [dndParams.view dragImage:image
-                            at:imageLoc
-                        offset:mouseOffset
-                         event:dndParams.theEvent
-                    pasteboard:pboard
-                        source:dndParams.view
-                     slideBack:YES];
-    // reset the implicit grab widget when drag ends because we will not
-    // receive the mouse release event when DND is active.
+
+    // Execute the drag:
+    [theView retain];
+    [theView dragImage:image
+        at:imageLoc
+        offset:mouseOffset
+        event:dndParams->theEvent
+        pasteboard:pboard
+        source:theView
+        slideBack:YES];
+
+    // Reset the implicit grab widget when drag ends because we will not
+    // receive the mouse release event when DND is active:
     qt_button_down = 0;
-    [dndParams.view release];
+    [theView release];
     [image release];
     if (dragPrivate())
         dragPrivate()->executed_action = Qt::IgnoreAction;
     object = 0;
-    Qt::DropAction performedAction(qt_mac_mapNSDragOperation(qMacDnDParams()->performedAction));
-    // do post drag processing, if required.
-    if(performedAction != Qt::IgnoreAction) {
-        // check if the receiver points us to a file location.
+    Qt::DropAction performedAction(qt_mac_mapNSDragOperation(dndParams->performedAction));
+
+    // Do post drag processing, if required.
+    if (performedAction != Qt::IgnoreAction) {
+        // Check if the receiver points us to a file location.
         // if so, we need to do the file copy/move ourselves.
         QCFType<CFURLRef> pasteLocation = 0;
         PasteboardCopyPasteLocation(dragBoard.pasteBoard(), &pasteLocation);
@@ -1646,6 +1319,8 @@ Qt::DropAction QDragManager::drag(QDrag *o)
             }
         }
     }
+
+    // Clean-up:
     o->setMimeData(0);
     o->deleteLater();
     return performedAction;
diff --git a/src/gui/kernel/qcocoaview_mac_p.h b/src/gui/kernel/qcocoaview_mac_p.h
index 8d57f95..cc79b67 100644
--- a/src/gui/kernel/qcocoaview_mac_p.h
+++ b/src/gui/kernel/qcocoaview_mac_p.h
@@ -58,57 +58,30 @@
 QT_FORWARD_DECLARE_CLASS(QWidgetPrivate);
 QT_FORWARD_DECLARE_CLASS(QWidget);
 QT_FORWARD_DECLARE_CLASS(QEvent);
-QT_FORWARD_DECLARE_CLASS(QCocoaDropData);
 QT_FORWARD_DECLARE_CLASS(QString);
 QT_FORWARD_DECLARE_CLASS(QStringList);
 
-QT_BEGIN_NAMESPACE
-struct DnDParams
-{
-    QT_MANGLE_NAMESPACE(QCocoaView) *view;
-    NSEvent *theEvent;
-    NSPoint localPoint;
-    NSDragOperation performedAction;
-    NSPoint activeDragEnterPos;
-};
-
-QT_END_NAMESPACE
-
-QT_FORWARD_DECLARE_STRUCT(DnDParams);
-
 Q_GUI_EXPORT
 @interface QT_MANGLE_NAMESPACE(QCocoaView) : NSControl <NSTextInput> {
     QWidget *qwidget;
     QWidgetPrivate *qwidgetprivate;
-    bool leftButtonIsRightButton;
-    QCocoaDropData *dropData;
     NSDragOperation supportedActions;
     bool composing;
     int composingLength;
     bool sendKeyEvents;
     bool fromKeyDownEvent;
     QString *composingText;
-    NSInteger dragEnterSequence;
+    @public int alienTouchCount;
 }
 - (id)initWithQWidget:(QWidget *)widget widgetPrivate:(QWidgetPrivate *)widgetprivate;
 - (void) finishInitWithQWidget:(QWidget *)widget widgetPrivate:(QWidgetPrivate *)widgetprivate;
 - (void)frameDidChange:(NSNotification *)note;
-- (NSDragOperation)draggingEntered:(id <NSDraggingInfo>)sender;
-- (NSDragOperation)draggingUpdated:(id < NSDraggingInfo >)sender;
-- (void)draggingExited:(id < NSDraggingInfo >)sender;
-- (BOOL)performDragOperation:(id <NSDraggingInfo>)sender;
-- (void)removeDropData;
-- (void)addDropData:(id <NSDraggingInfo>)sender;
 - (void)setSupportedActions:(NSDragOperation)actions;
 - (NSDragOperation)draggingSourceOperationMaskForLocal:(BOOL)isLocal;
 - (void)draggedImage:(NSImage *)anImage endedAt:(NSPoint)aPoint operation:(NSDragOperation)operation;
 - (BOOL)isComposing;
 - (QWidget *)qt_qwidget;
 - (void) qt_clearQWidget;
-- (BOOL)qt_leftButtonIsRightButton;
-- (void)qt_setLeftButtonIsRightButton:(BOOL)isSwapped;
-- (void)changeDraggingCursor:(NSDragOperation)newOperation;
-+ (DnDParams*)currentMouseEvent;
 
 @end
 #endif
diff --git a/src/gui/kernel/qcocoawindow_mac.mm b/src/gui/kernel/qcocoawindow_mac.mm
index 28f09ad..6e5023a 100644
--- a/src/gui/kernel/qcocoawindow_mac.mm
+++ b/src/gui/kernel/qcocoawindow_mac.mm
@@ -47,6 +47,8 @@
 #import <private/qt_cocoa_helpers_mac_p.h>
 #import <private/qcocoawindowcustomthemeframe_mac_p.h>
 #import <private/qcocoaapplication_mac_p.h>
+#import <private/qdnd_p.h>
+#import <private/qmultitouch_mac_p.h>
 
 #include <QtGui/QWidget>
 
diff --git a/src/gui/kernel/qcocoawindow_mac_p.h b/src/gui/kernel/qcocoawindow_mac_p.h
index 81e0be1..e6b50f5 100644
--- a/src/gui/kernel/qcocoawindow_mac_p.h
+++ b/src/gui/kernel/qcocoawindow_mac_p.h
@@ -50,17 +50,20 @@
 // We mean it.
 //
 
+#ifndef QCOCOAWINDOW_MAC_P
+#define QCOCOAWINDOW_MAC_P
+
 #ifdef QT_MAC_USE_COCOA
 #include "qmacdefines_mac.h"
 #import <Cocoa/Cocoa.h>
 #include <private/qapplication_p.h>
 #include <private/qbackingstore_p.h>
 
-
 enum { QtMacCustomizeWindow = 1 << 21 }; // This will one day be run over by
 
 QT_FORWARD_DECLARE_CLASS(QWidget);
 QT_FORWARD_DECLARE_CLASS(QStringList);
+QT_FORWARD_DECLARE_CLASS(QCocoaDropData);
 
 @interface NSWindow (QtCoverForHackWithCategory)
 + (Class)frameViewClassForStyleMask:(NSUInteger)styleMask;
@@ -72,13 +75,16 @@ QT_FORWARD_DECLARE_CLASS(QStringList);
 @end
 
 @interface QT_MANGLE_NAMESPACE(QCocoaWindow) : NSWindow {
-    bool leftButtonIsRightButton;
     QStringList *currentCustomDragTypes;
+    QCocoaDropData *dropData;
+    NSInteger dragEnterSequence;
 }
 
 + (Class)frameViewClassForStyleMask:(NSUInteger)styleMask;
 - (void)registerDragTypes;
+- (void)drawRectOriginal:(NSRect)rect;
 
 @end
 #endif
 
+#endif
diff --git a/src/gui/kernel/qcursor.h b/src/gui/kernel/qcursor.h
index d90375da..c993763 100644
--- a/src/gui/kernel/qcursor.h
+++ b/src/gui/kernel/qcursor.h
@@ -77,7 +77,7 @@ class QBitmap;
 class QPixmap;
 
 #if defined(Q_WS_MAC)
-void qt_mac_set_cursor(const QCursor *c, const QPoint &p);
+void qt_mac_set_cursor(const QCursor *c);
 #endif
 #if defined(Q_OS_SYMBIAN)
 extern void qt_symbian_show_pointer_sprite();
@@ -141,7 +141,8 @@ private:
     QCursorData *d;
 #if defined(Q_WS_MAC)
     friend void *qt_mac_nsCursorForQCursor(const QCursor &c);
-    friend void qt_mac_set_cursor(const QCursor *c, const QPoint &p);
+    friend void qt_mac_set_cursor(const QCursor *c);
+    friend void qt_mac_updateCursorWithWidgetUnderMouse(QWidget *widgetUnderMouse);
 #endif
 #if defined(Q_OS_SYMBIAN)
     friend void qt_symbian_show_pointer_sprite();
diff --git a/src/gui/kernel/qcursor_mac.mm b/src/gui/kernel/qcursor_mac.mm
index 1a82a68..0d57b85 100644
--- a/src/gui/kernel/qcursor_mac.mm
+++ b/src/gui/kernel/qcursor_mac.mm
@@ -50,6 +50,7 @@
 #include <AppKit/NSCursor.h>
 #include <qpainter.h>
 #include <private/qt_cocoa_helpers_mac_p.h>
+#include <private/qapplication_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -60,6 +61,7 @@ extern QCursorData *qt_cursorTable[Qt::LastCursor + 1];
 extern OSWindowRef qt_mac_window_for(const QWidget *); //qwidget_mac.cpp
 extern GrafPtr qt_mac_qd_context(const QPaintDevice *); //qpaintdevice_mac.cpp
 extern bool qt_sendSpontaneousEvent(QObject *, QEvent *); //qapplication_mac.cpp
+extern QPointer<QWidget> qt_button_down; //qapplication_mac.cpp
 
 /*****************************************************************************
   Internal QCursorData class
@@ -95,18 +97,19 @@ protected:
     }
 };
 
-void *qt_mac_nsCursorForQCursor(const QCursor &c)
+inline void *qt_mac_nsCursorForQCursor(const QCursor &c)
 {
     c.d->update();
     return [[static_cast<NSCursor *>(c.d->curs.cp.nscursor) retain] autorelease];
 }
 
 static QCursorData *currentCursor = 0; //current cursor
-void qt_mac_set_cursor(const QCursor *c, const QPoint &)
+
+void qt_mac_set_cursor(const QCursor *c)
 {
 #ifdef QT_MAC_USE_COCOA
-    Q_UNUSED(c);
-    return;
+    QMacCocoaAutoReleasePool pool;
+    [static_cast<NSCursor *>(qt_mac_nsCursorForQCursor(*c)) set];
 #else
     if (!c) {
         currentCursor = 0;
@@ -128,35 +131,122 @@ void qt_mac_set_cursor(const QCursor *c, const QPoint &)
             c->d->curs.tc.anim->start(c->d->curs.tc.curs);
         }
     }
+
     currentCursor = c->d;
 #endif
 }
 
-void qt_mac_update_cursor_at_global_pos(const QPoint &globalPos)
+static QPointer<QWidget> lastWidgetUnderMouse = 0;
+static QPointer<QWidget> lastMouseCursorWidget = 0;
+static bool qt_button_down_on_prev_call = false;
+static QCursor *grabCursor = 0;
+
+void qt_mac_updateCursorWithWidgetUnderMouse(QWidget *widgetUnderMouse)
 {
-#ifdef QT_MAC_USE_COCOA
-    Q_UNUSED(globalPos);
-    return;
-#else
     QCursor cursor(Qt::ArrowCursor);
+    if (qt_button_down) {
+        // The widget that is currently pressed
+        // grabs the mouse cursor:
+        widgetUnderMouse = qt_button_down;
+        qt_button_down_on_prev_call = true;
+    } else if (qt_button_down_on_prev_call) {
+        // Grab has been released, so do
+        // a full check:
+        qt_button_down_on_prev_call = false;
+        lastWidgetUnderMouse = 0;
+        lastMouseCursorWidget = 0;
+    }
+
     if (QApplication::overrideCursor()) {
         cursor = *QApplication::overrideCursor();
-    } else {
-        for(QWidget *w = QApplication::widgetAt(globalPos); w; w = w->parentWidget()) {
-            if(w->testAttribute(Qt::WA_SetCursor)) {
-                cursor = w->cursor();
-                break;
+    } else if (grabCursor) {
+        cursor = *grabCursor;
+    } else if (widgetUnderMouse) {
+        if (widgetUnderMouse == lastWidgetUnderMouse) {
+            // Optimization that should hit when the widget under
+            // the mouse does not change as the mouse moves:
+            if (lastMouseCursorWidget)
+                cursor = lastMouseCursorWidget->cursor();
+        } else {
+            QWidget *w = widgetUnderMouse;
+            for (; w; w = w->parentWidget()) {
+                if (w->testAttribute(Qt::WA_SetCursor)) {
+                    cursor = w->cursor();
+                    break;
+                }
+                if (w->isWindow())
+                    break;
             }
+            // One final check in case we ran out of parents in the loop:
+            if (w && !w->testAttribute(Qt::WA_SetCursor))
+                w = 0;
+
+            lastWidgetUnderMouse = widgetUnderMouse;
+            lastMouseCursorWidget = w;
         }
     }
-    qt_mac_set_cursor(&cursor, globalPos);
+
+#ifdef QT_MAC_USE_COCOA
+    cursor.d->update();
+    NSCursor *nsCursor = static_cast<NSCursor *>(cursor.d->curs.cp.nscursor);
+    if ([NSCursor currentCursor] != nsCursor) {
+        QMacCocoaAutoReleasePool pool;
+        [nsCursor set];
+    }
+#else
+    qt_mac_set_cursor(&cursor);
 #endif
 }
 
 void qt_mac_update_cursor()
 {
-    qt_mac_update_cursor_at_global_pos(QCursor::pos());
+    // This function is similar to qt_mac_updateCursorWithWidgetUnderMouse
+    // except that is clears the optimization cache, and finds the widget
+    // under mouse itself. Clearing the cache is useful in cases where the
+    // application has been deactivated/activated etc.
+    // NB: since we dont have any true native widget, the call to
+    // qt_mac_getTargetForMouseEvent will fail when the mouse is over QMacNativeWidgets.
+#ifdef QT_MAC_USE_COCOA
+    lastWidgetUnderMouse = 0;
+    lastMouseCursorWidget = 0;
+    QWidget *widgetUnderMouse = 0;
+
+    if (qt_button_down) {
+        widgetUnderMouse = qt_button_down;
+    } else {
+        QPoint localPoint;
+        QPoint globalPoint = QCursor::pos();
+        qt_mac_getTargetForMouseEvent(0, QEvent::None, localPoint, globalPoint, 0, &widgetUnderMouse);
+    }
+    qt_mac_updateCursorWithWidgetUnderMouse(widgetUnderMouse);
+#else
+    qt_mac_updateCursorWithWidgetUnderMouse(QApplication::widgetAt(QCursor::pos()));
+#endif
+}
+
+void qt_mac_setMouseGrabCursor(bool set, QCursor *const cursor = 0)
+{
+    if (grabCursor) {
+        delete grabCursor;
+        grabCursor = 0;
+    }
+    if (set) {
+        if (cursor)
+            grabCursor = new QCursor(*cursor);
+        else if (lastMouseCursorWidget)
+            grabCursor = new QCursor(lastMouseCursorWidget->cursor());
+        else
+            grabCursor = new QCursor(Qt::ArrowCursor);
+    }
+    qt_mac_update_cursor();
+}
+
+#ifndef QT_MAC_USE_COCOA
+void qt_mac_update_cursor_at_global_pos(const QPoint &globalPos)
+{
+    qt_mac_updateCursorWithWidgetUnderMouse(QApplication::widgetAt(globalPos));
 }
+#endif
 
 static int nextCursorId = Qt::BitmapCursor;
 
@@ -427,7 +517,8 @@ void QCursorData::update()
         break;
     case Qt::DragCopyCursor:
         type = QCursorData::TYPE_ThemeCursor;
-        curs.cp.nscursor = [NSCursor dragCopyCursor];
+        if ([NSCursor respondsToSelector:@selector(dragCopyCursor)])
+            curs.cp.nscursor = [NSCursor performSelector:@selector(dragCopyCursor)];
         break;
     case Qt::DragMoveCursor:
         type = QCursorData::TYPE_ThemeCursor;
@@ -435,7 +526,8 @@ void QCursorData::update()
         break;
     case Qt::DragLinkCursor:
         type = QCursorData::TYPE_ThemeCursor;
-        curs.cp.nscursor = [NSCursor dragLinkCursor];
+        if ([NSCursor respondsToSelector:@selector(dragLinkCursor)])
+            curs.cp.nscursor = [NSCursor performSelector:@selector(dragLinkCursor)];
         break;
 #define QT_USE_APPROXIMATE_CURSORS
 #ifdef QT_USE_APPROXIMATE_CURSORS
diff --git a/src/gui/kernel/qdnd_mac.mm b/src/gui/kernel/qdnd_mac.mm
index d630faa..3af2ba0 100644
--- a/src/gui/kernel/qdnd_mac.mm
+++ b/src/gui/kernel/qdnd_mac.mm
@@ -491,7 +491,7 @@ bool QWidgetPrivate::qt_mac_dnd_event(uint kind, DragRef dragRef)
         SetThemeCursor(cursor);
     }
     if(found_cursor) {
-        qt_mac_set_cursor(0, QPoint()); //just use our's
+        qt_mac_set_cursor(0); //just use our's
     } else {
         QCursor cursor(Qt::ArrowCursor);
         if(qApp && qApp->overrideCursor()) {
@@ -504,7 +504,7 @@ bool QWidgetPrivate::qt_mac_dnd_event(uint kind, DragRef dragRef)
                 }
             }
         }
-        qt_mac_set_cursor(&cursor, QPoint(mouse.h, mouse.v));
+        qt_mac_set_cursor(&cursor);
     }
 
     //idle things
diff --git a/src/gui/kernel/qevent.cpp b/src/gui/kernel/qevent.cpp
index db25da3..277a5e8 100644
--- a/src/gui/kernel/qevent.cpp
+++ b/src/gui/kernel/qevent.cpp
@@ -54,6 +54,10 @@
 #include "qgesture.h"
 #include "qgesture_p.h"
 
+#ifdef Q_OS_SYMBIAN
+#include "private/qcore_symbian_p.h"
+#endif
+
 QT_BEGIN_NAMESPACE
 
 /*!
@@ -725,12 +729,12 @@ QWheelEvent::QWheelEvent(const QPoint &pos, const QPoint& globalPos, int delta,
     The \a type parameter must be QEvent::KeyPress, QEvent::KeyRelease,
     or QEvent::ShortcutOverride.
 
-    Int \a key is the code for the Qt::Key that the event loop should listen 
-    for. If \a key is 0, the event is not a result of a known key; for 
+    Int \a key is the code for the Qt::Key that the event loop should listen
+    for. If \a key is 0, the event is not a result of a known key; for
     example, it may be the result of a compose sequence or keyboard macro.
-    The \a modifiers holds the keyboard modifiers, and the given \a text 
-    is the Unicode text that the key generated. If \a autorep is true, 
-    isAutoRepeat() will be true. \a count is the number of keys involved 
+    The \a modifiers holds the keyboard modifiers, and the given \a text
+    is the Unicode text that the key generated. If \a autorep is true,
+    isAutoRepeat() will be true. \a count is the number of keys involved
     in the event.
 */
 QKeyEvent::QKeyEvent(Type type, int key, Qt::KeyboardModifiers modifiers, const QString& text,
@@ -1659,7 +1663,7 @@ Qt::ButtonState QContextMenuEvent::state() const
     string is controlled by the widget only). The AttributeType enum
     describes the different attributes that can be set.
 
-    A class implementing QWidget::inputMethodEvent() or 
+    A class implementing QWidget::inputMethodEvent() or
     QGraphicsItem::inputMethodEvent() should at least understand and
     honor the \l TextFormat and \l Cursor attributes.
 
@@ -3024,9 +3028,16 @@ QShowEvent::~QShowEvent()
     This event is only used to notify the application of a request.
     It may be safely ignored.
 
-    \note This class is currently supported for Mac OS X only.
+    \note This class is currently supported for Mac OS X and Symbian only.
 */
 
+QFileOpenEventPrivate::~QFileOpenEventPrivate()
+{
+#ifdef Q_OS_SYMBIAN
+    file.Close();
+#endif
+}
+
 /*!
     \internal
 
@@ -3050,6 +3061,22 @@ QFileOpenEvent::QFileOpenEvent(const QUrl &url)
     f = url.toLocalFile();
 }
 
+#ifdef Q_OS_SYMBIAN
+/*! \internal
+*/
+QFileOpenEvent::QFileOpenEvent(const RFile &fileHandle)
+    : QEvent(FileOpen)
+{
+    TFileName fullName;
+    fileHandle.FullName(fullName);
+    f = qt_TDesC2QString(fullName);
+    QScopedPointer<QFileOpenEventPrivate> priv(new QFileOpenEventPrivate(QUrl::fromLocalFile(f)));
+    // Duplicate here allows the file handle to be valid after S60 app construction is complete.
+    qt_symbian_throwIfError(priv->file.Duplicate(fileHandle));
+    d = reinterpret_cast<QEventPrivate *>(priv.take());
+}
+#endif
+
 /*! \internal
 */
 QFileOpenEvent::~QFileOpenEvent()
@@ -3075,6 +3102,39 @@ QUrl QFileOpenEvent::url() const
     return reinterpret_cast<const QFileOpenEventPrivate *>(d)->url;
 }
 
+/*!
+    \fn bool openFile(QFile &file, QIODevice::OpenMode flags) const
+
+    Opens a QFile on the file referenced by this event.
+    Returns true if successful; otherwise returns false.
+
+    This is necessary as some files cannot be opened by name, but require specific
+    information stored in this event.
+    For example, if this QFileOpenEvent contains a request to open a Symbian data caged file,
+    the QFile could only be opened from the Symbian RFile used in the construction of this event.
+
+    \since 4.8
+*/
+bool QFileOpenEvent::openFile(QFile &file, QIODevice::OpenMode flags) const
+{
+    file.setFileName(f);
+#ifdef Q_OS_SYMBIAN
+    const QFileOpenEventPrivate *priv = reinterpret_cast<const QFileOpenEventPrivate *>(d);
+    if (priv->file.SubSessionHandle()) {
+        RFile dup;
+        // Duplicate here means that the opened QFile will continue to be valid beyond the lifetime of this QFileOpenEvent.
+        // It also allows openFile to be used in threads other than the thread in which the QFileOpenEvent was created.
+        if (dup.Duplicate(priv->file) == KErrNone) {
+            QScopedPointer<RFile, QScopedPointerRCloser<RFile> > dupCloser(&dup);
+            bool open = file.open(dup, flags, QFile::AutoCloseHandle);
+            dupCloser.take();
+            return open;
+        }
+    }
+#endif
+    return file.open(flags);
+}
+
 #ifndef QT_NO_TOOLBAR
 /*!
     \internal
@@ -3623,7 +3683,7 @@ QMenubarUpdatedEvent::QMenubarUpdatedEvent(QMenuBar * const menuBar)
 
 #endif
 
-/*! 
+/*!
     \class QTouchEvent
     \brief The QTouchEvent class contains parameters that describe a touch event.
     \since 4.6
diff --git a/src/gui/kernel/qevent.h b/src/gui/kernel/qevent.h
index a7b06f4..93c2bc5 100644
--- a/src/gui/kernel/qevent.h
+++ b/src/gui/kernel/qevent.h
@@ -54,6 +54,11 @@
 #include <QtCore/qvariant.h>
 #include <QtCore/qmap.h>
 #include <QtCore/qset.h>
+#include <QtCore/qfile.h>
+
+#ifdef Q_OS_SYMBIAN
+class RFile;
+#endif
 
 QT_BEGIN_HEADER
 
@@ -641,10 +646,14 @@ class Q_GUI_EXPORT QFileOpenEvent : public QEvent
 public:
     QFileOpenEvent(const QString &file);
     QFileOpenEvent(const QUrl &url);
+#ifdef Q_OS_SYMBIAN
+    QFileOpenEvent(const RFile &fileHandle);
+#endif
     ~QFileOpenEvent();
 
     inline QString file() const { return f; }
     QUrl url() const;
+    bool openFile(QFile &file, QIODevice::OpenMode flags) const;
 private:
     QString f;
 };
diff --git a/src/gui/kernel/qevent_p.h b/src/gui/kernel/qevent_p.h
index 3a27023..b79f372 100644
--- a/src/gui/kernel/qevent_p.h
+++ b/src/gui/kernel/qevent_p.h
@@ -46,6 +46,10 @@
 #include <QtCore/qurl.h>
 #include <QtGui/qevent.h>
 
+#ifdef Q_OS_SYMBIAN
+#include <f32file.h>
+#endif
+
 QT_BEGIN_NAMESPACE
 
 //
@@ -174,8 +178,12 @@ public:
         : url(url)
     {
     }
+    ~QFileOpenEventPrivate();
 
     QUrl url;
+#ifdef Q_OS_SYMBIAN
+    RFile file;
+#endif
 };
 
 
diff --git a/src/gui/kernel/qgesture.cpp b/src/gui/kernel/qgesture.cpp
index 17ede02..56daba2 100644
--- a/src/gui/kernel/qgesture.cpp
+++ b/src/gui/kernel/qgesture.cpp
@@ -332,7 +332,7 @@ void QPanGesture::setAcceleration(qreal value)
 /*!
     \class QPinchGesture
     \since 4.6
-    \brief The QPinchGesture class describes a pinch gesture made my the user.
+    \brief The QPinchGesture class describes a pinch gesture made by the user.
     \ingroup touch
     \ingroup gestures
 
diff --git a/src/gui/kernel/qkeymapper_p.h b/src/gui/kernel/qkeymapper_p.h
index 7a7c6a5..ec2d849 100644
--- a/src/gui/kernel/qkeymapper_p.h
+++ b/src/gui/kernel/qkeymapper_p.h
@@ -213,6 +213,7 @@ public:
     int mapS60ScanCodesToQt(TUint s60key);
     int mapQtToS60Key(int qtKey);
     int mapQtToS60ScanCodes(int qtKey);
+    void updateInputLanguage();
 #endif
 };
 
diff --git a/src/gui/kernel/qkeymapper_s60.cpp b/src/gui/kernel/qkeymapper_s60.cpp
index f0b17ac..bcf32a5 100644
--- a/src/gui/kernel/qkeymapper_s60.cpp
+++ b/src/gui/kernel/qkeymapper_s60.cpp
@@ -40,7 +40,11 @@
 ****************************************************************************/
 
 #include "private/qkeymapper_p.h"
+#include <private/qcore_symbian_p.h>
 #include <e32keys.h>
+#include <e32cmn.h>
+#include <centralrepository.h>
+#include <biditext.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -214,4 +218,32 @@ int QKeyMapperPrivate::mapQtToS60ScanCodes(int qtKey)
     }
     return res;
 }
+
+void QKeyMapperPrivate::updateInputLanguage()
+{
+#ifdef Q_WS_S60
+    TInt err;
+    CRepository *repo;
+    const TUid KCRUidAknFep = TUid::Uid(0x101F876D);
+    const TUint32 KAknFepInputTxtLang = 0x00000005;
+    TRAP(err, repo = CRepository::NewL(KCRUidAknFep));
+    if (err != KErrNone)
+        return;
+
+    TInt symbianLang;
+    err = repo->Get(KAknFepInputTxtLang, symbianLang);
+    delete repo;
+    if (err != KErrNone)
+        return;
+
+    QString qtLang = QString::fromAscii(qt_symbianLocaleName(symbianLang));
+    keyboardInputLocale = QLocale(qtLang);
+    keyboardInputDirection = (TBidiText::ScriptDirectionality(TLanguage(symbianLang)) == TBidiText::ERightToLeft)
+            ? Qt::RightToLeft : Qt::LeftToRight;
+#else
+    keyboardInputLocale = QLocale();
+    keyboardInputDirection = Qt::LeftToRight;
+#endif
+}
+
 QT_END_NAMESPACE
diff --git a/src/gui/kernel/qkeymapper_x11_p.cpp b/src/gui/kernel/qkeymapper_x11_p.cpp
index 1fad4b0..2dbe1e7 100644
--- a/src/gui/kernel/qkeymapper_x11_p.cpp
+++ b/src/gui/kernel/qkeymapper_x11_p.cpp
@@ -40,6 +40,7 @@
 ****************************************************************************/
 
 // This file is auto-generated, do not edit!
+// (Generated using util/xkbdatagen)
 
 static struct {
     const char *layout;
diff --git a/src/gui/kernel/qlayout.cpp b/src/gui/kernel/qlayout.cpp
index 1eeaf8e..e014ec8 100644
--- a/src/gui/kernel/qlayout.cpp
+++ b/src/gui/kernel/qlayout.cpp
@@ -980,10 +980,10 @@ void QLayoutPrivate::reparentChildWidgets(QWidget *mw)
 
 /*!
     This function is called from \c addWidget() functions in
-    subclasses to add \a w as a child widget.
+    subclasses to add \a w as a managed widget of a layout.
 
-    If \a w is already in a layout, this function will give a warning
-    and remove \a w from the layout. This function must therefore be
+    If \a w is already managed by a layout, this function will give a warning
+    and remove \a w from that layout. This function must therefore be
     called before adding \a w to the layout's data structure.
 */
 void QLayout::addChildWidget(QWidget *w)
diff --git a/src/gui/kernel/qmacgesturerecognizer_mac.mm b/src/gui/kernel/qmacgesturerecognizer_mac.mm
index 0e432f3..6a4f0bb 100644
--- a/src/gui/kernel/qmacgesturerecognizer_mac.mm
+++ b/src/gui/kernel/qmacgesturerecognizer_mac.mm
@@ -69,6 +69,7 @@ QMacSwipeGestureRecognizer::recognize(QGesture *gesture, QObject *obj, QEvent *e
             case QNativeGestureEvent::Swipe: {
                 QSwipeGesture *g = static_cast<QSwipeGesture *>(gesture);
                 g->setSwipeAngle(ev->angle);
+                g->setHotSpot(ev->position);
                 return QGestureRecognizer::FinishGesture | QGestureRecognizer::ConsumeEventHint;
                 break; }
             default:
@@ -110,6 +111,7 @@ QMacPinchGestureRecognizer::recognize(QGesture *gesture, QObject *obj, QEvent *e
             g->setCenterPoint(g->startCenterPoint());
             g->setChangeFlags(QPinchGesture::CenterPointChanged);
             g->setTotalChangeFlags(g->totalChangeFlags() | g->changeFlags());
+            g->setHotSpot(ev->position);
             return QGestureRecognizer::MayBeGesture | QGestureRecognizer::ConsumeEventHint;
         case QNativeGestureEvent::Rotate: {
             g->setLastScaleFactor(g->scaleFactor());
@@ -117,6 +119,7 @@ QMacPinchGestureRecognizer::recognize(QGesture *gesture, QObject *obj, QEvent *e
             g->setRotationAngle(g->rotationAngle() + ev->percentage);
             g->setChangeFlags(QPinchGesture::RotationAngleChanged);
             g->setTotalChangeFlags(g->totalChangeFlags() | g->changeFlags());
+            g->setHotSpot(ev->position);
             return QGestureRecognizer::TriggerGesture | QGestureRecognizer::ConsumeEventHint;
         }
         case QNativeGestureEvent::Zoom:
@@ -125,6 +128,7 @@ QMacPinchGestureRecognizer::recognize(QGesture *gesture, QObject *obj, QEvent *e
             g->setScaleFactor(g->scaleFactor() * (1 + ev->percentage));
             g->setChangeFlags(QPinchGesture::ScaleFactorChanged);
             g->setTotalChangeFlags(g->totalChangeFlags() | g->changeFlags());
+            g->setHotSpot(ev->position);
             return QGestureRecognizer::TriggerGesture | QGestureRecognizer::ConsumeEventHint;
         case QNativeGestureEvent::GestureEnd:
             return QGestureRecognizer::FinishGesture | QGestureRecognizer::ConsumeEventHint;
@@ -221,6 +225,7 @@ QMacPanGestureRecognizer::recognize(QGesture *gesture, QObject *target, QEvent *
                 const QPointF posOffset = p - _startPos;
                 g->setLastOffset(g->offset());
                 g->setOffset(QPointF(posOffset.x(), posOffset.y()));
+                g->setHotSpot(_startPos);
                 return QGestureRecognizer::TriggerGesture;
             }
         } else if (_panTimer.isActive()) {
@@ -239,6 +244,7 @@ QMacPanGestureRecognizer::recognize(QGesture *gesture, QObject *target, QEvent *
                 break;
             // Begin new pan session!
             _startPos = QCursor::pos();
+            g->setHotSpot(_startPos);
             return QGestureRecognizer::TriggerGesture | QGestureRecognizer::ConsumeEventHint;
         }
         break; }
diff --git a/src/gui/kernel/qt_cocoa_helpers_mac.mm b/src/gui/kernel/qt_cocoa_helpers_mac.mm
index b2d9ca6..98f62ca 100644
--- a/src/gui/kernel/qt_cocoa_helpers_mac.mm
+++ b/src/gui/kernel/qt_cocoa_helpers_mac.mm
@@ -89,9 +89,16 @@
 #include <private/qcocoaview_mac_p.h>
 #include <private/qkeymapper_p.h>
 #include <private/qwidget_p.h>
+#include <private/qcocoawindow_mac_p.h>
 
 QT_BEGIN_NAMESPACE
 
+#ifdef QT_MAC_USE_COCOA
+// Cmd + left mousebutton should produce a right button
+//  press (mainly for mac users with one-button mice):
+static bool qt_leftButtonIsRightButton = false;
+#endif
+
 Q_GLOBAL_STATIC(QMacWindowFader, macwindowFader);
 
 QMacWindowFader::QMacWindowFader()
@@ -141,6 +148,9 @@ void QMacWindowFader::performFade()
 extern bool qt_sendSpontaneousEvent(QObject *receiver, QEvent *event); // qapplication.cpp;
 extern QWidget * mac_mouse_grabber;
 extern QWidget *qt_button_down; //qapplication_mac.cpp
+extern QPointer<QWidget> qt_last_mouse_receiver;
+extern OSViewRef qt_mac_effectiveview_for(const QWidget *w);
+extern void qt_mac_updateCursorWithWidgetUnderMouse(QWidget *widgetUnderMouse); // qcursor_mac.mm
 
 void macWindowFade(void * /*OSWindowRef*/ window, float durationSeconds)
 {
@@ -167,6 +177,70 @@ void macWindowFade(void * /*OSWindowRef*/ window, float durationSeconds)
         }
     }
 }
+struct dndenum_mapper
+{
+    NSDragOperation mac_code;
+    Qt::DropAction qt_code;
+    bool Qt2Mac;
+};
+
+#ifdef QT_MAC_USE_COCOA && __OBJC__
+
+static dndenum_mapper dnd_enums[] = {
+    { NSDragOperationLink,  Qt::LinkAction, true },
+    { NSDragOperationMove,  Qt::MoveAction, true },
+    { NSDragOperationCopy,  Qt::CopyAction, true },
+    { NSDragOperationGeneric,  Qt::CopyAction, false },
+    { NSDragOperationEvery, Qt::ActionMask, false },
+    { NSDragOperationNone, Qt::IgnoreAction, false }
+};
+
+NSDragOperation qt_mac_mapDropAction(Qt::DropAction action)
+{
+    for (int i=0; dnd_enums[i].qt_code; i++) {
+        if (dnd_enums[i].Qt2Mac && (action & dnd_enums[i].qt_code)) {
+            return dnd_enums[i].mac_code;
+        }
+    }
+    return NSDragOperationNone;
+}
+
+NSDragOperation qt_mac_mapDropActions(Qt::DropActions actions)
+{
+    NSDragOperation nsActions = NSDragOperationNone;
+    for (int i=0; dnd_enums[i].qt_code; i++) {
+        if (dnd_enums[i].Qt2Mac && (actions & dnd_enums[i].qt_code))
+            nsActions |= dnd_enums[i].mac_code;
+    }
+    return nsActions;
+}
+
+Qt::DropAction qt_mac_mapNSDragOperation(NSDragOperation nsActions)
+{
+    Qt::DropAction action = Qt::IgnoreAction;
+    for (int i=0; dnd_enums[i].mac_code; i++) {
+        if (nsActions & dnd_enums[i].mac_code)
+            return dnd_enums[i].qt_code;
+    }
+    return action;
+}
+
+Qt::DropActions qt_mac_mapNSDragOperations(NSDragOperation nsActions)
+{
+    Qt::DropActions actions = Qt::IgnoreAction;
+    for (int i=0; dnd_enums[i].mac_code; i++) {
+        if (nsActions & dnd_enums[i].mac_code)
+            actions |= dnd_enums[i].qt_code;
+    }
+    return actions;
+}
+
+Q_GLOBAL_STATIC(DnDParams, currentDnDParameters);
+DnDParams *macCurrentDnDParameters()
+{
+    return currentDnDParameters();
+}
+#endif
 
 bool macWindowIsTextured( void * /*OSWindowRef*/ window )
 {
@@ -301,7 +375,7 @@ bool qt_mac_checkForNativeSizeGrip(const QWidget *widget)
     HIViewFindByID(HIViewGetRoot(HIViewGetWindow(HIViewRef(widget->winId()))), kHIViewWindowGrowBoxID, &nativeSizeGrip);
     return (nativeSizeGrip != 0);
 #else
-    return [[reinterpret_cast<NSView *>(widget->winId()) window] showsResizeIndicator];
+    return [[reinterpret_cast<NSView *>(widget->effectiveWinId()) window] showsResizeIndicator];
 #endif
 }
 struct qt_mac_enum_mapper
@@ -517,8 +591,12 @@ static const KeyPair entries[NumEntries] = {
     { NSNewlineCharacter, Qt::Key_Return },
     { NSCarriageReturnCharacter, Qt::Key_Return },
     { NSBackTabCharacter, Qt::Key_Backtab },
-    { NSDeleteCharacter, Qt::Key_Delete },
     { kEscapeCharCode, Qt::Key_Escape },
+    // Cocoa sends us delete when pressing backspace!
+    // (NB when we reverse this list in qtKey2CocoaKey, there
+    // will be two indices of Qt::Key_Backspace. But is seems to work
+    // ok for menu shortcuts (which uses that function):
+    { NSDeleteCharacter, Qt::Key_Backspace },
     { NSUpArrowFunctionKey, Qt::Key_Up },
     { NSDownArrowFunctionKey, Qt::Key_Down },
     { NSLeftArrowFunctionKey, Qt::Key_Left },
@@ -731,7 +809,6 @@ Qt::MouseButton cocoaButton2QtButton(NSInteger buttonNum)
     return Qt::NoButton;
 }
 
-// Helper to share code between QCocoaWindow and QCocoaView
 bool qt_dispatchKeyEvent(void * /*NSEvent * */ keyEvent, QWidget *widgetToGetEvent)
 {
 #ifndef QT_MAC_USE_COCOA
@@ -743,6 +820,7 @@ bool qt_dispatchKeyEvent(void * /*NSEvent * */ keyEvent, QWidget *widgetToGetEve
     EventRef key_event = static_cast<EventRef>(const_cast<void *>([event eventRef]));
     Q_ASSERT(key_event);
     unsigned int info = 0;
+
     if ([event type] == NSKeyDown) {
         NSString *characters = [event characters];
         if ([characters length]) {
@@ -752,19 +830,12 @@ bool qt_dispatchKeyEvent(void * /*NSEvent * */ keyEvent, QWidget *widgetToGetEve
         }
     }
 
-    // Redirect keys to alien widgets.
-    if (widgetToGetEvent->testAttribute(Qt::WA_NativeWindow) == false) {
-        widgetToGetEvent = qApp->focusWidget();
-    }
-
-    if (widgetToGetEvent == 0)
-        return false;
-
     if (qt_mac_sendMacEventToWidget(widgetToGetEvent, key_event))
         return true;
 
     if (mustUseCocoaKeyEvent())
         return qt_dispatchKeyEventWithCocoa(keyEvent, widgetToGetEvent);
+
     bool consumed = qt_keymapper_private()->translateKeyEvent(widgetToGetEvent, 0, key_event, &info, true);
     return consumed && (info != 0);
 #endif
@@ -788,7 +859,6 @@ void qt_dispatchModifiersChanged(void * /*NSEvent * */flagsChangedEvent, QWidget
 #endif
 }
 
-
 QPointF flipPoint(const NSPoint &p)
 {
     return QPointF(p.x, flipYCoordinate(p.y));
@@ -804,21 +874,15 @@ NSPoint flipPoint(const QPointF &p)
     return NSMakePoint(p.x(), flipYCoordinate(p.y()));
 }
 
-void qt_mac_dispatchNCMouseMessage(void * /* NSWindow* */eventWindow, void * /* NSEvent* */mouseEvent,
-                                   QWidget *widgetToGetEvent, bool &leftButtonIsRightButton)
+#if QT_MAC_USE_COCOA && __OBJC__
+
+void qt_mac_handleNonClientAreaMouseEvent(NSWindow *window, NSEvent *event)
 {
-#ifndef QT_MAC_USE_COCOA
-    Q_UNUSED(eventWindow);
-    Q_UNUSED(mouseEvent);
-    Q_UNUSED(widgetToGetEvent);
-    Q_UNUSED(leftButtonIsRightButton);
-#else
+    QWidget *widgetToGetEvent = [window QT_MANGLE_NAMESPACE(qt_qwidget)];
     if (widgetToGetEvent == 0)
         return;
-    NSWindow *window = static_cast<NSWindow *>(eventWindow);
-    NSEvent *event = static_cast<NSEvent *>(mouseEvent);
-    NSEventType evtType = [event type];
 
+    NSEventType evtType = [event type];
     QPoint qlocalPoint;
     QPoint qglobalPoint;
     bool processThisEvent = false;
@@ -936,12 +1000,12 @@ void qt_mac_dispatchNCMouseMessage(void * /* NSWindow* */eventWindow, void * /*
                                            : QEvent::MouseButtonDblClick;
         if (button == Qt::LeftButton && (keyMods & Qt::MetaModifier)) {
             button = Qt::RightButton;
-            leftButtonIsRightButton = true;
+            qt_leftButtonIsRightButton = true;
         }
     } else if (eventType == QEvent::NonClientAreaMouseButtonRelease || eventType == QEvent::MouseButtonRelease) {
-        if (button == Qt::LeftButton && leftButtonIsRightButton) {
+        if (button == Qt::LeftButton && qt_leftButtonIsRightButton) {
             button = Qt::RightButton;
-            leftButtonIsRightButton = false;
+            qt_leftButtonIsRightButton = false;
         }
     }
 
@@ -961,155 +1025,265 @@ void qt_mac_dispatchNCMouseMessage(void * /* NSWindow* */eventWindow, void * /*
     // However we might need to unset it if the event is Release.
     if (eventType == QEvent::MouseButtonRelease)
         qt_button_down = 0;
-#endif
 }
 
-bool qt_mac_handleMouseEvent(void * /* NSView * */view, void * /* NSEvent * */event, QEvent::Type eventType, Qt::MouseButton button)
+QWidget *qt_mac_getTargetForKeyEvent(QWidget *widgetThatReceivedEvent)
 {
-#ifndef QT_MAC_USE_COCOA
-    Q_UNUSED(view);
-    Q_UNUSED(event);
-    Q_UNUSED(eventType);
-    Q_UNUSED(button);
-    return false;
-#else
-    QT_MANGLE_NAMESPACE(QCocoaView) *theView = static_cast<QT_MANGLE_NAMESPACE(QCocoaView) *>(view);
-    NSEvent *theEvent = static_cast<NSEvent *>(event);
+    if (QWidget *popup = QApplication::activePopupWidget()) {
+        QWidget *focusInPopup = popup->focusWidget();
+        return focusInPopup ? focusInPopup : popup;
+    }
 
-    // Give the Input Manager a chance to process the mouse events.
-   NSInputManager *currentIManager = [NSInputManager currentInputManager];
-   if (currentIManager && [currentIManager wantsToHandleMouseEvents]) {
-        [currentIManager handleMouseEvent:theEvent];
-   }
+    QWidget *widgetToGetKey = qApp->focusWidget();
+    if (!widgetToGetKey)
+        widgetToGetKey = widgetThatReceivedEvent;
 
-    // Handle tablet events (if any) first.
-    if (qt_mac_handleTabletEvent(theView, theEvent)) {
-        // Tablet event was handled. In Qt we aren't supposed to send the mouse event.
-        return true;
+    return widgetToGetKey;
+}
+
+// This function will find the widget that should receive the
+// mouse event. Because of explicit/implicit mouse grabs, popups,
+// etc, this might not end up being the same as the widget under
+// the mouse (which is more interresting when handling enter/leave
+// 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,
+    QPoint &returnGlobalPoint,
+    QWidget *nativeWidget,
+    QWidget **returnWidgetUnderMouse)
+{
+    Q_UNUSED(event);
+    returnGlobalPoint = flipPoint([NSEvent mouseLocation]).toPoint();
+    QWidget *mouseGrabber = QWidget::mouseGrabber();
+    bool buttonDownNotBlockedByModal = qt_button_down && !QApplicationPrivate::isBlockedByModal(qt_button_down);
+    QWidget *popup = QApplication::activePopupWidget();
+
+    // Resolve the widget under the mouse:
+    QWidget *widgetUnderMouse = 0;
+    if (popup || qt_button_down || !nativeWidget || !nativeWidget->isVisible()) {
+        // Using QApplication::widgetAt for finding the widget under the mouse
+        // is most safe, since it ignores cocoas own mouse down redirections (which
+        // we need to be prepared for when using nativeWidget as starting point).
+        // (the only exception is for QMacNativeWidget, where QApplication::widgetAt fails).
+        // But it is also slower (I guess), so we try to avoid it and use nativeWidget if we can:
+        widgetUnderMouse = QApplication::widgetAt(returnGlobalPoint);
     }
 
-    NSPoint windowPoint = [theEvent locationInWindow];
-    NSPoint globalPoint = [[theEvent window] convertBaseToScreen:windowPoint];
+    if (!widgetUnderMouse && nativeWidget) {
+        // Entering here should be the common case. We
+        // also handle the QMacNativeWidget fallback case.
+        QPoint p = nativeWidget->mapFromGlobal(returnGlobalPoint);
+        widgetUnderMouse = nativeWidget->childAt(p);
+        if (!widgetUnderMouse && nativeWidget->rect().contains(p))
+            widgetUnderMouse = nativeWidget;
+    }
 
-    // Find the widget that *should* get the event (e.g., maybe it was a pop-up,
-    // they always get the mouse event).
-    QWidget *qwidget = [theView qt_qwidget];
-    QWidget *widgetToGetMouse = 0;
-    NSView *tmpView = 0;
-    QWidget *popup = qAppInstance()->activePopupWidget();
-    QPoint qglobalPoint(flipPoint(globalPoint).toPoint());
+    if (widgetUnderMouse) {
+        // Check if widgetUnderMouse is blocked by a modal
+        // window, or the mouse if over the frame strut:
+        if (widgetUnderMouse == qt_button_down) {
+            // Small optimization to avoid an extra call to isBlockedByModal:
+            if (buttonDownNotBlockedByModal == false)
+                widgetUnderMouse = 0;
+        } else if (QApplicationPrivate::isBlockedByModal(widgetUnderMouse)) {
+            widgetUnderMouse = 0;
+        }
 
-    if (popup) {
-        widgetToGetMouse = popup;
-        tmpView = qt_mac_nativeview_for(popup);
-        windowPoint = [[tmpView window] convertScreenToBase:globalPoint];
-
-        QPoint qWindowPoint(windowPoint.x, windowPoint.y);
-        if (widgetToGetMouse->rect().contains(qWindowPoint)) {
-            // Keeping the mouse pressed on a combobox button will make
-            // the popup pop in front of the mouse. But all mouse events
-            // will be sendt to the button. Since we want mouse events
-            // to be sendt to widgets inside the popup, we search for the
-            // widget in front of the mouse:
-            tmpView = [tmpView hitTest:windowPoint];
-            if (!tmpView)
-                return false;
-            widgetToGetMouse =
-                [static_cast<QT_MANGLE_NAMESPACE(QCocoaView) *>(tmpView) qt_qwidget];
+        if (widgetUnderMouse && widgetUnderMouse->isWindow()) {
+            // Exclude the titlebar (and frame strut) when finding widget under mouse:
+            QPoint p = widgetUnderMouse->mapFromGlobal(returnGlobalPoint);
+            if (!widgetUnderMouse->rect().contains(p))
+                widgetUnderMouse = 0;
+        }
+    }
+    if (returnWidgetUnderMouse)
+        *returnWidgetUnderMouse = widgetUnderMouse;
+
+    // Resolve the target for the mouse event. Default will be
+    // widgetUnderMouse, except if there is a grab (popup/mouse/button-down):
+    if (popup && !mouseGrabber) {
+        // We special case handling of popups, since they have an implicitt mouse grab.
+        QWidget *candidate = buttonDownNotBlockedByModal ? qt_button_down : widgetUnderMouse;
+        if (!popup->isAncestorOf(candidate)) {
+            // INVARIANT: we have a popup, but the candidate is not
+            // in it. But the popup will grab the mouse anyway,
+            // except if the user scrolls:
+            if (eventType == QEvent::Wheel)
+                return 0;
+            returnLocalPoint = popup->mapFromGlobal(returnGlobalPoint);
+            return popup;
+        } else if (popup == candidate) {
+            // INVARIANT: The candidate is the popup itself, and not a child:
+            returnLocalPoint = popup->mapFromGlobal(returnGlobalPoint);
+            return popup;
+        } else {
+            // INVARIANT: The candidate is a child inside the popup:
+            returnLocalPoint = candidate->mapFromGlobal(returnGlobalPoint);
+            return candidate;
         }
+    }
+
+    QWidget *target = mouseGrabber;
+    if (!target && buttonDownNotBlockedByModal)
+        target = qt_button_down;
+    if (!target)
+        target = widgetUnderMouse;
+    if (!target)
+        return 0;
+
+    returnLocalPoint = target->mapFromGlobal(returnGlobalPoint);
+    return target;
+}
+
+QPointer<QWidget> qt_last_native_mouse_receiver = 0;
+
+static inline void qt_mac_checkEnterLeaveForNativeWidgets(QWidget *maybeEnterWidget)
+{
+    // Dispatch enter/leave for the cases where QApplicationPrivate::sendMouseEvent do
+    // not. This will in general be the cases when alien widgets are not involved:
+    // 1. from a native widget to another native widget or
+    // 2. from a native widget to no widget
+    // 3. from no widget to a native or alien widget
+
+    if (qt_button_down || QWidget::mouseGrabber())
+        return;
+
+    if ((maybeEnterWidget == qt_last_native_mouse_receiver) && qt_last_native_mouse_receiver)
+        return;
+    if (maybeEnterWidget) {
+        if (!qt_last_native_mouse_receiver) {
+            // case 3
+            QApplicationPrivate::dispatchEnterLeave(maybeEnterWidget, 0);
+            qt_last_native_mouse_receiver = maybeEnterWidget->internalWinId() ? maybeEnterWidget : maybeEnterWidget->nativeParentWidget();
+        } else if (maybeEnterWidget->internalWinId()) {
+            // case 1
+            QApplicationPrivate::dispatchEnterLeave(maybeEnterWidget, qt_last_native_mouse_receiver);
+            qt_last_native_mouse_receiver = maybeEnterWidget->internalWinId() ? maybeEnterWidget : maybeEnterWidget->nativeParentWidget();
+        } // else at lest one of the widgets are alien, so enter/leave will be handled in QApplicationPrivate
     } else {
-        extern QWidget * qt_button_down; //qapplication_mac.cpp
-        QPoint pos;
-        widgetToGetMouse = QApplicationPrivate::pickMouseReceiver(qwidget, qglobalPoint,
-                                                                  pos, eventType,
-                                                                  button, qt_button_down, 0);
-        if (widgetToGetMouse)
-            tmpView = qt_mac_nativeview_for(widgetToGetMouse);
+        if (qt_last_native_mouse_receiver) {
+            // case 2
+            QApplicationPrivate::dispatchEnterLeave(0, qt_last_native_mouse_receiver);
+            qt_last_mouse_receiver = 0;
+            qt_last_native_mouse_receiver = 0;
+        }
     }
+}
+
+bool qt_mac_handleMouseEvent(NSEvent *event, QEvent::Type eventType, Qt::MouseButton button, QWidget *nativeWidget)
+{
+    // Give the Input Manager a chance to process the mouse events.
+    NSInputManager *currentIManager = [NSInputManager currentInputManager];
+    if (currentIManager && [currentIManager wantsToHandleMouseEvents]) {
+        [currentIManager handleMouseEvent:event];
+    }
+
+    // Find the widget that should receive the event, and the widget under the mouse. Those
+    // can differ if an implicit or explicit mouse grab is active:
+    QWidget *widgetUnderMouse = 0;
+    QPoint localPoint, globalPoint;
+    QWidget *widgetToGetMouse = qt_mac_getTargetForMouseEvent(event, eventType, localPoint, globalPoint, nativeWidget, &widgetUnderMouse);
     if (!widgetToGetMouse)
         return false;
 
-    NSPoint localPoint = [tmpView convertPoint:windowPoint fromView:nil];
-    QPoint qlocalPoint = QPoint(localPoint.x, localPoint.y);
+    // From here on, we let nativeWidget actually be the native widget under widgetUnderMouse. The reason
+    // for this, is that qt_mac_getTargetForMouseEvent will set cocoa's mouse event redirection aside when
+    // determining which widget is under the mouse (in other words, it will usually ignore nativeWidget).
+    // nativeWidget will be used in QApplicationPrivate::sendMouseEvent to correctly dispatch enter/leave events.
+    if (widgetUnderMouse)
+        nativeWidget = widgetUnderMouse->internalWinId() ? widgetUnderMouse : widgetUnderMouse->nativeParentWidget();
+    if (!nativeWidget)
+        return false;
+    NSView *view = qt_mac_effectiveview_for(nativeWidget);
 
-    // Search for alien child widgets (either on this qwidget or on the popup)
-    if (widgetToGetMouse->testAttribute(Qt::WA_NativeWindow) == false || qt_widget_private(widgetToGetMouse)->hasAlienChildren) {
-        QPoint qScreenPoint = flipPoint(globalPoint).toPoint();
-#ifdef ALIEN_DEBUG
-        qDebug() << "alien mouse event" << qScreenPoint << possibleAlien;
-#endif
-        QWidget *possibleAlien =  widgetToGetMouse->childAt(qlocalPoint);
-        if (possibleAlien) {
-            qlocalPoint = possibleAlien->mapFromGlobal(widgetToGetMouse->mapToGlobal(qlocalPoint));
-            widgetToGetMouse = possibleAlien;
-        }
+    // Handle tablet events (if any) first.
+    if (qt_mac_handleTabletEvent(view, event)) {
+        // Tablet event was handled. In Qt we aren't supposed to send the mouse event.
+        return true;
     }
 
-    EventRef carbonEvent = static_cast<EventRef>(const_cast<void *>([theEvent eventRef]));
+    EventRef carbonEvent = static_cast<EventRef>(const_cast<void *>([event eventRef]));
     if (qt_mac_sendMacEventToWidget(widgetToGetMouse, carbonEvent))
         return true;
 
-    // Yay! All the special cases are handled, it really is just a normal mouse event.
-    Qt::KeyboardModifiers keyMods = qt_cocoaModifiers2QtModifiers([theEvent modifierFlags]);
-    NSInteger clickCount = [theEvent clickCount];
-    Qt::MouseButtons buttons = 0;
+    // Keep previousButton to make sure we don't send double click
+    // events when the user double clicks using two different buttons:
     static Qt::MouseButton previousButton = Qt::NoButton;
+
+    Qt::KeyboardModifiers keyMods = qt_cocoaModifiers2QtModifiers([event modifierFlags]);
+    NSInteger clickCount = [event clickCount];
+    Qt::MouseButtons buttons = 0;
     {
         UInt32 mac_buttons;
         if (GetEventParameter(carbonEvent, kEventParamMouseChord, typeUInt32, 0,
                               sizeof(mac_buttons), 0, &mac_buttons) == noErr)
             buttons = qt_mac_get_buttons(mac_buttons);
     }
+
+    // Send enter/leave events for the cases when QApplicationPrivate::sendMouseEvent do not:
+    qt_mac_checkEnterLeaveForNativeWidgets(widgetUnderMouse);
+
     switch (eventType) {
     default:
         qWarning("not handled! %d", eventType);
         break;
     case QEvent::MouseMove:
+        if (button == Qt::LeftButton && qt_leftButtonIsRightButton)
+            button = Qt::RightButton;
         break;
     case QEvent::MouseButtonPress:
-        [QT_MANGLE_NAMESPACE(QCocoaView) currentMouseEvent]->view = theView;
-        [QT_MANGLE_NAMESPACE(QCocoaView) currentMouseEvent]->theEvent = theEvent;
-#ifndef QT_NAMESPACE
-        Q_ASSERT(clickCount > 0);
-#endif
+        qt_button_down = widgetUnderMouse;
         if (clickCount % 2 == 0 && (previousButton == Qt::NoButton || previousButton == button))
             eventType = QEvent::MouseButtonDblClick;
         if (button == Qt::LeftButton && (keyMods & Qt::MetaModifier)) {
             button = Qt::RightButton;
-            [theView qt_setLeftButtonIsRightButton: true];
+            qt_leftButtonIsRightButton = true;
         }
         break;
     case QEvent::MouseButtonRelease:
-        if (button == Qt::LeftButton && [theView qt_leftButtonIsRightButton]) {
+        if (button == Qt::LeftButton && qt_leftButtonIsRightButton) {
             button = Qt::RightButton;
-            [theView qt_setLeftButtonIsRightButton: false];
+            qt_leftButtonIsRightButton = false;
         }
         qt_button_down = 0;
         break;
     }
-    [QT_MANGLE_NAMESPACE(QCocoaView) currentMouseEvent]->localPoint = localPoint;
-    QMouseEvent qme(eventType, qlocalPoint, qglobalPoint, button, buttons, keyMods);
 
-#ifdef ALIEN_DEBUG
-    qDebug() << "sending mouse event to" << widgetToGetMouse;
-#endif
-    extern QWidget *qt_button_down;
-    extern QPointer<QWidget> qt_last_mouse_receiver;
+    qt_mac_updateCursorWithWidgetUnderMouse(widgetUnderMouse);
 
-    if (qwidget->testAttribute(Qt::WA_NativeWindow) && qt_widget_private(qwidget)->hasAlienChildren == false)
-        qt_sendSpontaneousEvent(widgetToGetMouse, &qme);
-    else
-        QApplicationPrivate::sendMouseEvent(widgetToGetMouse, &qme, widgetToGetMouse, qwidget, &qt_button_down,
-                                            qt_last_mouse_receiver);
+    DnDParams *dndParams = currentDnDParameters();
+    dndParams->view = view;
+    dndParams->theEvent = event;
+    dndParams->globalPoint = globalPoint;
+
+    // Send the mouse event:
+    QMouseEvent qme(eventType, localPoint, globalPoint, button, buttons, keyMods);
+    QApplicationPrivate::sendMouseEvent(
+                widgetToGetMouse, &qme, widgetUnderMouse, nativeWidget,
+                &qt_button_down, qt_last_mouse_receiver, true);
 
     if (eventType == QEvent::MouseButtonPress && button == Qt::RightButton) {
-        QContextMenuEvent qcme(QContextMenuEvent::Mouse, qlocalPoint, qglobalPoint, keyMods);
+        QContextMenuEvent qcme(QContextMenuEvent::Mouse, localPoint, globalPoint, keyMods);
         qt_sendSpontaneousEvent(widgetToGetMouse, &qcme);
     }
+
+    if (eventType == QEvent::MouseButtonRelease) {
+        // A mouse button was released, which means that the implicit grab was
+        // released. We therefore need to re-check if should send (delayed) enter leave events:
+        // qt_button_down has now become NULL since the call at the top of the function. Also, since
+        // the relase might have closed a window, we dont give the nativeWidget hint
+        qt_mac_getTargetForMouseEvent(0, QEvent::None, localPoint, globalPoint, nativeWidget, &widgetUnderMouse);
+        qt_mac_checkEnterLeaveForNativeWidgets(widgetUnderMouse);
+    }
+
     previousButton = button;
     return true;
-#endif
 }
+#endif
 
 bool qt_mac_handleTabletEvent(void * /*QCocoaView * */view, void * /*NSEvent * */tabletEvent)
 {
@@ -1293,17 +1467,17 @@ void qt_mac_replaceDrawRectOriginal(void * /*OSWindowRef */window, QWidgetPrivat
 }
 #endif // QT_MAC_USE_COCOA
 
+#if QT_MAC_USE_COCOA
 void qt_mac_showBaseLineSeparator(void * /*OSWindowRef */window, bool show)
 {
     if(!window)
         return;
-#if QT_MAC_USE_COCOA
     QMacCocoaAutoReleasePool pool;
     OSWindowRef theWindow = static_cast<OSWindowRef>(window);
     NSToolbar *macToolbar = [theWindow toolbar];
     [macToolbar setShowsBaselineSeparator:show];
-#endif // QT_MAC_USE_COCOA
 }
+#endif // QT_MAC_USE_COCOA
 
 QStringList qt_mac_NSArrayToQStringList(void *nsarray)
 {
@@ -1323,6 +1497,7 @@ void *qt_mac_QStringListToNSMutableArrayVoid(const QStringList &list)
     return result;
 }
 
+#if QT_MAC_USE_COCOA
 void qt_syncCocoaTitleBarButtons(OSWindowRef window, QWidget *widgetForWindow)
 {
     if (!widgetForWindow)
@@ -1347,6 +1522,7 @@ void qt_syncCocoaTitleBarButtons(OSWindowRef window, QWidget *widgetForWindow)
 
     [window setShowsToolbarButton:uint(flags & Qt::MacWindowToolBarButtonHint) != 0];
 }
+#endif // QT_MAC_USE_COCOA
 
 // Carbon: Make sure you call QDEndContext on the context when done with it.
 CGContextRef qt_mac_graphicsContextFor(QWidget *widget)
@@ -1448,8 +1624,10 @@ void qt_mac_constructQIconFromIconRef(const IconRef icon, const IconRef overlayI
     }
 }
 
+#ifdef QT_MAC_USE_COCOA
 void qt_mac_menu_collapseSeparators(void */*NSMenu **/ theMenu, bool collapse)
 {
+    QMacCocoaAutoReleasePool pool;
     OSMenuRef menu = static_cast<OSMenuRef>(theMenu);
     if (collapse) {
         bool previousIsSeparator = true; // setting to true kills all the separators placed at the top.
@@ -1481,12 +1659,24 @@ void qt_mac_menu_collapseSeparators(void */*NSMenu **/ theMenu, bool collapse)
     }
 }
 
-#ifdef QT_MAC_USE_COCOA
-void qt_cocoaChangeOverrideCursor(const QCursor &cursor)
+class CocoaPostMessageAfterEventLoopExitHelp : public QObject
 {
-    QMacCocoaAutoReleasePool pool;
-    [static_cast<NSCursor *>(qt_mac_nsCursorForQCursor(cursor)) set];
-}
+    id target;
+    SEL selector;
+    int argCount;
+    id arg1;
+    id arg2;
+public:
+    CocoaPostMessageAfterEventLoopExitHelp(id target, SEL selector, int argCount, id arg1, id arg2)
+        : target(target), selector(selector), argCount(argCount), arg1(arg1), arg2(arg2){
+        deleteLater();
+    }
+
+    ~CocoaPostMessageAfterEventLoopExitHelp()
+    {
+        qt_cocoaPostMessage(target, selector, argCount, arg1, arg2);
+    }
+};
 
 void qt_cocoaPostMessage(id target, SEL selector, int argCount, id arg1, id arg2)
 {
@@ -1500,6 +1690,15 @@ void qt_cocoaPostMessage(id target, SEL selector, int argCount, id arg1, id arg2
         context:nil subtype:QtCocoaEventSubTypePostMessage data1:lower data2:upper];
     [NSApp postEvent:e atStart:NO];
 }
+
+void qt_cocoaPostMessageAfterEventLoopExit(id target, SEL selector, int argCount, id arg1, id arg2)
+{
+    if (QApplicationPrivate::instance()->threadData->eventLoops.size() <= 1)
+        qt_cocoaPostMessage(target, selector, argCount, arg1, arg2);
+    else
+        new CocoaPostMessageAfterEventLoopExitHelp(target, selector, argCount, arg1, arg2);
+}
+
 #endif
 
 QMacCocoaAutoReleasePool::QMacCocoaAutoReleasePool()
@@ -1523,6 +1722,12 @@ void qt_mac_post_retranslateAppMenu()
 #endif
 }
 
+QWidgetPrivate *QMacScrollOptimization::_target = 0;
+bool QMacScrollOptimization::_inWheelEvent = false;
+int QMacScrollOptimization::_dx = 0;
+int QMacScrollOptimization::_dy = 0;
+QRect QMacScrollOptimization::_scrollRect = QRect(0, 0, -1, -1);
+
 #ifdef QT_MAC_USE_COCOA
 // This method implements the magic for the drawRectSpecial method.
 // We draw a line at the upper edge of the content view in order to
diff --git a/src/gui/kernel/qt_cocoa_helpers_mac_p.h b/src/gui/kernel/qt_cocoa_helpers_mac_p.h
index d61c00f..334d9e8 100644
--- a/src/gui/kernel/qt_cocoa_helpers_mac_p.h
+++ b/src/gui/kernel/qt_cocoa_helpers_mac_p.h
@@ -103,6 +103,7 @@
 #include <qtimer.h>
 #include <qtooltip.h>
 #include <private/qeffects_p.h>
+#include <private/qwidget_p.h>
 #include <qtextdocument.h>
 #include <qdebug.h>
 #include <qpoint.h>
@@ -144,18 +145,14 @@ bool qt_mac_checkForNativeSizeGrip(const QWidget *widget);
 void qt_dispatchTabletProximityEvent(void * /*NSEvent * */ tabletEvent);
 #ifdef QT_MAC_USE_COCOA
 bool qt_dispatchKeyEventWithCocoa(void * /*NSEvent * */ keyEvent, QWidget *widgetToGetEvent);
-void qt_cocoaChangeOverrideCursor(const QCursor &cursor);
 // These methods exists only for supporting unified mode.
 void macDrawRectOnTop(void * /*OSWindowRef */ window);
 void macSyncDrawingOnFirstInvocation(void * /*OSWindowRef */window);
 void qt_cocoaStackChildWindowOnTopOfOtherChildren(QWidget *widget);
-#endif
 void qt_mac_menu_collapseSeparators(void * /*NSMenu */ menu, bool collapse);
+#endif
 bool qt_dispatchKeyEvent(void * /*NSEvent * */ keyEvent, QWidget *widgetToGetEvent);
 void qt_dispatchModifiersChanged(void * /*NSEvent * */flagsChangedEvent, QWidget *widgetToGetEvent);
-void qt_mac_dispatchNCMouseMessage(void */* NSWindow* */eventWindow, void */* NSEvent* */mouseEvent, 
-                                   QWidget *widgetToGetEvent, bool &leftButtonIsRightButton);
-bool qt_mac_handleMouseEvent(void * /*QCocoaView * */view, void * /*NSEvent * */event, QEvent::Type eventType, Qt::MouseButton button);
 bool qt_mac_handleTabletEvent(void * /*QCocoaView * */view, void * /*NSEvent * */event);
 inline QApplication *qAppInstance() { return static_cast<QApplication *>(QCoreApplication::instance()); }
 struct ::TabletProximityRec;
@@ -165,6 +162,29 @@ Qt::KeyboardModifiers qt_cocoaDragOperation2QtModifiers(uint dragOperations);
 QPixmap qt_mac_convert_iconref(const IconRef icon, int width, int height);
 void qt_mac_constructQIconFromIconRef(const IconRef icon, const IconRef overlayIcon, QIcon *retIcon,
                                       QStyle::StandardPixmap standardIcon = QStyle::SP_CustomBase);
+
+#if QT_MAC_USE_COCOA && __OBJC__
+struct DnDParams
+{
+    NSView *view;
+    NSEvent *theEvent;
+    QPoint globalPoint;
+    NSDragOperation performedAction;
+};
+
+DnDParams *macCurrentDnDParameters();
+NSDragOperation qt_mac_mapDropAction(Qt::DropAction action);
+NSDragOperation qt_mac_mapDropActions(Qt::DropActions actions);
+Qt::DropAction qt_mac_mapNSDragOperation(NSDragOperation nsActions);
+Qt::DropActions qt_mac_mapNSDragOperations(NSDragOperation nsActions);
+
+QWidget *qt_mac_getTargetForKeyEvent(QWidget *widgetThatReceivedEvent);
+QWidget *qt_mac_getTargetForMouseEvent(NSEvent *event, QEvent::Type eventType,
+    QPoint &returnLocalPoint, QPoint &returnGlobalPoint, QWidget *nativeWidget, QWidget **returnWidgetUnderMouse);
+bool qt_mac_handleMouseEvent(NSEvent *event, QEvent::Type eventType, Qt::MouseButton button, QWidget *nativeWidget);
+void qt_mac_handleNonClientAreaMouseEvent(NSWindow *window, NSEvent *event);
+#endif
+
 inline int flipYCoordinate(int y)
 {
     return QApplication::desktop()->screenGeometry(0).height() - y;    
@@ -221,10 +241,64 @@ public:
     }
 };
 void qt_cocoaPostMessage(id target, SEL selector, int argCount=0, id arg1=0, id arg2=0);
+void qt_cocoaPostMessageAfterEventLoopExit(id target, SEL selector, int argCount=0, id arg1=0, id arg2=0);
 #endif
 
 #endif
 
+class QMacScrollOptimization {
+    // This class is made to optimize for the case when the user
+    // scrolls both horizontally and vertically at the same
+    // time. This will result in two QWheelEvents (one for each
+    // direction), which will typically result in two calls to
+    // QWidget::_scroll_sys. Rather than copying pixels twize on
+    // screen because of this, we add this helper class to try to
+    // get away with only one blit.
+    static QWidgetPrivate *_target;
+    static bool _inWheelEvent;
+    static int _dx;
+    static int _dy;
+    static QRect _scrollRect;
+
+public:
+    static void initDelayedScroll()
+    {
+        _inWheelEvent = true;
+    }
+
+    static bool delayScroll(QWidgetPrivate *target, int dx, int dy, const QRect &scrollRect)
+    {
+        if (!_inWheelEvent)
+            return false;
+        if (_target && _target != target)
+            return false;
+        if (_scrollRect.width() != -1 && _scrollRect != scrollRect)
+            return false;
+
+        _target = target;
+        _dx += dx;
+        _dy += dy;
+        _scrollRect = scrollRect;
+        return true;
+    }
+
+    static void performDelayedScroll()
+    {
+        if (!_inWheelEvent)
+            return;
+        _inWheelEvent = false;
+        if (!_target)
+            return;
+
+        _target->scroll_sys(_dx, _dy, _scrollRect);
+
+        _target = 0;
+        _dx = 0;
+        _dy = 0;
+        _scrollRect = QRect(0, 0, -1, -1);
+    }
+};
+
 void qt_mac_post_retranslateAppMenu();
 
 void qt_mac_display(QWidget *widget);
diff --git a/src/gui/kernel/qt_s60_p.h b/src/gui/kernel/qt_s60_p.h
index fdb35d5..40697bf 100644
--- a/src/gui/kernel/qt_s60_p.h
+++ b/src/gui/kernel/qt_s60_p.h
@@ -141,6 +141,7 @@ public:
     int supportsPremultipliedAlpha : 1;
     int avkonComponentsSupportTransparency : 1;
     int menuBeingConstructed : 1;
+    int orientationSet : 1;
     QApplication::QS60MainApplicationFactory s60ApplicationFactory; // typedef'ed pointer type
     static CEikButtonGroupContainer *cba;
 
@@ -295,6 +296,7 @@ inline QS60Data::QS60Data()
   supportsPremultipliedAlpha(0),
   avkonComponentsSupportTransparency(0),
   menuBeingConstructed(0),
+  orientationSet(0),
   s60ApplicationFactory(0)
 #ifdef Q_OS_SYMBIAN
   ,s60InstalledTrapHandler(0)
diff --git a/src/gui/kernel/qwidget.cpp b/src/gui/kernel/qwidget.cpp
index 4ba0ef8..bf9f6f9 100644
--- a/src/gui/kernel/qwidget.cpp
+++ b/src/gui/kernel/qwidget.cpp
@@ -127,6 +127,10 @@
 #include "qtabwidget.h" // Needed in inTabWidget()
 #endif // QT_KEYPAD_NAVIGATION
 
+#ifdef Q_WS_S60
+#include <aknappui.h>
+#endif
+
 // widget/widget data creation count
 //#define QWIDGET_EXTRA_DEBUG
 //#define ALIEN_DEBUG
@@ -144,6 +148,10 @@ Q_GUI_EXPORT void qt_x11_set_global_double_buffer(bool enable)
 }
 #endif
 
+#if defined(QT_MAC_USE_COCOA)
+bool qt_mac_clearDirtyOnWidgetInsideDrawWidget = false;
+#endif
+
 static inline bool qRectIntersects(const QRect &r1, const QRect &r2)
 {
     return (qMax(r1.left(), r2.left()) <= qMin(r1.right(), r2.right()) &&
@@ -300,7 +308,6 @@ QWidgetPrivate::QWidgetPrivate(int version)
   #endif
 #elif defined(Q_WS_MAC)
       , needWindowChange(0)
-      , hasAlienChildren(0)
       , window_event(0)
       , qd_hd(0)
 #endif
@@ -322,6 +329,7 @@ QWidgetPrivate::QWidgetPrivate(int version)
     hasOwnContext = false;
     isInUnifiedToolbar = false;
     unifiedSurface = 0;
+    touchEventsEnabled = false;
 #endif // QT_MAC_USE_COCOA
 #ifdef QWIDGET_EXTRA_DEBUG
     static int count = 0;
@@ -395,11 +403,24 @@ void QWidgetPrivate::scrollChildren(int dx, int dy)
     }
 }
 
+QInputContext *QWidgetPrivate::assignedInputContext() const
+{
+#ifndef QT_NO_IM
+    const QWidget *widget = q_func();
+    while (widget) {
+        if (QInputContext *qic = widget->d_func()->ic)
+            return qic;
+        widget = widget->parentWidget();
+    }
+#endif
+    return 0;
+}
+
 QInputContext *QWidgetPrivate::inputContext() const
 {
 #ifndef QT_NO_IM
-    if (ic)
-        return ic;
+    if (QInputContext *qic = assignedInputContext())
+        return qic;
     return qApp->inputContext();
 #else
     return 0;
@@ -1303,9 +1324,9 @@ void QWidgetPrivate::init(QWidget *parentWidget, Qt::WindowFlags f)
     if (f & Qt::MSWindowsOwnDC)
         q->setAttribute(Qt::WA_NativeWindow);
 
-#ifdef Q_WS_MAC
-    q->setAttribute(Qt::WA_NativeWindow);
-#endif
+//#ifdef Q_WS_MAC
+//    q->setAttribute(Qt::WA_NativeWindow);
+//#endif
 
     q->setAttribute(Qt::WA_QuitOnClose); // might be cleared in adjustQuitOnCloseAttribute()
     adjustQuitOnCloseAttribute();
@@ -1412,10 +1433,6 @@ void QWidget::create(WId window, bool initializeWindow, bool destroyOldWindow)
 
 #ifndef Q_WS_QPA
     if (QWidget *parent = parentWidget()) {
-#ifdef Q_WS_MAC
-        if (testAttribute(Qt::WA_NativeWindow) == false)
-            parent->d_func()->hasAlienChildren = true;
-#endif
         if (type & Qt::Window) {
             if (!parent->testAttribute(Qt::WA_WState_Created))
                 parent->createWinId();
@@ -5399,6 +5416,9 @@ void QWidgetPrivate::drawWidget(QPaintDevice *pdev, const QRegion &rgn, const QP
         return;
 
 #if defined(Q_WS_MAC) && defined(QT_MAC_USE_COCOA)
+    if (qt_mac_clearDirtyOnWidgetInsideDrawWidget)
+        dirtyOnWidget = QRegion();
+
     // We disable the rendering of QToolBar in the backingStore if
     // it's supposed to be in the unified toolbar on Mac OS X.
     if (backingStore && isInUnifiedToolbar)
@@ -5486,7 +5506,6 @@ void QWidgetPrivate::drawWidget(QPaintDevice *pdev, const QRegion &rgn, const QP
                 //paint the background
                 if ((asRoot || q->autoFillBackground() || onScreen || q->testAttribute(Qt::WA_StyledBackground))
                     && !q->testAttribute(Qt::WA_OpaquePaintEvent) && !q->testAttribute(Qt::WA_NoSystemBackground)) {
-
                     QPainter p(q);
                     paintBackground(&p, toBePainted, (asRoot || onScreen) ? flags | DrawAsRoot : 0);
                 }
@@ -5668,10 +5687,12 @@ void QWidgetPrivate::paintSiblingsRecursive(QPaintDevice *pdev, const QObjectLis
     QRect boundingRect;
     bool dirtyBoundingRect = true;
     const bool exludeOpaqueChildren = (flags & DontDrawOpaqueChildren);
+    const bool excludeNativeChildren = (flags & DontDrawNativeChildren);
 
     do {
         QWidget *x =  qobject_cast<QWidget*>(siblings.at(index));
-        if (x && !(exludeOpaqueChildren && x->d_func()->isOpaque) && !x->isHidden() && !x->isWindow()) {
+        if (x && !(exludeOpaqueChildren && x->d_func()->isOpaque) && !x->isHidden() && !x->isWindow()
+            && !(excludeNativeChildren && x->internalWinId())) {
             if (dirtyBoundingRect) {
                 boundingRect = rgn.boundingRect();
                 dirtyBoundingRect = false;
@@ -10075,7 +10096,13 @@ void QWidget::setParent(QWidget *parent, Qt::WindowFlags f)
 
 #if defined(Q_WS_X11) || defined(Q_WS_WIN) || defined(Q_WS_MAC) || defined(Q_OS_SYMBIAN)
     if (newParent && parent && !desktopWidget) {
-        if (testAttribute(Qt::WA_NativeWindow) && !qApp->testAttribute(Qt::AA_DontCreateNativeWidgetSiblings))
+        if (testAttribute(Qt::WA_NativeWindow) && !qApp->testAttribute(Qt::AA_DontCreateNativeWidgetSiblings)
+#if defined(Q_WS_MAC) && defined(QT_MAC_USE_COCOA)
+            // On Mac, toolbars inside the unified title bar will never overlap with
+            // siblings in the content view. So we skip enforce native siblings in that case
+            && !d->isInUnifiedToolbar && parentWidget() && parentWidget()->isWindow()
+#endif // Q_WS_MAC && QT_MAC_USE_COCOA
+        )
             parent->d_func()->enforceNativeChildren();
         else if (parent->d_func()->nativeChildrenForced() || parent->testAttribute(Qt::WA_PaintOnScreen))
             setAttribute(Qt::WA_NativeWindow);
@@ -10722,7 +10749,13 @@ void QWidget::setAttribute(Qt::WidgetAttribute attribute, bool on)
                 ic->setFocusWidget(0);
             }
         }
-        if (!qApp->testAttribute(Qt::AA_DontCreateNativeWidgetSiblings) && parentWidget())
+        if (!qApp->testAttribute(Qt::AA_DontCreateNativeWidgetSiblings) && parentWidget()
+#if defined(Q_WS_MAC) && defined(QT_MAC_USE_COCOA)
+            // On Mac, toolbars inside the unified title bar will never overlap with
+            // siblings in the content view. So we skip enforce native siblings in that case
+            && !d->isInUnifiedToolbar && parentWidget()->isWindow()
+#endif // Q_WS_MAC && QT_MAC_USE_COCOA
+        )
             parentWidget()->d_func()->enforceNativeChildren();
         if (on && !internalWinId() && testAttribute(Qt::WA_WState_Created))
             d->createWinId();
@@ -10762,7 +10795,7 @@ void QWidget::setAttribute(Qt::WidgetAttribute attribute, bool on)
     case Qt::WA_InputMethodEnabled: {
 #ifndef QT_NO_IM
         QWidget *focusWidget = d->effectiveFocusWidget();
-        QInputContext *ic = focusWidget->d_func()->ic;
+        QInputContext *ic = focusWidget->d_func()->assignedInputContext();
         if (!ic && (!on || hasFocus()))
             ic = focusWidget->d_func()->inputContext();
         if (ic) {
@@ -10855,6 +10888,42 @@ void QWidget::setAttribute(Qt::WidgetAttribute attribute, bool on)
             d->registerTouchWindow();
 #endif
         break;
+    case Qt::WA_LockPortraitOrientation:
+    case Qt::WA_LockLandscapeOrientation:
+    case Qt::WA_AutoOrientation: {
+        const Qt::WidgetAttribute orientations[3] = {
+            Qt::WA_LockPortraitOrientation,
+            Qt::WA_LockLandscapeOrientation,
+            Qt::WA_AutoOrientation
+        };
+
+        if (on) {
+            // We can only have one of these set at a time
+            for (int i = 0; i < 3; ++i) {
+                if (orientations[i] != attribute)
+                    setAttribute_internal(orientations[i], false, data, d);
+            }
+        }
+
+#ifdef Q_WS_S60
+        CAknAppUiBase* appUi = static_cast<CAknAppUiBase*>(CEikonEnv::Static()->EikAppUi());
+        const CAknAppUiBase::TAppUiOrientation s60orientations[] = {
+            CAknAppUiBase::EAppUiOrientationPortrait,
+            CAknAppUiBase::EAppUiOrientationLandscape,
+            CAknAppUiBase::EAppUiOrientationAutomatic
+        };
+        CAknAppUiBase::TAppUiOrientation s60orientation = CAknAppUiBase::EAppUiOrientationUnspecified;
+        for (int i = 0; i < 3; ++i) {
+            if (testAttribute(orientations[i])) {
+                s60orientation = s60orientations[i];
+                break;
+            }
+        }
+        QT_TRAP_THROWING(appUi->SetOrientationL(s60orientation));
+        S60->orientationSet = true;
+#endif
+        break;
+    }
     default:
         break;
     }
@@ -11213,7 +11282,7 @@ void QWidget::updateMicroFocus()
 #if !defined(QT_NO_IM) && (defined(Q_WS_X11) || defined(Q_WS_QWS) || defined(Q_OS_SYMBIAN))
     Q_D(QWidget);
     // and optimization to update input context only it has already been created.
-    if (d->ic || qApp->d_func()->inputContext) {
+    if (d->assignedInputContext() || qApp->d_func()->inputContext) {
         QInputContext *ic = inputContext();
         if (ic)
             ic->update();
diff --git a/src/gui/kernel/qwidget_mac.mm b/src/gui/kernel/qwidget_mac.mm
index 376999e..9a5a5f1 100644
--- a/src/gui/kernel/qwidget_mac.mm
+++ b/src/gui/kernel/qwidget_mac.mm
@@ -155,7 +155,6 @@ static bool qt_mac_raise_process = true;
 static OSWindowRef qt_root_win = 0;
 QWidget *mac_mouse_grabber = 0;
 QWidget *mac_keyboard_grabber = 0;
-extern QPointer<QWidget> qt_button_down; //qapplication_mac.cpp
 
 #ifndef QT_MAC_USE_COCOA
 #ifdef QT_NAMESPACE
@@ -179,13 +178,15 @@ static CFStringRef kObjectQWidget = CFSTR("com.trolltech.qt.widget");
 /*****************************************************************************
   Externals
  *****************************************************************************/
+extern QPointer<QWidget> qt_button_down; //qapplication_mac.cpp
 extern QWidget *qt_mac_modal_blocked(QWidget *); //qapplication_mac.mm
 extern void qt_event_request_activate(QWidget *); //qapplication_mac.mm
 extern bool qt_event_remove_activate(); //qapplication_mac.mm
 extern void qt_mac_event_release(QWidget *w); //qapplication_mac.mm
 extern void qt_event_request_showsheet(QWidget *); //qapplication_mac.mm
 extern void qt_event_request_window_change(QWidget *); //qapplication_mac.mm
-extern QPointer<QWidget> qt_mouseover; //qapplication_mac.mm
+extern QPointer<QWidget> qt_last_mouse_receiver; //qapplication_mac.mm
+extern QPointer<QWidget> qt_last_native_mouse_receiver; //qt_cocoa_helpers_mac.mm
 extern IconRef qt_mac_create_iconref(const QPixmap &); //qpixmap_mac.cpp
 extern void qt_mac_set_cursor(const QCursor *, const QPoint &); //qcursor_mac.mm
 extern void qt_mac_update_cursor(); //qcursor_mac.mm
@@ -193,7 +194,8 @@ extern bool qt_nograb();
 extern CGImageRef qt_mac_create_cgimage(const QPixmap &, bool); //qpixmap_mac.cpp
 extern RgnHandle qt_mac_get_rgn(); //qregion_mac.cpp
 extern QRegion qt_mac_convert_mac_region(RgnHandle rgn); //qregion_mac.cpp
-
+extern void qt_mac_setMouseGrabCursor(bool set, QCursor *cursor = 0); // qcursor_mac.mm
+extern QPointer<QWidget> topLevelAt_cache; // qapplication_mac.mm
 /*****************************************************************************
   QWidget utility functions
  *****************************************************************************/
@@ -217,22 +219,13 @@ static QSize qt_mac_desktopSize()
 #ifdef QT_MAC_USE_COCOA
 static NSDrawer *qt_mac_drawer_for(const QWidget *widget)
 {
-    // This only goes one level below the content view so start with the window.
-    // This works fine for straight Qt stuff, but runs into problems if we are
-    // embedding, but if that's the case, they probably want to be using
-    // NSDrawer directly.
-    NSView *widgetView = reinterpret_cast<NSView *>(widget->window()->winId());
+    NSView *widgetView = reinterpret_cast<NSView *>(widget->window()->effectiveWinId());
     NSArray *windows = [NSApp windows];
     for (NSWindow *window in windows) {
         NSArray *drawers = [window drawers];
         for (NSDrawer *drawer in drawers) {
             if ([drawer contentView] == widgetView)
                 return drawer;
-            NSArray *views = [[drawer contentView] subviews];
-            for (NSView *view in views) {
-                if (view == widgetView)
-                    return drawer;
-            }
         }
     }
     return 0;
@@ -314,7 +307,7 @@ bool qt_mac_is_macdrawer(const QWidget *w)
 bool qt_mac_insideKeyWindow(const QWidget *w)
 {
 #ifdef QT_MAC_USE_COCOA
-    return [[reinterpret_cast<NSView *>(w->winId()) window] isKeyWindow];
+    return [[reinterpret_cast<NSView *>(w->effectiveWinId()) window] isKeyWindow];
 #else
     Q_UNUSED(w);
 #endif
@@ -421,7 +414,14 @@ inline static void qt_mac_set_fullscreen_mode(bool b)
 
 Q_GUI_EXPORT OSViewRef qt_mac_nativeview_for(const QWidget *w)
 {
-    return reinterpret_cast<OSViewRef>(w->data->winid);
+    return reinterpret_cast<OSViewRef>(w->internalWinId());
+}
+
+Q_GUI_EXPORT OSViewRef qt_mac_effectiveview_for(const QWidget *w)
+{
+    // Get the first non-alien (parent) widget for
+    // w, and return its NSView (if it has one):
+    return reinterpret_cast<OSViewRef>(w->effectiveWinId());
 }
 
 Q_GUI_EXPORT OSViewRef qt_mac_get_contentview_for(OSWindowRef w)
@@ -479,11 +479,12 @@ bool qt_isGenuineQWidget(const QWidget *window)
 
 Q_GUI_EXPORT OSWindowRef qt_mac_window_for(const QWidget *w)
 {
-    OSViewRef hiview = qt_mac_nativeview_for(w);
-    if (hiview){
+    if (OSViewRef hiview = qt_mac_effectiveview_for(w)) {
         OSWindowRef window = qt_mac_window_for(hiview);
-        if (!window && qt_isGenuineQWidget(hiview)) {
-            QWidget *myWindow = w->window();
+        if (window)
+            return window;
+
+        if (qt_isGenuineQWidget(hiview)) {
             // This is a workaround for NSToolbar. When a widget is hidden
             // by clicking the toolbar button, Cocoa reparents the widgets
             // to another window (but Qt doesn't know about it).
@@ -491,18 +492,22 @@ Q_GUI_EXPORT OSWindowRef qt_mac_window_for(const QWidget *w)
             // but at this point it's window is nil, but the window it's being brought
             // into (the Qt one) is for sure created.
             // This stops the hierarchy moving under our feet.
-            if (myWindow != w && qt_mac_window_for(qt_mac_nativeview_for(myWindow)))
-                return qt_mac_window_for(qt_mac_nativeview_for(myWindow));
+            QWidget *toplevel = w->window();
+            if (toplevel != w) {
+                hiview = qt_mac_nativeview_for(toplevel);
+                if (OSWindowRef w = qt_mac_window_for(hiview))
+                    return w;
+            }
 
-            myWindow->d_func()->createWindow_sys();
-            // Reget the hiview since the "create window could potentially move the view (I guess).
-            hiview = qt_mac_nativeview_for(w);
-            window = qt_mac_window_for(hiview);
+            toplevel->d_func()->createWindow_sys();
+            // Reget the hiview since "create window" could potentially move the view (I guess).
+            hiview = qt_mac_nativeview_for(toplevel);
+            return qt_mac_window_for(hiview);
         }
-        return window;
     }
     return 0;
 }
+
 #ifndef QT_MAC_USE_COCOA
 /*  Checks if the current group is a 'stay on top' group. If so, the
     group gets removed from the hash table */
@@ -580,25 +585,6 @@ inline static void qt_mac_set_window_group_to_popup(OSWindowRef window)
 }
 #endif
 
-#ifdef QT_MAC_USE_COCOA
-void qt_mac_set_needs_display(QWidget *widget, QRegion region)
-{
-    NSView *theNSView = qt_mac_nativeview_for(widget);
-    if (region.isEmpty()) {
-        [theNSView setNeedsDisplay:YES];
-        return;
-    }
-
-    QVector<QRect> rects = region.rects();
-    for (int i = 0; i<rects.count(); ++i) {
-        const QRect &rect = rects.at(i);
-        NSRect nsrect = NSMakeRect(rect.x(), rect.y(), rect.width(), rect.height());
-        [theNSView setNeedsDisplayInRect:nsrect];
-    }
-
-}
-#endif
-
 inline static bool updateRedirectedToGraphicsProxyWidget(QWidget *widget, const QRect &rect)
 {
     if (!widget)
@@ -636,6 +622,51 @@ inline static bool updateRedirectedToGraphicsProxyWidget(QWidget *widget, const
     return false;
 }
 
+void QWidgetPrivate::macSetNeedsDisplay(QRegion region)
+{
+    Q_Q(QWidget);
+#ifndef QT_MAC_USE_COCOA
+    if (region.isEmpty())
+        HIViewSetNeedsDisplay(qt_mac_nativeview_for(q), true);
+    else if (RgnHandle rgnHandle = region.toQDRgnForUpdate_sys())
+        HIViewSetNeedsDisplayInRegion(qt_mac_nativeview_for(q), QMacSmartQuickDrawRegion(rgnHandle), true);
+    else
+        HIViewSetNeedsDisplay(qt_mac_nativeview_for(q), true); // do a complete repaint on overflow.
+#else
+    if (NSView *nativeView = qt_mac_nativeview_for(q)) {
+        // INVARIANT: q is _not_ alien. So we can optimize a little:
+        if (region.isEmpty()) {
+            [nativeView setNeedsDisplay:YES];
+        } else {
+            QVector<QRect> rects = region.rects();
+            for (int i = 0; i<rects.count(); ++i) {
+                const QRect &rect = rects.at(i);
+                NSRect nsrect = NSMakeRect(rect.x(), rect.y(), rect.width(), rect.height());
+                [nativeView setNeedsDisplayInRect:nsrect];
+            }
+        }
+    } else if (QWidget *effectiveWidget = q->nativeParentWidget()) {
+        // INVARIANT: q is alien, and effectiveWidget is native.
+        if (NSView *effectiveView = qt_mac_nativeview_for(effectiveWidget)) {
+            if (region.isEmpty()) {
+                const QRect &rect = q->rect();
+                QPoint p = q->mapTo(effectiveWidget, rect.topLeft());
+                NSRect nsrect = NSMakeRect(p.x(), p.y(), rect.width(), rect.height());
+                [effectiveView setNeedsDisplayInRect:nsrect];
+            } else {
+                QVector<QRect> rects = region.rects();
+                for (int i = 0; i<rects.count(); ++i) {
+                    const QRect &rect = rects.at(i);
+                    QPoint p = q->mapTo(effectiveWidget, rect.topLeft());
+                    NSRect nsrect = NSMakeRect(p.x(), p.y(), rect.width(), rect.height());
+                    [effectiveView setNeedsDisplayInRect:nsrect];
+                }
+            }
+        }
+    }
+#endif
+}
+
 void QWidgetPrivate::macUpdateIsOpaque()
 {
     Q_Q(QWidget);
@@ -1569,6 +1600,11 @@ OSViewRef qt_mac_create_widget(QWidget *widget, QWidgetPrivate *widgetPrivate, O
 #ifdef QT_MAC_USE_COCOA
     QMacCocoaAutoReleasePool pool;
     QT_MANGLE_NAMESPACE(QCocoaView) *view = [[QT_MANGLE_NAMESPACE(QCocoaView) alloc] initWithQWidget:widget widgetPrivate:widgetPrivate];
+
+#ifdef ALIEN_DEBUG
+    qDebug() << "Creating NSView for" << widget;
+#endif
+
     if (view && parent)
         [parent addSubview:view];
     return view;
@@ -1635,7 +1671,7 @@ bool QWidgetPrivate::qt_mac_update_sizer(QWidget *w, int up)
     // to happen, prevent that here (you really want the thing hidden).
     if (up >= 0 || topData->resizer != 0)
         topData->resizer += up;
-    OSWindowRef windowRef = qt_mac_window_for(OSViewRef(w->winId()));
+    OSWindowRef windowRef = qt_mac_window_for(OSViewRef(w->effectiveWinId()));
     {
 #ifndef QT_MAC_USE_COCOA
         WindowClass wclass;
@@ -1670,6 +1706,7 @@ bool QWidgetPrivate::qt_mac_update_sizer(QWidget *w, int up)
 void QWidgetPrivate::qt_clean_root_win()
 {
 #ifdef QT_MAC_USE_COCOA
+    QMacCocoaAutoReleasePool pool;
     [qt_root_win release];
 #else
     if(!qt_root_win)
@@ -2310,15 +2347,12 @@ void QWidgetPrivate::finishCreateWindow_sys_Cocoa(void * /*NSWindow * */ voidWin
     }
     [windowRef setContentView:nsview];
     [nsview setHidden:NO];
-    if (q->testAttribute(Qt::WA_DropSiteRegistered))
-        registerDropSite(true);
     transferChildren();
 
     // Tell Cocoa explicit that we wan't the view to receive key events
     // (regardless of focus policy) because this is how it works on other
     // platforms (and in the carbon port):
-    if (!qApp->focusWidget())
-        [windowRef makeFirstResponder:nsview];
+    [windowRef makeFirstResponder:nsview];
 
     if (topExtra->posFromMove) {
         updateFrameStrut();
@@ -2349,8 +2383,9 @@ void QWidgetPrivate::finishCreateWindow_sys_Cocoa(void * /*NSWindow * */ voidWin
         q->setAttribute(Qt::WA_WState_WindowOpacitySet, false);
     }
 
-    if (qApp->overrideCursor())
-        [windowRef disableCursorRects];
+    // Its more performant to handle the mouse cursor
+    // ourselves, expecially when using alien widgets:
+    [windowRef disableCursorRects];
 
     setWindowLevel();
     macUpdateHideOnSuspend();
@@ -2468,8 +2503,6 @@ void QWidgetPrivate::create_sys(WId window, bool initializeWindow, bool destroyO
         data.crect.setRect(0, 0, desktopSize.width(), desktopSize.height());
         dialog = popup = false;                  // force these flags off
     } else {
-        q->setAttribute(Qt::WA_WState_Visible, false);
-
         if (topLevel && (type != Qt::Drawer)) {
             if (QDesktopWidget *dsk = QApplication::desktop()) { // calc pos/size from screen
                 const bool wasResized = q->testAttribute(Qt::WA_Resized);
@@ -2559,6 +2592,8 @@ void QWidgetPrivate::create_sys(WId window, bool initializeWindow, bool destroyO
                 transfer = true;
         } else if (parentWidget) {
             // I need to be added to my parent, therefore my parent needs an NSView
+            // Alien note: a 'window' was supplied as argument, meaning this widget
+            // is not alien. So therefore the parent cannot be alien either.
             parentWidget->createWinId();
             parent = qt_mac_nativeview_for(parentWidget);
         }
@@ -2630,11 +2665,8 @@ void QWidgetPrivate::create_sys(WId window, bool initializeWindow, bool destroyO
         data.fstrut_dirty = false; // non-toplevel widgets don't have a frame, so no need to update the strut
 
 #ifdef QT_MAC_USE_COCOA
-        if (q->testAttribute(Qt::WA_NativeWindow) == false ||
-            q->internalWinId() != 0) {
-#ifdef ALIEN_DEBUG
-            qDebug() << "Skipping native widget creation for" << this;
-#endif
+        if (q->testAttribute(Qt::WA_NativeWindow) == false || q->internalWinId() != 0) {
+            // INVARIANT: q is Alien, and we should not create an NSView to back it up.
         } else
 #endif
         if (OSViewRef osview = qt_mac_create_widget(q, this, qt_mac_nativeview_for(parentWidget))) {
@@ -2646,21 +2678,26 @@ void QWidgetPrivate::create_sys(WId window, bool initializeWindow, bool destroyO
             NSRect bounds = NSMakeRect(data.crect.x(), data.crect.y(), data.crect.width(), data.crect.height());
             [osview setFrame:bounds];
             setWinId((WId)osview);
+            if (q->isVisible()) {
+                // If q were Alien before, but now became native (e.g. if a call to
+                // winId was done from somewhere), we need to show the view immidiatly:
+                QMacCocoaAutoReleasePool pool;
+                [osview setHidden:NO];
+            }
 #endif
-            if (q->testAttribute(Qt::WA_DropSiteRegistered))
-                registerDropSite(true);
         }
     }
 
     updateIsOpaque();
+
+    if (q->testAttribute(Qt::WA_DropSiteRegistered))
+        registerDropSite(true);
     if (q->hasFocus())
         setFocus_sys();
     if (!topLevel && initializeWindow)
         setWSGeometry();
     if (destroyid)
         qt_mac_destructView(destroyid);
-    if (q->testAttribute(Qt::WA_AcceptTouchEvents))
-        registerTouchWindow();
 }
 
 /*!
@@ -2694,16 +2731,29 @@ QWidget::macCGHandle() const
     return handle();
 }
 
+void qt_mac_repaintParentUnderAlienWidget(QWidget *alienWidget)
+{
+    QWidget *nativeParent = alienWidget->nativeParentWidget();
+    if (!nativeParent)
+        return;
+
+    QPoint globalPos = alienWidget->mapToGlobal(QPoint(0, 0));
+    QRect dirtyRect = QRect(nativeParent->mapFromGlobal(globalPos), alienWidget->size());
+    nativeParent->repaint(dirtyRect);
+}
+
 void QWidget::destroy(bool destroyWindow, bool destroySubWindows)
 {
     Q_D(QWidget);
+    QMacCocoaAutoReleasePool pool;
     d->aboutToDestroy();
     if (!isWindow() && parentWidget())
         parentWidget()->d_func()->invalidateBuffer(d->effectiveRectFor(geometry()));
+    if (!internalWinId())
+        qt_mac_repaintParentUnderAlienWidget(this);
     d->deactivateWidgetCleanup();
     qt_mac_event_release(this);
     if(testAttribute(Qt::WA_WState_Created)) {
-        QMacCocoaAutoReleasePool pool;
         setAttribute(Qt::WA_WState_Created, false);
         QObjectList chldrn = children();
         for(int i = 0; i < chldrn.size(); i++) {  // destroy all widget children
@@ -2759,7 +2809,7 @@ void QWidget::destroy(bool destroyWindow, bool destroySubWindows)
 void QWidgetPrivate::transferChildren()
 {
     Q_Q(QWidget);
-    if (!q->testAttribute(Qt::WA_WState_Created))
+    if (!q->internalWinId())
         return;  // Can't add any views anyway
 
     QObjectList chlist = q->children();
@@ -2771,7 +2821,7 @@ void QWidgetPrivate::transferChildren()
                 // This seems weird, no need to call it in a loop right?
                 if (!topData()->caption.isEmpty())
                     setWindowTitle_helper(extra->topextra->caption);
-                if (w->testAttribute(Qt::WA_WState_Created)) {
+                if (w->internalWinId()) {
 #ifndef QT_MAC_USE_COCOA
                     HIViewAddSubview(qt_mac_nativeview_for(q), qt_mac_nativeview_for(w));
 #else
@@ -2900,11 +2950,11 @@ void QWidgetPrivate::setParent_sys(QWidget *parent, Qt::WindowFlags f)
 #ifndef QT_MAC_USE_COCOA
         old_window_event = window_event;
 #else
-        OSWindowRef oldWindow = qt_mac_window_for(old_id);
         if (qt_mac_is_macdrawer(q)) {
             oldDrawer = qt_mac_drawer_for(q);
         }
         if (wasWindow) {
+            OSWindowRef oldWindow = qt_mac_window_for(old_id);
             oldToolbar = [oldWindow toolbar];
             if (oldToolbar) {
                 [oldToolbar retain];
@@ -3026,7 +3076,7 @@ void QWidgetPrivate::setParent_sys(QWidget *parent, Qt::WindowFlags f)
 QPoint QWidget::mapToGlobal(const QPoint &pos) const
 {
     Q_D(const QWidget);
-    if (!testAttribute(Qt::WA_WState_Created) || !internalWinId()) {
+    if (!internalWinId()) {
         QPoint p = pos + data->crect.topLeft();
         return isWindow() ?  p : parentWidget()->mapToGlobal(p);
     }
@@ -3053,7 +3103,7 @@ QPoint QWidget::mapToGlobal(const QPoint &pos) const
 QPoint QWidget::mapFromGlobal(const QPoint &pos) const
 {
     Q_D(const QWidget);
-    if (!testAttribute(Qt::WA_WState_Created) || !internalWinId()) {
+    if (!internalWinId()) {
         QPoint p = isWindow() ?  pos : parentWidget()->mapFromGlobal(pos);
         return p - data->crect.topLeft();
     }
@@ -3080,28 +3130,12 @@ void QWidgetPrivate::updateSystemBackground()
 
 void QWidgetPrivate::setCursor_sys(const QCursor &)
 {
-#ifndef QT_MAC_USE_COCOA
     qt_mac_update_cursor();
-#else
-     Q_Q(QWidget);
-    if (q->testAttribute(Qt::WA_WState_Created)) {
-        QMacCocoaAutoReleasePool pool;
-        [qt_mac_window_for(q) invalidateCursorRectsForView:qt_mac_nativeview_for(q)];
-    }
-#endif
 }
 
 void QWidgetPrivate::unsetCursor_sys()
 {
-#ifndef QT_MAC_USE_COCOA
     qt_mac_update_cursor();
-#else
-     Q_Q(QWidget);
-    if (q->testAttribute(Qt::WA_WState_Created)) {
-        QMacCocoaAutoReleasePool pool;
-        [qt_mac_window_for(q) invalidateCursorRectsForView:qt_mac_nativeview_for(q)];
-    }
-#endif
 }
 
 void QWidgetPrivate::setWindowTitle_sys(const QString &caption)
@@ -3243,24 +3277,28 @@ void QWidget::grabMouse()
         if(mac_mouse_grabber)
             mac_mouse_grabber->releaseMouse();
         mac_mouse_grabber=this;
+        qt_mac_setMouseGrabCursor(true);
     }
 }
 
 #ifndef QT_NO_CURSOR
-void QWidget::grabMouse(const QCursor &)
+void QWidget::grabMouse(const QCursor &cursor)
 {
     if(isVisible() && !qt_nograb()) {
         if(mac_mouse_grabber)
             mac_mouse_grabber->releaseMouse();
         mac_mouse_grabber=this;
+        qt_mac_setMouseGrabCursor(true, const_cast<QCursor *>(&cursor));
     }
 }
 #endif
 
 void QWidget::releaseMouse()
 {
-    if(!qt_nograb() && mac_mouse_grabber == this)
+    if(!qt_nograb() && mac_mouse_grabber == this) {
         mac_mouse_grabber = 0;
+        qt_mac_setMouseGrabCursor(false);
+    }
 }
 
 void QWidget::grabKeyboard()
@@ -3345,35 +3383,10 @@ QWindowSurface *QWidgetPrivate::createDefaultWindowSurface_sys()
 void QWidgetPrivate::update_sys(const QRect &r)
 {
     Q_Q(QWidget);
-    if (r == q->rect()) {
-        if (updateRedirectedToGraphicsProxyWidget(q, r))
-            return;
-        dirtyOnWidget += r;
-#ifndef QT_MAC_USE_COCOA
-            HIViewSetNeedsDisplay(qt_mac_nativeview_for(q), true);
-#else
-	    qt_mac_set_needs_display(q, QRegion());
-#endif
+    if (updateRedirectedToGraphicsProxyWidget(q, r))
         return;
-    }
-
-    int x = r.x(), y = r.y(), w = r.width(), h = r.height();
-    if (w < 0)
-        w = q->data->crect.width() - x;
-    if (h < 0)
-        h = q->data->crect.height() - y;
-    if (w && h) {
-        const QRect updateRect = QRect(x, y, w, h);
-        if (updateRedirectedToGraphicsProxyWidget(q, updateRect))
-            return;
-#ifndef QT_MAC_USE_COCOA
-        dirtyOnWidget += updateRect;
-        HIRect r = CGRectMake(x, y, w, h);
-        HIViewSetNeedsDisplayInRect(qt_mac_nativeview_for(q), &r, true);
-#else
-        [qt_mac_nativeview_for(q) setNeedsDisplayInRect:NSMakeRect(x, y, w, h)];
-#endif
-    }
+    dirtyOnWidget += r;
+    macSetNeedsDisplay(r != q->rect() ? r : QRegion());
 }
 
 void QWidgetPrivate::update_sys(const QRegion &rgn)
@@ -3382,33 +3395,7 @@ void QWidgetPrivate::update_sys(const QRegion &rgn)
     if (updateRedirectedToGraphicsProxyWidget(q, rgn))
         return;
     dirtyOnWidget += rgn;
-#ifndef QT_MAC_USE_COCOA
-    RgnHandle rgnHandle = rgn.toQDRgnForUpdate_sys();
-    if (rgnHandle)
-        HIViewSetNeedsDisplayInRegion(qt_mac_nativeview_for(q), QMacSmartQuickDrawRegion(rgnHandle), true);
-    else {
-        HIViewSetNeedsDisplay(qt_mac_nativeview_for(q), true); // do a complete repaint on overflow.
-    }
-#else
-    // Alien support: get the first native ancestor widget (will be q itself in the non-alien case),
-    // map the coordinates from q space to NSView space and invalidate the rect.
-    QWidget *nativeParent = q->internalWinId() ? q : q->nativeParentWidget();
-    if (nativeParent == 0)
-	return;
-
-    QVector<QRect> rects = rgn.rects();
-    for (int i = 0; i < rects.count(); ++i) {
-        const QRect &rect = rects.at(i);
-
-	const QRect nativeBoundingRect = QRect(
-		QPoint(q->mapTo(nativeParent, rect.topLeft())),
-		QSize(rect.size()));
-
-	[qt_mac_nativeview_for(nativeParent) setNeedsDisplayInRect:NSMakeRect(nativeBoundingRect.x(),
-		nativeBoundingRect.y(), nativeBoundingRect.width(),
-		nativeBoundingRect.height())];
-    }
-#endif
+    macSetNeedsDisplay(rgn);
 }
 
 bool QWidgetPrivate::isRealWindow() const
@@ -3447,7 +3434,6 @@ void QWidgetPrivate::show_sys()
 
     data.fstrut_dirty = true;
     if (realWindow) {
-         // Delegates can change window state, so record some things earlier.
         bool isCurrentlyMinimized = (q->windowState() & Qt::WindowMinimized);
         setModal_sys();
         OSWindowRef window = qt_mac_window_for(q);
@@ -3494,9 +3480,11 @@ void QWidgetPrivate::show_sys()
                 }
             }
             setSubWindowStacking(true);
+            qt_mac_update_cursor();
 #endif
             if (q->windowType() == Qt::Popup) {
-			    if (q->focusWidget())
+                qt_button_down = 0;
+                if (q->focusWidget())
 				    q->focusWidget()->d_func()->setFocus_sys();
 				else
                     setFocus_sys();
@@ -3518,21 +3506,34 @@ void QWidgetPrivate::show_sys()
 #ifndef QT_MAC_USE_COCOA
         HIViewSetVisible(qt_mac_nativeview_for(q), true);
 #else
-        [qt_mac_nativeview_for(q) setHidden:NO];
-
+        if (NSView *view = qt_mac_nativeview_for(q)) {
+            // INVARIANT: q is native. Just show the view:
+            [view setHidden:NO];
+        } else {
+            // INVARIANT: q is alien. Repaint q instead:
+            q->repaint();
+        }
 #endif
     }
 
-    if (!QWidget::mouseGrabber()){
-        QWidget *enterWidget = QApplication::widgetAt(QCursor::pos());
-        QApplicationPrivate::dispatchEnterLeave(enterWidget, qt_mouseover);
-        qt_mouseover = enterWidget;
+#ifdef QT_MAC_USE_COCOA
+    if ([NSApp isActive] && !qt_button_down && !QWidget::mouseGrabber()){
+        // Update enter/leave immidiatly, don't wait for a move event. But only
+        // if no grab exists (even if the grab points to this widget, it seems, ref X11)
+        QPoint qlocal, qglobal;
+        QWidget *widgetUnderMouse = 0;
+        qt_mac_getTargetForMouseEvent(0, QEvent::Enter, qlocal, qglobal, 0, &widgetUnderMouse);
+        QApplicationPrivate::dispatchEnterLeave(widgetUnderMouse, qt_last_mouse_receiver);
+        qt_last_mouse_receiver = widgetUnderMouse;
+        qt_last_native_mouse_receiver = widgetUnderMouse ?
+            (widgetUnderMouse->internalWinId() ? widgetUnderMouse : widgetUnderMouse->nativeParentWidget()) : 0;
     }
+#endif
 
+    topLevelAt_cache = 0;
     qt_event_request_window_change(q);
 }
 
-
 QPoint qt_mac_nativeMapFromParent(const QWidget *child, const QPoint &pt)
 {
 #ifndef QT_MAC_USE_COCOA
@@ -3613,6 +3614,7 @@ void QWidgetPrivate::hide_sys()
             }
 #endif
             toggleDrawers(false);
+            qt_mac_update_cursor();
 #ifndef QT_MAC_USE_COCOA
             // Clear modality (because it seems something that we've always done).
             if (data.window_modality != Qt::NonModal) {
@@ -3660,18 +3662,31 @@ void QWidgetPrivate::hide_sys()
 #ifndef QT_MAC_USE_COCOA
         HIViewSetVisible(qt_mac_nativeview_for(q), false);
 #else
-        [qt_mac_nativeview_for(q) setHidden:YES];
+        if (NSView *view = qt_mac_nativeview_for(q)) {
+            // INVARIANT: q is native. Just hide the view:
+            [view setHidden:YES];
+        } else {
+            // INVARIANT: q is alien. Repaint where q is placed instead:
+            qt_mac_repaintParentUnderAlienWidget(q);
+        }
 #endif
     }
 
-    if (!QWidget::mouseGrabber()){
-        QWidget *enterWidget = QApplication::widgetAt(QCursor::pos());
-        if (enterWidget && enterWidget->data->in_destructor)
-            enterWidget = 0;
-        QApplicationPrivate::dispatchEnterLeave(enterWidget, qt_mouseover);
-        qt_mouseover = enterWidget;
-    }
-
+#ifdef QT_MAC_USE_COCOA
+    if ([NSApp isActive] && !qt_button_down && !QWidget::mouseGrabber()){
+        // Update enter/leave immidiatly, don't wait for a move event. But only
+        // if no grab exists (even if the grab points to this widget, it seems, ref X11)
+        QPoint qlocal, qglobal;
+        QWidget *widgetUnderMouse = 0;
+        qt_mac_getTargetForMouseEvent(0, QEvent::Leave, qlocal, qglobal, 0, &widgetUnderMouse);
+        QApplicationPrivate::dispatchEnterLeave(widgetUnderMouse, qt_last_native_mouse_receiver);
+        qt_last_mouse_receiver = widgetUnderMouse;
+        qt_last_native_mouse_receiver = widgetUnderMouse ?
+            (widgetUnderMouse->internalWinId() ? widgetUnderMouse : widgetUnderMouse->nativeParentWidget()) : 0;
+     }
+#endif
+
+    topLevelAt_cache = 0;
     qt_event_request_window_change(q);
     deactivateWidgetCleanup();
     qt_mac_event_release(q);
@@ -3894,12 +3909,14 @@ void QWidgetPrivate::raise_sys()
                     QWidget *parentWidget = q->parentWidget();
                     if(parentWidget) {
                         OSWindowRef parentWindow = qt_mac_window_for(parentWidget);
-                        if(parentWindow && [parentWindow isOnActiveSpace]) {
-                            // The window was created in a different space. Therefore if we want
-                            // to show it in the current space we need to recreate it in the new
-                            // space.
-                            recreateMacWindow();
-                            window = qt_mac_window_for(q);
+                        if(parentWindow && [parentWindow respondsToSelector:@selector(isOnActiveSpace)]) {
+                            if ([parentWindow performSelector:@selector(isOnActiveSpace)]) {
+                                // The window was created in a different space. Therefore if we want
+                                // to show it in the current space we need to recreate it in the new
+                                // space.
+                                recreateMacWindow();
+                                window = qt_mac_window_for(q);
+                            }
                         }
                     }
                 }
@@ -3916,6 +3933,7 @@ void QWidgetPrivate::raise_sys()
         NSView *parentView = [view superview];
         [parentView sortSubviewsUsingFunction:compareViews2Raise context:reinterpret_cast<void *>(view)];
     }
+    topLevelAt_cache = 0;
 #else
     if(q->isWindow()) {
         //raise this window
@@ -3956,6 +3974,7 @@ void QWidgetPrivate::lower_sys()
         NSView *parentView = [view superview];
         [parentView sortSubviewsUsingFunction:compareViews2Lower context:reinterpret_cast<void *>(view)];
     }
+    topLevelAt_cache = 0;
 #else
     if(q->isWindow()) {
         SendBehind(qt_mac_window_for(q), 0);
@@ -4012,6 +4031,7 @@ void QWidgetPrivate::stackUnder_sys(QWidget *w)
 #endif
 }
 
+#ifndef QT_MAC_USE_COCOA
 /*
     Modifies the bounds for a widgets backing HIView during moves and resizes. Also updates the
     widget, either by scrolling its contents or repainting, depending on the WA_StaticContents
@@ -4019,7 +4039,6 @@ void QWidgetPrivate::stackUnder_sys(QWidget *w)
 */
 static void qt_mac_update_widget_position(QWidget *q, QRect oldRect, QRect newRect)
 {
-#ifndef QT_MAC_USE_COCOA
     HIRect bounds = CGRectMake(newRect.x(), newRect.y(),
                                newRect.width(), newRect.height());
 
@@ -4111,13 +4130,8 @@ static void qt_mac_update_widget_position(QWidget *q, QRect oldRect, QRect newRe
     HIViewSetNeedsDisplayInRect(view, &verticalSlice, true);
     const HIRect horizontalSlice = CGRectMake(0, starty, startx, stopy);
     HIViewSetNeedsDisplayInRect(view, &horizontalSlice, true);
-#else
-    Q_UNUSED(oldRect);
-    NSRect bounds = NSMakeRect(newRect.x(), newRect.y(),
-	    newRect.width(), newRect.height());
-    [qt_mac_nativeview_for(q) setFrame:bounds];
-#endif
 }
+#endif
 
 /*
   Helper function for non-toplevel widgets. Helps to map Qt's 32bit
@@ -4138,7 +4152,15 @@ void QWidgetPrivate::setWSGeometry(bool dontShow, const QRect &oldRect)
 {
     Q_Q(QWidget);
     Q_ASSERT(q->testAttribute(Qt::WA_WState_Created));
-    Q_UNUSED(oldRect);
+
+    if (!q->internalWinId() && QApplicationPrivate::graphicsSystem() != 0) {
+        // We have no view to move, and no paint engine that
+        // we can update dirty regions on. So just return:
+        return;
+    }
+
+    QMacCocoaAutoReleasePool pool;
+
     /*
       There are up to four different coordinate systems here:
       Qt coordinate system for this widget.
@@ -4146,13 +4168,31 @@ void QWidgetPrivate::setWSGeometry(bool dontShow, const QRect &oldRect)
       Qt coordinate system for parent
       X coordinate system for parent (relative to parent's wrect).
     */
+
+    // wrect is the same as crect, except that it is
+    // clipped to fit inside parent (and screen):
     QRect wrect;
-    //xrect is the X geometry of my X widget. (starts out in  parent's Qt coord sys, and ends up in parent's X coord sys)
-    QRect xrect = data.crect;
 
+    // wrectInParentCoordSys will be the same as wrect, except that it is
+    // originated in q's parent rather than q itself. It starts out in
+    // parent's Qt coord system, and ends up in parent's coordinate system:
+    QRect wrectInParentCoordSys = data.crect;
+
+    // If q's parent has been clipped, parentWRect will
+    // be filled with the parents clipped crect:
     QRect parentWRect;
+
+    // Embedded have different meaning on each platform, and on
+    // Mac, it means that q is a QMacNativeWidget.
     bool isEmbeddedWindow = (q->isWindow() && topData()->embedded);
-    if (isEmbeddedWindow) {
+#ifdef QT_MAC_USE_COCOA
+    NSView *nsview = qt_mac_nativeview_for(q);
+#endif
+    if (!isEmbeddedWindow) {
+        parentWRect = q->parentWidget()->data->wrect;
+    } else {
+        // INVARIANT: q's parent view is not owned by Qt. So we need to
+        // do some extra calls to get the clipped rect of the parent view:
 #ifndef QT_MAC_USE_COCOA
         HIViewRef parentView = HIViewGetSuperview(qt_mac_nativeview_for(q));
 #else
@@ -4171,43 +4211,57 @@ void QWidgetPrivate::setWSGeometry(bool dontShow, const QRect &oldRect)
             const QRect wrectRange(-WRECT_MAX,-WRECT_MAX, 2*WRECT_MAX, 2*WRECT_MAX);
             parentWRect = wrectRange;
         }
-    } else {
-        parentWRect = q->parentWidget()->data->wrect;
     }
 
     if (parentWRect.isValid()) {
-        // parent is clipped, and we have to clip to the same limit as parent
-        if (!parentWRect.contains(xrect) && !isEmbeddedWindow) {
-            xrect &= parentWRect;
-            wrect = xrect;
-            //translate from parent's to my Qt coord sys
+        // INVARIANT: q's parent has been clipped.
+        // So we fit our own wrects inside it:
+        if (!parentWRect.contains(wrectInParentCoordSys) && !isEmbeddedWindow) {
+            wrectInParentCoordSys &= parentWRect;
+            wrect = wrectInParentCoordSys;
+            // Make sure wrect is originated in q's coordinate system:
             wrect.translate(-data.crect.topLeft());
         }
-        //translate from parent's Qt coords to parent's X coords
-        xrect.translate(-parentWRect.topLeft());
-
+        // // Make sure wrectInParentCoordSys originated in q's parent coordinate system:
+        wrectInParentCoordSys.translate(-parentWRect.topLeft());
     } else {
-        // parent is not clipped, we may or may not have to clip
+        // INVARIANT: we dont know yet the clipping rect of q's parent.
+        // So we may or may not have to adjust our wrects:
 
         if (data.wrect.isValid() && QRect(QPoint(),data.crect.size()).contains(data.wrect)) {
-            // This is where the main optimization is: we are already
-            // clipped, and if our clip is still valid, we can just
-            // move our window, and do not need to move or clip
-            // children
+            // This is where the main optimization is: we have an old wrect from an earlier
+            // setGeometry call, and the new crect is smaller than it. If the final wrect is
+            // also inside the old wrect, we can just move q and its children to the new
+            // location without any clipping:
+
+             // vrect will be the part of q that's will be visible inside
+             // q's parent. If it inside the old wrect, then we can just move:
+            QRect vrect = wrectInParentCoordSys & q->parentWidget()->rect();
+            vrect.translate(-data.crect.topLeft());
 
-            QRect vrect = xrect & q->parentWidget()->rect();
-            vrect.translate(-data.crect.topLeft()); //the part of me that's visible through parent, in my Qt coords
             if (data.wrect.contains(vrect)) {
-                xrect = data.wrect;
-                xrect.translate(data.crect.topLeft());
+                wrectInParentCoordSys = data.wrect;
+                wrectInParentCoordSys.translate(data.crect.topLeft());
 #ifndef QT_MAC_USE_COCOA
-                HIRect bounds = CGRectMake(xrect.x(), xrect.y(),
-                                           xrect.width(), xrect.height());
+                HIRect bounds = CGRectMake(wrectInParentCoordSys.x(), wrectInParentCoordSys.y(),
+                                           wrectInParentCoordSys.width(), wrectInParentCoordSys.height());
                 HIViewSetFrame(qt_mac_nativeview_for(q), &bounds);
 #else
-                NSRect bounds = NSMakeRect(xrect.x(), xrect.y(),
-                                           xrect.width(), xrect.height());
-                [qt_mac_nativeview_for(q) setFrame:bounds];
+                if (nsview) {
+                    // INVARIANT: q is native. Set view frame:
+                    NSRect bounds = NSMakeRect(wrectInParentCoordSys.x(), wrectInParentCoordSys.y(),
+                        wrectInParentCoordSys.width(), wrectInParentCoordSys.height());
+                        [nsview setFrame:bounds];
+                } else {
+                    // INVARIANT: q is alien. Repaint wrect instead (includes old and new wrect):
+                    QWidget *parent = q->parentWidget();
+                    QPoint globalPosWRect = parent->mapToGlobal(data.wrect.topLeft());
+
+                    QWidget *nativeParent = q->nativeParentWidget();
+                    QRect dirtyWRect = QRect(nativeParent->mapFromGlobal(globalPosWRect), data.wrect.size());
+
+                    nativeParent->update(dirtyWRect);
+                }
 #endif
                 if (q->testAttribute(Qt::WA_OutsideWSRange)) {
                     q->setAttribute(Qt::WA_OutsideWSRange, false);
@@ -4216,7 +4270,8 @@ void QWidgetPrivate::setWSGeometry(bool dontShow, const QRect &oldRect)
 #ifndef QT_MAC_USE_COCOA
                         HIViewSetVisible(qt_mac_nativeview_for(q), true);
 #else
-                        [qt_mac_nativeview_for(q) setHidden:NO];
+                        // If q is Alien, the following call does nothing:
+                        [nsview setHidden:NO];
 #endif
                     }
                 }
@@ -4226,8 +4281,8 @@ void QWidgetPrivate::setWSGeometry(bool dontShow, const QRect &oldRect)
 
 #ifndef QT_MAC_USE_COCOA
         const QRect validRange(-XCOORD_MAX,-XCOORD_MAX, 2*XCOORD_MAX, 2*XCOORD_MAX);
-        if (!validRange.contains(xrect)) {
-            // we are too big, and must clip
+        if (!validRange.contains(wrectInParentCoordSys)) {
+            // We're too big, and must clip:
             QPoint screenOffset(0, 0); // offset of the part being on screen
             const QWidget *parentWidget = q->parentWidget();
             while (parentWidget && !parentWidget->isWindow()) {
@@ -4239,15 +4294,15 @@ void QWidgetPrivate::setWSGeometry(bool dontShow, const QRect &oldRect)
                            2*WRECT_MAX,
                            2*WRECT_MAX);
 
-            xrect &=cropRect;
-            wrect = xrect;
-            wrect.translate(-data.crect.topLeft()); // translate wrect in my Qt coordinates
+            wrectInParentCoordSys &=cropRect;
+            wrect = wrectInParentCoordSys;
+            wrect.translate(-data.crect.topLeft());
         }
 #endif //QT_MAC_USE_COCOA
     }
 
     // unmap if we are outside the valid window system coord system
-    bool outsideRange = !xrect.isValid();
+    bool outsideRange = !wrectInParentCoordSys.isValid();
     bool mapWindow = false;
     if (q->testAttribute(Qt::WA_OutsideWSRange) != outsideRange) {
         q->setAttribute(Qt::WA_OutsideWSRange, outsideRange);
@@ -4255,7 +4310,8 @@ void QWidgetPrivate::setWSGeometry(bool dontShow, const QRect &oldRect)
 #ifndef QT_MAC_USE_COCOA
             HIViewSetVisible(qt_mac_nativeview_for(q), false);
 #else
-            [qt_mac_nativeview_for(q) setHidden:YES];
+            // If q is Alien, the following call does nothing:
+            [nsview setHidden:YES];
 #endif
             q->setAttribute(Qt::WA_Mapped, false);
         } else if (!q->isHidden()) {
@@ -4266,10 +4322,10 @@ void QWidgetPrivate::setWSGeometry(bool dontShow, const QRect &oldRect)
     if (outsideRange)
         return;
 
+    // Store the new clipped rect:
     bool jump = (data.wrect != wrect);
     data.wrect = wrect;
 
-
     // and now recursively for all children...
     // ### can be optimized
     for (int i = 0; i < children.size(); ++i) {
@@ -4281,17 +4337,56 @@ void QWidgetPrivate::setWSGeometry(bool dontShow, const QRect &oldRect)
         }
     }
 
-    qt_mac_update_widget_position(q, oldRect, xrect);
-
-    if  (jump)
+#ifndef QT_MAC_USE_COCOA
+    // Move the actual HIView:
+    qt_mac_update_widget_position(q, oldRect, wrectInParentCoordSys);
+    if (jump)
         q->update();
+#else
+    if (nsview) {
+        // INVARIANT: q is native. Move the actual NSView:
+        NSRect bounds = NSMakeRect(
+            wrectInParentCoordSys.x(), wrectInParentCoordSys.y(),
+            wrectInParentCoordSys.width(), wrectInParentCoordSys.height());
+        [nsview setFrame:bounds];
+        if (jump)
+            q->update();
+    } else if (QApplicationPrivate::graphicsSystem() == 0){
+        // INVARIANT: q is alien and we use native paint engine.
+        // Schedule updates where q is moved from and to:
+        const QWidget *parent = q->parentWidget();
+        const QPoint globalPosOldWRect = parent->mapToGlobal(oldRect.topLeft());
+        const QPoint globalPosNewWRect = parent->mapToGlobal(wrectInParentCoordSys.topLeft());
+
+        QWidget *nativeParent = q->nativeParentWidget();
+        const QRegion dirtyOldWRect = QRect(nativeParent->mapFromGlobal(globalPosOldWRect), oldRect.size());
+        const QRegion dirtyNewWRect = QRect(nativeParent->mapFromGlobal(globalPosNewWRect), wrectInParentCoordSys.size());
+
+        const bool sizeUnchanged = oldRect.size() == wrectInParentCoordSys.size();
+        const bool posUnchanged = oldRect.topLeft() == wrectInParentCoordSys.topLeft();
+
+        // Resolve/minimize the region that needs to update:
+        if (sizeUnchanged && q->testAttribute(Qt::WA_OpaquePaintEvent)) {
+            // INVARIANT: q is opaque, and is only moved (not resized). So in theory we only
+            // need to blit pixels, and skip a repaint. But we can only make this work if we
+            // had access to the backbuffer, so we need to update all:
+            nativeParent->update(dirtyOldWRect | dirtyNewWRect);
+        } else if (posUnchanged && q->testAttribute(Qt::WA_StaticContents)) {
+            // We only need to redraw exposed areas:
+            nativeParent->update(dirtyNewWRect - dirtyOldWRect);
+        } else {
+            nativeParent->update(dirtyOldWRect | dirtyNewWRect);
+        }
+    }
+#endif
 
     if (mapWindow && !dontShow) {
         q->setAttribute(Qt::WA_Mapped);
 #ifndef QT_MAC_USE_COCOA
         HIViewSetVisible(qt_mac_nativeview_for(q), true);
 #else
-        [qt_mac_nativeview_for(q) setHidden:NO];
+        // If q is Alien, the following call does nothing:
+        [nsview setHidden:NO];
 #endif
     }
 }
@@ -4353,7 +4448,6 @@ void QWidgetPrivate::setGeometry_sys(int x, int y, int w, int h, bool isMove)
 
     QMacCocoaAutoReleasePool pool;
     bool realWindow = isRealWindow();
-    BOOL needDisplay = realWindow ? YES : NO;
 
     if (realWindow && !q->testAttribute(Qt::WA_DontShowOnScreen)){
         adjustWithinMaxAndMinSize(w, h);
@@ -4401,7 +4495,7 @@ void QWidgetPrivate::setGeometry_sys(int x, int y, int w, int h, bool isMove)
         if (currTopLeft.x() == x && currTopLeft.y() == y
                 && cocoaFrameRect.size.width != 0
                 && cocoaFrameRect.size.height != 0) {
-            [window setFrame:cocoaFrameRect display:needDisplay];
+            [window setFrame:cocoaFrameRect display:realWindow];
         } else {
             // The window is moved and resized (or resized to zero).
             // Since Cocoa usually only sends us a resize callback after
@@ -4410,7 +4504,7 @@ void QWidgetPrivate::setGeometry_sys(int x, int y, int w, int h, bool isMove)
             // would have the same origin as the setFrame call) we shift the
             // window back and forth inbetween.
             cocoaFrameRect.origin.y += 1;
-            [window setFrame:cocoaFrameRect display:needDisplay];
+            [window setFrame:cocoaFrameRect display:realWindow];
             cocoaFrameRect.origin.y -= 1;
             [window setFrameOrigin:cocoaFrameRect.origin];
         }
@@ -4418,6 +4512,8 @@ void QWidgetPrivate::setGeometry_sys(int x, int y, int w, int h, bool isMove)
     } else {
         setGeometry_sys_helper(x, y, w, h, isMove);
     }
+
+    topLevelAt_cache = 0;
 }
 
 void QWidgetPrivate::setGeometry_sys_helper(int x, int y, int w, int h, bool isMove)
@@ -4468,17 +4564,11 @@ void QWidgetPrivate::setGeometry_sys_helper(int x, int y, int w, int h, bool isM
         const QRect oldRect(oldp, olds);
         if (!isResize && QApplicationPrivate::graphicsSystem())
             moveRect(oldRect, x - oldp.x(), y - oldp.y());
+
         setWSGeometry(false, oldRect);
-        if (isResize && QApplicationPrivate::graphicsSystem()) {
-            invalidateBuffer(q->rect());
-            if (extra && !graphicsEffect && !extra->mask.isEmpty()) {
-                QRegion oldRegion(extra->mask.translated(oldp));
-                oldRegion &= oldRect;
-                q->parentWidget()->d_func()->invalidateBuffer(oldRegion);
-            } else {
-                q->parentWidget()->d_func()->invalidateBuffer(effectiveRectFor(oldRect));
-            }
-        }
+
+        if (isResize && QApplicationPrivate::graphicsSystem())
+            invalidateBuffer_resizeHelper(oldp, olds);
     }
 
     if(isMove || isResize) {
@@ -4558,6 +4648,7 @@ void QWidgetPrivate::updateMaximizeButton_sys()
 void QWidgetPrivate::scroll_sys(int dx, int dy)
 {
     if (QApplicationPrivate::graphicsSystem() && !paintOnScreen()) {
+        // INVARIANT: Alien paint engine
         scrollChildren(dx, dy);
         scrollRect(q_func()->rect(), dx, dy);
     } else {
@@ -4565,37 +4656,81 @@ void QWidgetPrivate::scroll_sys(int dx, int dy)
     }
 }
 
-void QWidgetPrivate::scroll_sys(int dx, int dy, const QRect &r)
+void QWidgetPrivate::scroll_sys(int dx, int dy, const QRect &qscrollRect)
 {
-    Q_Q(QWidget);
+    if (QMacScrollOptimization::delayScroll(this, dx, dy, qscrollRect))
+        return;
 
+    Q_Q(QWidget);
     if (QApplicationPrivate::graphicsSystem() && !paintOnScreen()) {
-        scrollRect(r, dx, dy);
+        // INVARIANT: Alien paint engine
+        scrollRect(qscrollRect, dx, dy);
         return;
     }
 
-    const bool valid_rect = r.isValid();
-    if (!q->updatesEnabled() &&  (valid_rect || q->children().isEmpty()))
-        return;
+    static int accelEnv = -1;
+    if (accelEnv == -1) {
+        accelEnv = qgetenv("QT_NO_FAST_SCROLL").toInt() == 0;
+    }
 
-    qt_event_request_window_change(q);
+    // Scroll the whole widget if qscrollRect is not valid:
+    QRect validScrollRect = qscrollRect.isValid() ? qscrollRect : q->rect();
+    validScrollRect &= clipRect();
+
+    // If q is overlapped by other widgets, we cannot just blit pixels since
+    // this will move overlapping widgets as well. In case we just update:
+    const bool overlapped = isOverlapped(validScrollRect.translated(data.crect.topLeft()));
+    const bool accelerateScroll = accelEnv && isOpaque && !overlapped;
+    const bool isAlien = (q->internalWinId() == 0);
+    const QPoint scrollDelta(dx, dy);
+
+    // If qscrollRect is valid, we are _not_ supposed to scroll q's children (as documented).
+    // But we do scroll children (and the whole of q) if qscrollRect is invalid. This case is
+    // documented as undefined, but we exploit it to help factor our code into one function.
+    const bool scrollChildren = !qscrollRect.isValid();
+
+    if (!q->updatesEnabled()) {
+        // We are told not to update anything on q at this point. So unless
+        // we are supposed to scroll children, we bail out early:
+        if (!scrollChildren || q->children().isEmpty())
+            return;
+    }
+
+    if (!accelerateScroll) {
+        if (overlapped) {
+            QRegion region(validScrollRect);
+            subtractOpaqueSiblings(region);
+            update_sys(region);
+        }else {
+            update_sys(qscrollRect);
+        }
+        return;
+    }
 
 #ifdef QT_MAC_USE_COCOA
     QMacCocoaAutoReleasePool pool;
+#else
+    Q_UNUSED(isAlien);
+    // We're not sure what the following call is supposed to achive
+    // but until we see what it breaks, we don't bring it into the
+    // Cocoa port:
+    qt_event_request_window_change(q);
 #endif
 
-    if(!valid_rect) {        // scroll children
-        QPoint pd(dx, dy);
-        QWidgetList moved;
-        QObjectList chldrn = q->children();
-        for(int i = 0; i < chldrn.size(); i++) {  //first move all children
-            QObject *obj = chldrn.at(i);
-            if(obj->isWidgetType()) {
-                QWidget *w = (QWidget*)obj;
-                if(!w->isWindow()) {
-                    w->data->crect = QRect(w->pos() + pd, w->size());
-                    if (w->testAttribute(Qt::WA_WState_Created)) {
+    // First move all native children. Alien children will indirectly be
+    // moved when the parent is scrolled. All directly or indirectly moved
+    // children will receive a move event before the function call returns.
+    QWidgetList movedChildren;
+    if (scrollChildren) {
+        QObjectList children = q->children();
+
+        for (int i=0; i<children.size(); i++) {
+            QObject *obj = children.at(i);
+            if (QWidget *w = qobject_cast<QWidget*>(obj)) {
+                if (!w->isWindow()) {
+                    w->data->crect = QRect(w->pos() + scrollDelta, w->size());
 #ifndef QT_MAC_USE_COCOA
+                    if (w->testAttribute(Qt::WA_WState_Created)) {
                         HIRect bounds = CGRectMake(w->data->crect.x(), w->data->crect.y(),
                                                    w->data->crect.width(), w->data->crect.height());
                         HIViewRef hiview = qt_mac_nativeview_for(w);
@@ -4606,83 +4741,118 @@ void QWidgetPrivate::scroll_sys(int dx, int dy, const QRect &r)
                         HIViewSetFrame(hiview, &bounds);
                         if (opaque)
                             HIViewSetDrawingEnabled(hiview,  true);
+                    }
 #else
-                        [qt_mac_nativeview_for(w)
-                            setFrame:NSMakeRect(w->data->crect.x(), w->data->crect.y(),
-                                                w->data->crect.width(), w->data->crect.height())];
-#endif
+                    if (NSView *view = qt_mac_nativeview_for(w)) {
+                        // INVARIANT: w is not alien
+                        [view setFrame:NSMakeRect(
+                            w->data->crect.x(), w->data->crect.y(),
+                            w->data->crect.width(), w->data->crect.height())];
                     }
-                    moved.append(w);
+#endif
+                    movedChildren.append(w);
                 }
             }
         }
-        //now send move events (do not do this in the above loop, breaks QAquaFocusWidget)
-        for(int i = 0; i < moved.size(); i++) {
-            QWidget *w = moved.at(i);
-            QMoveEvent e(w->pos(), w->pos() - pd);
-            QApplication::sendEvent(w, &e);
-        }
     }
 
-    if (!q->testAttribute(Qt::WA_WState_Created) || !q->isVisible())
-        return;
+    if (q->testAttribute(Qt::WA_WState_Created) && q->isVisible()) {
+        // Scroll q itself according to the qscrollRect, and
+        // call update on any exposed areas so that they get redrawn:
 
-    OSViewRef view = qt_mac_nativeview_for(q);
 #ifndef QT_MAC_USE_COCOA
-    HIRect scrollrect = CGRectMake(r.x(), r.y(), r.width(), r.height());
-   OSStatus err = _HIViewScrollRectWithOptions(view, valid_rect ? &scrollrect : 0, dx, dy, kHIViewScrollRectAdjustInvalid);
-   if (err) {
-       // The only parameter that can go wrong, is the rect.
-       qWarning("QWidget::scroll: Your rectangle was too big for the widget, clipping rect");
-       scrollrect = CGRectMake(qMax(r.x(), 0), qMax(r.y(), 0),
-                               qMin(r.width(), q->width()), qMin(r.height(), q->height()));
-       _HIViewScrollRectWithOptions(view, valid_rect ? &scrollrect : 0, dx, dy, kHIViewScrollRectAdjustInvalid);
-   }
+        OSViewRef view = qt_mac_nativeview_for(q);
+        HIRect scrollrect = CGRectMake(qscrollRect.x(), qscrollRect.y(), qscrollRect.width(), qscrollRect.height());
+        OSStatus err = _HIViewScrollRectWithOptions(view, qscrollRect.isValid() ? &scrollrect : 0, dx, dy, kHIViewScrollRectAdjustInvalid);
+        if (err) {
+           // The only parameter that can go wrong, is the rect.
+           qWarning("QWidget::scroll: Your rectangle was too big for the widget, clipping rect");
+           scrollrect = CGRectMake(qMax(qscrollRect.x(), 0), qMax(qscrollRect.y(), 0),
+                                   qMin(qscrollRect.width(), q->width()), qMin(qscrollRect.height(), q->height()));
+           _HIViewScrollRectWithOptions(view, qscrollRect.isValid() ? &scrollrect : 0, dx, dy, kHIViewScrollRectAdjustInvalid);
+        }
 #else
-    NSRect scrollRect = valid_rect ? NSMakeRect(r.x(), r.y(), r.width(), r.height())
-                                   : NSMakeRect(0, 0, q->width(), q->height());
 
+        QWidget *nativeWidget = isAlien ? q->nativeParentWidget() : q;
+        if (!nativeWidget)
+            return;
+        OSViewRef view = qt_mac_nativeview_for(nativeWidget);
+        if (!view)
+            return;
 
-    // calc the updateRect
-    NSRect deltaXRect = { {0, 0}, {0, 0} };
-    NSRect deltaYRect = { {0, 0}, {0, 0} };
-    if (dy != 0) {
-        deltaYRect.size.width = scrollRect.size.width;
-        if (dy > 0) {
-            deltaYRect.size.height = dy;
-        } else {
-            deltaYRect.size.height = -dy;
-            deltaYRect.origin.y = scrollRect.size.height + dy;
+        // Calculate the rectangles that needs to be redrawn
+        // after the scroll. This will be source rect minus destination rect:
+        QRect deltaXRect;
+        if (dx != 0) {
+            deltaXRect.setY(validScrollRect.y());
+            deltaXRect.setHeight(validScrollRect.height());
+            if (dx > 0) {
+                deltaXRect.setX(validScrollRect.x());
+                deltaXRect.setWidth(dx);
+            } else {
+                deltaXRect.setX(validScrollRect.x() + validScrollRect.width() + dx);
+                deltaXRect.setWidth(-dx);
+            }
         }
-    }
-    if (dx != 0) {
-        deltaXRect.size.height = scrollRect.size.height;
-        if (dx > 0) {
-            deltaXRect.size.width = dx;
-        } else {
-            deltaXRect.size.width = -dx;
-            deltaXRect.origin.x = scrollRect.size.width + dx;
+
+        QRect deltaYRect;
+        if (dy != 0) {
+            deltaYRect.setX(validScrollRect.x());
+            deltaYRect.setWidth(validScrollRect.width());
+            if (dy > 0) {
+                deltaYRect.setY(validScrollRect.y());
+                deltaYRect.setHeight(dy);
+           } else {
+                deltaYRect.setY(validScrollRect.y() + validScrollRect.height() + dy);
+                deltaYRect.setHeight(-dy);
+            }
         }
-    }
 
-    // ### Scroll the dirty regions as well, the following is not correct.
-    QRegion displayRegion = r.isNull() ? dirtyOnWidget : (dirtyOnWidget & r);
-    const QVector<QRect> &rects = dirtyOnWidget.rects();
-    const QVector<QRect>::const_iterator end = rects.end();
-    QVector<QRect>::const_iterator it = rects.begin();
-    while (it != end) {
-	const QRect rect = *it;
-	const NSRect dirtyRect = NSMakeRect(rect.x() + dx, rect.y() + dy,
-		rect.width(), rect.height());
-	[view setNeedsDisplayInRect:dirtyRect];
-	++it;
-    }
+        if (isAlien) {
+            // Adjust the scroll rect to the location as seen from the native parent:
+            QPoint scrollTopLeftInsideNative = nativeWidget->mapFromGlobal(q->mapToGlobal(validScrollRect.topLeft()));
+            validScrollRect.moveTo(scrollTopLeftInsideNative);
+        }
+
+        // Make the pixel copy rect within the validScrollRect bounds:
+        NSRect nsscrollRect = NSMakeRect(
+            validScrollRect.x() + (dx < 0 ? -dx : 0),
+            validScrollRect.y() + (dy < 0 ? -dy : 0),
+            validScrollRect.width() + (dx > 0 ? -dx : 0),
+            validScrollRect.height() + (dy > 0 ? -dy : 0));
+
+        NSSize deltaSize = NSMakeSize(dx, dy);
+        [view scrollRect:nsscrollRect by:deltaSize];
+
+        // Some areas inside the scroll rect might have been marked as dirty from before, which
+        // means that they are scheduled to be redrawn. But as we now scroll, those dirty rects
+        // should also move along to ensure that q receives repaints on the correct places.
+        // Since some of the dirty rects might lay outside, or only intersect with, the scroll
+        // rect, the old calls to setNeedsDisplay still makes sense.
+        // NB: Using [view translateRectsNeedingDisplayInRect:nsscrollRect by:deltaSize] have
+        // so far not been proven fruitful to solve this problem.
+        const QVector<QRect> &dirtyRectsToScroll = dirtyOnWidget.rects();
+        for (int i=0; i<dirtyRectsToScroll.size(); ++i) {
+            QRect qdirtyRect = dirtyRectsToScroll[i];
+            qdirtyRect.translate(dx, dy);
+            update_sys(qdirtyRect);
+        }
+
+        // Update newly exposed areas. This will generate new dirty areas on
+        // q, and therefore, we do it after updating the old dirty rects above:
+        if (dx != 0)
+            update_sys(deltaXRect);
+        if (dy != 0)
+            update_sys(deltaYRect);
 
-    NSSize deltaSize = NSMakeSize(dx, dy);
-    [view scrollRect:scrollRect by:deltaSize];
-    [view setNeedsDisplayInRect:deltaXRect];
-    [view setNeedsDisplayInRect:deltaYRect];
 #endif // QT_MAC_USE_COCOA
+    }
+
+    for (int i=0; i<movedChildren.size(); i++) {
+        QWidget *w = movedChildren.at(i);
+        QMoveEvent e(w->pos(), w->pos() - scrollDelta);
+        QApplication::sendEvent(w, &e);
+    }
 }
 
 int QWidget::metric(PaintDeviceMetric m) const
@@ -4693,16 +4863,19 @@ int QWidget::metric(PaintDeviceMetric m) const
     case PdmWidthMM:
         return qRound(metric(PdmWidth) * 25.4 / qreal(metric(PdmDpiX)));
     case PdmHeight:
-    case PdmWidth: {
+    case PdmWidth:
 #ifndef QT_MAC_USE_COCOA
-        HIRect rect;
+        { HIRect rect;
         HIViewGetFrame(qt_mac_nativeview_for(this), &rect);
-#else
-        NSRect rect = [qt_mac_nativeview_for(this) frame];
-#endif
         if(m == PdmWidth)
             return (int)rect.size.width;
         return (int)rect.size.height; }
+#else
+        if (m == PdmWidth)
+            return data->crect.width();
+        else
+            return data->crect.height();
+#endif
     case PdmDepth:
         return 32;
     case PdmNumColors:
@@ -4817,19 +4990,35 @@ void QWidgetPrivate::registerDropSite(bool on)
 #endif
 }
 
-void QWidgetPrivate::registerTouchWindow()
+void QWidgetPrivate::registerTouchWindow(bool enable)
 {
+    Q_UNUSED(enable);
+#ifdef QT_MAC_USE_COCOA
 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
     if (QSysInfo::MacintoshVersion < QSysInfo::MV_10_6)
         return;
+
     Q_Q(QWidget);
-    if (!q->testAttribute(Qt::WA_WState_Created))
+    if (enable == touchEventsEnabled)
         return;
-#ifndef QT_MAC_USE_COCOA
-    // Needs implementation!
-#else
-    NSView *view = qt_mac_nativeview_for(q);
-    [view setAcceptsTouchEvents:YES];
+
+    QCocoaView *view = static_cast<QCocoaView *>(qt_mac_effectiveview_for(q));
+    if (!view)
+        return;
+
+    if (enable) {
+        ++view->alienTouchCount;
+        if (view->alienTouchCount == 1) {
+            touchEventsEnabled = true;
+            [view setAcceptsTouchEvents:YES];
+        }
+    } else {
+        --view->alienTouchCount;
+        if (view->alienTouchCount == 0) {
+            touchEventsEnabled = false;
+            [view setAcceptsTouchEvents:NO];
+        }
+    }
 #endif
 #endif
 }
@@ -4837,13 +5026,17 @@ void QWidgetPrivate::registerTouchWindow()
 void QWidgetPrivate::setMask_sys(const QRegion &region)
 {
     Q_UNUSED(region);
-#ifndef QT_MAC_USE_COCOA
     Q_Q(QWidget);
+
+#ifndef QT_MAC_USE_COCOA
     if (q->isWindow())
         ReshapeCustomWindow(qt_mac_window_for(q));
     else
         HIViewReshapeStructure(qt_mac_nativeview_for(q));
 #else
+    if (!q->internalWinId())
+        return;
+
     if (extra->mask.isEmpty()) {
         extra->maskBits = QImage();
         finishCocoaMaskSetup();
@@ -4851,6 +5044,7 @@ void QWidgetPrivate::setMask_sys(const QRegion &region)
         syncCocoaMask();
     }
 
+    topLevelAt_cache = 0;
 #endif
 }
 
@@ -4928,7 +5122,7 @@ void QWidgetPrivate::finishCocoaMaskSetup()
         [window setOpaque:(extra->imageMask == 0)];
         [window invalidateShadow];
     }
-    qt_mac_set_needs_display(q, QRegion());
+    macSetNeedsDisplay(QRegion());
 }
 #endif
 
diff --git a/src/gui/kernel/qwidget_p.h b/src/gui/kernel/qwidget_p.h
index 2e82aa6..1083a1f 100644
--- a/src/gui/kernel/qwidget_p.h
+++ b/src/gui/kernel/qwidget_p.h
@@ -361,7 +361,8 @@ public:
         DrawInvisible = 0x08,
         DontSubtractOpaqueChildren = 0x10,
         DontSetCompositionMode = 0x20,
-        DontDrawOpaqueChildren = 0x40
+        DontDrawOpaqueChildren = 0x40,
+        DontDrawNativeChildren = 0x80
     };
 
     enum CloseMode {
@@ -567,6 +568,7 @@ public:
     // sub-classes that their internals are about to be released.
     virtual void aboutToDestroy() {}
 
+    QInputContext *assignedInputContext() const;
     QInputContext *inputContext() const;
     inline QWidget *effectiveFocusWidget() {
         QWidget *w = q_func();
@@ -775,6 +777,8 @@ public:
     void x11UpdateIsOpaque();
     bool isBackgroundInherited() const;
     void updateX11AcceptFocus();
+    QPoint mapToGlobal(const QPoint &pos) const;
+    QPoint mapFromGlobal(const QPoint &pos) const;
 #elif defined(Q_WS_WIN) // <--------------------------------------------------------- WIN
     uint noPaintOnScreen : 1; // see qwidget_win.cpp ::paintEngine()
 #ifndef QT_NO_GESTURES
@@ -793,7 +797,6 @@ public:
 #elif defined(Q_WS_MAC) // <--------------------------------------------------------- MAC
     // This is new stuff
     uint needWindowChange : 1;
-    uint hasAlienChildren : 1;
 
     // Each wiget keeps a list of all its child and grandchild OpenGL widgets.
     // This list is used to update the gl context whenever a parent and a granparent
@@ -824,6 +827,7 @@ public:
     void macUpdateIgnoreMouseEvents();
     void macUpdateMetalAttribute();
     void macUpdateIsOpaque();
+    void macSetNeedsDisplay(QRegion region);
     void setEnabled_helper_sys(bool enable);
     bool isRealWindow() const;
     void adjustWithinMaxAndMinSize(int &w, int &h);
@@ -859,6 +863,7 @@ public:
     bool isInUnifiedToolbar;
     QWindowSurface *unifiedSurface;
     QPoint toolbar_offset;
+    bool touchEventsEnabled;
 #endif
     void determineWindowClass();
     void transferChildren();
@@ -871,7 +876,7 @@ public:
     static OSStatus qt_window_event(EventHandlerCallRef er, EventRef event, void *);
     static OSStatus qt_widget_event(EventHandlerCallRef er, EventRef event, void *);
     static bool qt_widget_rgn(QWidget *, short, RgnHandle, bool);
-    void registerTouchWindow();
+    void registerTouchWindow(bool enable = true);
 #elif defined(Q_WS_QWS) // <--------------------------------------------------------- QWS
     void setMaxWindowState_helper();
     void setFullScreenSize_helper();
diff --git a/src/gui/kernel/qwidget_s60.cpp b/src/gui/kernel/qwidget_s60.cpp
index cb72800..85164d2 100644
--- a/src/gui/kernel/qwidget_s60.cpp
+++ b/src/gui/kernel/qwidget_s60.cpp
@@ -63,6 +63,19 @@
 // CCoeControl objects until after the CONE event handler has finished running.
 Q_DECLARE_METATYPE(WId)
 
+// Workaround for the fact that S60 SDKs 3.x do not contain the akntoolbar.h
+// header, even though the documentation says that it should be there, and indeed
+// it is present in the library.
+class CAknToolbar : public CAknControl,
+                    public MCoeControlObserver,
+                    public MCoeControlBackground,
+                    public MEikCommandObserver,
+                    public MAknFadedComponent
+{
+public:
+    IMPORT_C void SetToolbarVisibility(const TBool visible);
+};
+
 QT_BEGIN_NAMESPACE
 
 extern bool qt_nograb();
@@ -488,6 +501,7 @@ void QWidgetPrivate::show_sys()
 
          QSymbianControl *id = static_cast<QSymbianControl *>(q->internalWinId());
          const bool isFullscreen = q->windowState() & Qt::WindowFullScreen;
+         const TBool cbaRequested = q->windowFlags() & Qt::WindowSoftkeysVisibleHint;
 
 #ifdef Q_WS_S60
         // Lazily initialize the S60 screen furniture when the first window is shown.
@@ -507,11 +521,25 @@ void QWidgetPrivate::show_sys()
 
                     CEikButtonGroupContainer *cba = CEikButtonGroupContainer::NewL(CEikButtonGroupContainer::ECba,
                         CEikButtonGroupContainer::EHorizontal,ui,R_AVKON_SOFTKEYS_EMPTY_WITH_IDS);
+                    if (isFullscreen && !cbaRequested)
+                        cba->MakeVisible(false);
 
                     CEikButtonGroupContainer *oldCba = factory->SwapButtonGroup(cba);
                     Q_ASSERT(!oldCba);
                     S60->setButtonGroupContainer(cba);
 
+                    // If the creation of the first widget is delayed, for example by doing it
+                    // inside the event loop, S60 somehow "forgets" to set the visibility of the
+                    // toolbar (the three middle softkeys) when you flip the phone over, so we
+                    // need to do it ourselves to avoid a "hole" in the application, even though
+                    // Qt itself does not use the toolbar directly..
+                    CAknAppUi *appui = dynamic_cast<CAknAppUi *>(CEikonEnv::Static()->AppUi());
+                    if (appui) {
+                        CAknToolbar *toolbar = appui->PopupToolbar();
+                        if (toolbar && !toolbar->IsVisible())
+                            toolbar->SetToolbarVisibility(ETrue);
+                    }
+
                     CEikMenuBar *menuBar = new(ELeave) CEikMenuBar;
                     menuBar->ConstructL(ui, 0, R_AVKON_MENUPANE_EMPTY);
                     menuBar->SetMenuType(CEikMenuBar::EMenuOptions);
@@ -1160,14 +1188,17 @@ void QWidget::setWindowState(Qt::WindowStates newstate)
         }
 
 #ifdef Q_WS_S60
-        // Hide window decoration when switching to fullsccreen / minimized otherwise show decoration.
-        // The window decoration visibility has to be changed before doing actual window state
-        // change since in that order the availableGeometry will return directly the right size and
-        // we will avoid unnecessarty redraws
-        const bool visible = !(newstate & (Qt::WindowFullScreen | Qt::WindowMinimized));
-        const bool statusPaneVisibility = visible;
-        const bool buttonGroupVisibility = (visible || (isFullscreen && cbaRequested));
-        S60->setStatusPaneAndButtonGroupVisibility(statusPaneVisibility, buttonGroupVisibility);
+        bool decorationsVisible(false);
+        if (!parentWidget()) { // Only top level native windows have control over cba/status pane
+            // Hide window decoration when switching to fullscreen / minimized otherwise show decoration.
+            // The window decoration visibility has to be changed before doing actual window state
+            // change since in that order the availableGeometry will return directly the right size and
+            // we will avoid unnecessary redraws
+            decorationsVisible = !(newstate & (Qt::WindowFullScreen | Qt::WindowMinimized));
+            const bool statusPaneVisibility = decorationsVisible;
+            const bool buttonGroupVisibility = (decorationsVisible || (isFullscreen && cbaRequested));
+            S60->setStatusPaneAndButtonGroupVisibility(statusPaneVisibility, buttonGroupVisibility);
+        }
 #endif // Q_WS_S60
 
         // Ensure the initial size is valid, since we store it as normalGeometry below.
@@ -1191,7 +1222,7 @@ void QWidget::setWindowState(Qt::WindowStates newstate)
             // accurate because it did not consider the status pane. This means that when returning
             // normal mode after showing the status pane, the geometry would overlap so we should
             // move it if it never had an explicit position.
-            if (!wasMoved && S60->statusPane() && visible) {
+            if (!wasMoved && S60->statusPane() && decorationsVisible) {
                 TPoint tl = static_cast<CEikAppUi*>(S60->appUi())->ClientRect().iTl;
                 normalGeometry.setTopLeft(QPoint(tl.iX, tl.iY));
             }
diff --git a/src/gui/kernel/qwidget_x11.cpp b/src/gui/kernel/qwidget_x11.cpp
index cf23981..b378b78 100644
--- a/src/gui/kernel/qwidget_x11.cpp
+++ b/src/gui/kernel/qwidget_x11.cpp
@@ -444,6 +444,7 @@ static QVector<Atom> getNetWmState(QWidget *w)
         && actualType == XA_ATOM && actualFormat == 32) {
         returnValue.resize(bytesLeft / 4);
         XFree((char*) propertyData);
+        propertyData = 0;
 
         // fetch all data
         if (XGetWindowProperty(X11->display, w->internalWinId(), ATOM(_NET_WM_STATE), 0,
@@ -458,7 +459,8 @@ static QVector<Atom> getNetWmState(QWidget *w)
         if (!returnValue.isEmpty()) {
             memcpy(returnValue.data(), propertyData, returnValue.size() * sizeof(Atom));
         }
-        XFree((char*) propertyData);
+        if (propertyData)
+            XFree((char*) propertyData);
     }
 
     return returnValue;
@@ -1289,39 +1291,49 @@ void QWidgetPrivate::setParent_sys(QWidget *parent, Qt::WindowFlags f)
 #endif
 }
 
-
-QPoint QWidget::mapToGlobal(const QPoint &pos) const
+QPoint QWidgetPrivate::mapToGlobal(const QPoint &pos) const
 {
-    Q_D(const QWidget);
-    if (!testAttribute(Qt::WA_WState_Created) || !internalWinId()) {
-        QPoint p = pos + data->crect.topLeft();
+    Q_Q(const QWidget);
+    if (!q->testAttribute(Qt::WA_WState_Created) || !q->internalWinId()) {
+        QPoint p = pos + q->data->crect.topLeft();
         //cannot trust that !isWindow() implies parentWidget() before create
-        return (isWindow() || !parentWidget()) ?  p : parentWidget()->mapToGlobal(p);
+        return (q->isWindow() || !q->parentWidget()) ?  p : q->parentWidget()->d_func()->mapToGlobal(p);
     }
-    int           x, y;
+    int x, y;
     Window child;
-    QPoint p = d->mapToWS(pos);
-    XTranslateCoordinates(X11->display, internalWinId(),
-                          QApplication::desktop()->screen(d->xinfo.screen())->internalWinId(),
+    QPoint p = mapToWS(pos);
+    XTranslateCoordinates(X11->display, q->internalWinId(),
+                          QApplication::desktop()->screen(xinfo.screen())->internalWinId(),
                           p.x(), p.y(), &x, &y, &child);
     return QPoint(x, y);
 }
 
-
-QPoint QWidget::mapFromGlobal(const QPoint &pos) const
+QPoint QWidgetPrivate::mapFromGlobal(const QPoint &pos) const
 {
-    Q_D(const QWidget);
-    if (!testAttribute(Qt::WA_WState_Created) || !internalWinId()) {
+    Q_Q(const QWidget);
+    if (!q->testAttribute(Qt::WA_WState_Created) || !q->internalWinId()) {
         //cannot trust that !isWindow() implies parentWidget() before create
-        QPoint p = (isWindow() || !parentWidget()) ?  pos : parentWidget()->mapFromGlobal(pos);
-        return p - data->crect.topLeft();
+        QPoint p = (q->isWindow() || !q->parentWidget()) ?  pos : q->parentWidget()->d_func()->mapFromGlobal(pos);
+        return p - q->data->crect.topLeft();
     }
-    int           x, y;
+    int x, y;
     Window child;
     XTranslateCoordinates(X11->display,
-                          QApplication::desktop()->screen(d->xinfo.screen())->internalWinId(),
-                          internalWinId(), pos.x(), pos.y(), &x, &y, &child);
-    return d->mapFromWS(QPoint(x, y));
+                          QApplication::desktop()->screen(xinfo.screen())->internalWinId(),
+                          q->internalWinId(), pos.x(), pos.y(), &x, &y, &child);
+    return mapFromWS(QPoint(x, y));
+}
+
+QPoint QWidget::mapToGlobal(const QPoint &pos) const
+{
+    Q_D(const QWidget);
+    return d->mapToGlobal(pos);
+}
+
+QPoint QWidget::mapFromGlobal(const QPoint &pos) const
+{
+    Q_D(const QWidget);
+    return d->mapFromGlobal(pos);
 }
 
 void QWidgetPrivate::updateSystemBackground()
diff --git a/src/gui/kernel/qx11embed_x11.cpp b/src/gui/kernel/qx11embed_x11.cpp
index 47cefe4..49a8194 100644
--- a/src/gui/kernel/qx11embed_x11.cpp
+++ b/src/gui/kernel/qx11embed_x11.cpp
@@ -415,8 +415,9 @@ static Bool functor(Display *display, XEvent *event, XPointer arg)
 	status = XGetWindowProperty(display, data->id, ATOM(WM_STATE), 0, 2, False, ATOM(WM_STATE),
 				    &ret, &format, &nitems, &after, &retval );
 	if (status == Success && ret == ATOM(WM_STATE) && format == 32 && nitems > 0) {
-            long *state = (long *)retval;
-	    if (state[0] == WithdrawnState) {
+            long state = *(long *)retval;
+            XFree(retval);
+            if (state == WithdrawnState) {
                 data->clearedWmState = true;
 		return true;
             }
@@ -833,6 +834,8 @@ bool QX11EmbedWidget::x11Event(XEvent *event)
                         XUnmapWindow(x11Info().display(), internalWinId());
                     }
                 }
+                if (prop_return)
+                    XFree(prop_return);
             }
         }
 
diff --git a/src/gui/math3d/qgenericmatrix.h b/src/gui/math3d/qgenericmatrix.h
index d9aef20..181eda8 100644
--- a/src/gui/math3d/qgenericmatrix.h
+++ b/src/gui/math3d/qgenericmatrix.h
@@ -79,9 +79,9 @@ public:
 
     void copyDataTo(T *values) const;
 
-    T *data() { return m[0]; }
-    const T *data() const { return m[0]; }
-    const T *constData() const { return m[0]; }
+    T *data() { return *m; }
+    const T *data() const { return *m; }
+    const T *constData() const { return *m; }
 
 #if !defined(Q_NO_TEMPLATE_FRIENDS)
     template<int NN, int MM, typename TT>
diff --git a/src/gui/math3d/qmatrix4x4.h b/src/gui/math3d/qmatrix4x4.h
index 706450a..ad05116 100644
--- a/src/gui/math3d/qmatrix4x4.h
+++ b/src/gui/math3d/qmatrix4x4.h
@@ -173,8 +173,8 @@ public:
     QGenericMatrix<N, M, qreal> toGenericMatrix() const;
 
     inline qreal *data();
-    inline const qreal *data() const { return m[0]; }
-    inline const qreal *constData() const { return m[0]; }
+    inline const qreal *data() const { return *m; }
+    inline const qreal *constData() const { return *m; }
 
     void optimize();
 
@@ -974,7 +974,7 @@ inline qreal *QMatrix4x4::data()
     // We have to assume that the caller will modify the matrix elements,
     // so we flip it over to "General" mode.
     flagBits = General;
-    return m[0];
+    return *m;
 }
 
 #ifndef QT_NO_DEBUG_STREAM
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/qbrush.cpp b/src/gui/painting/qbrush.cpp
index 5741667..811f3ae 100644
--- a/src/gui/painting/qbrush.cpp
+++ b/src/gui/painting/qbrush.cpp
@@ -1217,14 +1217,14 @@ QDataStream &operator>>(QDataStream &s, QBrush &b)
     Each of the types is represented by a subclass of QGradient:
 
     \table
-    \row
-    \o \inlineimage qgradient-linear.png
-    \o \inlineimage qgradient-radial.png
-    \o \inlineimage qgradient-conical.png
     \header
     \o QLinearGradient
     \o QRadialGradient
     \o QConicalGradient
+    \row
+    \o \inlineimage qgradient-linear.png
+    \o \inlineimage qgradient-radial.png
+    \o \inlineimage qgradient-conical.png
     \endtable
 
     The colors in a gradient are defined using stop points of the
diff --git a/src/gui/painting/qcolor.cpp b/src/gui/painting/qcolor.cpp
index dea3a72..73a6ed8 100644
--- a/src/gui/painting/qcolor.cpp
+++ b/src/gui/painting/qcolor.cpp
@@ -78,12 +78,12 @@ QT_BEGIN_NAMESPACE
     names.
 
     \table
+    \header
+    \o RGB \o HSV \o CMYK
     \row
     \o \inlineimage qcolor-rgb.png
     \o \inlineimage qcolor-hsv.png
     \o \inlineimage qcolor-cmyk.png
-    \header
-    \o RGB \o HSV \o CMYK
     \endtable
 
     The QColor constructor creates the color based on RGB values.  To
@@ -1781,7 +1781,7 @@ QColor QColor::toHsl() const
     color.ct.ahsl.lightness = qRound(lightness * USHRT_MAX);
     if (qFuzzyIsNull(delta)) {
         // achromatic case, hue is undefined
-        color.ct.ahsl.hue = 0;
+        color.ct.ahsl.hue = USHRT_MAX;
         color.ct.ahsl.saturation = 0;
     } else {
         // chromatic case
diff --git a/src/gui/painting/qdrawhelper.cpp b/src/gui/painting/qdrawhelper.cpp
index 9928dea..5904296 100644
--- a/src/gui/painting/qdrawhelper.cpp
+++ b/src/gui/painting/qdrawhelper.cpp
@@ -43,7 +43,9 @@
 #include <private/qpaintengine_raster_p.h>
 #include <private/qpainter_p.h>
 #include <private/qdrawhelper_x86_p.h>
+#ifdef QT_HAVE_ARM_SIMD
 #include <private/qdrawhelper_arm_simd_p.h>
+#endif
 #include <private/qdrawhelper_neon_p.h>
 #include <private/qmath_p.h>
 #include <qmath.h>
diff --git a/src/gui/painting/qdrawhelper_arm_simd.cpp b/src/gui/painting/qdrawhelper_arm_simd.cpp
index 806df29..af9854c 100644
--- a/src/gui/painting/qdrawhelper_arm_simd.cpp
+++ b/src/gui/painting/qdrawhelper_arm_simd.cpp
@@ -201,8 +201,8 @@ argb32constalpha_next_pixel
     uxtb16  r10, r9
     uxtb16  r6, r9, ror #8
 
-    // Negate r11 and extract src alpha
-    mvn     r9, r11 // bitwise not
+    // Negate r8 and extract src alpha
+    mvn     r9, r8 // bitwise not
     uxtb    r9, r9, ror #24
 
     mla     r10, r9, r10, r14
diff --git a/src/gui/painting/qgraphicssystem_runtime.cpp b/src/gui/painting/qgraphicssystem_runtime.cpp
index 0294c4b..5841d40 100644
--- a/src/gui/painting/qgraphicssystem_runtime.cpp
+++ b/src/gui/painting/qgraphicssystem_runtime.cpp
@@ -285,6 +285,7 @@ void QRuntimeWindowSurface::flush(QWidget *widget, const QRegion &region,
 
 void QRuntimeWindowSurface::setGeometry(const QRect &rect)
 {
+    QWindowSurface::setGeometry(rect);
     m_windowSurface->setGeometry(rect);
 }
 
diff --git a/src/gui/painting/qpaintengine_raster.cpp b/src/gui/painting/qpaintengine_raster.cpp
index 47caa9f..9242fb6 100644
--- a/src/gui/painting/qpaintengine_raster.cpp
+++ b/src/gui/painting/qpaintengine_raster.cpp
@@ -662,19 +662,19 @@ QRasterPaintEngineState::QRasterPaintEngineState()
 
 QRasterPaintEngineState::QRasterPaintEngineState(QRasterPaintEngineState &s)
     : QPainterState(s)
+    , lastPen(s.lastPen)
+    , penData(s.penData)
     , stroker(s.stroker)
+    , strokeFlags(s.strokeFlags)
     , lastBrush(s.lastBrush)
     , brushData(s.brushData)
-    , lastPen(s.lastPen)
-    , penData(s.penData)
     , fillFlags(s.fillFlags)
-    , strokeFlags(s.strokeFlags)
     , pixmapFlags(s.pixmapFlags)
     , intOpacity(s.intOpacity)
     , txscale(s.txscale)
-    , flag_bits(s.flag_bits)
     , clip(s.clip)
     , dirty(s.dirty)
+    , flag_bits(s.flag_bits)
 {
     brushData.tempImage = 0;
     penData.tempImage = 0;
@@ -3716,6 +3716,13 @@ void QRasterPaintEnginePrivate::rasterizeLine_dashed(QLineF line,
     const bool squareCap = (pen.capStyle() == Qt::SquareCap);
     const QVector<qreal> pattern = pen.dashPattern();
 
+    qreal patternLength = 0;
+    for (int i = 0; i < pattern.size(); ++i)
+        patternLength += pattern.at(i);
+
+    if (patternLength <= 0)
+        return;
+
     qreal length = line.length();
     Q_ASSERT(length > 0);
     while (length > 0) {
diff --git a/src/gui/painting/qpainter.cpp b/src/gui/painting/qpainter.cpp
index a5f4251..2c25e70 100644
--- a/src/gui/painting/qpainter.cpp
+++ b/src/gui/painting/qpainter.cpp
@@ -1126,14 +1126,14 @@ void QPainterPrivate::updateState(QPainterState *newState)
     the range of available patterns.
 
     \table
-    \row
-    \o \inlineimage qpainter-vectordeformation.png
-    \o \inlineimage qpainter-gradients.png
-    \o \inlineimage qpainter-pathstroking.png
     \header
     \o \l {demos/deform}{Vector Deformation}
     \o \l {demos/gradients}{Gradients}
     \o \l {demos/pathstroke}{Path Stroking}
+    \row
+    \o \inlineimage qpainter-vectordeformation.png
+    \o \inlineimage qpainter-gradients.png
+    \o \inlineimage qpainter-pathstroking.png
     \endtable
 
 
@@ -1206,13 +1206,13 @@ void QPainterPrivate::updateState(QPainterState *newState)
     coordinate transformations.
 
     \table
+    \header
+    \o  nop \o rotate() \o scale() \o translate()
     \row
     \o \inlineimage qpainter-clock.png
     \o \inlineimage qpainter-rotation.png
     \o \inlineimage qpainter-scale.png
     \o \inlineimage qpainter-translation.png
-    \header
-    \o  nop \o rotate() \o scale() \o translate()
     \endtable
 
     The most commonly used transformations are scaling, rotation,
diff --git a/src/gui/painting/qpainterpath.cpp b/src/gui/painting/qpainterpath.cpp
index 9f49b2f..8bff021 100644
--- a/src/gui/painting/qpainterpath.cpp
+++ b/src/gui/painting/qpainterpath.cpp
@@ -240,12 +240,12 @@ static void qt_debug_path(const QPainterPath &path)
     provides two methods for filling paths:
 
     \table
-    \row
-    \o \inlineimage qt-fillrule-oddeven.png
-    \o \inlineimage qt-fillrule-winding.png
     \header
     \o Qt::OddEvenFill
     \o Qt::WindingFill
+    \row
+    \o \inlineimage qt-fillrule-oddeven.png
+    \o \inlineimage qt-fillrule-winding.png
     \endtable
 
     See the Qt::FillRule documentation for the definition of the
@@ -315,12 +315,12 @@ static void qt_debug_path(const QPainterPath &path)
     QPainterPath to draw text.
 
     \table
-    \row
-    \o \inlineimage qpainterpath-example.png
-    \o \inlineimage qpainterpath-demo.png
     \header
     \o \l {painting/painterpaths}{Painter Paths Example}
     \o \l {demos/deform}{Vector Deformation Demo}
+    \row
+    \o \inlineimage qpainterpath-example.png
+    \o \inlineimage qpainterpath-demo.png
     \endtable
 
     \sa QPainterPathStroker, QPainter, QRegion, {Painter Paths Example}
@@ -874,7 +874,7 @@ void QPainterPath::arcTo(const QRectF &rect, qreal startAngle, qreal sweepLength
            rect.x(), rect.y(), rect.width(), rect.height(), startAngle, sweepLength);
 #endif
 
-    if (!qt_is_finite(rect.x()) && !qt_is_finite(rect.y()) || !qt_is_finite(rect.width()) || !qt_is_finite(rect.height())
+    if ((!qt_is_finite(rect.x()) && !qt_is_finite(rect.y())) || !qt_is_finite(rect.width()) || !qt_is_finite(rect.height())
         || !qt_is_finite(startAngle) || !qt_is_finite(sweepLength)) {
 #ifndef QT_NO_DEBUG
         qWarning("QPainterPath::arcTo: Adding arc where a parameter is NaN or Inf, ignoring call");
@@ -1279,12 +1279,12 @@ Qt::FillRule QPainterPath::fillRule() const
     fillRule. Qt provides two methods for filling paths:
 
     \table
-    \row
-    \o \inlineimage qt-fillrule-oddeven.png
-    \o \inlineimage qt-fillrule-winding.png
     \header
     \o Qt::OddEvenFill (default)
     \o Qt::WindingFill
+    \row
+    \o \inlineimage qt-fillrule-oddeven.png
+    \o \inlineimage qt-fillrule-winding.png
     \endtable
 
     \sa fillRule()
@@ -2923,9 +2923,12 @@ QPointF QPainterPath::pointAtPercent(qreal t) const
         return QPointF();
     }
 
-    if (isEmpty())
+    if (!d_ptr || d_ptr->elements.size() == 0)
         return QPointF();
 
+    if (d_ptr->elements.size() == 1)
+        return d_ptr->elements.at(0);
+
     qreal totalLength = length();
     qreal curLen = 0;
     qreal bezierLen = 0;
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/qwindowsurface_raster.cpp b/src/gui/painting/qwindowsurface_raster.cpp
index d0b9239..419518ac 100644
--- a/src/gui/painting/qwindowsurface_raster.cpp
+++ b/src/gui/painting/qwindowsurface_raster.cpp
@@ -78,6 +78,9 @@ public:
 
 #ifdef Q_WS_X11
     GC gc;
+#ifndef QT_NO_MITSHM
+    uint needsSync : 1;
+#endif
 #ifndef QT_NO_XRENDER
     uint translucentBackground : 1;
 #endif
@@ -94,6 +97,9 @@ QRasterWindowSurface::QRasterWindowSurface(QWidget *window, bool setDefaultSurfa
     d_ptr->translucentBackground = X11->use_xrender
         && window->x11Info().depth() == 32;
 #endif
+#ifndef QT_NO_MITHSM
+    d_ptr->needsSync = false;
+#endif
 #endif
     d_ptr->image = 0;
     d_ptr->inSetGeometry = false;
@@ -116,8 +122,23 @@ QPaintDevice *QRasterWindowSurface::paintDevice()
     return &d_ptr->image->image;
 }
 
+#if defined(Q_WS_X11) && !defined(QT_NO_MITSHM)
+void QRasterWindowSurface::syncX()
+{
+    // delay writing to the backbuffer until we know for sure X is done reading from it
+    if (d_ptr->needsSync) {
+        XSync(X11->display, false);
+        d_ptr->needsSync = false;
+    }
+}
+#endif
+
 void QRasterWindowSurface::beginPaint(const QRegion &rgn)
 {
+#if defined(Q_WS_X11) && !defined(QT_NO_MITSHM)
+    syncX();
+#endif
+
 #if (defined(Q_WS_X11) && !defined(QT_NO_XRENDER)) || (defined(Q_WS_WIN) && !defined(Q_WS_WINCE))
     if (!qt_widget_private(window())->isOpaque && window()->testAttribute(Qt::WA_TranslucentBackground)) {
 #if defined(Q_WS_WIN) && !defined(Q_WS_WINCE)
@@ -217,13 +238,13 @@ void QRasterWindowSurface::flush(QWidget *widget, const QRegion &rgn, const QPoi
     if (d_ptr->image->xshmpm) {
         XCopyArea(X11->display, d_ptr->image->xshmpm, widget->handle(), d_ptr->gc,
                   br.x(), br.y(), br.width(), br.height(), wbr.x(), wbr.y());
-        XSync(X11->display, False);
+        d_ptr->needsSync = true;
     } else if (d_ptr->image->xshmimg) {
         const QImage &src = d->image->image;
         br = br.intersected(src.rect());
         XShmPutImage(X11->display, widget->handle(), d_ptr->gc, d_ptr->image->xshmimg,
                      br.x(), br.y(), wbr.x(), wbr.y(), br.width(), br.height(), False);
-        XSync(X11->display, False);
+        d_ptr->needsSync = true;
     } else
 #endif
     {
@@ -282,6 +303,7 @@ void QRasterWindowSurface::flush(QWidget *widget, const QRegion &rgn, const QPoi
     CGrafPtr port = GetWindowPort(qt_mac_window_for(widget));
     QDBeginCGContext(port, &context);
 #else
+    QMacCocoaAutoReleasePool pool;
     extern CGContextRef qt_mac_graphicsContextFor(QWidget *);
     CGContextRef context = qt_mac_graphicsContextFor(widget);
 #endif
@@ -391,6 +413,10 @@ bool QRasterWindowSurface::scroll(const QRegion &area, int dx, int dy)
     if (!d->image || d->image->image.isNull())
         return false;
 
+#if defined(Q_WS_X11) && !defined(QT_NO_MITSHM)
+    syncX();
+#endif
+
     const QVector<QRect> rects = area.rects();
     for (int i = 0; i < rects.size(); ++i)
         qt_scrollRectInImage(d->image->image, rects.at(i), QPoint(dx, dy));
diff --git a/src/gui/painting/qwindowsurface_raster_p.h b/src/gui/painting/qwindowsurface_raster_p.h
index b6e61e1..903810b 100644
--- a/src/gui/painting/qwindowsurface_raster_p.h
+++ b/src/gui/painting/qwindowsurface_raster_p.h
@@ -107,6 +107,9 @@ public:
     bool scroll(const QRegion &area, int dx, int dy);
 
 private:
+#if defined(Q_WS_X11) && !defined(QT_NO_MITSHM)
+    void syncX();
+#endif
     void prepareBuffer(QImage::Format format, QWidget *widget);
     Q_DECLARE_PRIVATE(QRasterWindowSurface)
     QScopedPointer<QRasterWindowSurfacePrivate> d_ptr;
diff --git a/src/gui/painting/qwindowsurface_s60.cpp b/src/gui/painting/qwindowsurface_s60.cpp
index a860818..71556d7 100644
--- a/src/gui/painting/qwindowsurface_s60.cpp
+++ b/src/gui/painting/qwindowsurface_s60.cpp
@@ -61,13 +61,11 @@ struct QS60WindowSurfacePrivate
     QList<QImage*> bufferImages;
 };
 
-QS60WindowSurface::QS60WindowSurface(QWidget* widget)
-    : QWindowSurface(widget), d_ptr(new QS60WindowSurfacePrivate)
+TDisplayMode displayMode(bool opaque)
 {
 
     TDisplayMode mode = S60->screenDevice()->DisplayMode();
-    bool isOpaque = qt_widget_private(widget)->isOpaque;
-    if (isOpaque) {
+    if (opaque) {
         mode = EColor16MU;
     } else  {
         if (QSysInfo::symbianVersion() >= QSysInfo::SV_SF_3)
@@ -75,7 +73,13 @@ QS60WindowSurface::QS60WindowSurface(QWidget* widget)
         else
             mode = EColor16MA; // Symbian prior to Symbian^3 sw accelerates EColor16MA
     }
+    return mode;
+}
 
+QS60WindowSurface::QS60WindowSurface(QWidget* widget)
+    : QWindowSurface(widget), d_ptr(new QS60WindowSurfacePrivate)
+{
+    TDisplayMode mode = displayMode(qt_widget_private(widget)->isOpaque);
     // We create empty CFbsBitmap here -> it will be resized in setGeometry
     CFbsBitmap *bitmap = new CFbsBitmap;	// CBase derived object needs check on new
     Q_CHECK_PTR(bitmap);
@@ -122,6 +126,11 @@ void QS60WindowSurface::beginPaint(const QRegion &rgn)
 
     if (!qt_widget_private(window())->isOpaque) {
         QS60PixmapData *pixmapData = static_cast<QS60PixmapData *>(d_ptr->device.data_ptr().data());
+
+        TDisplayMode mode = displayMode(false);
+        if (pixmapData->cfbsBitmap->DisplayMode() != mode)
+            pixmapData->convertToDisplayMode(mode);
+
         pixmapData->beginDataAccess();
 
         QPainter p(&pixmapData->image);
diff --git a/src/gui/s60framework/qs60mainappui.cpp b/src/gui/s60framework/qs60mainappui.cpp
index b5b8b81..0c99f80 100644
--- a/src/gui/s60framework/qs60mainappui.cpp
+++ b/src/gui/s60framework/qs60mainappui.cpp
@@ -49,6 +49,7 @@
 #include <avkon.rsg>
 #endif
 #include <barsread.h>
+#include <coeutils.h>
 #include <qconfig.h>
 
 #include "qs60mainappui.h"
@@ -401,6 +402,16 @@ void QS60MainAppUi::HandleForegroundEventL(TBool aForeground)
     QS60MainAppUiBase::HandleForegroundEventL(aForeground);
 }
 
+/*!
+  \internal
+*/
+TBool QS60MainAppUi::ProcessCommandParametersL(TApaCommand /*aCommand*/, TFileName &/*aDocumentName*/, const TDesC8 &/*aTail*/)
+{
+    // bypass CEikAppUi::ProcessCommandParametersL(..) which modifies aDocumentName, preventing apparc document opening from working.
+    // The return value is effectively unused in Qt apps (see QS60MainDocument::OpenFileL)
+    return EFalse;
+}
+
 #ifndef Q_WS_S60
 
 void QS60StubAknAppUi::HandleViewDeactivation(const TVwsViewId &, const TVwsViewId &) {}
diff --git a/src/gui/s60framework/qs60mainappui.h b/src/gui/s60framework/qs60mainappui.h
index ce3b5b0..bf118ff 100644
--- a/src/gui/s60framework/qs60mainappui.h
+++ b/src/gui/s60framework/qs60mainappui.h
@@ -131,6 +131,7 @@ public:
     virtual void HandleViewDeactivation(const TVwsViewId &aViewIdToBeDeactivated, const TVwsViewId &aNewlyActivatedViewId);
     virtual void PrepareToExit();
     virtual void HandleTouchPaneSizeChange();
+    virtual TBool ProcessCommandParametersL(TApaCommand aCommand, TFileName &aDocumentName, const TDesC8 &aTail);
 
 protected:
     virtual void HandleScreenDeviceChangedL();
diff --git a/src/gui/s60framework/qs60maindocument.cpp b/src/gui/s60framework/qs60maindocument.cpp
index a8886ac..37bd55f 100644
--- a/src/gui/s60framework/qs60maindocument.cpp
+++ b/src/gui/s60framework/qs60maindocument.cpp
@@ -41,6 +41,9 @@
 
 #include "qs60mainappui.h"
 #include "qs60maindocument.h"
+#include "qcoreapplication.h"
+#include "qevent.h"
+#include "private/qcore_symbian_p.h"
 
 #include <exception>
 
@@ -108,9 +111,15 @@ CEikAppUi *QS60MainDocument::CreateAppUiL()
 /*!
   \internal
  */
-CFileStore *QS60MainDocument::OpenFileL(TBool aDoOpen, const TDesC &aFilename, RFs &aFs)
+CFileStore *QS60MainDocument::OpenFileL(TBool /*aDoOpen*/, const TDesC &aFilename, RFs &/*aFs*/)
 {
-    return QS60MainDocumentBase::OpenFileL(aDoOpen, aFilename, aFs);
+    QT_TRYCATCH_LEAVING( {
+        QCoreApplication* app = QCoreApplication::instance();
+        QString qname = qt_TDesC2QString(aFilename);
+        QFileOpenEvent* event = new QFileOpenEvent(qname);
+        app->postEvent(app, event);
+    })
+    return 0;
 }
 
 /*!
@@ -118,7 +127,12 @@ CFileStore *QS60MainDocument::OpenFileL(TBool aDoOpen, const TDesC &aFilename, R
  */
 void QS60MainDocument::OpenFileL(CFileStore *&aFileStore, RFile &aFile)
 {
-    QS60MainDocumentBase::OpenFileL(aFileStore, aFile);
+    QT_TRYCATCH_LEAVING( {
+        QCoreApplication* app = QCoreApplication::instance();
+        QFileOpenEvent* event = new QFileOpenEvent(aFile);
+        app->postEvent(app, event);
+        aFileStore = 0;
+    })
 }
 
 QT_END_NAMESPACE
diff --git a/src/gui/statemachine/qguistatemachine.cpp b/src/gui/statemachine/qguistatemachine.cpp
index eadb8ff..2a0de3c 100644
--- a/src/gui/statemachine/qguistatemachine.cpp
+++ b/src/gui/statemachine/qguistatemachine.cpp
@@ -404,6 +404,7 @@ static QEvent *cloneEvent(QEvent *e)
         we2->setButtons(we->buttons());
         we2->setModifiers(we->modifiers());
         we2->setOrientation(we->orientation());
+        we2->setDelta(we->delta());
         return we2;
     }
 #endif
diff --git a/src/gui/styles/qs60style.cpp b/src/gui/styles/qs60style.cpp
index c5e95f2e..ecc2539 100644
--- a/src/gui/styles/qs60style.cpp
+++ b/src/gui/styles/qs60style.cpp
@@ -96,7 +96,8 @@ const layoutHeader QS60StylePrivate::m_layoutHeaders[] = {
 {320,240,1,19,"QVGA Portrait"},
 {360,640,1,19,"NHD Landscape"},
 {640,360,1,19,"NHD Portrait"},
-{352,800,1,12,"E90 Landscape"}
+{352,800,1,12,"E90 Landscape"},
+{480,640,1,19,"VGA Landscape"}
 // *** End of generated data ***
 };
 const int QS60StylePrivate::m_numberOfLayouts =
@@ -108,7 +109,8 @@ const short QS60StylePrivate::data[][MAX_PIXELMETRICS] = {
 {5,0,-909,0,0,1,0,2,-1,8,14,22,15,15,7,164,-909,-909,-909,19,15,2,0,0,21,8,27,28,4,4,1,-909,-909,0,7,6,0,13,23,17,17,21,21,7,115,21,0,-909,-909,-909,-909,0,0,15,1,-909,0,0,-909,15,-909,-909,-909,-909,32,21,65,27,65,3,3,5,10,15,-909,5,58,13,5,0,4,4,7,9,4,4,-909,2,-909,-909,-909,-909,6,6,3,1,106},
 {7,0,-909,0,0,2,0,5,-1,25,69,46,37,37,9,258,-909,-909,-909,23,19,26,0,0,32,25,72,44,5,5,2,-909,-909,0,7,21,0,17,29,22,22,27,27,7,173,29,0,-909,-909,-909,-909,0,0,25,2,-909,0,0,-909,25,-909,-909,-909,-909,87,27,77,35,77,13,3,6,8,19,-909,7,74,19,7,0,5,5,8,12,5,5,-909,3,-909,-909,-909,-909,7,7,3,1,135},
 {7,0,-909,0,0,2,0,5,-1,25,68,46,37,37,9,258,-909,-909,-909,31,19,6,0,0,32,25,60,52,5,5,2,-909,-909,0,7,32,0,17,29,22,22,27,27,7,173,29,0,-909,-909,-909,-909,0,0,26,2,-909,0,0,-909,26,-909,-909,-909,-909,87,27,96,35,96,12,3,6,8,19,-909,7,74,22,7,0,5,5,8,12,5,5,-909,3,-909,-909,-909,-909,7,7,3,1,135},
-{7,0,-909,0,0,2,0,2,-1,10,20,27,18,18,9,301,-909,-909,-909,29,18,5,0,0,35,7,32,30,5,5,2,-909,-909,0,2,8,0,16,28,21,21,26,26,2,170,26,0,-909,-909,-909,-909,0,0,21,6,-909,0,0,-909,-909,-909,-909,-909,-909,54,26,265,34,265,5,5,6,3,18,-909,7,72,19,7,0,5,6,8,11,6,5,-909,2,-909,-909,-909,-909,5,5,3,1,106}
+{7,0,-909,0,0,2,0,2,-1,10,20,27,18,18,9,301,-909,-909,-909,29,18,5,0,0,35,7,32,30,5,5,2,-909,-909,0,2,8,0,16,28,21,21,26,26,2,170,26,0,-909,-909,-909,-909,0,0,21,6,-909,0,0,-909,-909,-909,-909,-909,-909,54,26,265,34,265,5,5,6,3,18,-909,7,72,19,7,0,5,6,8,11,6,5,-909,2,-909,-909,-909,-909,5,5,3,1,106},
+{9,0,-909,0,0,2,0,5,-1,34,99,76,51,51,25,352,-909,-909,-909,29,25,7,0,0,43,34,42,76,7,7,2,-909,-909,0,9,14,0,23,39,30,30,37,37,9,391,40,0,-909,-909,-909,-909,0,0,29,2,-909,0,0,-909,29,-909,-909,-909,-909,115,37,96,48,96,19,19,9,1,25,-909,9,101,24,9,0,7,7,7,16,7,7,-909,3,-909,-909,-909,-909,9,9,3,1,184}
 // *** End of generated data ***
 };
 
diff --git a/src/gui/styles/qs60style_s60.cpp b/src/gui/styles/qs60style_s60.cpp
index 04c40aa..605872e 100644
--- a/src/gui/styles/qs60style_s60.cpp
+++ b/src/gui/styles/qs60style_s60.cpp
@@ -1378,12 +1378,13 @@ QPixmap QS60StylePrivate::frame(SkinFrameElements frame, const QSize &size, Skin
 QPixmap QS60StylePrivate::backgroundTexture()
 {
     bool createNewBackground = false;
+    TRect applicationRect = (static_cast<CEikAppUi*>(S60->appUi())->ApplicationRect());
     if (!m_background) {
         createNewBackground = true;
     } else {
         //if background brush does not match screensize, re-create it
-        if (m_background->width() != S60->screenWidthInPixels ||
-            m_background->height() != S60->screenHeightInPixels) {
+        if (m_background->width() != applicationRect.Width() ||
+            m_background->height() != applicationRect.Height()) {
             delete m_background;
             createNewBackground = true;
         }
@@ -1391,7 +1392,7 @@ QPixmap QS60StylePrivate::backgroundTexture()
 
     if (createNewBackground) {
         QPixmap background = part(QS60StyleEnums::SP_QsnBgScreen,
-            QSize(S60->screenWidthInPixels, S60->screenHeightInPixels), 0, SkinElementFlags());
+                QSize(applicationRect.Width(), applicationRect.Height()), 0, SkinElementFlags());
         m_background = new QPixmap(background);
     }
     return *m_background;
@@ -1411,7 +1412,6 @@ QS60Style::QS60Style()
 void QS60StylePrivate::handleDynamicLayoutVariantSwitch()
 {
     clearCaches(QS60StylePrivate::CC_LayoutChange);
-    setBackgroundTexture(qApp);
     setActiveLayout();
     refreshUI();
     foreach (QWidget *widget, QApplication::allWidgets())
diff --git a/src/gui/styles/qstylesheetstyle.cpp b/src/gui/styles/qstylesheetstyle.cpp
index 4b591e2..ecf924c 100644
--- a/src/gui/styles/qstylesheetstyle.cpp
+++ b/src/gui/styles/qstylesheetstyle.cpp
@@ -4238,7 +4238,7 @@ void QStyleSheetStyle::drawPrimitive(PrimitiveElement pe, const QStyleOption *op
         return;
 
     case PE_Widget:
-        if (!rule.hasDrawable()) {
+        if (w && !rule.hasDrawable()) {
             QWidget *container = containerWidget(w);
             if (styleSheetCaches->autoFillDisabledWidgets.contains(container)
                 && (container == w || !renderRule(container, opt).hasBackground())) {
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_s60.cpp b/src/gui/text/qfont_s60.cpp
index c7d36ef..114191d 100644
--- a/src/gui/text/qfont_s60.cpp
+++ b/src/gui/text/qfont_s60.cpp
@@ -49,13 +49,14 @@ QT_BEGIN_NAMESPACE
 
 #ifdef QT_NO_FREETYPE
 Q_GLOBAL_STATIC(QMutex, lastResortFamilyMutex);
+#endif // QT_NO_FREETYPE
+
 extern QStringList qt_symbian_fontFamiliesOnFontServer(); // qfontdatabase_s60.cpp
 Q_GLOBAL_STATIC_WITH_INITIALIZER(QStringList, fontFamiliesOnFontServer, {
     // We are only interested in the initial font families. No Application fonts.
     // Therefore, we are allowed to cache the list.
     x->append(qt_symbian_fontFamiliesOnFontServer());
 });
-#endif // QT_NO_FREETYPE
 
 QString QFont::lastResortFont() const
 {
@@ -95,7 +96,20 @@ QString QFont::lastResortFamily() const
     const bool isJapaneseOrChineseSystem =
         User::Language() == ELangJapanese || User::Language() == ELangPrcChinese;
 
-    return QLatin1String(isJapaneseOrChineseSystem?"Heisei Kaku Gothic S60":"Series 60 Sans");
+    static QString family;
+    if (family.isEmpty()) {
+        QStringList families = qt_symbian_fontFamiliesOnFontServer();
+        const char* const preferredFamilies[] = {"Nokia Sans S60", "Series 60 Sans"};
+        for (int i = 0; i < sizeof preferredFamilies / sizeof preferredFamilies[0]; ++i) {
+            const QString preferredFamily = QLatin1String(preferredFamilies[i]);
+            if (families.contains(preferredFamily)) {
+                family = preferredFamily;
+                break;
+            }
+        }
+    }
+
+    return QLatin1String(isJapaneseOrChineseSystem?"Heisei Kaku Gothic S60":family.toLatin1());
 #endif // QT_NO_FREETYPE
 }
 
diff --git a/src/gui/text/qfontdatabase.cpp b/src/gui/text/qfontdatabase.cpp
index 20c72dd..8e92b1a 100644
--- a/src/gui/text/qfontdatabase.cpp
+++ b/src/gui/text/qfontdatabase.cpp
@@ -646,6 +646,10 @@ public:
     { }
     ~QFontDatabasePrivate() {
         free();
+#if defined(Q_OS_SYMBIAN) && defined(QT_NO_FREETYPE)
+        if (symbianExtras)
+            delete symbianExtras;
+#endif
     }
     QtFontFamily *family(const QString &f, bool = false);
     void free() {
@@ -654,12 +658,6 @@ public:
         ::free(families);
         families = 0;
         count = 0;
-#if defined(Q_OS_SYMBIAN) && defined(QT_NO_FREETYPE)
-        if (symbianExtras) {
-            delete symbianExtras;
-            symbianExtras = 0;
-        }
-#endif
         // don't clear the memory fonts!
     }
 
@@ -678,6 +676,10 @@ public:
         QVector<FONTSIGNATURE> signatures;
 #elif defined(Q_WS_MAC)
         ATSFontContainerRef handle;
+#elif defined(Q_OS_SYMBIAN) && defined(QT_NO_FREETYPE)
+        QString temporaryFileName;
+        TInt screenDeviceFontFileId;
+        TUid fontStoreFontFileUid;
 #endif
         QStringList families;
     };
@@ -704,7 +706,7 @@ public:
 #if defined(Q_WS_QWS)
     QDataStream *stream;
 #elif defined(Q_OS_SYMBIAN) && defined(QT_NO_FREETYPE)
-    const QSymbianFontDatabaseExtras *symbianExtras;
+    QSymbianFontDatabaseExtras *symbianExtras;
 #endif
 #if defined(Q_WS_QWS) || defined(Q_WS_QPA)
     QStringList fallbackFamilies;
@@ -2573,6 +2575,8 @@ bool QFontDatabasePrivate::isApplicationFont(const QString &fileName)
     \note Adding application fonts on Unix/X11 platforms without fontconfig is
     currently not supported.
 
+    \note On Symbian, the font family names get truncated to a length of 20 characters.
+
     \sa addApplicationFontFromData(), applicationFontFamilies(), removeApplicationFont()
 */
 int QFontDatabase::addApplicationFont(const QString &fileName)
@@ -2603,6 +2607,8 @@ int QFontDatabase::addApplicationFont(const QString &fileName)
     \bold{Note:} Adding application fonts on Unix/X11 platforms without fontconfig is
     currently not supported.
 
+    \note On Symbian, the font family names get truncated to a length of 20 characters.
+
     \sa addApplicationFont(), applicationFontFamilies(), removeApplicationFont()
 */
 int QFontDatabase::addApplicationFontFromData(const QByteArray &fontData)
diff --git a/src/gui/text/qfontdatabase_s60.cpp b/src/gui/text/qfontdatabase_s60.cpp
index 6ba035e..6d3970e 100644
--- a/src/gui/text/qfontdatabase_s60.cpp
+++ b/src/gui/text/qfontdatabase_s60.cpp
@@ -45,6 +45,8 @@
 #include "qfontengine_s60_p.h"
 #include "qabstractfileengine.h"
 #include "qdesktopservices.h"
+#include "qtemporaryfile.h"
+#include "qtextcodec.h"
 #include <private/qpixmap_s60_p.h>
 #include <private/qt_s60_p.h>
 #include "qendian.h"
@@ -114,7 +116,14 @@ public:
     ~QSymbianFontDatabaseExtrasImplementation();
 
     const QSymbianTypeFaceExtras *extras(const QString &typeface, bool bold, bool italic) const;
-    void addFontFileToFontStore(const QFileInfo &fontFileInfo);
+    void removeAppFontData(QFontDatabasePrivate::ApplicationFont *fnt);
+    static inline bool appFontLimitReached();
+    TUid addFontFileToFontStore(const QFileInfo &fontFileInfo);
+    static void clear();
+
+    static inline QString tempAppFontFolder();
+    static const QString appFontMarkerPrefix;
+    static QString appFontMarker(); // 'qaf<shortUid[+shortPid]>'
 
     struct CFontFromFontStoreReleaser {
         static inline void cleanup(CFont *font)
@@ -144,8 +153,75 @@ public:
     mutable QList<const QSymbianTypeFaceExtras *> m_extras;
 
     mutable QHash<QString, const QSymbianTypeFaceExtras *> m_extrasHash;
+    mutable QSet<QString> m_applicationFontFamilies;
 };
 
+const QString QSymbianFontDatabaseExtrasImplementation::appFontMarkerPrefix =
+        QLatin1String("Q");
+
+inline QString QSymbianFontDatabaseExtrasImplementation::tempAppFontFolder()
+{
+    return QDir::toNativeSeparators(QDir::tempPath()) + QLatin1Char('\\');
+}
+
+QString QSymbianFontDatabaseExtrasImplementation::appFontMarker()
+{
+    static QString result;
+    if (result.isEmpty()) {
+        quint16 id = 0;
+        if (QSymbianTypeFaceExtras::symbianFontTableApiAvailable()) {
+            // We are allowed to load app fonts even from previous, crashed runs
+            // of this application, since we can access the font tables.
+            const quint32 uid = RProcess().Type().MostDerived().iUid;
+            id = static_cast<quint16>(uid + (uid >> 16));
+        } else {
+            // If no font table Api is available, we must not even load a font
+            // from a previous (crashed) run of this application. Reason: we
+            // won't get the font tables, they are not in the CFontStore.
+            // So, we use the pid, for more uniqueness.
+            id = static_cast<quint16>(RProcess().Id().Id());
+        }
+        result = appFontMarkerPrefix + QString::fromLatin1("%1").arg(id & 0x7fff, 3, 32, QLatin1Char('0'));
+        Q_ASSERT(appFontMarkerPrefix.length() == 1 && result.length() == 4);
+    }
+    return result;
+}
+
+static inline bool qt_symbian_fontNameHasAppFontMarker(const QString &fontName)
+{
+    const int idLength = 3; // Keep in sync with id length in appFontMarker().
+    const QString &prefix = QSymbianFontDatabaseExtrasImplementation::appFontMarkerPrefix;
+    if (fontName.length() < prefix.length() + idLength
+            || fontName.mid(fontName.length() - idLength - prefix.length(), prefix.length()) != prefix)
+        return false;
+    // Testing if the the id is base32 data
+    for (int i = fontName.length() - idLength; i < fontName.length(); ++i) {
+        const QChar &c = fontName.at(i);
+        if (!(c >= QLatin1Char('0') && c <= QLatin1Char('9')
+              || c >= QLatin1Char('a') && c <= QLatin1Char('v')))
+            return false;
+    }
+    return true;
+}
+
+// If fontName is an application font of this app, prepend the app font marker
+QString qt_symbian_fontNameWithAppFontMarker(const QString &fontName)
+{
+    QFontDatabasePrivate *db = privateDb();
+    Q_ASSERT(db);
+    const QSymbianFontDatabaseExtrasImplementation *dbExtras =
+            static_cast<const QSymbianFontDatabaseExtrasImplementation*>(db->symbianExtras);
+    return dbExtras->m_applicationFontFamilies.contains(fontName) ?
+                fontName + QSymbianFontDatabaseExtrasImplementation::appFontMarker()
+              : fontName;
+}
+
+static inline QString qt_symbian_appFontNameWithoutMarker(const QString &markedFontName)
+{
+    return markedFontName.left(markedFontName.length()
+                               - QSymbianFontDatabaseExtrasImplementation::appFontMarker().length());
+}
+
 QSymbianFontDatabaseExtrasImplementation::QSymbianFontDatabaseExtrasImplementation()
 {
     if (!QSymbianTypeFaceExtras::symbianFontTableApiAvailable()) {
@@ -170,10 +246,13 @@ QSymbianFontDatabaseExtrasImplementation::QSymbianFontDatabaseExtrasImplementati
     }
 }
 
-void qt_cleanup_symbianFontDatabaseExtras()
+void QSymbianFontDatabaseExtrasImplementation::clear()
 {
+    QFontDatabasePrivate *db = privateDb();
+    if (!db)
+        return;
     const QSymbianFontDatabaseExtrasImplementation *dbExtras =
-            static_cast<const QSymbianFontDatabaseExtrasImplementation*>(privateDb()->symbianExtras);
+            static_cast<const QSymbianFontDatabaseExtrasImplementation*>(db->symbianExtras);
     if (!dbExtras)
         return; // initializeDb() has never been called
     if (QSymbianTypeFaceExtras::symbianFontTableApiAvailable()) {
@@ -189,9 +268,32 @@ void qt_cleanup_symbianFontDatabaseExtras()
     dbExtras->m_extrasHash.clear();
 }
 
+void qt_cleanup_symbianFontDatabase()
+{
+    QFontDatabasePrivate *db = privateDb();
+    if (!db)
+        return;
+
+    QSymbianFontDatabaseExtrasImplementation::clear();
+
+    if (!db->applicationFonts.isEmpty()) {
+        QFontDatabase::removeAllApplicationFonts();
+        // We remove the left over temporary font files of Qt application.
+        // Active fonts are undeletable since the font server holds a handle
+        // on them, so we do not need to worry to delete other running
+        // applications' fonts.
+        const QDir dir(QSymbianFontDatabaseExtrasImplementation::tempAppFontFolder());
+        const QStringList filter(
+                QSymbianFontDatabaseExtrasImplementation::appFontMarkerPrefix + QLatin1String("*.ttf"));
+        foreach (const QFileInfo &ttfFile, dir.entryInfoList(filter))
+            QFile(ttfFile.absoluteFilePath()).remove();
+        db->applicationFonts.clear();
+    }
+}
+
 QSymbianFontDatabaseExtrasImplementation::~QSymbianFontDatabaseExtrasImplementation()
 {
-    qt_cleanup_symbianFontDatabaseExtras();
+    qt_cleanup_symbianFontDatabase();
     if (!QSymbianTypeFaceExtras::symbianFontTableApiAvailable()) {
         delete m_store;
         m_heap->Close();
@@ -215,9 +317,10 @@ COpenFont* OpenFontFromBitmapFont(const CBitmapFont* aBitmapFont)
 }
 #endif // FNTSTORE_H_INLINES_SUPPORT_FMM
 
-const QSymbianTypeFaceExtras *QSymbianFontDatabaseExtrasImplementation::extras(const QString &typeface,
+const QSymbianTypeFaceExtras *QSymbianFontDatabaseExtrasImplementation::extras(const QString &aTypeface,
                                                                                bool bold, bool italic) const
 {
+    const QString typeface = qt_symbian_fontNameWithAppFontMarker(aTypeface);
     const QString searchKey = typeface + QString::number(int(bold)) + QString::number(int(italic));
     if (!m_extrasHash.contains(searchKey)) {
         TFontSpec searchSpec(qt_QString2TPtrC(typeface), 1);
@@ -263,12 +366,42 @@ const QSymbianTypeFaceExtras *QSymbianFontDatabaseExtrasImplementation::extras(c
     return m_extrasHash.value(searchKey);
 }
 
-void QSymbianFontDatabaseExtrasImplementation::addFontFileToFontStore(const QFileInfo &fontFileInfo)
+void QSymbianFontDatabaseExtrasImplementation::removeAppFontData(
+    QFontDatabasePrivate::ApplicationFont *fnt)
+{
+    clear();
+    if (!QSymbianTypeFaceExtras::symbianFontTableApiAvailable()
+            && fnt->fontStoreFontFileUid.iUid != 0)
+        m_store->RemoveFile(fnt->fontStoreFontFileUid);
+    if (!fnt->families.isEmpty())
+        m_applicationFontFamilies.remove(fnt->families.first());
+    if (fnt->screenDeviceFontFileId != 0)
+        S60->screenDevice()->RemoveFile(fnt->screenDeviceFontFileId);
+    QFile::remove(fnt->temporaryFileName);
+    *fnt = QFontDatabasePrivate::ApplicationFont();
+}
+
+bool QSymbianFontDatabaseExtrasImplementation::appFontLimitReached()
+{
+    QFontDatabasePrivate *db = privateDb();
+    if (!db)
+        return false;
+    const int maxAppFonts = 5;
+    int registeredAppFonts = 0;
+    foreach (const QFontDatabasePrivate::ApplicationFont &appFont, db->applicationFonts)
+        if (!appFont.families.isEmpty() && ++registeredAppFonts == maxAppFonts)
+            return true;
+    return false;
+}
+
+TUid QSymbianFontDatabaseExtrasImplementation::addFontFileToFontStore(const QFileInfo &fontFileInfo)
 {
     Q_ASSERT(!QSymbianTypeFaceExtras::symbianFontTableApiAvailable());
     const QString fontFile = QDir::toNativeSeparators(fontFileInfo.absoluteFilePath());
-    TPtrC fontFilePtr(qt_QString2TPtrC(fontFile));
-    QT_TRAP_THROWING(m_store->AddFileL(fontFilePtr));
+    const TPtrC fontFilePtr(qt_QString2TPtrC(fontFile));
+    TUid fontUid = {0};
+    TRAP_IGNORE(fontUid = m_store->AddFileL(fontFilePtr));
+    return fontUid;
 }
 
 #else // QT_NO_FREETYPE
@@ -331,11 +464,24 @@ void QFontEngineMultiS60::loadEngine(int at)
     Q_ASSERT(engines[at]);
 }
 
-static bool addFontToScreenDevice(int screenDeviceFontIndex,
-                                  const QSymbianFontDatabaseExtrasImplementation *dbExtras)
-{    
+#ifdef QT_NO_FREETYPE
+static bool registerScreenDeviceFont(int screenDeviceFontIndex,
+                                     const QSymbianFontDatabaseExtrasImplementation *dbExtras)
+{
     TTypefaceSupport typefaceSupport;
         S60->screenDevice()->TypefaceSupport(typefaceSupport, screenDeviceFontIndex);
+
+    QString familyName((const QChar*)typefaceSupport.iTypeface.iName.Ptr(), typefaceSupport.iTypeface.iName.Length());
+    if (qt_symbian_fontNameHasAppFontMarker(familyName)) {
+        const QString &marker = QSymbianFontDatabaseExtrasImplementation::appFontMarker();
+        if (familyName.endsWith(marker)) {
+            familyName = qt_symbian_appFontNameWithoutMarker(familyName);
+            dbExtras->m_applicationFontFamilies.insert(familyName);
+        } else {
+            return false; // This was somebody else's application font. Skip it.
+        }
+    }
+
     CFont *font; // We have to get a font instance in order to know all the details
     TFontSpec fontSpec(typefaceSupport.iTypeface.iName, 11);
     if (S60->screenDevice()->GetNearestFontInPixels(font, fontSpec) != KErrNone)
@@ -351,7 +497,6 @@ static bool addFontToScreenDevice(int screenDeviceFontIndex,
     styleKey.style = faceAttrib.IsItalic()?QFont::StyleItalic:QFont::StyleNormal;
     styleKey.weight = faceAttrib.IsBold()?QFont::Bold:QFont::Normal;
 
-    QString familyName((const QChar *)typefaceSupport.iTypeface.iName.Ptr(), typefaceSupport.iTypeface.iName.Length());
     QtFontFamily *family = privateDb()->family(familyName, true);
     family->fixedPitch = faceAttrib.IsMonoWidth();
     QtFontFoundry *foundry = family->foundry(QString(), true);
@@ -381,6 +526,7 @@ static bool addFontToScreenDevice(int screenDeviceFontIndex,
         family->writingSystems[system] = QtFontFamily::Supported;
     return true;
 }
+#endif
 
 static void initializeDb()
 {
@@ -398,7 +544,12 @@ static void initializeDb()
     const QSymbianFontDatabaseExtrasImplementation *dbExtras =
             static_cast<const QSymbianFontDatabaseExtrasImplementation*>(db->symbianExtras);
     for (int i = 0; i < numTypeFaces; i++)
-        addFontToScreenDevice(i, dbExtras);
+        registerScreenDeviceFont(i, dbExtras);
+
+    // We have to clear/release all CFonts, here, in case one of the fonts is
+    // an application font of another running Qt app. Otherwise the other Qt app
+    // cannot remove it's application font, anymore -> "Zombie Font".
+    QSymbianFontDatabaseExtrasImplementation::clear();
 
     lock.relock();
 
@@ -421,20 +572,386 @@ static inline void load(const QString &family = QString(), int script = -1)
     initializeDb();
 }
 
+struct OffsetTable {
+    quint32 sfntVersion;
+    quint16 numTables, searchRange, entrySelector, rangeShift;
+};
+
+struct TableRecord {
+    quint32 tag, checkSum, offset, length;
+};
+
+struct NameTableHead {
+    quint16 format, count, stringOffset;
+};
+
+struct NameRecord {
+    quint16 platformID, encodingID, languageID, nameID, length, offset;
+};
+
+static quint32 ttfCalcChecksum(const char *data, quint32 bytesCount)
+{
+    quint32 result = 0;
+    const quint32 *ptr = reinterpret_cast<const quint32*>(data);
+    const quint32 *endPtr =
+            ptr + (bytesCount + sizeof(quint32) - 1) / sizeof(quint32);
+    while (ptr < endPtr) {
+        const quint32 unit32Value = *ptr++;
+        result += qFromBigEndian(unit32Value);
+    }
+    return result;
+}
+
+static inline quint32 toDWordBoundary(quint32 value)
+{
+    return (value + 3) & ~3;
+}
+
+static inline quint32 dWordPadding(quint32 value)
+{
+    return (4 - (value & 3)) & 3;
+}
+
+static inline bool ttfMarkNameTable(QByteArray &table, const QString &marker)
+{
+    const quint32 tableLength = static_cast<quint32>(table.size());
+
+    if (tableLength > 50000 // hard limit
+            || tableLength < sizeof(NameTableHead)) // corrupt name table
+        return false;
+
+    const NameTableHead *head = reinterpret_cast<const NameTableHead*>(table.constData());
+    const quint16 count = qFromBigEndian(head->count);
+    const quint16 stringOffset = qFromBigEndian(head->stringOffset);
+    if (count > 200 // hard limit
+            || stringOffset >= tableLength // corrupt name table
+            || sizeof(NameTableHead) + count * sizeof(NameRecord) >= tableLength) // corrupt name table
+        return false;
+
+    QTextEncoder encoder(QTextCodec::codecForName("UTF-16BE"), QTextCodec::IgnoreHeader);
+    const QByteArray markerUtf16BE = encoder.fromUnicode(marker);
+    const QByteArray markerAscii = marker.toAscii();
+
+    QByteArray markedTable;
+    markedTable.reserve(tableLength + marker.length() * 20); // Original size plus some extra
+    markedTable.append(table, stringOffset);
+    QByteArray markedStrings;
+    quint32 stringDataCount = stringOffset;
+    for (quint16 i = 0; i < count; ++i) {
+        const quint32 nameRecordOffset = sizeof(NameTableHead) + sizeof(NameRecord) * i;
+        NameRecord *nameRecord =
+                reinterpret_cast<NameRecord*>(markedTable.data() + nameRecordOffset);
+        const quint16 nameID = qFromBigEndian(nameRecord->nameID);
+        const quint16 platformID = qFromBigEndian(nameRecord->platformID);
+        const quint16 encodingID = qFromBigEndian(nameRecord->encodingID);
+        const quint16 offset = qFromBigEndian(nameRecord->offset);
+        const quint16 length = qFromBigEndian(nameRecord->length);
+        stringDataCount += length;
+        if (stringDataCount > 80000 // hard limit. String data may be > name table size. Multiple records can reference the same string.
+                || static_cast<quint32>(stringOffset + offset + length) > tableLength) // String outside bounds
+            return false;
+        const bool needsMarker =
+                nameID == 1 || nameID == 3 || nameID == 4 || nameID == 16 || nameID == 21;
+        const bool isUnicode =
+                platformID == 0 || platformID == 3 && encodingID == 1;
+        const QByteArray originalString =
+                QByteArray::fromRawData(table.constData() + stringOffset + offset, length);
+        QByteArray markedString;
+        if (needsMarker) {
+            const int maxBytesLength = (KMaxTypefaceNameLength - marker.length()) * (isUnicode ? 2 : 1);
+            markedString = originalString.left(maxBytesLength) + (isUnicode ? markerUtf16BE : markerAscii);
+        } else {
+            markedString = originalString;
+        }
+        nameRecord->offset = qToBigEndian(static_cast<quint16>(markedStrings.length()));
+        nameRecord->length = qToBigEndian(static_cast<quint16>(markedString.length()));
+        markedStrings.append(markedString);
+    }
+    markedTable.append(markedStrings);
+    table = markedTable;
+    return true;
+}
+
+const quint32 ttfMaxFileSize = 3500000;
+
+static inline bool ttfMarkAppFont(QByteArray &ttf, const QString &marker)
+{
+    const quint32 ttfChecksumNumber = 0xb1b0afba;
+    const quint32 alignment = 4;
+    const quint32 ttfLength = static_cast<quint32>(ttf.size());
+    if (ttfLength > ttfMaxFileSize // hard limit
+            || ttfLength % alignment != 0 // ttf sizes are always factors of 4
+            || ttfLength <= sizeof(OffsetTable) // ttf too short
+            || ttfCalcChecksum(ttf.constData(), ttf.size()) != ttfChecksumNumber) // ttf checksum is invalid
+        return false;
+
+    const OffsetTable *offsetTable = reinterpret_cast<const OffsetTable*>(ttf.constData());
+    const quint16 numTables = qFromBigEndian(offsetTable->numTables);
+    const quint32 recordsLength =
+            toDWordBoundary(sizeof(OffsetTable) + numTables * sizeof(TableRecord));
+    if (numTables > 30 // hard limit
+            || recordsLength + numTables * alignment > ttfLength) // Corrupt ttf. Tables would not fit, even if empty.
+        return false;
+
+    QByteArray markedTtf;
+    markedTtf.reserve(ttfLength + marker.length() * 20); // Original size plus some extra
+    markedTtf.append(ttf.constData(), recordsLength);
+
+    const quint32 ttfCheckSumAdjustmentOffset = 8; // Offset from the start of 'head'
+    int indexOfHeadTable = -1;
+    quint32 ttfDataSize = recordsLength;
+    typedef QPair<quint32, quint32> Range;
+    QList<Range> memoryRanges;
+    memoryRanges.reserve(numTables);
+    for (int i = 0; i < numTables; ++i) {
+        TableRecord *tableRecord =
+                reinterpret_cast<TableRecord*>(markedTtf.data() + sizeof(OffsetTable) + i * sizeof(TableRecord));
+        const quint32 offset = qFromBigEndian(tableRecord->offset);
+        const quint32 length = qFromBigEndian(tableRecord->length);
+        const quint32 lengthAligned = toDWordBoundary(length);
+        ttfDataSize += lengthAligned;
+        if (offset < recordsLength // must not intersect ttf header/records
+                || offset % alignment != 0 // must be aligned
+                || offset > ttfLength - alignment // table out of bounds
+                || offset + lengthAligned > ttfLength // table out of bounds
+                || ttfDataSize > ttfLength) // tables would not fit into the ttf
+            return false;
+
+        foreach (const Range &range, memoryRanges)
+            if (offset < range.first + range.second && offset + lengthAligned > range.first)
+                return false; // Overlaps with another table
+        memoryRanges.append(Range(offset, lengthAligned));
+
+        quint32 checkSum = qFromBigEndian(tableRecord->checkSum);
+        if (tableRecord->tag == qToBigEndian(static_cast<quint32>('head'))) {
+            if (length < ttfCheckSumAdjustmentOffset + sizeof(quint32))
+                return false; // Invalid 'head' table
+            const quint32 *checkSumAdjustmentTag =
+                    reinterpret_cast<const quint32*>(ttf.constData() + offset + ttfCheckSumAdjustmentOffset);
+            const quint32 checkSumAdjustment = qFromBigEndian(*checkSumAdjustmentTag);
+            checkSum += checkSumAdjustment;
+            indexOfHeadTable = i; // For the ttf checksum re-calculation, later
+        }
+        if (checkSum != ttfCalcChecksum(ttf.constData() + offset, length))
+            return false; // Table checksum is invalid
+
+        bool updateTableChecksum = false;
+        QByteArray table;
+        if (tableRecord->tag == qToBigEndian(static_cast<quint32>('name'))) {
+            table = QByteArray(ttf.constData() + offset, length);
+            if (!ttfMarkNameTable(table, marker))
+                return false; // Name table was not markable.
+            updateTableChecksum = true;
+        } else {
+            table = QByteArray::fromRawData(ttf.constData() + offset, length);
+        }
+
+        tableRecord->offset = qToBigEndian(markedTtf.size());
+        tableRecord->length = qToBigEndian(table.size());
+        markedTtf.append(table);
+        markedTtf.append(QByteArray(dWordPadding(table.size()), 0)); // 0-padding
+        if (updateTableChecksum) {
+            TableRecord *tableRecord = // Need to recalculate, since markedTtf changed
+                    reinterpret_cast<TableRecord*>(markedTtf.data() + sizeof(OffsetTable) + i * sizeof(TableRecord));
+            const quint32 offset = qFromBigEndian(tableRecord->offset);
+            const quint32 length = qFromBigEndian(tableRecord->length);
+            tableRecord->checkSum = qToBigEndian(ttfCalcChecksum(markedTtf.constData() + offset, length));
+        }
+    }
+    if (indexOfHeadTable == -1 // 'head' table is mandatory
+            || ttfDataSize != ttfLength) // We do not allow ttf data "holes". Neither does Symbian.
+        return false;
+    TableRecord *headRecord =
+            reinterpret_cast<TableRecord*>(markedTtf.data() + sizeof(OffsetTable) + indexOfHeadTable * sizeof(TableRecord));
+    quint32 *checkSumAdjustmentTag =
+            reinterpret_cast<quint32*>(markedTtf.data() + qFromBigEndian(headRecord->offset) + ttfCheckSumAdjustmentOffset);
+    *checkSumAdjustmentTag = 0;
+    const quint32 ttfChecksum = ttfCalcChecksum(markedTtf.constData(), markedTtf.count());
+    *checkSumAdjustmentTag = qToBigEndian(ttfChecksumNumber - ttfChecksum);
+    ttf = markedTtf;
+    return true;
+}
+
+static inline bool ttfCanSymbianLoadFont(const QByteArray &data, const QString &fileName)
+{
+    bool result = false;
+    QString ttfFileName;
+    QFile tempFileGuard;
+    QFileInfo info(fileName);
+    if (!data.isEmpty()) {
+        QTemporaryFile tempfile(QSymbianFontDatabaseExtrasImplementation::tempAppFontFolder()
+                                + QSymbianFontDatabaseExtrasImplementation::appFontMarker()
+                                + QLatin1String("XXXXXX.ttf"));
+        if (!tempfile.open() || tempfile.write(data) == -1)
+            return false;
+        ttfFileName = QDir::toNativeSeparators(QFileInfo(tempfile).canonicalFilePath());
+        tempfile.setAutoRemove(false);
+        tempfile.close();
+        tempFileGuard.setFileName(ttfFileName);
+        if (!tempFileGuard.open(QIODevice::ReadOnly))
+            return false;
+    } else if (info.isFile()) {
+        ttfFileName = QDir::toNativeSeparators(info.canonicalFilePath());
+    } else {
+        return false;
+    }
+
+    CFontStore *store = 0;
+    RHeap* heap = User::ChunkHeap(NULL, 0x1000, 0x20000);
+    if (heap) {
+        QT_TRAP_THROWING(
+            CleanupClosePushL(*heap);
+            store = CFontStore::NewL(heap);
+            CleanupStack::PushL(store);
+            COpenFontRasterizer *rasterizer = COpenFontRasterizer::NewL(TUid::Uid(0x101F7F5E));
+            CleanupStack::PushL(rasterizer);
+            store->InstallRasterizerL(rasterizer);
+            CleanupStack::Pop(rasterizer);
+            TUid fontUid = {-1};
+            TRAP_IGNORE(fontUid = store->AddFileL(qt_QString2TPtrC(ttfFileName)));
+            if (fontUid.iUid != -1)
+                result = true;
+            CleanupStack::PopAndDestroy(2, heap); // heap, store
+        );
+    }
+
+    if (tempFileGuard.isOpen())
+        tempFileGuard.remove();
+
+    return result;
+}
+
 static void registerFont(QFontDatabasePrivate::ApplicationFont *fnt)
 {
-    Q_UNUSED(fnt);
+    if (QSymbianFontDatabaseExtrasImplementation::appFontLimitReached()
+            || fnt->data.size() > ttfMaxFileSize // hard limit
+            || fnt->data.isEmpty() && (!fnt->fileName.endsWith(QLatin1String(".ttf"), Qt::CaseInsensitive) // Only buffer or .ttf
+                                       || QFileInfo(fnt->fileName).size() > ttfMaxFileSize)) // hard limit
+        return;
+
+//    Using ttfCanSymbianLoadFont() causes crashes on app destruction (Symbian^3|PR1 and lower).
+//    Therefore, not using it for now, but eventually in a later version.
+//    if (!ttfCanSymbianLoadFont(fnt->data, fnt->fileName))
+//        return;
+
+    QFontDatabasePrivate *db = privateDb();
+    if (!db)
+        return;
+
+    if (!db->count)
+        initializeDb();
+
+    QSymbianFontDatabaseExtrasImplementation *dbExtras =
+            static_cast<QSymbianFontDatabaseExtrasImplementation*>(db->symbianExtras);
+    if (!dbExtras)
+        return;
+
+    const QString &marker = QSymbianFontDatabaseExtrasImplementation::appFontMarker();
+
+    // The QTemporaryFile object being used in the following section must be
+    // destructed before letting Symbian load the TTF file. Symbian would not
+    // load it otherwise, because QTemporaryFile will still keep some handle
+    // on it. The scope is used to reduce the life time of the QTemporaryFile.
+    // In order to prevent other processes from modifying the file between the
+    // moment where the QTemporaryFile is destructed and the file is loaded by
+    // Symbian, we have a QFile "tempFileGuard" outside the scope which opens
+    // the file in ReadOnly mode while the QTemporaryFile is still alive.
+    QFile tempFileGuard;
+    {
+        QTemporaryFile tempfile(QSymbianFontDatabaseExtrasImplementation::tempAppFontFolder()
+                                + marker + QLatin1String("XXXXXX.ttf"));
+        if (!tempfile.open())
+            return;
+        const QString tempFileName = QFileInfo(tempfile).canonicalFilePath();
+        if (fnt->data.isEmpty()) {
+            QFile sourceFile(fnt->fileName);
+            if (!sourceFile.open(QIODevice::ReadOnly))
+                return;
+            fnt->data = sourceFile.readAll();
+        }
+        if (!ttfMarkAppFont(fnt->data, marker) || tempfile.write(fnt->data) == -1)
+            return;
+        tempfile.setAutoRemove(false);
+        tempfile.close(); // Tempfile still keeps a file handle, forbidding write access
+        fnt->data.clear(); // The TTF data was marked and saved. Not needed in memory, anymore.
+        tempFileGuard.setFileName(tempFileName);
+        if (!tempFileGuard.open(QIODevice::ReadOnly))
+            return;
+        fnt->temporaryFileName = tempFileName;
+    }
+
+    const QString fullFileName = QDir::toNativeSeparators(fnt->temporaryFileName);
+    QSymbianFbsHeapLock lock(QSymbianFbsHeapLock::Unlock);
+    const QStringList fontsOnServerBefore = qt_symbian_fontFamiliesOnFontServer();
+    const TInt err =
+            S60->screenDevice()->AddFile(qt_QString2TPtrC(fullFileName), fnt->screenDeviceFontFileId);
+    tempFileGuard.close(); // Did its job
+    const QStringList fontsOnServerAfter = qt_symbian_fontFamiliesOnFontServer();
+    if (err == KErrNone && fontsOnServerBefore.count() < fontsOnServerAfter.count()) { // Added to screen device?
+        int fontOnServerIndex = fontsOnServerAfter.count() - 1;
+        for (int i = 0; i < fontsOnServerBefore.count(); i++) {
+            if (fontsOnServerBefore.at(i) != fontsOnServerAfter.at(i)) {
+                fontOnServerIndex = i;
+                break;
+            }
+        }
+
+        // Must remove all font engines with their CFonts, first.
+        QFontCache::instance()->clear();
+        db->free();
+        QSymbianFontDatabaseExtrasImplementation::clear();
+
+        if (!QSymbianTypeFaceExtras::symbianFontTableApiAvailable())
+            fnt->fontStoreFontFileUid = dbExtras->addFontFileToFontStore(QFileInfo(fullFileName));
+
+        const QString &appFontName = fontsOnServerAfter.at(fontOnServerIndex);
+        fnt->families.append(qt_symbian_appFontNameWithoutMarker(appFontName));
+        if (!qt_symbian_fontNameHasAppFontMarker(appFontName)
+                || !registerScreenDeviceFont(fontOnServerIndex, dbExtras))
+            dbExtras->removeAppFontData(fnt);
+    } else {
+        if (fnt->screenDeviceFontFileId > 0)
+            S60->screenDevice()->RemoveFile(fnt->screenDeviceFontFileId); // May still have the file open!
+        QFile::remove(fnt->temporaryFileName);
+        *fnt = QFontDatabasePrivate::ApplicationFont();
+    }
+    lock.relock();
 }
 
 bool QFontDatabase::removeApplicationFont(int handle)
 {
-    Q_UNUSED(handle);
-    return false;
+    QMutexLocker locker(fontDatabaseMutex());
+
+    QFontDatabasePrivate *db = privateDb();
+    if (!db || handle < 0 || handle >= db->applicationFonts.count())
+        return false;
+    QSymbianFontDatabaseExtrasImplementation *dbExtras =
+            static_cast<QSymbianFontDatabaseExtrasImplementation*>(db->symbianExtras);
+    if (!dbExtras)
+        return false;
+
+    QFontDatabasePrivate::ApplicationFont *fnt = &db->applicationFonts[handle];
+    if (fnt->families.isEmpty())
+        return true; // Nothing to remove. Return peacefully.
+
+    // Must remove all font engines with their CFonts, first
+    QFontCache::instance()->clear();
+    db->free();
+    dbExtras->removeAppFontData(fnt);
+
+    db->invalidate(); // This will just emit 'fontDatabaseChanged()'
+    return true;
 }
 
 bool QFontDatabase::removeAllApplicationFonts()
 {
-    return false;
+    QMutexLocker locker(fontDatabaseMutex());
+
+    const int applicationFontsCount = privateDb()->applicationFonts.count();
+    for (int i = 0; i < applicationFontsCount; ++i)
+        if (!removeApplicationFont(i))
+            return false;
+    return true;
 }
 
 bool QFontDatabase::supportsThreadedFontRendering()
@@ -467,7 +984,7 @@ QFontEngine *QFontDatabase::findFont(int script, const QFontPrivate *d, const QF
         QFontDatabasePrivate *db = privateDb();
         QtFontDesc desc;
         QList<int> blacklistedFamilies;
-        match(script, req, req.family, QString(), -1, &desc, blacklistedFamilies);
+        match(script, key.def, key.def.family, QString(), -1, &desc, blacklistedFamilies);
         if (!desc.family) // falling back to application font
             desc.family = db->family(QApplication::font().defaultFamily());
         Q_ASSERT(desc.family);
diff --git a/src/gui/text/qfontdatabase_x11.cpp b/src/gui/text/qfontdatabase_x11.cpp
index 2186058..f923d87 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);
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/qfontengine_s60.cpp b/src/gui/text/qfontengine_s60.cpp
index 4317ee6..e9b54e3 100644
--- a/src/gui/text/qfontengine_s60.cpp
+++ b/src/gui/text/qfontengine_s60.cpp
@@ -244,10 +244,13 @@ static inline unsigned int getChar(const QChar *str, int &i, const int len)
     return uc;
 }
 
+extern QString qt_symbian_fontNameWithAppFontMarker(const QString &fontName); // qfontdatabase_s60.cpp
+
 CFont *QFontEngineS60::fontWithSize(qreal size) const
 {
     CFont *result = 0;
-    TFontSpec fontSpec(qt_QString2TPtrC(QFontEngine::fontDef.family), TInt(size));
+    const QString family = qt_symbian_fontNameWithAppFontMarker(QFontEngine::fontDef.family);
+    TFontSpec fontSpec(qt_QString2TPtrC(family), TInt(size));
     fontSpec.iFontStyle.SetBitmapType(EAntiAliasedGlyphBitmap);
     fontSpec.iFontStyle.SetPosture(QFontEngine::fontDef.style == QFont::StyleNormal?EPostureUpright:EPostureItalic);
     fontSpec.iFontStyle.SetStrokeWeight(QFontEngine::fontDef.weight > QFont::Normal?EStrokeWeightBold:EStrokeWeightNormal);
diff --git a/src/gui/text/qtextcontrol.cpp b/src/gui/text/qtextcontrol.cpp
index 89ca6bf..46f1d62 100644
--- a/src/gui/text/qtextcontrol.cpp
+++ b/src/gui/text/qtextcontrol.cpp
@@ -115,6 +115,7 @@ static QTextLine currentTextLine(const QTextCursor &cursor)
 QTextControlPrivate::QTextControlPrivate()
     : doc(0), cursorOn(false), cursorIsFocusIndicator(false),
       interactionFlags(Qt::TextEditorInteraction),
+      dragEnabled(true),
 #ifndef QT_NO_DRAGANDDROP
       mousePressed(false), mightStartDrag(false),
 #endif
@@ -129,7 +130,8 @@ QTextControlPrivate::QTextControlPrivate()
       isEnabled(true),
       hadSelectionOnMousePress(false),
       ignoreUnusedNavigationEvents(false),
-      openExternalLinks(false)
+      openExternalLinks(false),
+      wordSelectionEnabled(false)
 {}
 
 bool QTextControlPrivate::cursorMoveKeyEvent(QKeyEvent *e)
@@ -931,15 +933,18 @@ void QTextControl::processEvent(QEvent *e, const QMatrix &matrix, QWidget *conte
             break; }
         case QEvent::MouseMove: {
             QMouseEvent *ev = static_cast<QMouseEvent *>(e);
-            d->mouseMoveEvent(ev->buttons(), matrix.map(ev->pos()));
+            d->mouseMoveEvent(ev, ev->button(), matrix.map(ev->pos()), ev->modifiers(),
+                              ev->buttons(), ev->globalPos());
             break; }
         case QEvent::MouseButtonRelease: {
             QMouseEvent *ev = static_cast<QMouseEvent *>(e);
-            d->mouseReleaseEvent(ev->button(), matrix.map(ev->pos()));
+            d->mouseReleaseEvent(ev, ev->button(), matrix.map(ev->pos()), ev->modifiers(),
+                                 ev->buttons(), ev->globalPos());
             break; }
         case QEvent::MouseButtonDblClick: {
             QMouseEvent *ev = static_cast<QMouseEvent *>(e);
-            d->mouseDoubleClickEvent(e, ev->button(), matrix.map(ev->pos()));
+            d->mouseDoubleClickEvent(ev, ev->button(), matrix.map(ev->pos()), ev->modifiers(),
+                                     ev->buttons(), ev->globalPos());
             break; }
         case QEvent::InputMethod:
             d->inputMethodEvent(static_cast<QInputMethodEvent *>(e));
@@ -999,15 +1004,18 @@ void QTextControl::processEvent(QEvent *e, const QMatrix &matrix, QWidget *conte
             break; }
         case QEvent::GraphicsSceneMouseMove: {
             QGraphicsSceneMouseEvent *ev = static_cast<QGraphicsSceneMouseEvent *>(e);
-            d->mouseMoveEvent(ev->buttons(), matrix.map(ev->pos()));
+            d->mouseMoveEvent(ev, ev->button(), matrix.map(ev->pos()), ev->modifiers(), ev->buttons(),
+                              ev->screenPos());
             break; }
         case QEvent::GraphicsSceneMouseRelease: {
             QGraphicsSceneMouseEvent *ev = static_cast<QGraphicsSceneMouseEvent *>(e);
-            d->mouseReleaseEvent(ev->button(), matrix.map(ev->pos()));
+            d->mouseReleaseEvent(ev, ev->button(), matrix.map(ev->pos()), ev->modifiers(), ev->buttons(),
+                                 ev->screenPos());
             break; }
         case QEvent::GraphicsSceneMouseDoubleClick: {
             QGraphicsSceneMouseEvent *ev = static_cast<QGraphicsSceneMouseEvent *>(e);
-            d->mouseDoubleClickEvent(e, ev->button(), matrix.map(ev->pos()));
+            d->mouseDoubleClickEvent(ev, ev->button(), matrix.map(ev->pos()), ev->modifiers(), ev->buttons(),
+                                     ev->screenPos());
             break; }
         case QEvent::GraphicsSceneContextMenu: {
             QGraphicsSceneContextMenuEvent *ev = static_cast<QGraphicsSceneContextMenuEvent *>(e);
@@ -1016,7 +1024,8 @@ void QTextControl::processEvent(QEvent *e, const QMatrix &matrix, QWidget *conte
 
         case QEvent::GraphicsSceneHoverMove: {
             QGraphicsSceneHoverEvent *ev = static_cast<QGraphicsSceneHoverEvent *>(e);
-            d->mouseMoveEvent(Qt::NoButton, matrix.map(ev->pos()));
+            d->mouseMoveEvent(ev, Qt::NoButton, matrix.map(ev->pos()), ev->modifiers(),Qt::NoButton,
+                              ev->screenPos());
             break; }
 
         case QEvent::GraphicsSceneDragEnter: {
@@ -1486,6 +1495,11 @@ void QTextControlPrivate::mousePressEvent(QEvent *e, Qt::MouseButton button, con
 {
     Q_Q(QTextControl);
 
+    if (sendMouseEventToInputContext(
+            e, QEvent::MouseButtonPress, button, pos, modifiers, buttons, globalPos)) {
+        return;
+    }
+
     if (interactionFlags & Qt::LinksAccessibleByMouse) {
         anchorOnMousePress = q->anchorAt(pos);
 
@@ -1528,31 +1542,22 @@ void QTextControlPrivate::mousePressEvent(QEvent *e, Qt::MouseButton button, con
             return;
         }
 
-#if !defined(QT_NO_IM)
-        QTextLayout *layout = cursor.block().layout();
-        if (contextWidget && layout && !layout->preeditAreaText().isEmpty()) {
-            QInputContext *ctx = inputContext();
-            if (ctx) {
-                QMouseEvent ev(QEvent::MouseButtonPress, contextWidget->mapFromGlobal(globalPos), globalPos,
-                               button, buttons, modifiers);
-                ctx->mouseHandler(cursorPos - cursor.position(), &ev);
+        if (modifiers == Qt::ShiftModifier && (interactionFlags & Qt::TextSelectableByMouse)) {
+            if (wordSelectionEnabled && !selectedWordOnDoubleClick.hasSelection()) {
+                selectedWordOnDoubleClick = cursor;
+                selectedWordOnDoubleClick.select(QTextCursor::WordUnderCursor);
             }
-            if (!layout->preeditAreaText().isEmpty()) {
-                e->ignore();
-                return;
-            }
-        }
-#endif
-        if (modifiers == Qt::ShiftModifier) {
+
             if (selectedBlockOnTrippleClick.hasSelection())
                 extendBlockwiseSelection(cursorPos);
             else if (selectedWordOnDoubleClick.hasSelection())
                 extendWordwiseSelection(cursorPos, pos.x());
-            else
+            else if (wordSelectionEnabled)
                 setCursorPosition(cursorPos, QTextCursor::KeepAnchor);
         } else {
 
-            if (cursor.hasSelection()
+            if (dragEnabled
+                && cursor.hasSelection()
                 && !cursorIsFocusIndicator
                 && cursorPos >= cursor.selectionStart()
                 && cursorPos <= cursor.selectionEnd()
@@ -1582,10 +1587,16 @@ void QTextControlPrivate::mousePressEvent(QEvent *e, Qt::MouseButton button, con
     hadSelectionOnMousePress = cursor.hasSelection();
 }
 
-void QTextControlPrivate::mouseMoveEvent(Qt::MouseButtons buttons, const QPointF &mousePos)
+void QTextControlPrivate::mouseMoveEvent(QEvent *e, Qt::MouseButton button, const QPointF &mousePos, Qt::KeyboardModifiers modifiers,
+                                         Qt::MouseButtons buttons, const QPoint &globalPos)
 {
     Q_Q(QTextControl);
 
+    if (sendMouseEventToInputContext(
+            e, QEvent::MouseMove, button, mousePos, modifiers, buttons, globalPos)) {
+        return;
+    }
+
     if (interactionFlags & Qt::LinksAccessibleByMouse) {
         QString anchor = q->anchorAt(mousePos);
         if (anchor != highlightedAnchor) {
@@ -1615,21 +1626,20 @@ void QTextControlPrivate::mouseMoveEvent(Qt::MouseButtons buttons, const QPointF
     }
     const qreal mouseX = qreal(mousePos.x());
 
-#if !defined(QT_NO_IM)
-    QTextLayout *layout = cursor.block().layout();
-    if (layout && !layout->preeditAreaText().isEmpty())
-        return;
-#endif
-
     int newCursorPos = q->hitTest(mousePos, Qt::FuzzyHit);
     if (newCursorPos == -1)
         return;
 
+    if (wordSelectionEnabled && !selectedWordOnDoubleClick.hasSelection()) {
+        selectedWordOnDoubleClick = cursor;
+        selectedWordOnDoubleClick.select(QTextCursor::WordUnderCursor);
+    }
+
     if (selectedBlockOnTrippleClick.hasSelection())
         extendBlockwiseSelection(newCursorPos);
     else if (selectedWordOnDoubleClick.hasSelection())
         extendWordwiseSelection(newCursorPos, mouseX);
-    else
+    else if (interactionFlags & Qt::TextSelectableByMouse)
         setCursorPosition(newCursorPos, QTextCursor::KeepAnchor);
 
     if (interactionFlags & Qt::TextEditable) {
@@ -1653,10 +1663,16 @@ void QTextControlPrivate::mouseMoveEvent(Qt::MouseButtons buttons, const QPointF
     repaintOldAndNewSelection(oldSelection);
 }
 
-void QTextControlPrivate::mouseReleaseEvent(Qt::MouseButton button, const QPointF &pos)
+void QTextControlPrivate::mouseReleaseEvent(QEvent *e, Qt::MouseButton button, const QPointF &pos, Qt::KeyboardModifiers modifiers,
+                                            Qt::MouseButtons buttons, const QPoint &globalPos)
 {
     Q_Q(QTextControl);
 
+    if (sendMouseEventToInputContext(
+            e, QEvent::MouseButtonRelease, button, pos, modifiers, buttons, globalPos)) {
+        return;
+    }
+
     const QTextCursor oldSelection = cursor;
     const int oldCursorPos = cursor.position();
 
@@ -1714,19 +1730,21 @@ void QTextControlPrivate::mouseReleaseEvent(Qt::MouseButton button, const QPoint
     }
 }
 
-void QTextControlPrivate::mouseDoubleClickEvent(QEvent *e, Qt::MouseButton button, const QPointF &pos)
+void QTextControlPrivate::mouseDoubleClickEvent(QEvent *e, Qt::MouseButton button, const QPointF &pos, Qt::KeyboardModifiers modifiers,
+                                                Qt::MouseButtons buttons, const QPoint &globalPos)
 {
     Q_Q(QTextControl);
+
+    if (sendMouseEventToInputContext(
+            e, QEvent::MouseButtonDblClick, button, pos, modifiers, buttons, globalPos)) {
+        return;
+    }
+
     if (button != Qt::LeftButton
         || !(interactionFlags & Qt::TextSelectableByMouse)) {
         e->ignore();
         return;
     }
-#if !defined(QT_NO_IM)
-    QTextLayout *layout = cursor.block().layout();
-    if (layout && !layout->preeditAreaText().isEmpty())
-        return;
-#endif
 
 #ifndef QT_NO_DRAGANDDROP
     mightStartDrag = false;
@@ -1755,6 +1773,45 @@ void QTextControlPrivate::mouseDoubleClickEvent(QEvent *e, Qt::MouseButton butto
     }
 }
 
+bool QTextControlPrivate::sendMouseEventToInputContext(
+        QEvent *e, QEvent::Type eventType, Qt::MouseButton button, const QPointF &pos,
+        Qt::KeyboardModifiers modifiers, Qt::MouseButtons buttons, const QPoint &globalPos)
+{
+#if !defined(QT_NO_IM)
+    Q_Q(QTextControl);
+
+    QTextLayout *layout = cursor.block().layout();
+    if (contextWidget && layout && !layout->preeditAreaText().isEmpty()) {
+        QInputContext *ctx = inputContext();
+        int cursorPos = q->hitTest(pos, Qt::FuzzyHit) - cursor.position();
+
+        if (cursorPos < 0 || cursorPos > layout->preeditAreaText().length()) {
+            cursorPos = -1;
+            // don't send move events outside the preedit area
+            if (eventType == QEvent::MouseMove)
+                return true;
+        }
+        if (ctx) {
+            QMouseEvent ev(eventType, contextWidget->mapFromGlobal(globalPos), globalPos,
+                           button, buttons, modifiers);
+            ctx->mouseHandler(cursorPos, &ev);
+            e->setAccepted(ev.isAccepted());
+        }
+        if (!layout->preeditAreaText().isEmpty())
+            return true;
+    }
+#else
+    Q_UNUSED(e);
+    Q_UNUSED(eventType);
+    Q_UNUSED(button);
+    Q_UNUSED(pos);
+    Q_UNUSED(modifiers);
+    Q_UNUSED(buttons);
+    Q_UNUSED(globalPos);
+#endif
+    return false;
+}
+
 void QTextControlPrivate::contextMenuEvent(const QPoint &screenPos, const QPointF &docPos, QWidget *contextWidget)
 {
 #ifdef QT_NO_CONTEXTMENU
@@ -2331,6 +2388,31 @@ bool QTextControl::cursorIsFocusIndicator() const
     return d->cursorIsFocusIndicator;
 }
 
+
+void QTextControl::setDragEnabled(bool enabled)
+{
+    Q_D(QTextControl);
+    d->dragEnabled = enabled;
+}
+
+bool QTextControl::isDragEnabled() const
+{
+    Q_D(const QTextControl);
+    return d->dragEnabled;
+}
+
+void QTextControl::setWordSelectionEnabled(bool enabled)
+{
+    Q_D(QTextControl);
+    d->wordSelectionEnabled = enabled;
+}
+
+bool QTextControl::isWordSelectionEnabled() const
+{
+    Q_D(const QTextControl);
+    return d->wordSelectionEnabled;
+}
+
 #ifndef QT_NO_PRINTER
 void QTextControl::print(QPrinter *printer) const
 {
diff --git a/src/gui/text/qtextcontrol_p.h b/src/gui/text/qtextcontrol_p.h
index 6540f4f..31fa843 100644
--- a/src/gui/text/qtextcontrol_p.h
+++ b/src/gui/text/qtextcontrol_p.h
@@ -175,6 +175,12 @@ public:
     void setCursorIsFocusIndicator(bool b);
     bool cursorIsFocusIndicator() const;
 
+    void setDragEnabled(bool enabled);
+    bool isDragEnabled() const;
+
+    bool isWordSelectionEnabled() const;
+    void setWordSelectionEnabled(bool enabled);
+
 #ifndef QT_NO_PRINTER
     void print(QPrinter *printer) const;
 #endif
@@ -183,8 +189,6 @@ public:
     virtual QRectF blockBoundingRect(const QTextBlock &block) const;
     QAbstractTextDocumentLayout::PaintContext getPaintContext(QWidget *widget) const;
 
-
-
 public Q_SLOTS:
     void setPlainText(const QString &text);
     void setHtml(const QString &text);
diff --git a/src/gui/text/qtextcontrol_p_p.h b/src/gui/text/qtextcontrol_p_p.h
index 04f4c75..94670e2 100644
--- a/src/gui/text/qtextcontrol_p_p.h
+++ b/src/gui/text/qtextcontrol_p_p.h
@@ -135,9 +135,23 @@ public:
                          Qt::KeyboardModifiers modifiers,
                          Qt::MouseButtons buttons,
                          const QPoint &globalPos);
-    void mouseMoveEvent(Qt::MouseButtons buttons, const QPointF &pos);
-    void mouseReleaseEvent(Qt::MouseButton button, const QPointF &pos);
-    void mouseDoubleClickEvent(QEvent *e, Qt::MouseButton button, const QPointF &pos);
+    void mouseMoveEvent(QEvent *e, Qt::MouseButton button, const QPointF &pos,
+                        Qt::KeyboardModifiers modifiers,
+                        Qt::MouseButtons buttons,
+                        const QPoint &globalPos);
+    void mouseReleaseEvent(QEvent *e, Qt::MouseButton button, const QPointF &pos,
+                           Qt::KeyboardModifiers modifiers,
+                           Qt::MouseButtons buttons,
+                           const QPoint &globalPos);
+    void mouseDoubleClickEvent(QEvent *e, Qt::MouseButton button, const QPointF &pos,
+                               Qt::KeyboardModifiers modifiers,
+                               Qt::MouseButtons buttons,
+                               const QPoint &globalPos);
+    bool sendMouseEventToInputContext(QEvent *e,  QEvent::Type eventType, Qt::MouseButton button,
+                                      const QPointF &pos,
+                                      Qt::KeyboardModifiers modifiers,
+                                      Qt::MouseButtons buttons,
+                                      const QPoint &globalPos);
     void contextMenuEvent(const QPoint &screenPos, const QPointF &docPos, QWidget *contextWidget);
     void focusEvent(QFocusEvent *e);
 #ifdef QT_KEYPAD_NAVIGATION
@@ -174,6 +188,8 @@ public:
     QBasicTimer trippleClickTimer;
     QPointF trippleClickPoint;
 
+    bool dragEnabled;
+
     bool mousePressed;
 
     bool mightStartDrag;
@@ -209,6 +225,8 @@ public:
     bool ignoreUnusedNavigationEvents;
     bool openExternalLinks;
 
+    bool wordSelectionEnabled;
+
     QString linkToCopy;
     void _q_copyLink();
     void _q_updateBlock(const QTextBlock &);
diff --git a/src/gui/text/qtextdocument_p.cpp b/src/gui/text/qtextdocument_p.cpp
index 498a432..2172f74 100644
--- a/src/gui/text/qtextdocument_p.cpp
+++ b/src/gui/text/qtextdocument_p.cpp
@@ -663,7 +663,8 @@ void QTextDocumentPrivate::move(int pos, int to, int length, QTextUndoCommand::O
 
     Q_ASSERT(blocks.length() == fragments.length());
 
-    finishEdit();
+    if (!blockCursorAdjustment)
+        finishEdit();
 }
 
 void QTextDocumentPrivate::remove(int pos, int length, QTextUndoCommand::Operation op)
@@ -678,6 +679,7 @@ void QTextDocumentPrivate::remove(int pos, int length, QTextUndoCommand::Operati
             curs->changed = true;
         }
     }
+    finishEdit();
 }
 
 void QTextDocumentPrivate::setCharFormat(int pos, int length, const QTextCharFormat &newFormat, FormatChangeMode mode)
diff --git a/src/gui/text/qtextdocumentlayout.cpp b/src/gui/text/qtextdocumentlayout.cpp
index 157b7bc..838face 100644
--- a/src/gui/text/qtextdocumentlayout.cpp
+++ b/src/gui/text/qtextdocumentlayout.cpp
@@ -2510,6 +2510,7 @@ static inline void getLineHeightParams(const QTextBlockFormat &blockFormat, cons
                                        QFixed *lineAdjustment, QFixed *lineBreakHeight, QFixed *lineHeight)
 {
     *lineHeight = QFixed::fromReal(blockFormat.lineHeight(line.height(), scaling));
+
     if (blockFormat.lineHeightType() == QTextBlockFormat::FixedHeight || blockFormat.lineHeightType() == QTextBlockFormat::MinimumHeight) {
         *lineBreakHeight = *lineHeight;
         if (blockFormat.lineHeightType() == QTextBlockFormat::FixedHeight)
diff --git a/src/gui/text/qtextengine.cpp b/src/gui/text/qtextengine.cpp
index 415fa4b..a63fdbf 100644
--- a/src/gui/text/qtextengine.cpp
+++ b/src/gui/text/qtextengine.cpp
@@ -1385,6 +1385,15 @@ void QTextEngine::shape(int item) const
     }
 }
 
+static inline void releaseCachedFontEngine(QFontEngine *fontEngine)
+{
+    if (fontEngine) {
+        fontEngine->ref.deref();
+        if (fontEngine->cache_count == 0 && fontEngine->ref == 0)
+            delete fontEngine;
+    }
+}
+
 void QTextEngine::invalidate()
 {
     freeMemory();
@@ -1392,6 +1401,9 @@ void QTextEngine::invalidate()
     maxWidth = 0;
     if (specialData)
         specialData->resolvedFormatIndices.clear();
+
+    releaseCachedFontEngine(feCache.prevFontEngine);
+    releaseCachedFontEngine(feCache.prevScaledFontEngine);
     feCache.reset();
 }
 
@@ -1824,7 +1836,11 @@ QFontEngine *QTextEngine::fontEngine(const QScriptItem &si, QFixed *ascent, QFix
                 scaledEngine = font.d->engineForScript(script);
             }
             feCache.prevFontEngine = engine;
+            if (engine)
+                engine->ref.ref();
             feCache.prevScaledFontEngine = scaledEngine;
+            if (scaledEngine)
+                scaledEngine->ref.ref();
             feCache.prevScript = script;
             feCache.prevPosition = si.position;
             feCache.prevLength = length(&si);
@@ -1835,6 +1851,8 @@ QFontEngine *QTextEngine::fontEngine(const QScriptItem &si, QFixed *ascent, QFix
         else {
             engine = font.d->engineForScript(script);
             feCache.prevFontEngine = engine;
+            if (engine)
+                engine->ref.ref();
             feCache.prevScript = script;
             feCache.prevPosition = -1;
             feCache.prevLength = -1;
diff --git a/src/gui/text/text.pri b/src/gui/text/text.pri
index daafdd9..d3e8f2d 100644
--- a/src/gui/text/text.pri
+++ b/src/gui/text/text.pri
@@ -147,8 +147,8 @@ symbian {
 			text/qfontengine_s60.cpp
 		HEADERS += \
 			text/qfontengine_s60_p.h
-		LIBS += -lfntstr -lecom
 	}
+	LIBS += -lfntstr -lecom
 }
 
 !qpa {
diff --git a/src/gui/widgets/qcocoamenu_mac.mm b/src/gui/widgets/qcocoamenu_mac.mm
index d5c8eb8..dff37b4 100644
--- a/src/gui/widgets/qcocoamenu_mac.mm
+++ b/src/gui/widgets/qcocoamenu_mac.mm
@@ -48,6 +48,7 @@
 #include <private/qt_cocoa_helpers_mac_p.h>
 #include <private/qapplication_p.h>
 #include <private/qaction_p.h>
+#include <private/qcocoaapplication_mac_p.h>
 
 #include <QtGui/QMenu>
 
diff --git a/src/gui/widgets/qcombobox.cpp b/src/gui/widgets/qcombobox.cpp
index 7946137..b5dda5a 100644
--- a/src/gui/widgets/qcombobox.cpp
+++ b/src/gui/widgets/qcombobox.cpp
@@ -2486,10 +2486,18 @@ void QComboBox::showPopup()
             listRect.setWidth(listRect.height());
             //by default popup is centered on screen in landscape
             listRect.moveCenter(screen.center());
-            if (staConTopRect.IsEmpty() && AknLayoutUtils::CbaLocation() != AknLayoutUtils::EAknCbaLocationBottom) {
-                // landscape without stacon, menu should be at the right
-                (opt.direction == Qt::LeftToRight) ? listRect.setRight(screen.right()) :
-                                                     listRect.setLeft(screen.left());
+            if (staConTopRect.IsEmpty()) {
+                TRect cbaRect = TRect();
+                AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EControlPane, cbaRect);
+                AknLayoutUtils::TAknCbaLocation cbaLocation = AknLayoutUtils::CbaLocation();
+                switch (cbaLocation) {
+                case AknLayoutUtils::EAknCbaLocationRight:
+                    listRect.setRight(screen.right());
+                    break;
+                case AknLayoutUtils::EAknCbaLocationLeft:
+                    listRect.setLeft(screen.left());
+                    break;
+                }
             }
         }
 #endif
diff --git a/src/gui/widgets/qfocusframe.cpp b/src/gui/widgets/qfocusframe.cpp
index c159a1e..6508c31 100644
--- a/src/gui/widgets/qfocusframe.cpp
+++ b/src/gui/widgets/qfocusframe.cpp
@@ -85,6 +85,9 @@ void QFocusFramePrivate::update()
 void QFocusFramePrivate::updateSize()
 {
     Q_Q(QFocusFrame);
+    if (!widget)
+        return;
+
     int vmargin = q->style()->pixelMetric(QStyle::PM_FocusFrameVMargin),
         hmargin = q->style()->pixelMetric(QStyle::PM_FocusFrameHMargin);
     QPoint pos(widget->x(), widget->y());
diff --git a/src/gui/widgets/qlinecontrol.cpp b/src/gui/widgets/qlinecontrol.cpp
index 062bb61..023b9ee 100644
--- a/src/gui/widgets/qlinecontrol.cpp
+++ b/src/gui/widgets/qlinecontrol.cpp
@@ -456,6 +456,7 @@ void QLineControl::processInputMethodEvent(QInputMethodEvent *event)
 #ifndef QT_NO_IM
     setPreeditArea(m_cursor, event->preeditString());
 #endif //QT_NO_IM
+    const int oldPreeditCursor = m_preeditCursor;
     m_preeditCursor = event->preeditString().length();
     m_hideCursor = false;
     QList<QTextLayout::FormatRange> formats;
@@ -479,6 +480,8 @@ void QLineControl::processInputMethodEvent(QInputMethodEvent *event)
     updateDisplayText(/*force*/ true);
     if (cursorPositionChanged)
         emitCursorPositionChanged();
+    else if (m_preeditCursor != oldPreeditCursor)
+        emit updateMicroFocus();
     if (isGettingInput)
         finishChange(priorState);
 }
@@ -541,10 +544,13 @@ void QLineControl::draw(QPainter *painter, const QPoint &offset, const QRect &cl
 */
 void QLineControl::selectWordAtPos(int cursor)
 {
-    int c = m_textLayout.previousCursorPosition(cursor, QTextLayout::SkipWords);
+    int next = cursor + 1;
+    if(next > end())
+        --next;
+    int c = m_textLayout.previousCursorPosition(next, QTextLayout::SkipWords);
     moveCursor(c, false);
     // ## text layout should support end of words.
-    int end = m_textLayout.nextCursorPosition(cursor, QTextLayout::SkipWords);
+    int end = m_textLayout.nextCursorPosition(c, QTextLayout::SkipWords);
     while (end > cursor && m_text[end-1].isSpace())
         --end;
     moveCursor(end, true);
diff --git a/src/gui/widgets/qlinecontrol_p.h b/src/gui/widgets/qlinecontrol_p.h
index bfe50fe..3c505c8 100644
--- a/src/gui/widgets/qlinecontrol_p.h
+++ b/src/gui/widgets/qlinecontrol_p.h
@@ -425,6 +425,7 @@ Q_SIGNALS:
     void textEdited(const QString &);
 
     void resetInputContext();
+    void updateMicroFocus();
 
     void accepted();
     void editingFinished();
diff --git a/src/gui/widgets/qmainwindow.cpp b/src/gui/widgets/qmainwindow.cpp
index a786e2f..fd61783 100644
--- a/src/gui/widgets/qmainwindow.cpp
+++ b/src/gui/widgets/qmainwindow.cpp
@@ -1516,11 +1516,6 @@ void QMainWindow::setUnifiedTitleAndToolBarOnMac(bool set)
     if (!isWindow() || d->useHIToolBar == set || QSysInfo::MacintoshVersion < QSysInfo::MV_10_3)
         return;
 
-    // ### Disable when using alien widgets
-    if (testAttribute(Qt::WA_NativeWindow) == false) {
-        return;
-    }
-
     d->useHIToolBar = set;
     createWinId(); // We need the hiview for down below.
 
diff --git a/src/gui/widgets/qmainwindowlayout_mac.mm b/src/gui/widgets/qmainwindowlayout_mac.mm
index 9a23ca7..e428ffc 100644
--- a/src/gui/widgets/qmainwindowlayout_mac.mm
+++ b/src/gui/widgets/qmainwindowlayout_mac.mm
@@ -355,7 +355,11 @@ void QMainWindowLayout::updateHIToolBarStatus()
         // Move everything out of the HIToolbar into the main toolbar.
         while (!qtoolbarsInUnifiedToolbarList.isEmpty()) {
             // Should shrink the list by one every time.
-            layoutState.mainWindow->addToolBar(Qt::TopToolBarArea, qtoolbarsInUnifiedToolbarList.first());
+            QToolBar *toolbar = qtoolbarsInUnifiedToolbarList.first();
+            layoutState.mainWindow->addToolBar(Qt::TopToolBarArea, toolbar);
+#if defined(QT_MAC_USE_COCOA)
+            toolbar->d_func()->isInUnifiedToolbar = false;
+#endif
         }
         macWindowToolbarSet(qt_mac_window_for(layoutState.mainWindow), 0);
     } else {
@@ -363,7 +367,8 @@ void QMainWindowLayout::updateHIToolBarStatus()
         for (int i = 0; i < toolbars.size(); ++i) {
             QToolBar *toolbar = toolbars.at(i);
             if (toolBarArea(toolbar) == Qt::TopToolBarArea) {
-                removeWidget(toolbar);  // Do this here, because we are in an in-between state.
+                // Do this here, because we are in an in-between state.
+                removeWidget(toolbar);
                 layoutState.mainWindow->addToolBar(Qt::TopToolBarArea, toolbar);
             }
         }
@@ -387,10 +392,20 @@ void QMainWindowLayout::insertIntoMacToolbar(QToolBar *before, QToolBar *toolbar
     if (toolbar == 0)
         return;
 
+#if defined(QT_MAC_USE_COCOA)
+    // toolbar will now become native (if not allready) since we need
+    // an nsview for it inside the corresponding NSToolbarItem.
+    // Setting isInUnifiedToolbar will (among other things) stop alien
+    // siblings from becoming native when this happends since the toolbar
+    // will not overlap with other children of the QMainWindow. NB: Switching
+    // unified toolbar off after this stage is not supported, as this means
+    // that either the menubar must be alien again, or the sibling must
+    // be backed by an nsview to protect from overlapping issues:
+    toolbar->d_func()->isInUnifiedToolbar = true;
+#endif
 
     QToolBarLayout *toolbarLayout = static_cast<QToolBarLayout *>(toolbar->layout());
-    toolbarSaveState.insert(toolbar, ToolBarSaveState(toolbar->isMovable(),
-                                                      toolbar->maximumSize()));
+    toolbarSaveState.insert(toolbar, ToolBarSaveState(toolbar->isMovable(), toolbar->maximumSize()));
 
     if (toolbarLayout->hasExpandFlag() == false)
         toolbar->setMaximumSize(toolbar->sizeHint());
@@ -399,8 +414,8 @@ void QMainWindowLayout::insertIntoMacToolbar(QToolBar *before, QToolBar *toolbar
     toolbarLayout->setUsePopupMenu(true);
     // Make the toolbar a child of the mainwindow to avoid creating a window.
     toolbar->setParent(layoutState.mainWindow);
-    toolbar->createWinId();  // Now create the OSViewRef.
 
+    toolbar->winId();  // Now create the OSViewRef.
     layoutState.mainWindow->createWinId();
 
     OSWindowRef window = qt_mac_window_for(layoutState.mainWindow);
diff --git a/src/gui/widgets/qmenubar.cpp b/src/gui/widgets/qmenubar.cpp
index dda5aba..5bfac9a 100644
--- a/src/gui/widgets/qmenubar.cpp
+++ b/src/gui/widgets/qmenubar.cpp
@@ -1073,8 +1073,11 @@ void QMenuBar::paintEvent(QPaintEvent *e)
 void QMenuBar::setVisible(bool visible)
 {
 #if defined(Q_WS_MAC) || defined(Q_OS_WINCE) || defined(Q_WS_S60)
-    if (isNativeMenuBar())
+    if (isNativeMenuBar()) {
+        if (!visible)
+            QWidget::setVisible(false);
         return;
+    }
 #endif
     QWidget::setVisible(visible);
 }
diff --git a/src/gui/widgets/qplaintextedit.cpp b/src/gui/widgets/qplaintextedit.cpp
index d3af9e1..7435691 100644
--- a/src/gui/widgets/qplaintextedit.cpp
+++ b/src/gui/widgets/qplaintextedit.cpp
@@ -967,7 +967,7 @@ void QPlainTextEditPrivate::_q_adjustScrollbars()
                     ++lineNumber;
                 }
                 if (lineNumber < layoutLineCount)
-                    visibleFromBottom += (layoutLineCount - lineNumber - 1);
+                    visibleFromBottom += (layoutLineCount - lineNumber);
                 break;
 
             }
diff --git a/src/gui/widgets/qscrollbar.cpp b/src/gui/widgets/qscrollbar.cpp
index 67f34eb..c895b1b 100644
--- a/src/gui/widgets/qscrollbar.cpp
+++ b/src/gui/widgets/qscrollbar.cpp
@@ -82,21 +82,21 @@ QT_BEGIN_NAMESPACE
     needs.
 
     \table
-    \row \i \image qscrollbar-picture.png
-    \i Scroll bars typically include four separate controls: a slider,
+    \row \o \image qscrollbar-picture.png
+    \o Scroll bars typically include four separate controls: a slider,
     scroll arrows, and a page control.
 
     \list
-    \i a. The slider provides a way to quickly go to any part of the
+    \o a. The slider provides a way to quickly go to any part of the
     document, but does not support accurate navigation within large
     documents.
-    \i b. The scroll arrows are push buttons which can be used to accurately
+    \o b. The scroll arrows are push buttons which can be used to accurately
     navigate to a particular place in a document. For a vertical scroll bar
     connected to a text editor, these typically move the current position one
     "line" up or down, and adjust the position of the slider by a small
     amount. In editors and list boxes a "line" might mean one line of text;
     in an image viewer it might mean 20 pixels.
-    \i c. The page control is the area over which the slider is dragged (the
+    \o c. The page control is the area over which the slider is dragged (the
     scroll bar's background). Clicking here moves the scroll bar towards
     the click by one "page". This value is usually the same as the length of
     the slider.
@@ -134,13 +134,12 @@ QT_BEGIN_NAMESPACE
     value of 80. This would give us a scroll bar with five "pages".
 
     \table
-    \row \i \inlineimage qscrollbar-values.png
-    \i The relationship between a document length, the range of values used
+    \row \o \inlineimage qscrollbar-values.png
+    \o The relationship between a document length, the range of values used
     in a scroll bar, and the page step is simple in many common situations.
     The scroll bar's range of values is determined by subtracting a
     chosen page step from some value representing the length of the document.
     In such cases, the following equation is useful:
-
     \e{document length} = maximum() - minimum() + pageStep().
     \endtable
 
@@ -153,18 +152,18 @@ QT_BEGIN_NAMESPACE
 
     ScrollBar inherits a comprehensive set of signals from QAbstractSlider:
     \list
-    \i \l{QAbstractSlider::valueChanged()}{valueChanged()} is emitted when the
+    \o \l{QAbstractSlider::valueChanged()}{valueChanged()} is emitted when the
        scroll bar's value has changed. The tracking() determines whether this
        signal is emitted during user interaction.
-    \i \l{QAbstractSlider::rangeChanged()}{rangeChanged()} is emitted when the
+    \o \l{QAbstractSlider::rangeChanged()}{rangeChanged()} is emitted when the
        scroll bar's range of values has changed.
-    \i \l{QAbstractSlider::sliderPressed()}{sliderPressed()} is emitted when
+    \o \l{QAbstractSlider::sliderPressed()}{sliderPressed()} is emitted when
        the user starts to drag the slider.
-    \i \l{QAbstractSlider::sliderMoved()}{sliderMoved()} is emitted when the user
+    \o \l{QAbstractSlider::sliderMoved()}{sliderMoved()} is emitted when the user
        drags the slider.
-    \i \l{QAbstractSlider::sliderReleased()}{sliderReleased()} is emitted when
+    \o \l{QAbstractSlider::sliderReleased()}{sliderReleased()} is emitted when
        the user releases the slider.
-    \i \l{QAbstractSlider::actionTriggered()}{actionTriggered()} is emitted
+    \o \l{QAbstractSlider::actionTriggered()}{actionTriggered()} is emitted
        when the scroll bar is changed by user interaction or via the
        \l{QAbstractSlider::triggerAction()}{triggerAction()} function.
     \endlist
@@ -173,12 +172,12 @@ QT_BEGIN_NAMESPACE
     default focusPolicy() of Qt::NoFocus. Use setFocusPolicy() to
     enable keyboard interaction with the scroll bar:
     \list
-         \i Left/Right move a horizontal scroll bar by one single step.
-         \i Up/Down move a vertical scroll bar by one single step.
-         \i PageUp moves up one page.
-         \i PageDown moves down one page.
-         \i Home moves to the start (mininum).
-         \i End moves to the end (maximum).
+         \o Left/Right move a horizontal scroll bar by one single step.
+         \o Up/Down move a vertical scroll bar by one single step.
+         \o PageUp moves up one page.
+         \o PageDown moves down one page.
+         \o Home moves to the start (mininum).
+         \o End moves to the end (maximum).
      \endlist
 
     The slider itself can be controlled by using the
diff --git a/src/gui/widgets/qsizegrip.cpp b/src/gui/widgets/qsizegrip.cpp
index f2ea1bf..630aecf 100644
--- a/src/gui/widgets/qsizegrip.cpp
+++ b/src/gui/widgets/qsizegrip.cpp
@@ -309,6 +309,7 @@ void QSizeGrip::mousePressEvent(QMouseEvent * e)
 #ifdef Q_WS_X11
     // Use a native X11 sizegrip for "real" top-level windows if supported.
     if (tlw->isWindow() && X11->isSupportedByWM(ATOM(_NET_WM_MOVERESIZE))
+        && !(tlw->windowFlags() & Qt::X11BypassWindowManagerHint)
         && !tlw->testAttribute(Qt::WA_DontShowOnScreen) && !qt_widget_private(tlw)->hasHeightForWidth()) {
         XEvent xev;
         xev.xclient.type = ClientMessage;
@@ -420,7 +421,8 @@ void QSizeGrip::mouseMoveEvent(QMouseEvent * e)
 
 #ifdef Q_WS_X11
     if (tlw->isWindow() && X11->isSupportedByWM(ATOM(_NET_WM_MOVERESIZE))
-        && tlw->isTopLevel() && !tlw->testAttribute(Qt::WA_DontShowOnScreen) && !qt_widget_private(tlw)->hasHeightForWidth())
+        && tlw->isTopLevel() && !(tlw->windowFlags() & Qt::X11BypassWindowManagerHint)
+        && !tlw->testAttribute(Qt::WA_DontShowOnScreen) && !qt_widget_private(tlw)->hasHeightForWidth())
         return;
 #endif
 #ifdef Q_WS_WIN