Merge branch '4.6' of git@scm.dev.nokia.troll.no:qt/oslo-staging-2 into 4.6

66 files changed, 1335 insertions, 364 deletions

diff --git a/src/3rdparty/phonon/mmf/abstractaudioeffect.cpp b/src/3rdparty/phonon/mmf/abstractaudioeffect.cpp
index a793390..a559249 100644
--- a/src/3rdparty/phonon/mmf/abstractaudioeffect.cpp
+++ b/src/3rdparty/phonon/mmf/abstractaudioeffect.cpp
@@ -29,6 +29,10 @@ using namespace Phonon::MMF;
   \internal
 */
 
+/*! \namespace Phonon::MMF
+  \internal
+*/
+
 AbstractAudioEffect::AbstractAudioEffect(QObject *parent,
                                          const QList<EffectParameter> &params) : MediaNode::MediaNode(parent)
                                                                                , m_params(params)
diff --git a/src/3rdparty/phonon/mmf/ancestormovemonitor.cpp b/src/3rdparty/phonon/mmf/ancestormovemonitor.cpp
index 0447d57..18ced94 100644
--- a/src/3rdparty/phonon/mmf/ancestormovemonitor.cpp
+++ b/src/3rdparty/phonon/mmf/ancestormovemonitor.cpp
@@ -26,7 +26,7 @@ QT_BEGIN_NAMESPACE
 
 using namespace Phonon::MMF;
 
-/*! \class MMF::AncestorMoveMonitor
+/*! \class Phonon::MMF::AncestorMoveMonitor
   \internal
   \brief Class which installs a global event filter, and listens for move
   events which may affect the absolute position of widgets registered with
@@ -34,6 +34,11 @@ using namespace Phonon::MMF;
   See QTBUG-4956
 */
 
+
+/*! \class Phonon::MMF::VideoOutputObserver
+    \internal
+*/
+
 //-----------------------------------------------------------------------------
 // Constructor / destructor
 //-----------------------------------------------------------------------------
diff --git a/src/3rdparty/phonon/mmf/utils.cpp b/src/3rdparty/phonon/mmf/utils.cpp
index 58d1ece..d728fcf 100644
--- a/src/3rdparty/phonon/mmf/utils.cpp
+++ b/src/3rdparty/phonon/mmf/utils.cpp
@@ -24,16 +24,24 @@ QT_BEGIN_NAMESPACE
 using namespace Phonon;
 using namespace Phonon::MMF;
 
-/*! \namespace MMF::Utils
+/*! \namespace Phonon::MMF::Utils
   \internal
 */
 
-/*! \class MMF::TTraceContext
+/*! \class Phonon::MMF::TTraceContext
   \internal
 */
 
-/*! \class MMF::Utils
-  \internal
+/*! \enum Phonon::MMF::PanicCode
+ \internal
+*/
+
+/*! \enum Phonon::MMF::TTraceCategory
+ \internal
+*/
+
+/*! \enum Phonon::MMF::MediaType
+ \internal
 */
 
 _LIT(PanicCategory, "Phonon::MMF");
diff --git a/src/3rdparty/phonon/phonon/audiooutput.cpp b/src/3rdparty/phonon/phonon/audiooutput.cpp
index 3d03dc4..0f6a49b 100644
--- a/src/3rdparty/phonon/phonon/audiooutput.cpp
+++ b/src/3rdparty/phonon/phonon/audiooutput.cpp
@@ -259,6 +259,7 @@ void AudioOutputPrivate::setupBackendObject()
     // set up attributes
     pINTERFACE_CALL(setVolume(pow(volume, VOLTAGE_TO_LOUDNESS_EXPONENT)));
 
+#ifndef QT_NO_PHONON_SETTINGSGROUP
     // if the output device is not available and the device was not explicitly set
     if (!callSetOutputDevice(this, device) && !outputDeviceOverridden) {
         // fall back in the preference list of output devices
@@ -278,6 +279,7 @@ void AudioOutputPrivate::setupBackendObject()
         callSetOutputDevice(this, none);
         handleAutomaticDeviceChange(none, FallbackChange);
     }
+#endif //QT_NO_PHONON_SETTINGSGROUP
 }
 
 void AudioOutputPrivate::_k_volumeChanged(qreal newVolume)
@@ -307,6 +309,7 @@ void AudioOutputPrivate::_k_audioDeviceFailed()
     pDebug() << Q_FUNC_INFO;
     // outputDeviceIndex identifies a failing device
     // fall back in the preference list of output devices
+#ifndef QT_NO_PHONON_SETTINGSGROUP
     const QList<int> deviceList = GlobalConfig().audioOutputDeviceListFor(category, GlobalConfig::AdvancedDevicesFromSettings | GlobalConfig::HideUnavailableDevices);
     for (int i = 0; i < deviceList.count(); ++i) {
         const int devIndex = deviceList.at(i);
@@ -319,6 +322,7 @@ void AudioOutputPrivate::_k_audioDeviceFailed()
             }
         }
     }
+#endif //QT_NO_PHONON_SETTINGSGROUP
     // if we get here there is no working output device. Tell the backend.
     const AudioOutputDevice none;
     callSetOutputDevice(this, none);
@@ -328,6 +332,7 @@ void AudioOutputPrivate::_k_audioDeviceFailed()
 void AudioOutputPrivate::_k_deviceListChanged()
 {
     pDebug() << Q_FUNC_INFO;
+#ifndef QT_NO_PHONON_SETTINGSGROUP
     // let's see if there's a usable device higher in the preference list
     const QList<int> deviceList = GlobalConfig().audioOutputDeviceListFor(category, GlobalConfig::AdvancedDevicesFromSettings);
     DeviceChangeType changeType = HigherPreferenceChange;
@@ -353,6 +358,7 @@ void AudioOutputPrivate::_k_deviceListChanged()
             break; // found one with higher preference that works
         }
     }
+#endif //QT_NO_PHONON_SETTINGSGROUP
 }
 
 static struct
diff --git a/src/3rdparty/phonon/phonon/backendcapabilities.cpp b/src/3rdparty/phonon/phonon/backendcapabilities.cpp
index 0bcc76c..fbeb020 100644
--- a/src/3rdparty/phonon/phonon/backendcapabilities.cpp
+++ b/src/3rdparty/phonon/phonon/backendcapabilities.cpp
@@ -75,10 +75,12 @@ bool BackendCapabilities::isMimeTypeAvailable(const QString &mimeType)
 QList<AudioOutputDevice> BackendCapabilities::availableAudioOutputDevices()
 {
     QList<AudioOutputDevice> ret;
+#ifndef QT_NO_PHONON_SETTINGSGROUP
     const QList<int> deviceIndexes = GlobalConfig().audioOutputDeviceListFor(Phonon::NoCategory);
     for (int i = 0; i < deviceIndexes.count(); ++i) {
         ret.append(AudioOutputDevice::fromIndex(deviceIndexes.at(i)));
     }
+#endif //QT_NO_PHONON_SETTINGSGROUP
     return ret;
 }
 
diff --git a/src/3rdparty/phonon/phonon/effectwidget.cpp b/src/3rdparty/phonon/phonon/effectwidget.cpp
index c5963eb..2334d7f 100644
--- a/src/3rdparty/phonon/phonon/effectwidget.cpp
+++ b/src/3rdparty/phonon/phonon/effectwidget.cpp
@@ -97,8 +97,9 @@ void EffectWidgetPrivate::autogenerateUi()
     Q_Q(EffectWidget);
     QVBoxLayout *mainLayout = new QVBoxLayout(q);
     mainLayout->setMargin(0);
-    for (int i = 0; i < effect->parameters().count(); ++i) {
-        const EffectParameter &para = effect->parameters().at(i);
+    const QList<Phonon::EffectParameter> parameters = effect->parameters();
+    for (int i = 0; i < parameters.count(); ++i) {
+        const EffectParameter &para = parameters.at(i);
         QVariant value = effect->parameterValue(para);
         QHBoxLayout *pLayout = new QHBoxLayout;
         mainLayout->addLayout(pLayout);
diff --git a/src/3rdparty/phonon/phonon/globalconfig.cpp b/src/3rdparty/phonon/phonon/globalconfig.cpp
index 6e6263a..3b77a18 100644
--- a/src/3rdparty/phonon/phonon/globalconfig.cpp
+++ b/src/3rdparty/phonon/phonon/globalconfig.cpp
@@ -178,13 +178,15 @@ QList<int> GlobalConfig::audioOutputDeviceListFor(Phonon::Category category, int
 
     return listSortedByConfig(backendConfig, category, defaultList);
 }
-#endif //QT_NO_SETTINGSGROUPS
+#endif //QT_NO_PHONON_SETTINGSGROUP
 int GlobalConfig::audioOutputDeviceFor(Phonon::Category category, int override) const
 {
+#ifndef QT_NO_PHONON_SETTINGSGROUP
     QList<int> ret = audioOutputDeviceListFor(category, override);
-    if (ret.isEmpty())
-        return -1;
-    return ret.first();
+    if (!ret.isEmpty())
+        return ret.first();
+#endif //QT_NO_PHONON_SETTINGSGROUP
+    return -1;
 }
 
 #ifndef QT_NO_PHONON_AUDIOCAPTURE
diff --git a/src/3rdparty/webkit/WebKit/qt/tests/qwebelement/tst_qwebelement.cpp b/src/3rdparty/webkit/WebKit/qt/tests/qwebelement/tst_qwebelement.cpp
index 117393a..bbb676b 100644
--- a/src/3rdparty/webkit/WebKit/qt/tests/qwebelement/tst_qwebelement.cpp
+++ b/src/3rdparty/webkit/WebKit/qt/tests/qwebelement/tst_qwebelement.cpp
@@ -971,7 +971,10 @@ void tst_QWebElement::render()
     QImage testImage(resource.width(), resource.height(), QImage::Format_ARGB32);
     QPainter painter0(&testImage);
     painter0.fillRect(imageRect, Qt::white);
-    painter0.drawImage(0, 0, resource);
+    //render() uses pixmaps internally, and pixmaps might have bit depths
+    // other than 32, giving different pixel values due to rounding.
+    QPixmap pix = QPixmap::fromImage(resource);
+    painter0.drawPixmap(0, 0, pix);
     painter0.end();
 
     QImage image1(resource.width(), resource.height(), QImage::Format_ARGB32);
diff --git a/src/corelib/animation/qpropertyanimation.cpp b/src/corelib/animation/qpropertyanimation.cpp
index 3065083..013ff7f 100644
--- a/src/corelib/animation/qpropertyanimation.cpp
+++ b/src/corelib/animation/qpropertyanimation.cpp
@@ -58,12 +58,12 @@
     an example:
 
     \code
-        QPropertyAnimation animation(myWidget, "geometry");
-        animation.setDuration(10000);
-        animation.setStartValue(QRect(0, 0, 100, 30));
-        animation.setEndValue(QRect(250, 250, 100, 30));
+        QPropertyAnimation *animation = new QPropertyAnimation(myWidget, "geometry");
+        animation->setDuration(10000);
+        animation->setStartValue(QRect(0, 0, 100, 30));
+        animation->setEndValue(QRect(250, 250, 100, 30));
 
-        animation.start();
+        animation->start();
     \endcode
 
     The property name and the QObject instance of which property
diff --git a/src/corelib/animation/qsequentialanimationgroup.cpp b/src/corelib/animation/qsequentialanimationgroup.cpp
index 861e26e..5dbb8c3 100644
--- a/src/corelib/animation/qsequentialanimationgroup.cpp
+++ b/src/corelib/animation/qsequentialanimationgroup.cpp
@@ -63,12 +63,12 @@
     pause to a sequential animation group.
 
     \code
-        QSequentialAnimationGroup group;
+        QSequentialAnimationGroup *group = new QSequentialAnimationGroup;
 
-        group.addAnimation(anim1);
-        group.addAnimation(anim2);
+        group->addAnimation(anim1);
+        group->addAnimation(anim2);
 
-        group.start();
+        group->start();
     \endcode
 
     In this example, \c anim1 and \c anim2 are two already set up
diff --git a/src/corelib/arch/armv6/qatomic_generic_armv6.cpp b/src/corelib/arch/armv6/qatomic_generic_armv6.cpp
new file mode 100644
index 0000000..3078662
--- /dev/null
+++ b/src/corelib/arch/armv6/qatomic_generic_armv6.cpp
@@ -0,0 +1,260 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtCore 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$
+**
+** This file implements the generic atomics interface using ARMv6 assembly
+** instructions. It is more efficent than the inline versions when Qt is
+** built for the THUMB instruction set, as the required instructions are
+** only available in ARM state.
+****************************************************************************/
+
+#include <QtCore/qglobal.h>
+
+#ifdef QT_HAVE_ARMV6
+
+QT_BEGIN_NAMESPACE
+
+QT_USE_NAMESPACE
+
+#ifdef Q_CC_RVCT
+#pragma push
+#pragma arm
+Q_CORE_EXPORT asm
+bool QBasicAtomicInt_testAndSetOrdered(volatile int *_q_value, int expectedValue, int newValue)
+{
+    CODE32
+    //R0 = _q_value
+    //R1 = expectedValue
+    //R2 = newValue
+retry_testAndSetOrdered
+    LDREX    r3,[r0]        //r3 = *_q_value
+    EORS     r3,r3,r1       //if (r3 == expectedValue) {
+    STREXEQ  r3,r2,[r0]     //*_q_value = newvalue, r3 = error
+    TEQEQ    r3,#1          //if error
+    BEQ      retry_testAndSetOrdered          //then goto retry }
+    RSBS     r0,r3,#1       //return (r3 == 0)
+    MOVCC    r0,#0
+    BX       r14
+}
+
+Q_CORE_EXPORT asm
+int QBasicAtomicInt_fetchAndStoreOrdered(volatile int *_q_value, int newValue)
+{
+    CODE32
+//R0 = _q_value
+//R1 = newValue
+retry_fetchAndStoreOrdered
+    LDREX    r3,[r0]        //r3 = *_q_value
+    STREX    r2,r1,[r0]     //*_q_value = newValue, r2 = error
+    TEQ      r2,#0          //if error
+    BNE      retry_fetchAndStoreOrdered          //then goto retry
+    MOV      r0,r3          //return r3
+    BX       r14
+}
+
+Q_CORE_EXPORT asm
+int QBasicAtomicInt_fetchAndAddOrdered(volatile int *_q_value, int valueToAdd)
+{
+    CODE32
+    //R0 = _q_value
+    //R1 = valueToAdd
+    STMDB    sp!,{r12,lr}
+retry_fetchAndAddOrdered
+    LDREX    r2,[r0]        //r2 = *_q_value
+    ADD      r3,r2,r1       //r3 = r2 + r1
+    STREX    r12,r3,[r0]    //*_q_value = r3, r12 = error
+    TEQ      r12,#0         //if error
+    BNE      retry_fetchAndAddOrdered          //then retry
+    MOV      r0,r2          //return r2
+    LDMIA    sp!,{r12,pc}
+}
+
+Q_CORE_EXPORT asm
+bool QBasicAtomicPointer_testAndSetOrdered(void * volatile *_q_value,
+                                           void *expectedValue,
+                                           void *newValue)
+{
+    CODE32
+    //R0 = _q_value
+    //R1 = expectedValue
+    //R2 = newValue
+retryPointer_testAndSetOrdered
+    LDREX    r3,[r0]        //r3 = *_q_value
+    EORS     r3,r3,r1       //if (r3 == expectedValue) {
+    STREXEQ  r3,r2,[r0]     //*_q_value = newvalue, r3 = error
+    TEQEQ    r3,#1          //if error
+    BEQ      retryPointer_testAndSetOrdered          //then goto retry }
+    RSBS     r0,r3,#1       //return (r3 == 0)
+    MOVCC    r0,#0
+    BX       r14
+}
+
+Q_CORE_EXPORT asm
+void *QBasicAtomicPointer_fetchAndStoreOrdered(void * volatile *_q_value, void *newValue)
+{
+    CODE32
+    //R0 = _q_value
+    //R1 = newValue
+retryPointer_fetchAndStoreOrdered
+    LDREX    r3,[r0]        //r3 = *_q_value
+    STREX    r2,r1,[r0]     //*_q_value = newValue, r2 = error
+    TEQ      r2,#0          //if error
+    BNE      retryPointer_fetchAndStoreOrdered          //then goto retry
+    MOV      r0,r3          //return r3
+    BX       r14
+}
+
+Q_CORE_EXPORT asm
+void *QBasicAtomicPointer_fetchAndAddOrdered(void * volatile *_q_value, qptrdiff valueToAdd)
+{
+    CODE32
+    //R0 = _q_value
+    //R1 = valueToAdd
+    STMDB    sp!,{r12,lr}
+retryPointer_fetchAndAddOrdered
+    LDREX    r2,[r0]        //r2 = *_q_value
+    ADD      r3,r2,r1       //r3 = r2 + r1
+    STREX    r12,r3,[r0]    //*_q_value = r3, r12 = error
+    TEQ      r12,#0         //if error
+    BNE      retryPointer_fetchAndAddOrdered          //then retry
+    MOV      r0,r2          //return r2
+    LDMIA    sp!,{r12,pc}
+}
+
+#pragma pop
+#elif defined (Q_CC_GCCE)
+Q_CORE_EXPORT __declspec( naked )
+bool QBasicAtomicInt_testAndSetOrdered(volatile int *_q_value, int expectedValue, int newValue)
+{
+    //R0 = _q_value
+    //R1 = expectedValue
+    //R2 = newValue
+    asm("retry_testAndSetOrdered:");
+    asm("    LDREX    r3,[r0]");        //r3 = *_q_value
+    asm("    EORS     r3,r3,r1");       //if (r3 == expectedValue) {
+    asm("    STREXEQ  r3,r2,[r0]");     //*_q_value = newvalue, r3 = error
+    asm("    TEQEQ    r3,#1");          //if error
+    asm("    BEQ      retry_testAndSetOrdered");          //then goto retry }
+    asm("    RSBS     r0,r3,#1");       //return (r3 == 0)
+    asm("    MOVCC    r0,#0");
+    asm("    BX       r14");
+}
+
+Q_CORE_EXPORT __declspec( naked )
+int QBasicAtomicInt_fetchAndStoreOrdered(volatile int *_q_value, int newValue)
+{
+//R0 = _q_value
+//R1 = newValue
+    asm("retry_fetchAndStoreOrdered:");
+    asm("    LDREX    r3,[r0]");        //r3 = *_q_value
+    asm("    STREX    r2,r1,[r0]");     //*_q_value = newValue, r2 = error
+    asm("    TEQ      r2,#0");          //if error
+    asm("    BNE      retry_fetchAndStoreOrdered");          //then goto retry
+    asm("    MOV      r0,r3");          //return r3
+    asm("    BX       r14");
+}
+
+Q_CORE_EXPORT __declspec( naked )
+int QBasicAtomicInt_fetchAndAddOrdered(volatile int *_q_value, int valueToAdd)
+{
+    //R0 = _q_value
+    //R1 = valueToAdd
+    asm("    STMDB    sp!,{r12,lr}");
+    asm("retry_fetchAndAddOrdered:");
+    asm("    LDREX    r2,[r0]");        //r2 = *_q_value
+    asm("    ADD      r3,r2,r1 ");      //r3 = r2 + r1
+    asm("    STREX    r12,r3,[r0]");    //*_q_value = r3, r12 = error
+    asm("    TEQ      r12,#0");         //if error
+    asm("    BNE      retry_fetchAndAddOrdered");          //then retry
+    asm("    MOV      r0,r2");          //return r2
+    asm("    LDMIA    sp!,{r12,pc}");
+}
+
+Q_CORE_EXPORT __declspec( naked )
+bool QBasicAtomicPointer_testAndSetOrdered(void * volatile *_q_value,
+                                           void *expectedValue,
+                                           void *newValue)
+{
+    //R0 = _q_value
+    //R1 = expectedValue
+    //R2 = newValue
+    asm("retryPointer_testAndSetOrdered:");
+    asm("    LDREX    r3,[r0]");        //r3 = *_q_value
+    asm("    EORS     r3,r3,r1");       //if (r3 == expectedValue) {
+    asm("    STREXEQ  r3,r2,[r0]");     //*_q_value = newvalue, r3 = error
+    asm("    TEQEQ    r3,#1");          //if error
+    asm("    BEQ      retryPointer_testAndSetOrdered");          //then goto retry }
+    asm("    RSBS     r0,r3,#1");       //return (r3 == 0)
+    asm("    MOVCC    r0,#0");
+    asm("    BX       r14");
+}
+
+Q_CORE_EXPORT __declspec( naked )
+void *QBasicAtomicPointer_fetchAndStoreOrdered(void * volatile *_q_value, void *newValue)
+{
+    //R0 = _q_value
+    //R1 = newValue
+    asm("retryPointer_fetchAndStoreOrdered:");
+    asm("    LDREX    r3,[r0]");        //r3 = *_q_value
+    asm("    STREX    r2,r1,[r0]");     //*_q_value = newValue, r2 = error
+    asm("    TEQ      r2,#0");          //if error
+    asm("    BNE      retryPointer_fetchAndStoreOrdered");          //then goto retry
+    asm("    MOV      r0,r3");          //return r3
+    asm("    BX       r14");
+}
+
+Q_CORE_EXPORT __declspec( naked )
+void *QBasicAtomicPointer_fetchAndAddOrdered(void * volatile *_q_value, qptrdiff valueToAdd)
+{
+    //R0 = _q_value
+    //R1 = valueToAdd
+    asm("    STMDB    sp!,{r12,lr}");
+    asm("retryPointer_fetchAndAddOrdered:");
+    asm("    LDREX    r2,[r0]");        //r2 = *_q_value
+    asm("    ADD      r3,r2,r1");       //r3 = r2 + r1
+    asm("    STREX    r12,r3,[r0]");    //*_q_value = r3, r12 = error
+    asm("    TEQ      r12,#0");         //if error
+    asm("    BNE      retryPointer_fetchAndAddOrdered");          //then retry
+    asm("    MOV      r0,r2");          //return r2
+    asm("    LDMIA    sp!,{r12,pc}");
+}
+#else
+#error unknown arm compiler
+#endif
+QT_END_NAMESPACE
+#endif
diff --git a/src/corelib/arch/qatomic_armv6.h b/src/corelib/arch/qatomic_armv6.h
index 6862638..1e9f0c4 100644
--- a/src/corelib/arch/qatomic_armv6.h
+++ b/src/corelib/arch/qatomic_armv6.h
@@ -45,7 +45,6 @@
 QT_BEGIN_HEADER
 
 QT_BEGIN_NAMESPACE
-
 #define Q_ATOMIC_INT_REFERENCE_COUNTING_IS_ALWAYS_NATIVE
 
 inline bool QBasicAtomicInt::isReferenceCountingNative()
@@ -101,6 +100,8 @@ template <typename T>
 Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::isFetchAndAddWaitFree()
 { return false; }
 
+#ifndef Q_CC_RVCT
+
 inline bool QBasicAtomicInt::ref()
 {
     register int newValue;
@@ -155,21 +156,6 @@ inline bool QBasicAtomicInt::testAndSetOrdered(int expectedValue, int newValue)
     return result == 0;
 }
 
-inline bool QBasicAtomicInt::testAndSetRelaxed(int expectedValue, int newValue)
-{
-    return testAndSetOrdered(expectedValue, newValue);
-}
-
-inline bool QBasicAtomicInt::testAndSetAcquire(int expectedValue, int newValue)
-{
-    return testAndSetOrdered(expectedValue, newValue);
-}
-
-inline bool QBasicAtomicInt::testAndSetRelease(int expectedValue, int newValue)
-{
-    return testAndSetOrdered(expectedValue, newValue);
-}
-
 inline int QBasicAtomicInt::fetchAndStoreOrdered(int newValue)
 {
     register int originalValue;
@@ -188,21 +174,6 @@ inline int QBasicAtomicInt::fetchAndStoreOrdered(int newValue)
     return originalValue;
 }
 
-inline int QBasicAtomicInt::fetchAndStoreRelaxed(int newValue)
-{
-    return fetchAndStoreOrdered(newValue);
-}
-
-inline int QBasicAtomicInt::fetchAndStoreAcquire(int newValue)
-{
-    return fetchAndStoreOrdered(newValue);
-}
-
-inline int QBasicAtomicInt::fetchAndStoreRelease(int newValue)
-{
-    return fetchAndStoreOrdered(newValue);
-}
-
 inline int QBasicAtomicInt::fetchAndAddOrdered(int valueToAdd)
 {
     register int originalValue;
@@ -224,21 +195,6 @@ inline int QBasicAtomicInt::fetchAndAddOrdered(int valueToAdd)
     return originalValue;
 }
 
-inline int QBasicAtomicInt::fetchAndAddRelaxed(int valueToAdd)
-{
-    return fetchAndAddOrdered(valueToAdd);
-}
-
-inline int QBasicAtomicInt::fetchAndAddAcquire(int valueToAdd)
-{
-    return fetchAndAddOrdered(valueToAdd);
-}
-
-inline int QBasicAtomicInt::fetchAndAddRelease(int valueToAdd)
-{
-    return fetchAndAddOrdered(valueToAdd);
-}
-
 template <typename T>
 Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetOrdered(T *expectedValue, T *newValue)
 {
@@ -259,24 +215,6 @@ Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetOrdered(T *expectedValu
 }
 
 template <typename T>
-Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetRelaxed(T *expectedValue, T *newValue)
-{
-    return testAndSetOrdered(expectedValue, newValue);
-}
-
-template <typename T>
-Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetAcquire(T *expectedValue, T *newValue)
-{
-    return testAndSetOrdered(expectedValue, newValue);
-}
-
-template <typename T>
-Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetRelease(T *expectedValue, T *newValue)
-{
-    return testAndSetOrdered(expectedValue, newValue);
-}
-
-template <typename T>
 Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreOrdered(T *newValue)
 {
     register T *originalValue;
@@ -296,24 +234,6 @@ Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreOrdered(T *newValue)
 }
 
 template <typename T>
-Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreRelaxed(T *newValue)
-{
-    return fetchAndStoreOrdered(newValue);
-}
-
-template <typename T>
-Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreAcquire(T *newValue)
-{
-    return fetchAndStoreOrdered(newValue);
-}
-
-template <typename T>
-Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreRelease(T *newValue)
-{
-    return fetchAndStoreOrdered(newValue);
-}
-
-template <typename T>
 Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddOrdered(qptrdiff valueToAdd)
 {
     register T *originalValue;
@@ -335,6 +255,226 @@ Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddOrdered(qptrdiff valueTo
     return originalValue;
 }
 
+#else
+// This is Q_CC_RVCT
+
+// RVCT inline assembly documentation:
+// http://www.keil.com/support/man/docs/armcc/armcc_chdcffdb.htm
+// RVCT embedded assembly documentation:
+// http://www.keil.com/support/man/docs/armcc/armcc_chddbeib.htm
+
+// save our pragma state and switch to ARM mode
+#pragma push
+#pragma arm
+
+inline bool QBasicAtomicInt::ref()
+{
+    register int newValue;
+    register int result;
+    retry:
+    __asm {
+        ldrex   newValue, [&_q_value]
+        add     newValue, newValue, #1
+        strex   result, newValue, [&_q_value]
+        teq     result, #0
+        bne     retry
+    }
+    return newValue != 0;
+}
+
+inline bool QBasicAtomicInt::deref()
+{
+    register int newValue;
+    register int result;
+    retry:
+    __asm {
+        ldrex   newValue, [&_q_value]
+        sub     newValue, newValue, #1
+        strex   result, newValue, [&_q_value]
+        teq     result, #0
+        bne     retry
+    }
+    return newValue != 0;
+}
+
+inline bool QBasicAtomicInt::testAndSetOrdered(int expectedValue, int newValue)
+{
+    register int result;
+    retry:
+    __asm {
+        ldrex   result, [&_q_value]
+        eors    result, result, expectedValue
+        strexeq result, newValue, [&_q_value]
+        teqeq   result, #1
+        beq     retry
+    }
+    return result == 0;
+}
+
+inline int QBasicAtomicInt::fetchAndStoreOrdered(int newValue)
+{
+    register int originalValue;
+    register int result;
+    retry:
+    __asm {
+        ldrex   originalValue, [&_q_value]
+        strex   result, newValue, [&_q_value]
+        teq     result, #0
+        bne     retry
+    }
+    return originalValue;
+}
+
+inline int QBasicAtomicInt::fetchAndAddOrdered(int valueToAdd)
+{
+    register int originalValue;
+    register int newValue;
+    register int result;
+    retry:
+    __asm {
+        ldrex   originalValue, [&_q_value]
+        add     newValue, originalValue, valueToAdd
+        strex   result, newValue, [&_q_value]
+        teq     result, #0
+        bne     retry
+    }
+    return originalValue;
+}
+
+template <typename T>
+Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetOrdered(T *expectedValue, T *newValue)
+{
+    register T *result;
+    retry:
+    __asm {
+        ldrex   result, [&_q_value]
+        eors    result, result, expectedValue
+        strexeq result, newValue, [&_q_value]
+        teqeq   result, #1
+        beq     retry
+    }
+    return result == 0;
+}
+
+template <typename T>
+Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreOrdered(T *newValue)
+{
+    register T *originalValue;
+    register int result;
+    retry:
+    __asm {
+        ldrex   originalValue, [&_q_value]
+        strex   result, newValue, [&_q_value]
+        teq     result, #0
+        bne     retry
+    }
+    return originalValue;
+}
+
+template <typename T>
+Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddOrdered(qptrdiff valueToAdd)
+{
+    register T *originalValue;
+    register T *newValue;
+    register int result;
+    retry:
+    __asm {
+        ldrex   originalValue, [&_q_value]
+        add     newValue, originalValue, valueToAdd * sizeof(T)
+        strex   result, newValue, [&_q_value]
+        teq     result, #0
+        bne     retry
+    }
+    return originalValue;
+}
+
+// go back to the previous pragma state (probably Thumb mode)
+#pragma pop
+#endif
+
+// common code
+
+inline bool QBasicAtomicInt::testAndSetRelaxed(int expectedValue, int newValue)
+{
+    return testAndSetOrdered(expectedValue, newValue);
+}
+
+inline bool QBasicAtomicInt::testAndSetAcquire(int expectedValue, int newValue)
+{
+    return testAndSetOrdered(expectedValue, newValue);
+}
+
+inline bool QBasicAtomicInt::testAndSetRelease(int expectedValue, int newValue)
+{
+    return testAndSetOrdered(expectedValue, newValue);
+}
+
+inline int QBasicAtomicInt::fetchAndStoreRelaxed(int newValue)
+{
+    return fetchAndStoreOrdered(newValue);
+}
+
+inline int QBasicAtomicInt::fetchAndStoreAcquire(int newValue)
+{
+    return fetchAndStoreOrdered(newValue);
+}
+
+inline int QBasicAtomicInt::fetchAndStoreRelease(int newValue)
+{
+    return fetchAndStoreOrdered(newValue);
+}
+
+inline int QBasicAtomicInt::fetchAndAddRelaxed(int valueToAdd)
+{
+    return fetchAndAddOrdered(valueToAdd);
+}
+
+inline int QBasicAtomicInt::fetchAndAddAcquire(int valueToAdd)
+{
+    return fetchAndAddOrdered(valueToAdd);
+}
+
+inline int QBasicAtomicInt::fetchAndAddRelease(int valueToAdd)
+{
+    return fetchAndAddOrdered(valueToAdd);
+}
+
+template <typename T>
+Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetRelaxed(T *expectedValue, T *newValue)
+{
+    return testAndSetOrdered(expectedValue, newValue);
+}
+
+template <typename T>
+Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetAcquire(T *expectedValue, T *newValue)
+{
+    return testAndSetOrdered(expectedValue, newValue);
+}
+
+template <typename T>
+Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetRelease(T *expectedValue, T *newValue)
+{
+    return testAndSetOrdered(expectedValue, newValue);
+}
+
+template <typename T>
+Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreRelaxed(T *newValue)
+{
+    return fetchAndStoreOrdered(newValue);
+}
+
+template <typename T>
+Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreAcquire(T *newValue)
+{
+    return fetchAndStoreOrdered(newValue);
+}
+
+template <typename T>
+Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreRelease(T *newValue)
+{
+    return fetchAndStoreOrdered(newValue);
+}
+
 template <typename T>
 Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddRelaxed(qptrdiff valueToAdd)
 {
diff --git a/src/corelib/arch/qatomic_symbian.h b/src/corelib/arch/qatomic_symbian.h
index 3721aca..92f6ef9 100644
--- a/src/corelib/arch/qatomic_symbian.h
+++ b/src/corelib/arch/qatomic_symbian.h
@@ -42,12 +42,8 @@
 #ifndef QATOMIC_SYMBIAN_H
 #define QATOMIC_SYMBIAN_H
 
-#if defined(Q_CC_RVCT)
-#  define QT_NO_ARM_EABI
-#  include <QtCore/qatomic_arm.h>
-#elif defined(Q_CC_NOKIAX86) || defined(Q_CC_GCCE)
-#  include <QtCore/qatomic_generic.h>
-#endif
+#include <qglobal.h>
+#include <e32std.h>
 
 QT_BEGIN_HEADER
 
@@ -55,7 +51,232 @@ QT_BEGIN_NAMESPACE
 
 QT_MODULE(Core)
 
-// Empty, but needed to avoid warnings
+#define Q_ATOMIC_INT_REFERENCE_COUNTING_IS_SOMETIMES_NATIVE
+
+inline bool QBasicAtomicInt::isReferenceCountingWaitFree()
+{ return false; }
+
+#define Q_ATOMIC_INT_TEST_AND_SET_IS_SOMETIMES_NATIVE
+
+inline bool QBasicAtomicInt::isTestAndSetWaitFree()
+{ return false; }
+
+#define Q_ATOMIC_INT_FETCH_AND_STORE_IS_SOMETIMES_NATIVE
+
+inline bool QBasicAtomicInt::isFetchAndStoreWaitFree()
+{ return false; }
+
+#define Q_ATOMIC_INT_FETCH_AND_ADD_IS_SOMETIMES_NATIVE
+
+inline bool QBasicAtomicInt::isFetchAndAddWaitFree()
+{ return false; }
+
+#define Q_ATOMIC_POINTER_TEST_AND_SET_IS_SOMETIMES_NATIVE
+
+Q_CORE_EXPORT bool QBasicAtomicPointer_isTestAndSetNative();
+template <typename T>
+Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::isTestAndSetNative()
+{ return QBasicAtomicPointer_isTestAndSetNative(); }
+template <typename T>
+Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::isTestAndSetWaitFree()
+{ return false; }
+
+#define Q_ATOMIC_POINTER_FETCH_AND_STORE_IS_SOMETIMES_NATIVE
+
+Q_CORE_EXPORT bool QBasicAtomicPointer_isFetchAndStoreNative();
+template <typename T>
+Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::isFetchAndStoreNative()
+{ return QBasicAtomicPointer_isFetchAndStoreNative(); }
+template <typename T>
+Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::isFetchAndStoreWaitFree()
+{ return false; }
+
+#define Q_ATOMIC_POINTER_FETCH_AND_ADD_IS_SOMETIMES_NATIVE
+
+Q_CORE_EXPORT bool QBasicAtomicPointer_isFetchAndAddNative();
+template <typename T>
+Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::isFetchAndAddNative()
+{ return QBasicAtomicPointer_isFetchAndAddNative(); }
+template <typename T>
+Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::isFetchAndAddWaitFree()
+{ return false; }
+
+Q_CORE_EXPORT bool QBasicAtomicInt_testAndSetOrdered(volatile int *, int, int);
+Q_CORE_EXPORT int QBasicAtomicInt_fetchAndStoreOrdered(volatile int *, int);
+Q_CORE_EXPORT int QBasicAtomicInt_fetchAndAddOrdered(volatile int *, int);
+
+Q_CORE_EXPORT bool QBasicAtomicPointer_testAndSetOrdered(void * volatile *, void *, void *);
+Q_CORE_EXPORT void *QBasicAtomicPointer_fetchAndStoreOrdered(void * volatile *, void *);
+Q_CORE_EXPORT void *QBasicAtomicPointer_fetchAndAddOrdered(void * volatile *, qptrdiff);
+
+// Reference counting
+
+//LockedInc and LockedDec are machine coded for ARMv6 (and future proof)
+inline bool QBasicAtomicInt::ref()
+{
+    int original = User::LockedInc((TInt&)_q_value);
+    return original != -1;
+}
+
+inline bool QBasicAtomicInt::deref()
+{
+    int original = User::LockedDec((TInt&)_q_value);
+    return original != 1;
+}
+
+// Test and set for integers
+
+inline bool QBasicAtomicInt::testAndSetOrdered(int expectedValue, int newValue)
+{
+    return QBasicAtomicInt_testAndSetOrdered(&_q_value, expectedValue, newValue);
+}
+
+inline bool QBasicAtomicInt::testAndSetRelaxed(int expectedValue, int newValue)
+{
+    return testAndSetOrdered(expectedValue, newValue);
+}
+
+inline bool QBasicAtomicInt::testAndSetAcquire(int expectedValue, int newValue)
+{
+    return testAndSetOrdered(expectedValue, newValue);
+}
+
+inline bool QBasicAtomicInt::testAndSetRelease(int expectedValue, int newValue)
+{
+    return testAndSetOrdered(expectedValue, newValue);
+}
+
+// Fetch and store for integers
+
+inline int QBasicAtomicInt::fetchAndStoreOrdered(int newValue)
+{
+    return QBasicAtomicInt_fetchAndStoreOrdered(&_q_value, newValue);
+}
+
+inline int QBasicAtomicInt::fetchAndStoreRelaxed(int newValue)
+{
+    return fetchAndStoreOrdered(newValue);
+}
+
+inline int QBasicAtomicInt::fetchAndStoreAcquire(int newValue)
+{
+    return fetchAndStoreOrdered(newValue);
+}
+
+inline int QBasicAtomicInt::fetchAndStoreRelease(int newValue)
+{
+    return fetchAndStoreOrdered(newValue);
+}
+
+// Fetch and add for integers
+
+inline int QBasicAtomicInt::fetchAndAddOrdered(int valueToAdd)
+{
+    return QBasicAtomicInt_fetchAndAddOrdered(&_q_value, valueToAdd);
+}
+
+inline int QBasicAtomicInt::fetchAndAddRelaxed(int valueToAdd)
+{
+    return fetchAndAddOrdered(valueToAdd);
+}
+
+inline int QBasicAtomicInt::fetchAndAddAcquire(int valueToAdd)
+{
+    return fetchAndAddOrdered(valueToAdd);
+}
+
+inline int QBasicAtomicInt::fetchAndAddRelease(int valueToAdd)
+{
+    return fetchAndAddOrdered(valueToAdd);
+}
+
+// Test and set for pointers
+
+template <typename T>
+Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetOrdered(T *expectedValue, T *newValue)
+{
+    union { T * volatile * typed; void * volatile * voidp; } pointer;
+    pointer.typed = &_q_value;
+    return QBasicAtomicPointer_testAndSetOrdered(pointer.voidp, expectedValue, newValue);
+}
+
+template <typename T>
+Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetRelaxed(T *expectedValue, T *newValue)
+{
+    return testAndSetOrdered(expectedValue, newValue);
+}
+
+template <typename T>
+Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetAcquire(T *expectedValue, T *newValue)
+{
+    return testAndSetOrdered(expectedValue, newValue);
+}
+
+template <typename T>
+Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetRelease(T *expectedValue, T *newValue)
+{
+    return testAndSetOrdered(expectedValue, newValue);
+}
+
+// Fetch and store for pointers
+
+template <typename T>
+Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreOrdered(T *newValue)
+{
+    union { T * volatile * typed; void * volatile * voidp; } pointer;
+    union { T *typed; void *voidp; } returnValue;
+    pointer.typed = &_q_value;
+    returnValue.voidp = QBasicAtomicPointer_fetchAndStoreOrdered(pointer.voidp, newValue);
+    return returnValue.typed;
+}
+
+template <typename T>
+Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreRelaxed(T *newValue)
+{
+    return fetchAndStoreOrdered(newValue);
+}
+
+template <typename T>
+Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreAcquire(T *newValue)
+{
+    return fetchAndStoreOrdered(newValue);
+}
+
+template <typename T>
+Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreRelease(T *newValue)
+{
+    return fetchAndStoreOrdered(newValue);
+}
+
+// Fetch and add for pointers
+
+template <typename T>
+Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddOrdered(qptrdiff valueToAdd)
+{
+    union { T * volatile *typed; void * volatile *voidp; } pointer;
+    union { T *typed; void *voidp; } returnValue;
+    pointer.typed = &_q_value;
+    returnValue.voidp = QBasicAtomicPointer_fetchAndAddOrdered(pointer.voidp, valueToAdd * sizeof(T));
+    return returnValue.typed;
+}
+
+template <typename T>
+Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddRelaxed(qptrdiff valueToAdd)
+{
+    return fetchAndAddOrdered(valueToAdd);
+}
+
+template <typename T>
+Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddAcquire(qptrdiff valueToAdd)
+{
+    return fetchAndAddOrdered(valueToAdd);
+}
+
+template <typename T>
+Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddRelease(qptrdiff valueToAdd)
+{
+    return fetchAndAddOrdered(valueToAdd);
+}
 
 QT_END_NAMESPACE
 
diff --git a/src/corelib/arch/symbian/arch.pri b/src/corelib/arch/symbian/arch.pri
index deb94b1..3ef1c9e 100644
--- a/src/corelib/arch/symbian/arch.pri
+++ b/src/corelib/arch/symbian/arch.pri
@@ -2,4 +2,4 @@
 # Symbian architecture
 #
 SOURCES +=  $$QT_ARCH_CPP/qatomic_symbian.cpp \
-            $$QT_ARCH_CPP/../generic/qatomic_generic_unix.cpp
+            $$QT_ARCH_CPP/../armv6/qatomic_generic_armv6.cpp
diff --git a/src/corelib/arch/symbian/qatomic_symbian.cpp b/src/corelib/arch/symbian/qatomic_symbian.cpp
index 8f02155..91b49c7 100644
--- a/src/corelib/arch/symbian/qatomic_symbian.cpp
+++ b/src/corelib/arch/symbian/qatomic_symbian.cpp
@@ -50,7 +50,7 @@ QT_BEGIN_NAMESPACE
 // This way we can report on heap cells and handles that are really not owned by anything which still exists.
 // This information can be used to detect whether memory leaks are happening, particularly if these numbers grow as the app is used more.
 // This code is placed here as it happens to make it the very last static to be destroyed in a Qt app. The
-// reason assumed is that this file appears before any other file declaring static data in the generated 
+// reason assumed is that this file appears before any other file declaring static data in the generated
 // Symbian MMP file. This particular file was chosen as it is the earliest symbian specific file.
 struct QSymbianPrintExitInfo
 {
@@ -77,37 +77,158 @@ struct QSymbianPrintExitInfo
     TInt initThreadHandleCount;
 } symbian_printExitInfo;
 
-QT_END_NAMESPACE
+Q_CORE_EXPORT bool QBasicAtomicInt::isReferenceCountingNative()
+{
+#ifdef QT_HAVE_ARMV6
+    return true;
+#else
+    return false;
+#endif
+}
 
+Q_CORE_EXPORT bool QBasicAtomicInt::isTestAndSetNative()
+{
+#ifdef QT_HAVE_ARMV6
+    return true;
+#else
+    return false;
+#endif
+}
 
-#if defined(Q_CC_RVCT)
+Q_CORE_EXPORT bool QBasicAtomicInt::isFetchAndStoreNative()
+{
+#ifdef QT_HAVE_ARMV6
+    return true;
+#else
+    return false;
+#endif
+}
 
-#include "../arm/qatomic_arm.cpp"
+Q_CORE_EXPORT bool QBasicAtomicInt::isFetchAndAddNative()
+{
+#ifdef QT_HAVE_ARMV6
+    return true;
+#else
+    return false;
+#endif
+}
 
-QT_BEGIN_NAMESPACE
+Q_CORE_EXPORT bool QBasicAtomicPointer_isTestAndSetNative()
+{
+#ifdef QT_HAVE_ARMV6
+    return true;
+#else
+    return false;
+#endif
+}
 
-Q_CORE_EXPORT __asm char q_atomic_swp(volatile char *ptr, char newval)
+Q_CORE_EXPORT bool QBasicAtomicPointer_isFetchAndStoreNative()
 {
-    add r2, pc, #0
-    bx r2
-    arm
-    swpb r2,r1,[r0]
-    mov r0, r2
-    bx lr
-    thumb
+#ifdef QT_HAVE_ARMV6
+    return true;
+#else
+    return false;
+#endif
 }
 
-Q_CORE_EXPORT __asm int QBasicAtomicInt::fetchAndStoreOrdered(int newValue)
+Q_CORE_EXPORT bool QBasicAtomicPointer_isFetchAndAddNative()
 {
-    add r2, pc, #0
-    bx r2
-    arm
-    swp r2,r1,[r0]
-    mov r0, r2
-    bx lr
-    thumb
+#ifdef QT_HAVE_ARMV6
+    return true;
+#else
+    return false;
+#endif
 }
 
-QT_END_NAMESPACE
+//For ARMv6, the generic atomics are machine coded
+#ifndef QT_HAVE_ARMV6
+
+class QCriticalSection
+{
+public:
+        QCriticalSection()  { fastlock.CreateLocal(); }
+        ~QCriticalSection() { fastlock.Close(); }
+        void lock()         { fastlock.Wait(); }
+        void unlock()       { fastlock.Signal(); }
 
-#endif // Q_CC_RVCT
+private:
+        RFastLock fastlock;
+};
+
+QCriticalSection qAtomicCriticalSection;
+
+Q_CORE_EXPORT
+bool QBasicAtomicInt_testAndSetOrdered(volatile int *_q_value, int expectedValue, int newValue)
+{
+    bool returnValue = false;
+    qAtomicCriticalSection.lock();
+    if (*_q_value == expectedValue) {
+        *_q_value = newValue;
+        returnValue = true;
+    }
+        qAtomicCriticalSection.unlock();
+    return returnValue;
+}
+
+Q_CORE_EXPORT
+int QBasicAtomicInt_fetchAndStoreOrdered(volatile int *_q_value, int newValue)
+{
+    int returnValue;
+        qAtomicCriticalSection.lock();
+    returnValue = *_q_value;
+    *_q_value = newValue;
+        qAtomicCriticalSection.unlock();
+    return returnValue;
+}
+
+Q_CORE_EXPORT
+int QBasicAtomicInt_fetchAndAddOrdered(volatile int *_q_value, int valueToAdd)
+{
+    int returnValue;
+        qAtomicCriticalSection.lock();
+    returnValue = *_q_value;
+    *_q_value += valueToAdd;
+        qAtomicCriticalSection.unlock();
+    return returnValue;
+}
+
+Q_CORE_EXPORT
+bool QBasicAtomicPointer_testAndSetOrdered(void * volatile *_q_value,
+                                           void *expectedValue,
+                                           void *newValue)
+{
+    bool returnValue = false;
+        qAtomicCriticalSection.lock();
+    if (*_q_value == expectedValue) {
+        *_q_value = newValue;
+        returnValue = true;
+    }
+        qAtomicCriticalSection.unlock();
+    return returnValue;
+}
+
+Q_CORE_EXPORT
+void *QBasicAtomicPointer_fetchAndStoreOrdered(void * volatile *_q_value, void *newValue)
+{
+    void *returnValue;
+        qAtomicCriticalSection.lock();
+    returnValue = *_q_value;
+    *_q_value = newValue;
+        qAtomicCriticalSection.unlock();
+    return returnValue;
+}
+
+Q_CORE_EXPORT
+void *QBasicAtomicPointer_fetchAndAddOrdered(void * volatile *_q_value, qptrdiff valueToAdd)
+{
+    void *returnValue;
+        qAtomicCriticalSection.lock();
+    returnValue = *_q_value;
+    *_q_value = reinterpret_cast<char *>(returnValue) + valueToAdd;
+        qAtomicCriticalSection.unlock();
+    return returnValue;
+}
+
+#endif // QT_HAVE_ARMV6
+
+QT_END_NAMESPACE
diff --git a/src/corelib/global/qglobal.h b/src/corelib/global/qglobal.h
index d113e02..9558256 100644
--- a/src/corelib/global/qglobal.h
+++ b/src/corelib/global/qglobal.h
@@ -437,13 +437,18 @@ namespace QT_NAMESPACE {}
 #elif defined(__GCCE__)
 #  define Q_CC_GCCE
 #  define QT_VISIBILITY_AVAILABLE
+#  if defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__)
+#    define QT_HAVE_ARMV6
+#  endif
 
 /* ARM Realview Compiler Suite
    RVCT compiler also defines __EDG__ and __GNUC__ (if --gnu flag is given),
    so check for it before that */
 #elif defined(__ARMCC__) || defined(__CC_ARM)
 #  define Q_CC_RVCT
-
+#  if __TARGET_ARCH_ARM >= 6
+#    define QT_HAVE_ARMV6
+#  endif
 #elif defined(__GNUC__)
 #  define Q_CC_GNU
 #  define Q_C_CALLBACKS
diff --git a/src/corelib/kernel/qabstractitemmodel.cpp b/src/corelib/kernel/qabstractitemmodel.cpp
index 8e2273d..10a61ca 100644
--- a/src/corelib/kernel/qabstractitemmodel.cpp
+++ b/src/corelib/kernel/qabstractitemmodel.cpp
@@ -2475,10 +2475,8 @@ void QAbstractItemModel::endRemoveRows()
 bool QAbstractItemModelPrivate::allowMove(const QModelIndex &srcParent, int start, int end, const QModelIndex &destinationParent, int destinationStart, Qt::Orientation orientation)
 {
     // Don't move the range within itself.
-    if ( ( destinationParent == srcParent )
-            && ( destinationStart >= start )
-            && ( destinationStart <= end + 1) )
-        return false;
+    if (destinationParent == srcParent)
+        return !(destinationStart >= start && destinationStart <= end + 1);
 
     QModelIndex destinationAncestor = destinationParent;
     int pos = (Qt::Vertical == orientation) ? destinationAncestor.row() : destinationAncestor.column();
diff --git a/src/corelib/kernel/qeventdispatcher_win.cpp b/src/corelib/kernel/qeventdispatcher_win.cpp
index 3050b82..0518e24 100644
--- a/src/corelib/kernel/qeventdispatcher_win.cpp
+++ b/src/corelib/kernel/qeventdispatcher_win.cpp
@@ -675,6 +675,11 @@ bool QEventDispatcherWin32::processEvents(QEventLoop::ProcessEventsFlags flags)
     bool seenWM_QT_SENDPOSTEDEVENTS = false;
     bool needWM_QT_SENDPOSTEDEVENTS = false;
     do {
+        if (! (flags & QEventLoop::EventLoopExec)) {
+            // when called "manually", always send posted events
+            QCoreApplicationPrivate::sendPostedEvents(0, 0, d->threadData);
+        }
+
         DWORD waitRet = 0;
         HANDLE pHandles[MAXIMUM_WAIT_OBJECTS - 1];
         QVarLengthArray<MSG> processedTimers;
diff --git a/src/gui/dialogs/qfiledialog.cpp b/src/gui/dialogs/qfiledialog.cpp
index 6bc6b76..3b1befd 100644
--- a/src/gui/dialogs/qfiledialog.cpp
+++ b/src/gui/dialogs/qfiledialog.cpp
@@ -3022,12 +3022,6 @@ bool QFileDialogPrivate::itemViewKeyboardEvent(QKeyEvent *event) {
     case Qt::Key_Escape:
         q->hide();
         return true;
-#ifdef QT_KEYPAD_NAVIGATION
-    case Qt::Key_Down:
-    case Qt::Key_Up:
-        return (QApplication::navigationMode() != Qt::NavigationModeKeypadTabOrder
-                && QApplication::navigationMode() != Qt::NavigationModeKeypadDirectional);
-#endif
     default:
         break;
     }
@@ -3145,20 +3139,16 @@ QSize QFileDialogListView::sizeHint() const
 
 void QFileDialogListView::keyPressEvent(QKeyEvent *e)
 {
-    if (!d_ptr->itemViewKeyboardEvent(e)) {
-        QListView::keyPressEvent(e);
-    }
 #ifdef QT_KEYPAD_NAVIGATION
-    else if ((QApplication::navigationMode() == Qt::NavigationModeKeypadTabOrder
-         || QApplication::navigationMode() == Qt::NavigationModeKeypadDirectional)
-         && !hasEditFocus()) {
-         e->ignore();
-    } else {
-        e->accept();
+    if (QApplication::navigationMode() == Qt::NavigationModeKeypadDirectional) {
+        QListView::keyPressEvent(e);
+        return;
     }
-#else
+#endif // QT_KEYPAD_NAVIGATION
+
+    if (!d_ptr->itemViewKeyboardEvent(e))
+        QListView::keyPressEvent(e);
     e->accept();
-#endif
 }
 
 QFileDialogTreeView::QFileDialogTreeView(QWidget *parent) : QTreeView(parent)
@@ -3184,20 +3174,16 @@ void QFileDialogTreeView::init(QFileDialogPrivate *d_pointer)
 
 void QFileDialogTreeView::keyPressEvent(QKeyEvent *e)
 {
-    if (!d_ptr->itemViewKeyboardEvent(e)) {
-        QTreeView::keyPressEvent(e);
-    }
 #ifdef QT_KEYPAD_NAVIGATION
-    else if ((QApplication::navigationMode() == Qt::NavigationModeKeypadTabOrder
-         || QApplication::navigationMode() == Qt::NavigationModeKeypadDirectional)
-         && !hasEditFocus()) {
-         e->ignore();
-    } else {
-        e->accept();
+    if (QApplication::navigationMode() == Qt::NavigationModeKeypadDirectional) {
+        QTreeView::keyPressEvent(e);
+        return;
     }
-#else
+#endif // QT_KEYPAD_NAVIGATION
+
+    if (!d_ptr->itemViewKeyboardEvent(e))
+        QTreeView::keyPressEvent(e);
     e->accept();
-#endif
 }
 
 QSize QFileDialogTreeView::sizeHint() const
@@ -3213,13 +3199,16 @@ QSize QFileDialogTreeView::sizeHint() const
 */
 void QFileDialogLineEdit::keyPressEvent(QKeyEvent *e)
 {
+#ifdef QT_KEYPAD_NAVIGATION
+    if (QApplication::navigationMode() == Qt::NavigationModeKeypadDirectional) {
+        QLineEdit::keyPressEvent(e);
+        return;
+    }
+#endif // QT_KEYPAD_NAVIGATION
+
     int key = e->key();
     QLineEdit::keyPressEvent(e);
-    if (key != Qt::Key_Escape
-#ifdef QT_KEYPAD_NAVIGATION
-        && QApplication::navigationMode() == Qt::NavigationModeNone
-#endif
-        )
+    if (key != Qt::Key_Escape)
         e->accept();
     if (hideOnEsc && (key == Qt::Key_Escape || key == Qt::Key_Return || key == Qt::Key_Enter)) {
         e->accept();
diff --git a/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp b/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp
index 182594e..594a205 100644
--- a/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp
+++ b/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp
@@ -903,7 +903,7 @@ bool QGraphicsAnchorLayoutPrivate::simplifyGraphIteration(QGraphicsAnchorLayoutP
     QStack<QPair<AnchorVertex *, AnchorVertex *> > stack;
     stack.push(qMakePair(static_cast<AnchorVertex *>(0), layoutFirstVertex[orientation]));
     QVector<AnchorVertex*> candidates;
-    bool candidatesForward;
+    bool candidatesForward = true;
 
     // Walk depth-first, in the stack we store start of the candidate sequence (beforeSequence)
     // and the vertex to be visited.
diff --git a/src/gui/graphicsview/qgraphicsitem.cpp b/src/gui/graphicsview/qgraphicsitem.cpp
index 9d495e9..4e5e5c8 100644
--- a/src/gui/graphicsview/qgraphicsitem.cpp
+++ b/src/gui/graphicsview/qgraphicsitem.cpp
@@ -9606,6 +9606,7 @@ void QGraphicsTextItem::setDefaultTextColor(const QColor &col)
     QPalette pal = c->palette();
     pal.setColor(QPalette::Text, col);
     c->setPalette(pal);
+    update();
 }
 
 /*!
diff --git a/src/gui/graphicsview/qgraphicsscene.cpp b/src/gui/graphicsview/qgraphicsscene.cpp
index 13f31b8..5b0643d 100644
--- a/src/gui/graphicsview/qgraphicsscene.cpp
+++ b/src/gui/graphicsview/qgraphicsscene.cpp
@@ -4551,6 +4551,10 @@ void QGraphicsScenePrivate::drawItemHelper(QGraphicsItem *item, QPainter *painte
 void QGraphicsScenePrivate::drawItems(QPainter *painter, const QTransform *const viewTransform,
                                       QRegion *exposedRegion, QWidget *widget)
 {
+    // Make sure we don't have unpolished items before we draw.
+    if (!unpolishedItems.isEmpty())
+        _q_polishItems();
+
     QRectF exposedSceneRect;
     if (exposedRegion && indexMethod != QGraphicsScene::NoIndex) {
         exposedSceneRect = exposedRegion->boundingRect().adjusted(-1, -1, 1, 1);
@@ -5077,6 +5081,10 @@ void QGraphicsScene::drawItems(QPainter *painter,
                                const QStyleOptionGraphicsItem options[], QWidget *widget)
 {
     Q_D(QGraphicsScene);
+    // Make sure we don't have unpolished items before we draw.
+    if (!d->unpolishedItems.isEmpty())
+        d->_q_polishItems();
+
     QTransform viewTransform = painter->worldTransform();
     Q_UNUSED(options);
 
diff --git a/src/gui/graphicsview/qgraphicsview.cpp b/src/gui/graphicsview/qgraphicsview.cpp
index 27fd09e..3ef311c 100644
--- a/src/gui/graphicsview/qgraphicsview.cpp
+++ b/src/gui/graphicsview/qgraphicsview.cpp
@@ -3275,13 +3275,10 @@ void QGraphicsView::paintEvent(QPaintEvent *event)
 
     // Determine the exposed region
     d->exposedRegion = event->region();
-    if (d->exposedRegion.isEmpty())
-        d->exposedRegion = viewport()->rect();
     QRectF exposedSceneRect = mapToScene(d->exposedRegion.boundingRect()).boundingRect();
 
     // Set up the painter
     QPainter painter(viewport());
-    painter.setClipRect(event->rect(), Qt::IntersectClip);
 #ifndef QT_NO_RUBBERBAND
     if (d->rubberBanding && !d->rubberBandRect.isEmpty())
         painter.save();
diff --git a/src/gui/image/qpixmap_s60.cpp b/src/gui/image/qpixmap_s60.cpp
index 9d783dd..17baa50 100644
--- a/src/gui/image/qpixmap_s60.cpp
+++ b/src/gui/image/qpixmap_s60.cpp
@@ -349,7 +349,8 @@ QS60PixmapData::QS60PixmapData(PixelType type) : QRasterPixmapData(type),
     bitmapDevice(0),
     bitmapGc(0),
     pengine(0),
-    bytes(0)
+    bytes(0),
+    formatLocked(false)
 {
 
 }
@@ -425,11 +426,12 @@ void QS60PixmapData::release()
 }
 
 /*!
- * Takes ownership of bitmap
+ * Takes ownership of bitmap. Used by window surface
  */
 void QS60PixmapData::fromSymbianBitmap(CFbsBitmap* bitmap)
 {
 	cfbsBitmap = bitmap;
+	formatLocked = true;
 
 	 if(!initSymbianBitmapContext()) {
 		qWarning("Could not create CBitmapContext");
@@ -693,8 +695,10 @@ void QS60PixmapData::beginDataAccess()
     bytes = newBytes;
     TDisplayMode mode = cfbsBitmap->DisplayMode();
     QImage::Format format = qt_TDisplayMode2Format(mode);
-    //on S60 3.1, premultiplied alpha pixels are stored in a bitmap with 16MA type
-    if (format == QImage::Format_ARGB32)
+    // On S60 3.1, premultiplied alpha pixels are stored in a bitmap with 16MA type.
+    // S60 window surface needs backing store pixmap for transparent window in ARGB32 format.
+    // In that case formatLocked is true.
+    if (!formatLocked && format == QImage::Format_ARGB32)
         format = QImage::Format_ARGB32_Premultiplied; // pixel data is actually in premultiplied format
 
     QVector<QRgb> savedColorTable;
diff --git a/src/gui/image/qpixmap_s60_p.h b/src/gui/image/qpixmap_s60_p.h
index b23961a..b1b5824 100644
--- a/src/gui/image/qpixmap_s60_p.h
+++ b/src/gui/image/qpixmap_s60_p.h
@@ -118,6 +118,8 @@ private:
     QPaintEngine *pengine;
     uchar* bytes;
 
+    bool formatLocked;
+
     friend class QPixmap;
     friend class QS60WindowSurface;
     friend class QS60PaintEngine;
diff --git a/src/gui/inputmethod/qcoefepinputcontext_p.h b/src/gui/inputmethod/qcoefepinputcontext_p.h
index 2c65b4c..e24ee04 100644
--- a/src/gui/inputmethod/qcoefepinputcontext_p.h
+++ b/src/gui/inputmethod/qcoefepinputcontext_p.h
@@ -84,7 +84,7 @@ public:
 
     bool filterEvent(const QEvent *event);
     void mouseHandler( int x, QMouseEvent *event);
-    bool isComposing() const { return m_isEditing; }
+    bool isComposing() const { return !m_preeditString.isEmpty(); }
 
     void setFocusWidget(QWidget * w);
     void widgetDestroyed(QWidget *w);
@@ -132,6 +132,7 @@ public:
     // From MObjectProvider
 public:
     TTypeUid::Ptr MopSupplyObject(TTypeUid id);
+    MObjectProvider *MopNext();
 
 private:
     QSymbianControl *m_parent;
@@ -139,13 +140,14 @@ private:
     QString m_preeditString;
     Qt::InputMethodHints m_lastImHints;
     TUint m_textCapabilities;
-    bool m_isEditing;
     bool m_inDestruction;
     bool m_pendingInputCapabilitiesChanged;
     int m_cursorVisibility;
     int m_inlinePosition;
     MFepInlineTextFormatRetriever *m_formatRetriever;
     MFepPointerEventHandlerDuringInlineEdit *m_pointerHandler;
+    int m_longPress;
+    int m_cursorPos;
 };
 
 QT_END_NAMESPACE
diff --git a/src/gui/inputmethod/qcoefepinputcontext_s60.cpp b/src/gui/inputmethod/qcoefepinputcontext_s60.cpp
index 19f296c..bdff5e7 100644
--- a/src/gui/inputmethod/qcoefepinputcontext_s60.cpp
+++ b/src/gui/inputmethod/qcoefepinputcontext_s60.cpp
@@ -65,13 +65,14 @@ QCoeFepInputContext::QCoeFepInputContext(QObject *parent)
       m_fepState(q_check_ptr(new CAknEdwinState)),		// CBase derived object needs check on new
       m_lastImHints(Qt::ImhNone),
       m_textCapabilities(TCoeInputCapabilities::EAllText),
-      m_isEditing(false),
       m_inDestruction(false),
       m_pendingInputCapabilitiesChanged(false),
       m_cursorVisibility(1),
       m_inlinePosition(0),
       m_formatRetriever(0),
-      m_pointerHandler(0)
+      m_pointerHandler(0),
+      m_longPress(0),
+      m_cursorPos(0)
 {
     m_fepState->SetObjectProvider(this);
     m_fepState->SetFlags(EAknEditorFlagDefault);
@@ -79,7 +80,7 @@ QCoeFepInputContext::QCoeFepInputContext(QObject *parent)
     m_fepState->SetPermittedInputModes( EAknEditorAllInputModes );
     m_fepState->SetDefaultCase( EAknEditorLowerCase );
     m_fepState->SetPermittedCases( EAknEditorLowerCase|EAknEditorUpperCase );
-    m_fepState->SetSpecialCharacterTableResourceId( 0 );
+    m_fepState->SetSpecialCharacterTableResourceId(R_AVKON_SPECIAL_CHARACTER_TABLE_DIALOG);
     m_fepState->SetNumericKeymap( EAknEditorStandardNumberModeKeymap );
 }
 
@@ -202,14 +203,26 @@ bool QCoeFepInputContext::filterEvent(const QEvent *event)
 
     if (event->type() == QEvent::KeyPress || event->type() == QEvent::KeyRelease) {
         const QKeyEvent *keyEvent = static_cast<const QKeyEvent *>(event);
-        Q_ASSERT(m_lastImHints == focusWidget()->inputMethodHints());
-        if (keyEvent->key() == Qt::Key_F20 && m_lastImHints & Qt::ImhHiddenText) {
-            // Special case in Symbian. On editors with secret text, F20 is for some reason
-            // considered to be a backspace.
-            QKeyEvent modifiedEvent(keyEvent->type(), Qt::Key_Backspace, keyEvent->modifiers(),
-                    keyEvent->text(), keyEvent->isAutoRepeat(), keyEvent->count());
-            QApplication::sendEvent(focusWidget(), &modifiedEvent);
-            return true;
+        switch (keyEvent->key()) {
+        case Qt::Key_F20:
+            Q_ASSERT(m_lastImHints == focusWidget()->inputMethodHints());
+            if (m_lastImHints & Qt::ImhHiddenText) {
+                // Special case in Symbian. On editors with secret text, F20 is for some reason
+                // considered to be a backspace.
+                QKeyEvent modifiedEvent(keyEvent->type(), Qt::Key_Backspace, keyEvent->modifiers(),
+                        keyEvent->text(), keyEvent->isAutoRepeat(), keyEvent->count());
+                QApplication::sendEvent(focusWidget(), &modifiedEvent);
+                return true;
+            }
+            break;
+        case Qt::Key_Select:
+            if (!m_preeditString.isEmpty()) {
+                commitCurrentString(false);
+                return true;
+            }
+            break;
+        default:
+            break;
         }
     }
 
@@ -243,7 +256,6 @@ bool QCoeFepInputContext::filterEvent(const QEvent *event)
 
 void QCoeFepInputContext::mouseHandler( int x, QMouseEvent *event)
 {
-    Q_ASSERT(m_isEditing);
     Q_ASSERT(focusWidget());
 
     if (event->type() == QEvent::MouseButtonPress && event->button() == Qt::LeftButton) {
@@ -407,6 +419,14 @@ void QCoeFepInputContext::applyHints(Qt::InputMethodHints hints)
     }
     m_fepState->SetNumericKeymap(static_cast<TAknEditorNumericKeymap>(flags));
 
+    if (hints & ImhEmailCharactersOnly) {
+        m_fepState->SetSpecialCharacterTableResourceId(R_AVKON_EMAIL_ADDR_SPECIAL_CHARACTER_TABLE_DIALOG);
+    } else if (hints & ImhUrlCharactersOnly) {
+        m_fepState->SetSpecialCharacterTableResourceId(R_AVKON_URL_SPECIAL_CHARACTER_TABLE_DIALOG);
+    } else {
+        m_fepState->SetSpecialCharacterTableResourceId(R_AVKON_SPECIAL_CHARACTER_TABLE_DIALOG);
+    }
+
     if (hints & ImhHiddenText) {
         m_textCapabilities = TCoeInputCapabilities::EAllText | TCoeInputCapabilities::ESecretText;
     } else {
@@ -478,8 +498,8 @@ void QCoeFepInputContext::StartFepInlineEditL(const TDesC& aInitialInlineText,
     if (!w)
         return;
 
-    m_isEditing = true;
-
+    m_cursorPos = w->inputMethodQuery(Qt::ImCursorPosition).toInt();
+    
     QList<QInputMethodEvent::Attribute> attributes;
 
     m_cursorVisibility = aCursorVisibility ? 1 : 0;
@@ -543,8 +563,6 @@ void QCoeFepInputContext::CancelFepInlineEdit()
     event.setCommitString(QLatin1String(""), 0, 0);
     m_preeditString.clear();
     sendEvent(event);
-
-    m_isEditing = false;
 }
 
 TInt QCoeFepInputContext::DocumentLengthForFep() const
@@ -683,16 +701,22 @@ void QCoeFepInputContext::DoCommitFepInlineEditL()
 void QCoeFepInputContext::commitCurrentString(bool triggeredBySymbian)
 {
     if (m_preeditString.size() == 0) {
+        QWidget *w = focusWidget();
+        if (triggeredBySymbian && w) {
+            // We must replace the last character only if the input box has already accepted one 
+            if (w->inputMethodQuery(Qt::ImCursorPosition).toInt() != m_cursorPos)
+                m_longPress = 1;
+        }
         return;
     }
 
     QList<QInputMethodEvent::Attribute> attributes;
     QInputMethodEvent event(QLatin1String(""), attributes);
-    event.setCommitString(m_preeditString, 0, 0);//m_preeditString.size());
+    event.setCommitString(m_preeditString, 0-m_longPress, m_longPress);
     m_preeditString.clear();
     sendEvent(event);
 
-    m_isEditing = false;
+    m_longPress = 0;
 
     if (!triggeredBySymbian) {
         CCoeFep* fep = CCoeEnv::Static()->Fep();
@@ -733,6 +757,14 @@ TTypeUid::Ptr QCoeFepInputContext::MopSupplyObject(TTypeUid /*id*/)
     return TTypeUid::Null();
 }
 
+MObjectProvider *QCoeFepInputContext::MopNext()
+{
+    QWidget *w = focusWidget();
+    if (w)
+        return w->effectiveWinId();
+    return 0;
+}
+
 QT_END_NAMESPACE
 
 #endif // QT_NO_IM
diff --git a/src/gui/itemviews/qtreewidget.cpp b/src/gui/itemviews/qtreewidget.cpp
index 040c498..c133ae4 100644
--- a/src/gui/itemviews/qtreewidget.cpp
+++ b/src/gui/itemviews/qtreewidget.cpp
@@ -2851,7 +2851,14 @@ QTreeWidgetItem *QTreeWidget::itemAt(const QPoint &p) const
 QRect QTreeWidget::visualItemRect(const QTreeWidgetItem *item) const
 {
     Q_D(const QTreeWidget);
-    return visualRect(d->index(item));
+    //the visual rect for an item is across all columns. So we need to determine
+	//what is the first and last column and get their visual index rects
+    QModelIndex base = d->index(item);
+    const int firstVisiblesection = header()->logicalIndexAt(- header()->offset());
+    const int lastVisibleSection = header()->logicalIndexAt(header()->length() - header()->offset() - 1);
+    QModelIndex first = base.sibling(base.row(), header()->logicalIndex(firstVisiblesection));
+    QModelIndex last = base.sibling(base.row(), header()->logicalIndex(lastVisibleSection));
+    return visualRect(first) | visualRect(last);
 }
 
 /*!
diff --git a/src/gui/kernel/qaction.cpp b/src/gui/kernel/qaction.cpp
index 6f3cbaf..3eaf2e1 100644
--- a/src/gui/kernel/qaction.cpp
+++ b/src/gui/kernel/qaction.cpp
@@ -100,6 +100,21 @@ QActionPrivate::~QActionPrivate()
 {
 }
 
+bool QActionPrivate::showStatusText(QWidget *widget, const QString &str)
+{
+#ifdef QT_NO_STATUSTIP
+    Q_UNUSED(widget);
+    Q_UNUSED(str);
+#else
+    if(QObject *object = widget ? widget : parent) {
+        QStatusTipEvent tip(str);
+        QApplication::sendEvent(object, &tip);
+        return true;
+    }
+#endif
+    return false;
+}
+
 void QActionPrivate::sendDataChanged()
 {
     Q_Q(QAction);
@@ -1206,16 +1221,7 @@ QAction::setData(const QVariant &data)
 bool
 QAction::showStatusText(QWidget *widget)
 {
-#ifdef QT_NO_STATUSTIP
-    Q_UNUSED(widget);
-#else
-    if(QObject *object = widget ? widget : parent()) {
-        QStatusTipEvent tip(statusTip());
-        QApplication::sendEvent(object, &tip);
-        return true;
-    }
-#endif
-    return false;
+    return d_func()->showStatusText(widget, statusTip());
 }
 
 /*!
diff --git a/src/gui/kernel/qaction_p.h b/src/gui/kernel/qaction_p.h
index 2527a02..f7b035b 100644
--- a/src/gui/kernel/qaction_p.h
+++ b/src/gui/kernel/qaction_p.h
@@ -75,6 +75,8 @@ public:
     QActionPrivate();
     ~QActionPrivate();
 
+    bool showStatusText(QWidget *w, const QString &str);
+
     QPointer<QActionGroup> group;
     QString text;
     QString iconText;
diff --git a/src/gui/kernel/qapplication.cpp b/src/gui/kernel/qapplication.cpp
index 987aa26..4b8f6a0 100644
--- a/src/gui/kernel/qapplication.cpp
+++ b/src/gui/kernel/qapplication.cpp
@@ -791,7 +791,8 @@ void QApplicationPrivate::construct(
     }
 
     //make sure the plugin is loaded
-    qt_guiPlatformPlugin();
+    if (qt_is_gui_used)
+        qt_guiPlatformPlugin();
 #endif
 }
 
diff --git a/src/gui/kernel/qapplication_s60.cpp b/src/gui/kernel/qapplication_s60.cpp
index ec95d48..04e4b31 100644
--- a/src/gui/kernel/qapplication_s60.cpp
+++ b/src/gui/kernel/qapplication_s60.cpp
@@ -319,7 +319,12 @@ void QLongTapTimer::RunL()
 }
 
 QSymbianControl::QSymbianControl(QWidget *w)
-    : CCoeControl(), qwidget(w), m_ignoreFocusChanged(false)
+    : CCoeControl()
+    , qwidget(w)
+    , m_longTapDetector(0)
+    , m_ignoreFocusChanged(0)
+    , m_previousEventLongTap(0)
+    , m_symbianPopupIsOpen(0)
 {
 }
 
@@ -911,6 +916,15 @@ void QSymbianControl::FocusChanged(TDrawNow /* aDrawNow */)
         return;
 
     if (IsFocused() && IsVisible()) {
+        if (m_symbianPopupIsOpen) {
+            QWidget *fw = QApplication::focusWidget();
+            if (fw) {
+                QFocusEvent event(QEvent::FocusIn, Qt::PopupFocusReason);
+                QCoreApplication::sendEvent(fw, &event);
+            }
+            m_symbianPopupIsOpen = false;
+        }
+
         QApplication::setActiveWindow(qwidget->window());
 #ifdef Q_WS_S60
         // If widget is fullscreen, hide status pane and button container
@@ -924,6 +938,16 @@ void QSymbianControl::FocusChanged(TDrawNow /* aDrawNow */)
             buttonGroup->MakeVisible(!isFullscreen);
 #endif
     } else if (QApplication::activeWindow() == qwidget->window()) {
+        if (CCoeEnv::Static()->AppUi()->IsDisplayingMenuOrDialog()) {
+            QWidget *fw = QApplication::focusWidget();
+            if (fw) {
+                QFocusEvent event(QEvent::FocusOut, Qt::PopupFocusReason);
+                QCoreApplication::sendEvent(fw, &event);
+            }
+            m_symbianPopupIsOpen = true;
+            return;
+        }
+
         QApplication::setActiveWindow(0);
     }
     // else { We don't touch the active window unless we were explicitly activated or deactivated }
diff --git a/src/gui/kernel/qgesturemanager.cpp b/src/gui/kernel/qgesturemanager.cpp
index 3d4bb8c..192f9ac 100644
--- a/src/gui/kernel/qgesturemanager.cpp
+++ b/src/gui/kernel/qgesturemanager.cpp
@@ -601,6 +601,7 @@ void QGestureManager::deliverEvents(const QSet<QGesture *> &gestures,
 
         Qt::GestureType gestureType = gesture->gestureType();
         Q_ASSERT(gestureType != Qt::CustomGesture);
+        Q_UNUSED(gestureType);
 
         if (target) {
             if (gesture->state() == Qt::GestureStarted) {
diff --git a/src/gui/kernel/qkeysequence.cpp b/src/gui/kernel/qkeysequence.cpp
index 1a76083..89c18fb 100644
--- a/src/gui/kernel/qkeysequence.cpp
+++ b/src/gui/kernel/qkeysequence.cpp
@@ -1014,9 +1014,12 @@ bool QKeySequence::isEmpty() const
 */
 QKeySequence QKeySequence::mnemonic(const QString &text)
 {
+    QKeySequence ret;
+
     if(qt_sequence_no_mnemonics)
-	return QKeySequence();
+        return ret;
 
+    bool found = false;
     int p = 0;
     while (p >= 0) {
         p = text.indexOf(QLatin1Char('&'), p) + 1;
@@ -1025,13 +1028,22 @@ QKeySequence QKeySequence::mnemonic(const QString &text)
         if (text.at(p) != QLatin1Char('&')) {
             QChar c = text.at(p);
             if (c.isPrint()) {
-                c = c.toUpper();
-                return QKeySequence(c.unicode() + Qt::ALT);
+                if (!found) {
+                    c = c.toUpper();
+                    ret = QKeySequence(c.unicode() + Qt::ALT);
+#ifdef QT_NO_DEBUG
+                    return ret;
+#else
+                    found = true;
+                } else {
+                    qWarning(qPrintable(QString::fromLatin1("QKeySequence::mnemonic: \"%1\" contains multiple occurences of '&'").arg(text)));
+#endif
+                }
             }
         }
         p++;
     }
-    return QKeySequence();
+    return ret;
 }
 
 /*!
diff --git a/src/gui/kernel/qsoftkeymanager.cpp b/src/gui/kernel/qsoftkeymanager.cpp
index ecad72f..22ac319 100644
--- a/src/gui/kernel/qsoftkeymanager.cpp
+++ b/src/gui/kernel/qsoftkeymanager.cpp
@@ -213,11 +213,15 @@ void QSoftKeyManagerPrivate::updateSoftKeys_sys(const QList<QAction*> &softkeys)
     CEikButtonGroupContainer* nativeContainer = S60->buttonGroupContainer();
     nativeContainer->DrawableWindow()->SetOrdinalPosition(0);
     nativeContainer->DrawableWindow()->SetPointerCapturePriority(1); //keep softkeys available in modal dialog
-    QT_TRAP_THROWING(nativeContainer->SetCommandSetL(R_AVKON_SOFTKEYS_EMPTY_WITH_IDS));
+    nativeContainer->DrawableWindow()->SetFaded(EFalse, RWindowTreeNode::EFadeIncludeChildren);
 
     int position = -1;
-    int command;
     bool needsExitButton = true;
+    QT_TRAP_THROWING(
+        //Using -1 instead of EAknSoftkeyEmpty to avoid flickering.
+        nativeContainer->SetCommandL(0, -1, KNullDesC);
+        nativeContainer->SetCommandL(2, -1, KNullDesC);
+    );
 
     for (int index = 0; index < softkeys.count(); index++) {
         const QAction* softKeyAction = softkeys.at(index);
@@ -238,7 +242,7 @@ void QSoftKeyManagerPrivate::updateSoftKeys_sys(const QList<QAction*> &softkeys)
             break;
         }
 
-        command = (softKeyAction->objectName().contains("_q_menuSoftKeyAction"))
+        int command = (softKeyAction->objectName().contains("_q_menuSoftKeyAction"))
                     ? EAknSoftkeyOptions
                     : s60CommandStart + index;
 
@@ -255,7 +259,8 @@ void QSoftKeyManagerPrivate::updateSoftKeys_sys(const QList<QAction*> &softkeys)
         :   Qt::Widget;
 
     if (needsExitButton && sourceWindowType != Qt::Dialog && sourceWindowType != Qt::Popup)
-        QT_TRAP_THROWING(nativeContainer->SetCommandL(2, EAknSoftkeyExit, qt_QString2TPtrC(QSoftKeyManager::tr("Exit"))));
+        QT_TRAP_THROWING(
+            nativeContainer->SetCommandL(2, EAknSoftkeyExit, qt_QString2TPtrC(QSoftKeyManager::tr("Exit"))));
 
     nativeContainer->DrawDeferred(); // 3.1 needs an extra invitation
 }
diff --git a/src/gui/kernel/qt_s60_p.h b/src/gui/kernel/qt_s60_p.h
index 333458b..ec8c9cb 100644
--- a/src/gui/kernel/qt_s60_p.h
+++ b/src/gui/kernel/qt_s60_p.h
@@ -175,7 +175,7 @@ public:
 
 protected: // from MAknFadedComponent
     TInt CountFadedComponents() {return 1;}
-    CCoeControl* FadedComponent(TInt aIndex) {return this;}
+    CCoeControl* FadedComponent(TInt /*aIndex*/) {return this;}
 #else
     #warning No fallback implementation for QSymbianControl::FadeBehindPopup
     void FadeBehindPopup(bool /*fade*/){ }
@@ -202,9 +202,10 @@ private:
 
 private:
     QWidget *qwidget;
-    bool m_ignoreFocusChanged;
     QLongTapTimer* m_longTapDetector;
-    bool m_previousEventLongTap;
+    bool m_ignoreFocusChanged : 1;
+    bool m_previousEventLongTap : 1;
+    bool m_symbianPopupIsOpen : 1;
 
 #ifdef Q_WS_S60
     // Fader object used to fade everything except this menu and the CBA.
diff --git a/src/gui/kernel/qt_x11_p.h b/src/gui/kernel/qt_x11_p.h
index 9f08dc6..9e4cf60 100644
--- a/src/gui/kernel/qt_x11_p.h
+++ b/src/gui/kernel/qt_x11_p.h
@@ -163,7 +163,9 @@ extern "C" {
 #endif // QT_NO_XRENDER
 
 #ifndef QT_NO_XSYNC
+extern "C" {
 #  include "X11/extensions/sync.h"
+}
 #endif
 
 // #define QT_NO_XKB
diff --git a/src/gui/kernel/qwidget_s60.cpp b/src/gui/kernel/qwidget_s60.cpp
index 67bbd9f..629af8f 100644
--- a/src/gui/kernel/qwidget_s60.cpp
+++ b/src/gui/kernel/qwidget_s60.cpp
@@ -359,6 +359,7 @@ void QWidgetPrivate::create_sys(WId window, bool /* initializeWindow */, bool de
 
         QScopedPointer<QSymbianControl> control( q_check_ptr(new QSymbianControl(q)) );
         QT_TRAP_THROWING(control->ConstructL(true, desktop));
+        control->SetMopParent(static_cast<CEikAppUi*>(S60->appUi()));
 
         // Symbian windows are always created in an inactive state
         // We perform this assignment for the case where the window is being re-created
@@ -1235,7 +1236,7 @@ void QWidget::releaseKeyboard()
 
 void QWidget::grabMouse()
 {
-    if (!qt_nograb()) {
+    if (isVisible() && !qt_nograb()) {
         if (QWidgetPrivate::mouseGrabber && QWidgetPrivate::mouseGrabber != this)
             QWidgetPrivate::mouseGrabber->releaseMouse();
         Q_ASSERT(testAttribute(Qt::WA_WState_Created));
@@ -1252,7 +1253,7 @@ void QWidget::grabMouse()
 #ifndef QT_NO_CURSOR
 void QWidget::grabMouse(const QCursor &cursor)
 {
-    if (!qt_nograb()) {
+    if (isVisible() && !qt_nograb()) {
         if (QWidgetPrivate::mouseGrabber && QWidgetPrivate::mouseGrabber != this)
             QWidgetPrivate::mouseGrabber->releaseMouse();
         Q_ASSERT(testAttribute(Qt::WA_WState_Created));
diff --git a/src/gui/painting/painting.pri b/src/gui/painting/painting.pri
index c35c33a..628a109 100644
--- a/src/gui/painting/painting.pri
+++ b/src/gui/painting/painting.pri
@@ -370,7 +370,6 @@ symbian {
         SOURCES += painting/qwindowsurface_s60.cpp
         armccIfdefBlock = \
         "$${LITERAL_HASH}if defined(ARMV6)" \
-        "MACRO QT_HAVE_ARMV6" \
         "SOURCEPATH 	painting" \
         "SOURCE			qblendfunctions_armv6_rvct.s" \
         "SOURCE			qdrawhelper_armv6_rvct.s" \
diff --git a/src/gui/painting/qblendfunctions.cpp b/src/gui/painting/qblendfunctions.cpp
index 8737f10..ba1b642 100644
--- a/src/gui/painting/qblendfunctions.cpp
+++ b/src/gui/painting/qblendfunctions.cpp
@@ -223,21 +223,25 @@ void qt_scale_image_16bit(uchar *destPixels, int dbpl,
     int h = ty2 - ty1;
     int w = tx2 - tx1;
 
+
     quint32 basex;
     quint32 srcy;
 
+    const int dstx = qCeil((tx1 + 0.5 - qMin(targetRect.left(), targetRect.right())) * ix) - 1;
+    const int dsty = qCeil((ty1 + 0.5 - qMin(targetRect.top(), targetRect.bottom())) * iy) - 1;
+
     if (sx < 0) {
-        int dstx = qFloor((tx1 + 0.5 - targetRect.right()) * ix) + 1;
+        int dstx = qFloor((tx1 + qreal(0.5) - targetRect.right()) * ix) + 1;
         basex = quint32(srcRect.right() * 65536) + dstx;
     } else {
-        int dstx = qCeil((tx1 + 0.5 - targetRect.left()) * ix) - 1;
+        int dstx = qCeil((tx1 + qreal(0.5) - targetRect.left()) * ix) - 1;
         basex = quint32(srcRect.left() * 65536) + dstx;
     }
     if (sy < 0) {
-        int dsty = qFloor((ty1 + 0.5 - targetRect.bottom()) * iy) + 1;
+        int dsty = qFloor((ty1 + qreal(0.5) - targetRect.bottom()) * iy) + 1;
         srcy = quint32(srcRect.bottom() * 65536) + dsty;
     } else {
-        int dsty = qCeil((ty1 + 0.5 - targetRect.top()) * iy) - 1;
+        int dsty = qCeil((ty1 + qreal(0.5) - targetRect.top()) * iy) - 1;
         srcy = quint32(srcRect.top() * 65536) + dsty;
     }
 
@@ -738,18 +742,22 @@ template <typename T> void qt_scale_image_32bit(uchar *destPixels, int dbpl,
     quint32 basex;
     quint32 srcy;
 
+    const int dstx = qCeil((tx1 + 0.5 - qMin(targetRect.left(), targetRect.right())) * ix) - 1;
+    const int dsty = qCeil((ty1 + 0.5 - qMin(targetRect.top(), targetRect.bottom())) * iy) - 1;
+
+
     if (sx < 0) {
-        int dstx = qFloor((tx1 + 0.5 - targetRect.right()) * ix) + 1;
+        int dstx = qFloor((tx1 + qreal(0.5) - targetRect.right()) * ix) + 1;
         basex = quint32(srcRect.right() * 65536) + dstx;
     } else {
-        int dstx = qCeil((tx1 + 0.5 - targetRect.left()) * ix) - 1;
+        int dstx = qCeil((tx1 + qreal(0.5) - targetRect.left()) * ix) - 1;
         basex = quint32(srcRect.left() * 65536) + dstx;
     }
     if (sy < 0) {
-        int dsty = qFloor((ty1 + 0.5 - targetRect.bottom()) * iy) + 1;
+        int dsty = qFloor((ty1 + qreal(0.5) - targetRect.bottom()) * iy) + 1;
         srcy = quint32(srcRect.bottom() * 65536) + dsty;
     } else {
-        int dsty = qCeil((ty1 + 0.5 - targetRect.top()) * iy) - 1;
+        int dsty = qCeil((ty1 + qreal(0.5) - targetRect.top()) * iy) - 1;
         srcy = quint32(srcRect.top() * 65536) + dsty;
     }
 
diff --git a/src/gui/painting/qbrush.cpp b/src/gui/painting/qbrush.cpp
index afe9986..7273c35 100644
--- a/src/gui/painting/qbrush.cpp
+++ b/src/gui/painting/qbrush.cpp
@@ -970,7 +970,7 @@ bool QBrush::operator==(const QBrush &b) const
 QDebug operator<<(QDebug dbg, const QBrush &b)
 {
 #ifndef Q_BROKEN_DEBUG_STREAM
-    const char *BRUSH_STYLES[] = {
+    static const char *BRUSH_STYLES[] = {
      "NoBrush",
      "SolidPattern",
      "Dense1Pattern",
diff --git a/src/gui/styles/qplastiquestyle.cpp b/src/gui/styles/qplastiquestyle.cpp
index f880351..be4fff2 100644
--- a/src/gui/styles/qplastiquestyle.cpp
+++ b/src/gui/styles/qplastiquestyle.cpp
@@ -1094,8 +1094,6 @@ void QPlastiqueStyle::drawPrimitive(PrimitiveElement element, const QStyleOption
     QColor borderColor = option->palette.background().color().darker(178);
     QColor gradientStartColor = option->palette.button().color().lighter(104);
     QColor gradientStopColor = option->palette.button().color().darker(105);
-    QColor baseGradientStartColor = option->palette.base().color().darker(101);
-    QColor baseGradientStopColor = option->palette.base().color().darker(106);
     QColor highlightedGradientStartColor = option->palette.button().color().lighter(101);
     QColor highlightedGradientStopColor = mergedColors(option->palette.button().color(), option->palette.highlight().color(), 85);
     QColor highlightedBaseGradientStartColor = option->palette.base().color();
@@ -1978,7 +1976,13 @@ void QPlastiqueStyle::drawPrimitive(PrimitiveElement element, const QStyleOption
             QRect gradientRect(adjustedRect.left() + 1, adjustedRect.top() + 1,
                                adjustedRect.right() - adjustedRect.left() - 1,
                                adjustedRect.bottom() - adjustedRect.top() - 1);
-            qt_plastique_draw_gradient(painter, gradientRect, baseGradientStartColor, baseGradientStopColor);
+            if (option->palette.base().style() == Qt::SolidPattern) {
+                QColor baseGradientStartColor = option->palette.base().color().darker(101);
+                QColor baseGradientStopColor = option->palette.base().color().darker(106);
+                qt_plastique_draw_gradient(painter, gradientRect, baseGradientStartColor, baseGradientStopColor);
+            } else {
+                painter->fillRect(gradientRect, option->palette.base());
+            }
             // draw "+" or "-"
             painter->setPen(alphaTextColor);
             painter->drawLine(center.x() - 2, center.y(), center.x() + 2, center.y());
diff --git a/src/gui/styles/qs60style.cpp b/src/gui/styles/qs60style.cpp
index d33dc6a..df4b87e 100644
--- a/src/gui/styles/qs60style.cpp
+++ b/src/gui/styles/qs60style.cpp
@@ -473,7 +473,7 @@ void QS60StylePrivate::setBackgroundTexture(QApplication *app) const
     Q_UNUSED(app)
     QPalette applicationPalette = QApplication::palette();
     applicationPalette.setBrush(QPalette::Window, backgroundTexture());
-    setThemePalette(app);
+    setThemePalette(&applicationPalette);
 }
 
 void QS60StylePrivate::deleteBackground()
@@ -799,6 +799,9 @@ QSize QS60StylePrivate::partSize(QS60StyleEnums::SkinParts part, SkinElementFlag
         case QS60StyleEnums::SP_QgnGrafTabPassiveR:
         case QS60StyleEnums::SP_QgnGrafTabPassiveL:
         case QS60StyleEnums::SP_QgnGrafTabActiveL:
+            //Returned QSize for tabs must not be square, but narrow rectangle with width:height
+            //ratio of 1:2 for horizontal tab bars (and 2:1 for vertical ones).
+            result.setWidth(10);
             break;
         case QS60StyleEnums::SP_QgnIndiSliderEdit:
             result.scale(pixelMetric(QStyle::PM_SliderLength),
@@ -809,7 +812,7 @@ QSize QS60StylePrivate::partSize(QS60StyleEnums::SkinParts part, SkinElementFlag
         case QS60StyleEnums::SP_QgnGrafBarFrameSideR:
             result.setWidth(pixelMetric(PM_Custom_FrameCornerWidth));
             break;
-            
+
         case QS60StyleEnums::SP_QsnCpScrollHandleBottomPressed:
         case QS60StyleEnums::SP_QsnCpScrollHandleTopPressed:
         case QS60StyleEnums::SP_QsnCpScrollHandleMiddlePressed:
diff --git a/src/gui/styles/qstylesheetstyle.cpp b/src/gui/styles/qstylesheetstyle.cpp
index ce73fd8..59210c3 100644
--- a/src/gui/styles/qstylesheetstyle.cpp
+++ b/src/gui/styles/qstylesheetstyle.cpp
@@ -1180,7 +1180,7 @@ void QRenderRule::drawBackgroundImage(QPainter *p, const QRect &rect, QPoint off
 
     QRect r = originRect(rect, background()->origin);
     QRect aligned = QStyle::alignedRect(Qt::LeftToRight, background()->position, bgp.size(), r);
-    QRect inter = aligned.intersected(r);
+    QRect inter = aligned.translated(-off).intersected(r);
 
     switch (background()->repeat) {
     case Repeat_Y:
diff --git a/src/gui/text/qfont.cpp b/src/gui/text/qfont.cpp
index 447087c..f1cd6bb 100644
--- a/src/gui/text/qfont.cpp
+++ b/src/gui/text/qfont.cpp
@@ -1613,7 +1613,8 @@ bool QFont::operator==(const QFont &f) const
                 && f.d->underline == d->underline
                 && f.d->overline  == d->overline
                 && f.d->strikeOut == d->strikeOut
-                && f.d->kerning == d->kerning));
+                && f.d->kerning == d->kerning
+                && f.d->capital == d->capital));
 }
 
 
@@ -1645,6 +1646,7 @@ bool QFont::operator<(const QFont &f) const
 #ifdef Q_WS_X11
     if (r1.addStyle != r2.addStyle) return r1.addStyle < r2.addStyle;
 #endif // Q_WS_X11
+    if (f.d->capital != d->capital) return f.d->capital < d->capital;
 
     int f1attrs = (f.d->underline << 3) + (f.d->overline << 2) + (f.d->strikeOut<<1) + f.d->kerning;
     int f2attrs = (d->underline << 3) + (d->overline << 2) + (d->strikeOut<<1) + d->kerning;
diff --git a/src/gui/text/qtextformat.cpp b/src/gui/text/qtextformat.cpp
index d05d9e5..deda39f 100644
--- a/src/gui/text/qtextformat.cpp
+++ b/src/gui/text/qtextformat.cpp
@@ -265,21 +265,55 @@ private:
     friend QDataStream &operator>>(QDataStream &, QTextFormat &);
 };
 
-static uint variantHash(const QVariant &variant)
+// this is only safe if sizeof(int) == sizeof(float)
+static inline uint hash(float d)
 {
-    switch (variant.userType()) {
-    case QVariant::Invalid: return 0;
-    case QVariant::Bool: return variant.toBool();
-    case QVariant::Int: return variant.toInt();
-    case QMetaType::Float: return static_cast<int>(variant.toFloat());
-    case QVariant::Double: return static_cast<int>(variant.toDouble());
+    return reinterpret_cast<uint&>(d);
+}
+
+static inline uint hash(const QColor &color)
+{
+    return (color.isValid()) ? color.rgba() : 0x234109;
+}
+
+static inline uint hash(const QPen &pen)
+{
+    return hash(pen.color()) + hash(pen.widthF());
+}
+
+static inline uint hash(const QBrush &brush)
+{
+    return hash(brush.color()) + (brush.style() << 3);
+}
+
+static inline uint variantHash(const QVariant &variant)
+{
+    // simple and fast hash functions to differentiate between type and value
+    switch (variant.userType()) { // sorted by occurrence frequency
     case QVariant::String: return qHash(variant.toString());
-    case QVariant::Color: return qHash(qvariant_cast<QColor>(variant).rgb());
+    case QVariant::Double: return hash(variant.toDouble());
+    case QVariant::Int: return 0x811890 + variant.toInt();
+    case QVariant::Brush:
+        return 0x01010101 + hash(qvariant_cast<QBrush>(variant));
+    case QVariant::Bool: return 0x371818 + variant.toBool();
+    case QVariant::Pen: return 0x02020202 + hash(qvariant_cast<QPen>(variant));
+    case QVariant::List:
+        return 0x8377 + qvariant_cast<QVariantList>(variant).count();
+    case QVariant::Color: return hash(qvariant_cast<QColor>(variant));
+      case QVariant::TextLength:
+        return 0x377 + hash(qvariant_cast<QTextLength>(variant).rawValue());
+    case QMetaType::Float: return hash(variant.toFloat());
+    case QVariant::Invalid: return 0;
     default: break;
     }
     return qHash(variant.typeName());
 }
 
+static inline int getHash(const QTextFormatPrivate *d, int format)
+{
+    return (d ? d->hash() : 0) + format;
+}
+
 uint QTextFormatPrivate::recalcHash() const
 {
     hashValue = 0;
@@ -3033,13 +3067,15 @@ QTextFormatCollection::~QTextFormatCollection()
 
 int QTextFormatCollection::indexForFormat(const QTextFormat &format)
 {
-    uint hash = format.d ? format.d->hash() : 0;
-    if (hashes.contains(hash)) {
-        for (int i = 0; i < formats.size(); ++i) {
-            if (formats.at(i) == format)
-                return i;
+    uint hash = getHash(format.d, format.format_type);
+    QMultiHash<uint, int>::const_iterator i = hashes.find(hash);
+    while (i != hashes.end() && i.key() == hash) {
+        if (formats.value(i.value()) == format) {
+            return i.value();
         }
+        ++i;
     }
+
     int idx = formats.size();
     formats.append(format);
 
@@ -3049,7 +3085,7 @@ int QTextFormatCollection::indexForFormat(const QTextFormat &format)
             f.d = new QTextFormatPrivate;
         f.d->resolveFont(defaultFnt);
 
-        hashes.insert(hash);
+        hashes.insert(hash, idx);
 
     } QT_CATCH(...) {
         formats.pop_back();
@@ -3060,11 +3096,13 @@ int QTextFormatCollection::indexForFormat(const QTextFormat &format)
 
 bool QTextFormatCollection::hasFormatCached(const QTextFormat &format) const
 {
-    uint hash = format.d ? format.d->hash() : 0;
-    if (hashes.contains(hash)) {
-        for (int i = 0; i < formats.size(); ++i)
-            if (formats.at(i) == format)
-                return true;
+    uint hash = getHash(format.d, format.format_type);
+    QMultiHash<uint, int>::const_iterator i = hashes.find(hash);
+    while (i != hashes.end() && i.key() == hash) {
+        if (formats.value(i.value()) == format) {
+            return true;
+        }
+        ++i;
     }
     return false;
 }
diff --git a/src/gui/text/qtextformat_p.h b/src/gui/text/qtextformat_p.h
index c796343..73ca0ce 100644
--- a/src/gui/text/qtextformat_p.h
+++ b/src/gui/text/qtextformat_p.h
@@ -55,7 +55,7 @@
 
 #include "QtGui/qtextformat.h"
 #include "QtCore/qvector.h"
-#include "QtCore/qset.h"
+#include "QtCore/qhash.h"
 
 QT_BEGIN_NAMESPACE
 
@@ -97,7 +97,7 @@ public:
 
     FormatVector formats;
     QVector<qint32> objFormats;
-    QSet<uint> hashes;
+    QMultiHash<uint,int> hashes;
 
     inline QFont defaultFont() const { return defaultFnt; }
     void setDefaultFont(const QFont &f);
diff --git a/src/gui/widgets/qabstractscrollarea.cpp b/src/gui/widgets/qabstractscrollarea.cpp
index b0d0baf..35639b7 100644
--- a/src/gui/widgets/qabstractscrollarea.cpp
+++ b/src/gui/widgets/qabstractscrollarea.cpp
@@ -1130,10 +1130,13 @@ void QAbstractScrollArea::mouseMoveEvent(QMouseEvent *e)
 void QAbstractScrollArea::wheelEvent(QWheelEvent *e)
 {
     Q_D(QAbstractScrollArea);
-    if (static_cast<QWheelEvent*>(e)->orientation() == Qt::Horizontal)
-        QApplication::sendEvent(d->hbar, e);
-    else
-        QApplication::sendEvent(d->vbar, e);
+    QScrollBar *const bars[2] = { d->hbar, d->vbar };
+    int idx = (e->orientation() == Qt::Vertical) ? 1 : 0;
+    int other = (idx + 1) % 2;
+    if (!bars[idx]->isVisible() && bars[other]->isVisible())
+        idx = other;   // If the scrollbar of the event orientation is hidden, fallback to the other.
+
+    QApplication::sendEvent(bars[idx], e);
 }
 #endif
 
diff --git a/src/gui/widgets/qabstractslider.cpp b/src/gui/widgets/qabstractslider.cpp
index fec9fab..e0db9c2 100644
--- a/src/gui/widgets/qabstractslider.cpp
+++ b/src/gui/widgets/qabstractslider.cpp
@@ -690,8 +690,6 @@ void QAbstractSlider::wheelEvent(QWheelEvent * e)
 {
     Q_D(QAbstractSlider);
     e->ignore();
-    if (e->orientation() != d->orientation && !rect().contains(e->pos()))
-        return;
 
     int stepsToScroll = 0;
     qreal offset = qreal(e->delta()) / 120;
diff --git a/src/gui/widgets/qcalendarwidget.cpp b/src/gui/widgets/qcalendarwidget.cpp
index 08ed7f6..ee536ee 100644
--- a/src/gui/widgets/qcalendarwidget.cpp
+++ b/src/gui/widgets/qcalendarwidget.cpp
@@ -2297,7 +2297,21 @@ int QCalendarWidget::monthShown() const
 void QCalendarWidget::setCurrentPage(int year, int month)
 {
     Q_D(QCalendarWidget);
+    QDate currentDate = d->getCurrentDate();
+    int day = currentDate.day();
+    int daysInMonths = QDate(year, month, 1).daysInMonth();
+    if (day > daysInMonths)
+        day = daysInMonths;
+
     d->showMonth(year, month);
+
+    QDate newDate(year, month, day);
+    int row = -1, col = -1;
+    d->m_model->cellForDate(newDate, &row, &col);
+    if (row != -1 && col != -1) {
+        d->m_view->selectionModel()->setCurrentIndex(d->m_model->index(row, col),
+                                                  QItemSelectionModel::NoUpdate);
+    }
 }
 
 /*!
diff --git a/src/gui/widgets/qdialogbuttonbox.cpp b/src/gui/widgets/qdialogbuttonbox.cpp
index 2231b98..2ee5751 100644
--- a/src/gui/widgets/qdialogbuttonbox.cpp
+++ b/src/gui/widgets/qdialogbuttonbox.cpp
@@ -315,9 +315,9 @@ void QDialogButtonBoxPrivate::initLayout()
             buttonLayout = new QVBoxLayout(q);
     }
 
-	int left, top, right, bottom;
+    int left, top, right, bottom;
     setLayoutItemMargins(QStyle::SE_PushButtonLayoutItem);
-	getLayoutItemMargins(&left, &top, &right, &bottom);
+    getLayoutItemMargins(&left, &top, &right, &bottom);
     buttonLayout->setContentsMargins(-left, -top, -right, -bottom);
 
     if (!q->testAttribute(Qt::WA_WState_OwnSizePolicy)) {
@@ -356,7 +356,7 @@ void QDialogButtonBoxPrivate::addButtonsToLayout(const QList<QAbstractButton *>
 void QDialogButtonBoxPrivate::layoutButtons()
 {
     Q_Q(QDialogButtonBox);
-    const int MacGap = 36 - 8;	// 8 is the default gap between a widget and a spacer item
+    const int MacGap = 36 - 8;    // 8 is the default gap between a widget and a spacer item
 
     for (int i = buttonLayout->count() - 1; i >= 0; --i) {
         QLayoutItem *item = buttonLayout->takeAt(i);
@@ -581,6 +581,22 @@ QAction* QDialogButtonBoxPrivate::createSoftKey(QAbstractButton *button, QDialog
     }
     QObject::connect(action, SIGNAL(triggered()), button, SIGNAL(clicked()));
     action->setSoftKeyRole(softkeyRole);
+
+
+    QWidget *dialog = 0;
+    QWidget *p = q;
+    while (p && !p->isWindow()) {
+        p = p->parentWidget();
+        if ((dialog = qobject_cast<QDialog *>(p)))
+            break;
+    }
+
+    if (dialog) {
+        dialog->addAction(action);
+    } else {
+        q->addAction(action);
+    }
+
     return action;
 }
 #endif
@@ -1193,12 +1209,8 @@ bool QDialogButtonBox::event(QEvent *event)
         if (!hasDefault && firstAcceptButton)
             firstAcceptButton->setDefault(true);
 #ifdef QT_SOFTKEYS_ENABLED
-        if (dialog) {
+        if (dialog)
             setFixedSize(0,0);
-            dialog->addActions(d->softKeyActions.values());
-        } else {
-            addActions(d->softKeyActions.values());
-        }
 #endif
     }else if (event->type() == QEvent::LanguageChange) {
         d->retranslateStrings();
diff --git a/src/gui/widgets/qdockarealayout.cpp b/src/gui/widgets/qdockarealayout.cpp
index dffec11..953edab 100644
--- a/src/gui/widgets/qdockarealayout.cpp
+++ b/src/gui/widgets/qdockarealayout.cpp
@@ -1841,7 +1841,6 @@ void QDockAreaLayoutInfo::saveState(QDataStream &stream) const
     }
 }
 
-#ifdef Q_WS_MAC
 static Qt::DockWidgetArea toDockWidgetArea(QInternal::DockPosition pos)
 {
     switch (pos) {
@@ -1853,7 +1852,6 @@ static Qt::DockWidgetArea toDockWidgetArea(QInternal::DockPosition pos)
     }
     return Qt::NoDockWidgetArea;
 }
-#endif
 
 static QRect constrainedRect(QRect rect, const QRect &desktop)
 {
@@ -1933,6 +1931,9 @@ bool QDockAreaLayoutInfo::restoreState(QDataStream &stream, QList<QDockWidget*>
                     item_list.append(item);
             } else {
                 QDockAreaLayoutItem item(new QDockWidgetItem(widget));
+                if (!testing) {
+                    item_list.append(item);
+                }
                 if (flags & StateFlagFloating) {
                	    bool drawer = false;
 #ifdef Q_WS_MAC // drawer support
@@ -1977,12 +1978,10 @@ bool QDockAreaLayoutInfo::restoreState(QDataStream &stream, QList<QDockWidget*>
                     if (!testing) {
                         widget->setFloating(false);
                         widget->setVisible(flags & StateFlagVisible);
+                        emit widget->dockLocationChanged(toDockWidgetArea(dockPos));
                     }
                 }
 
-                if (!testing) {
-                    item_list.append(item);
-                }
             }
         } else if (nextMarker == SequenceMarker) {
             int dummy;
diff --git a/src/gui/widgets/qdockwidget.cpp b/src/gui/widgets/qdockwidget.cpp
index a8e2a37..9cf6af1 100644
--- a/src/gui/widgets/qdockwidget.cpp
+++ b/src/gui/widgets/qdockwidget.cpp
@@ -1225,6 +1225,7 @@ void QDockWidget::setFeatures(QDockWidget::DockWidgetFeatures features)
     features &= DockWidgetFeatureMask;
     if (d->features == features)
         return;
+    const bool closableChanged = (d->features ^ features) & DockWidgetClosable;
     d->features = features;
     QDockWidgetLayout *layout
         = qobject_cast<QDockWidgetLayout*>(this->layout());
@@ -1233,6 +1234,10 @@ void QDockWidget::setFeatures(QDockWidget::DockWidgetFeatures features)
     d->toggleViewAction->setEnabled((d->features & DockWidgetClosable) == DockWidgetClosable);
     emit featuresChanged(d->features);
     update();
+    if (closableChanged && layout->nativeWindowDeco()) {
+        //this ensures the native decoration is drawn
+        d->setWindowState(true /*floating*/, true /*unplug*/);
+    }
 }
 
 QDockWidget::DockWidgetFeatures QDockWidget::features() const
diff --git a/src/gui/widgets/qfontcombobox.cpp b/src/gui/widgets/qfontcombobox.cpp
index 806db59..d601f81 100644
--- a/src/gui/widgets/qfontcombobox.cpp
+++ b/src/gui/widgets/qfontcombobox.cpp
@@ -247,7 +247,14 @@ void QFontComboBoxPrivate::_q_updateModel()
     }
     list = result;
 
+    //we need to block the signals so that the model doesn't emit reset
+    //this prevents the current index from changing
+    //it will be updated just after this
+    ///TODO: we should finda way to avoid blocking signals and have a real update of the model
+    const bool old = m->blockSignals(true);
     m->setStringList(list);
+    m->blockSignals(old);
+
     if (list.isEmpty()) {
         if (currentFont != QFont()) {
             currentFont = QFont();
@@ -420,8 +427,10 @@ void QFontComboBox::setCurrentFont(const QFont &font)
     Q_D(QFontComboBox);
     if (font != d->currentFont) {
         d->currentFont = font;
-        emit currentFontChanged(d->currentFont);
         d->_q_updateModel();
+        if (d->currentFont == font) { //else the signal has already be emitted by _q_updateModel
+            emit currentFontChanged(d->currentFont);
+        }
     }
 }
 
diff --git a/src/gui/widgets/qlabel.cpp b/src/gui/widgets/qlabel.cpp
index 3d908a1..ea711e8 100644
--- a/src/gui/widgets/qlabel.cpp
+++ b/src/gui/widgets/qlabel.cpp
@@ -1170,22 +1170,10 @@ void QLabelPrivate::updateShortcut()
     // But then we do want to hide the ampersands, so we can't use shortcutId.
     hasShortcut = false;
 
-    if (control) {
-        ensureTextPopulated();
-        // Underline the first character that follows an ampersand
-        shortcutCursor = control->document()->find(QLatin1String("&"));
-        if (shortcutCursor.isNull())
-            return;
-        hasShortcut = true;
-        shortcutId = q->grabShortcut(QKeySequence::mnemonic(text));
-        shortcutCursor.deleteChar(); // remove the ampersand
-        shortcutCursor.movePosition(QTextCursor::NextCharacter, QTextCursor::KeepAnchor);
-    } else {
-        if (!text.contains(QLatin1Char('&')))
-            return;
-        hasShortcut = true;
-        shortcutId = q->grabShortcut(QKeySequence::mnemonic(text));
-    }
+    if (!text.contains(QLatin1Char('&')))
+        return;
+    hasShortcut = true;
+    shortcutId = q->grabShortcut(QKeySequence::mnemonic(text));
 }
 
 #endif // QT_NO_SHORTCUT
@@ -1456,6 +1444,24 @@ void QLabelPrivate::ensureTextPopulated() const
             doc->setPlainText(text);
 #endif
             doc->setUndoRedoEnabled(false);
+
+#ifndef QT_NO_SHORTCUT
+            if (hasShortcut) {
+                // Underline the first character that follows an ampersand (and remove the others ampersands)
+                int from = 0;
+                bool found = false;
+                QTextCursor cursor;
+                while (!(cursor = control->document()->find((QLatin1String("&")), from)).isNull()) {
+                    cursor.deleteChar(); // remove the ampersand
+                    cursor.movePosition(QTextCursor::NextCharacter, QTextCursor::KeepAnchor);
+                    from = cursor.position();
+                    if (!found && cursor.selectedText() != QLatin1String("&")) { //not a second &
+                        found = true;
+                        shortcutCursor = cursor;
+                    }
+                }
+            }
+#endif
         }
     }
     textDirty = false;
diff --git a/src/gui/widgets/qlabel_p.h b/src/gui/widgets/qlabel_p.h
index c5a74e2..ca17a35 100644
--- a/src/gui/widgets/qlabel_p.h
+++ b/src/gui/widgets/qlabel_p.h
@@ -113,7 +113,7 @@ public:
     mutable uint hasShortcut : 1;
     Qt::TextFormat textformat;
     mutable QTextControl *control;
-    QTextCursor shortcutCursor;
+    mutable QTextCursor shortcutCursor;
     Qt::TextInteractionFlags textInteractionFlags;
 
     inline bool needTextControl() const {
diff --git a/src/gui/widgets/qlinecontrol.cpp b/src/gui/widgets/qlinecontrol.cpp
index 2914164..300a2ea 100644
--- a/src/gui/widgets/qlinecontrol.cpp
+++ b/src/gui/widgets/qlinecontrol.cpp
@@ -414,7 +414,7 @@ void QLineControl::processInputMethodEvent(QInputMethodEvent *event)
 
 
     int c = m_cursor; // cursor position after insertion of commit string
-    if (event->replacementStart() <= 0)
+    if (event->replacementStart() == 0)
         c += event->commitString().length() + qMin(-event->replacementStart(), event->replacementLength());
 
     m_cursor += event->replacementStart();
diff --git a/src/gui/widgets/qmainwindowlayout.cpp b/src/gui/widgets/qmainwindowlayout.cpp
index 027a5d6..fa6f7a1 100644
--- a/src/gui/widgets/qmainwindowlayout.cpp
+++ b/src/gui/widgets/qmainwindowlayout.cpp
@@ -1641,6 +1641,9 @@ void QMainWindowLayout::animationFinished(QWidget *widget)
         savedState.clear();
         currentGapPos.clear();
         pluggingWidget = 0;
+        //applying the state will make sure that the currentGap is updated correctly
+        //and all the geometries (especially the one from the central widget) is correct
+        layoutState.apply(false);
     }
 
     if (!widgetAnimator.animating()) {
diff --git a/src/gui/widgets/qmenu.cpp b/src/gui/widgets/qmenu.cpp
index cc39b7f..54d1612 100644
--- a/src/gui/widgets/qmenu.cpp
+++ b/src/gui/widgets/qmenu.cpp
@@ -602,14 +602,7 @@ void QMenuPrivate::setCurrentAction(QAction *action, int popup, SelectionReason
         }
 #ifndef QT_NO_STATUSTIP
     }  else if (previousAction) {
-        QWidget *w = causedPopup.widget;
-        while (QMenu *m = qobject_cast<QMenu*>(w))
-            w = m->d_func()->causedPopup.widget;
-        if (w) {
-            QString empty;
-            QStatusTipEvent tip(empty);
-            QApplication::sendEvent(w, &tip);
-        }
+        previousAction->d_func()->showStatusText(topCausedWidget(), QString());
 #endif
     }
     if (hideActiveMenu) {
@@ -623,6 +616,15 @@ void QMenuPrivate::setCurrentAction(QAction *action, int popup, SelectionReason
     }
 }
 
+//return the top causedPopup.widget that is not a QMenu
+QWidget *QMenuPrivate::topCausedWidget() const
+{
+    QWidget* top = causedPopup.widget;
+    while (QMenu* m = qobject_cast<QMenu *>(top))
+        top = m->d_func()->causedPopup.widget;
+    return top;
+}
+
 QAction *QMenuPrivate::actionAt(QPoint p) const
 {
     if (!q_func()->rect().contains(p))     //sanity check
@@ -1094,10 +1096,7 @@ void QMenuPrivate::activateAction(QAction *action, QAction::ActionEvent action_e
             QAccessible::updateAccessibility(q, actionIndex, QAccessible::Selection);
         }
 #endif
-        QWidget *w = causedPopup.widget;
-        while (QMenu *m = qobject_cast<QMenu*>(w))
-            w = m->d_func()->causedPopup.widget;
-        action->showStatusText(w);
+        action->showStatusText(topCausedWidget());
     } else {
         actionAboutToTrigger = 0;
     }
@@ -1801,10 +1800,7 @@ void QMenu::popup(const QPoint &p, QAction *atAction)
 #ifndef QT_NO_MENUBAR
     // if this menu is part of a chain attached to a QMenuBar, set the
     // _NET_WM_WINDOW_TYPE_DROPDOWN_MENU X11 window type
-    QWidget* top = this;
-    while (QMenu* m = qobject_cast<QMenu *>(top))
-        top = m->d_func()->causedPopup.widget;
-    setAttribute(Qt::WA_X11NetWmWindowTypeDropDownMenu, qobject_cast<QMenuBar *>(top) != 0);
+    setAttribute(Qt::WA_X11NetWmWindowTypeDropDownMenu, qobject_cast<QMenuBar *>(d->topCausedWidget()) != 0);
 #endif
 
     ensurePolished(); // Get the right font
@@ -2752,18 +2748,14 @@ void QMenu::keyPressEvent(QKeyEvent *e)
             }
         }
         if (!key_consumed) {
-            if (QWidget *caused = d->causedPopup.widget) {
-                while(QMenu *m = qobject_cast<QMenu*>(caused))
-                    caused = m->d_func()->causedPopup.widget;
 #ifndef QT_NO_MENUBAR
-                if (QMenuBar *mb = qobject_cast<QMenuBar*>(caused)) {
-                    QAction *oldAct = mb->d_func()->currentAction;
-                    QApplication::sendEvent(mb, e);
-                    if (mb->d_func()->currentAction != oldAct)
-                        key_consumed = true;
-                }
-#endif
+            if (QMenuBar *mb = qobject_cast<QMenuBar*>(d->topCausedWidget())) {
+                QAction *oldAct = mb->d_func()->currentAction;
+                QApplication::sendEvent(mb, e);
+                if (mb->d_func()->currentAction != oldAct)
+                    key_consumed = true;
             }
+#endif
         }
 
 #ifdef Q_OS_WIN32
diff --git a/src/gui/widgets/qmenu_p.h b/src/gui/widgets/qmenu_p.h
index a5bde7c..c021063 100644
--- a/src/gui/widgets/qmenu_p.h
+++ b/src/gui/widgets/qmenu_p.h
@@ -215,6 +215,7 @@ public:
         SelectedFromKeyboard,
         SelectedFromElsewhere
     };
+    QWidget *topCausedWidget() const;
     QAction *actionAt(QPoint p) const;
     void setFirstActionActive();
     void setCurrentAction(QAction *, int popup = -1, SelectionReason reason = SelectedFromElsewhere, bool activateFirst = false);
diff --git a/src/gui/widgets/qmenubar.cpp b/src/gui/widgets/qmenubar.cpp
index 689d2e1..b1ff662 100644
--- a/src/gui/widgets/qmenubar.cpp
+++ b/src/gui/widgets/qmenubar.cpp
@@ -332,7 +332,9 @@ void QMenuBarPrivate::popupAction(QAction *action, bool activateFirst)
         QPoint pos(q->mapToGlobal(QPoint(adjustedActionRect.left(), adjustedActionRect.bottom() + 1)));
         QSize popup_size = activeMenu->sizeHint();
 
-        QRect screenRect = QApplication::desktop()->screenGeometry(pos);
+        //we put the popup menu on the screen containing the bottom-center of the action rect
+        QRect screenRect = QApplication::desktop()->screenGeometry(pos + QPoint(adjustedActionRect.width() / 2, 0));
+        pos = QPoint(qMax(pos.x(), screenRect.x()), qMax(pos.y(), screenRect.y()));
 
         const bool fitUp = (q->mapToGlobal(adjustedActionRect.topLeft()).y() >= popup_size.height());
         const bool fitDown = (pos.y() + popup_size.height() <= screenRect.bottom());
diff --git a/src/gui/widgets/qtoolbar.cpp b/src/gui/widgets/qtoolbar.cpp
index 5596ca4..58a3d28 100644
--- a/src/gui/widgets/qtoolbar.cpp
+++ b/src/gui/widgets/qtoolbar.cpp
@@ -396,7 +396,7 @@ bool QToolBarPrivate::mouseMoveEvent(QMouseEvent *event)
 void QToolBarPrivate::unplug(const QRect &_r)
 {
     Q_Q(QToolBar);
-    layout->setExpanded(false, false);
+    layout->setExpanded(false);
     QRect r = _r;
     r.moveTopLeft(q->mapToGlobal(QPoint(0, 0)));
     setWindowState(true, true, r);
diff --git a/src/gui/widgets/qtoolbararealayout.cpp b/src/gui/widgets/qtoolbararealayout.cpp
index de11625..b7e985c 100644
--- a/src/gui/widgets/qtoolbararealayout.cpp
+++ b/src/gui/widgets/qtoolbararealayout.cpp
@@ -480,7 +480,7 @@ void QToolBarAreaLayoutInfo::moveToolBar(QToolBar *toolbar, int pos)
 }
 
 
-QList<int> QToolBarAreaLayoutInfo::gapIndex(const QPoint &pos) const
+QList<int> QToolBarAreaLayoutInfo::gapIndex(const QPoint &pos, int *minDistance) const
 {
     int p = pick(o, pos);
 
@@ -509,12 +509,19 @@ QList<int> QToolBarAreaLayoutInfo::gapIndex(const QPoint &pos) const
 
             QList<int> result;
             result << j << k;
+            *minDistance = 0; //we found a perfect match
+            return result;
+        }
+    } else {
+        const int dist = distance(pos);
+        //it will only return a path if the minDistance is higher than the current distance
+        if (dist >= 0 && *minDistance > dist) {
+            *minDistance = dist;
+
+            QList<int> result;
+            result << lines.count() << 0;
             return result;
         }
-    } else if (appendLineDropRect().contains(pos)) {
-        QList<int> result;
-        result << lines.count() << 0;
-        return result;
     }
 
     return QList<int>();
@@ -587,32 +594,20 @@ QRect QToolBarAreaLayoutInfo::itemRect(const QList<int> &path) const
     return result;
 }
 
-QRect QToolBarAreaLayoutInfo::appendLineDropRect() const
+int QToolBarAreaLayoutInfo::distance(const QPoint &pos) const
 {
-    QRect result;
-
     switch (dockPos) {
         case QInternal::LeftDock:
-            result = QRect(rect.right(), rect.top(),
-                            EmptyDockAreaSize, rect.height());
-            break;
+            return pos.x() - rect.right();
         case QInternal::RightDock:
-            result = QRect(rect.left() - EmptyDockAreaSize, rect.top(),
-                            EmptyDockAreaSize, rect.height());
-            break;
+            return rect.left() - pos.x();
         case QInternal::TopDock:
-            result = QRect(rect.left(), rect.bottom() + 1,
-                            rect.width(), EmptyDockAreaSize);
-            break;
+            return pos.y() - rect.bottom();
         case QInternal::BottomDock:
-            result = QRect(rect.left(), rect.top() - EmptyDockAreaSize,
-                            rect.width(), EmptyDockAreaSize);
-            break;
+            return rect.top() - pos.y();
         default:
-            break;
+            return -1;
     }
-
-    return result;
 }
 
 /******************************************************************************
@@ -1022,21 +1017,24 @@ QList<int> QToolBarAreaLayout::indexOf(QWidget *toolBar) const
     return result;
 }
 
+//this functions returns the path to the possible gapindex for the position pos
 QList<int> QToolBarAreaLayout::gapIndex(const QPoint &pos) const
 {
     Qt::LayoutDirection dir = mainWindow->layoutDirection();
+    int minDistance = 80; // when a dock area is empty, how "wide" is it?
+    QList<int> ret; //return value
     for (int i = 0; i < QInternal::DockCount; ++i) {
         QPoint p = pos;
         if (docks[i].o == Qt::Horizontal)
             p = QStyle::visualPos(dir, docks[i].rect, p);
-        QList<int> result = docks[i].gapIndex(p);
+        QList<int> result = docks[i].gapIndex(p, &minDistance);
         if (!result.isEmpty()) {
             result.prepend(i);
-            return result;
+            ret = result;
         }
     }
 
-    return QList<int>();
+    return ret;
 }
 
 QList<int> QToolBarAreaLayout::currentGapIndex() const
diff --git a/src/gui/widgets/qtoolbararealayout_p.h b/src/gui/widgets/qtoolbararealayout_p.h
index 1e113b7..f0ab80c 100644
--- a/src/gui/widgets/qtoolbararealayout_p.h
+++ b/src/gui/widgets/qtoolbararealayout_p.h
@@ -155,8 +155,6 @@ public:
 class QToolBarAreaLayoutInfo
 {
 public:
-    enum { EmptyDockAreaSize = 80 }; // when a dock area is empty, how "wide" is it?
-
     QToolBarAreaLayoutInfo(QInternal::DockPosition pos = QInternal::TopDock);
 
     QList<QToolBarAreaLayoutLine> lines;
@@ -173,11 +171,11 @@ public:
     void removeToolBarBreak(QToolBar *before);
     void moveToolBar(QToolBar *toolbar, int pos); 
 
-    QList<int> gapIndex(const QPoint &pos) const;
+    QList<int> gapIndex(const QPoint &pos, int *maxDistance) const;
     bool insertGap(const QList<int> &path, QLayoutItem *item);
     void clear();
     QRect itemRect(const QList<int> &path) const;
-    QRect appendLineDropRect() const;
+    int distance(const QPoint &pos) const;
 
     QRect rect;
     Qt::Orientation o;
diff --git a/src/gui/widgets/qtoolbarlayout.cpp b/src/gui/widgets/qtoolbarlayout.cpp
index 7dc1e01..0afe5d8 100644
--- a/src/gui/widgets/qtoolbarlayout.cpp
+++ b/src/gui/widgets/qtoolbarlayout.cpp
@@ -642,7 +642,7 @@ QSize QToolBarLayout::expandedSize(const QSize &size) const
     return result;
 }
 
-void QToolBarLayout::setExpanded(bool exp, bool animated)
+void QToolBarLayout::setExpanded(bool exp)
 {
     if (exp == expanded)
         return;
@@ -654,7 +654,6 @@ void QToolBarLayout::setExpanded(bool exp, bool animated)
     if (!tb)
         return;
     if (QMainWindow *win = qobject_cast<QMainWindow*>(tb->parentWidget())) {
-        animating = true;
         QMainWindowLayout *layout = qobject_cast<QMainWindowLayout*>(win->layout());
         if (expanded) {
             tb->raise();
@@ -665,7 +664,7 @@ void QToolBarLayout::setExpanded(bool exp, bool animated)
                 layoutActions(rect.size());
             }
         }
-        layout->layoutState.toolBarAreaLayout.apply(animated);
+        layout->layoutState.toolBarAreaLayout.apply(win->isAnimated());
     }
 }
 
diff --git a/src/gui/widgets/qtoolbarlayout_p.h b/src/gui/widgets/qtoolbarlayout_p.h
index d49a5df..afd0227 100644
--- a/src/gui/widgets/qtoolbarlayout_p.h
+++ b/src/gui/widgets/qtoolbarlayout_p.h
@@ -112,7 +112,7 @@ public:
     bool hasExpandFlag() const;
 
 public Q_SLOTS:
-    void setExpanded(bool b, bool animated = true);
+    void setExpanded(bool b);
 
 private:
     QList<QToolBarItem*> items;