Merge remote-tracking branch 'qt/4.8'

206 files changed, 4332 insertions, 2539 deletions

diff --git a/src/3rdparty/harfbuzz/src/harfbuzz-shaper.cpp b/src/3rdparty/harfbuzz/src/harfbuzz-shaper.cpp
index c202e1f..3410782 100644
--- a/src/3rdparty/harfbuzz/src/harfbuzz-shaper.cpp
+++ b/src/3rdparty/harfbuzz/src/harfbuzz-shaper.cpp
@@ -655,6 +655,7 @@ void HB_GetCharAttributes(const HB_UChar16 *string, hb_uint32 stringLength,
                           const HB_ScriptItem *items, hb_uint32 numItems,
                           HB_CharAttributes *attributes)
 {
+    memset(attributes, 0, stringLength * sizeof(HB_CharAttributes));
     calcLineBreaks(string, stringLength, attributes);
 
     for (hb_uint32 i = 0; i < numItems; ++i) {
diff --git a/src/3rdparty/phonon/phonon/audiooutputadaptor.cpp b/src/3rdparty/phonon/phonon/audiooutputadaptor.cpp
index 2c01773..959172d 100644
--- a/src/3rdparty/phonon/phonon/audiooutputadaptor.cpp
+++ b/src/3rdparty/phonon/phonon/audiooutputadaptor.cpp
@@ -1,3 +1,28 @@
+/*  This file is part of the KDE project
+    The following license applies to the edits made to the generated
+    source code:
+
+    Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+    Copyright (C) 2009 Matthias Kretz.
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) version 3, or any
+    later version accepted by the membership of KDE e.V. (or its
+    successor approved by the membership of KDE e.V.), Nokia Corporation 
+    (or its successors, if any) and the KDE Free Qt Foundation, which shall
+    act as a proxy defined in Section 6 of version 3 of the license.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public 
+    License along with this library.  If not, see <http://www.gnu.org/licenses/>.
+
+*/
 /*
  * This file was generated by dbusidl2cpp version 0.4
  * when processing input file org.kde.Phonon.AudioOutput.xml
diff --git a/src/3rdparty/phonon/phonon/audiooutputadaptor_p.h b/src/3rdparty/phonon/phonon/audiooutputadaptor_p.h
index 7178e9b..140a74f 100644
--- a/src/3rdparty/phonon/phonon/audiooutputadaptor_p.h
+++ b/src/3rdparty/phonon/phonon/audiooutputadaptor_p.h
@@ -1,3 +1,28 @@
+/*  This file is part of the KDE project
+    The following license applies to the edits made to the generated
+    source code:
+
+    Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+    Copyright (C) 2009 Matthias Kretz.
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) version 3, or any
+    later version accepted by the membership of KDE e.V. (or its
+    successor approved by the membership of KDE e.V.), Nokia Corporation 
+    (or its successors, if any) and the KDE Free Qt Foundation, which shall
+    act as a proxy defined in Section 6 of version 3 of the license.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public 
+    License along with this library.  If not, see <http://www.gnu.org/licenses/>.
+
+*/
 /*
  * This file was generated by dbusidl2cpp version 0.4
  * when processing input file org.kde.Phonon.AudioOutput.xml
diff --git a/src/activeqt/shared/qaxtypes.cpp b/src/activeqt/shared/qaxtypes.cpp
index c48b55b..8835caf 100644
--- a/src/activeqt/shared/qaxtypes.cpp
+++ b/src/activeqt/shared/qaxtypes.cpp
@@ -265,7 +265,7 @@ bool QVariantToVARIANT(const QVariant &var, VARIANT &arg, const QByteArray &type
         return QVariantToVARIANT(var, *arg.pvarVal, typeName, false);
     }
 
-    if (out && proptype == QVariant::Invalid && typeName == "QVariant") {
+    if (out && proptype == QVariant::UserType && typeName == "QVariant") {
         VARIANT *pVariant = new VARIANT;
         QVariantToVARIANT(var, *pVariant, QByteArray(), false);
         arg.vt = VT_VARIANT|VT_BYREF;
diff --git a/src/corelib/animation/qabstractanimation.cpp b/src/corelib/animation/qabstractanimation.cpp
index 602cf8a..0a1f5d7 100644
--- a/src/corelib/animation/qabstractanimation.cpp
+++ b/src/corelib/animation/qabstractanimation.cpp
@@ -260,7 +260,8 @@ void QUnifiedTimer::restartAnimationTimer()
     } else if (!driver->isRunning() || isPauseTimerActive) {
         driver->start();
         isPauseTimerActive = false;
-    }
+    } else if (runningLeafAnimations == 0)
+        driver->stop();
 }
 
 void QUnifiedTimer::setTimingInterval(int interval)
diff --git a/src/corelib/animation/qabstractanimation_p.h b/src/corelib/animation/qabstractanimation_p.h
index ba92960..0ccc502 100644
--- a/src/corelib/animation/qabstractanimation_p.h
+++ b/src/corelib/animation/qabstractanimation_p.h
@@ -184,6 +184,9 @@ public:
     void restartAnimationTimer();
     void updateAnimationsTime();
 
+    //useful for profiling/debugging
+    int runningAnimationCount() { return animations.count(); }
+
 protected:
     void timerEvent(QTimerEvent *);
 
diff --git a/src/corelib/concurrent/qtconcurrentfilter.h b/src/corelib/concurrent/qtconcurrentfilter.h
index e392212..63dcc4b 100644
--- a/src/corelib/concurrent/qtconcurrentfilter.h
+++ b/src/corelib/concurrent/qtconcurrentfilter.h
@@ -115,19 +115,7 @@ ThreadEngineStarter<void> filterInternal(Sequence &sequence, KeepFunctor keep, T
 template <typename Sequence, typename KeepFunctor>
 QFuture<void> filter(Sequence &sequence, KeepFunctor keep)
 {
-    return filterInternal(sequence, keep, &Sequence::push_back);
-}
-
-template <typename Sequence, typename T>
-QFuture<void> filter(Sequence &sequence, bool (keep)(T))
-{
-    return filterInternal(sequence, FunctionWrapper1<bool, T>(keep), &Sequence::push_back);
-}
-
-template <typename Sequence, typename C>
-QFuture<void> filter(Sequence &sequence, bool (C::*keep)() const)
-{
-    return filterInternal(sequence, ConstMemberFunctionWrapper<bool, C>(keep), &Sequence::push_back);
+    return filterInternal(sequence, QtPrivate::createFunctionWrapper(keep), &Sequence::push_back);
 }
 
 // filteredReduced() on sequences
@@ -137,103 +125,20 @@ QFuture<ResultType> filteredReduced(const Sequence &sequence,
                                     ReduceFunctor reduce,
                                     ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
 {
-    return startFilteredReduced<ResultType>(sequence, keep, reduce, options);
- }
-
-template <typename ResultType, typename Sequence, typename T, typename ReduceFunctor>
-QFuture<ResultType> filteredReduced(const Sequence &sequence,
-                                    bool (filter)(T),
-                                    ReduceFunctor reduce,
-                                    ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return filteredReduced<ResultType>(sequence,
-                                       FunctionWrapper1<bool, T>(filter),
-                                       reduce,
-                                       options);
+    return startFilteredReduced<ResultType>(sequence, QtPrivate::createFunctionWrapper(keep), QtPrivate::createFunctionWrapper(reduce), options);
 }
 
-template <typename ResultType, typename Sequence, typename C, typename ReduceFunctor>
-QFuture<ResultType> filteredReduced(const Sequence &sequence,
-                                    bool (C::*filter)() const,
+template <typename Sequence, typename KeepFunctor, typename ReduceFunctor>
+QFuture<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType> filteredReduced(const Sequence &sequence,
+                                    KeepFunctor keep,
                                     ReduceFunctor reduce,
                                     ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
 {
-    return filteredReduced<ResultType>(sequence,
-                                       ConstMemberFunctionWrapper<bool, C>(filter),
-                                       reduce,
-                                       options);
-}
-
-template <typename Sequence, typename KeepFunctor, typename T, typename U, typename V>
-QFuture<U> filteredReduced(const Sequence &sequence,
-                           KeepFunctor keep,
-                           T (reduce)(U &, V),
-                           ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return filteredReduced<U>(sequence,
-                              keep,
-                              FunctionWrapper2<T, U &, V>(reduce),
-                              options);
-}
-
-template <typename Sequence, typename KeepFunctor, typename T, typename C, typename U>
-QFuture<C> filteredReduced(const Sequence &sequence,
-                           KeepFunctor keep,
-                           T (C::*reduce)(U),
-                           ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return filteredReduced<C>(sequence,
-                              keep,
-                              MemberFunctionWrapper1<T, C, U>(reduce),
-                              options);
-}
-
-template <typename Sequence, typename T, typename U, typename V, typename W>
-QFuture<V> filteredReduced(const Sequence &sequence,
-                           bool (keep)(T),
-                           U (reduce)(V &, W),
-                           ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return filteredReduced<V>(sequence,
-                              FunctionWrapper1<bool, T>(keep),
-                              FunctionWrapper2<U, V &, W>(reduce),
-                              options);
-}
-
-template <typename Sequence, typename C, typename T, typename U, typename V>
-QFuture<U> filteredReduced(const Sequence &sequence,
-                           bool (C::*keep)() const,
-                           T (reduce)(U &, V),
-                           ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return filteredReduced<U>(sequence,
-                              ConstMemberFunctionWrapper<bool, C>(keep),
-                              FunctionWrapper2<T, U &, V>(reduce),
-                              options);
-}
-
-template <typename Sequence, typename T, typename U, typename C, typename V>
-QFuture<C> filteredReduced(const Sequence &sequence,
-                           bool (keep)(T),
-                           U (C::*reduce)(V),
-                           ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return filteredReduced<C>(sequence,
-                              FunctionWrapper1<bool, T>(keep),
-                              MemberFunctionWrapper1<U, C, V>(reduce),
-                              options);
-}
-
-template <typename Sequence, typename C, typename T, typename D, typename U>
-QFuture<D> filteredReduced(const Sequence &sequence,
-                           bool (C::*keep)() const,
-                           T (D::*reduce)(U),
-                           ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return filteredReduced<D>(sequence,
-                              ConstMemberFunctionWrapper<bool, C>(keep),
-                              MemberFunctionWrapper1<T, D, U>(reduce),
-                              options);
+    return startFilteredReduced<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
+            (sequence,
+             QtPrivate::createFunctionWrapper(keep),
+             QtPrivate::createFunctionWrapper(reduce),
+             options);
 }
 
 // filteredReduced() on iterators
@@ -244,184 +149,42 @@ QFuture<ResultType> filteredReduced(Iterator begin,
                                     ReduceFunctor reduce,
                                     ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
 {
-   return startFilteredReduced<ResultType>(begin, end, keep, reduce, options);
-}
-
-template <typename ResultType, typename Iterator, typename T, typename ReduceFunctor>
-QFuture<ResultType> filteredReduced(Iterator begin,
-                                    Iterator end,
-                                    bool (filter)(T),
-                                    ReduceFunctor reduce,
-                                    ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return filteredReduced<ResultType>(begin,
-                                       end,
-                                       FunctionWrapper1<bool, T>(filter),
-                                       reduce,
-                                       options);
+   return startFilteredReduced<ResultType>(begin, end, QtPrivate::createFunctionWrapper(keep), QtPrivate::createFunctionWrapper(reduce), options);
 }
 
-template <typename ResultType, typename Iterator, typename C, typename ReduceFunctor>
-QFuture<ResultType> filteredReduced(Iterator begin,
+template <typename Iterator, typename KeepFunctor, typename ReduceFunctor>
+QFuture<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType> filteredReduced(Iterator begin,
                                     Iterator end,
-                                    bool (C::*filter)() const,
+                                    KeepFunctor keep,
                                     ReduceFunctor reduce,
                                     ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
 {
-    return filteredReduced<ResultType>(begin,
-                                       end,
-                                       ConstMemberFunctionWrapper<bool, C>(filter),
-                                       reduce,
-                                       options);
-}
-
-template <typename Iterator, typename KeepFunctor, typename T, typename U, typename V>
-QFuture<U> filteredReduced(Iterator begin,
-                           Iterator end,
-                           KeepFunctor keep,
-                           T (reduce)(U &, V),
-                           ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return filteredReduced<U>(begin,
-                              end,
-                              keep,
-                              FunctionWrapper2<T, U &, V>(reduce),
-                              options);
-}
-
-template <typename Iterator, typename KeepFunctor, typename T, typename C, typename U>
-QFuture<C> filteredReduced(Iterator begin,
-                           Iterator end,
-                           KeepFunctor keep,
-                           T (C::*reduce)(U),
-                           ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return filteredReduced<C>(begin,
-                              end,
-                              keep,
-                              MemberFunctionWrapper1<T, C, U>(reduce),
-                              options);
-}
-
-template <typename Iterator, typename T, typename U, typename V, typename W>
-QFuture<V> filteredReduced(Iterator begin,
-                           Iterator end,
-                           bool (keep)(T),
-                           U (reduce)(V &, W),
-                           ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return filteredReduced<V>(begin,
-                              end,
-                              FunctionWrapper1<bool, T>(keep),
-                              FunctionWrapper2<U, V &, W>(reduce),
-                              options);
-}
-
-template <typename Iterator, typename C, typename T, typename U, typename V>
-QFuture<U> filteredReduced(Iterator begin,
-                           Iterator end,
-                           bool (C::*keep)() const,
-                           T (reduce)(U &, V),
-                           ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return filteredReduced<U>(begin,
-                              end,
-                              ConstMemberFunctionWrapper<bool, C>(keep),
-                              FunctionWrapper2<T, U &, V>(reduce),
-                              options);
-}
-
-template <typename Iterator, typename T, typename U, typename C, typename V>
-QFuture<C> filteredReduced(Iterator begin,
-                           Iterator end,
-                           bool (keep)(T),
-                           U (C::*reduce)(V),
-                           ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return filteredReduced<C>(begin,
-                              end,
-                              FunctionWrapper1<bool, T>(keep),
-                              MemberFunctionWrapper1<U, C, V>(reduce),
-                              options);
+   return startFilteredReduced<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
+           (begin, end,
+            QtPrivate::createFunctionWrapper(keep),
+            QtPrivate::createFunctionWrapper(reduce),
+            options);
 }
 
-template <typename Iterator, typename C, typename T, typename D, typename U>
-QFuture<D> filteredReduced(Iterator begin,
-                           Iterator end,
-                           bool (C::*keep)() const,
-                           T (D::*reduce)(U),
-                           ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return filteredReduced<D>(begin,
-                              end,
-                              ConstMemberFunctionWrapper<bool, C>(keep),
-                              MemberFunctionWrapper1<T, D, U>(reduce),
-                              options);
-}
-
-
 // filtered() on sequences
 template <typename Sequence, typename KeepFunctor>
 QFuture<typename Sequence::value_type> filtered(const Sequence &sequence, KeepFunctor keep)
 {
-    return startFiltered(sequence, keep);
-}
-
-template <typename Sequence, typename T>
-QFuture<typename Sequence::value_type> filtered(const Sequence &sequence, bool (keep)(T))
-{
-    return startFiltered(sequence, FunctionWrapper1<bool, T>(keep));
-}
-
-template <typename Sequence, typename C>
-QFuture<typename Sequence::value_type> filtered(const Sequence &sequence, bool (C::*keep)() const)
-{
-    return startFiltered(sequence, ConstMemberFunctionWrapper<bool, C>(keep));
+    return startFiltered(sequence, QtPrivate::createFunctionWrapper(keep));
 }
 
 // filtered() on iterators
 template <typename Iterator, typename KeepFunctor>
 QFuture<typename qValueType<Iterator>::value_type> filtered(Iterator begin, Iterator end, KeepFunctor keep)
 {
-    return startFiltered(begin, end, keep);
+    return startFiltered(begin, end, QtPrivate::createFunctionWrapper(keep));
 }
 
-template <typename Iterator, typename T>
-QFuture<typename qValueType<Iterator>::value_type> filtered(Iterator begin, Iterator end, bool (keep)(T))
-{
-    return startFiltered(begin, end, FunctionWrapper1<bool, T>(keep));
-}
-
-template <typename Iterator, typename C>
-QFuture<typename qValueType<Iterator>::value_type> filtered(Iterator begin,
-                                                Iterator end,
-                                                bool (C::*keep)() const)
-{
-    return startFiltered(begin, end, ConstMemberFunctionWrapper<bool, C>(keep));
-}
-
-
 // blocking filter() on sequences
 template <typename Sequence, typename KeepFunctor>
 void blockingFilter(Sequence &sequence, KeepFunctor keep)
 {
-    filterInternal(sequence, keep, &Sequence::push_back).startBlocking();
-}
-
-template <typename Sequence, typename T>
-void blockingFilter(Sequence &sequence, bool (keep)(T))
-{
-    filterInternal(sequence, FunctionWrapper1<bool, T>(keep), &Sequence::push_back)
-        .startBlocking();
-}
-
-template <typename Sequence, typename C>
-void blockingFilter(Sequence &sequence, bool (C::*keep)() const)
-{
-    filterInternal(sequence,
-                   ConstMemberFunctionWrapper<bool, C>(keep),
-                   &Sequence::push_back)
-        .startBlocking();
+    filterInternal(sequence, QtPrivate::createFunctionWrapper(keep), &Sequence::push_back).startBlocking();
 }
 
 // blocking filteredReduced() on sequences
@@ -431,111 +194,20 @@ ResultType blockingFilteredReduced(const Sequence &sequence,
                                    ReduceFunctor reduce,
                                    ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
 {
-    return startFilteredReduced<ResultType>(sequence, keep, reduce, options)
+    return startFilteredReduced<ResultType>(sequence, QtPrivate::createFunctionWrapper(keep), QtPrivate::createFunctionWrapper(reduce), options)
         .startBlocking();
 }
 
-template <typename ResultType, typename Sequence, typename T, typename ReduceFunctor>
-ResultType blockingFilteredReduced(const Sequence &sequence,
-                                   bool (filter)(T),
-                                   ReduceFunctor reduce,
-                                   ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return blockingFilteredReduced<ResultType>
-        (sequence,
-         FunctionWrapper1<bool, T>(filter),
-         reduce,
-         options);
-}
-
-template <typename ResultType, typename Sequence, typename C, typename ReduceFunctor>
-ResultType blockingFilteredReduced(const Sequence &sequence,
-                                   bool (C::*filter)() const,
+template <typename Sequence, typename KeepFunctor, typename ReduceFunctor>
+typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType blockingFilteredReduced(const Sequence &sequence,
+                                   KeepFunctor keep,
                                    ReduceFunctor reduce,
                                    ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
 {
-    return blockingFilteredReduced<ResultType>
-        (sequence,
-         ConstMemberFunctionWrapper<bool, C>(filter),
-         reduce,
-         options);
-}
-
-template <typename Sequence, typename KeepFunctor, typename T, typename U, typename V>
-U blockingFilteredReduced(const Sequence &sequence,
-                          KeepFunctor keep,
-                          T (reduce)(U &, V),
-                          ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return blockingFilteredReduced<U>
-        (sequence,
-         keep,
-         FunctionWrapper2<T, U &, V>(reduce),
-         options);
-}
-
-template <typename Sequence, typename KeepFunctor, typename T, typename C, typename U>
-C blockingFilteredReduced(const Sequence &sequence,
-                          KeepFunctor keep,
-                          T (C::*reduce)(U),
-                          ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return blockingFilteredReduced<C>
+    return blockingFilteredReduced<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
         (sequence,
-         keep,
-         MemberFunctionWrapper1<T, C, U>(reduce),
-         options);
-}
-
-template <typename Sequence, typename T, typename U, typename V, typename W>
-V blockingFilteredReduced(const Sequence &sequence,
-                          bool (keep)(T),
-                          U (reduce)(V &, W),
-                          ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return blockingFilteredReduced<V>
-        (sequence,
-         FunctionWrapper1<bool, T>(keep),
-         FunctionWrapper2<U, V &, W>(reduce),
-         options);
-}
-
-template <typename Sequence, typename C, typename T, typename U, typename V>
-U blockingFilteredReduced(const Sequence &sequence,
-                          bool (C::*keep)() const,
-                          T (reduce)(U &, V),
-                          ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return blockingFilteredReduced<U>
-        (sequence,
-         ConstMemberFunctionWrapper<bool, C>(keep),
-         FunctionWrapper2<T, U &, V>(reduce),
-         options);
-}
-
-template <typename Sequence, typename T, typename U, typename C, typename V>
-C blockingFilteredReduced(const Sequence &sequence,
-                          bool (keep)(T),
-                          U (C::*reduce)(V),
-                          ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return blockingFilteredReduced<C>
-        (sequence,
-         FunctionWrapper1<bool, T>(keep),
-         MemberFunctionWrapper1<U, C, V>(reduce),
-         options);
-}
-
-template <typename Sequence, typename C, typename T, typename D, typename U>
-D blockingFilteredReduced(const Sequence &sequence,
-                          bool (C::*keep)() const,
-                          T (D::*reduce)(U),
-                          ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return blockingFilteredReduced<D>
-        (sequence,
-         ConstMemberFunctionWrapper<bool, C>(keep),
-         MemberFunctionWrapper1<T, D, U>(reduce),
+         QtPrivate::createFunctionWrapper(keep),
+         QtPrivate::createFunctionWrapper(reduce),
          options);
 }
 
@@ -547,150 +219,34 @@ ResultType blockingFilteredReduced(Iterator begin,
                                    ReduceFunctor reduce,
                                    ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
 {
-    return startFilteredReduced<ResultType>(begin, end, keep, reduce, options)
+    return startFilteredReduced<ResultType>
+        (begin, end,
+         QtPrivate::createFunctionWrapper(keep),
+         QtPrivate::createFunctionWrapper(reduce),
+         options)
         .startBlocking();
 }
 
-template <typename ResultType, typename Iterator, typename T, typename ReduceFunctor>
-ResultType blockingFilteredReduced(Iterator begin,
-                                   Iterator end,
-                                   bool (filter)(T),
-                                   ReduceFunctor reduce,
-                                   ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return blockingFilteredReduced<ResultType>
-        (begin,
-         end,
-         FunctionWrapper1<bool, T>(filter),
-         reduce,
-         options);
-}
-
-template <typename ResultType, typename Iterator, typename C, typename ReduceFunctor>
-ResultType blockingFilteredReduced(Iterator begin,
+template <typename Iterator, typename KeepFunctor, typename ReduceFunctor>
+typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType blockingFilteredReduced(Iterator begin,
                                    Iterator end,
-                                   bool (C::*filter)() const,
+                                   KeepFunctor keep,
                                    ReduceFunctor reduce,
                                    ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
 {
-    return blockingFilteredReduced<ResultType>
-        (begin,
-         end,
-         ConstMemberFunctionWrapper<bool, C>(filter),
-         reduce,
-         options);
-}
-
-template <typename Iterator, typename KeepFunctor, typename T, typename U, typename V>
-U blockingFilteredReduced(Iterator begin,
-                          Iterator end,
-                          KeepFunctor keep,
-                          T (reduce)(U &, V),
-                          ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return blockingFilteredReduced<U>
-        (begin,
-         end,
-         keep,
-         FunctionWrapper2<T, U &, V>(reduce),
-         options);
-}
-
-template <typename Iterator, typename KeepFunctor, typename T, typename C, typename U>
-C blockingFilteredReduced(Iterator begin,
-                          Iterator end,
-                          KeepFunctor keep,
-                          T (C::*reduce)(U),
-                          ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return blockingFilteredReduced<C>
-        (begin,
-         end,
-         keep,
-         MemberFunctionWrapper1<T, C, U>(reduce),
-         options);
-}
-
-template <typename Iterator, typename T, typename U, typename V, typename W>
-V blockingFilteredReduced(Iterator begin,
-                          Iterator end,
-                          bool (keep)(T),
-                          U (reduce)(V &, W),
-                          ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return blockingFilteredReduced<V>
-        (begin,
-         end,
-         FunctionWrapper1<bool, T>(keep),
-         FunctionWrapper2<U, V &, W>(reduce),
-         options);
-}
-
-template <typename Iterator, typename C, typename T, typename U, typename V>
-U blockingFilteredReduced(Iterator begin,
-                          Iterator end,
-                          bool (C::*keep)() const,
-                          T (reduce)(U &, V),
-                          ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return blockingFilteredReduced<U>
-        (begin,
-         end,
-         ConstMemberFunctionWrapper<bool, C>(keep),
-         FunctionWrapper2<T, U &, V>(reduce),
-         options);
-}
-
-template <typename Iterator, typename T, typename U, typename C, typename V>
-C blockingFilteredReduced(Iterator begin,
-                          Iterator end,
-                          bool (keep)(T),
-                          U (C::*reduce)(V),
-                          ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return blockingFilteredReduced<C>
-        (begin,
-         end,
-         FunctionWrapper1<bool, T>(keep),
-         MemberFunctionWrapper1<U, C, V>(reduce),
-         options);
-}
-
-template <typename Iterator, typename C, typename T, typename D, typename U>
-D blockingFilteredReduced(Iterator begin,
-                          Iterator end,
-                          bool (C::*keep)() const,
-                          T (D::*reduce)(U),
-                          ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return blockingFilteredReduced<D>
-        (begin,
-         end,
-         ConstMemberFunctionWrapper<bool, C>(keep),
-         MemberFunctionWrapper1<T, D, U>(reduce),
-         options);
+    return startFilteredReduced<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
+        (begin, end,
+         QtPrivate::createFunctionWrapper(keep),
+         QtPrivate::createFunctionWrapper(reduce),
+         options)
+        .startBlocking();
 }
 
 // blocking filtered() on sequences
 template <typename Sequence, typename KeepFunctor>
 Sequence blockingFiltered(const Sequence &sequence, KeepFunctor keep)
 {
-    return blockingFilteredReduced(sequence, keep, &Sequence::push_back, OrderedReduce);
-}
-
-template <typename Sequence, typename T>
-Sequence blockingFiltered(const Sequence &sequence, bool (keep)(T))
-{
-    return blockingFilteredReduced(sequence, keep, &Sequence::push_back, OrderedReduce);
-}
-
-template <typename Sequence, typename C>
-Sequence blockingFiltered(const Sequence &sequence, bool (C::*filter)() const)
-{
-    return blockingFilteredReduced(sequence,
-                                   filter,
-                                   &Sequence::push_back,
-                                   OrderedReduce);
+    return blockingFilteredReduced(sequence, QtPrivate::createFunctionWrapper(keep), &Sequence::push_back, OrderedReduce);
 }
 
 // blocking filtered() on iterators
@@ -699,27 +255,7 @@ OutputSequence blockingFiltered(Iterator begin, Iterator end, KeepFunctor keep)
 {
     return blockingFilteredReduced(begin,
                                    end,
-                                   keep,
-                                   &OutputSequence::push_back,
-                                   OrderedReduce);
-}
-
-template <typename OutputSequence, typename Iterator, typename T>
-OutputSequence blockingFiltered(Iterator begin, Iterator end, bool (keep)(T))
-{
-    return blockingFilteredReduced(begin,
-                                   end,
-                                   keep,
-                                   &OutputSequence::push_back,
-                                   OrderedReduce);
-}
-
-template <typename OutputSequence, typename Iterator, typename C>
-OutputSequence blockingFiltered(Iterator begin, Iterator end, bool (C::*filter)() const)
-{
-    return blockingFilteredReduced(begin,
-                                   end,
-                                   filter,
+                                   QtPrivate::createFunctionWrapper(keep),
                                    &OutputSequence::push_back,
                                    OrderedReduce);
 }
diff --git a/src/corelib/concurrent/qtconcurrentfunctionwrappers.h b/src/corelib/concurrent/qtconcurrentfunctionwrappers.h
index f31f7d2..98506a5 100644
--- a/src/corelib/concurrent/qtconcurrentfunctionwrappers.h
+++ b/src/corelib/concurrent/qtconcurrentfunctionwrappers.h
@@ -163,6 +163,125 @@ private:
 
 } // namespace QtConcurrent.
 
+namespace QtPrivate {
+
+template <typename T>
+const T& createFunctionWrapper(const T& t)
+{
+    return t;
+}
+
+template <typename T, typename U>
+QtConcurrent::FunctionWrapper1<T, U> createFunctionWrapper(T (*func)(U))
+{
+    return QtConcurrent::FunctionWrapper1<T, U>(func);
+}
+
+template <typename T, typename C>
+QtConcurrent::MemberFunctionWrapper<T, C> createFunctionWrapper(T (C::*func)())
+{
+    return QtConcurrent::MemberFunctionWrapper<T, C>(func);
+}
+
+template <typename T, typename C, typename U>
+QtConcurrent::MemberFunctionWrapper1<T, C, U> createFunctionWrapper(T (C::*func)(U))
+{
+    return QtConcurrent::MemberFunctionWrapper1<T, C, U>(func);
+}
+
+template <typename T, typename C>
+QtConcurrent::ConstMemberFunctionWrapper<T, C> createFunctionWrapper(T (C::*func)() const)
+{
+    return QtConcurrent::ConstMemberFunctionWrapper<T, C>(func);
+}
+
+
+template<typename T>
+void *lazyResultType_helper(int, typename T::result_type * = 0);
+template<typename T>
+char lazyResultType_helper(double);
+
+template <typename Functor, bool foo = sizeof(lazyResultType_helper<Functor>(0)) != sizeof(void*)>
+struct LazyResultType { typedef typename Functor::result_type Type; };
+template <typename Functor>
+struct LazyResultType<Functor, true> { typedef void Type; };
+
+
+template <class T>
+struct ReduceResultType;
+
+template <class U, class V>
+struct ReduceResultType<void(*)(U&,V)>
+{
+    typedef U ResultType;
+};
+
+template <class T, class C, class U>
+struct ReduceResultType<T(C::*)(U)>
+{
+    typedef C ResultType;
+};
+
+template <class InputSequence, class MapFunctor>
+struct MapResultType
+{
+    typedef typename LazyResultType<MapFunctor>::Type ResultType;
+};
+
+template <class U, class V>
+struct MapResultType<void, U (*)(V)>
+{
+    typedef U ResultType;
+};
+
+template <class T, class C>
+struct MapResultType<void, T(C::*)() const>
+{
+    typedef T ResultType;
+};
+
+#ifndef QT_NO_TEMPLATE_TEMPLATE_PARAMETERS
+
+template <template <typename> class InputSequence, typename MapFunctor, typename T>
+struct MapResultType<InputSequence<T>, MapFunctor>
+{
+    typedef InputSequence<typename LazyResultType<MapFunctor>::Type> ResultType;
+};
+
+template <template <typename> class InputSequence, class T, class U, class V>
+struct MapResultType<InputSequence<T>, U (*)(V)>
+{
+    typedef InputSequence<U> ResultType;
+};
+
+template <template <typename> class InputSequence, class T, class U, class C>
+struct MapResultType<InputSequence<T>, U(C::*)() const>
+{
+    typedef InputSequence<U> ResultType;
+};
+
+#endif // QT_NO_TEMPLATE_TEMPLATE_PARAMETER
+
+template <class MapFunctor>
+struct MapResultType<QStringList, MapFunctor>
+{
+    typedef QList<typename LazyResultType<MapFunctor>::Type> ResultType;
+};
+
+template <class U, class V>
+struct MapResultType<QStringList, U (*)(V)>
+{
+    typedef QList<U> ResultType;
+};
+
+template <class U, class C>
+struct MapResultType<QStringList, U(C::*)() const>
+{
+    typedef QList<U> ResultType;
+};
+
+} // namespace QtPrivate.
+
 #endif //qdoc
 
 QT_END_NAMESPACE
diff --git a/src/corelib/concurrent/qtconcurrentmap.h b/src/corelib/concurrent/qtconcurrentmap.h
index 80edf7e..a857ab5 100644
--- a/src/corelib/concurrent/qtconcurrentmap.h
+++ b/src/corelib/concurrent/qtconcurrentmap.h
@@ -110,38 +110,14 @@ namespace QtConcurrent {
 template <typename Sequence, typename MapFunctor>
 QFuture<void> map(Sequence &sequence, MapFunctor map)
 {
-    return startMap(sequence.begin(), sequence.end(), map);
-}
-
-template <typename Sequence, typename T, typename U>
-QFuture<void> map(Sequence &sequence, T (map)(U))
-{
-    return startMap(sequence.begin(), sequence.end(), FunctionWrapper1<T, U>(map));
-}
-
-template <typename Sequence, typename T, typename C>
-QFuture<void> map(Sequence &sequence, T (C::*map)())
-{
-    return startMap(sequence.begin(), sequence.end(), MemberFunctionWrapper<T, C>(map));
+    return startMap(sequence.begin(), sequence.end(), QtPrivate::createFunctionWrapper(map));
 }
 
 // map() on iterators
 template <typename Iterator, typename MapFunctor>
 QFuture<void> map(Iterator begin, Iterator end, MapFunctor map)
 {
-    return startMap(begin, end, map);
-}
-
-template <typename Iterator, typename T, typename U>
-QFuture<void> map(Iterator begin, Iterator end, T (map)(U))
-{
-    return startMap(begin, end, FunctionWrapper1<T, U>(map));
-}
-
-template <typename Iterator, typename T, typename C>
-QFuture<void> map(Iterator begin, Iterator end, T (C::*map)())
-{
-    return startMap(begin, end, MemberFunctionWrapper<T, C>(map));
+    return startMap(begin, end, QtPrivate::createFunctionWrapper(map));
 }
 
 // mappedReduced() for sequences.
@@ -151,88 +127,24 @@ QFuture<ResultType> mappedReduced(const Sequence &sequence,
                                   ReduceFunctor reduce,
                                   ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
 {
-    return startMappedReduced<typename MapFunctor::result_type, ResultType>
-    (sequence, map, reduce, options);
-}
-
-template <typename Sequence, typename MapFunctor, typename T, typename U, typename V>
-QFuture<U> mappedReduced(const Sequence &sequence,
-                         MapFunctor map,
-                         T (reduce)(U &, V),
-                         ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return startMappedReduced<typename MapFunctor::result_type, U>
-    (sequence, map, FunctionWrapper2<T, U &, V>(reduce), options);
-}
-
-template <typename Sequence, typename MapFunctor, typename T, typename C, typename U>
-QFuture<C> mappedReduced(const Sequence &sequence,
-                         MapFunctor map,
-                         T (C::*reduce)(U),
-                         ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return startMappedReduced<typename MapFunctor::result_type, C>
-    (sequence, map, MemberFunctionWrapper1<T, C, U>(reduce), options);
-}
-
-template <typename ResultType, typename Sequence, typename T, typename U, typename ReduceFunctor>
-QFuture<ResultType> mappedReduced(const Sequence &sequence,
-                                  T (map)(U),
-                                  ReduceFunctor reduce,
-                                  ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return startMappedReduced<T, ResultType>
-    (sequence, FunctionWrapper1<T, U>(map), reduce, options);
+    return startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, ResultType>
+        (sequence,
+         QtPrivate::createFunctionWrapper(map),
+         QtPrivate::createFunctionWrapper(reduce),
+         options);
 }
 
-template <typename ResultType, typename Sequence, typename T, typename C, typename ReduceFunctor>
-QFuture<ResultType> mappedReduced(const Sequence &sequence,
-                                  T (C::*map)() const,
+template <typename Sequence, typename MapFunctor, typename ReduceFunctor>
+QFuture<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType> mappedReduced(const Sequence &sequence,
+                                  MapFunctor map,
                                   ReduceFunctor reduce,
                                   ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
 {
-    return startMappedReduced<T, ResultType>
-    (sequence, ConstMemberFunctionWrapper<T, C>(map), reduce, options);
-}
-
-template <typename Sequence, typename T, typename U, typename V, typename W, typename X>
-QFuture<W> mappedReduced(const Sequence &sequence,
-                         T (map)(U),
-                         V (reduce)(W &, X),
-                         ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return startMappedReduced<T, W>
-    (sequence, FunctionWrapper1<T, U>(map), FunctionWrapper2<V, W &, X>(reduce), options);
-}
-
-template <typename Sequence, typename T, typename C, typename U, typename V, typename W>
-QFuture<V> mappedReduced(const Sequence &sequence,
-                         T (C::*map)() const,
-                         U (reduce)(V &, W),
-                         ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return startMappedReduced<T, V> (sequence, ConstMemberFunctionWrapper<T, C>(map),
-                                    FunctionWrapper2<U, V &, W>(reduce), options);
-}
-
-template <typename Sequence, typename T, typename U, typename V, typename C, typename W>
-QFuture<C> mappedReduced(const Sequence &sequence,
-                         T (map)(U),
-                         V (C::*reduce)(W),
-                         ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return startMappedReduced<T, C> (sequence, FunctionWrapper1<T, U>(map),
-                                     MemberFunctionWrapper1<V, C, W>(reduce), options);
-}
-
-template <typename Sequence, typename T, typename C, typename U,typename D, typename V>
-QFuture<D> mappedReduced(const Sequence &sequence,
-                         T (C::*map)() const,
-                         U (D::*reduce)(V),
-                         ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return startMappedReduced<T, D>(sequence, ConstMemberFunctionWrapper<T, C>(map),
-                                    MemberFunctionWrapper1<U, D, V>(reduce), options);
+    return startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
+        (sequence,
+         QtPrivate::createFunctionWrapper(map),
+         QtPrivate::createFunctionWrapper(reduce),
+         options);
 }
 
 // mappedReduced() for iterators
@@ -243,295 +155,85 @@ QFuture<ResultType> mappedReduced(Iterator begin,
                                   ReduceFunctor reduce,
                                   ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
 {
-    return startMappedReduced<ResultType, typename MapFunctor::result_type>
-    (begin, end, map, reduce, options);
-}
-
-template <typename Iterator, typename MapFunctor, typename T, typename U, typename V>
-QFuture<U> mappedReduced(Iterator begin,
-                         Iterator end,
-                         MapFunctor map,
-                         T (reduce)(U &, V),
-                         ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return startMappedReduced<typename MapFunctor::result_type, U>
-    (begin, end, map, FunctionWrapper2<T, U &, V>(reduce), options);
-}
-
-template <typename Iterator, typename MapFunctor, typename T, typename C, typename U>
-QFuture<C> mappedReduced(Iterator begin,
-                         Iterator end,
-                         MapFunctor map,
-                         T (C::*reduce)(U),
-                         ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return startMappedReduced<typename MapFunctor::result_type, C>
-    (begin, end, map, MemberFunctionWrapper1<T, C, U>(reduce), options);
+    return startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, ResultType>
+        (begin, end,
+         QtPrivate::createFunctionWrapper(map),
+         QtPrivate::createFunctionWrapper(reduce),
+         options);
 }
 
-template <typename ResultType, typename Iterator, typename T, typename U, typename ReduceFunctor>
-QFuture<ResultType> mappedReduced(Iterator begin,
+template <typename Iterator, typename MapFunctor, typename ReduceFunctor>
+QFuture<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType> mappedReduced(Iterator begin,
                                   Iterator end,
-                                  T (map)(U),
-                                  ReduceFunctor reduce,
-                                  ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return startMappedReduced<T, ResultType>
-    (begin, end, FunctionWrapper1<T, U>(map), reduce, options);
-}
-
-template <typename ResultType, typename Iterator, typename T, typename C, typename ReduceFunctor>
-QFuture<ResultType> mappedReduced(Iterator begin,
-                                  Iterator end,
-                                  T (C::*map)() const,
+                                  MapFunctor map,
                                   ReduceFunctor reduce,
                                   ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
 {
-    return startMappedReduced<T, ResultType>
-    (begin, end, ConstMemberFunctionWrapper<T, C>(map), reduce, options);
-}
-
-template <typename Iterator, typename T, typename U, typename V, typename W, typename X>
-QFuture<W> mappedReduced(Iterator begin,
-                         Iterator end,
-                         T (map)(U),
-                         V (reduce)(W &, X),
-                         ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return startMappedReduced<T, W>
-    (begin, end, FunctionWrapper1<T, U>(map), FunctionWrapper2<V, W &, X>(reduce), options);
-}
-
-template <typename Iterator, typename T, typename C, typename U, typename V, typename W>
-QFuture<V> mappedReduced(Iterator begin,
-                         Iterator end,
-                         T (C::*map)() const,
-                         U (reduce)(V &, W),
-                         ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return startMappedReduced<T, V>(begin, end, ConstMemberFunctionWrapper<T, C>(map),
-                                   FunctionWrapper2<U, V &, W>(reduce), options);
-}
-
-template <typename Iterator, typename T, typename U, typename V, typename C, typename W>
-QFuture<C> mappedReduced(Iterator begin,
-                         Iterator end,
-                         T (map)(U),
-                         V (C::*reduce)(W),
-                         ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return startMappedReduced<T, C>
-    (begin, end, FunctionWrapper1<T, U>(map), MemberFunctionWrapper1<V, C, W>(reduce), options);
-}
-
-template <typename Iterator, typename T, typename C, typename U,typename D, typename V>
-QFuture<D> mappedReduced(Iterator begin,
-                         Iterator end,
-                         T (C::*map)() const,
-                         U (D::*reduce)(V),
-                         ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return startMappedReduced<T, D>(begin, end, ConstMemberFunctionWrapper<T, C>(map),
-                                    MemberFunctionWrapper1<U, D, V>(reduce), options);
+    return startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
+        (begin, end,
+         QtPrivate::createFunctionWrapper(map),
+         QtPrivate::createFunctionWrapper(reduce),
+         options);
 }
 
 // mapped() for sequences
 template <typename Sequence, typename MapFunctor>
-QFuture<typename MapFunctor::result_type> mapped(const Sequence &sequence, MapFunctor map)
+QFuture<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType> mapped(const Sequence &sequence, MapFunctor map)
 {
-    return startMapped<typename MapFunctor::result_type>(sequence, map);
-}
-
-template <typename Sequence, typename T, typename U>
-QFuture<T> mapped(const Sequence &sequence, T (map)(U))
-{
-   return startMapped<T>(sequence, FunctionWrapper1<T, U>(map));
-}
-
-template <typename Sequence, typename T, typename C>
-QFuture<T> mapped(const Sequence &sequence, T (C::*map)() const)
-{
-    return startMapped<T>(sequence, ConstMemberFunctionWrapper<T, C>(map));
+    return startMapped<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType>(sequence, QtPrivate::createFunctionWrapper(map));
 }
 
 // mapped() for iterator ranges.
 template <typename Iterator, typename MapFunctor>
-QFuture<typename MapFunctor::result_type> mapped(Iterator begin, Iterator end, MapFunctor map)
-{
-    return startMapped<Q_TYPENAME MapFunctor::result_type>(begin, end, map);
-}
-
-template <typename Iterator, typename T, typename U>
-QFuture<T> mapped(Iterator begin, Iterator end, T (map)(U))
+QFuture<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType> mapped(Iterator begin, Iterator end, MapFunctor map)
 {
-    return startMapped<T>(begin, end, FunctionWrapper1<T, U>(map));
+    return startMapped<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType>(begin, end, QtPrivate::createFunctionWrapper(map));
 }
 
-template <typename Iterator, typename T, typename C>
-QFuture<T> mapped(Iterator begin, Iterator end, T (C::*map)() const)
-{
-    return startMapped<T>(begin, end, ConstMemberFunctionWrapper<T, C>(map));
-}
-
-
+// blockingMap() for sequences
 template <typename Sequence, typename MapFunctor>
 void blockingMap(Sequence &sequence, MapFunctor map)
 {
-    startMap(sequence.begin(), sequence.end(), map).startBlocking();
-}
-
-template <typename Sequence, typename T, typename U>
-void blockingMap(Sequence &sequence, T (map)(U))
-{
-    startMap(sequence.begin(), sequence.end(), QtConcurrent::FunctionWrapper1<T, U>(map)).startBlocking();
-}
-
-template <typename Sequence, typename T, typename C>
-void blockingMap(Sequence &sequence, T (C::*map)())
-{
-    startMap(sequence.begin(), sequence.end(), QtConcurrent::MemberFunctionWrapper<T, C>(map)).startBlocking();
+    startMap(sequence.begin(), sequence.end(), QtPrivate::createFunctionWrapper(map)).startBlocking();
 }
 
+// blockingMap() for iterator ranges
 template <typename Iterator, typename MapFunctor>
 void blockingMap(Iterator begin, Iterator end, MapFunctor map)
 {
-    startMap(begin, end, map).startBlocking();
-}
-
-template <typename Iterator, typename T, typename U>
-void blockingMap(Iterator begin, Iterator end, T (map)(U))
-{
-    startMap(begin, end, QtConcurrent::FunctionWrapper1<T, U>(map)).startBlocking();
-}
-
-template <typename Iterator, typename T, typename C>
-void blockingMap(Iterator begin, Iterator end, T (C::*map)())
-{
-    startMap(begin, end, QtConcurrent::MemberFunctionWrapper<T, C>(map)).startBlocking();
+    startMap(begin, end, QtPrivate::createFunctionWrapper(map)).startBlocking();
 }
 
+// blockingMappedReduced() for sequences
 template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor>
 ResultType blockingMappedReduced(const Sequence &sequence,
                                  MapFunctor map,
                                  ReduceFunctor reduce,
                                  ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
 {
-    return QtConcurrent::startMappedReduced<typename MapFunctor::result_type, ResultType>
-    (sequence, map, reduce, options).startBlocking();
-}
-
-template <typename Sequence, typename MapFunctor, typename T, typename U, typename V>
-U blockingMappedReduced(const Sequence &sequence,
-                        MapFunctor map,
-                        T (reduce)(U &, V),
-                        QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
-{
-    return QtConcurrent::startMappedReduced<typename MapFunctor::result_type, U>
-        (sequence,
-         map,
-         QtConcurrent::FunctionWrapper2<T, U &, V>(reduce),
-         options)
-        .startBlocking();
-}
-
-template <typename Sequence, typename MapFunctor, typename T, typename C, typename U>
-C blockingMappedReduced(const Sequence &sequence,
-                        MapFunctor map,
-                        T (C::*reduce)(U),
-                        QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
-{
-    return QtConcurrent::startMappedReduced<typename MapFunctor::result_type, C>
-        (sequence,
-         map,
-         QtConcurrent::MemberFunctionWrapper1<T, C, U>(reduce),
-         options)
-        .startBlocking();
-}
-
-template <typename ResultType, typename Sequence, typename T, typename U, typename ReduceFunctor>
-ResultType blockingMappedReduced(const Sequence &sequence,
-                                 T (map)(U),
-                                 ReduceFunctor reduce,
-                                 QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
-{
-    return QtConcurrent::startMappedReduced<T, ResultType>
+    return QtConcurrent::startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, ResultType>
         (sequence,
-         QtConcurrent::FunctionWrapper1<T, U>(map),
-         reduce,
+         QtPrivate::createFunctionWrapper(map),
+         QtPrivate::createFunctionWrapper(reduce),
          options)
         .startBlocking();
 }
 
-template <typename ResultType, typename Sequence, typename T, typename C, typename ReduceFunctor>
-ResultType blockingMappedReduced(const Sequence &sequence,
-                                 T (C::*map)() const,
+template <typename MapFunctor, typename ReduceFunctor, typename Sequence>
+typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType blockingMappedReduced(const Sequence &sequence,
+                                 MapFunctor map,
                                  ReduceFunctor reduce,
-                                 QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
-{
-    return QtConcurrent::startMappedReduced<T, ResultType>
-        (sequence,
-         QtConcurrent::ConstMemberFunctionWrapper<T, C>(map),
-         reduce,
-         options)
-        .startBlocking();
-}
-
-template <typename Sequence, typename T, typename U, typename V, typename W, typename X>
-W blockingMappedReduced(const Sequence &sequence,
-                        T (map)(U),
-                        V (reduce)(W &, X),
-                        QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
-{
-    return QtConcurrent::startMappedReduced<T, W>
-        (sequence,
-         QtConcurrent::FunctionWrapper1<T, U>(map),
-         QtConcurrent::FunctionWrapper2<V, W &, X>(reduce),
-         options)
-        .startBlocking();
-}
-
-template <typename Sequence, typename T, typename C, typename U, typename V, typename W>
-V blockingMappedReduced(const Sequence &sequence,
-                        T (C::*map)() const,
-                        U (reduce)(V &, W),
-                        QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
-{
-    return QtConcurrent::startMappedReduced<T, V>
-        (sequence,
-         QtConcurrent::ConstMemberFunctionWrapper<T, C>(map),
-         QtConcurrent::FunctionWrapper2<U, V &, W>(reduce),
-         options)
-        .startBlocking();
-}
-
-template <typename Sequence, typename T, typename U, typename V, typename C, typename W>
-C blockingMappedReduced(const Sequence &sequence,
-                        T (map)(U),
-                        V (C::*reduce)(W),
-                        QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
-{
-    return QtConcurrent::startMappedReduced<T, C>
-        (sequence,
-         QtConcurrent::FunctionWrapper1<T, U>(map),
-         QtConcurrent::MemberFunctionWrapper1<V, C, W>(reduce),
-         options)
-        .startBlocking();
-}
-
-template <typename Sequence, typename T, typename C, typename U,typename D, typename V>
-D blockingMappedReduced(const Sequence &sequence,
-                        T (C::*map)() const,
-                        U (D::*reduce)(V),
-                        QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
+                                 ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
 {
-    return QtConcurrent::startMappedReduced<T, D>
+    return QtConcurrent::startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
         (sequence,
-         QtConcurrent::ConstMemberFunctionWrapper<T, C>(map),
-         QtConcurrent::MemberFunctionWrapper1<U, D, V>(reduce),
+         QtPrivate::createFunctionWrapper(map),
+         QtPrivate::createFunctionWrapper(reduce),
          options)
         .startBlocking();
 }
 
+// blockingMappedReduced() for iterator ranges
 template <typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor>
 ResultType blockingMappedReduced(Iterator begin,
                                  Iterator end,
@@ -539,134 +241,25 @@ ResultType blockingMappedReduced(Iterator begin,
                                  ReduceFunctor reduce,
                                  QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
 {
-    return QtConcurrent::startMappedReduced<typename MapFunctor::result_type, ResultType>
-        (begin, end, map, reduce, options).startBlocking();
-}
-
-template <typename Iterator, typename MapFunctor, typename T, typename U, typename V>
-U blockingMappedReduced(Iterator begin,
-                        Iterator end,
-                        MapFunctor map,
-                        T (reduce)(U &, V),
-                        QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
-{
-    return QtConcurrent::startMappedReduced<typename MapFunctor::result_type, U>
-        (begin,
-         end,
-         map,
-         QtConcurrent::FunctionWrapper2<T, U &, V>(reduce),
-         options)
-        .startBlocking();
-}
-
-template <typename Iterator, typename MapFunctor, typename T, typename C, typename U>
-C blockingMappedReduced(Iterator begin,
-                        Iterator end,
-                        MapFunctor map,
-                        T (C::*reduce)(U),
-                        QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
-{
-    return QtConcurrent::startMappedReduced<typename MapFunctor::result_type, C>
-        (begin,
-         end,
-         map,
-         QtConcurrent::MemberFunctionWrapper1<T, C, U>(reduce),
+    return QtConcurrent::startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, ResultType>
+        (begin, end,
+         QtPrivate::createFunctionWrapper(map),
+         QtPrivate::createFunctionWrapper(reduce),
          options)
         .startBlocking();
 }
 
-template <typename ResultType, typename Iterator, typename T, typename U, typename ReduceFunctor>
-ResultType blockingMappedReduced(Iterator begin,
+template <typename Iterator, typename MapFunctor, typename ReduceFunctor>
+typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType blockingMappedReduced(Iterator begin,
                                  Iterator end,
-                                 T (map)(U),
-                                 ReduceFunctor reduce,
-                                 QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
-{
-    return QtConcurrent::startMappedReduced<T, ResultType>
-        (begin,
-         end,
-         QtConcurrent::FunctionWrapper1<T, U>(map),
-         reduce,
-         options)
-        .startBlocking();
-}
-
-template <typename ResultType, typename Iterator, typename T, typename C, typename ReduceFunctor>
-ResultType blockingMappedReduced(Iterator begin,
-                                 Iterator end,
-                                 T (C::*map)() const,
+                                 MapFunctor map,
                                  ReduceFunctor reduce,
                                  QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
 {
-    return QtConcurrent::startMappedReduced<T, ResultType>
-        (begin,
-         end,
-         QtConcurrent::ConstMemberFunctionWrapper<T, C>(map),
-         reduce,
-         options)
-        .startBlocking();
-}
-
-template <typename Iterator, typename T, typename U, typename V, typename W, typename X>
-W blockingMappedReduced(Iterator begin,
-                        Iterator end,
-                        T (map)(U),
-                        V (reduce)(W &, X),
-                        QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
-{
-    return QtConcurrent::startMappedReduced<T, W>
-        (begin,
-         end,
-         QtConcurrent::FunctionWrapper1<T, U>(map),
-         QtConcurrent::FunctionWrapper2<V, W &, X>(reduce),
-         options)
-        .startBlocking();
-}
-
-template <typename Iterator, typename T, typename C, typename U, typename V, typename W>
-V blockingMappedReduced(Iterator begin,
-                        Iterator end,
-                        T (C::*map)() const,
-                        U (reduce)(V &, W),
-                        QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
-{
-    return QtConcurrent::startMappedReduced<T, V>
-        (begin,
-         end,
-         QtConcurrent::ConstMemberFunctionWrapper<T, C>(map),
-         QtConcurrent::FunctionWrapper2<U, V &, W>(reduce),
-         options)
-        .startBlocking();
-}
-
-template <typename Iterator, typename T, typename U, typename V, typename C, typename W>
-C blockingMappedReduced(Iterator begin,
-                        Iterator end,
-                        T (map)(U),
-                        V (C::*reduce)(W),
-                        QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
-{
-    return QtConcurrent::startMappedReduced<T, C>
-        (begin,
-         end,
-         QtConcurrent::FunctionWrapper1<T, U>(map),
-         QtConcurrent::MemberFunctionWrapper1<V, C, W>(reduce),
-         options)
-        .startBlocking();
-}
-
-template <typename Iterator, typename T, typename C, typename U,typename D, typename V>
-D blockingMappedReduced(Iterator begin,
-                        Iterator end,
-                        T (C::*map)() const,
-                        U (D::*reduce)(V),
-                        QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
-{
-    return QtConcurrent::startMappedReduced<T, D>
-        (begin,
-         end,
-         QtConcurrent::ConstMemberFunctionWrapper<T, C>(map),
-         QtConcurrent::MemberFunctionWrapper1<U, D, V>(reduce),
+    return QtConcurrent::startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
+        (begin, end,
+         QtPrivate::createFunctionWrapper(map),
+         QtPrivate::createFunctionWrapper(reduce),
          options)
         .startBlocking();
 }
@@ -675,97 +268,44 @@ D blockingMappedReduced(Iterator begin,
 template <typename OutputSequence, typename InputSequence, typename MapFunctor>
 OutputSequence blockingMapped(const InputSequence &sequence, MapFunctor map)
 {
-    return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
-                                 QtConcurrent::OrderedReduce);
-}
-
-template <typename OutputSequence, typename InputSequence, typename T, typename U>
-OutputSequence blockingMapped(const InputSequence &sequence, T (map)(U))
-{
-    return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
-                                 QtConcurrent::OrderedReduce);
-}
-
-template <typename OutputSequence, typename InputSequence, typename T, typename C>
-OutputSequence blockingMapped(const InputSequence &sequence, T (C::*map)() const)
-{
-    return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
-                                 QtConcurrent::OrderedReduce);
-}
-#ifndef QT_NO_TEMPLATE_TEMPLATE_PARAMETERS
-
-// overloads for changing the container value type:
-template <template <typename> class Sequence, typename MapFunctor, typename T>
-Sequence<typename MapFunctor::result_type> blockingMapped(const Sequence<T> &sequence, MapFunctor map)
-{
-    typedef Sequence<typename MapFunctor::result_type> OutputSequence;
-    return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
-                                               QtConcurrent::OrderedReduce);
-}
-
-template <template <typename> class Sequence, typename T, typename U, typename V>
-Sequence<U> blockingMapped(const Sequence<T> &sequence, U (map)(V))
-{
-    typedef Sequence<U> OutputSequence;
-    return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
-                                               QtConcurrent::OrderedReduce);
-}
-
-template <template <typename> class Sequence, typename T, typename U, typename C>
-Sequence<U> blockingMapped(const Sequence<T> &sequence, U (C::*map)() const)
-{
-    typedef Sequence<U> OutputSequence;
-    return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
-                                               QtConcurrent::OrderedReduce);
-}
-
-#endif // QT_NO_TEMPLATE_TEMPLATE_PARAMETER
-
-// overloads for changing the container value type from a QStringList:
-template <typename MapFunctor>
-QList<typename MapFunctor::result_type> blockingMapped(const QStringList &sequence, MapFunctor map)
-{
-    typedef QList<typename MapFunctor::result_type> OutputSequence;
-    return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
-                                 QtConcurrent::OrderedReduce);
-}
-
-template <typename U, typename V>
-QList<U> blockingMapped(const QStringList &sequence, U (map)(V))
-{
-    typedef QList<U> OutputSequence;
-    return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
-                                 QtConcurrent::OrderedReduce);
+    return blockingMappedReduced<OutputSequence>
+        (sequence,
+         QtPrivate::createFunctionWrapper(map),
+         &OutputSequence::push_back,
+         QtConcurrent::OrderedReduce);
 }
 
-template <typename U, typename C>
-QList<U> blockingMapped(const QStringList &sequence, U (C::*map)() const)
+template <typename MapFunctor, typename InputSequence>
+typename QtPrivate::MapResultType<InputSequence, MapFunctor>::ResultType blockingMapped(const InputSequence &sequence, MapFunctor map)
 {
-    typedef QList<U> OutputSequence;
-    return blockingMappedReduced(sequence, map, &OutputSequence::push_back,
-                                 QtConcurrent::OrderedReduce);
+    typedef typename QtPrivate::MapResultType<InputSequence, MapFunctor>::ResultType OutputSequence;
+    return blockingMappedReduced<OutputSequence>
+        (sequence,
+         QtPrivate::createFunctionWrapper(map),
+         &OutputSequence::push_back,
+         QtConcurrent::OrderedReduce);
 }
 
 // mapped()  for iterator ranges
 template <typename Sequence, typename Iterator, typename MapFunctor>
 Sequence blockingMapped(Iterator begin, Iterator end, MapFunctor map)
 {
-    return blockingMappedReduced(begin, end, map, &Sequence::push_back,
-                                 QtConcurrent::OrderedReduce);
-}
-
-template <typename Sequence, typename Iterator, typename T, typename U>
-Sequence blockingMapped(Iterator begin, Iterator end, T (map)(U))
-{
-    return blockingMappedReduced(begin, end, map, &Sequence::push_back,
-                                 QtConcurrent::OrderedReduce);
+    return blockingMappedReduced<Sequence>
+        (begin, end,
+         QtPrivate::createFunctionWrapper(map),
+         &Sequence::push_back,
+         QtConcurrent::OrderedReduce);
 }
 
-template <typename Sequence, typename Iterator, typename T, typename C>
-Sequence blockingMapped(Iterator begin, Iterator end, T (C::*map)() const)
-{
-    return blockingMappedReduced(begin, end, map, &Sequence::push_back,
-                                 QtConcurrent::OrderedReduce);
+template <typename Iterator, typename MapFunctor>
+typename QtPrivate::MapResultType<Iterator, MapFunctor>::ResultType blockingMapped(Iterator begin, Iterator end, MapFunctor map)
+{
+    typedef typename QtPrivate::MapResultType<Iterator, MapFunctor>::ResultType OutputSequence;
+    return blockingMappedReduced<OutputSequence>
+        (begin, end,
+         QtPrivate::createFunctionWrapper(map),
+         &OutputSequence::push_back,
+         QtConcurrent::OrderedReduce);
 }
 
 } // namespace QtConcurrent
diff --git a/src/corelib/global/qglobal.h b/src/corelib/global/qglobal.h
index 9434eb2..49f5f98 100644
--- a/src/corelib/global/qglobal.h
+++ b/src/corelib/global/qglobal.h
@@ -2755,7 +2755,8 @@ QT_LICENSED_MODULE(DBus)
 
 #if !(defined(Q_WS_WIN) && !defined(Q_WS_WINCE)) \
     && !(defined(Q_WS_MAC) && defined(QT_MAC_USE_COCOA)) \
-    && !(defined(Q_WS_X11) && !defined(QT_NO_FREETYPE))
+    && !(defined(Q_WS_X11) && !defined(QT_NO_FREETYPE)) \
+    && !(defined(Q_WS_QPA))
 #  define QT_NO_RAWFONT
 #endif
 
diff --git a/src/corelib/io/qfilesystemengine_unix.cpp b/src/corelib/io/qfilesystemengine_unix.cpp
index c9ebaa4..030b845 100644
--- a/src/corelib/io/qfilesystemengine_unix.cpp
+++ b/src/corelib/io/qfilesystemengine_unix.cpp
@@ -356,6 +356,7 @@ bool QFileSystemEngine::fillMetaData(const QFileSystemEntry &entry, QFileSystemM
         const QByteArray &path = entry.nativeFilePath();
         nativeFilePath = path.constData();
         nativeFilePathLength = path.size();
+        Q_UNUSED(nativeFilePathLength);
     }
 
     bool entryExists = true; // innocent until proven otherwise
@@ -638,7 +639,7 @@ QFileSystemEntry QFileSystemEngine::currentPath()
 #if defined(__GLIBC__) && !defined(PATH_MAX)
         char *currentName = ::get_current_dir_name();
         if (currentName) {
-            result = QFile::decodeName(QByteArray(currentName));
+            result = QFileSystemEntry(QByteArray(currentName), QFileSystemEntry::FromNativePath());
             ::free(currentName);
         }
 #else
diff --git a/src/corelib/io/qfilesystemengine_win.cpp b/src/corelib/io/qfilesystemengine_win.cpp
index 82c6eba..1dbc40f 100644
--- a/src/corelib/io/qfilesystemengine_win.cpp
+++ b/src/corelib/io/qfilesystemengine_win.cpp
@@ -583,6 +583,7 @@ QString QFileSystemEngine::owner(const QFileSystemEntry &entry, QAbstractFileEng
         }
     }
 #else
+    Q_UNUSED(entry);
     Q_UNUSED(own);
 #endif
     return name;
diff --git a/src/corelib/io/qprocess.cpp b/src/corelib/io/qprocess.cpp
index a45225f..c2234e9 100644
--- a/src/corelib/io/qprocess.cpp
+++ b/src/corelib/io/qprocess.cpp
@@ -143,55 +143,13 @@ QT_BEGIN_NAMESPACE
 
     \sa QProcess, QProcess::systemEnvironment(), QProcess::setProcessEnvironment()
 */
-#ifdef Q_OS_WIN
-static inline QProcessEnvironmentPrivate::Unit prepareName(const QString &name)
-{ return name.toUpper(); }
-static inline QProcessEnvironmentPrivate::Unit prepareName(const QByteArray &name)
-{ return QString::fromLocal8Bit(name).toUpper(); }
-static inline QString nameToString(const QProcessEnvironmentPrivate::Unit &name)
-{ return name; }
-static inline QProcessEnvironmentPrivate::Unit prepareValue(const QString &value)
-{ return value; }
-static inline QProcessEnvironmentPrivate::Unit prepareValue(const QByteArray &value)
-{ return QString::fromLocal8Bit(value); }
-static inline QString valueToString(const QProcessEnvironmentPrivate::Unit &value)
-{ return value; }
-static inline QByteArray valueToByteArray(const QProcessEnvironmentPrivate::Unit &value)
-{ return value.toLocal8Bit(); }
-#else
-static inline QProcessEnvironmentPrivate::Unit prepareName(const QByteArray &name)
-{ return name; }
-static inline QProcessEnvironmentPrivate::Unit prepareName(const QString &name)
-{ return name.toLocal8Bit(); }
-static inline QString nameToString(const QProcessEnvironmentPrivate::Unit &name)
-{ return QString::fromLocal8Bit(name); }
-static inline QProcessEnvironmentPrivate::Unit prepareValue(const QByteArray &value)
-{ return value; }
-static inline QProcessEnvironmentPrivate::Unit prepareValue(const QString &value)
-{ return value.toLocal8Bit(); }
-static inline QString valueToString(const QProcessEnvironmentPrivate::Unit &value)
-{ return QString::fromLocal8Bit(value); }
-static inline QByteArray valueToByteArray(const QProcessEnvironmentPrivate::Unit &value)
-{ return value; }
-#endif
-
-template<> void QSharedDataPointer<QProcessEnvironmentPrivate>::detach()
-{
-    if (d && d->ref == 1)
-        return;
-    QProcessEnvironmentPrivate *x = (d ? new QProcessEnvironmentPrivate(*d)
-                                     : new QProcessEnvironmentPrivate);
-    x->ref.ref();
-    if (d && !d->ref.deref())
-        delete d;
-    d = x;
-}
 
 QStringList QProcessEnvironmentPrivate::toList() const
 {
     QStringList result;
-    QHash<Unit, Unit>::ConstIterator it = hash.constBegin(),
-                                    end = hash.constEnd();
+    result.reserve(hash.size());
+    Hash::ConstIterator it = hash.constBegin(),
+                       end = hash.constEnd();
     for ( ; it != end; ++it) {
         QString data = nameToString(it.key());
         QString value = valueToString(it.value());
@@ -224,19 +182,27 @@ QProcessEnvironment QProcessEnvironmentPrivate::fromList(const QStringList &list
 QStringList QProcessEnvironmentPrivate::keys() const
 {
     QStringList result;
-    QHash<Unit, Unit>::ConstIterator it = hash.constBegin(),
-                                    end = hash.constEnd();
+    result.reserve(hash.size());
+    Hash::ConstIterator it = hash.constBegin(),
+                       end = hash.constEnd();
     for ( ; it != end; ++it)
         result << nameToString(it.key());
     return result;
 }
 
-void QProcessEnvironmentPrivate::insert(const Hash &h)
+void QProcessEnvironmentPrivate::insert(const QProcessEnvironmentPrivate &other)
 {
-    QHash<Unit, Unit>::ConstIterator it = h.constBegin(),
-                                    end = h.constEnd();
+    Hash::ConstIterator it = other.hash.constBegin(),
+                       end = other.hash.constEnd();
     for ( ; it != end; ++it)
         hash.insert(it.key(), it.value());
+
+#ifdef Q_OS_UNIX
+    QHash<QString, Key>::ConstIterator nit = other.nameMap.constBegin(),
+                                      nend = other.nameMap.constEnd();
+    for ( ; nit != nend; ++nit)
+        nameMap.insert(nit.key(), nit.value());
+#endif
 }
 
 /*!
@@ -317,6 +283,8 @@ void QProcessEnvironment::clear()
 {
     if (d)
         d->hash.clear();
+    // Unix: Don't clear d->nameMap, as the environment is likely to be
+    // re-populated with the same keys again.
 }
 
 /*!
@@ -331,7 +299,7 @@ void QProcessEnvironment::clear()
 */
 bool QProcessEnvironment::contains(const QString &name) const
 {
-    return d ? d->hash.contains(prepareName(name)) : false;
+    return d ? d->hash.contains(d->prepareName(name)) : false;
 }
 
 /*!
@@ -353,7 +321,7 @@ bool QProcessEnvironment::contains(const QString &name) const
 void QProcessEnvironment::insert(const QString &name, const QString &value)
 {
     // d detaches from null
-    d->hash.insert(prepareName(name), prepareValue(value));
+    d->hash.insert(d->prepareName(name), d->prepareValue(value));
 }
 
 /*!
@@ -370,7 +338,7 @@ void QProcessEnvironment::insert(const QString &name, const QString &value)
 void QProcessEnvironment::remove(const QString &name)
 {
     if (d)
-        d->hash.remove(prepareName(name));
+        d->hash.remove(d->prepareName(name));
 }
 
 /*!
@@ -389,11 +357,11 @@ QString QProcessEnvironment::value(const QString &name, const QString &defaultVa
     if (!d)
         return defaultValue;
 
-    QProcessEnvironmentPrivate::Hash::ConstIterator it = d->hash.constFind(prepareName(name));
+    QProcessEnvironmentPrivate::Hash::ConstIterator it = d->hash.constFind(d->prepareName(name));
     if (it == d->hash.constEnd())
         return defaultValue;
 
-    return valueToString(it.value());
+    return d->valueToString(it.value());
 }
 
 /*!
@@ -438,7 +406,7 @@ void QProcessEnvironment::insert(const QProcessEnvironment &e)
         return;
 
     // d detaches from null
-    d->insert(e.d->hash);
+    d->insert(*e.d);
 }
 
 void QProcessPrivate::Channel::clear()
@@ -2321,6 +2289,8 @@ QStringList QProcess::systemEnvironment()
 }
 
 /*!
+    \fn QProcessEnvironment QProcessEnvironment::systemEnvironment()
+
     \since 4.6
 
     \brief The systemEnvironment function returns the environment of
@@ -2336,21 +2306,6 @@ QStringList QProcess::systemEnvironment()
 
     \sa QProcess::systemEnvironment()
 */
-QProcessEnvironment QProcessEnvironment::systemEnvironment()
-{
-    QProcessEnvironment env;
-    const char *entry;
-    for (int count = 0; (entry = environ[count]); ++count) {
-        const char *equal = strchr(entry, '=');
-        if (!equal)
-            continue;
-
-        QByteArray name(entry, equal - entry);
-        QByteArray value(equal + 1);
-        env.insert(QString::fromLocal8Bit(name), QString::fromLocal8Bit(value));
-    }
-    return env;
-}
 
 /*!
     \typedef Q_PID
diff --git a/src/corelib/io/qprocess_p.h b/src/corelib/io/qprocess_p.h
index 7bfcb31..54d4936 100644
--- a/src/corelib/io/qprocess_p.h
+++ b/src/corelib/io/qprocess_p.h
@@ -81,23 +81,119 @@ class QTimer;
 class RProcess;
 #endif
 
+#ifdef Q_OS_WIN
+class QProcEnvKey : public QString
+{
+public:
+    QProcEnvKey() {}
+    explicit QProcEnvKey(const QString &other) : QString(other) {}
+    QProcEnvKey(const QProcEnvKey &other) : QString(other) {}
+    bool operator==(const QProcEnvKey &other) const { return !compare(other, Qt::CaseInsensitive); }
+};
+inline uint qHash(const QProcEnvKey &key) { return qHash(key.toCaseFolded()); }
+
+typedef QString QProcEnvValue;
+#else
+class QProcEnvKey
+{
+public:
+    QProcEnvKey() : hash(0) {}
+    explicit QProcEnvKey(const QByteArray &other) : key(other), hash(qHash(key)) {}
+    QProcEnvKey(const QProcEnvKey &other) { *this = other; }
+    bool operator==(const QProcEnvKey &other) const { return key == other.key; }
+
+    QByteArray key;
+    uint hash;
+};
+inline uint qHash(const QProcEnvKey &key) { return key.hash; }
+
+class QProcEnvValue
+{
+public:
+    QProcEnvValue() {}
+    QProcEnvValue(const QProcEnvValue &other) { *this = other; }
+    explicit QProcEnvValue(const QString &value) : stringValue(value) {}
+    explicit QProcEnvValue(const QByteArray &value) : byteValue(value) {}
+    bool operator==(const QProcEnvValue &other) const
+    {
+        return byteValue.isEmpty() && other.byteValue.isEmpty()
+                ? stringValue == other.stringValue
+                : bytes() == other.bytes();
+    }
+    QByteArray bytes() const
+    {
+        if (byteValue.isEmpty() && !stringValue.isEmpty())
+            byteValue = stringValue.toLocal8Bit();
+        return byteValue;
+    }
+    QString string() const
+    {
+        if (stringValue.isEmpty() && !byteValue.isEmpty())
+            stringValue = QString::fromLocal8Bit(byteValue);
+        return stringValue;
+    }
+
+    mutable QByteArray byteValue;
+    mutable QString stringValue;
+};
+Q_DECLARE_TYPEINFO(QProcEnvValue, Q_MOVABLE_TYPE);
+#endif
+Q_DECLARE_TYPEINFO(QProcEnvKey, Q_MOVABLE_TYPE);
+
 class QProcessEnvironmentPrivate: public QSharedData
 {
 public:
+    typedef QProcEnvKey Key;
+    typedef QProcEnvValue Value;
 #ifdef Q_OS_WIN
-    typedef QString Unit;
+    inline Key prepareName(const QString &name) const { return Key(name); }
+    inline QString nameToString(const Key &name) const { return name; }
+    inline Value prepareValue(const QString &value) const { return value; }
+    inline QString valueToString(const Value &value) const { return value; }
 #else
-    typedef QByteArray Unit;
+    inline Key prepareName(const QString &name) const
+    {
+        Key &ent = nameMap[name];
+        if (ent.key.isEmpty())
+            ent = Key(name.toLocal8Bit());
+        return ent;
+    }
+    inline QString nameToString(const Key &name) const
+    {
+        const QString sname = QString::fromLocal8Bit(name.key);
+        nameMap[sname] = name;
+        return sname;
+    }
+    inline Value prepareValue(const QString &value) const { return Value(value); }
+    inline QString valueToString(const Value &value) const { return value.string(); }
 #endif
-    typedef QHash<Unit, Unit> Hash;
+
+    typedef QHash<Key, Value> Hash;
     Hash hash;
 
+#ifdef Q_OS_UNIX
+    typedef QHash<QString, Key> NameHash;
+    mutable NameHash nameMap;
+#endif
+
     static QProcessEnvironment fromList(const QStringList &list);
     QStringList toList() const;
     QStringList keys() const;
-    void insert(const Hash &hash);
+    void insert(const QProcessEnvironmentPrivate &other);
 };
 
+template<> Q_INLINE_TEMPLATE void QSharedDataPointer<QProcessEnvironmentPrivate>::detach()
+{
+    if (d && d->ref == 1)
+        return;
+    QProcessEnvironmentPrivate *x = (d ? new QProcessEnvironmentPrivate(*d)
+                                     : new QProcessEnvironmentPrivate);
+    x->ref.ref();
+    if (d && !d->ref.deref())
+        delete d;
+    d = x;
+}
+
 class QProcessPrivate : public QIODevicePrivate
 {
 public:
diff --git a/src/corelib/io/qprocess_unix.cpp b/src/corelib/io/qprocess_unix.cpp
index 3af9b46..a3c589f 100644
--- a/src/corelib/io/qprocess_unix.cpp
+++ b/src/corelib/io/qprocess_unix.cpp
@@ -453,7 +453,36 @@ bool QProcessPrivate::createChannel(Channel &channel)
     }
 }
 
-static char **_q_dupEnvironment(const QHash<QByteArray, QByteArray> &environment, int *envc)
+QT_BEGIN_INCLUDE_NAMESPACE
+#if defined(Q_OS_MAC) && !defined(QT_NO_CORESERVICES)
+# include <crt_externs.h>
+# define environ (*_NSGetEnviron())
+#elif defined(Q_OS_SYMBIAN) || (defined(Q_OS_MAC) && defined(QT_NO_CORESERVICES))
+  static char *qt_empty_environ[] = { 0 };
+#define environ qt_empty_environ
+#else
+  extern char **environ;
+#endif
+QT_END_INCLUDE_NAMESPACE
+
+QProcessEnvironment QProcessEnvironment::systemEnvironment()
+{
+    QProcessEnvironment env;
+    const char *entry;
+    for (int count = 0; (entry = environ[count]); ++count) {
+        const char *equal = strchr(entry, '=');
+        if (!equal)
+            continue;
+
+        QByteArray name(entry, equal - entry);
+        QByteArray value(equal + 1);
+        env.d->hash.insert(QProcessEnvironmentPrivate::Key(name),
+                           QProcessEnvironmentPrivate::Value(value));
+    }
+    return env;
+}
+
+static char **_q_dupEnvironment(const QProcessEnvironmentPrivate::Hash &environment, int *envc)
 {
     *envc = 0;
     if (environment.isEmpty())
@@ -469,17 +498,17 @@ static char **_q_dupEnvironment(const QHash<QByteArray, QByteArray> &environment
 #endif
     const QByteArray envLibraryPath = qgetenv(libraryPath);
     bool needToAddLibraryPath = !envLibraryPath.isEmpty() &&
-                                !environment.contains(libraryPath);
+                                !environment.contains(QProcessEnvironmentPrivate::Key(QByteArray(libraryPath)));
 
     char **envp = new char *[environment.count() + 2];
     envp[environment.count()] = 0;
     envp[environment.count() + 1] = 0;
 
-    QHash<QByteArray, QByteArray>::ConstIterator it = environment.constBegin();
-    const QHash<QByteArray, QByteArray>::ConstIterator end = environment.constEnd();
+    QProcessEnvironmentPrivate::Hash::ConstIterator it = environment.constBegin();
+    const QProcessEnvironmentPrivate::Hash::ConstIterator end = environment.constEnd();
     for ( ; it != end; ++it) {
-        QByteArray key = it.key();
-        QByteArray value = it.value();
+        QByteArray key = it.key().key;
+        QByteArray value = it.value().bytes();
         key.reserve(key.length() + 1 + value.length());
         key.append('=');
         key.append(value);
diff --git a/src/corelib/io/qprocess_win.cpp b/src/corelib/io/qprocess_win.cpp
index 625ed98..bb23954 100644
--- a/src/corelib/io/qprocess_win.cpp
+++ b/src/corelib/io/qprocess_win.cpp
@@ -278,29 +278,55 @@ static QString qt_create_commandline(const QString &program, const QStringList &
     return args;
 }
 
-static QByteArray qt_create_environment(const QHash<QString, QString> &environment)
+QProcessEnvironment QProcessEnvironment::systemEnvironment()
+{
+    QProcessEnvironment env;
+#if !defined(Q_OS_WINCE)
+    // Calls to setenv() affect the low-level environment as well.
+    // This is not the case the other way round.
+    if (wchar_t *envStrings = GetEnvironmentStringsW()) {
+        for (const wchar_t *entry = envStrings; *entry; ) {
+            int entryLen = wcslen(entry);
+            if (const wchar_t *equal = wcschr(entry, L'=')) {
+                int nameLen = equal - entry;
+                QString name = QString::fromWCharArray(entry, nameLen);
+                QString value = QString::fromWCharArray(equal + 1, entryLen - nameLen - 1);
+                env.d->hash.insert(QProcessEnvironmentPrivate::Key(name), value);
+            }
+            entry += entryLen + 1;
+        }
+        FreeEnvironmentStringsW(envStrings);
+    }
+#endif
+    return env;
+}
+
+#if !defined(Q_OS_WINCE)
+static QByteArray qt_create_environment(const QProcessEnvironmentPrivate::Hash &environment)
 {
     QByteArray envlist;
     if (!environment.isEmpty()) {
-        QHash<QString, QString> copy = environment;
+        QProcessEnvironmentPrivate::Hash copy = environment;
 
         // add PATH if necessary (for DLL loading)
-        if (!copy.contains(QLatin1String("PATH"))) {
+        QProcessEnvironmentPrivate::Key pathKey(QLatin1String("PATH"));
+        if (!copy.contains(pathKey)) {
             QByteArray path = qgetenv("PATH");
             if (!path.isEmpty())
-                copy.insert(QLatin1String("PATH"), QString::fromLocal8Bit(path));
+                copy.insert(pathKey, QString::fromLocal8Bit(path));
         }
 
         // add systemroot if needed
-        if (!copy.contains(QLatin1String("SYSTEMROOT"))) {
-            QByteArray systemRoot = qgetenv("SYSTEMROOT");
+        QProcessEnvironmentPrivate::Key rootKey(QLatin1String("SystemRoot"));
+        if (!copy.contains(rootKey)) {
+            QByteArray systemRoot = qgetenv("SystemRoot");
             if (!systemRoot.isEmpty())
-                copy.insert(QLatin1String("SYSTEMROOT"), QString::fromLocal8Bit(systemRoot));
+                copy.insert(rootKey, QString::fromLocal8Bit(systemRoot));
         }
 
         int pos = 0;
-        QHash<QString, QString>::ConstIterator it = copy.constBegin(),
-                                              end = copy.constEnd();
+        QProcessEnvironmentPrivate::Hash::ConstIterator it = copy.constBegin(),
+                                                       end = copy.constEnd();
 
         static const wchar_t equal = L'=';
         static const wchar_t nul = L'\0';
@@ -335,6 +361,7 @@ static QByteArray qt_create_environment(const QHash<QString, QString> &environme
     }
     return envlist;
 }
+#endif
 
 void QProcessPrivate::startProcess()
 {
diff --git a/src/corelib/io/qsettings.cpp b/src/corelib/io/qsettings.cpp
index b084ca5..f43fb31 100644
--- a/src/corelib/io/qsettings.cpp
+++ b/src/corelib/io/qsettings.cpp
@@ -981,23 +981,6 @@ QStringList QSettingsPrivate::splitArgs(const QString &s, int idx)
 // ************************************************************************
 // QConfFileSettingsPrivate
 
-/*
-    If we don't have the permission to read the file, returns false.
-    If the file doesn't exist, returns true.
-*/
-static bool checkAccess(const QString &name)
-{
-    QFileInfo fileInfo(name);
-
-    if (fileInfo.exists()) {
-        QFile file(name);
-        // if the file exists but we can't open it, report an error
-        return file.open(QFile::ReadOnly);
-    } else {
-        return true;
-    }
-}
-
 void QConfFileSettingsPrivate::initFormat()
 {
     extension = (format == QSettings::NativeFormat) ? QLatin1String(".conf") : QLatin1String(".ini");
@@ -1026,18 +1009,13 @@ void QConfFileSettingsPrivate::initFormat()
 
 void QConfFileSettingsPrivate::initAccess()
 {
-    bool readAccess = false;
     if (confFiles[spec]) {
-        readAccess = checkAccess(confFiles[spec]->name);
         if (format > QSettings::IniFormat) {
             if (!readFunc)
-                readAccess = false;
+                setStatus(QSettings::AccessError);
         }
     }
 
-    if (!readAccess)
-        setStatus(QSettings::AccessError);
-
     sync();       // loads the files the first time
 }
 
@@ -1432,7 +1410,7 @@ void QConfFileSettingsPrivate::syncConfFile(int confFileNo)
         We can often optimize the read-only case, if the file on disk
         hasn't changed.
     */
-    if (readOnly) {
+    if (readOnly && confFile->size > 0) {
         QFileInfo fileInfo(confFile->name);
         if (confFile->size == fileInfo.size() && confFile->timeStamp == fileInfo.lastModified())
             return;
@@ -1455,6 +1433,9 @@ void QConfFileSettingsPrivate::syncConfFile(int confFileNo)
     if (!file.isOpen())
         file.open(QFile::ReadOnly);
 
+    if (!createFile && !file.isOpen())
+        setStatus(QSettings::AccessError);
+
 #ifdef Q_OS_WIN
     HANDLE readSemaphore = 0;
     HANDLE writeSemaphore = 0;
diff --git a/src/corelib/kernel/qabstractitemmodel.h b/src/corelib/kernel/qabstractitemmodel.h
index 6de3bf5..7bed3a2 100644
--- a/src/corelib/kernel/qabstractitemmodel.h
+++ b/src/corelib/kernel/qabstractitemmodel.h
@@ -162,6 +162,7 @@ class Q_CORE_EXPORT QAbstractItemModel : public QObject
 
     friend class QPersistentModelIndexData;
     friend class QAbstractItemViewPrivate;
+    friend class QIdentityProxyModel;
 public:
 
     explicit QAbstractItemModel(QObject *parent = 0);
diff --git a/src/corelib/kernel/qcoreapplication.cpp b/src/corelib/kernel/qcoreapplication.cpp
index be86c58..c0b1748 100644
--- a/src/corelib/kernel/qcoreapplication.cpp
+++ b/src/corelib/kernel/qcoreapplication.cpp
@@ -270,6 +270,17 @@ bool QCoreApplicationPrivate::is_app_closing = false;
 Q_CORE_EXPORT bool qt_locale_initialized = false;
 
 
+/*
+  Create an instance of Trolltech.conf. This ensures that the settings will not
+  be thrown out of QSetting's cache for unused settings.
+  */
+Q_GLOBAL_STATIC_WITH_ARGS(QSettings, staticTrolltechConf, (QSettings::UserScope, QLatin1String("Trolltech")))
+
+QSettings *QCoreApplicationPrivate::trolltechConf()
+{
+    return staticTrolltechConf();
+}
+
 Q_CORE_EXPORT uint qGlobalPostedEventsCount()
 {
     QThreadData *currentThreadData = QThreadData::current();
diff --git a/src/corelib/kernel/qcoreapplication_p.h b/src/corelib/kernel/qcoreapplication_p.h
index add2a35..eb46ae5 100644
--- a/src/corelib/kernel/qcoreapplication_p.h
+++ b/src/corelib/kernel/qcoreapplication_p.h
@@ -55,6 +55,7 @@
 
 #include "QtCore/qcoreapplication.h"
 #include "QtCore/qtranslator.h"
+#include "QtCore/qsettings.h"
 #include "private/qobject_p.h"
 
 #ifdef Q_OS_SYMBIAN
@@ -139,6 +140,7 @@ public:
 #if defined(QT3_SUPPORT)
     static bool useQt3Support;
 #endif
+    static QSettings *trolltechConf();
 };
 
 QT_END_NAMESPACE
diff --git a/src/corelib/plugin/qlibrary.cpp b/src/corelib/plugin/qlibrary.cpp
index 80e927b..d9aac00 100644
--- a/src/corelib/plugin/qlibrary.cpp
+++ b/src/corelib/plugin/qlibrary.cpp
@@ -52,6 +52,7 @@
 #include <qmap.h>
 #include <qsettings.h>
 #include <qdatetime.h>
+#include <private/qcoreapplication_p.h>
 #ifdef Q_OS_MAC
 #  include <private/qcore_mac_p.h>
 #endif
@@ -408,12 +409,6 @@ static bool qt_unix_query(const QString &library, uint *version, bool *debug, QB
 typedef QMap<QString, QLibraryPrivate*> LibraryMap;
 
 struct LibraryData {
-    LibraryData() : settings(0) { }
-    ~LibraryData() {
-        delete settings;
-    }
-
-    QSettings *settings;
     LibraryMap libraryMap;
     QSet<QLibraryPrivate*> loadedLibs;
 };
@@ -711,11 +706,7 @@ bool QLibraryPrivate::isPlugin(QSettings *settings)
     QStringList reg;
 #ifndef QT_NO_SETTINGS
     if (!settings) {
-        settings = libraryData()->settings;
-        if (!settings) {
-            settings = new QSettings(QSettings::UserScope, QLatin1String("Trolltech"));
-            libraryData()->settings = settings;
-        }
+        settings = QCoreApplicationPrivate::trolltechConf();
     }
     reg = settings->value(regkey).toStringList();
 #endif
diff --git a/src/corelib/thread/qmutex_unix.cpp b/src/corelib/thread/qmutex_unix.cpp
index 11e2060..b584ae5 100644
--- a/src/corelib/thread/qmutex_unix.cpp
+++ b/src/corelib/thread/qmutex_unix.cpp
@@ -107,18 +107,21 @@ bool QMutexPrivate::wait(int timeout)
         // lock acquired without waiting
         return true;
     }
-    bool returnValue;
+    kern_return_t r;
     if (timeout < 0) {
-        returnValue = semaphore_wait(mach_semaphore) == KERN_SUCCESS;
+        do {
+            r = semaphore_wait(mach_semaphore);
+        } while (r == KERN_ABORTED);
+	if (r != KERN_SUCCESS)
+            qWarning("QMutex: infinite wait failed, error %d", r);
     } else {
         mach_timespec_t ts;
         ts.tv_nsec = ((timeout % 1000) * 1000) * 1000;
         ts.tv_sec = (timeout / 1000);
-        kern_return_t r = semaphore_timedwait(mach_semaphore, ts);
-        returnValue = r == KERN_SUCCESS;
+        r = semaphore_timedwait(mach_semaphore, ts);
     }
     contenders.deref();
-    return returnValue;
+    return r == KERN_SUCCESS;
 }
 
 void QMutexPrivate::wakeUp()
diff --git a/src/corelib/thread/qthread_win.cpp b/src/corelib/thread/qthread_win.cpp
index bab6cf8..bdade1d 100644
--- a/src/corelib/thread/qthread_win.cpp
+++ b/src/corelib/thread/qthread_win.cpp
@@ -300,7 +300,7 @@ void QThreadPrivate::createEventDispatcher(QThreadData *data)
 
 #ifndef QT_NO_THREAD
 
-unsigned int __stdcall QThreadPrivate::start(void *arg)
+unsigned int __stdcall QT_ENSURE_STACK_ALIGNED_FOR_SSE QThreadPrivate::start(void *arg)
 {
     QThread *thr = reinterpret_cast<QThread *>(arg);
     QThreadData *data = QThreadData::get2(thr);
diff --git a/src/corelib/tools/qdatetime.cpp b/src/corelib/tools/qdatetime.cpp
index a3a8884..d9a054a 100644
--- a/src/corelib/tools/qdatetime.cpp
+++ b/src/corelib/tools/qdatetime.cpp
@@ -2460,7 +2460,11 @@ void QDateTime::setTime_t(uint secsSince1Jan1970UTC)
 
     If the \a format is Qt::ISODate, the string format corresponds
     to the ISO 8601 extended specification for representations of
-    dates and times, taking the form YYYY-MM-DDTHH:MM:SS.
+    dates and times, taking the form YYYY-MM-DDTHH:MM:SS[Z|[+|-]HH:MM],
+    depending on the timeSpec() of the QDateTime. If the timeSpec()
+    is Qt::UTC, Z will be appended to the string; if the timeSpec() is
+    Qt::OffsetFromUTC the offset in hours and minutes from UTC will
+    be appended to the string.
 
     If the \a format is Qt::SystemLocaleShortDate or
     Qt::SystemLocaleLongDate, the string format depends on the locale
@@ -2497,6 +2501,21 @@ QString QDateTime::toString(Qt::DateFormat f) const
             return QString();   // failed to convert
         buf += QLatin1Char('T');
         buf += d->time.toString(Qt::ISODate);
+        switch (d->spec) {
+        case QDateTimePrivate::UTC:
+            buf += QLatin1Char('Z');
+            break;
+        case QDateTimePrivate::OffsetFromUTC: {
+            int sign = d->utcOffset >= 0 ? 1: -1;
+            buf += QString::fromLatin1("%1%2:%3").
+                arg(sign == 1 ? QLatin1Char('+') : QLatin1Char('-')).
+                arg(d->utcOffset * sign / SECS_PER_HOUR, 2, 10, QLatin1Char('0')).
+                arg((d->utcOffset / 60) % 60, 2, 10, QLatin1Char('0'));
+            break;
+        }
+        default:
+            break;
+        }
     }
 #ifndef QT_NO_TEXTDATE
     else if (f == Qt::TextDate) {
diff --git a/src/corelib/tools/qlocale.cpp b/src/corelib/tools/qlocale.cpp
index 5c4085a..c8ed94b 100644
--- a/src/corelib/tools/qlocale.cpp
+++ b/src/corelib/tools/qlocale.cpp
@@ -2782,8 +2782,6 @@ bool QLocalePrivate::numberToCLocale(const QString &num,
     if (idx == l)
         return false;
 
-    const QChar _group = group();
-
     while (idx < l) {
         const QChar &in = uc[idx];
 
diff --git a/src/corelib/tools/qlocale_symbian.cpp b/src/corelib/tools/qlocale_symbian.cpp
index 09d74d0..5dca7b7 100644
--- a/src/corelib/tools/qlocale_symbian.cpp
+++ b/src/corelib/tools/qlocale_symbian.cpp
@@ -44,6 +44,7 @@
 #include <QTime>
 #include <QVariant>
 #include <QThread>
+#include <QStringList>
 
 #include <e32std.h>
 #include <e32const.h>
@@ -86,6 +87,7 @@ static TPtrC defaultFormatSpec(TExtendedLocale&)
 struct symbianToISO {
     int symbian_language;
     char iso_name[8];
+    char uilanguage[8];
 };
 
 
@@ -94,77 +96,80 @@ struct symbianToISO {
   NOTE: This array should be sorted by the first column!
 */
 static const symbianToISO symbian_to_iso_list[] = {
-    { ELangEnglish,             "en_GB" },  // 1
-    { ELangFrench,              "fr_FR" },  // 2
-    { ELangGerman,              "de_DE" },  // 3
-    { ELangSpanish,             "es_ES" },  // 4
-    { ELangItalian,             "it_IT" },  // 5
-    { ELangSwedish,             "sv_SE" },  // 6
-    { ELangDanish,              "da_DK" },  // 7
-    { ELangNorwegian,           "no_NO" },  // 8
-    { ELangFinnish,             "fi_FI" },  // 9
-    { ELangAmerican,            "en_US" },  // 10
-    { ELangPortuguese,          "pt_PT" },  // 13
-    { ELangTurkish,             "tr_TR" },  // 14
-    { ELangIcelandic,           "is_IS" },  // 15
-    { ELangRussian,             "ru_RU" },  // 16
-    { ELangHungarian,           "hu_HU" },  // 17
-    { ELangDutch,               "nl_NL" },  // 18
-    { ELangBelgianFlemish,      "nl_BE" },  // 19
-    { ELangCzech,               "cs_CZ" },  // 25
-    { ELangSlovak,              "sk_SK" },  // 26
-    { ELangPolish,              "pl_PL" },  // 27
-    { ELangSlovenian,           "sl_SI" },  // 28
-    { ELangTaiwanChinese,       "zh_TW" },  // 29
-    { ELangHongKongChinese,     "zh_HK" },  // 30
-    { ELangPrcChinese,          "zh_CN" },  // 31
-    { ELangJapanese,            "ja_JP" },  // 32
-    { ELangThai,                "th_TH" },  // 33
-    { ELangArabic,              "ar_AE" },  // 37
-    { ELangTagalog,             "tl_PH" },  // 39
-    { ELangBulgarian,           "bg_BG" },  // 42
-    { ELangCatalan,             "ca_ES" },  // 44
-    { ELangCroatian,            "hr_HR" },  // 45
-    { ELangEstonian,            "et_EE" },  // 49
-    { ELangFarsi,               "fa_IR" },  // 50
-    { ELangCanadianFrench,      "fr_CA" },  // 51
-    { ELangGreek,               "el_GR" },  // 54
-    { ELangHebrew,              "he_IL" },  // 57
-    { ELangHindi,               "hi_IN" },  // 58
-    { ELangIndonesian,          "id_ID" },  // 59
-    { ELangKorean,              "ko_KO" },  // 65
-    { ELangLatvian,             "lv_LV" },  // 67
-    { ELangLithuanian,          "lt_LT" },  // 68
-    { ELangMalay,               "ms_MY" },  // 70
-    { ELangNorwegianNynorsk,    "nn_NO" },  // 75
-    { ELangBrazilianPortuguese, "pt_BR" },  // 76
-    { ELangRomanian,            "ro_RO" },  // 78
-    { ELangSerbian,             "sr_RS" },  // 79
-    { ELangLatinAmericanSpanish,"es_419" }, // 83
-    { ELangUkrainian,           "uk_UA" },  // 93
-    { ELangUrdu,                "ur_PK" },  // 94 - India/Pakistan
-    { ELangVietnamese,          "vi_VN" },  // 96
+    { ELangEnglish,             "en_GB", "en" },    // 1
+    { ELangFrench,              "fr_FR", "fr" },    // 2
+    { ELangGerman,              "de_DE", "de" },    // 3
+    { ELangSpanish,             "es_ES", "es" },    // 4
+    { ELangItalian,             "it_IT", "it" },    // 5
+    { ELangSwedish,             "sv_SE", "sv" },    // 6
+    { ELangDanish,              "da_DK", "da" },    // 7
+    { ELangNorwegian,           "nb_NO", "nb" },    // 8
+    { ELangFinnish,             "fi_FI", "fi" },    // 9
+    { ELangAmerican,            "en_US", "en-US" }, // 10
+    { ELangPortuguese,          "pt_PT", "pt" },    // 13
+    { ELangTurkish,             "tr_TR", "tr" },    // 14
+    { ELangIcelandic,           "is_IS", "is" },    // 15
+    { ELangRussian,             "ru_RU", "ru" },    // 16
+    { ELangHungarian,           "hu_HU", "hu" },    // 17
+    { ELangDutch,               "nl_NL", "nl" },    // 18
+    { ELangCzech,               "cs_CZ", "cs" },    // 25
+    { ELangSlovak,              "sk_SK", "sk" },    // 26
+    { ELangPolish,              "pl_PL", "pl" },    // 27
+    { ELangSlovenian,           "sl_SI", "sl" },    // 28
+    { ELangTaiwanChinese,       "zh_TW", "zh-TW" }, // 29
+    { ELangHongKongChinese,     "zh_HK", "zh-HK" }, // 30
+    { ELangPrcChinese,          "zh_CN", "zh" },    // 31
+    { ELangJapanese,            "ja_JP", "ja" },    // 32
+    { ELangThai,                "th_TH", "th" },    // 33
+    { ELangArabic,              "ar_AE", "ar" },    // 37
+    { ELangTagalog,             "tl_PH", "tl" },    // 39
+    { ELangBulgarian,           "bg_BG", "bg" },    // 42
+    { ELangCatalan,             "ca_ES", "ca" },    // 44
+    { ELangCroatian,            "hr_HR", "hr" },    // 45
+    { ELangEstonian,            "et_EE", "et" },    // 49
+    { ELangFarsi,               "fa_IR", "fa" },    // 50
+    { ELangCanadianFrench,      "fr_CA", "fr-CA" }, // 51
+    { ELangGreek,               "el_GR", "el" },    // 54
+    { ELangHebrew,              "he_IL", "he" },    // 57
+    { ELangHindi,               "hi_IN", "hi" },    // 58
+    { ELangIndonesian,          "id_ID", "id" },    // 59
+    { 63/*ELangKazakh*/,        "kk_KZ", "kk" },    // 63
+    { ELangKorean,              "ko_KO", "ko" },    // 65
+    { ELangLatvian,             "lv_LV", "lv" },    // 67
+    { ELangLithuanian,          "lt_LT", "lt" },    // 68
+    { ELangMalay,               "ms_MY", "ms" },    // 70
+    { ELangNorwegianNynorsk,    "nn_NO", "nn" },    // 75
+    { ELangBrazilianPortuguese, "pt_BR", "pt-BR" }, // 76
+    { ELangRomanian,            "ro_RO", "ro" },    // 78
+    { ELangSerbian,             "sr_RS", "sr" },    // 79
+    { ELangLatinAmericanSpanish,"es_419", "es-419" },// 83
+    { ELangUkrainian,           "uk_UA", "uk" },    // 93
+    { ELangUrdu,                "ur_PK", "ur" },    // 94 - India/Pakistan
+    { ELangVietnamese,          "vi_VN", "vi" },    // 96
 #ifdef __E32LANG_H__
 // 5.0
-    { ELangBasque,              "eu_ES" },  // 102
-    { ELangGalician,            "gl_ES" },  // 103
+    { ELangBasque,              "eu_ES", "eu" },    // 102
+    { ELangGalician,            "gl_ES", "gl" },    // 103
 #endif
 #if !defined(__SERIES60_31__)
-    { ELangEnglish_Apac,        "en" },     // 129
-    { ELangEnglish_Taiwan,      "en_TW" },  // 157 ### Not supported by CLDR
-    { ELangEnglish_HongKong,    "en_HK" },  // 158
-    { ELangEnglish_Prc,         "en_CN" },  // 159 ### Not supported by CLDR
-    { ELangEnglish_Japan,       "en_JP"},   // 160 ### Not supported by CLDR
-    { ELangEnglish_Thailand,    "en_TH" },  // 161 ### Not supported by CLDR
-    { ELangMalay_Apac,          "ms" },     // 326
+    { ELangEnglish_Apac,        "en_GB", "en" },     // 129
+    { ELangEnglish_Taiwan,      "en_TW", "en-TW" },  // 157 ### Not supported by CLDR
+    { ELangEnglish_HongKong,    "en_HK", "en-HK" },  // 158
+    { ELangEnglish_Prc,         "en_CN", "en-CN" },  // 159 ### Not supported by CLDR
+    { ELangEnglish_Japan,       "en_JP", "en" },     // 160 ### Not supported by CLDR
+    { ELangEnglish_Thailand,    "en_TH", "en" },     // 161 ### Not supported by CLDR
+    { 230/*ELangEnglish_India*/,"en_IN", "en" },     // 230
+    { ELangMalay_Apac,          "ms_MY", "ms" },     // 326
 #endif
-    { 327/*ELangIndonesian_Apac*/,"id_ID" } // 327 - appeared in Symbian^3
+    { 327/*ELangIndonesian_Apac*/, "id_ID", "id" }   // 327 - appeared in Symbian^3
 };
 
-/*!
-    Returns ISO name corresponding to the Symbian locale code \a sys_fmt.
-*/
-QByteArray qt_symbianLocaleName(int code)
+enum LocaleNameType {
+    ISO,
+    UILanguage
+};
+
+QByteArray qt_resolveSymbianLocaleName(int code, LocaleNameType type)
 {
     //Number of Symbian to ISO locale mappings
     static const int symbian_to_iso_count
@@ -174,8 +179,11 @@ QByteArray qt_symbianLocaleName(int code)
     if (cmp < 0)
         return 0;
 
-    if (cmp == 0)
-        return symbian_to_iso_list[0].iso_name;
+    if (cmp == 0) {
+        if (type == ISO)
+            return symbian_to_iso_list[0].iso_name;
+        return symbian_to_iso_list[0].uilanguage;
+    }
 
     int begin = 0;
     int end = symbian_to_iso_count;
@@ -185,17 +193,27 @@ QByteArray qt_symbianLocaleName(int code)
 
         const symbianToISO *elt = symbian_to_iso_list + mid;
         int cmp = code - elt->symbian_language;
-        if (cmp < 0)
+        if (cmp < 0) {
             end = mid;
-        else if (cmp > 0)
+        } else if (cmp > 0) {
             begin = mid;
-        else
-            return elt->iso_name;
+        } else {
+            if (type == ISO)
+                return elt->iso_name;
+            return elt->uilanguage;
+        }
     }
 
     return 0;
 }
 
+/*!
+    Returns ISO name corresponding to the Symbian locale code \a sys_fmt.
+*/
+QByteArray qt_symbianLocaleName(int code)
+{
+    return qt_resolveSymbianLocaleName(code, ISO);
+}
 
 // order is: normal, abbr, nmode, nmode+abbr
 static const char *us_locale_dep[] = {
@@ -822,6 +840,13 @@ QLocale QSystemLocale::fallbackLocale() const
     return QLocale(locale);
 }
 
+static QStringList symbianUILanguages()
+{
+    TLanguage lang = User::Language();
+    QString s = QLatin1String(qt_resolveSymbianLocaleName(lang, UILanguage));
+    return QStringList(s);
+}
+
 QVariant QSystemLocale::query(QueryType type, QVariant in = QVariant()) const
 {
     switch(type) {
@@ -889,6 +914,8 @@ QVariant QSystemLocale::query(QueryType type, QVariant in = QVariant()) const
             return qt_TDes2QString(TAmPmName(TAmPm(EAm)));
         case PMText:
             return qt_TDes2QString(TAmPmName(TAmPm(EPm)));
+        case UILanguages:
+            return QVariant(symbianUILanguages());
         default:
             break;
     }
diff --git a/src/corelib/tools/qstring.h b/src/corelib/tools/qstring.h
index 66cfa74..6418a8c 100644
--- a/src/corelib/tools/qstring.h
+++ b/src/corelib/tools/qstring.h
@@ -695,9 +695,9 @@ inline QString::QString(const QLatin1String &aLatin1) : d(fromLatin1_helper(aLat
 inline int QString::length() const
 { return d->size; }
 inline const QChar QString::at(int i) const
-{ Q_ASSERT(i >= 0 && i < size()); return d->data[i]; }
+{ Q_ASSERT(uint(i) < uint(size())); return d->data[i]; }
 inline const QChar QString::operator[](int i) const
-{ Q_ASSERT(i >= 0 && i < size()); return d->data[i]; }
+{ Q_ASSERT(uint(i) < uint(size())); return d->data[i]; }
 inline const QChar QString::operator[](uint i) const
 { Q_ASSERT(i < uint(size())); return d->data[i]; }
 inline bool QString::isEmpty() const
diff --git a/src/corelib/tools/qtextboundaryfinder.cpp b/src/corelib/tools/qtextboundaryfinder.cpp
index 34bc406..47319d4 100644
--- a/src/corelib/tools/qtextboundaryfinder.cpp
+++ b/src/corelib/tools/qtextboundaryfinder.cpp
@@ -199,11 +199,11 @@ QTextBoundaryFinder &QTextBoundaryFinder::operator=(const QTextBoundaryFinder &o
     chars = other.chars;
     length = other.length;
     pos = other.pos;
-    freePrivate = true;
 
     QTextBoundaryFinderPrivate *newD = (QTextBoundaryFinderPrivate *)
-        realloc(d, length*sizeof(HB_CharAttributes));
+        realloc(freePrivate ? d : 0, length*sizeof(HB_CharAttributes));
     Q_CHECK_PTR(newD);
+    freePrivate = true;
     d = newD;
     memcpy(d, other.d, length*sizeof(HB_CharAttributes));
 
diff --git a/src/declarative/debugger/qdeclarativedebug.cpp b/src/declarative/debugger/qdeclarativedebug.cpp
index 62eb8fe..049e05e 100644
--- a/src/declarative/debugger/qdeclarativedebug.cpp
+++ b/src/declarative/debugger/qdeclarativedebug.cpp
@@ -84,6 +84,7 @@ public:
     static void remove(QDeclarativeEngineDebug *, QDeclarativeDebugRootContextQuery *);
     static void remove(QDeclarativeEngineDebug *, QDeclarativeDebugObjectQuery *);
     static void remove(QDeclarativeEngineDebug *, QDeclarativeDebugExpressionQuery *);
+    static void remove(QDeclarativeEngineDebug *, QDeclarativeDebugWatch *);
 
     QHash<int, QDeclarativeDebugEnginesQuery *> enginesQuery;
     QHash<int, QDeclarativeDebugRootContextQuery *> rootContextQuery;
@@ -120,6 +121,41 @@ QDeclarativeEngineDebugPrivate::~QDeclarativeEngineDebugPrivate()
 {
     if (client)
         client->priv = 0;
+    delete client;
+
+    QHash<int, QDeclarativeDebugEnginesQuery*>::iterator enginesIter = enginesQuery.begin();
+    for (; enginesIter != enginesQuery.end(); ++enginesIter) {
+        enginesIter.value()->m_client = 0;
+        if (enginesIter.value()->state() == QDeclarativeDebugQuery::Waiting)
+            enginesIter.value()->setState(QDeclarativeDebugQuery::Error);
+    }
+
+    QHash<int, QDeclarativeDebugRootContextQuery*>::iterator rootContextIter = rootContextQuery.begin();
+    for (; rootContextIter != rootContextQuery.end(); ++rootContextIter) {
+        rootContextIter.value()->m_client = 0;
+        if (rootContextIter.value()->state() == QDeclarativeDebugQuery::Waiting)
+            rootContextIter.value()->setState(QDeclarativeDebugQuery::Error);
+    }
+
+    QHash<int, QDeclarativeDebugObjectQuery*>::iterator objectIter = objectQuery.begin();
+    for (; objectIter != objectQuery.end(); ++objectIter) {
+        objectIter.value()->m_client = 0;
+        if (objectIter.value()->state() == QDeclarativeDebugQuery::Waiting)
+            objectIter.value()->setState(QDeclarativeDebugQuery::Error);
+    }
+
+    QHash<int, QDeclarativeDebugExpressionQuery*>::iterator exprIter = expressionQuery.begin();
+    for (; exprIter != expressionQuery.end(); ++exprIter) {
+        exprIter.value()->m_client = 0;
+        if (exprIter.value()->state() == QDeclarativeDebugQuery::Waiting)
+            exprIter.value()->setState(QDeclarativeDebugQuery::Error);
+    }
+
+    QHash<int, QDeclarativeDebugWatch*>::iterator watchIter = watched.begin();
+    for (; watchIter != watched.end(); ++watchIter) {
+        watchIter.value()->m_client = 0;
+        watchIter.value()->setState(QDeclarativeDebugWatch::Dead);
+    }
 }
 
 int QDeclarativeEngineDebugPrivate::getId()
@@ -160,6 +196,14 @@ void QDeclarativeEngineDebugPrivate::remove(QDeclarativeEngineDebug *c, QDeclara
     }
 }
 
+void QDeclarativeEngineDebugPrivate::remove(QDeclarativeEngineDebug *c, QDeclarativeDebugWatch *w)
+{
+    if (c && w) {
+        QDeclarativeEngineDebugPrivate *p = (QDeclarativeEngineDebugPrivate *)QObjectPrivate::get(c);
+        p->watched.remove(w->m_queryId);
+    }
+}
+
 void QDeclarativeEngineDebugPrivate::decode(QDataStream &ds, QDeclarativeDebugObjectReference &o,
                                    bool simple)
 {
@@ -647,6 +691,8 @@ QDeclarativeDebugWatch::QDeclarativeDebugWatch(QObject *parent)
 
 QDeclarativeDebugWatch::~QDeclarativeDebugWatch()
 {
+    if (m_client && m_queryId != -1)
+        QDeclarativeEngineDebugPrivate::remove(m_client, this);
 }
 
 int QDeclarativeDebugWatch::queryId() const
diff --git a/src/declarative/debugger/qdeclarativedebugserver.cpp b/src/declarative/debugger/qdeclarativedebugserver.cpp
index c7bdcb6..5112af0 100644
--- a/src/declarative/debugger/qdeclarativedebugserver.cpp
+++ b/src/declarative/debugger/qdeclarativedebugserver.cpp
@@ -116,6 +116,7 @@ void QDeclarativeDebugServerPrivate::advertisePlugins()
 QDeclarativeDebugServerConnection *QDeclarativeDebugServerPrivate::loadConnectionPlugin(
     const QString &pluginName)
 {
+#ifndef QT_NO_LIBRARY
     QStringList pluginCandidates;
     const QStringList paths = QCoreApplication::libraryPaths();
     foreach (const QString &libPath, paths) {
@@ -142,6 +143,7 @@ QDeclarativeDebugServerConnection *QDeclarativeDebugServerPrivate::loadConnectio
             return connection;
         loader.unload();
     }
+#endif
     return 0;
 }
 
diff --git a/src/declarative/graphicsitems/qdeclarativetextedit.cpp b/src/declarative/graphicsitems/qdeclarativetextedit.cpp
index af2c8f3..ca78593 100644
--- a/src/declarative/graphicsitems/qdeclarativetextedit.cpp
+++ b/src/declarative/graphicsitems/qdeclarativetextedit.cpp
@@ -273,7 +273,6 @@ void QDeclarativeTextEdit::setText(const QString &text)
     \o TextEdit.AutoText
     \o TextEdit.PlainText
     \o TextEdit.RichText
-    \o TextEdit.StyledText
     \endlist
 
     The default is TextEdit.AutoText.  If the text format is TextEdit.AutoText the text edit
diff --git a/src/declarative/graphicsitems/qdeclarativetextinput.cpp b/src/declarative/graphicsitems/qdeclarativetextinput.cpp
index 9a91769..4500a87 100644
--- a/src/declarative/graphicsitems/qdeclarativetextinput.cpp
+++ b/src/declarative/graphicsitems/qdeclarativetextinput.cpp
@@ -1876,6 +1876,7 @@ bool QDeclarativeTextInput::isInputMethodComposing() const
 void QDeclarativeTextInputPrivate::init()
 {
     Q_Q(QDeclarativeTextInput);
+    control->setParent(q);
     control->setCursorWidth(1);
     control->setPasswordCharacter(QLatin1Char('*'));
     q->setSmooth(smooth);
diff --git a/src/declarative/graphicsitems/qdeclarativetextinput_p_p.h b/src/declarative/graphicsitems/qdeclarativetextinput_p_p.h
index f6f6bd8..7595b36 100644
--- a/src/declarative/graphicsitems/qdeclarativetextinput_p_p.h
+++ b/src/declarative/graphicsitems/qdeclarativetextinput_p_p.h
@@ -70,7 +70,7 @@ class Q_AUTOTEST_EXPORT QDeclarativeTextInputPrivate : public QDeclarativeImplic
 {
     Q_DECLARE_PUBLIC(QDeclarativeTextInput)
 public:
-    QDeclarativeTextInputPrivate() : control(new QLineControl(QString())),
+    QDeclarativeTextInputPrivate() : control(new QLineControl),
                  color((QRgb)0), style(QDeclarativeText::Normal),
                  styleColor((QRgb)0), hAlign(QDeclarativeTextInput::AlignLeft),
                  mouseSelectionMode(QDeclarativeTextInput::SelectCharacters), inputMethodHints(Qt::ImhNone),
@@ -89,7 +89,6 @@ public:
 
     ~QDeclarativeTextInputPrivate()
     {
-        delete control;
     }
 
     int xToPos(int x, QTextLine::CursorPosition betweenOrOn = QTextLine::CursorBetweenCharacters) const
diff --git a/src/declarative/graphicsitems/qdeclarativevisualitemmodel.cpp b/src/declarative/graphicsitems/qdeclarativevisualitemmodel.cpp
index 97ce059..4c839a1 100644
--- a/src/declarative/graphicsitems/qdeclarativevisualitemmodel.cpp
+++ b/src/declarative/graphicsitems/qdeclarativevisualitemmodel.cpp
@@ -1398,7 +1398,12 @@ void QDeclarativeVisualDataModel::_q_layoutChanged()
 
 void QDeclarativeVisualDataModel::_q_modelReset()
 {
+    Q_D(QDeclarativeVisualDataModel);
+    d->m_root = QModelIndex();
     emit modelReset();
+    emit rootIndexChanged();
+    if (d->m_abstractItemModel && d->m_abstractItemModel->canFetchMore(d->m_root))
+        d->m_abstractItemModel->fetchMore(d->m_root);
 }
 
 void QDeclarativeVisualDataModel::_q_createdPackage(int index, QDeclarativePackage *package)
diff --git a/src/declarative/qml/qdeclarativeobjectscriptclass.cpp b/src/declarative/qml/qdeclarativeobjectscriptclass.cpp
index 9eecc65..edc1755 100644
--- a/src/declarative/qml/qdeclarativeobjectscriptclass.cpp
+++ b/src/declarative/qml/qdeclarativeobjectscriptclass.cpp
@@ -403,6 +403,33 @@ void QDeclarativeObjectScriptClass::setProperty(QObject *obj,
     } else if (value.isFunction() && !value.isRegExp()) {
         // this is handled by the binding creation above
     } else {
+        //### expand optimization for other known types
+        if (lastData->propType == QMetaType::Int && value.isNumber()) {
+            int rawValue = qRound(value.toNumber());
+            int status = -1;
+            int flags = 0;
+            void *a[] = { (void *)&rawValue, 0, &status, &flags };
+            QMetaObject::metacall(obj, QMetaObject::WriteProperty,
+                                  lastData->coreIndex, a);
+            return;
+        } else if (lastData->propType == QMetaType::QReal && value.isNumber()) {
+            qreal rawValue = qreal(value.toNumber());
+            int status = -1;
+            int flags = 0;
+            void *a[] = { (void *)&rawValue, 0, &status, &flags };
+            QMetaObject::metacall(obj, QMetaObject::WriteProperty,
+                                  lastData->coreIndex, a);
+            return;
+        } else if (lastData->propType == QMetaType::QString && value.isString()) {
+            const QString &rawValue = value.toString();
+            int status = -1;
+            int flags = 0;
+            void *a[] = { (void *)&rawValue, 0, &status, &flags };
+            QMetaObject::metacall(obj, QMetaObject::WriteProperty,
+                                  lastData->coreIndex, a);
+            return;
+        }
+
         QVariant v;
         if (lastData->flags & QDeclarativePropertyCache::Data::IsQList)
             v = enginePriv->scriptValueToVariant(value, qMetaTypeId<QList<QObject *> >());
diff --git a/src/declarative/qml/qmetaobjectbuilder.cpp b/src/declarative/qml/qmetaobjectbuilder.cpp
index dc941e2..a63656b 100644
--- a/src/declarative/qml/qmetaobjectbuilder.cpp
+++ b/src/declarative/qml/qmetaobjectbuilder.cpp
@@ -101,7 +101,7 @@ bool isVariantType(const char* type)
     return qvariant_nameToType(type) != 0;
 }
 
-// copied from qmetaobject.cpp
+// copied from qmetaobject_p.h
 // do not touch without touching the moc as well
 enum PropertyFlags  {
     Invalid = 0x00000000,
@@ -111,6 +111,8 @@ enum PropertyFlags  {
     EnumOrFlag = 0x00000008,
     StdCppSet = 0x00000100,
 //    Override = 0x00000200,
+    Constant = 0x00000400,
+    Final = 0x00000800,
     Designable = 0x00001000,
     ResolveDesignable = 0x00002000,
     Scriptable = 0x00004000,
@@ -618,6 +620,8 @@ QMetaPropertyBuilder QMetaObjectBuilder::addProperty(const QMetaProperty& protot
     property.setUser(prototype.isUser());
     property.setStdCppSet(prototype.hasStdCppSet());
     property.setEnumOrFlag(prototype.isEnumType());
+    property.setConstant(prototype.isConstant());
+    property.setFinal(prototype.isFinal());
     if (prototype.hasNotifySignal()) {
         // Find an existing method for the notify signal, or add a new one.
         QMetaMethod method = prototype.notifySignal();
@@ -2278,6 +2282,32 @@ bool QMetaPropertyBuilder::isEnumOrFlag() const
 }
 
 /*!
+    Returns true if the property is constant; otherwise returns false.
+    The default value is false.
+*/
+bool QMetaPropertyBuilder::isConstant() const
+{
+    QMetaPropertyBuilderPrivate *d = d_func();
+    if (d)
+        return d->flag(Constant);
+    else
+        return false;
+}
+
+/*!
+    Returns true if the property is final; otherwise returns false.
+    The default value is false.
+*/
+bool QMetaPropertyBuilder::isFinal() const
+{
+    QMetaPropertyBuilderPrivate *d = d_func();
+    if (d)
+        return d->flag(Final);
+    else
+        return false;
+}
+
+/*!
     Sets this property to readable if \a value is true.
 
     \sa isReadable(), setWritable()
@@ -2401,6 +2431,31 @@ void QMetaPropertyBuilder::setEnumOrFlag(bool value)
 }
 
 /*!
+    Sets the \c CONSTANT flag on this property to \a value.
+
+    \sa isConstant()
+*/
+void QMetaPropertyBuilder::setConstant(bool value)
+{
+    QMetaPropertyBuilderPrivate *d = d_func();
+    if (d)
+        d->setFlag(Constant, value);
+}
+
+/*!
+    Sets the \c FINAL flag on this property to \a value.
+
+    \sa isFinal()
+*/
+void QMetaPropertyBuilder::setFinal(bool value)
+{
+    QMetaPropertyBuilderPrivate *d = d_func();
+    if (d)
+        d->setFlag(Final, value);
+}
+
+
+/*!
     \class QMetaEnumBuilder
     \internal
     \brief The QMetaEnumBuilder class enables modifications to an enumerator definition on a meta object builder.
diff --git a/src/declarative/qml/qmetaobjectbuilder_p.h b/src/declarative/qml/qmetaobjectbuilder_p.h
index d7085f8..335a825 100644
--- a/src/declarative/qml/qmetaobjectbuilder_p.h
+++ b/src/declarative/qml/qmetaobjectbuilder_p.h
@@ -258,6 +258,8 @@ public:
     bool isUser() const;
     bool hasStdCppSet() const;
     bool isEnumOrFlag() const;
+    bool isConstant() const;
+    bool isFinal() const;
 
     void setReadable(bool value);
     void setWritable(bool value);
@@ -269,6 +271,8 @@ public:
     void setUser(bool value);
     void setStdCppSet(bool value);
     void setEnumOrFlag(bool value);
+    void setConstant(bool value);
+    void setFinal(bool value);
 
 private:
     const QMetaObjectBuilder *_mobj;
diff --git a/src/gui/accessible/qaccessible.h b/src/gui/accessible/qaccessible.h
index c714173..1e9e55e 100644
--- a/src/gui/accessible/qaccessible.h
+++ b/src/gui/accessible/qaccessible.h
@@ -83,6 +83,42 @@ public:
 
         MenuCommand          = 0x0018,
 
+        // Values from IAccessible2
+        ActionChanged        = 0x0101,
+        ActiveDescendantChanged,
+        AttributeChanged,
+        DocumentContentChanged,
+        DocumentLoadComplete,
+        DocumentLoadStopped,
+        DocumentReload,
+        HyperlinkEndIndexChanged,
+        HyperlinkNumberOfAnchorsChanged,
+        HyperlinkSelectedLinkChanged,
+        HypertextLinkActivated,
+        HypertextLinkSelected,
+        HyperlinkStartIndexChanged,
+        HypertextChanged,
+        HypertextNLinksChanged,
+        ObjectAttributeChanged,
+        PageChanged,
+        SectionChanged,
+        TableCaptionChanged,
+        TableColumnDescriptionChanged,
+        TableColumnHeaderChanged,
+        TableModelChanged,
+        TableRowDescriptionChanged,
+        TableRowHeaderChanged,
+        TableSummaryChanged,
+        TextAttributeChanged,
+        TextCaretMoved,
+        // TextChanged, deprecated, use TextUpdated
+        TextColumnChanged = TextCaretMoved + 2,
+        TextInserted,
+        TextRemoved,
+        TextUpdated,
+        TextSelectionChanged,
+        VisibleDataChanged,
+
         ObjectCreated        = 0x8000,
         ObjectDestroyed      = 0x8001,
         ObjectShow           = 0x8002,
diff --git a/src/gui/accessible/qaccessibleobject.cpp b/src/gui/accessible/qaccessibleobject.cpp
index 1d2d1da..0cb2c08 100644
--- a/src/gui/accessible/qaccessibleobject.cpp
+++ b/src/gui/accessible/qaccessibleobject.cpp
@@ -322,9 +322,7 @@ QString QAccessibleApplication::text(Text t, int) const
 {
     switch (t) {
     case Name:
-        if (QApplication::activeWindow())
-            return QApplication::activeWindow()->windowTitle();
-        break;
+        return QApplication::applicationName();
     case Description:
         return QApplication::applicationFilePath();
     default:
diff --git a/src/gui/dialogs/qcolordialog_mac.mm b/src/gui/dialogs/qcolordialog_mac.mm
index ee9b19a..9daf595 100644
--- a/src/gui/dialogs/qcolordialog_mac.mm
+++ b/src/gui/dialogs/qcolordialog_mac.mm
@@ -343,6 +343,7 @@ QT_USE_NAMESPACE
     mDialogIsExecuting = true;
     bool modalEnded = false;
     while (!modalEnded) {
+#ifndef QT_NO_EXCEPTIONS
         @try {
             [NSApp runModalForWindow:mColorPanel];
             modalEnded = true;
@@ -351,6 +352,10 @@ QT_USE_NAMESPACE
             // clicking on 'SelectedMenuItemColor' from the 'Developer'
             // palette (tab three).
         }
+#else
+        [NSApp runModalForWindow:mColorPanel];
+        modalEnded = true;
+#endif
     }
 
     QAbstractEventDispatcher::instance()->interrupt();
diff --git a/src/gui/dialogs/qfilesystemmodel.cpp b/src/gui/dialogs/qfilesystemmodel.cpp
index cb8eb6a..ff4410d 100644
--- a/src/gui/dialogs/qfilesystemmodel.cpp
+++ b/src/gui/dialogs/qfilesystemmodel.cpp
@@ -1977,13 +1977,14 @@ bool QFileSystemModelPrivate::filtersAcceptsNode(const QFileSystemNode *node) co
     const bool hideHidden        = !(filters & QDir::Hidden);
     const bool hideSystem        = !(filters & QDir::System);
     const bool hideSymlinks      = (filters & QDir::NoSymLinks);
-    const bool hideDotAndDotDot  = (filters & QDir::NoDotAndDotDot);
+    const bool hideDot           = (filters & QDir::NoDot) || (filters & QDir::NoDotAndDotDot); // ### Qt5: simplify (because NoDotAndDotDot=NoDot|NoDotDot)
+    const bool hideDotDot        = (filters & QDir::NoDotDot) || (filters & QDir::NoDotAndDotDot); // ### Qt5: simplify (because NoDotAndDotDot=NoDot|NoDotDot)
 
     // Note that we match the behavior of entryList and not QFileInfo on this and this
     // incompatibility won't be fixed until Qt 5 at least
-    bool isDotOrDot = (  (node->fileName == QLatin1String(".")
-                       || node->fileName == QLatin1String("..")));
-    if (   (hideHidden && (!isDotOrDot && node->isHidden()))
+    bool isDot    = (node->fileName == QLatin1String("."));
+    bool isDotDot = (node->fileName == QLatin1String(".."));
+    if (   (hideHidden && !(isDot || isDotDot) && node->isHidden())
         || (hideSystem && node->isSystem())
         || (hideDirs && node->isDir())
         || (hideFiles && node->isFile())
@@ -1991,7 +1992,8 @@ bool QFileSystemModelPrivate::filtersAcceptsNode(const QFileSystemNode *node) co
         || (hideReadable && node->isReadable())
         || (hideWritable && node->isWritable())
         || (hideExecutable && node->isExecutable())
-        || (hideDotAndDotDot && isDotOrDot))
+        || (hideDot && isDot)
+        || (hideDotDot && isDotDot))
         return false;
 
     return nameFilterDisables || passNameFilters(node);
diff --git a/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp b/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp
index 48cbec3..78918cc 100644
--- a/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp
+++ b/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp
@@ -451,8 +451,8 @@ static QPair<QGraphicsAnchorLayoutPrivate::Interval, qreal> getFactor(qreal valu
 static qreal interpolate(const QPair<QGraphicsAnchorLayoutPrivate::Interval, qreal> &factor,
                          qreal min, qreal minPref, qreal pref, qreal maxPref, qreal max)
 {
-    qreal lower;
-    qreal upper;
+    qreal lower = 0;
+    qreal upper = 0;
 
     switch (factor.first) {
     case QGraphicsAnchorLayoutPrivate::MinimumToMinPreferred:
diff --git a/src/gui/graphicsview/qgraphicslayout.cpp b/src/gui/graphicsview/qgraphicslayout.cpp
index 904a3de..a67ae48 100644
--- a/src/gui/graphicsview/qgraphicslayout.cpp
+++ b/src/gui/graphicsview/qgraphicslayout.cpp
@@ -167,7 +167,7 @@ QGraphicsLayout::QGraphicsLayout(QGraphicsLayoutItem *parent)
                     " neither a QGraphicsWidget nor QGraphicsLayout");
         }
     }
-    setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding, QSizePolicy::DefaultType);
+    d_func()->sizePolicy = QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding, QSizePolicy::DefaultType);
     setOwnedByLayout(true);
 }
 
@@ -188,7 +188,7 @@ QGraphicsLayout::QGraphicsLayout(QGraphicsLayoutPrivate &dd, QGraphicsLayoutItem
                     " neither a QGraphicsWidget nor QGraphicsLayout");
         }
     }
-    setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding, QSizePolicy::DefaultType);
+    d_func()->sizePolicy = QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding, QSizePolicy::DefaultType);
     setOwnedByLayout(true);
 }
 
@@ -269,12 +269,20 @@ void QGraphicsLayout::activate()
         return;
     Q_ASSERT(!parentItem->isLayout());
 
-    setGeometry(parentItem->contentsRect());    // relayout children
+    if (QGraphicsLayout::instantInvalidatePropagation()) {
+        QGraphicsWidget *parentWidget = static_cast<QGraphicsWidget*>(parentItem);
+        if (!parentWidget->parentLayoutItem()) {
+            // we've reached the topmost widget, resize it
+            bool wasResized = parentWidget->testAttribute(Qt::WA_Resized);
+            parentWidget->resize(parentWidget->size());
+            parentWidget->setAttribute(Qt::WA_Resized, wasResized);
+        }
 
-    // ### bug, should be parentItem ?
-    parentLayoutItem()->updateGeometry();            // bubble up; will set activated to false
-    // ### too many resizes? maybe we should walk up the chain to the
-    // ### top-level layouted layoutItem and call activate there.
+        setGeometry(parentItem->contentsRect());    // relayout children
+    } else {
+        setGeometry(parentItem->contentsRect());    // relayout children
+        parentLayoutItem()->updateGeometry();
+    }
 }
 
 /*!
@@ -300,32 +308,36 @@ bool QGraphicsLayout::isActivated() const
 */
 void QGraphicsLayout::invalidate()
 {
-    // only mark layouts as invalid (activated = false) if we can post a LayoutRequest event.
-    QGraphicsLayoutItem *layoutItem = this;
-    while (layoutItem && layoutItem->isLayout()) {
-        // we could call updateGeometry(), but what if that method
-        // does not call the base implementation? In addition, updateGeometry()
-        // does more than we need.
-        layoutItem->d_func()->sizeHintCacheDirty = true;
-        layoutItem->d_func()->sizeHintWithConstraintCacheDirty = true;
-        layoutItem = layoutItem->parentLayoutItem();
-    }
-    if (layoutItem) {
-        layoutItem->d_func()->sizeHintCacheDirty = true;
-        layoutItem->d_func()->sizeHintWithConstraintCacheDirty = true;
-    }
-
-    bool postIt = layoutItem ? !layoutItem->isLayout() : false;
-    if (postIt) {
-        layoutItem = this;
-        while (layoutItem && layoutItem->isLayout()
-                && static_cast<QGraphicsLayout*>(layoutItem)->d_func()->activated) {
-            static_cast<QGraphicsLayout*>(layoutItem)->d_func()->activated = false;
+    if (QGraphicsLayout::instantInvalidatePropagation()) {
+        updateGeometry();
+    } else {
+        // only mark layouts as invalid (activated = false) if we can post a LayoutRequest event.
+        QGraphicsLayoutItem *layoutItem = this;
+        while (layoutItem && layoutItem->isLayout()) {
+            // we could call updateGeometry(), but what if that method
+            // does not call the base implementation? In addition, updateGeometry()
+            // does more than we need.
+            layoutItem->d_func()->sizeHintCacheDirty = true;
+            layoutItem->d_func()->sizeHintWithConstraintCacheDirty = true;
             layoutItem = layoutItem->parentLayoutItem();
         }
-        if (layoutItem && !layoutItem->isLayout()) {
-            // If a layout has a parent that is not a layout it must be a QGraphicsWidget.
-            QApplication::postEvent(static_cast<QGraphicsWidget *>(layoutItem), new QEvent(QEvent::LayoutRequest));
+        if (layoutItem) {
+            layoutItem->d_func()->sizeHintCacheDirty = true;
+            layoutItem->d_func()->sizeHintWithConstraintCacheDirty = true;
+        }
+
+        bool postIt = layoutItem ? !layoutItem->isLayout() : false;
+        if (postIt) {
+            layoutItem = this;
+            while (layoutItem && layoutItem->isLayout()
+                    && static_cast<QGraphicsLayout*>(layoutItem)->d_func()->activated) {
+                static_cast<QGraphicsLayout*>(layoutItem)->d_func()->activated = false;
+                layoutItem = layoutItem->parentLayoutItem();
+            }
+            if (layoutItem && !layoutItem->isLayout()) {
+                // If a layout has a parent that is not a layout it must be a QGraphicsWidget.
+                QApplication::postEvent(static_cast<QGraphicsWidget *>(layoutItem), new QEvent(QEvent::LayoutRequest));
+            }
         }
     }
 }
@@ -335,12 +347,27 @@ void QGraphicsLayout::invalidate()
 */
 void QGraphicsLayout::updateGeometry()
 {
-    QGraphicsLayoutItem::updateGeometry();
-    if (QGraphicsLayoutItem *parentItem = parentLayoutItem()) {
-        if (parentItem->isLayout()) {
+    Q_D(QGraphicsLayout);
+    if (QGraphicsLayout::instantInvalidatePropagation()) {
+        d->activated = false;
+        QGraphicsLayoutItem::updateGeometry();
+
+        QGraphicsLayoutItem *parentItem = parentLayoutItem();
+        if (!parentItem)
+            return;
+
+        if (parentItem->isLayout())
+            static_cast<QGraphicsLayout *>(parentItem)->invalidate();
+        else
             parentItem->updateGeometry();
-        } else {
-            invalidate();
+    } else {
+        QGraphicsLayoutItem::updateGeometry();
+        if (QGraphicsLayoutItem *parentItem = parentLayoutItem()) {
+            if (parentItem->isLayout()) {
+                parentItem->updateGeometry();
+            } else {
+                invalidate();
+            }
         }
     }
 }
@@ -446,6 +473,50 @@ void QGraphicsLayout::addChildLayoutItem(QGraphicsLayoutItem *layoutItem)
     d->addChildLayoutItem(layoutItem);
 }
 
+static bool g_instantInvalidatePropagation = false;
+
+/*!
+    \internal
+    \since 4.8
+    \see instantInvalidatePropagation
+
+    Calling this function with \a enable set to true will enable a feature that
+    makes propagation of invalidation up to ancestor layout items to be done in
+    one go. It will propagate up the parentLayoutItem() hierarchy until it has
+    reached the root. If the root item is a QGraphicsWidget, it will *post* a
+    layout request to it. When the layout request is consumed it will traverse
+    down the hierarchy of layouts and widgets and activate all layouts that is
+    invalid (not activated). This is the recommended behaviour.
+
+    If not set it will also propagate up the parentLayoutItem() hierarchy, but
+    it will stop at the \i first \i widget it encounters, and post a layout
+    request to the widget. When the layout request is consumed, this might
+    cause it to continue propagation up to the parentLayoutItem() of the
+    widget. It will continue in this fashion until it has reached a widget with
+    no parentLayoutItem(). This strategy might cause drawing artifacts, since
+    it is not done in one go, and the consumption of layout requests might be
+    interleaved by consumption of paint events, which might cause significant
+    flicker.
+    Note, this is not the recommended behavior, but for compatibility reasons
+    this is the default behaviour.
+*/
+void QGraphicsLayout::setInstantInvalidatePropagation(bool enable)
+{
+    g_instantInvalidatePropagation = enable;
+}
+
+/*!
+    \internal
+    \since 4.8
+    \see setInstantInvalidatePropagation
+
+    returns true if the complete widget/layout hierarchy is rearranged in one go.
+*/
+bool QGraphicsLayout::instantInvalidatePropagation()
+{
+    return g_instantInvalidatePropagation;
+}
+
 QT_END_NAMESPACE
 
 #endif //QT_NO_GRAPHICSVIEW
diff --git a/src/gui/graphicsview/qgraphicslayout.h b/src/gui/graphicsview/qgraphicslayout.h
index c622fb8..6031174 100644
--- a/src/gui/graphicsview/qgraphicslayout.h
+++ b/src/gui/graphicsview/qgraphicslayout.h
@@ -76,6 +76,8 @@ public:
     virtual QGraphicsLayoutItem *itemAt(int i) const = 0;
     virtual void removeAt(int index) = 0;
 
+    static void setInstantInvalidatePropagation(bool enable);
+    static bool instantInvalidatePropagation();
 protected:
     QGraphicsLayout(QGraphicsLayoutPrivate &, QGraphicsLayoutItem *);
     void addChildLayoutItem(QGraphicsLayoutItem *layoutItem);
diff --git a/src/gui/graphicsview/qgraphicslayout_p.cpp b/src/gui/graphicsview/qgraphicslayout_p.cpp
index c325602..f73fb6a 100644
--- a/src/gui/graphicsview/qgraphicslayout_p.cpp
+++ b/src/gui/graphicsview/qgraphicslayout_p.cpp
@@ -180,8 +180,13 @@ void QGraphicsLayoutPrivate::activateRecursive(QGraphicsLayoutItem *item)
 {
     if (item->isLayout()) {
         QGraphicsLayout *layout = static_cast<QGraphicsLayout *>(item);
-        if (layout->d_func()->activated)
-            layout->invalidate();
+        if (layout->d_func()->activated) {
+            if (QGraphicsLayout::instantInvalidatePropagation()) {
+                return;
+            } else {
+                layout->invalidate();   // ### LOOKS SUSPICIOUSLY WRONG!!???
+            }
+        }
 
         for (int i = layout->count() - 1; i >= 0; --i) {
             QGraphicsLayoutItem *childItem = layout->itemAt(i);
diff --git a/src/gui/graphicsview/qgraphicslinearlayout.cpp b/src/gui/graphicsview/qgraphicslinearlayout.cpp
index 5591638..40f9b1d 100644
--- a/src/gui/graphicsview/qgraphicslinearlayout.cpp
+++ b/src/gui/graphicsview/qgraphicslinearlayout.cpp
@@ -275,17 +275,13 @@ void QGraphicsLinearLayout::insertItem(int index, QGraphicsLayoutItem *item)
         qWarning("QGraphicsLinearLayout::insertItem: cannot insert itself");
         return;
     }
-    Q_ASSERT(item);
-
-    //the order of the following instructions is very important because
-    //invalidating the layout before adding the child item will make the layout happen
-    //before we try to paint the item
-    invalidate();
     d->addChildLayoutItem(item);
 
+    Q_ASSERT(item);
     d->fixIndex(&index);
     d->engine.insertRow(index, d->orientation);
     new QGridLayoutItem(&d->engine, item, d->gridRow(index), d->gridColumn(index), 1, 1, 0, index);
+    invalidate();
 }
 
 /*!
diff --git a/src/gui/graphicsview/qgraphicsscenebsptreeindex.cpp b/src/gui/graphicsview/qgraphicsscenebsptreeindex.cpp
index 92e4a55..4688fa0 100644
--- a/src/gui/graphicsview/qgraphicsscenebsptreeindex.cpp
+++ b/src/gui/graphicsview/qgraphicsscenebsptreeindex.cpp
@@ -50,14 +50,14 @@
 
     QGraphicsSceneBspTreeIndex index use a BSP(Binary Space Partitioning)
     implementation to discover items quickly. This implementation is
-    very efficient for static scene. It has a depth that you can set.
+    very efficient for static scenes. It has a depth that you can set.
     The depth directly affects performance and memory usage; the latter
     growing exponentially with the depth of the tree. With an optimal tree
     depth, the index can instantly determine the locality of items, even
     for scenes with thousands or millions of items. This also greatly improves
     rendering performance.
 
-    By default, the value is 0, in which case Qt will guess a reasonable
+    By default, the depth value is 0, in which case Qt will guess a reasonable
     default depth based on the size, location and number of items in the
     scene. If these parameters change frequently, however, you may experience
     slowdowns as the index retunes the depth internally. You can avoid
diff --git a/src/gui/graphicsview/qgraphicswidget.cpp b/src/gui/graphicsview/qgraphicswidget.cpp
index 675a5c5..141e305 100644
--- a/src/gui/graphicsview/qgraphicswidget.cpp
+++ b/src/gui/graphicsview/qgraphicswidget.cpp
@@ -354,8 +354,10 @@ void QGraphicsWidget::setGeometry(const QRectF &rect)
         newGeom = rect;
         newGeom.setSize(rect.size().expandedTo(effectiveSizeHint(Qt::MinimumSize))
                                    .boundedTo(effectiveSizeHint(Qt::MaximumSize)));
-        if (newGeom == d->geom)
-            return;
+
+        if (newGeom == d->geom) {
+            goto relayoutChildrenAndReturn;
+        }
 
         // setPos triggers ItemPositionChange, which can adjust position
         wd->inSetGeometry = 1;
@@ -363,8 +365,9 @@ void QGraphicsWidget::setGeometry(const QRectF &rect)
         wd->inSetGeometry = 0;
         newGeom.moveTopLeft(pos());
 
-        if (newGeom == d->geom)
-           return;
+        if (newGeom == d->geom) {
+            goto relayoutChildrenAndReturn;
+        }
 
          // Update and prepare to change the geometry (remove from index) if the size has changed.
         if (wd->scene) {
@@ -375,35 +378,54 @@ void QGraphicsWidget::setGeometry(const QRectF &rect)
     }
 
     // Update the layout item geometry
-    bool moved = oldPos != pos();
-    if (moved) {
-        // Send move event.
-        QGraphicsSceneMoveEvent event;
-        event.setOldPos(oldPos);
-        event.setNewPos(pos());
-        QApplication::sendEvent(this, &event);
-        if (wd->inSetPos) {
-            //set the new pos
-            d->geom.moveTopLeft(pos());
-            emit geometryChanged();
-            return;
+    {
+        bool moved = oldPos != pos();
+        if (moved) {
+            // Send move event.
+            QGraphicsSceneMoveEvent event;
+            event.setOldPos(oldPos);
+            event.setNewPos(pos());
+            QApplication::sendEvent(this, &event);
+            if (wd->inSetPos) {
+                //set the new pos
+                d->geom.moveTopLeft(pos());
+                emit geometryChanged();
+                goto relayoutChildrenAndReturn;
+            }
+        }
+        QSizeF oldSize = size();
+        QGraphicsLayoutItem::setGeometry(newGeom);
+        // Send resize event
+        bool resized = newGeom.size() != oldSize;
+        if (resized) {
+            QGraphicsSceneResizeEvent re;
+            re.setOldSize(oldSize);
+            re.setNewSize(newGeom.size());
+            if (oldSize.width() != newGeom.size().width())
+                emit widthChanged();
+            if (oldSize.height() != newGeom.size().height())
+                emit heightChanged();
+            QGraphicsLayout *lay = wd->layout;
+            if (QGraphicsLayout::instantInvalidatePropagation()) {
+                if (!lay || lay->isActivated()) {
+                    QApplication::sendEvent(this, &re);
+                }
+            } else {
+                QApplication::sendEvent(this, &re);
+            }
         }
     }
-    QSizeF oldSize = size();
-    QGraphicsLayoutItem::setGeometry(newGeom);
-    // Send resize event
-    bool resized = newGeom.size() != oldSize;
-    if (resized) {
-        QGraphicsSceneResizeEvent re;
-        re.setOldSize(oldSize);
-        re.setNewSize(newGeom.size());
-        if (oldSize.width() != newGeom.size().width())
-            emit widthChanged();
-        if (oldSize.height() != newGeom.size().height())
-            emit heightChanged();
-        QApplication::sendEvent(this, &re);
-    }
+
     emit geometryChanged();
+relayoutChildrenAndReturn:
+    if (QGraphicsLayout::instantInvalidatePropagation()) {
+        if (QGraphicsLayout *lay = wd->layout) {
+            if (!lay->isActivated()) {
+                QEvent layoutRequest(QEvent::LayoutRequest);
+                QApplication::sendEvent(this, &layoutRequest);
+            }
+        }
+    }
 }
 
 /*!
@@ -1052,16 +1074,31 @@ void QGraphicsWidget::updateGeometry()
     QGraphicsLayoutItem *parentItem = parentLayoutItem();
 
     if (parentItem && parentItem->isLayout()) {
-        parentItem->updateGeometry();
+        if (QGraphicsLayout::instantInvalidatePropagation()) {
+            static_cast<QGraphicsLayout *>(parentItem)->invalidate();
+        } else {
+            parentItem->updateGeometry();
+        }
     } else {
         if (parentItem) {
+            // This is for custom layouting
             QGraphicsWidget *parentWid = parentWidget();    //###
             if (parentWid->isVisible())
                 QApplication::postEvent(parentWid, new QEvent(QEvent::LayoutRequest));
+        } else {
+            /**
+             * If this is the topmost widget, post a LayoutRequest event to the widget.
+             * When the event is received, it will start flowing all the way down to the leaf
+             * widgets in one go. This will make a relayout flicker-free.
+             */
+            if (QGraphicsLayout::instantInvalidatePropagation())
+                QApplication::postEvent(static_cast<QGraphicsWidget *>(this), new QEvent(QEvent::LayoutRequest));
+        }
+        if (!QGraphicsLayout::instantInvalidatePropagation()) {
+            bool wasResized = testAttribute(Qt::WA_Resized);
+            resize(size()); // this will restrict the size
+            setAttribute(Qt::WA_Resized, wasResized);
         }
-        bool wasResized = testAttribute(Qt::WA_Resized);
-        resize(size()); // this will restrict the size
-        setAttribute(Qt::WA_Resized, wasResized);
     }
 }
 
diff --git a/src/gui/graphicsview/qgraphicswidget_p.cpp b/src/gui/graphicsview/qgraphicswidget_p.cpp
index 4580055..63d7298 100644
--- a/src/gui/graphicsview/qgraphicswidget_p.cpp
+++ b/src/gui/graphicsview/qgraphicswidget_p.cpp
@@ -857,8 +857,6 @@ void QGraphicsWidgetPrivate::setWidth(qreal w)
     if (q->geometry().width() == w)
         return;
 
-    QRectF oldGeom = q->geometry();
-
     q->setGeometry(QRectF(q->x(), q->y(), w, height()));
 }
 
@@ -882,8 +880,6 @@ void QGraphicsWidgetPrivate::setHeight(qreal h)
     if (q->geometry().height() == h)
         return;
 
-    QRectF oldGeom = q->geometry();
-
     q->setGeometry(QRectF(q->x(), q->y(), width(), h));
 }
 
diff --git a/src/gui/image/qpixmap.cpp b/src/gui/image/qpixmap.cpp
index 34804e5..c34f6ac 100644
--- a/src/gui/image/qpixmap.cpp
+++ b/src/gui/image/qpixmap.cpp
@@ -1224,12 +1224,8 @@ Qt::HANDLE QPixmap::handle() const
 {
 #if defined(Q_WS_X11)
     const QPixmapData *pd = pixmapData();
-    if (pd) {
-        if (pd->classId() == QPixmapData::X11Class)
-            return static_cast<const QX11PixmapData*>(pd)->handle();
-        else
-            qWarning("QPixmap::handle(): Pixmap is not an X11 class pixmap");
-    }
+    if (pd && pd->classId() == QPixmapData::X11Class)
+        return static_cast<const QX11PixmapData*>(pd)->handle();
 #endif
     return 0;
 }
diff --git a/src/gui/image/qvolatileimage.cpp b/src/gui/image/qvolatileimage.cpp
index 098e9a1..f5076e1 100644
--- a/src/gui/image/qvolatileimage.cpp
+++ b/src/gui/image/qvolatileimage.cpp
@@ -103,6 +103,11 @@ QVolatileImage &QVolatileImage::operator=(const QVolatileImage &rhs)
     return *this;
 }
 
+bool QVolatileImage::paintingActive() const
+{
+    return d->pengine && d->pengine->isActive();
+}
+
 bool QVolatileImage::isNull() const
 {
     return d->image.isNull();
diff --git a/src/gui/image/qvolatileimage_p.h b/src/gui/image/qvolatileimage_p.h
index fc5d6b1..d835f45 100644
--- a/src/gui/image/qvolatileimage_p.h
+++ b/src/gui/image/qvolatileimage_p.h
@@ -71,6 +71,7 @@ public:
     ~QVolatileImage();
     QVolatileImage &operator=(const QVolatileImage &rhs);
 
+    bool paintingActive() const;
     bool isNull() const;
     QImage::Format format() const;
     int width() const;
diff --git a/src/gui/itemviews/itemviews.pri b/src/gui/itemviews/itemviews.pri
index bbc1e98..149bfd6 100644
--- a/src/gui/itemviews/itemviews.pri
+++ b/src/gui/itemviews/itemviews.pri
@@ -4,6 +4,7 @@ HEADERS += \
 	itemviews/qabstractitemview.h \
     itemviews/qabstractitemview_p.h \
 	itemviews/qheaderview.h \
+	itemviews/qidentityproxymodel.h \
 	itemviews/qlistview.h \
 	itemviews/qlistview_p.h \
 	itemviews/qbsptree_p.h \
@@ -44,6 +45,7 @@ HEADERS += \
 SOURCES += \
 	itemviews/qabstractitemview.cpp \
 	itemviews/qheaderview.cpp \
+	itemviews/qidentityproxymodel.cpp \
 	itemviews/qlistview.cpp \
 	itemviews/qbsptree.cpp \
 	itemviews/qtableview.cpp \
diff --git a/src/gui/itemviews/qabstractproxymodel.cpp b/src/gui/itemviews/qabstractproxymodel.cpp
index 34ca7df..82b6c8d 100644
--- a/src/gui/itemviews/qabstractproxymodel.cpp
+++ b/src/gui/itemviews/qabstractproxymodel.cpp
@@ -121,15 +121,12 @@ QAbstractProxyModel::~QAbstractProxyModel()
 void QAbstractProxyModel::setSourceModel(QAbstractItemModel *sourceModel)
 {
     Q_D(QAbstractProxyModel);
-    if (d->model) {
+    if (d->model)
         disconnect(d->model, SIGNAL(destroyed()), this, SLOT(_q_sourceModelDestroyed()));
-        disconnect(d->model, SIGNAL(modelReset()), this, SLOT(resetInternalData()));
-    }
 
     if (sourceModel) {
         d->model = sourceModel;
         connect(d->model, SIGNAL(destroyed()), this, SLOT(_q_sourceModelDestroyed()));
-        connect(d->model, SIGNAL(modelReset()), this, SLOT(resetInternalData()));
     } else {
         d->model = QAbstractItemModelPrivate::staticEmptyModel();
     }
@@ -383,25 +380,6 @@ Qt::DropActions QAbstractProxyModel::supportedDropActions() const
     return d->model->supportedDropActions();
 }
 
-/*
-    \since 4.8
-
-    This slot is called just after the internal data of a model is cleared
-    while it is being reset.
-
-    This slot is provided the convenience of subclasses of concrete proxy
-    models, such as subclasses of QSortFilterProxyModel which maintain extra
-    data.
-
-    \snippet doc/src/snippets/code/src_corelib_kernel_qabstractitemmodel.cpp 10
-
-    \sa modelAboutToBeReset(), modelReset()
-*/
-void QAbstractProxyModel::resetInternalData()
-{
-
-}
-
 QT_END_NAMESPACE
 
 #include "moc_qabstractproxymodel.cpp"
diff --git a/src/gui/itemviews/qabstractproxymodel.h b/src/gui/itemviews/qabstractproxymodel.h
index 6e485ae..4f3bc18 100644
--- a/src/gui/itemviews/qabstractproxymodel.h
+++ b/src/gui/itemviews/qabstractproxymodel.h
@@ -95,9 +95,6 @@ public:
     QStringList mimeTypes() const;
     Qt::DropActions supportedDropActions() const;
 
-protected Q_SLOTS:
-    void resetInternalData();
-
 protected:
     QAbstractProxyModel(QAbstractProxyModelPrivate &, QObject *parent);
 
diff --git a/src/gui/itemviews/qdatawidgetmapper.cpp b/src/gui/itemviews/qdatawidgetmapper.cpp
index 745ef5a..dac4613 100644
--- a/src/gui/itemviews/qdatawidgetmapper.cpp
+++ b/src/gui/itemviews/qdatawidgetmapper.cpp
@@ -291,7 +291,7 @@ void QDataWidgetMapperPrivate::_q_modelDestroyed()
     \snippet doc/src/snippets/code/src_gui_itemviews_qdatawidgetmapper.cpp 0
 
     After the call to toFirst(), \c mySpinBox displays the value \c{1}, \c myLineEdit
-    displays \c {Nokia Corporation and/or its subsidiary(-ies)} and \c myCountryChooser displays \c{Oslo}. The
+    displays \c{Qt Norway} and \c myCountryChooser displays \c{Oslo}. The
     navigational functions toFirst(), toNext(), toPrevious(), toLast() and setCurrentIndex()
     can be used to navigate in the model and update the widgets with contents from
     the model.
diff --git a/src/gui/itemviews/qidentityproxymodel.cpp b/src/gui/itemviews/qidentityproxymodel.cpp
new file mode 100644
index 0000000..60f7d98
--- /dev/null
+++ b/src/gui/itemviews/qidentityproxymodel.cpp
@@ -0,0 +1,587 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com, author Stephen Kelly <stephen.kelly@kdab.com>
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qidentityproxymodel.h"
+
+#ifndef QT_NO_IDENTITYPROXYMODEL
+
+#include "qitemselectionmodel.h"
+#include <private/qabstractproxymodel_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QIdentityProxyModelPrivate : public QAbstractProxyModelPrivate
+{
+  QIdentityProxyModelPrivate()
+    : ignoreNextLayoutAboutToBeChanged(false),
+      ignoreNextLayoutChanged(false)
+  {
+
+  }
+
+  Q_DECLARE_PUBLIC(QIdentityProxyModel)
+
+  bool ignoreNextLayoutAboutToBeChanged;
+  bool ignoreNextLayoutChanged;
+  QList<QPersistentModelIndex> layoutChangePersistentIndexes;
+  QModelIndexList proxyIndexes;
+
+  void _q_sourceRowsAboutToBeInserted(const QModelIndex &parent, int start, int end);
+  void _q_sourceRowsInserted(const QModelIndex &parent, int start, int end);
+  void _q_sourceRowsAboutToBeRemoved(const QModelIndex &parent, int start, int end);
+  void _q_sourceRowsRemoved(const QModelIndex &parent, int start, int end);
+  void _q_sourceRowsAboutToBeMoved(const QModelIndex &sourceParent, int sourceStart, int sourceEnd, const QModelIndex &destParent, int dest);
+  void _q_sourceRowsMoved(const QModelIndex &sourceParent, int sourceStart, int sourceEnd, const QModelIndex &destParent, int dest);
+
+  void _q_sourceColumnsAboutToBeInserted(const QModelIndex &parent, int start, int end);
+  void _q_sourceColumnsInserted(const QModelIndex &parent, int start, int end);
+  void _q_sourceColumnsAboutToBeRemoved(const QModelIndex &parent, int start, int end);
+  void _q_sourceColumnsRemoved(const QModelIndex &parent, int start, int end);
+  void _q_sourceColumnsAboutToBeMoved(const QModelIndex &sourceParent, int sourceStart, int sourceEnd, const QModelIndex &destParent, int dest);
+  void _q_sourceColumnsMoved(const QModelIndex &sourceParent, int sourceStart, int sourceEnd, const QModelIndex &destParent, int dest);
+
+  void _q_sourceDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight);
+  void _q_sourceHeaderDataChanged(Qt::Orientation orientation, int first, int last);
+
+  void _q_sourceLayoutAboutToBeChanged();
+  void _q_sourceLayoutChanged();
+  void _q_sourceModelAboutToBeReset();
+  void _q_sourceModelReset();
+
+};
+
+/*!
+    \since 4.8
+    \class QIdentityProxyModel
+    \brief The QIdentityProxyModel class proxies its source model unmodified
+
+    \ingroup model-view
+
+    QIdentityProxyModel can be used to forward the structure of a source model exactly, with no sorting, filtering or other transformation.
+    This is similar in concept to an identity matrix where A.I = A.
+
+    Because it does no sorting or filtering, this class is most suitable to proxy models which transform the data() of the source model.
+    For example, a proxy model could be created to define the font used, or the background colour, or the tooltip etc. This removes the
+    need to implement all data handling in the same class that creates the structure of the model, and can also be used to create
+    re-usable components.
+
+    This also provides a way to change the data in the case where a source model is supplied by a third party which can not be modified.
+
+    \snippet doc/src/snippets/code/src_gui_itemviews_qidentityproxymodel.cpp 0
+
+    \sa QAbstractProxyModel, {Model/View Programming}, QAbstractItemModel
+
+*/
+
+/*!
+    Constructs an identity model with the given \a parent.
+*/
+QIdentityProxyModel::QIdentityProxyModel(QObject* parent)
+  : QAbstractProxyModel(*new QIdentityProxyModelPrivate, parent)
+{
+
+}
+
+/*! \internal
+ */
+QIdentityProxyModel::QIdentityProxyModel(QIdentityProxyModelPrivate &dd, QObject* parent)
+  : QAbstractProxyModel(dd, parent)
+{
+
+}
+
+/*!
+    Destroys this identity model.
+*/
+QIdentityProxyModel::~QIdentityProxyModel()
+{
+}
+
+/*!
+    \reimp
+ */
+int QIdentityProxyModel::columnCount(const QModelIndex& parent) const
+{
+    Q_ASSERT(parent.isValid() ? parent.model() == this : true);
+    Q_D(const QIdentityProxyModel);
+    return d->model->columnCount(mapToSource(parent));
+}
+
+/*!
+    \reimp
+ */
+bool QIdentityProxyModel::dropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent)
+{
+    Q_ASSERT(parent.isValid() ? parent.model() == this : true);
+    Q_D(QIdentityProxyModel);
+    return d->model->dropMimeData(data, action, row, column, mapToSource(parent));
+}
+
+/*!
+    \reimp
+ */
+QModelIndex QIdentityProxyModel::index(int row, int column, const QModelIndex& parent) const
+{
+    Q_ASSERT(parent.isValid() ? parent.model() == this : true);
+    Q_D(const QIdentityProxyModel);
+    if (!hasIndex(row, column, parent))
+        return QModelIndex();
+    const QModelIndex sourceParent = mapToSource(parent);
+    const QModelIndex sourceIndex = d->model->index(row, column, sourceParent);
+    Q_ASSERT(sourceIndex.isValid());
+    return mapFromSource(sourceIndex);
+}
+
+/*!
+    \reimp
+ */
+bool QIdentityProxyModel::insertColumns(int column, int count, const QModelIndex& parent)
+{
+    Q_ASSERT(parent.isValid() ? parent.model() == this : true);
+    Q_D(QIdentityProxyModel);
+    return d->model->insertColumns(column, count, mapToSource(parent));
+}
+
+/*!
+    \reimp
+ */
+bool QIdentityProxyModel::insertRows(int row, int count, const QModelIndex& parent)
+{
+    Q_ASSERT(parent.isValid() ? parent.model() == this : true);
+    Q_D(QIdentityProxyModel);
+    return d->model->insertRows(row, count, mapToSource(parent));
+}
+
+/*!
+    \reimp
+ */
+QModelIndex QIdentityProxyModel::mapFromSource(const QModelIndex& sourceIndex) const
+{
+    Q_D(const QIdentityProxyModel);
+    if (!d->model || !sourceIndex.isValid())
+        return QModelIndex();
+
+    Q_ASSERT(sourceIndex.model() == d->model);
+    return createIndex(sourceIndex.row(), sourceIndex.column(), sourceIndex.internalPointer());
+}
+
+/*!
+    \reimp
+ */
+QItemSelection QIdentityProxyModel::mapSelectionFromSource(const QItemSelection& selection) const
+{
+    Q_D(const QIdentityProxyModel);
+    QItemSelection proxySelection;
+
+    if (!d->model)
+        return proxySelection;
+
+    QItemSelection::const_iterator it = selection.constBegin();
+    const QItemSelection::const_iterator end = selection.constEnd();
+    for ( ; it != end; ++it) {
+        Q_ASSERT(it->model() == d->model);
+        const QItemSelectionRange range(mapFromSource(it->topLeft()), mapFromSource(it->bottomRight()));
+        proxySelection.append(range);
+    }
+
+    return proxySelection;
+}
+
+/*!
+    \reimp
+ */
+QItemSelection QIdentityProxyModel::mapSelectionToSource(const QItemSelection& selection) const
+{
+    Q_D(const QIdentityProxyModel);
+    QItemSelection sourceSelection;
+
+    if (!d->model)
+        return sourceSelection;
+
+    QItemSelection::const_iterator it = selection.constBegin();
+    const QItemSelection::const_iterator end = selection.constEnd();
+    for ( ; it != end; ++it) {
+        Q_ASSERT(it->model() == this);
+        const QItemSelectionRange range(mapToSource(it->topLeft()), mapToSource(it->bottomRight()));
+        sourceSelection.append(range);
+    }
+
+    return sourceSelection;
+}
+
+/*!
+    \reimp
+ */
+QModelIndex QIdentityProxyModel::mapToSource(const QModelIndex& proxyIndex) const
+{
+    Q_D(const QIdentityProxyModel);
+    if (!d->model || !proxyIndex.isValid())
+        return QModelIndex();
+    Q_ASSERT(proxyIndex.model() == this);
+    return d->model->createIndex(proxyIndex.row(), proxyIndex.column(), proxyIndex.internalPointer());
+}
+
+/*!
+    \reimp
+ */
+QModelIndexList QIdentityProxyModel::match(const QModelIndex& start, int role, const QVariant& value, int hits, Qt::MatchFlags flags) const
+{
+    Q_D(const QIdentityProxyModel);
+    Q_ASSERT(start.isValid() ? start.model() == this : true);
+    if (!d->model)
+        return QModelIndexList();
+
+    const QModelIndexList sourceList = d->model->match(mapToSource(start), role, value, hits, flags);
+    QModelIndexList::const_iterator it = sourceList.constBegin();
+    const QModelIndexList::const_iterator end = sourceList.constEnd();
+    QModelIndexList proxyList;
+    for ( ; it != end; ++it)
+        proxyList.append(mapFromSource(*it));
+    return proxyList;
+}
+
+/*!
+    \reimp
+ */
+QModelIndex QIdentityProxyModel::parent(const QModelIndex& child) const
+{
+    Q_ASSERT(child.isValid() ? child.model() == this : true);
+    const QModelIndex sourceIndex = mapToSource(child);
+    const QModelIndex sourceParent = sourceIndex.parent();
+    return mapFromSource(sourceParent);
+}
+
+/*!
+    \reimp
+ */
+bool QIdentityProxyModel::removeColumns(int column, int count, const QModelIndex& parent)
+{
+    Q_ASSERT(parent.isValid() ? parent.model() == this : true);
+    Q_D(QIdentityProxyModel);
+    return d->model->removeColumns(column, count, mapToSource(parent));
+}
+
+/*!
+    \reimp
+ */
+bool QIdentityProxyModel::removeRows(int row, int count, const QModelIndex& parent)
+{
+    Q_ASSERT(parent.isValid() ? parent.model() == this : true);
+    Q_D(QIdentityProxyModel);
+    return d->model->removeRows(row, count, mapToSource(parent));
+}
+
+/*!
+    \reimp
+ */
+int QIdentityProxyModel::rowCount(const QModelIndex& parent) const
+{
+    Q_ASSERT(parent.isValid() ? parent.model() == this : true);
+    Q_D(const QIdentityProxyModel);
+    return d->model->rowCount(mapToSource(parent));
+}
+
+/*!
+    \reimp
+ */
+void QIdentityProxyModel::setSourceModel(QAbstractItemModel* sourceModel)
+{
+    beginResetModel();
+
+    if (sourceModel) {
+        disconnect(sourceModel, SIGNAL(rowsAboutToBeInserted(const QModelIndex &, int, int)),
+                   this, SLOT(_q_sourceRowsAboutToBeInserted(const QModelIndex &, int, int)));
+        disconnect(sourceModel, SIGNAL(rowsInserted(const QModelIndex &, int, int)),
+                   this, SLOT(_q_sourceRowsInserted(const QModelIndex &, int, int)));
+        disconnect(sourceModel, SIGNAL(rowsAboutToBeRemoved(const QModelIndex &, int, int)),
+                   this, SLOT(_q_sourceRowsAboutToBeRemoved(const QModelIndex &, int, int)));
+        disconnect(sourceModel, SIGNAL(rowsRemoved(const QModelIndex &, int, int)),
+                   this, SLOT(_q_sourceRowsRemoved(const QModelIndex &, int, int)));
+        disconnect(sourceModel, SIGNAL(rowsAboutToBeMoved(const QModelIndex &, int, int, const QModelIndex &, int)),
+                   this, SLOT(_q_sourceRowsAboutToBeMoved(const QModelIndex &, int, int, const QModelIndex &, int)));
+        disconnect(sourceModel, SIGNAL(rowsMoved(const QModelIndex &, int, int, const QModelIndex &, int)),
+                   this, SLOT(_q_sourceRowsMoved(const QModelIndex &, int, int, const QModelIndex &, int)));
+        disconnect(sourceModel, SIGNAL(columnsAboutToBeInserted(const QModelIndex &, int, int)),
+                   this, SLOT(_q_sourceColumnsAboutToBeInserted(const QModelIndex &, int, int)));
+        disconnect(sourceModel, SIGNAL(columnsInserted(const QModelIndex &, int, int)),
+                   this, SLOT(_q_sourceColumnsInserted(const QModelIndex &, int, int)));
+        disconnect(sourceModel, SIGNAL(columnsAboutToBeRemoved(const QModelIndex &, int, int)),
+                   this, SLOT(_q_sourceColumnsAboutToBeRemoved(const QModelIndex &, int, int)));
+        disconnect(sourceModel, SIGNAL(columnsRemoved(const QModelIndex &, int, int)),
+                   this, SLOT(_q_sourceColumnsRemoved(const QModelIndex &, int, int)));
+        disconnect(sourceModel, SIGNAL(columnsAboutToBeMoved(const QModelIndex &, int, int, const QModelIndex &, int)),
+                   this, SLOT(_q_sourceColumnsAboutToBeMoved(const QModelIndex &, int, int, const QModelIndex &, int)));
+        disconnect(sourceModel, SIGNAL(columnsMoved(const QModelIndex &, int, int, const QModelIndex &, int)),
+                   this, SLOT(_q_sourceColumnsMoved(const QModelIndex &, int, int, const QModelIndex &, int)));
+        disconnect(sourceModel, SIGNAL(modelAboutToBeReset()),
+                   this, SLOT(_q_sourceModelAboutToBeReset()));
+        disconnect(sourceModel, SIGNAL(modelReset()),
+                   this, SLOT(_q_sourceModelReset()));
+        disconnect(sourceModel, SIGNAL(dataChanged(const QModelIndex &, const QModelIndex &)),
+                   this, SLOT(_q_sourceDataChanged(const QModelIndex &, const QModelIndex &)));
+        disconnect(sourceModel, SIGNAL(headerDataChanged(Qt::Orientation,int,int)),
+                   this, SLOT(_q_sourceHeaderDataChanged(Qt::Orientation,int,int)));
+        disconnect(sourceModel, SIGNAL(layoutAboutToBeChanged()),
+                   this, SLOT(_q_sourceLayoutAboutToBeChanged()));
+        disconnect(sourceModel, SIGNAL(layoutChanged()),
+                   this, SLOT(_q_sourceLayoutChanged()));
+    }
+
+    QAbstractProxyModel::setSourceModel(sourceModel);
+
+    if (sourceModel) {
+        connect(sourceModel, SIGNAL(rowsAboutToBeInserted(const QModelIndex &, int, int)),
+                SLOT(_q_sourceRowsAboutToBeInserted(const QModelIndex &, int, int)));
+        connect(sourceModel, SIGNAL(rowsInserted(const QModelIndex &, int, int)),
+                SLOT(_q_sourceRowsInserted(const QModelIndex &, int, int)));
+        connect(sourceModel, SIGNAL(rowsAboutToBeRemoved(const QModelIndex &, int, int)),
+                SLOT(_q_sourceRowsAboutToBeRemoved(const QModelIndex &, int, int)));
+        connect(sourceModel, SIGNAL(rowsRemoved(const QModelIndex &, int, int)),
+                SLOT(_q_sourceRowsRemoved(const QModelIndex &, int, int)));
+        connect(sourceModel, SIGNAL(rowsAboutToBeMoved(const QModelIndex &, int, int, const QModelIndex &, int)),
+                SLOT(_q_sourceRowsAboutToBeMoved(const QModelIndex &, int, int, const QModelIndex &, int)));
+        connect(sourceModel, SIGNAL(rowsMoved(const QModelIndex &, int, int, const QModelIndex &, int)),
+                SLOT(_q_sourceRowsMoved(const QModelIndex &, int, int, const QModelIndex &, int)));
+        connect(sourceModel, SIGNAL(columnsAboutToBeInserted(const QModelIndex &, int, int)),
+                SLOT(_q_sourceColumnsAboutToBeInserted(const QModelIndex &, int, int)));
+        connect(sourceModel, SIGNAL(columnsInserted(const QModelIndex &, int, int)),
+                SLOT(_q_sourceColumnsInserted(const QModelIndex &, int, int)));
+        connect(sourceModel, SIGNAL(columnsAboutToBeRemoved(const QModelIndex &, int, int)),
+                SLOT(_q_sourceColumnsAboutToBeRemoved(const QModelIndex &, int, int)));
+        connect(sourceModel, SIGNAL(columnsRemoved(const QModelIndex &, int, int)),
+                SLOT(_q_sourceColumnsRemoved(const QModelIndex &, int, int)));
+        connect(sourceModel, SIGNAL(columnsAboutToBeMoved(const QModelIndex &, int, int, const QModelIndex &, int)),
+                SLOT(_q_sourceColumnsAboutToBeMoved(const QModelIndex &, int, int, const QModelIndex &, int)));
+        connect(sourceModel, SIGNAL(columnsMoved(const QModelIndex &, int, int, const QModelIndex &, int)),
+                SLOT(_q_sourceColumnsMoved(const QModelIndex &, int, int, const QModelIndex &, int)));
+        connect(sourceModel, SIGNAL(modelAboutToBeReset()),
+                SLOT(_q_sourceModelAboutToBeReset()));
+        connect(sourceModel, SIGNAL(modelReset()),
+                SLOT(_q_sourceModelReset()));
+        connect(sourceModel, SIGNAL(dataChanged(const QModelIndex &, const QModelIndex &)),
+                SLOT(_q_sourceDataChanged(const QModelIndex &, const QModelIndex &)));
+        connect(sourceModel, SIGNAL(headerDataChanged(Qt::Orientation,int,int)),
+                SLOT(_q_sourceHeaderDataChanged(Qt::Orientation,int,int)));
+        connect(sourceModel, SIGNAL(layoutAboutToBeChanged()),
+                SLOT(_q_sourceLayoutAboutToBeChanged()));
+        connect(sourceModel, SIGNAL(layoutChanged()),
+                SLOT(_q_sourceLayoutChanged()));
+    }
+
+    endResetModel();
+}
+
+void QIdentityProxyModelPrivate::_q_sourceColumnsAboutToBeInserted(const QModelIndex &parent, int start, int end)
+{
+    Q_ASSERT(parent.isValid() ? parent.model() == model : true);
+    Q_Q(QIdentityProxyModel);
+    q->beginInsertColumns(q->mapFromSource(parent), start, end);
+}
+
+void QIdentityProxyModelPrivate::_q_sourceColumnsAboutToBeMoved(const QModelIndex &sourceParent, int sourceStart, int sourceEnd, const QModelIndex &destParent, int dest)
+{
+    Q_ASSERT(sourceParent.isValid() ? sourceParent.model() == model : true);
+    Q_ASSERT(destParent.isValid() ? destParent.model() == model : true);
+    Q_Q(QIdentityProxyModel);
+    q->beginMoveColumns(q->mapFromSource(sourceParent), sourceStart, sourceEnd, q->mapFromSource(destParent), dest);
+}
+
+void QIdentityProxyModelPrivate::_q_sourceColumnsAboutToBeRemoved(const QModelIndex &parent, int start, int end)
+{
+    Q_ASSERT(parent.isValid() ? parent.model() == model : true);
+    Q_Q(QIdentityProxyModel);
+    q->beginRemoveColumns(q->mapFromSource(parent), start, end);
+}
+
+void QIdentityProxyModelPrivate::_q_sourceColumnsInserted(const QModelIndex &parent, int start, int end)
+{
+    Q_ASSERT(parent.isValid() ? parent.model() == model : true);
+    Q_Q(QIdentityProxyModel);
+    Q_UNUSED(parent)
+    Q_UNUSED(start)
+    Q_UNUSED(end)
+    q->endInsertColumns();
+}
+
+void QIdentityProxyModelPrivate::_q_sourceColumnsMoved(const QModelIndex &sourceParent, int sourceStart, int sourceEnd, const QModelIndex &destParent, int dest)
+{
+    Q_ASSERT(sourceParent.isValid() ? sourceParent.model() == model : true);
+    Q_ASSERT(destParent.isValid() ? destParent.model() == model : true);
+    Q_Q(QIdentityProxyModel);
+    Q_UNUSED(sourceParent)
+    Q_UNUSED(sourceStart)
+    Q_UNUSED(sourceEnd)
+    Q_UNUSED(destParent)
+    Q_UNUSED(dest)
+    q->endMoveColumns();
+}
+
+void QIdentityProxyModelPrivate::_q_sourceColumnsRemoved(const QModelIndex &parent, int start, int end)
+{
+    Q_ASSERT(parent.isValid() ? parent.model() == model : true);
+    Q_Q(QIdentityProxyModel);
+    Q_UNUSED(parent)
+    Q_UNUSED(start)
+    Q_UNUSED(end)
+    q->endRemoveColumns();
+}
+
+void QIdentityProxyModelPrivate::_q_sourceDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight)
+{
+    Q_ASSERT(topLeft.isValid() ? topLeft.model() == model : true);
+    Q_ASSERT(bottomRight.isValid() ? bottomRight.model() == model : true);
+    Q_Q(QIdentityProxyModel);
+    q->dataChanged(q->mapFromSource(topLeft), q->mapFromSource(bottomRight));
+}
+
+void QIdentityProxyModelPrivate::_q_sourceHeaderDataChanged(Qt::Orientation orientation, int first, int last)
+{
+    Q_Q(QIdentityProxyModel);
+    q->headerDataChanged(orientation, first, last);
+}
+
+void QIdentityProxyModelPrivate::_q_sourceLayoutAboutToBeChanged()
+{
+    if (ignoreNextLayoutAboutToBeChanged)
+        return;
+
+    Q_Q(QIdentityProxyModel);
+
+    foreach(const QPersistentModelIndex &proxyPersistentIndex, q->persistentIndexList()) {
+        proxyIndexes << proxyPersistentIndex;
+        Q_ASSERT(proxyPersistentIndex.isValid());
+        const QPersistentModelIndex srcPersistentIndex = q->mapToSource(proxyPersistentIndex);
+        Q_ASSERT(srcPersistentIndex.isValid());
+        layoutChangePersistentIndexes << srcPersistentIndex;
+    }
+
+    q->layoutAboutToBeChanged();
+}
+
+void QIdentityProxyModelPrivate::_q_sourceLayoutChanged()
+{
+    if (ignoreNextLayoutChanged)
+        return;
+
+    Q_Q(QIdentityProxyModel);
+
+    for (int i = 0; i < proxyIndexes.size(); ++i) {
+        q->changePersistentIndex(proxyIndexes.at(i), q->mapFromSource(layoutChangePersistentIndexes.at(i)));
+    }
+
+    layoutChangePersistentIndexes.clear();
+    proxyIndexes.clear();
+
+    q->layoutChanged();
+}
+
+void QIdentityProxyModelPrivate::_q_sourceModelAboutToBeReset()
+{
+    Q_Q(QIdentityProxyModel);
+    q->beginResetModel();
+}
+
+void QIdentityProxyModelPrivate::_q_sourceModelReset()
+{
+    Q_Q(QIdentityProxyModel);
+    q->endResetModel();
+}
+
+void QIdentityProxyModelPrivate::_q_sourceRowsAboutToBeInserted(const QModelIndex &parent, int start, int end)
+{
+    Q_ASSERT(parent.isValid() ? parent.model() == model : true);
+    Q_Q(QIdentityProxyModel);
+    q->beginInsertRows(q->mapFromSource(parent), start, end);
+}
+
+void QIdentityProxyModelPrivate::_q_sourceRowsAboutToBeMoved(const QModelIndex &sourceParent, int sourceStart, int sourceEnd, const QModelIndex &destParent, int dest)
+{
+    Q_ASSERT(sourceParent.isValid() ? sourceParent.model() == model : true);
+    Q_ASSERT(destParent.isValid() ? destParent.model() == model : true);
+    Q_Q(QIdentityProxyModel);
+    q->beginMoveRows(q->mapFromSource(sourceParent), sourceStart, sourceEnd, q->mapFromSource(destParent), dest);
+}
+
+void QIdentityProxyModelPrivate::_q_sourceRowsAboutToBeRemoved(const QModelIndex &parent, int start, int end)
+{
+    Q_ASSERT(parent.isValid() ? parent.model() == model : true);
+    Q_Q(QIdentityProxyModel);
+    q->beginRemoveRows(q->mapFromSource(parent), start, end);
+}
+
+void QIdentityProxyModelPrivate::_q_sourceRowsInserted(const QModelIndex &parent, int start, int end)
+{
+    Q_ASSERT(parent.isValid() ? parent.model() == model : true);
+    Q_Q(QIdentityProxyModel);
+    Q_UNUSED(parent)
+    Q_UNUSED(start)
+    Q_UNUSED(end)
+    q->endInsertRows();
+}
+
+void QIdentityProxyModelPrivate::_q_sourceRowsMoved(const QModelIndex &sourceParent, int sourceStart, int sourceEnd, const QModelIndex &destParent, int dest)
+{
+    Q_ASSERT(sourceParent.isValid() ? sourceParent.model() == model : true);
+    Q_ASSERT(destParent.isValid() ? destParent.model() == model : true);
+    Q_Q(QIdentityProxyModel);
+    Q_UNUSED(sourceParent)
+    Q_UNUSED(sourceStart)
+    Q_UNUSED(sourceEnd)
+    Q_UNUSED(destParent)
+    Q_UNUSED(dest)
+    q->endMoveRows();
+}
+
+void QIdentityProxyModelPrivate::_q_sourceRowsRemoved(const QModelIndex &parent, int start, int end)
+{
+    Q_ASSERT(parent.isValid() ? parent.model() == model : true);
+    Q_Q(QIdentityProxyModel);
+    Q_UNUSED(parent)
+    Q_UNUSED(start)
+    Q_UNUSED(end)
+    q->endRemoveRows();
+}
+
+QT_END_NAMESPACE
+
+#include "moc_qidentityproxymodel.cpp"
+
+#endif // QT_NO_IDENTITYPROXYMODEL
diff --git a/src/gui/itemviews/qidentityproxymodel.h b/src/gui/itemviews/qidentityproxymodel.h
new file mode 100644
index 0000000..4b3176a
--- /dev/null
+++ b/src/gui/itemviews/qidentityproxymodel.h
@@ -0,0 +1,120 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com, author Stephen Kelly <stephen.kelly@kdab.com>
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#ifndef QIDENTITYPROXYMODEL_H
+#define QIDENTITYPROXYMODEL_H
+
+#include <QtGui/qabstractproxymodel.h>
+
+#ifndef QT_NO_IDENTITYPROXYMODEL
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+class QIdentityProxyModelPrivate;
+
+class Q_GUI_EXPORT QIdentityProxyModel : public QAbstractProxyModel
+{
+    Q_OBJECT
+public:
+    explicit QIdentityProxyModel(QObject* parent = 0);
+    ~QIdentityProxyModel();
+
+    int columnCount(const QModelIndex& parent = QModelIndex()) const;
+    QModelIndex index(int row, int column, const QModelIndex& parent = QModelIndex()) const;
+    QModelIndex mapFromSource(const QModelIndex& sourceIndex) const;
+    QModelIndex mapToSource(const QModelIndex& proxyIndex) const;
+    QModelIndex parent(const QModelIndex& child) const;
+    int rowCount(const QModelIndex& parent = QModelIndex()) const;
+    bool dropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent);
+
+    QItemSelection mapSelectionFromSource(const QItemSelection& selection) const;
+    QItemSelection mapSelectionToSource(const QItemSelection& selection) const;
+    QModelIndexList match(const QModelIndex& start, int role, const QVariant& value, int hits = 1, Qt::MatchFlags flags = Qt::MatchFlags(Qt::MatchStartsWith|Qt::MatchWrap)) const;
+    void setSourceModel(QAbstractItemModel* sourceModel);
+
+    bool insertColumns(int column, int count, const QModelIndex& parent = QModelIndex());
+    bool insertRows(int row, int count, const QModelIndex& parent = QModelIndex());
+    bool removeColumns(int column, int count, const QModelIndex& parent = QModelIndex());
+    bool removeRows(int row, int count, const QModelIndex& parent = QModelIndex());
+
+protected:
+    QIdentityProxyModel(QIdentityProxyModelPrivate &dd, QObject* parent);
+
+private:
+    Q_DECLARE_PRIVATE(QIdentityProxyModel)
+    Q_DISABLE_COPY(QIdentityProxyModel)
+
+    Q_PRIVATE_SLOT(d_func(), void _q_sourceRowsAboutToBeInserted(QModelIndex,int,int))
+    Q_PRIVATE_SLOT(d_func(), void _q_sourceRowsInserted(QModelIndex,int,int))
+    Q_PRIVATE_SLOT(d_func(), void _q_sourceRowsAboutToBeRemoved(QModelIndex,int,int))
+    Q_PRIVATE_SLOT(d_func(), void _q_sourceRowsRemoved(QModelIndex,int,int))
+    Q_PRIVATE_SLOT(d_func(), void _q_sourceRowsAboutToBeMoved(QModelIndex,int,int,QModelIndex,int))
+    Q_PRIVATE_SLOT(d_func(), void _q_sourceRowsMoved(QModelIndex,int,int,QModelIndex,int))
+
+    Q_PRIVATE_SLOT(d_func(), void _q_sourceColumnsAboutToBeInserted(QModelIndex,int,int))
+    Q_PRIVATE_SLOT(d_func(), void _q_sourceColumnsInserted(QModelIndex,int,int))
+    Q_PRIVATE_SLOT(d_func(), void _q_sourceColumnsAboutToBeRemoved(QModelIndex,int,int))
+    Q_PRIVATE_SLOT(d_func(), void _q_sourceColumnsRemoved(QModelIndex,int,int))
+    Q_PRIVATE_SLOT(d_func(), void _q_sourceColumnsAboutToBeMoved(QModelIndex,int,int,QModelIndex,int))
+    Q_PRIVATE_SLOT(d_func(), void _q_sourceColumnsMoved(QModelIndex,int,int,QModelIndex,int))
+
+    Q_PRIVATE_SLOT(d_func(), void _q_sourceDataChanged(QModelIndex,QModelIndex))
+    Q_PRIVATE_SLOT(d_func(), void _q_sourceHeaderDataChanged(Qt::Orientation orientation, int first, int last))
+
+    Q_PRIVATE_SLOT(d_func(), void _q_sourceLayoutAboutToBeChanged())
+    Q_PRIVATE_SLOT(d_func(), void _q_sourceLayoutChanged())
+    Q_PRIVATE_SLOT(d_func(), void _q_sourceModelAboutToBeReset())
+    Q_PRIVATE_SLOT(d_func(), void _q_sourceModelReset())
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QT_NO_IDENTITYPROXYMODEL
+
+#endif // QIDENTITYPROXYMODEL_H
+
diff --git a/src/gui/itemviews/qitemselectionmodel.cpp b/src/gui/itemviews/qitemselectionmodel.cpp
index 27a4a40..0b64452 100644
--- a/src/gui/itemviews/qitemselectionmodel.cpp
+++ b/src/gui/itemviews/qitemselectionmodel.cpp
@@ -1145,11 +1145,8 @@ void QItemSelectionModel::clearSelection()
     Q_D(QItemSelectionModel);
     if (d->ranges.count() == 0 && d->currentSelection.count() == 0)
         return;
-    QItemSelection selection = d->ranges;
-    selection.merge(d->currentSelection, d->currentCommand);
-    d->ranges.clear();
-    d->currentSelection.clear();
-    emit selectionChanged(QItemSelection(), selection);
+
+    select(QItemSelection(), Clear);
 }
 
 
diff --git a/src/gui/itemviews/qsortfilterproxymodel.cpp b/src/gui/itemviews/qsortfilterproxymodel.cpp
index eb56f56..f73607b 100644
--- a/src/gui/itemviews/qsortfilterproxymodel.cpp
+++ b/src/gui/itemviews/qsortfilterproxymodel.cpp
@@ -1502,7 +1502,7 @@ void QSortFilterProxyModelPrivate::_q_sourceColumnsRemoved(
     \l{Model Subclassing Reference}.
 
     \sa QAbstractProxyModel, QAbstractItemModel, {Model/View Programming},
-    {Basic Sort/Filter Model Example}, {Custom Sort/Filter Model Example}
+    {Basic Sort/Filter Model Example}, {Custom Sort/Filter Model Example}, QIdentityProxyModel
 */
 
 /*!
diff --git a/src/gui/itemviews/qtableview.cpp b/src/gui/itemviews/qtableview.cpp
index e494ee5..e70f356 100644
--- a/src/gui/itemviews/qtableview.cpp
+++ b/src/gui/itemviews/qtableview.cpp
@@ -1104,6 +1104,21 @@ void QTableView::setRootIndex(const QModelIndex &index)
 /*!
   \reimp
 */
+void QTableView::doItemsLayout()
+{
+    Q_D(QTableView);
+    QAbstractItemView::doItemsLayout();
+    if (verticalScrollMode() == QAbstractItemView::ScrollPerItem)
+        d->verticalHeader->setOffsetToSectionPosition(verticalScrollBar()->value());
+    else
+        d->verticalHeader->setOffset(verticalScrollBar()->value());
+    if (!d->verticalHeader->updatesEnabled())
+        d->verticalHeader->setUpdatesEnabled(true);
+}
+
+/*!
+  \reimp
+*/
 void QTableView::setSelectionModel(QItemSelectionModel *selectionModel)
 {
     Q_D(QTableView);
@@ -1285,7 +1300,6 @@ void QTableView::paintEvent(QPaintEvent *event)
     const QPen gridPen = QPen(gridColor, 0, d->gridStyle);
     const QHeaderView *verticalHeader = d->verticalHeader;
     const QHeaderView *horizontalHeader = d->horizontalHeader;
-    const QStyle::State state = option.state;
     const bool alternate = d->alternatingColors;
     const bool rightToLeft = isRightToLeft();
 
@@ -1975,9 +1989,13 @@ QModelIndexList QTableView::selectedIndexes() const
     previous number of rows is specified by \a oldCount, and the new
     number of rows is specified by \a newCount.
 */
-void QTableView::rowCountChanged(int /*oldCount*/, int /*newCount*/ )
+void QTableView::rowCountChanged(int oldCount, int newCount )
 {
     Q_D(QTableView);
+    //when removing rows, we need to disable updates for the header until the geometries have been
+    //updated and the offset has been adjusted, or we risk calling paintSection for all the sections
+    if (newCount < oldCount)
+        d->verticalHeader->setUpdatesEnabled(false);
     d->doDelayedItemsLayout();
 }
 
diff --git a/src/gui/itemviews/qtableview.h b/src/gui/itemviews/qtableview.h
index d4be086..7ab9d08 100644
--- a/src/gui/itemviews/qtableview.h
+++ b/src/gui/itemviews/qtableview.h
@@ -71,6 +71,7 @@ public:
     void setModel(QAbstractItemModel *model);
     void setRootIndex(const QModelIndex &index);
     void setSelectionModel(QItemSelectionModel *selectionModel);
+    void doItemsLayout();
 
     QHeaderView *horizontalHeader() const;
     QHeaderView *verticalHeader() const;
diff --git a/src/gui/kernel/qapplication_win.cpp b/src/gui/kernel/qapplication_win.cpp
index 0a03397..63e2319 100644
--- a/src/gui/kernel/qapplication_win.cpp
+++ b/src/gui/kernel/qapplication_win.cpp
@@ -237,6 +237,7 @@ static void resolveAygLibs()
 #  define FE_FONTSMOOTHINGCLEARTYPE 0x0002
 #endif
 
+Q_GUI_EXPORT qreal qt_fontsmoothing_gamma;
 Q_GUI_EXPORT bool qt_cleartype_enabled;
 Q_GUI_EXPORT bool qt_win_owndc_required; // CS_OWNDC is required if we use the GL graphicssystem as default
 
@@ -653,8 +654,18 @@ static void qt_win_read_cleartype_settings()
     if (SystemParametersInfo(SPI_GETFONTSMOOTHINGTYPE, 0, &result, 0))
         qt_cleartype_enabled = (result == FE_FONTSMOOTHINGCLEARTYPE);
 #endif
-}
 
+    int winSmooth;
+    if (SystemParametersInfo(0x200C /* SPI_GETFONTSMOOTHINGCONTRAST */, 0, &winSmooth, 0)) {
+        qt_fontsmoothing_gamma = winSmooth / qreal(1000.0);
+    } else {
+        qt_fontsmoothing_gamma = 1.0;
+    }
+
+    // Safeguard ourselves against corrupt registry values...
+    if (qt_fontsmoothing_gamma > 5 || qt_fontsmoothing_gamma < 1)
+        qt_fontsmoothing_gamma = qreal(1.4);
+}
 
 static void qt_set_windows_resources()
 {
@@ -2361,8 +2372,13 @@ extern "C" LRESULT QT_WIN_CALLBACK QtWndProc(HWND hwnd, UINT message, WPARAM wPa
 #ifndef QT_NO_ACCESSIBILITY
         case WM_GETOBJECT:
             {
+                /* On Win64, lParam can be 0x00000000fffffffc or 0xfffffffffffffffc (!),
+                   but MSDN says that lParam should be converted to a DWORD
+                   before its compared against OBJID_CLIENT
+                */
+                const DWORD dwObjId = (DWORD)lParam;
                 // Ignoring all requests while starting up
-                if (QApplication::startingUp() || QApplication::closingDown() || lParam != (LPARAM)OBJID_CLIENT) {
+                if (QApplication::startingUp() || QApplication::closingDown() || dwObjId != OBJID_CLIENT) {
                     result = false;
                     break;
                 }
diff --git a/src/gui/kernel/qcursor_x11.cpp b/src/gui/kernel/qcursor_x11.cpp
index d0ed98e..0bc7250 100644
--- a/src/gui/kernel/qcursor_x11.cpp
+++ b/src/gui/kernel/qcursor_x11.cpp
@@ -55,6 +55,9 @@
 #endif // QT_NO_XCURSOR
 
 #ifndef QT_NO_XFIXES
+#ifndef Status
+#define Status int
+#endif
 #  include <X11/extensions/Xfixes.h>
 #endif // QT_NO_XFIXES
 
diff --git a/src/gui/kernel/qdesktopwidget_qpa.cpp b/src/gui/kernel/qdesktopwidget_qpa.cpp
index cff05f5..6257a8b 100644
--- a/src/gui/kernel/qdesktopwidget_qpa.cpp
+++ b/src/gui/kernel/qdesktopwidget_qpa.cpp
@@ -51,6 +51,8 @@ QT_USE_NAMESPACE
 
 void QDesktopWidgetPrivate::updateScreenList()
 {
+    Q_Q(QDesktopWidget);
+
     QList<QPlatformScreen *> screenList = QApplicationPrivate::platformIntegration()->screens();
     int targetLength = screenList.length();
     int currentLength = screens.length();
@@ -72,19 +74,15 @@ void QDesktopWidgetPrivate::updateScreenList()
     }
 
     QRegion virtualGeometry;
-    bool doVirtualGeometry = QApplicationPrivate::platformIntegration()->isVirtualDesktop();
 
     // update the geometry of each screen widget
     for (int i = 0; i < screens.length(); i++) {
         QRect screenGeometry = screenList.at(i)->geometry();
         screens.at(i)->setGeometry(screenGeometry);
-        if (doVirtualGeometry)
-            virtualGeometry += screenGeometry;
+        virtualGeometry += screenGeometry;
     }
 
-    virtualScreen.setGeometry(virtualGeometry.boundingRect());
-    Q_Q(QDesktopWidget);
-    q->setGeometry(virtualScreen.geometry());
+    q->setGeometry(virtualGeometry.boundingRect());
 }
 
 QDesktopWidget::QDesktopWidget()
@@ -118,8 +116,6 @@ int QDesktopWidget::numScreens() const
 QWidget *QDesktopWidget::screen(int screen)
 {
     Q_D(QDesktopWidget);
-    if (QApplicationPrivate::platformIntegration()->isVirtualDesktop())
-        return &d->virtualScreen;
     if (screen < 0 || screen >= d->screens.length())
         return d->screens.at(0);
     return d->screens.at(screen);
diff --git a/src/gui/kernel/qdesktopwidget_qpa_p.h b/src/gui/kernel/qdesktopwidget_qpa_p.h
index abee8a1..d6ed686 100644
--- a/src/gui/kernel/qdesktopwidget_qpa_p.h
+++ b/src/gui/kernel/qdesktopwidget_qpa_p.h
@@ -76,7 +76,6 @@ public:
     void updateScreenList();
 
     QList<QDesktopScreenWidget *> screens;
-    QDesktopScreenWidget virtualScreen;
 };
 
 #endif // QDESKTOPWIDGET_QPA_P_H
diff --git a/src/gui/kernel/qgesturemanager.cpp b/src/gui/kernel/qgesturemanager.cpp
index 5359fb3..7aa7dffd 100644
--- a/src/gui/kernel/qgesturemanager.cpp
+++ b/src/gui/kernel/qgesturemanager.cpp
@@ -566,7 +566,6 @@ void QGestureManager::getGestureTargets(const QSet<QGesture*> &gestures,
                         = w->d_func()->gestureContext.find(type);
                 if (it != w->d_func()->gestureContext.end()) {
                     // i.e. 'w' listens to gesture 'type'
-                    Qt::GestureFlags flags = it.value();
                     if (!(it.value() & Qt::DontStartGestureOnChildren) && w != widget) {
                         // conflicting gesture!
                         (*conflicts)[widget].append(gestures[widget]);
diff --git a/src/gui/kernel/qplatformintegration_qpa.cpp b/src/gui/kernel/qplatformintegration_qpa.cpp
index d559c53..8ff12eb 100644
--- a/src/gui/kernel/qplatformintegration_qpa.cpp
+++ b/src/gui/kernel/qplatformintegration_qpa.cpp
@@ -214,6 +214,7 @@ QPlatformNativeInterface * QPlatformIntegration::nativeInterface() const
 
 bool QPlatformIntegration::hasCapability(Capability cap) const
 {
+    Q_UNUSED(cap);
     return false;
 }
 
diff --git a/src/gui/kernel/qplatformwindow_qpa.cpp b/src/gui/kernel/qplatformwindow_qpa.cpp
index 19bf7a9..f3654b6 100644
--- a/src/gui/kernel/qplatformwindow_qpa.cpp
+++ b/src/gui/kernel/qplatformwindow_qpa.cpp
@@ -150,7 +150,7 @@ void QPlatformWindow::setParent(const QPlatformWindow *parent)
 /*!
   Reimplement to set the window title to \a title
 */
-void QPlatformWindow::setWindowTitle(const QString &title) {}
+void QPlatformWindow::setWindowTitle(const QString &) {}
 
 /*!
   Reimplement to be able to let Qt rais windows to the top of the desktop
diff --git a/src/gui/kernel/qsessionmanager_qpa.cpp b/src/gui/kernel/qsessionmanager_qpa.cpp
index ef532d7..68685b4 100644
--- a/src/gui/kernel/qsessionmanager_qpa.cpp
+++ b/src/gui/kernel/qsessionmanager_qpa.cpp
@@ -42,6 +42,8 @@
 #include <qsessionmanager.h>
 
 #include <private/qobject_p.h>
+#include <qapplication.h>
+
 #ifndef QT_NO_SESSIONMANAGER
 
 QT_BEGIN_NAMESPACE
diff --git a/src/gui/kernel/qwidget.cpp b/src/gui/kernel/qwidget.cpp
index 5705214..80d7b85 100644
--- a/src/gui/kernel/qwidget.cpp
+++ b/src/gui/kernel/qwidget.cpp
@@ -612,7 +612,7 @@ void QWidget::setAutoFillBackground(bool enabled)
     \brief The QWidget class is the base class of all user interface objects.
 
     \ingroup basicwidgets
-    
+
     The widget is the atom of the user interface: it receives mouse, keyboard
     and other events from the window system, and paints a representation of
     itself on the screen. Every widget is rectangular, and they are sorted in a
@@ -1588,6 +1588,7 @@ QWidget::~QWidget()
 
     // delete layout while we still are a valid widget
     delete d->layout;
+    d->layout = 0;
     // Remove myself from focus list
 
     Q_ASSERT(d->focus_next->d_func()->focus_prev == this);
@@ -11205,6 +11206,7 @@ void QWidget::setAccessibleName(const QString &name)
 {
     Q_D(QWidget);
     d->accessibleName = name;
+    QAccessible::updateAccessibility(this, 0, QAccessible::NameChanged);
 }
 
 QString QWidget::accessibleName() const
@@ -11226,6 +11228,7 @@ void QWidget::setAccessibleDescription(const QString &description)
 {
     Q_D(QWidget);
     d->accessibleDescription = description;
+    QAccessible::updateAccessibility(this, 0, QAccessible::DescriptionChanged);
 }
 
 QString QWidget::accessibleDescription() const
diff --git a/src/gui/kernel/qwidget_x11.cpp b/src/gui/kernel/qwidget_x11.cpp
index 5ece7d6..3eec5c7 100644
--- a/src/gui/kernel/qwidget_x11.cpp
+++ b/src/gui/kernel/qwidget_x11.cpp
@@ -486,8 +486,6 @@ void QWidgetPrivate::create_sys(WId window, bool initializeWindow, bool destroyO
 
     bool topLevel = (flags & Qt::Window);
     bool popup = (type == Qt::Popup);
-    bool dialog = (type == Qt::Dialog
-                   || type == Qt::Sheet);
     bool desktop = (type == Qt::Desktop);
     bool tool = (type == Qt::Tool || type == Qt::SplashScreen
                  || type == Qt::ToolTip || type == Qt::Drawer);
@@ -553,7 +551,7 @@ void QWidgetPrivate::create_sys(WId window, bool initializeWindow, bool destroyO
     int sh = DisplayHeight(dpy,scr);
 
     if (desktop) {                                // desktop widget
-        dialog = popup = false;                        // force these flags off
+        popup = false;                        // force these flags off
         data.crect.setRect(0, 0, sw, sh);
     } else if (topLevel && !q->testAttribute(Qt::WA_Resized)) {
         QDesktopWidget *desktopWidget = qApp->desktop();
@@ -954,8 +952,13 @@ static void qt_x11_recreateWidget(QWidget *widget)
         // recreate their GL context, which in turn causes them to choose
         // their visual again. Now that WA_TranslucentBackground is set,
         // QGLContext::chooseVisual will select an ARGB visual.
-        QEvent e(QEvent::ParentChange);
-        QApplication::sendEvent(widget, &e);
+
+        // QGLWidget expects a ParentAboutToChange to be sent first
+        QEvent aboutToChangeEvent(QEvent::ParentAboutToChange);
+        QApplication::sendEvent(widget, &aboutToChangeEvent);
+
+        QEvent parentChangeEvent(QEvent::ParentChange);
+        QApplication::sendEvent(widget, &parentChangeEvent);
     } else {
         // For regular widgets, reparent them with their parent which
         // also triggers a recreation of the native window
diff --git a/src/gui/painting/qbrush.cpp b/src/gui/painting/qbrush.cpp
index bf5764a..3ff7eb8 100644
--- a/src/gui/painting/qbrush.cpp
+++ b/src/gui/painting/qbrush.cpp
@@ -840,6 +840,22 @@ const QGradient *QBrush::gradient() const
     return 0;
 }
 
+Q_GUI_EXPORT bool qt_isExtendedRadialGradient(const QBrush &brush)
+{
+    if (brush.style() == Qt::RadialGradientPattern) {
+        const QGradient *g = brush.gradient();
+        const QRadialGradient *rg = static_cast<const QRadialGradient *>(g);
+
+        if (!qFuzzyIsNull(rg->focalRadius()))
+            return true;
+
+        QPointF delta = rg->focalPoint() - rg->center();
+        if (delta.x() * delta.x() + delta.y() * delta.y() > rg->radius() * rg->radius())
+            return true;
+    }
+
+    return false;
+}
 
 /*!
     Returns true if the brush is fully opaque otherwise false. A brush
@@ -849,6 +865,7 @@ const QGradient *QBrush::gradient() const
     \i The alpha component of the color() is 255.
     \i Its texture() does not have an alpha channel and is not a QBitmap.
     \i The colors in the gradient() all have an alpha component that is 255.
+    \i It is an extended radial gradient.
     \endlist
 */
 
@@ -860,6 +877,9 @@ bool QBrush::isOpaque() const
     if (d->style == Qt::SolidPattern)
         return opaqueColor;
 
+    if (qt_isExtendedRadialGradient(*this))
+        return false;
+
     if (d->style == Qt::LinearGradientPattern
         || d->style == Qt::RadialGradientPattern
         || d->style == Qt::ConicalGradientPattern) {
@@ -1209,8 +1229,10 @@ QDataStream &operator>>(QDataStream &s, QBrush &b)
 
     \list
     \o \e Linear gradients interpolate colors between start and end points.
-    \o \e Radial gradients interpolate colors between a focal point and end
-        points on a circle surrounding it.
+    \o \e Simple radial gradients interpolate colors between a focal point
+        and end points on a circle surrounding it.
+    \o \e Extended radial gradients interpolate colors between a center and
+        a focal circle.
     \o \e Conical gradients interpolate colors around a center point.
     \endlist
 
@@ -1506,8 +1528,6 @@ void QGradient::setInterpolationMode(InterpolationMode mode)
     dummy = p;
 }
 
-#undef Q_DUMMY_ACCESSOR
-
 /*!
     \fn bool QGradient::operator!=(const QGradient &gradient) const
     \since 4.2
@@ -1541,7 +1561,7 @@ bool QGradient::operator==(const QGradient &gradient) const
             || m_data.radial.cy != gradient.m_data.radial.cy
             || m_data.radial.fx != gradient.m_data.radial.fx
             || m_data.radial.fy != gradient.m_data.radial.fy
-            || m_data.radial.radius != gradient.m_data.radial.radius)
+            || m_data.radial.cradius != gradient.m_data.radial.cradius)
             return false;
     } else { // m_type == ConicalGradient
         if (m_data.conical.cx != gradient.m_data.conical.cx
@@ -1747,10 +1767,17 @@ void QLinearGradient::setFinalStop(const QPointF &stop)
     \brief The QRadialGradient class is used in combination with QBrush to
     specify a radial gradient brush.
 
-    Radial gradients interpolate colors between a focal point and end
-    points on a circle surrounding it. Outside the end points the
-    gradient is either padded, reflected or repeated depending on the
-    currently set \l {QGradient::Spread}{spread} method:
+    Qt supports both simple and extended radial gradients.
+
+    Simple radial gradients interpolate colors between a focal point and end
+    points on a circle surrounding it. Extended radial gradients interpolate
+    colors between a focal circle and a center circle. Points outside the cone
+    defined by the two circles will be transparent. For simple radial gradients
+    the focal point is adjusted to lie inside the center circle, whereas the
+    focal point can have any position in an extended radial gradient.
+
+    Outside the end points the gradient is either padded, reflected or repeated
+    depending on the currently set \l {QGradient::Spread}{spread} method:
 
     \table
     \row
@@ -1795,9 +1822,14 @@ static QPointF qt_radial_gradient_adapt_focal_point(const QPointF &center,
 }
 
 /*!
-    Constructs a radial gradient with the given \a center, \a
+    Constructs a simple radial gradient with the given \a center, \a
     radius and \a focalPoint.
 
+    \note If the given focal point is outside the circle defined by the
+    center (\a cx, \a cy) and the \a radius it will be re-adjusted to
+    the intersection between the line from the center to the focal point
+    and the circle.
+
     \sa QGradient::setColorAt(), QGradient::setStops()
 */
 
@@ -1807,7 +1839,7 @@ QRadialGradient::QRadialGradient(const QPointF &center, qreal radius, const QPoi
     m_spread = PadSpread;
     m_data.radial.cx = center.x();
     m_data.radial.cy = center.y();
-    m_data.radial.radius = radius;
+    m_data.radial.cradius = radius;
 
     QPointF adapted_focal = qt_radial_gradient_adapt_focal_point(center, radius, focalPoint);
     m_data.radial.fx = adapted_focal.x();
@@ -1815,7 +1847,7 @@ QRadialGradient::QRadialGradient(const QPointF &center, qreal radius, const QPoi
 }
 
 /*!
-    Constructs a radial gradient with the given \a center, \a
+    Constructs a simple radial gradient with the given \a center, \a
     radius and the focal point in the circle center.
 
     \sa QGradient::setColorAt(), QGradient::setStops()
@@ -1826,16 +1858,21 @@ QRadialGradient::QRadialGradient(const QPointF &center, qreal radius)
     m_spread = PadSpread;
     m_data.radial.cx = center.x();
     m_data.radial.cy = center.y();
-    m_data.radial.radius = radius;
+    m_data.radial.cradius = radius;
     m_data.radial.fx = center.x();
     m_data.radial.fy = center.y();
 }
 
 
 /*!
-    Constructs a radial gradient with the given center (\a cx, \a cy),
+    Constructs a simple radial gradient with the given center (\a cx, \a cy),
     \a radius and focal point (\a fx, \a fy).
 
+    \note If the given focal point is outside the circle defined by the
+    center (\a cx, \a cy) and the \a radius it will be re-adjusted to
+    the intersection between the line from the center to the focal point
+    and the circle.
+
     \sa QGradient::setColorAt(), QGradient::setStops()
 */
 
@@ -1845,7 +1882,7 @@ QRadialGradient::QRadialGradient(qreal cx, qreal cy, qreal radius, qreal fx, qre
     m_spread = PadSpread;
     m_data.radial.cx = cx;
     m_data.radial.cy = cy;
-    m_data.radial.radius = radius;
+    m_data.radial.cradius = radius;
 
     QPointF adapted_focal = qt_radial_gradient_adapt_focal_point(QPointF(cx, cy),
                                                                  radius,
@@ -1856,7 +1893,7 @@ QRadialGradient::QRadialGradient(qreal cx, qreal cy, qreal radius, qreal fx, qre
 }
 
 /*!
-    Constructs a radial gradient with the center at (\a cx, \a cy) and the
+    Constructs a simple radial gradient with the center at (\a cx, \a cy) and the
     specified \a radius. The focal point lies at the center of the circle.
 
     \sa QGradient::setColorAt(), QGradient::setStops()
@@ -1867,14 +1904,14 @@ QRadialGradient::QRadialGradient(qreal cx, qreal cy, qreal radius)
     m_spread = PadSpread;
     m_data.radial.cx = cx;
     m_data.radial.cy = cy;
-    m_data.radial.radius = radius;
+    m_data.radial.cradius = radius;
     m_data.radial.fx = cx;
     m_data.radial.fy = cy;
 }
 
 
 /*!
-    Constructs a radial gradient with the center and focal point at
+    Constructs a simple radial gradient with the center and focal point at
     (0, 0) with a radius of 1.
 */
 QRadialGradient::QRadialGradient()
@@ -1883,11 +1920,51 @@ QRadialGradient::QRadialGradient()
     m_spread = PadSpread;
     m_data.radial.cx = 0;
     m_data.radial.cy = 0;
-    m_data.radial.radius = 1;
+    m_data.radial.cradius = 1;
     m_data.radial.fx = 0;
     m_data.radial.fy = 0;
 }
 
+/*!
+    \since 4.8
+
+    Constructs an extended radial gradient with the given \a center, \a
+    centerRadius, \a focalPoint, and \a focalRadius.
+*/
+QRadialGradient::QRadialGradient(const QPointF &center, qreal centerRadius, const QPointF &focalPoint, qreal focalRadius)
+{
+    m_type = RadialGradient;
+    m_spread = PadSpread;
+    m_data.radial.cx = center.x();
+    m_data.radial.cy = center.y();
+    m_data.radial.cradius = centerRadius;
+
+    m_data.radial.fx = focalPoint.x();
+    m_data.radial.fy = focalPoint.y();
+    setFocalRadius(focalRadius);
+}
+
+/*!
+    \since 4.8
+
+    Constructs an extended radial gradient with the given \a center, \a
+    centerRadius, \a focalPoint, and \a focalRadius.
+    Constructs a radial gradient with the given center (\a cx, \a cy),
+    center radius \a centerRadius, focal point (\a fx, \a fy), and
+    focal radius \a focalRadius.
+*/
+QRadialGradient::QRadialGradient(qreal cx, qreal cy, qreal centerRadius, qreal fx, qreal fy, qreal focalRadius)
+{
+    m_type = RadialGradient;
+    m_spread = PadSpread;
+    m_data.radial.cx = cx;
+    m_data.radial.cy = cy;
+    m_data.radial.cradius = centerRadius;
+
+    m_data.radial.fx = fx;
+    m_data.radial.fy = fy;
+    setFocalRadius(focalRadius);
+}
 
 /*!
     Returns the center of this radial gradient in logical coordinates.
@@ -1932,13 +2009,15 @@ void QRadialGradient::setCenter(const QPointF &center)
 /*!
     Returns the radius of this radial gradient in logical coordinates.
 
+    Equivalent to centerRadius()
+
     \sa QGradient::stops()
 */
 
 qreal QRadialGradient::radius() const
 {
     Q_ASSERT(m_type == RadialGradient);
-    return m_data.radial.radius;
+    return m_data.radial.cradius;
 }
 
 
@@ -1947,13 +2026,81 @@ qreal QRadialGradient::radius() const
 
     Sets the radius of this radial gradient in logical coordinates
     to \a radius
+
+    Equivalent to setCenterRadius()
 */
 void QRadialGradient::setRadius(qreal radius)
 {
     Q_ASSERT(m_type == RadialGradient);
-    m_data.radial.radius = radius;
+    m_data.radial.cradius = radius;
+}
+
+/*!
+    \since 4.8
+
+    Returns the center radius of this radial gradient in logical
+    coordinates.
+
+    \sa QGradient::stops()
+*/
+qreal QRadialGradient::centerRadius() const
+{
+    Q_ASSERT(m_type == RadialGradient);
+    return m_data.radial.cradius;
+}
+
+/*
+   \since 4.8
+
+   Sets the center radius of this radial gradient in logical coordinates
+   to \a radius
+*/
+void QRadialGradient::setCenterRadius(qreal radius)
+{
+    Q_ASSERT(m_type == RadialGradient);
+    m_data.radial.cradius = radius;
+}
+
+/*!
+    \since 4.8
+
+    Returns the focal radius of this radial gradient in logical
+    coordinates.
+
+    \sa QGradient::stops()
+*/
+qreal QRadialGradient::focalRadius() const
+{
+    Q_ASSERT(m_type == RadialGradient);
+    Q_DUMMY_ACCESSOR
+
+    // mask away low three bits
+    union { float f; quint32 i; } u;
+    u.i = i & ~0x07;
+    return u.f;
 }
 
+/*
+   \since 4.8
+
+   Sets the focal radius of this radial gradient in logical coordinates
+   to \a radius
+*/
+void QRadialGradient::setFocalRadius(qreal radius)
+{
+    Q_ASSERT(m_type == RadialGradient);
+    Q_DUMMY_ACCESSOR
+
+    // Since there's no QGradientData, we only have the dummy void * to
+    // store additional data in. The three lowest bits are already
+    // taken, thus we cut the three lowest bits from the significand
+    // and store the radius as a float.
+    union { float f; quint32 i; } u;
+    u.f = float(radius);
+    // add 0x04 to round up when we drop the three lowest bits
+    i |= (u.i + 0x04) & ~0x07;
+    dummy = p;
+}
 
 /*!
     Returns the focal point of this radial gradient in logical
@@ -2193,4 +2340,6 @@ void QConicalGradient::setAngle(qreal angle)
     \sa setTransform()
 */
 
+#undef Q_DUMMY_ACCESSOR
+
 QT_END_NAMESPACE
diff --git a/src/gui/painting/qbrush.h b/src/gui/painting/qbrush.h
index 8b31319..d914c8c 100644
--- a/src/gui/painting/qbrush.h
+++ b/src/gui/painting/qbrush.h
@@ -255,6 +255,7 @@ private:
     friend class QLinearGradient;
     friend class QRadialGradient;
     friend class QConicalGradient;
+    friend class QBrush;
 
     Type m_type;
     Spread m_spread;
@@ -264,7 +265,7 @@ private:
             qreal x1, y1, x2, y2;
         } linear;
         struct {
-            qreal cx, cy, fx, fy, radius;
+            qreal cx, cy, fx, fy, cradius;
         } radial;
         struct {
             qreal cx, cy, angle;
@@ -303,6 +304,9 @@ public:
     QRadialGradient(const QPointF &center, qreal radius);
     QRadialGradient(qreal cx, qreal cy, qreal radius);
 
+    QRadialGradient(const QPointF &center, qreal centerRadius, const QPointF &focalPoint, qreal focalRadius);
+    QRadialGradient(qreal cx, qreal cy, qreal centerRadius, qreal fx, qreal fy, qreal focalRadius);
+
     QPointF center() const;
     void setCenter(const QPointF &center);
     inline void setCenter(qreal x, qreal y) { setCenter(QPointF(x, y)); }
@@ -313,6 +317,12 @@ public:
 
     qreal radius() const;
     void setRadius(qreal radius);
+
+    qreal centerRadius() const;
+    void setCenterRadius(qreal radius);
+
+    qreal focalRadius() const;
+    void setFocalRadius(qreal radius);
 };
 
 
diff --git a/src/gui/painting/qdrawhelper.cpp b/src/gui/painting/qdrawhelper.cpp
index 5e75e4a..360292c 100644
--- a/src/gui/painting/qdrawhelper.cpp
+++ b/src/gui/painting/qdrawhelper.cpp
@@ -75,43 +75,9 @@ enum {
     fixed_scale = 1 << 16,
     half_point = 1 << 15
 };
-static const int buffer_size = 2048;
-
-struct LinearGradientValues
-{
-    qreal dx;
-    qreal dy;
-    qreal l;
-    qreal off;
-};
-
-struct RadialGradientValues
-{
-    qreal dx;
-    qreal dy;
-    qreal a;
-};
-
-struct Operator;
-typedef uint* (QT_FASTCALL *DestFetchProc)(uint *buffer, QRasterBuffer *rasterBuffer, int x, int y, int length);
-typedef void (QT_FASTCALL *DestStoreProc)(QRasterBuffer *rasterBuffer, int x, int y, const uint *buffer, int length);
-typedef const uint* (QT_FASTCALL *SourceFetchProc)(uint *buffer, const Operator *o, const QSpanData *data, int y, int x, int length);
-
 
-struct Operator
-{
-    QPainter::CompositionMode mode;
-    DestFetchProc dest_fetch;
-    DestStoreProc dest_store;
-    SourceFetchProc src_fetch;
-    CompositionFunctionSolid funcSolid;
-    CompositionFunction func;
-    union {
-        LinearGradientValues linear;
-        RadialGradientValues radial;
-//        TextureValues texture;
-    };
-};
+// must be multiple of 4 for easier SIMD implementations
+static const int buffer_size = 2048;
 
 /*
   Destination fetch. This is simple as we don't have to do bounds checks or
@@ -1346,64 +1312,13 @@ static const SourceFetchProc sourceFetch[NBlendTypes][QImage::NImageFormats] = {
     },
 };
 
-
-static inline uint qt_gradient_pixel(const QGradientData *data, qreal pos)
-{
-    int ipos = int(pos * (GRADIENT_STOPTABLE_SIZE - 1) + qreal(0.5));
-
-  // calculate the actual offset.
-    if (ipos < 0 || ipos >= GRADIENT_STOPTABLE_SIZE) {
-        if (data->spread == QGradient::RepeatSpread) {
-            ipos = ipos % GRADIENT_STOPTABLE_SIZE;
-            ipos = ipos < 0 ? GRADIENT_STOPTABLE_SIZE + ipos : ipos;
-
-        } else if (data->spread == QGradient::ReflectSpread) {
-            const int limit = GRADIENT_STOPTABLE_SIZE * 2 - 1;
-            ipos = ipos % limit;
-            ipos = ipos < 0 ? limit + ipos : ipos;
-            ipos = ipos >= GRADIENT_STOPTABLE_SIZE ? limit - ipos : ipos;
-
-        } else {
-            if (ipos < 0) ipos = 0;
-            else if (ipos >= GRADIENT_STOPTABLE_SIZE) ipos = GRADIENT_STOPTABLE_SIZE-1;
-        }
-    }
-
-    Q_ASSERT(ipos >= 0);
-    Q_ASSERT(ipos < GRADIENT_STOPTABLE_SIZE);
-
-    return data->colorTable[ipos];
-}
-
 #define FIXPT_BITS 8
 #define FIXPT_SIZE (1<<FIXPT_BITS)
 
 static uint qt_gradient_pixel_fixed(const QGradientData *data, int fixed_pos)
 {
     int ipos = (fixed_pos + (FIXPT_SIZE / 2)) >> FIXPT_BITS;
-
-    // calculate the actual offset.
-    if (ipos < 0 || ipos >= GRADIENT_STOPTABLE_SIZE) {
-        if (data->spread == QGradient::RepeatSpread) {
-            ipos = ipos % GRADIENT_STOPTABLE_SIZE;
-            ipos = ipos < 0 ? GRADIENT_STOPTABLE_SIZE + ipos : ipos;
-
-        } else if (data->spread == QGradient::ReflectSpread) {
-            const int limit = GRADIENT_STOPTABLE_SIZE * 2 - 1;
-            ipos = ipos % limit;
-            ipos = ipos < 0 ? limit + ipos : ipos;
-            ipos = ipos >= GRADIENT_STOPTABLE_SIZE ? limit - ipos : ipos;
-
-        } else {
-            if (ipos < 0) ipos = 0;
-            else if (ipos >= GRADIENT_STOPTABLE_SIZE) ipos = GRADIENT_STOPTABLE_SIZE-1;
-        }
-    }
-
-    Q_ASSERT(ipos >= 0);
-    Q_ASSERT(ipos < GRADIENT_STOPTABLE_SIZE);
-
-    return data->colorTable[ipos];
+    return data->colorTable[qt_gradient_clamp(data, ipos)];
 }
 
 static void QT_FASTCALL getLinearGradientValues(LinearGradientValues *v, const QSpanData *data)
@@ -1419,8 +1334,8 @@ static void QT_FASTCALL getLinearGradientValues(LinearGradientValues *v, const Q
     }
 }
 
-static const uint * QT_FASTCALL fetchLinearGradient(uint *buffer, const Operator *op, const QSpanData *data,
-                                                    int y, int x, int length)
+static const uint * QT_FASTCALL qt_fetch_linear_gradient(uint *buffer, const Operator *op, const QSpanData *data,
+                                                         int y, int x, int length)
 {
     const uint *b = buffer;
     qreal t, inc;
@@ -1487,110 +1402,65 @@ static const uint * QT_FASTCALL fetchLinearGradient(uint *buffer, const Operator
     return b;
 }
 
-static inline qreal determinant(qreal a, qreal b, qreal c)
-{
-    return (b * b) - (4 * a * c);
-}
-
-// function to evaluate real roots
-static inline qreal realRoots(qreal a, qreal b, qreal detSqrt)
-{
-    return (-b + detSqrt)/(2 * a);
-}
-
-static inline qreal qSafeSqrt(qreal x)
-{
-    return x > 0 ? qSqrt(x) : 0;
-}
-
 static void QT_FASTCALL getRadialGradientValues(RadialGradientValues *v, const QSpanData *data)
 {
     v->dx = data->gradient.radial.center.x - data->gradient.radial.focal.x;
     v->dy = data->gradient.radial.center.y - data->gradient.radial.focal.y;
-    v->a = data->gradient.radial.radius*data->gradient.radial.radius - v->dx*v->dx - v->dy*v->dy;
-}
-
-static const uint * QT_FASTCALL fetchRadialGradient(uint *buffer, const Operator *op, const QSpanData *data,
-                                                    int y, int x, int length)
-{
-    const uint *b = buffer;
-    qreal rx = data->m21 * (y + qreal(0.5))
-               + data->dx + data->m11 * (x + qreal(0.5));
-    qreal ry = data->m22 * (y + qreal(0.5))
-               + data->dy + data->m12 * (x + qreal(0.5));
-    bool affine = !data->m13 && !data->m23;
-    //qreal r  = data->gradient.radial.radius;
-
-    const uint *end = buffer + length;
-    if (affine) {
-        rx -= data->gradient.radial.focal.x;
-        ry -= data->gradient.radial.focal.y;
-
-        qreal inv_a = 1 / qreal(2 * op->radial.a);
-
-        const qreal delta_rx = data->m11;
-        const qreal delta_ry = data->m12;
-
-        qreal b = 2*(rx * op->radial.dx + ry * op->radial.dy);
-        qreal delta_b = 2*(delta_rx * op->radial.dx + delta_ry * op->radial.dy);
-        const qreal b_delta_b = 2 * b * delta_b;
-        const qreal delta_b_delta_b = 2 * delta_b * delta_b;
 
-        const qreal bb = b * b;
-        const qreal delta_bb = delta_b * delta_b;
+    v->dr = data->gradient.radial.center.radius - data->gradient.radial.focal.radius;
+    v->sqrfr = data->gradient.radial.focal.radius * data->gradient.radial.focal.radius;
 
-        b *= inv_a;
-        delta_b *= inv_a;
+    v->a = v->dr * v->dr - v->dx*v->dx - v->dy*v->dy;
+    v->inv2a = 1 / (2 * v->a);
 
-        const qreal rxrxryry = rx * rx + ry * ry;
-        const qreal delta_rxrxryry = delta_rx * delta_rx + delta_ry * delta_ry;
-        const qreal rx_plus_ry = 2*(rx * delta_rx + ry * delta_ry);
-        const qreal delta_rx_plus_ry = 2 * delta_rxrxryry;
-
-        inv_a *= inv_a;
-
-        qreal det = (bb + 4 * op->radial.a * rxrxryry) * inv_a;
-        qreal delta_det = (b_delta_b + delta_bb + 4 * op->radial.a * (rx_plus_ry + delta_rxrxryry)) * inv_a;
-        const qreal delta_delta_det = (delta_b_delta_b + 4 * op->radial.a * delta_rx_plus_ry) * inv_a;
+    v->extended = !qFuzzyIsNull(data->gradient.radial.focal.radius) || v->a <= 0;
+}
 
-        while (buffer < end) {
-            *buffer = qt_gradient_pixel(&data->gradient, qSafeSqrt(det) - b);
+class RadialFetchPlain
+{
+public:
+    static inline void fetch(uint *buffer, uint *end, const Operator *op, const QSpanData *data, qreal det,
+                             qreal delta_det, qreal delta_delta_det, qreal b, qreal delta_b)
+    {
+        if (op->radial.extended) {
+            while (buffer < end) {
+                quint32 result = 0;
+                if (det >= 0) {
+                    qreal w = qSqrt(det) - b;
+                    if (data->gradient.radial.focal.radius + op->radial.dr * w >= 0)
+                        result = qt_gradient_pixel(&data->gradient, w);
+                }
 
-            det += delta_det;
-            delta_det += delta_delta_det;
-            b += delta_b;
+                *buffer = result;
 
-            ++buffer;
-        }
-    } else {
-        qreal rw = data->m23 * (y + qreal(0.5))
-                   + data->m33 + data->m13 * (x + qreal(0.5));
-        if (!rw)
-            rw = 1;
-        while (buffer < end) {
-            qreal gx = rx/rw - data->gradient.radial.focal.x;
-            qreal gy = ry/rw - data->gradient.radial.focal.y;
-            qreal b  = 2*(gx*op->radial.dx + gy*op->radial.dy);
-            qreal det = determinant(op->radial.a, b , -(gx*gx + gy*gy));
-            qreal s = realRoots(op->radial.a, b, qSafeSqrt(det));
+                det += delta_det;
+                delta_det += delta_delta_det;
+                b += delta_b;
 
-            *buffer = qt_gradient_pixel(&data->gradient, s);
+                ++buffer;
+            }
+        } else {
+            while (buffer < end) {
+                *buffer++ = qt_gradient_pixel(&data->gradient, qSqrt(det) - b);
 
-            rx += data->m11;
-            ry += data->m12;
-            rw += data->m13;
-            if (!rw) {
-                rw += data->m13;
+                det += delta_det;
+                delta_det += delta_delta_det;
+                b += delta_b;
             }
-            ++buffer;
         }
     }
+};
 
-    return b;
+const uint * QT_FASTCALL qt_fetch_radial_gradient_plain(uint *buffer, const Operator *op, const QSpanData *data,
+                                                        int y, int x, int length)
+{
+    return qt_fetch_radial_gradient_template<RadialFetchPlain>(buffer, op, data, y, x, length);
 }
 
-static const uint * QT_FASTCALL fetchConicalGradient(uint *buffer, const Operator *, const QSpanData *data,
-                                                     int y, int x, int length)
+static SourceFetchProc qt_fetch_radial_gradient = qt_fetch_radial_gradient_plain;
+
+static const uint * QT_FASTCALL qt_fetch_conical_gradient(uint *buffer, const Operator *, const QSpanData *data,
+                                                          int y, int x, int length)
 {
     const uint *b = buffer;
     qreal rx = data->m21 * (y + qreal(0.5))
@@ -3347,16 +3217,16 @@ static inline Operator getOperator(const QSpanData *data, const QSpan *spans, in
     case QSpanData::LinearGradient:
         solidSource = !data->gradient.alphaColor;
         getLinearGradientValues(&op.linear, data);
-        op.src_fetch = fetchLinearGradient;
+        op.src_fetch = qt_fetch_linear_gradient;
         break;
     case QSpanData::RadialGradient:
         solidSource = !data->gradient.alphaColor;
         getRadialGradientValues(&op.radial, data);
-        op.src_fetch = fetchRadialGradient;
+        op.src_fetch = qt_fetch_radial_gradient;
         break;
     case QSpanData::ConicalGradient:
         solidSource = !data->gradient.alphaColor;
-        op.src_fetch = fetchConicalGradient;
+        op.src_fetch = qt_fetch_conical_gradient;
         break;
     case QSpanData::Texture:
         op.src_fetch = sourceFetch[getBlendType(data)][data->texture.format];
@@ -7198,14 +7068,8 @@ void qt_build_pow_tables() {
 #endif
 
 #ifdef Q_WS_WIN
-    int winSmooth;
-    if (SystemParametersInfo(0x200C /* SPI_GETFONTSMOOTHINGCONTRAST */, 0, &winSmooth, 0))
-        smoothing = winSmooth / qreal(1000.0);
-
-    // Safeguard ourselves against corrupt registry values...
-    if (smoothing > 5 || smoothing < 1)
-        smoothing = qreal(1.4);
-
+    extern qreal qt_fontsmoothing_gamma; // qapplication_win.cpp
+    smoothing = qt_fontsmoothing_gamma;
 #endif
 
 #ifdef Q_WS_X11
@@ -7888,6 +7752,11 @@ void qInitDrawhelperAsm()
         qBlendFunctions[QImage::Format_ARGB32_Premultiplied][QImage::Format_RGB32] = qt_blend_rgb32_on_rgb32_sse2;
         qBlendFunctions[QImage::Format_RGB32][QImage::Format_ARGB32_Premultiplied] = qt_blend_argb32_on_argb32_sse2;
         qBlendFunctions[QImage::Format_ARGB32_Premultiplied][QImage::Format_ARGB32_Premultiplied] = qt_blend_argb32_on_argb32_sse2;
+
+        extern const uint * QT_FASTCALL qt_fetch_radial_gradient_sse2(uint *buffer, const Operator *op, const QSpanData *data,
+                                                                      int y, int x, int length);
+
+        qt_fetch_radial_gradient = qt_fetch_radial_gradient_sse2;
     }
 
 #ifdef QT_HAVE_SSSE3
@@ -7983,6 +7852,11 @@ void qInitDrawhelperAsm()
         qMemRotateFunctions[QImage::Format_RGB16][0] = qt_memrotate90_16_neon;
         qMemRotateFunctions[QImage::Format_RGB16][2] = qt_memrotate270_16_neon;
         qt_memfill32 = qt_memfill32_neon;
+
+        extern const uint * QT_FASTCALL qt_fetch_radial_gradient_neon(uint *buffer, const Operator *op, const QSpanData *data,
+                                                                      int y, int x, int length);
+
+        qt_fetch_radial_gradient = qt_fetch_radial_gradient_neon;
     }
 #endif
 
diff --git a/src/gui/painting/qdrawhelper_neon.cpp b/src/gui/painting/qdrawhelper_neon.cpp
index debca37..e673dd9 100644
--- a/src/gui/painting/qdrawhelper_neon.cpp
+++ b/src/gui/painting/qdrawhelper_neon.cpp
@@ -955,6 +955,46 @@ void qt_memrotate270_16_neon(const uchar *srcPixels, int w, int h,
     }
 }
 
+class QSimdNeon
+{
+public:
+    typedef int32x4_t Int32x4;
+    typedef float32x4_t Float32x4;
+
+    union Vect_buffer_i { Int32x4 v; int i[4]; };
+    union Vect_buffer_f { Float32x4 v; float f[4]; };
+
+    static inline Float32x4 v_dup(float x) { return vdupq_n_f32(x); }
+    static inline Int32x4 v_dup(int x) { return vdupq_n_s32(x); }
+    static inline Int32x4 v_dup(uint x) { return vdupq_n_s32(x); }
+
+    static inline Float32x4 v_add(Float32x4 a, Float32x4 b) { return vaddq_f32(a, b); }
+    static inline Int32x4 v_add(Int32x4 a, Int32x4 b) { return vaddq_s32(a, b); }
+
+    static inline Float32x4 v_max(Float32x4 a, Float32x4 b) { return vmaxq_f32(a, b); }
+    static inline Float32x4 v_min(Float32x4 a, Float32x4 b) { return vminq_f32(a, b); }
+    static inline Int32x4 v_min_16(Int32x4 a, Int32x4 b) { return vminq_s32(a, b); }
+
+    static inline Int32x4 v_and(Int32x4 a, Int32x4 b) { return vandq_s32(a, b); }
+
+    static inline Float32x4 v_sub(Float32x4 a, Float32x4 b) { return vsubq_f32(a, b); }
+    static inline Int32x4 v_sub(Int32x4 a, Int32x4 b) { return vsubq_s32(a, b); }
+
+    static inline Float32x4 v_mul(Float32x4 a, Float32x4 b) { return vmulq_f32(a, b); }
+
+    static inline Float32x4 v_sqrt(Float32x4 x) { Float32x4 y = vrsqrteq_f32(x); y = vmulq_f32(y, vrsqrtsq_f32(x, vmulq_f32(y, y))); return vmulq_f32(x, y); }
+
+    static inline Int32x4 v_toInt(Float32x4 x) { return vcvtq_s32_f32(x); }
+
+    static inline Int32x4 v_greaterOrEqual(Float32x4 a, Float32x4 b) { return vcge_f32(a, b); }
+};
+
+const uint * QT_FASTCALL qt_fetch_radial_gradient_neon(uint *buffer, const Operator *op, const QSpanData *data,
+                                                       int y, int x, int length)
+{
+    return qt_fetch_radial_gradient_template<QRadialFetchSimd<QSimdNeon> >(buffer, op, data, y, x, length);
+}
+
 QT_END_NAMESPACE
 
 #endif // QT_HAVE_NEON
diff --git a/src/gui/painting/qdrawhelper_p.h b/src/gui/painting/qdrawhelper_p.h
index d4e731b..fa6ad0b 100644
--- a/src/gui/painting/qdrawhelper_p.h
+++ b/src/gui/painting/qdrawhelper_p.h
@@ -63,6 +63,7 @@
 #endif
 #include "private/qrasterdefs_p.h"
 #include <private/qsimd_p.h>
+#include <private/qmath_p.h>
 
 #ifdef Q_WS_QWS
 #include "QtGui/qscreen_qws.h"
@@ -178,6 +179,44 @@ void qBlendTextureCallback(int count, const QSpan *spans, void *userData);
 typedef void (QT_FASTCALL *CompositionFunction)(uint *dest, const uint *src, int length, uint const_alpha);
 typedef void (QT_FASTCALL *CompositionFunctionSolid)(uint *dest, int length, uint color, uint const_alpha);
 
+struct LinearGradientValues
+{
+    qreal dx;
+    qreal dy;
+    qreal l;
+    qreal off;
+};
+
+struct RadialGradientValues
+{
+    qreal dx;
+    qreal dy;
+    qreal dr;
+    qreal sqrfr;
+    qreal a;
+    qreal inv2a;
+    bool extended;
+};
+
+struct Operator;
+typedef uint* (QT_FASTCALL *DestFetchProc)(uint *buffer, QRasterBuffer *rasterBuffer, int x, int y, int length);
+typedef void (QT_FASTCALL *DestStoreProc)(QRasterBuffer *rasterBuffer, int x, int y, const uint *buffer, int length);
+typedef const uint* (QT_FASTCALL *SourceFetchProc)(uint *buffer, const Operator *o, const QSpanData *data, int y, int x, int length);
+
+struct Operator
+{
+    QPainter::CompositionMode mode;
+    DestFetchProc dest_fetch;
+    DestStoreProc dest_store;
+    SourceFetchProc src_fetch;
+    CompositionFunctionSolid funcSolid;
+    CompositionFunction func;
+    union {
+        LinearGradientValues linear;
+        RadialGradientValues radial;
+    };
+};
+
 void qInitDrawhelperAsm();
 
 class QRasterPaintEngine;
@@ -204,12 +243,13 @@ struct QRadialGradientData
     struct {
         qreal x;
         qreal y;
+        qreal radius;
     } center;
     struct {
         qreal x;
         qreal y;
+        qreal radius;
     } focal;
-    qreal radius;
 };
 
 struct QConicalGradientData
@@ -233,8 +273,10 @@ struct QGradientData
 
 #ifdef Q_WS_QWS
 #define GRADIENT_STOPTABLE_SIZE 256
+#define GRADIENT_STOPTABLE_SIZE_SHIFT 8
 #else
 #define GRADIENT_STOPTABLE_SIZE 1024
+#define GRADIENT_STOPTABLE_SIZE_SHIFT 10
 #endif
 
     uint* colorTable; //[GRADIENT_STOPTABLE_SIZE];
@@ -308,6 +350,218 @@ struct QSpanData
     void adjustSpanMethods();
 };
 
+static inline uint qt_gradient_clamp(const QGradientData *data, int ipos)
+{
+    if (ipos < 0 || ipos >= GRADIENT_STOPTABLE_SIZE) {
+        if (data->spread == QGradient::RepeatSpread) {
+            ipos = ipos % GRADIENT_STOPTABLE_SIZE;
+            ipos = ipos < 0 ? GRADIENT_STOPTABLE_SIZE + ipos : ipos;
+        } else if (data->spread == QGradient::ReflectSpread) {
+            const int limit = GRADIENT_STOPTABLE_SIZE * 2;
+            ipos = ipos % limit;
+            ipos = ipos < 0 ? limit + ipos : ipos;
+            ipos = ipos >= GRADIENT_STOPTABLE_SIZE ? limit - 1 - ipos : ipos;
+        } else {
+            if (ipos < 0)
+                ipos = 0;
+            else if (ipos >= GRADIENT_STOPTABLE_SIZE)
+                ipos = GRADIENT_STOPTABLE_SIZE-1;
+        }
+    }
+
+    Q_ASSERT(ipos >= 0);
+    Q_ASSERT(ipos < GRADIENT_STOPTABLE_SIZE);
+
+    return ipos;
+}
+
+static inline uint qt_gradient_pixel(const QGradientData *data, qreal pos)
+{
+    int ipos = int(pos * (GRADIENT_STOPTABLE_SIZE - 1) + qreal(0.5));
+    return data->colorTable[qt_gradient_clamp(data, ipos)];
+}
+
+static inline qreal qRadialDeterminant(qreal a, qreal b, qreal c)
+{
+    return (b * b) - (4 * a * c);
+}
+
+template <class RadialFetchFunc>
+const uint * QT_FASTCALL qt_fetch_radial_gradient_template(uint *buffer, const Operator *op, const QSpanData *data,
+                                                           int y, int x, int length)
+{
+    // avoid division by zero
+    if (qFuzzyIsNull(op->radial.a)) {
+        extern void (*qt_memfill32)(quint32 *dest, quint32 value, int count);
+        qt_memfill32(buffer, 0, length);
+        return buffer;
+    }
+
+    const uint *b = buffer;
+    qreal rx = data->m21 * (y + qreal(0.5))
+               + data->dx + data->m11 * (x + qreal(0.5));
+    qreal ry = data->m22 * (y + qreal(0.5))
+               + data->dy + data->m12 * (x + qreal(0.5));
+    bool affine = !data->m13 && !data->m23;
+
+    uint *end = buffer + length;
+    if (affine) {
+        rx -= data->gradient.radial.focal.x;
+        ry -= data->gradient.radial.focal.y;
+
+        qreal inv_a = 1 / qreal(2 * op->radial.a);
+
+        const qreal delta_rx = data->m11;
+        const qreal delta_ry = data->m12;
+
+        qreal b = 2*(op->radial.dr*data->gradient.radial.focal.radius + rx * op->radial.dx + ry * op->radial.dy);
+        qreal delta_b = 2*(delta_rx * op->radial.dx + delta_ry * op->radial.dy);
+        const qreal b_delta_b = 2 * b * delta_b;
+        const qreal delta_b_delta_b = 2 * delta_b * delta_b;
+
+        const qreal bb = b * b;
+        const qreal delta_bb = delta_b * delta_b;
+
+        b *= inv_a;
+        delta_b *= inv_a;
+
+        const qreal rxrxryry = rx * rx + ry * ry;
+        const qreal delta_rxrxryry = delta_rx * delta_rx + delta_ry * delta_ry;
+        const qreal rx_plus_ry = 2*(rx * delta_rx + ry * delta_ry);
+        const qreal delta_rx_plus_ry = 2 * delta_rxrxryry;
+
+        inv_a *= inv_a;
+
+        qreal det = (bb - 4 * op->radial.a * (op->radial.sqrfr - rxrxryry)) * inv_a;
+        qreal delta_det = (b_delta_b + delta_bb + 4 * op->radial.a * (rx_plus_ry + delta_rxrxryry)) * inv_a;
+        const qreal delta_delta_det = (delta_b_delta_b + 4 * op->radial.a * delta_rx_plus_ry) * inv_a;
+
+        RadialFetchFunc::fetch(buffer, end, op, data, det, delta_det, delta_delta_det, b, delta_b);
+    } else {
+        qreal rw = data->m23 * (y + qreal(0.5))
+                   + data->m33 + data->m13 * (x + qreal(0.5));
+
+        while (buffer < end) {
+            if (rw == 0) {
+                *buffer = 0;
+            } else {
+                qreal invRw = 1 / rw;
+                qreal gx = rx * invRw - data->gradient.radial.focal.x;
+                qreal gy = ry * invRw - data->gradient.radial.focal.y;
+                qreal b  = 2*(op->radial.dr*data->gradient.radial.focal.radius + gx*op->radial.dx + gy*op->radial.dy);
+                qreal det = qRadialDeterminant(op->radial.a, b, op->radial.sqrfr - (gx*gx + gy*gy));
+
+                quint32 result = 0;
+                if (det >= 0) {
+                    qreal detSqrt = qSqrt(det);
+
+                    qreal s0 = (-b - detSqrt) * op->radial.inv2a;
+                    qreal s1 = (-b + detSqrt) * op->radial.inv2a;
+
+                    qreal s = qMax(s0, s1);
+
+                    if (data->gradient.radial.focal.radius + op->radial.dr * s >= 0)
+                        result = qt_gradient_pixel(&data->gradient, s);
+                }
+
+                *buffer = result;
+            }
+
+            rx += data->m11;
+            ry += data->m12;
+            rw += data->m13;
+
+            ++buffer;
+        }
+    }
+
+    return b;
+}
+
+template <class Simd>
+class QRadialFetchSimd
+{
+public:
+    static void fetch(uint *buffer, uint *end, const Operator *op, const QSpanData *data, qreal det,
+                      qreal delta_det, qreal delta_delta_det, qreal b, qreal delta_b)
+    {
+        typename Simd::Vect_buffer_f det_vec;
+        typename Simd::Vect_buffer_f delta_det4_vec;
+        typename Simd::Vect_buffer_f b_vec;
+
+        for (int i = 0; i < 4; ++i) {
+            det_vec.f[i] = det;
+            delta_det4_vec.f[i] = 4 * delta_det;
+            b_vec.f[i] = b;
+
+            det += delta_det;
+            delta_det += delta_delta_det;
+            b += delta_b;
+        }
+
+        const typename Simd::Float32x4 v_delta_delta_det16 = Simd::v_dup(16 * delta_delta_det);
+        const typename Simd::Float32x4 v_delta_delta_det6 = Simd::v_dup(6 * delta_delta_det);
+        const typename Simd::Float32x4 v_delta_b4 = Simd::v_dup(4 * delta_b);
+
+        const typename Simd::Float32x4 v_r0 = Simd::v_dup(data->gradient.radial.focal.radius);
+        const typename Simd::Float32x4 v_dr = Simd::v_dup(op->radial.dr);
+
+        const typename Simd::Float32x4 v_min = Simd::v_dup(0.0f);
+        const typename Simd::Float32x4 v_max = Simd::v_dup(float(GRADIENT_STOPTABLE_SIZE-1));
+        const typename Simd::Float32x4 v_half = Simd::v_dup(0.5f);
+
+        const typename Simd::Int32x4 v_repeat_mask = Simd::v_dup(~(uint(0xffffff) << GRADIENT_STOPTABLE_SIZE_SHIFT));
+        const typename Simd::Int32x4 v_reflect_mask = Simd::v_dup(~(uint(0xffffff) << (GRADIENT_STOPTABLE_SIZE_SHIFT+1)));
+
+        const typename Simd::Int32x4 v_reflect_limit = Simd::v_dup(2 * GRADIENT_STOPTABLE_SIZE - 1);
+
+        const int extended_mask = op->radial.extended ? 0x0 : ~0x0;
+
+#define FETCH_RADIAL_LOOP_PROLOGUE \
+        while (buffer < end) { \
+            typename Simd::Vect_buffer_i v_buffer_mask; \
+            v_buffer_mask.v = Simd::v_greaterOrEqual(det_vec.v, v_min); \
+            const typename Simd::Float32x4 v_index_local = Simd::v_sub(Simd::v_sqrt(Simd::v_max(v_min, det_vec.v)), b_vec.v); \
+            const typename Simd::Float32x4 v_index = Simd::v_add(Simd::v_mul(v_index_local, v_max), v_half); \
+            v_buffer_mask.v = Simd::v_and(v_buffer_mask.v, Simd::v_greaterOrEqual(Simd::v_add(v_r0, Simd::v_mul(v_dr, v_index_local)), v_min)); \
+            typename Simd::Vect_buffer_i index_vec;
+#define FETCH_RADIAL_LOOP_CLAMP_REPEAT \
+            index_vec.v = Simd::v_and(v_repeat_mask, Simd::v_toInt(v_index));
+#define FETCH_RADIAL_LOOP_CLAMP_REFLECT \
+            const typename Simd::Int32x4 v_index_i = Simd::v_and(v_reflect_mask, Simd::v_toInt(v_index)); \
+            const typename Simd::Int32x4 v_index_i_inv = Simd::v_sub(v_reflect_limit, v_index_i); \
+            index_vec.v = Simd::v_min_16(v_index_i, v_index_i_inv);
+#define FETCH_RADIAL_LOOP_CLAMP_PAD \
+            index_vec.v = Simd::v_toInt(Simd::v_min(v_max, Simd::v_max(v_min, v_index)));
+#define FETCH_RADIAL_LOOP_EPILOGUE \
+            det_vec.v = Simd::v_add(Simd::v_add(det_vec.v, delta_det4_vec.v), v_delta_delta_det6); \
+            delta_det4_vec.v = Simd::v_add(delta_det4_vec.v, v_delta_delta_det16); \
+            b_vec.v = Simd::v_add(b_vec.v, v_delta_b4); \
+            for (int i = 0; i < 4; ++i) \
+                *buffer++ = (extended_mask | v_buffer_mask.i[i]) & data->gradient.colorTable[index_vec.i[i]]; \
+        }
+
+#define FETCH_RADIAL_LOOP(FETCH_RADIAL_LOOP_CLAMP) \
+        FETCH_RADIAL_LOOP_PROLOGUE \
+        FETCH_RADIAL_LOOP_CLAMP \
+        FETCH_RADIAL_LOOP_EPILOGUE
+
+        switch (data->gradient.spread) {
+        case QGradient::RepeatSpread:
+            FETCH_RADIAL_LOOP(FETCH_RADIAL_LOOP_CLAMP_REPEAT)
+            break;
+        case QGradient::ReflectSpread:
+            FETCH_RADIAL_LOOP(FETCH_RADIAL_LOOP_CLAMP_REFLECT)
+            break;
+        case QGradient::PadSpread:
+            FETCH_RADIAL_LOOP(FETCH_RADIAL_LOOP_CLAMP_PAD)
+            break;
+        default:
+            Q_ASSERT(false);
+        }
+    }
+};
+
 #if defined(Q_CC_RVCT)
 #  pragma push
 #  pragma arm
diff --git a/src/gui/painting/qdrawhelper_sse2.cpp b/src/gui/painting/qdrawhelper_sse2.cpp
index aad6bc9..75bb619 100644
--- a/src/gui/painting/qdrawhelper_sse2.cpp
+++ b/src/gui/painting/qdrawhelper_sse2.cpp
@@ -112,8 +112,6 @@ void qt_blend_rgb32_on_rgb32_sse2(uchar *destPixels, int dbpl,
 
                 // First, align dest to 16 bytes:
                 ALIGNMENT_PROLOGUE_16BYTES(dst, x, w) {
-                    quint32 s = src[x];
-                    s = BYTE_MUL(s, const_alpha);
                     dst[x] = INTERPOLATE_PIXEL_255(src[x], const_alpha, dst[x], one_minus_const_alpha);
                 }
 
@@ -127,8 +125,6 @@ void qt_blend_rgb32_on_rgb32_sse2(uchar *destPixels, int dbpl,
                     }
                 }
                 for (; x<w; ++x) {
-                    quint32 s = src[x];
-                    s = BYTE_MUL(s, const_alpha);
                     dst[x] = INTERPOLATE_PIXEL_255(src[x], const_alpha, dst[x], one_minus_const_alpha);
                 }
                 dst = (quint32 *)(((uchar *) dst) + dbpl);
@@ -491,6 +487,58 @@ void qt_bitmapblit16_sse2(QRasterBuffer *rasterBuffer, int x, int y,
     }
 }
 
+class QSimdSse2
+{
+public:
+    typedef __m128i Int32x4;
+    typedef __m128 Float32x4;
+
+    union Vect_buffer_i { Int32x4 v; int i[4]; };
+    union Vect_buffer_f { Float32x4 v; float f[4]; };
+
+    static inline Float32x4 v_dup(float x) { return _mm_set1_ps(x); }
+    static inline Float32x4 v_dup(double x) { return _mm_set1_ps(x); }
+    static inline Int32x4 v_dup(int x) { return _mm_set1_epi32(x); }
+    static inline Int32x4 v_dup(uint x) { return _mm_set1_epi32(x); }
+
+    static inline Float32x4 v_add(Float32x4 a, Float32x4 b) { return _mm_add_ps(a, b); }
+    static inline Int32x4 v_add(Int32x4 a, Int32x4 b) { return _mm_add_epi32(a, b); }
+
+    static inline Float32x4 v_max(Float32x4 a, Float32x4 b) { return _mm_max_ps(a, b); }
+    static inline Float32x4 v_min(Float32x4 a, Float32x4 b) { return _mm_min_ps(a, b); }
+    static inline Int32x4 v_min_16(Int32x4 a, Int32x4 b) { return _mm_min_epi16(a, b); }
+
+    static inline Int32x4 v_and(Int32x4 a, Int32x4 b) { return _mm_and_si128(a, b); }
+
+    static inline Float32x4 v_sub(Float32x4 a, Float32x4 b) { return _mm_sub_ps(a, b); }
+    static inline Int32x4 v_sub(Int32x4 a, Int32x4 b) { return _mm_sub_epi32(a, b); }
+
+    static inline Float32x4 v_mul(Float32x4 a, Float32x4 b) { return _mm_mul_ps(a, b); }
+
+    static inline Float32x4 v_sqrt(Float32x4 x) { return _mm_sqrt_ps(x); }
+
+    static inline Int32x4 v_toInt(Float32x4 x) { return _mm_cvttps_epi32(x); }
+
+    // pre-VS 2008 doesn't have cast intrinsics, whereas 2008 and later requires it
+#if defined(Q_CC_MSVC) && _MSC_VER < 1500
+    static inline Int32x4 v_greaterOrEqual(Float32x4 a, Float32x4 b)
+    {
+        union Convert { Int32x4 vi; Float32x4 vf; } convert;
+        convert.vf = _mm_cmpgt_ps(a, b);
+        return convert.vi;
+    }
+#else
+    static inline Int32x4 v_greaterOrEqual(Float32x4 a, Float32x4 b) { return _mm_castps_si128(_mm_cmpgt_ps(a, b)); }
+#endif
+};
+
+const uint * QT_FASTCALL qt_fetch_radial_gradient_sse2(uint *buffer, const Operator *op, const QSpanData *data,
+                                                       int y, int x, int length)
+{
+    return qt_fetch_radial_gradient_template<QRadialFetchSimd<QSimdSse2> >(buffer, op, data, y, x, length);
+}
+
+
 QT_END_NAMESPACE
 
 #endif // QT_HAVE_SSE2
diff --git a/src/gui/painting/qpaintbuffer.cpp b/src/gui/painting/qpaintbuffer.cpp
index 7870def..51171c5 100644
--- a/src/gui/painting/qpaintbuffer.cpp
+++ b/src/gui/painting/qpaintbuffer.cpp
@@ -535,16 +535,6 @@ QString QPaintBuffer::commandDescription(int command) const
         QTextItemInt &ti = (*tiCopy)();
         QString text(ti.text());
 
-        QFont font(ti.font());
-        font.setUnderline(false);
-        font.setStrikeOut(false);
-        font.setOverline(false);
-
-        const QTextItemInt &si = static_cast<const QTextItemInt &>(ti);
-        qreal justificationWidth = 0;
-        if (si.justified)
-            justificationWidth = si.width.toReal();
-
         debug << "Cmd_DrawTextItem:" << pos << " " << text;
         break; }
     case QPaintBufferPrivate::Cmd_SystemStateChanged: {
diff --git a/src/gui/painting/qpaintengine_mac.cpp b/src/gui/painting/qpaintengine_mac.cpp
index 8aab7c7..cc75b86 100644
--- a/src/gui/painting/qpaintengine_mac.cpp
+++ b/src/gui/painting/qpaintengine_mac.cpp
@@ -1544,8 +1544,9 @@ void QCoreGraphicsPaintEnginePrivate::setFillBrush(const QPointF &offset)
                 QPointF center(radialGrad->center());
                 QPointF focal(radialGrad->focalPoint());
                 qreal radius = radialGrad->radius();
+                qreal focalRadius = radialGrad->focalRadius();
                 shading = CGShadingCreateRadial(colorspace, CGPointMake(focal.x(), focal.y()),
-                                                0.0, CGPointMake(center.x(), center.y()), radius, fill_func, false, true);
+                                                focalRadius, CGPointMake(center.x(), center.y()), radius, fill_func, false, true);
             }
 
             CGFunctionRelease(fill_func);
diff --git a/src/gui/painting/qpaintengine_raster.cpp b/src/gui/painting/qpaintengine_raster.cpp
index 6902543..2119e30 100644
--- a/src/gui/painting/qpaintengine_raster.cpp
+++ b/src/gui/painting/qpaintengine_raster.cpp
@@ -5033,6 +5033,84 @@ void QGradientCache::generateGradientColorTable(const QGradient& gradient, uint
 
     bool colorInterpolation = (gradient.interpolationMode() == QGradient::ColorInterpolation);
 
+    if (stopCount == 2) {
+        uint first_color = ARGB_COMBINE_ALPHA(stops[0].second.rgba(), opacity);
+        uint second_color = ARGB_COMBINE_ALPHA(stops[1].second.rgba(), opacity);
+
+        qreal first_stop = stops[0].first;
+        qreal second_stop = stops[1].first;
+
+        if (second_stop < first_stop) {
+            qSwap(first_color, second_color);
+            qSwap(first_stop, second_stop);
+        }
+
+        if (colorInterpolation) {
+            first_color = PREMUL(first_color);
+            second_color = PREMUL(second_color);
+        }
+
+        int first_index = qRound(first_stop * (GRADIENT_STOPTABLE_SIZE-1));
+        int second_index = qRound(second_stop * (GRADIENT_STOPTABLE_SIZE-1));
+
+        uint red_first = qRed(first_color) << 16;
+        uint green_first = qGreen(first_color) << 16;
+        uint blue_first = qBlue(first_color) << 16;
+        uint alpha_first = qAlpha(first_color) << 16;
+
+        uint red_second = qRed(second_color) << 16;
+        uint green_second = qGreen(second_color) << 16;
+        uint blue_second = qBlue(second_color) << 16;
+        uint alpha_second = qAlpha(second_color) << 16;
+
+        int i = 0;
+        for (; i <= qMin(GRADIENT_STOPTABLE_SIZE, first_index); ++i) {
+            if (colorInterpolation)
+                colorTable[i] = first_color;
+            else
+                colorTable[i] = PREMUL(first_color);
+        }
+
+        if (i < second_index) {
+            qreal reciprocal = qreal(1) / (second_index - first_index);
+
+            int red_delta = qRound(int(red_second - red_first) * reciprocal);
+            int green_delta = qRound(int(green_second - green_first) * reciprocal);
+            int blue_delta = qRound(int(blue_second - blue_first) * reciprocal);
+            int alpha_delta = qRound(int(alpha_second - alpha_first) * reciprocal);
+
+            // rounding
+            red_first += 1 << 15;
+            green_first += 1 << 15;
+            blue_first += 1 << 15;
+            alpha_first += 1 << 15;
+
+            for (; i < qMin(GRADIENT_STOPTABLE_SIZE, second_index); ++i) {
+                red_first += red_delta;
+                green_first += green_delta;
+                blue_first += blue_delta;
+                alpha_first += alpha_delta;
+
+                const uint color = ((alpha_first << 8) & 0xff000000) | (red_first & 0xff0000)
+                                 | ((green_first >> 8) & 0xff00) | (blue_first >> 16);
+
+                if (colorInterpolation)
+                    colorTable[i] = color;
+                else
+                    colorTable[i] = PREMUL(color);
+            }
+        }
+
+        for (; i < GRADIENT_STOPTABLE_SIZE; ++i) {
+            if (colorInterpolation)
+                colorTable[i] = second_color;
+            else
+                colorTable[i] = PREMUL(second_color);
+        }
+
+        return;
+    }
+
     uint current_color = ARGB_COMBINE_ALPHA(stops[0].second.rgba(), opacity);
     if (stopCount == 1) {
         current_color = PREMUL(current_color);
@@ -5204,10 +5282,11 @@ void QSpanData::setup(const QBrush &brush, int alpha, QPainter::CompositionMode
             QPointF center = g->center();
             radialData.center.x = center.x();
             radialData.center.y = center.y();
+            radialData.center.radius = g->centerRadius();
             QPointF focal = g->focalPoint();
             radialData.focal.x = focal.x();
             radialData.focal.y = focal.y();
-            radialData.radius = g->radius();
+            radialData.focal.radius = g->focalRadius();
         }
         break;
 
diff --git a/src/gui/painting/qpaintengine_x11.cpp b/src/gui/painting/qpaintengine_x11.cpp
index 94828fb..6ba9a99 100644
--- a/src/gui/painting/qpaintengine_x11.cpp
+++ b/src/gui/painting/qpaintengine_x11.cpp
@@ -1611,8 +1611,6 @@ void QX11PaintEnginePrivate::fillPolygon_dev(const QPointF *polygonPoints, int p
         && (fill.style() != Qt::NoBrush)
         && ((has_fill_texture && fill.texture().hasAlpha()) || antialias || !solid_fill || has_alpha_pen != has_alpha_brush))
     {
-        QRect br = tessellator->tessellate((QPointF *)clippedPoints, clippedCount,
-                                              mode == QPaintEngine::WindingMode);
         if (tessellator->size > 0) {
             XRenderPictureAttributes attrs;
             attrs.poly_edge = antialias ? PolyEdgeSmooth : PolyEdgeSharp;
@@ -1771,7 +1769,6 @@ void QX11PaintEngine::drawPath(const QPainterPath &path)
     Q_D(QX11PaintEngine);
     if (path.isEmpty())
         return;
-    QTransform old_matrix = d->matrix;
 
     if (d->has_brush)
         d->fillPath(path, QX11PaintEnginePrivate::BrushGC, true);
diff --git a/src/gui/painting/qpaintengineex.cpp b/src/gui/painting/qpaintengineex.cpp
index 509fb77..7f601eb 100644
--- a/src/gui/painting/qpaintengineex.cpp
+++ b/src/gui/painting/qpaintengineex.cpp
@@ -1012,4 +1012,50 @@ void QPaintEngineEx::updateState(const QPaintEngineState &)
     // do nothing...
 }
 
+Q_GUI_EXPORT QPainterPath qt_painterPathFromVectorPath(const QVectorPath &path)
+{
+    const qreal *points = path.points();
+    const QPainterPath::ElementType *types = path.elements();
+
+    QPainterPath p;
+    if (types) {
+        int id = 0;
+        for (int i=0; i<path.elementCount(); ++i) {
+            switch(types[i]) {
+            case QPainterPath::MoveToElement:
+                p.moveTo(QPointF(points[id], points[id+1]));
+                id+=2;
+                break;
+            case QPainterPath::LineToElement:
+                p.lineTo(QPointF(points[id], points[id+1]));
+                id+=2;
+                break;
+            case QPainterPath::CurveToElement: {
+                QPointF p1(points[id], points[id+1]);
+                QPointF p2(points[id+2], points[id+3]);
+                QPointF p3(points[id+4], points[id+5]);
+                p.cubicTo(p1, p2, p3);
+                id+=6;
+                break;
+            }
+            case QPainterPath::CurveToDataElement:
+                ;
+                break;
+            }
+        }
+    } else {
+        p.moveTo(QPointF(points[0], points[1]));
+        int id = 2;
+        for (int i=1; i<path.elementCount(); ++i) {
+            p.lineTo(QPointF(points[id], points[id+1]));
+            id+=2;
+        }
+    }
+    if (path.hints() & QVectorPath::WindingFill)
+        p.setFillRule(Qt::WindingFill);
+
+    return p;
+}
+
+
 QT_END_NAMESPACE
diff --git a/src/gui/painting/qpainter.cpp b/src/gui/painting/qpainter.cpp
index 9fafba5..9e28102 100644
--- a/src/gui/painting/qpainter.cpp
+++ b/src/gui/painting/qpainter.cpp
@@ -156,7 +156,8 @@ static bool qt_paintengine_supports_transformations(QPaintEngine::Type type)
 {
     return type == QPaintEngine::OpenGL2
             || type == QPaintEngine::OpenVG
-            || type == QPaintEngine::OpenGL;
+            || type == QPaintEngine::OpenGL
+            || type == QPaintEngine::CoreGraphics;
 }
 
 #ifndef QT_NO_DEBUG
@@ -503,8 +504,12 @@ void QPainterPrivate::draw_helper(const QPainterPath &originalPath, DrawOperatio
 
     q->save();
     state->matrix = QTransform();
-    state->dirtyFlags |= QPaintEngine::DirtyTransform;
-    updateState(state);
+    if (extended) {
+        extended->transformChanged();
+    } else {
+        state->dirtyFlags |= QPaintEngine::DirtyTransform;
+        updateState(state);
+    }
     engine->drawImage(absPathRect,
                  image,
                  QRectF(0, 0, absPathRect.width(), absPathRect.height()),
@@ -687,11 +692,14 @@ void QPainterPrivate::updateInvMatrix()
     invMatrix = state->matrix.inverted();
 }
 
+extern bool qt_isExtendedRadialGradient(const QBrush &brush);
+
 void QPainterPrivate::updateEmulationSpecifier(QPainterState *s)
 {
     bool alpha = false;
     bool linearGradient = false;
     bool radialGradient = false;
+    bool extendedRadialGradient = false;
     bool conicalGradient = false;
     bool patternBrush = false;
     bool xform = false;
@@ -723,6 +731,7 @@ void QPainterPrivate::updateEmulationSpecifier(QPainterState *s)
                            (brushStyle == Qt::LinearGradientPattern));
         radialGradient = ((penBrushStyle == Qt::RadialGradientPattern) ||
                            (brushStyle == Qt::RadialGradientPattern));
+        extendedRadialGradient = radialGradient && (qt_isExtendedRadialGradient(penBrush) || qt_isExtendedRadialGradient(s->brush));
         conicalGradient = ((penBrushStyle == Qt::ConicalGradientPattern) ||
                             (brushStyle == Qt::ConicalGradientPattern));
         patternBrush = (((penBrushStyle > Qt::SolidPattern
@@ -806,7 +815,7 @@ void QPainterPrivate::updateEmulationSpecifier(QPainterState *s)
         s->emulationSpecifier &= ~QPaintEngine::LinearGradientFill;
 
     // Radial gradient emulation
-    if (radialGradient && !engine->hasFeature(QPaintEngine::RadialGradientFill))
+    if (extendedRadialGradient || (radialGradient && !engine->hasFeature(QPaintEngine::RadialGradientFill)))
         s->emulationSpecifier |= QPaintEngine::RadialGradientFill;
     else
         s->emulationSpecifier &= ~QPaintEngine::RadialGradientFill;
@@ -5809,7 +5818,7 @@ void QPainter::drawGlyphs(const QPointF &position, const QGlyphs &glyphs)
     bool paintEngineSupportsTransformations =
             d->extended != 0
             ? qt_paintengine_supports_transformations(d->extended->type())
-            : false;
+            : qt_paintengine_supports_transformations(d->engine->type());
     for (int i=0; i<count; ++i) {
         QPointF processedPosition = position + glyphPositions.at(i);
         if (!paintEngineSupportsTransformations)
diff --git a/src/gui/painting/qpainter.h b/src/gui/painting/qpainter.h
index 4b2c447..1a432e6 100644
--- a/src/gui/painting/qpainter.h
+++ b/src/gui/painting/qpainter.h
@@ -553,6 +553,7 @@ private:
     friend class QPaintEngine;
     friend class QPaintEngineExPrivate;
     friend class QOpenGLPaintEngine;
+    friend class QVGPaintEngine;
     friend class QX11PaintEngine;
     friend class QX11PaintEnginePrivate;
     friend class QWin32PaintEngine;
diff --git a/src/gui/painting/qpainterpath.cpp b/src/gui/painting/qpainterpath.cpp
index 27aed32..9fbac13 100644
--- a/src/gui/painting/qpainterpath.cpp
+++ b/src/gui/painting/qpainterpath.cpp
@@ -1126,6 +1126,7 @@ void QPainterPath::addText(const QPointF &point, const QFont &f, const QString &
     QTextEngine *eng = layout.engine();
     layout.beginLayout();
     QTextLine line = layout.createLine();
+    Q_UNUSED(line);
     layout.endLayout();
     const QScriptLine &sl = eng->lines[0];
     if (!sl.length || !eng->layoutData)
diff --git a/src/gui/painting/qprintengine_pdf.cpp b/src/gui/painting/qprintengine_pdf.cpp
index b7f5160..353869f 100644
--- a/src/gui/painting/qprintengine_pdf.cpp
+++ b/src/gui/painting/qprintengine_pdf.cpp
@@ -534,7 +534,10 @@ int QPdfEnginePrivate::addImage(const QImage &img, bool *bitmap, qint64 serial_n
 
     QImage image = img;
     QImage::Format format = image.format();
-    if (image.depth() == 1 && *bitmap && img.colorTable().size() == 0) {
+    if (image.depth() == 1 && *bitmap && img.colorTable().size() == 2
+        && img.colorTable().at(0) == QColor(Qt::black).rgba()
+        && img.colorTable().at(1) == QColor(Qt::white).rgba())
+    {
         if (format == QImage::Format_MonoLSB)
             image = image.convertToFormat(QImage::Format_Mono);
         format = QImage::Format_Mono;
diff --git a/src/gui/painting/qstroker.cpp b/src/gui/painting/qstroker.cpp
index fca46b4..dd723ed 100644
--- a/src/gui/painting/qstroker.cpp
+++ b/src/gui/painting/qstroker.cpp
@@ -552,6 +552,7 @@ void QStroker::joinPoints(qfixed focal_x, qfixed focal_y, const QLineF &nextLine
 
 //             // line to the beginning of the arc segment, (should not be needed).
 //             emitLineTo(qt_real_to_fixed(curve_start.x()), qt_real_to_fixed(curve_start.y()));
+            Q_UNUSED(curve_start);
 
             for (int i=0; i<point_count; i+=3) {
                 emitCubicTo(qt_real_to_fixed(curves[i].x()),
diff --git a/src/gui/painting/qtextureglyphcache.cpp b/src/gui/painting/qtextureglyphcache.cpp
index 53f025f..e9e56a2 100644
--- a/src/gui/painting/qtextureglyphcache.cpp
+++ b/src/gui/painting/qtextureglyphcache.cpp
@@ -296,7 +296,7 @@ void QTextureGlyphCache::fillInPendingGlyphs()
 QImage QTextureGlyphCache::textureMapForGlyph(glyph_t g, QFixed subPixelPosition) const
 {
 #if defined(Q_WS_X11)
-    if (m_transform.type() > QTransform::TxTranslate) {
+    if (m_transform.type() > QTransform::TxTranslate && m_current_fontengine->type() == QFontEngine::Freetype) {
         QFontEngineFT::GlyphFormat format = QFontEngineFT::Format_None;
         QImage::Format imageFormat = QImage::Format_Invalid;
         switch (m_type) {
diff --git a/src/gui/painting/qunifiedtoolbarsurface_mac.cpp b/src/gui/painting/qunifiedtoolbarsurface_mac.cpp
index 3876c3d..2fda6b9 100644
--- a/src/gui/painting/qunifiedtoolbarsurface_mac.cpp
+++ b/src/gui/painting/qunifiedtoolbarsurface_mac.cpp
@@ -152,7 +152,8 @@ void QUnifiedToolbarSurface::beginPaint(const QRegion &rgn)
 void QUnifiedToolbarSurface::updateToolbarOffset(QWidget *widget)
 {
     QMainWindowLayout *mlayout = qobject_cast<QMainWindowLayout*> (widget->window()->layout());
-    mlayout->updateUnifiedToolbarOffset();
+    if (mlayout)
+        mlayout->updateUnifiedToolbarOffset();
 }
 
 void QUnifiedToolbarSurface::flush(QWidget *widget, const QRegion &region, const QPoint &offset)
diff --git a/src/gui/styles/qcleanlooksstyle.cpp b/src/gui/styles/qcleanlooksstyle.cpp
index cc5fe10..786aab3 100644
--- a/src/gui/styles/qcleanlooksstyle.cpp
+++ b/src/gui/styles/qcleanlooksstyle.cpp
@@ -841,7 +841,6 @@ void QCleanlooksStyle::drawPrimitive(PrimitiveElement elem,
     case PE_PanelButtonTool:
         painter->save();
         if ((option->state & State_Enabled || option->state & State_On) || !(option->state & State_AutoRaise)) {
-            QRect rect = option->rect;
             QPen oldPen = painter->pen();
 
             if (widget && widget->inherits("QDockWidgetTitleButton")) {
@@ -1241,7 +1240,6 @@ void QCleanlooksStyle::drawPrimitive(PrimitiveElement elem,
         if (const QStyleOptionTabWidgetFrame *twf = qstyleoption_cast<const QStyleOptionTabWidgetFrame *>(option)) {
             QColor borderColor = darkOutline.lighter(110);
             QColor alphaCornerColor = mergedColors(borderColor, option->palette.background().color());
-            QColor innerShadow = mergedColors(borderColor, option->palette.base().color());
 
             int borderThickness = proxy()->pixelMetric(PM_TabBarBaseOverlap, twf, widget);
             bool reverse = (twf->direction == Qt::RightToLeft);
@@ -1879,7 +1877,6 @@ void QCleanlooksStyle::drawControl(ControlElement element, const QStyleOption *o
             } else {
                 alphaCornerColor = mergedColors(option->palette.background().color(), borderColor);
             }
-            QColor alphaTextColor = mergedColors(option->palette.background().color(), option->palette.text().color());
             if (menuItem->menuItemType == QStyleOptionMenuItem::Separator) {
                 painter->fillRect(menuItem->rect, menuBackground);
                 int w = 0;
@@ -2220,7 +2217,6 @@ void QCleanlooksStyle::drawControl(ControlElement element, const QStyleOption *o
                                     && tabBarAlignment == Qt::AlignLeft);
 
             QColor light = tab->palette.light().color();
-            QColor midlight = tab->palette.midlight().color();
 
             QColor background = tab->palette.background().color();
             int borderThinkness = proxy()->pixelMetric(PM_TabBarBaseOverlap, tab, widget);
@@ -2444,14 +2440,6 @@ void QCleanlooksStyle::drawComplexControl(ComplexControl control, const QStyleOp
     QColor gradientStartColor = option->palette.button().color().lighter(108);
     QColor gradientStopColor = mergedColors(option->palette.button().color().darker(108), dark.lighter(150), 70);
 
-    QColor highlightedGradientStartColor = option->palette.button().color();
-    QColor highlightedGradientStopColor = mergedColors(option->palette.button().color(), option->palette.highlight().color(), 85);
-
-    QColor highlightedDarkInnerBorderColor = mergedColors(option->palette.button().color(), option->palette.highlight().color(), 35);
-    QColor highlightedLightInnerBorderColor = mergedColors(option->palette.button().color(), option->palette.highlight().color(), 58);
-
-    QColor buttonShadowAlpha = option->palette.background().color().darker(105);
-
     QPalette palette = option->palette;
 
     switch (control) {
@@ -3437,7 +3425,6 @@ void QCleanlooksStyle::drawComplexControl(ComplexControl control, const QStyleOp
         if (const QStyleOptionSlider *slider = qstyleoption_cast<const QStyleOptionSlider *>(option)) {
             QRect groove = proxy()->subControlRect(CC_Slider, option, SC_SliderGroove, widget);
             QRect handle = proxy()->subControlRect(CC_Slider, option, SC_SliderHandle, widget);
-            QRect ticks = proxy()->subControlRect(CC_Slider, option, SC_SliderTickmarks, widget);
 
             bool horizontal = slider->orientation == Qt::Horizontal;
             bool ticksAbove = slider->tickPosition & QSlider::TicksAbove;
@@ -3539,8 +3526,6 @@ void QCleanlooksStyle::drawComplexControl(ComplexControl control, const QStyleOp
                     QRect pixmapRect(0, 0, handle.width(), handle.height());
                     QPainter handlePainter(&cache);
 
-                    QColor highlightedGradientStartColor = option->palette.button().color();
-                    QColor highlightedGradientStopColor = option->palette.light().color();
                     QColor gradientStartColor = mergedColors(option->palette.button().color().lighter(155),
                                                              dark.lighter(155), 50);
                     QColor gradientStopColor = gradientStartColor.darker(108);
@@ -3557,7 +3542,6 @@ void QCleanlooksStyle::drawComplexControl(ComplexControl control, const QStyleOp
                     }
 
                     // gradient fill
-                    QRect innerBorder = gradRect;
                     QRect r = pixmapRect.adjusted(1, 1, -1, -1);
 
                     qt_cleanlooks_draw_gradient(&handlePainter, gradRect,
diff --git a/src/gui/styles/qcommonstyle.cpp b/src/gui/styles/qcommonstyle.cpp
index 8f99d6a..95ebdb4 100644
--- a/src/gui/styles/qcommonstyle.cpp
+++ b/src/gui/styles/qcommonstyle.cpp
@@ -223,16 +223,13 @@ void QCommonStyle::drawPrimitive(PrimitiveElement pe, const QStyleOption *opt, Q
             --yy;
         }
         if (!(opt->state & State_Enabled) && !(opt->state & State_On)) {
-            int pnt;
-            p->setPen(opt->palette.highlightedText().color());
-            QPoint offset(1, 1);
-            for (pnt = 0; pnt < a.size(); ++pnt)
-                a[pnt].translate(offset.x(), offset.y());
+            p->save();
+            p->translate(1, 1);
+            p->setPen(opt->palette.light().color());
             p->drawLines(a);
-            for (pnt = 0; pnt < a.size(); ++pnt)
-                a[pnt].translate(offset.x(), offset.y());
+            p->restore();
         }
-        p->setPen(opt->palette.text().color());
+        p->setPen((opt->state & State_On) ? opt->palette.highlightedText().color() : opt->palette.text().color());
         p->drawLines(a);
         break; }
     case PE_Frame:
@@ -919,6 +916,7 @@ static QSizeF viewItemTextLayout(QTextLayout &textLayout, int lineWidth)
     return QSizeF(widthUsed, height);
 }
 
+
 void QCommonStylePrivate::viewItemDrawText(QPainter *p, const QStyleOptionViewItemV4 *option, const QRect &rect) const
 {
     Q_Q(const QCommonStyle);
@@ -936,7 +934,7 @@ void QCommonStylePrivate::viewItemDrawText(QPainter *p, const QStyleOptionViewIt
     textLayout.setFont(option->font);
     textLayout.setText(option->text);
 
-    QSizeF textLayoutSize = viewItemTextLayout(textLayout, textRect.width());
+    viewItemTextLayout(textLayout, textRect.width());
 
     QString elidedText;
     qreal height = 0;
diff --git a/src/gui/styles/qgtkpainter.cpp b/src/gui/styles/qgtkpainter.cpp
index 68ade04..6258fe4 100644
--- a/src/gui/styles/qgtkpainter.cpp
+++ b/src/gui/styles/qgtkpainter.cpp
@@ -586,7 +586,6 @@ void QGtkPainter::paintShadow(GtkWidget *gtkWidget, const gchar* part,
     if (!rect.isValid())
         return;
 
-    QRect r = rect;
     QPixmap cache;
     QString pixmapName = uniqueName(QLS(part), state, shadow, rect.size()) % pmKey;
     if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
@@ -605,7 +604,6 @@ void QGtkPainter::paintFlatBox(GtkWidget *gtkWidget, const gchar* part,
 {
     if (!rect.isValid())
         return;
-    QRect r = rect;
     QPixmap cache;
     QString pixmapName = uniqueName(QLS(part), state, shadow, rect.size()) % pmKey;
     if (!m_usePixmapCache || !QPixmapCache::find(pixmapName, cache)) {
@@ -632,7 +630,6 @@ void QGtkPainter::paintExtention(GtkWidget *gtkWidget,
     if (!rect.isValid())
         return;
 
-    QRect r = rect;
     QPixmap cache;
     QString pixmapName = uniqueName(QLS(part), state, shadow, rect.size(), gtkWidget)
                          % HexString<uchar>(gap_pos);
@@ -660,7 +657,6 @@ void QGtkPainter::paintOption(GtkWidget *gtkWidget, const QRect &radiorect,
     if (!rect.isValid())
         return;
 
-    QRect r = rect;
     QPixmap cache;
     QString pixmapName = uniqueName(detail, state, shadow, rect.size());
     GdkRectangle gtkCliprect = {0, 0, rect.width(), rect.height()};
@@ -692,7 +688,6 @@ void QGtkPainter::paintCheckbox(GtkWidget *gtkWidget, const QRect &checkrect,
     if (!rect.isValid())
         return;
 
-    QRect r = rect;
     QPixmap cache;
     QString pixmapName = uniqueName(detail, state, shadow, rect.size());
     GdkRectangle gtkCliprect = {0, 0, rect.width(), rect.height()};
diff --git a/src/gui/styles/qgtkstyle.cpp b/src/gui/styles/qgtkstyle.cpp
index 277e302..d6dd527 100644
--- a/src/gui/styles/qgtkstyle.cpp
+++ b/src/gui/styles/qgtkstyle.cpp
@@ -782,7 +782,6 @@ void QGtkStyle::drawPrimitive(PrimitiveElement element,
             GtkStateType state = gtkPainter.gtkState(option);
             style = gtkTreeHeader->style;
             GtkArrowType type = GTK_ARROW_UP;
-            QRect r = header->rect;
             QImage arrow;
             // This sorting indicator inversion is intentional, and follows the GNOME HIG.
             // See http://library.gnome.org/devel/hig-book/stable/controls-lists.html.en#controls-lists-sortable
@@ -1857,7 +1856,6 @@ void QGtkStyle::drawComplexControl(ComplexControl control, const QStyleOptionCom
                     editArea.setRight(upRect.left());
             }
             if (spinBox->frame) {
-                GtkShadowType shadow = GTK_SHADOW_OUT;
                 GtkStateType state = gtkPainter.gtkState(option);
 
                 if (!(option->state & State_Enabled))
@@ -1867,7 +1865,6 @@ void QGtkStyle::drawComplexControl(ComplexControl control, const QStyleOptionCom
                 else if (state == GTK_STATE_PRELIGHT)
                     state = GTK_STATE_NORMAL;
 
-                shadow = GTK_SHADOW_IN;
                 style = gtkPainter.getStyle(gtkSpinButton);
 
 
diff --git a/src/gui/styles/qmacstyle_mac.mm b/src/gui/styles/qmacstyle_mac.mm
index 2d21628..18003ce 100644
--- a/src/gui/styles/qmacstyle_mac.mm
+++ b/src/gui/styles/qmacstyle_mac.mm
@@ -4707,7 +4707,7 @@ void QMacStyle::drawComplexControl(ComplexControl cc, const QStyleOptionComplex
 
                 HIThemeFrameDrawInfo fdi;
                 fdi.version = qt_mac_hitheme_version;
-                fdi.state = kThemeStateInactive;
+                fdi.state = tds;
                 fdi.kind = kHIThemeFrameTextFieldSquare;
                 fdi.isFocused = false;
                 HIRect hirect = qt_hirectForQRect(lineeditRect);
diff --git a/src/gui/styles/qplastiquestyle.cpp b/src/gui/styles/qplastiquestyle.cpp
index 02ce60e..1d33212 100644
--- a/src/gui/styles/qplastiquestyle.cpp
+++ b/src/gui/styles/qplastiquestyle.cpp
@@ -2007,14 +2007,10 @@ void QPlastiqueStyle::drawControl(ControlElement element, const QStyleOption *op
     } else {
         alphaCornerColor = mergedColors(option->palette.background().color(), borderColor);
     }
-    QColor alphaTextColor = mergedColors(option->palette.background().color(), option->palette.text().color());
 
     QColor gradientStartColor = option->palette.button().color().lighter(104);
     QColor gradientStopColor = option->palette.button().color().darker(105);
 
-    QColor shadowGradientStartColor = option->palette.button().color().darker(115);
-    QColor shadowGradientStopColor = option->palette.button().color().darker(120);
-
     QColor highlightedGradientStartColor = option->palette.button().color().lighter(101);
     QColor highlightedGradientStopColor = mergedColors(option->palette.button().color(), option->palette.highlight().color(), 85);
 
@@ -2025,8 +2021,6 @@ void QPlastiqueStyle::drawControl(ControlElement element, const QStyleOption *op
     QColor highlightedLightInnerBorderColor = mergedColors(option->palette.button().color(), option->palette.highlight().color(), 58);
 
     QColor alphaInnerColor = mergedColors(highlightedDarkInnerBorderColor, option->palette.base().color());
-    QColor lightShadow = lightShadowGradientStartColor;
-    QColor shadow = shadowGradientStartColor;
 
     switch (element) {
 #ifndef QT_NO_TABBAR
@@ -3786,10 +3780,6 @@ void QPlastiqueStyle::drawComplexControl(ComplexControl control, const QStyleOpt
     }
     QColor gradientStartColor = option->palette.button().color().lighter(104);
     QColor gradientStopColor = option->palette.button().color().darker(105);
-    QColor highlightedGradientStartColor = option->palette.button().color().lighter(101);
-    QColor highlightedGradientStopColor = mergedColors(option->palette.button().color(), option->palette.highlight().color(), 85);
-    QColor highlightedDarkInnerBorderColor = mergedColors(option->palette.button().color(), option->palette.highlight().color(), 35);
-    QColor highlightedLightInnerBorderColor = mergedColors(option->palette.button().color(), option->palette.highlight().color(), 58);
 
     switch (control) {
 #ifndef QT_NO_SLIDER
@@ -3797,7 +3787,6 @@ void QPlastiqueStyle::drawComplexControl(ComplexControl control, const QStyleOpt
         if (const QStyleOptionSlider *slider = qstyleoption_cast<const QStyleOptionSlider *>(option)) {
             QRect grooveRegion = proxy()->subControlRect(CC_Slider, option, SC_SliderGroove, widget);
             QRect handle = proxy()->subControlRect(CC_Slider, option, SC_SliderHandle, widget);
-            QRect ticks = proxy()->subControlRect(CC_Slider, option, SC_SliderTickmarks, widget);
             bool horizontal = slider->orientation == Qt::Horizontal;
             bool ticksAbove = slider->tickPosition & QSlider::TicksAbove;
             bool ticksBelow = slider->tickPosition & QSlider::TicksBelow;
diff --git a/src/gui/styles/qwindowsstyle.cpp b/src/gui/styles/qwindowsstyle.cpp
index 44f3f92..754486e 100644
--- a/src/gui/styles/qwindowsstyle.cpp
+++ b/src/gui/styles/qwindowsstyle.cpp
@@ -1858,8 +1858,8 @@ void QWindowsStyle::drawControl(ControlElement ce, const QStyleOption *opt, QPai
             }
 
             QRect vCheckRect = visualRect(opt->direction, menuitem->rect, QRect(menuitem->rect.x(), menuitem->rect.y(), checkcol, menuitem->rect.height()));
-            if (checked) {
-                if (act && !dis) {
+            if (!menuitem->icon.isNull() && checked) {
+                if (act) {
                     qDrawShadePanel(p, vCheckRect,
                                     menuitem->palette, true, 1,
                                     &menuitem->palette.brush(QPalette::Button));
@@ -2028,10 +2028,8 @@ void QWindowsStyle::drawControl(ControlElement ce, const QStyleOption *opt, QPai
                                          && tabBarAlignment == Qt::AlignLeft);
 
             QColor light = tab->palette.light().color();
-            QColor midlight = tab->palette.midlight().color();
             QColor dark = tab->palette.dark().color();
             QColor shadow = tab->palette.shadow().color();
-            QColor background = tab->palette.background().color();
             int borderThinkness = proxy()->pixelMetric(PM_TabBarBaseOverlap, tab, widget);
             if (selected)
                 borderThinkness /= 2;
diff --git a/src/gui/styles/qwindowsvistastyle.cpp b/src/gui/styles/qwindowsvistastyle.cpp
index 7f1a3ab..123741e 100644
--- a/src/gui/styles/qwindowsvistastyle.cpp
+++ b/src/gui/styles/qwindowsvistastyle.cpp
@@ -969,7 +969,8 @@ void QWindowsVistaStyle::drawControl(ControlElement element, const QStyleOption
         if (const QStyleOptionButton *btn = qstyleoption_cast<const QStyleOptionButton *>(option))
         {
 
-            if (QWindowsVistaAnimation *anim = d->widgetAnimation(widget)) {
+            QWindowsVistaAnimation *anim = d->widgetAnimation(widget);
+            if (anim && (btn->state & State_Enabled)) {
                 anim->paint(painter, option);
             } else {
                 name = QLatin1String("BUTTON");
@@ -996,7 +997,6 @@ void QWindowsVistaStyle::drawControl(ControlElement element, const QStyleOption
                         !(state & (State_Sunken | State_On)) && !(state & State_MouseOver) &&
                          (state & State_Enabled) && (state & State_Active))
                         {
-                        QWindowsVistaAnimation *anim = d->widgetAnimation(widget);
                         if (!anim && widget) {
                             QImage startImage(option->rect.size(), QImage::Format_ARGB32_Premultiplied);
                             startImage.fill(0);
@@ -1074,8 +1074,8 @@ void QWindowsVistaStyle::drawControl(ControlElement element, const QStyleOption
             }
 
             if (const QProgressBar *progressbar = qobject_cast<const QProgressBar *>(widget)) {
-                if (((progressbar->value() > 0  && d->transitionsEnabled()) || isIndeterminate)) {
-                    if (!d->widgetAnimation(progressbar) && progressbar->value() < progressbar->maximum()) {
+                if (isIndeterminate || (progressbar->value() > 0 && (progressbar->value() < progressbar->maximum()) && d->transitionsEnabled())) {
+                    if (!d->widgetAnimation(progressbar)) {
                         QWindowsVistaAnimation *a = new QWindowsVistaAnimation;
                         a->setWidget(const_cast<QWidget*>(widget));
                         a->setStartTime(QTime::currentTime());
@@ -2502,7 +2502,6 @@ void QWindowsVistaStylePrivate::timerEvent()
             animations[i]->widget()->update();
 
         if (!animations[i]->widget() ||
-            !animations[i]->widget()->isEnabled() ||
             !animations[i]->widget()->isVisible() ||
             animations[i]->widget()->window()->isMinimized() ||
             !animations[i]->running() ||
diff --git a/src/gui/styles/qwindowsxpstyle.cpp b/src/gui/styles/qwindowsxpstyle.cpp
index 74a20fc..4b2c3a5 100644
--- a/src/gui/styles/qwindowsxpstyle.cpp
+++ b/src/gui/styles/qwindowsxpstyle.cpp
@@ -1196,8 +1196,14 @@ QRect QWindowsXPStyle::subElementRect(SubElement sr, const QStyleOption *option,
         if (qstyleoption_cast<const QStyleOptionTabWidgetFrame *>(option))
         {
             rect = QWindowsStyle::subElementRect(sr, option, widget);
-            if (sr == SE_TabWidgetTabContents)
-                   rect.adjust(0, 0, -2, -2);
+            if (sr == SE_TabWidgetTabContents) {
+                if (const QTabWidget *tabWidget = qobject_cast<const QTabWidget *>(widget)) {
+                    if (tabWidget->documentMode())
+                        break;
+                }
+
+                rect.adjust(0, 0, -2, -2);
+            }
         }
         break;
     case SE_TabWidgetTabBar: {
diff --git a/src/gui/text/qfont.h b/src/gui/text/qfont.h
index 8dbc746..0c7b6f8 100644
--- a/src/gui/text/qfont.h
+++ b/src/gui/text/qfont.h
@@ -239,7 +239,7 @@ public:
     bool isCopyOf(const QFont &) const;
 #ifdef Q_COMPILER_RVALUE_REFS
     inline QFont &operator=(QFont &&other)
-    { qSwap(d, other.d); return *this; }
+    { qSwap(d, other.d); qSwap(resolve_mask, other.resolve_mask);  return *this; }
 #endif
 
 #ifdef Q_WS_WIN
diff --git a/src/gui/text/qfontengine_coretext.mm b/src/gui/text/qfontengine_coretext.mm
index 20b3730..d4df218 100644
--- a/src/gui/text/qfontengine_coretext.mm
+++ b/src/gui/text/qfontengine_coretext.mm
@@ -162,8 +162,10 @@ uint QCoreTextFontEngineMulti::fontIndexForFont(CTFontRef font) const
     return engines.count() - 1;
 }
 
-bool QCoreTextFontEngineMulti::stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, QTextEngine::ShaperFlags flags,
-                  unsigned short *logClusters, const HB_CharAttributes *) const
+bool QCoreTextFontEngineMulti::stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs,
+                                            int *nglyphs, QTextEngine::ShaperFlags flags,
+                                            unsigned short *logClusters, const HB_CharAttributes *,
+                                            QScriptItem *si) const
 {
     QCFType<CFStringRef> cfstring = CFStringCreateWithCharactersNoCopy(0,
                                                                reinterpret_cast<const UniChar *>(str),
@@ -180,6 +182,8 @@ bool QCoreTextFontEngineMulti::stringToCMap(const QChar *str, int len, QGlyphLay
                                                               &kCFCopyStringDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
         typeSetter = CTTypesetterCreateWithAttributedStringAndOptions(attributedString, options);
     } else
+#else
+    Q_UNUSED(flags);
 #endif
         typeSetter = CTTypesetterCreateWithAttributedString(attributedString);
 
@@ -219,6 +223,25 @@ bool QCoreTextFontEngineMulti::stringToCMap(const QChar *str, int len, QGlyphLay
 
         Q_ASSERT((CTRunGetStatus(run) & kCTRunStatusRightToLeft) == rtl);
         CFRange stringRange = CTRunGetStringRange(run);
+        int prepend = 0;
+#if MAC_OS_X_VERSION_MAX_ALLOWED == MAC_OS_X_VERSION_10_5
+        UniChar beginGlyph = CFStringGetCharacterAtIndex(cfstring, stringRange.location);
+        QChar dir = QChar::direction(beginGlyph);
+        bool beginWithOverride = dir == QChar::DirLRO || dir == QChar::DirRLO || dir == QChar::DirLRE || dir == QChar::DirRLE;
+        if (beginWithOverride) {
+            logClusters[stringRange.location] = 0;
+            outGlyphs[0] = 0xFFFF;
+            outAdvances_x[0] = 0;
+            outAdvances_y[0] = 0;
+            outAttributes[0].clusterStart = true;
+            outAttributes[0].dontPrint = true;
+            outGlyphs++;
+            outAdvances_x++;
+            outAdvances_y++;
+            outAttributes++;
+            prepend = 1;
+        }
+#endif
         UniChar endGlyph = CFStringGetCharacterAtIndex(cfstring, stringRange.location + stringRange.length - 1);
         bool endWithPDF = QChar::direction(endGlyph) == QChar::DirPDF;
         if (endWithPDF)
@@ -233,7 +256,12 @@ bool QCoreTextFontEngineMulti::stringToCMap(const QChar *str, int len, QGlyphLay
             if (!runAttribs)
                 runAttribs = attributeDict;
             CTFontRef runFont = static_cast<CTFontRef>(CFDictionaryGetValue(runAttribs, NSFontAttributeName));
-            const uint fontIndex = (fontIndexForFont(runFont) << 24);
+            uint fontIndex = fontIndexForFont(runFont);
+            const QFontEngine *engine = engineAt(fontIndex);
+            fontIndex <<= 24;
+            si->ascent = qMax(engine->ascent(), si->ascent);
+            si->descent = qMax(engine->descent(), si->descent);
+            si->leading = qMax(engine->leading(), si->leading);
             //NSLog(@"Run Font Name = %@", CTFontCopyFamilyName(runFont));
             if (endWithPDF)
                 glyphCount--;
@@ -271,9 +299,9 @@ bool QCoreTextFontEngineMulti::stringToCMap(const QChar *str, int len, QGlyphLay
 
                 CFIndex k = 0;
                 CFIndex i = 0;
-                for (i = stringRange.location;
+                for (i = stringRange.location + prepend;
                      (i < stringRange.location + stringRange.length) && (k < glyphCount); ++i) {
-                    if (tmpIndices[k * rtlSign + rtlOffset] == i || i == stringRange.location) {
+                    if (tmpIndices[k * rtlSign + rtlOffset] == i || i == stringRange.location + prepend) {
                         logClusters[i] = k + firstGlyphIndex;
                         outAttributes[k].clusterStart = true;
                         ++k;
@@ -308,7 +336,7 @@ bool QCoreTextFontEngineMulti::stringToCMap(const QChar *str, int len, QGlyphLay
                     : QFixed::fromReal(lastGlyphAdvance.width);
 
             if (endWithPDF) {
-                logClusters[stringRange.location + stringRange.length - 1] = glyphCount;
+                logClusters[stringRange.location + stringRange.length - 1] = glyphCount + prepend;
                 outGlyphs[glyphCount] = 0xFFFF;
                 outAdvances_x[glyphCount] = 0;
                 outAdvances_y[glyphCount] = 0;
@@ -837,6 +865,15 @@ QFixed QCoreTextFontEngine::emSquareSize() const
     return QFixed::QFixed(int(CTFontGetUnitsPerEm(ctfont)));
 }
 
+QFontEngine *QCoreTextFontEngine::cloneWithSize(qreal pixelSize) const
+{
+    QFontDef newFontDef = fontDef;
+    newFontDef.pixelSize = pixelSize;
+    newFontDef.pointSize = pixelSize * 72.0 / qt_defaultDpi();
+
+    return new QCoreTextFontEngine(cgFont, fontDef);
+}
+
 QT_END_NAMESPACE
 
 #endif// !defined(Q_WS_MAC) || (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5)
diff --git a/src/gui/text/qfontengine_coretext_p.h b/src/gui/text/qfontengine_coretext_p.h
index 1503c3f..bb80a9b 100644
--- a/src/gui/text/qfontengine_coretext_p.h
+++ b/src/gui/text/qfontengine_coretext_p.h
@@ -91,6 +91,8 @@ public:
     virtual qreal minLeftBearing() const;
     virtual QFixed emSquareSize() const;
 
+    virtual QFontEngine *cloneWithSize(qreal pixelSize) const;
+
 private:
     friend class QRawFontPrivate;
 
@@ -118,7 +120,8 @@ public:
                               QTextEngine::ShaperFlags flags) const;
     bool stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs,
                       QTextEngine::ShaperFlags flags,
-                      unsigned short *logClusters, const HB_CharAttributes *charAttributes) const;
+                      unsigned short *logClusters, const HB_CharAttributes *charAttributes,
+                      QScriptItem *si) const;
 
     virtual const char *name() const { return "CoreText"; }
 protected:
diff --git a/src/gui/text/qfontengine_ft.cpp b/src/gui/text/qfontengine_ft.cpp
index 8f2da9b..237cde4 100644
--- a/src/gui/text/qfontengine_ft.cpp
+++ b/src/gui/text/qfontengine_ft.cpp
@@ -803,106 +803,6 @@ int QFontEngineFT::loadFlags(QGlyphSet *set, GlyphFormat format, int flags,
     return load_flags;
 }
 
-QFontEngineFT::Glyph *QFontEngineFT::loadGlyphMetrics(QGlyphSet *set, uint glyph, GlyphFormat format) const
-{
-    Glyph *g = set->getGlyph(glyph);
-    if (g && g->format == format)
-        return g;
-
-    bool hsubpixel = false;
-    int vfactor = 1;
-    int load_flags = loadFlags(set, format, 0, hsubpixel, vfactor);
-
-    // apply our matrix to this, but note that the metrics will not be affected by this.
-    FT_Face face = lockFace();
-    FT_Matrix matrix = this->matrix;
-    FT_Matrix_Multiply(&set->transformationMatrix, &matrix);
-    FT_Set_Transform(face, &matrix, 0);
-    freetype->matrix = matrix;
-
-    bool transform = matrix.xx != 0x10000 || matrix.yy != 0x10000 || matrix.xy != 0 || matrix.yx != 0;
-    if (transform)
-        load_flags |= FT_LOAD_NO_BITMAP;
-
-    FT_Error err = FT_Load_Glyph(face, glyph, load_flags);
-    if (err && (load_flags & FT_LOAD_NO_BITMAP)) {
-        load_flags &= ~FT_LOAD_NO_BITMAP;
-        err = FT_Load_Glyph(face, glyph, load_flags);
-    }
-    if (err == FT_Err_Too_Few_Arguments) {
-        // this is an error in the bytecode interpreter, just try to run without it
-        load_flags |= FT_LOAD_FORCE_AUTOHINT;
-        err = FT_Load_Glyph(face, glyph, load_flags);
-    }
-    if (err != FT_Err_Ok)
-        qWarning("load glyph failed err=%x face=%p, glyph=%d", err, face, glyph);
-
-    unlockFace();
-    if (set->outline_drawing)
-        return 0;
-
-    if (!g) {
-        g = new Glyph;
-        g->uploadedToServer = false;
-        g->data = 0;
-    }
-
-    FT_GlyphSlot slot = face->glyph;
-    if (embolden) Q_FT_GLYPHSLOT_EMBOLDEN(slot);
-    int left  = slot->metrics.horiBearingX;
-    int right = slot->metrics.horiBearingX + slot->metrics.width;
-    int top    = slot->metrics.horiBearingY;
-    int bottom = slot->metrics.horiBearingY - slot->metrics.height;
-    if (transform && slot->format != FT_GLYPH_FORMAT_BITMAP) { // freetype doesn't apply the transformation on the metrics
-        int l, r, t, b;
-        FT_Vector vector;
-        vector.x = left;
-        vector.y = top;
-        FT_Vector_Transform(&vector, &matrix);
-        l = r = vector.x;
-        t = b = vector.y;
-        vector.x = right;
-        vector.y = top;
-        FT_Vector_Transform(&vector, &matrix);
-        if (l > vector.x) l = vector.x;
-        if (r < vector.x) r = vector.x;
-        if (t < vector.y) t = vector.y;
-        if (b > vector.y) b = vector.y;
-        vector.x = right;
-        vector.y = bottom;
-        FT_Vector_Transform(&vector, &matrix);
-        if (l > vector.x) l = vector.x;
-        if (r < vector.x) r = vector.x;
-        if (t < vector.y) t = vector.y;
-        if (b > vector.y) b = vector.y;
-        vector.x = left;
-        vector.y = bottom;
-        FT_Vector_Transform(&vector, &matrix);
-        if (l > vector.x) l = vector.x;
-        if (r < vector.x) r = vector.x;
-        if (t < vector.y) t = vector.y;
-        if (b > vector.y) b = vector.y;
-        left = l;
-        right = r;
-        top = t;
-        bottom = b;
-    }
-    left = FLOOR(left);
-    right = CEIL(right);
-    bottom = FLOOR(bottom);
-    top = CEIL(top);
-
-    g->linearAdvance = face->glyph->linearHoriAdvance >> 10;
-    g->width = TRUNC(right-left);
-    g->height = TRUNC(top-bottom);
-    g->x = TRUNC(left);
-    g->y = TRUNC(top);
-    g->advance = TRUNC(ROUND(face->glyph->advance.x));
-    g->format = Format_None;
-
-    return g;
-}
-
 QFontEngineFT::Glyph *QFontEngineFT::loadGlyph(QGlyphSet *set, uint glyph,
                                                QFixed subPixelPosition,
                                                GlyphFormat format,
@@ -2069,6 +1969,41 @@ HB_Error QFontEngineFT::getPointInOutline(HB_Glyph glyph, int flags, hb_uint32 p
     return result;
 }
 
+bool QFontEngineFT::initFromFontEngine(const QFontEngineFT *fe)
+{
+    if (!init(fe->faceId(), fe->antialias, fe->defaultFormat, fe->freetype))
+        return false;
+
+    // Increase the reference of this QFreetypeFace since one more QFontEngineFT
+    // will be using it
+    freetype->ref.ref();
+
+    default_load_flags = fe->default_load_flags;
+    default_hint_style = fe->default_hint_style;
+    antialias = fe->antialias;
+    transform = fe->transform;
+    embolden = fe->embolden;
+    subpixelType = fe->subpixelType;
+    lcdFilterType = fe->lcdFilterType;
+    canUploadGlyphsToServer = fe->canUploadGlyphsToServer;
+    embeddedbitmap = fe->embeddedbitmap;
+
+    return true;
+}
+
+QFontEngine *QFontEngineFT::cloneWithSize(qreal pixelSize) const
+{
+    QFontDef fontDef;
+    fontDef.pixelSize = pixelSize;
+    QFontEngineFT *fe = new QFontEngineFT(fontDef);
+    if (!fe->initFromFontEngine(this)) {
+        delete fe;
+        return 0;
+    } else {
+        return fe;
+    }
+}
+
 QT_END_NAMESPACE
 
 #endif // QT_NO_FREETYPE
diff --git a/src/gui/text/qfontengine_ft_p.h b/src/gui/text/qfontengine_ft_p.h
index 887efed..a620006 100644
--- a/src/gui/text/qfontengine_ft_p.h
+++ b/src/gui/text/qfontengine_ft_p.h
@@ -122,7 +122,7 @@ struct QFreetypeFace
     static void addBitmapToPath(FT_GlyphSlot slot, const QFixedPoint &point, QPainterPath *path, bool = false);
 
 private:
-    friend class QFontEngineFTRawFont;
+    friend class QFontEngineFT;
     friend class QScopedPointerDeleter<QFreetypeFace>;
     QFreetypeFace() : _lock(QMutex::Recursive) {}
     ~QFreetypeFace() {}
@@ -319,6 +319,10 @@ private:
     };
 
     void setDefaultHintStyle(HintStyle style);
+
+    virtual QFontEngine *cloneWithSize(qreal pixelSize) const;
+    bool initFromFontEngine(const QFontEngineFT *fontEngine);
+
     HintStyle defaultHintStyle() const { return default_hint_style; }
 protected:
 
@@ -345,7 +349,6 @@ protected:
 private:
     friend class QFontEngineFTRawFont;
 
-    QFontEngineFT::Glyph *loadGlyphMetrics(QGlyphSet *set, uint glyph, GlyphFormat format) const;
     int loadFlags(QGlyphSet *set, GlyphFormat format, int flags, bool &hsubpixel, int &vfactor) const;
 
     GlyphFormat defaultFormat;
diff --git a/src/gui/text/qfontengine_mac.mm b/src/gui/text/qfontengine_mac.mm
index 673a7c8..9f094ad 100644
--- a/src/gui/text/qfontengine_mac.mm
+++ b/src/gui/text/qfontengine_mac.mm
@@ -377,7 +377,7 @@ bool QFontEngineMacMulti::stringToCMap(const QChar *str, int len, QGlyphLayout *
 }
 
 bool QFontEngineMacMulti::stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, QTextEngine::ShaperFlags flags,
-                                       unsigned short *logClusters, const HB_CharAttributes *charAttributes) const
+                                       unsigned short *logClusters, const HB_CharAttributes *charAttributes, QScriptItem *) const
 {
     if (*nglyphs < len) {
         *nglyphs = len;
diff --git a/src/gui/text/qfontengine_mac_p.h b/src/gui/text/qfontengine_mac_p.h
index 385fa83..292ea98 100644
--- a/src/gui/text/qfontengine_mac_p.h
+++ b/src/gui/text/qfontengine_mac_p.h
@@ -131,7 +131,7 @@ public:
 
     virtual bool stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, QTextEngine::ShaperFlags flags) const;
     bool stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, QTextEngine::ShaperFlags flags,
-                      unsigned short *logClusters, const HB_CharAttributes *charAttributes) const;
+                      unsigned short *logClusters, const HB_CharAttributes *charAttributes, QScriptItem *) const;
 
     virtual void recalcAdvances(QGlyphLayout *, QTextEngine::ShaperFlags) const;
     virtual void doKerning(QGlyphLayout *, QTextEngine::ShaperFlags) const;
diff --git a/src/gui/text/qfontengine_p.h b/src/gui/text/qfontengine_p.h
index 5b39fd3..6db0aa6 100644
--- a/src/gui/text/qfontengine_p.h
+++ b/src/gui/text/qfontengine_p.h
@@ -235,6 +235,8 @@ public:
 
     virtual int glyphCount() const;
 
+    virtual QFontEngine *cloneWithSize(qreal /*pixelSize*/) const { return 0; }
+
     HB_Font harfbuzzFont() const;
     HB_Face harfbuzzFace() const;
 
diff --git a/src/gui/text/qfontengine_win.cpp b/src/gui/text/qfontengine_win.cpp
index 82d9da0..54d7ec2 100644
--- a/src/gui/text/qfontengine_win.cpp
+++ b/src/gui/text/qfontengine_win.cpp
@@ -1284,6 +1284,23 @@ QImage QFontEngineWin::alphaRGBMapForGlyph(glyph_t glyph, QFixed, int margin, co
     return rgbMask;
 }
 
+// From qfontdatabase_win.cpp
+extern QFontEngine *qt_load_font_engine_win(const QFontDef &request);
+QFontEngine *QFontEngineWin::cloneWithSize(qreal pixelSize) const
+{
+    QFontDef request = fontDef;
+    QString actualFontName = request.family;
+    if (!uniqueFamilyName.isEmpty())
+        request.family = uniqueFamilyName;
+    request.pixelSize = pixelSize;
+
+    QFontEngine *fontEngine = qt_load_font_engine_win(request);
+    if (fontEngine != NULL)
+        fontEngine->fontDef.family = actualFontName;
+
+    return fontEngine;
+}
+
 // -------------------------------------- Multi font engine
 
 QFontEngineMultiWin::QFontEngineMultiWin(QFontEngine *first, const QStringList &fallbacks)
diff --git a/src/gui/text/qfontengine_win_p.h b/src/gui/text/qfontengine_win_p.h
index 28d8000..114149d 100644
--- a/src/gui/text/qfontengine_win_p.h
+++ b/src/gui/text/qfontengine_win_p.h
@@ -106,6 +106,8 @@ public:
     virtual QImage alphaMapForGlyph(glyph_t, const QTransform &xform);
     virtual QImage alphaRGBMapForGlyph(glyph_t t, QFixed subPixelPosition, int margin, const QTransform &xform);
 
+    virtual QFontEngine *cloneWithSize(qreal pixelSize) const;
+
 #ifndef Q_CC_MINGW
     virtual void getGlyphBearings(glyph_t glyph, qreal *leftBearing = 0, qreal *rightBearing = 0);
 #endif
@@ -118,6 +120,7 @@ public:
 #endif
 
     QString     _name;
+    QString     uniqueFamilyName;
     HFONT       hfont;
     LOGFONT     logfont;
     uint        stockFont  : 1;
diff --git a/src/gui/text/qfontengine_x11.cpp b/src/gui/text/qfontengine_x11.cpp
index 9f3f8d3..4260b85 100644
--- a/src/gui/text/qfontengine_x11.cpp
+++ b/src/gui/text/qfontengine_x11.cpp
@@ -1196,6 +1196,20 @@ bool QFontEngineX11FT::uploadGlyphToServer(QGlyphSet *set, uint glyphid, Glyph *
 #endif
 }
 
+QFontEngine *QFontEngineX11FT::cloneWithSize(qreal pixelSize) const
+{
+    QFontDef fontDef;
+    fontDef.pixelSize = pixelSize;
+    QFontEngineX11FT *fe = new QFontEngineX11FT(fontDef);
+    if (!fe->initFromFontEngine(this)) {
+        delete fe;
+        return 0;
+    } else {
+        fe->xglyph_format = xglyph_format;
+        return fe;
+    }
+}
+
 #endif // QT_NO_FONTCONFIG
 
 QT_END_NAMESPACE
diff --git a/src/gui/text/qfontengine_x11_p.h b/src/gui/text/qfontengine_x11_p.h
index ad68fac..d7eb39d 100644
--- a/src/gui/text/qfontengine_x11_p.h
+++ b/src/gui/text/qfontengine_x11_p.h
@@ -161,6 +161,8 @@ public:
     explicit QFontEngineX11FT(FcPattern *pattern, const QFontDef &fd, int screen);
     ~QFontEngineX11FT();
 
+    QFontEngine *cloneWithSize(qreal pixelSize) const;
+
 #ifndef QT_NO_XRENDER
     int xglyph_format;
 #endif
diff --git a/src/gui/text/qfontenginedirectwrite.cpp b/src/gui/text/qfontenginedirectwrite.cpp
index f0a3644..aab00c0 100644
--- a/src/gui/text/qfontenginedirectwrite.cpp
+++ b/src/gui/text/qfontenginedirectwrite.cpp
@@ -630,6 +630,17 @@ QFontEngine::Type QFontEngineDirectWrite::type() const
     return QFontEngine::DirectWrite;
 }
 
+QFontEngine *QFontEngineDirectWrite::cloneWithSize(qreal pixelSize) const
+{
+    QFontEngine *fontEngine = new QFontEngineDirectWrite(m_directWriteFactory, m_directWriteFontFace,
+                                                         pixelSize);
+
+    fontEngine->fontDef = fontDef;
+    fontEngine->fontDef.pixelSize = pixelSize;
+
+    return fontEngine;
+}
+
 QT_END_NAMESPACE
 
 #endif // QT_NO_DIRECTWRITE
diff --git a/src/gui/text/qfontenginedirectwrite_p.h b/src/gui/text/qfontenginedirectwrite_p.h
index c440a6c..53a4b0a 100644
--- a/src/gui/text/qfontenginedirectwrite_p.h
+++ b/src/gui/text/qfontenginedirectwrite_p.h
@@ -101,6 +101,8 @@ public:
     QImage alphaRGBMapForGlyph(glyph_t t, QFixed subPixelPosition, int margin,
                                const QTransform &xform);
 
+    QFontEngine *cloneWithSize(qreal pixelSize) const;
+
     bool canRender(const QChar *string, int len);
     Type type() const;
 
diff --git a/src/gui/text/qglyphs.cpp b/src/gui/text/qglyphs.cpp
index b8a418d..cfea6ec 100644
--- a/src/gui/text/qglyphs.cpp
+++ b/src/gui/text/qglyphs.cpp
@@ -50,7 +50,7 @@ QT_BEGIN_NAMESPACE
 
 /*!
     \class QGlyphs
-    \brief the QGlyphs class provides direct access to the internal glyphs in a font
+    \brief The QGlyphs class provides direct access to the internal glyphs in a font.
     \since 4.8
 
     \ingroup text
@@ -76,8 +76,8 @@ QT_BEGIN_NAMESPACE
     QTextLayout::glyphs() or QTextFragment::glyphs() can be used to convert unicode encoded text
     into a list of QGlyphs objects, and QPainter::drawGlyphs() can be used to draw the glyphs.
 
-    \note Please note that QRawFont is considered local to the thread in which it is constructed,
-    which in turn means that a new QRawFont will have to be created and set on the QGlyphs if it is
+    \note Please note that QRawFont is considered local to the thread in which it is constructed.
+    This in turn means that a new QRawFont will have to be created and set on the QGlyphs if it is
     moved to a different thread. If the QGlyphs contains a reference to a QRawFont from a different
     thread than the current, it will not be possible to draw the glyphs using a QPainter, as the
     QRawFont is considered invalid and inaccessible in this case.
diff --git a/src/gui/text/qplatformfontdatabase_qpa.cpp b/src/gui/text/qplatformfontdatabase_qpa.cpp
index 6fa25e7..82ec279 100644
--- a/src/gui/text/qplatformfontdatabase_qpa.cpp
+++ b/src/gui/text/qplatformfontdatabase_qpa.cpp
@@ -218,6 +218,16 @@ QFontEngine *QPlatformFontDatabase::fontEngine(const QFontDef &fontDef, QUnicode
     return engine;
 }
 
+QFontEngine *QPlatformFontDatabase::fontEngine(const QByteArray &fontData, qreal pixelSize,
+                                               QFont::HintingPreference hintingPreference)
+{
+    Q_UNUSED(fontData);
+    Q_UNUSED(pixelSize);
+    Q_UNUSED(hintingPreference);
+    qWarning("This plugin does not support font engines created directly from font data");
+    return 0;
+}
+
 /*!
 
 */
diff --git a/src/gui/text/qplatformfontdatabase_qpa.h b/src/gui/text/qplatformfontdatabase_qpa.h
index e0e4f04..046311f 100644
--- a/src/gui/text/qplatformfontdatabase_qpa.h
+++ b/src/gui/text/qplatformfontdatabase_qpa.h
@@ -92,6 +92,8 @@ public:
     virtual QStringList addApplicationFont(const QByteArray &fontData, const QString &fileName);
     virtual void releaseHandle(void *handle);
 
+    virtual QFontEngine *fontEngine(const QByteArray &fontData, qreal pixelSize, QFont::HintingPreference hintingPreference);
+
     virtual QString fontDir() const;
 
     //callback
diff --git a/src/gui/text/qrawfont.cpp b/src/gui/text/qrawfont.cpp
index 4a715c2..46c892c 100644
--- a/src/gui/text/qrawfont.cpp
+++ b/src/gui/text/qrawfont.cpp
@@ -302,16 +302,68 @@ qreal QRawFont::descent() const
 }
 
 /*!
+   Returns the xHeight of this QRawFont in pixel units.
+
+   \sa QFontMetricsF::xHeight()
+*/
+qreal QRawFont::xHeight() const
+{
+    if (!isValid())
+        return 0.0;
+
+    return d->fontEngine->xHeight().toReal();
+}
+
+/*!
+   Returns the leading of this QRawFont in pixel units.
+
+   \sa QFontMetricsF::leading()
+*/
+qreal QRawFont::leading() const
+{
+    if (!isValid())
+        return 0.0;
+
+    return d->fontEngine->leading().toReal();
+}
+
+/*!
+   Returns the average character width of this QRawFont in pixel units.
+
+   \sa QFontMetricsF::averageCharWidth()
+*/
+qreal QRawFont::averageCharWidth() const
+{
+    if (!isValid())
+        return 0.0;
+
+    return d->fontEngine->averageCharWidth().toReal();
+}
+
+/*!
+   Returns the width of the widest character in the font.
+
+   \sa QFontMetricsF::maxWidth()
+*/
+qreal QRawFont::maxCharWidth() const
+{
+    if (!isValid())
+        return 0.0;
+
+    return d->fontEngine->maxCharWidth();
+}
+
+/*!
    Returns the pixel size set for this QRawFont. The pixel size affects how glyphs are
    rasterized, the size of glyphs returned by pathForGlyph(), and is used to convert
    internal metrics from design units to logical pixel units.
 
    \sa setPixelSize()
 */
-int QRawFont::pixelSize() const
+qreal QRawFont::pixelSize() const
 {
     if (!isValid())
-        return -1;
+        return 0.0;
 
     return d->fontEngine->fontDef.pixelSize;
 }
@@ -577,10 +629,21 @@ QRawFont QRawFont::fromFont(const QFont &font, QFontDatabase::WritingSystem writ
 /*!
    Sets the pixel size with which this font should be rendered to \a pixelSize.
 */
-void QRawFont::setPixelSize(int pixelSize)
+void QRawFont::setPixelSize(qreal pixelSize)
 {
+    if (d->fontEngine == 0)
+        return;
+
     detach();
-    d->platformSetPixelSize(pixelSize);
+    QFontEngine *oldFontEngine = d->fontEngine;
+
+    d->fontEngine = d->fontEngine->cloneWithSize(pixelSize);
+    if (d->fontEngine != 0)
+        d->fontEngine->ref.ref();
+
+    oldFontEngine->ref.deref();
+    if (oldFontEngine->cache_count == 0 && oldFontEngine->ref == 0)
+        delete oldFontEngine;
 }
 
 /*!
diff --git a/src/gui/text/qrawfont.h b/src/gui/text/qrawfont.h
index 96dc838..900c07a 100644
--- a/src/gui/text/qrawfont.h
+++ b/src/gui/text/qrawfont.h
@@ -96,13 +96,17 @@ public:
                             const QTransform &transform = QTransform()) const;
     QPainterPath pathForGlyph(quint32 glyphIndex) const;
 
-    void setPixelSize(int pixelSize);
-    int pixelSize() const;
+    void setPixelSize(qreal pixelSize);
+    qreal pixelSize() const;
 
     QFont::HintingPreference hintingPreference() const;
 
     qreal ascent() const;
     qreal descent() const;
+    qreal leading() const;
+    qreal xHeight() const;
+    qreal averageCharWidth() const;
+    qreal maxCharWidth() const;
 
     qreal unitsPerEm() const;
 
diff --git a/src/gui/text/qrawfont_ft.cpp b/src/gui/text/qrawfont_ft.cpp
index eefbd92..23d47eb 100644
--- a/src/gui/text/qrawfont_ft.cpp
+++ b/src/gui/text/qrawfont_ft.cpp
@@ -90,32 +90,6 @@ public:
 
         return init(faceId, true, Format_None, fontData);
     }
-
-    bool initFromFontEngine(QFontEngine *oldFontEngine)
-    {
-        QFontEngineFT *fe = static_cast<QFontEngineFT *>(oldFontEngine);
-
-        // Increase the reference of this QFreetypeFace since one more QFontEngineFT
-        // will be using it
-        fe->freetype->ref.ref();
-        if (!init(fe->faceId(), fe->antialias, fe->defaultFormat, fe->freetype))
-            return false;
-
-        default_load_flags = fe->default_load_flags;
-        default_hint_style = fe->default_hint_style;
-        antialias = fe->antialias;
-        transform = fe->transform;
-        embolden = fe->embolden;
-        subpixelType = fe->subpixelType;
-        lcdFilterType = fe->lcdFilterType;
-        canUploadGlyphsToServer = fe->canUploadGlyphsToServer;
-        embeddedbitmap = fe->embeddedbitmap;
-
-#if defined(Q_WS_X11)
-        xglyph_format = static_cast<QFontEngineX11FT *>(fe)->xglyph_format;
-#endif
-        return true;
-    }
 };
 
 
@@ -159,31 +133,6 @@ void QRawFontPrivate::platformLoadFromData(const QByteArray &fontData, int pixel
     fontEngine->ref.ref();
 }
 
-void QRawFontPrivate::platformSetPixelSize(int pixelSize)
-{
-    if (fontEngine == NULL)
-        return;
-
-    QFontEngine *oldFontEngine = fontEngine;
-
-    QFontDef fontDef;
-    fontDef.pixelSize = pixelSize;
-    QFontEngineFTRawFont *fe = new QFontEngineFTRawFont(fontDef);
-    if (!fe->initFromFontEngine(oldFontEngine)) {
-        delete fe;
-        return;
-    }
-
-    fontEngine = fe;
-    fontEngine->fontDef = oldFontEngine->fontDef;
-    fontEngine->fontDef.pixelSize = pixelSize;
-    fontEngine->ref.ref();
-    Q_ASSERT(fontEngine != oldFontEngine);
-    oldFontEngine->ref.deref();
-    if (oldFontEngine->cache_count == 0 && oldFontEngine->ref == 0)
-        delete oldFontEngine;
-}
-
 QT_END_NAMESPACE
 
 #endif // QT_NO_RAWFONT
diff --git a/src/gui/text/qrawfont_mac.cpp b/src/gui/text/qrawfont_mac.cpp
index 56005c6..1ed4185 100644
--- a/src/gui/text/qrawfont_mac.cpp
+++ b/src/gui/text/qrawfont_mac.cpp
@@ -78,28 +78,6 @@ void QRawFontPrivate::platformLoadFromData(const QByteArray &fontData,
     }
 }
 
-void QRawFontPrivate::platformSetPixelSize(int pixelSize)
-{
-    if (fontEngine == NULL)
-        return;
-
-    QFontEngine *oldFontEngine = fontEngine;
-
-    QFontDef fontDef = oldFontEngine->fontDef;
-    fontDef.pixelSize = pixelSize;
-    fontDef.pointSize = pixelSize * 72.0 / qt_defaultDpi();
-
-    QCoreTextFontEngine *ctFontEngine = static_cast<QCoreTextFontEngine *>(oldFontEngine);
-    Q_ASSERT(ctFontEngine->cgFont);
-
-    fontEngine = new QCoreTextFontEngine(ctFontEngine->cgFont, fontDef);
-    fontEngine->ref.ref();
-    Q_ASSERT(fontEngine != oldFontEngine);
-    oldFontEngine->ref.deref();
-    if (oldFontEngine->cache_count == 0 && oldFontEngine->ref == 0)
-        delete oldFontEngine;
-}
-
 QT_END_NAMESPACE
 
 #endif // QT_NO_RAWFONT
diff --git a/src/gui/text/qrawfont_p.h b/src/gui/text/qrawfont_p.h
index f9a9ab5..e29ea9c 100644
--- a/src/gui/text/qrawfont_p.h
+++ b/src/gui/text/qrawfont_p.h
@@ -83,7 +83,6 @@ public:
         , fontHandle(NULL)
         , ptrAddFontMemResourceEx(other.ptrAddFontMemResourceEx)
         , ptrRemoveFontMemResourceEx(other.ptrRemoveFontMemResourceEx)
-        , uniqueFamilyName(other.uniqueFamilyName)
 #endif
     {
         fontEngine = other.fontEngine;
@@ -102,7 +101,6 @@ public:
     void platformLoadFromData(const QByteArray &fontData,
                               int pixelSize,
                               QFont::HintingPreference hintingPreference);
-    void platformSetPixelSize(int pixelSize);
 
     static QRawFontPrivate *get(const QRawFont &font) { return font.d.data(); }
 
@@ -120,8 +118,6 @@ public:
     PtrAddFontMemResourceEx ptrAddFontMemResourceEx;
     PtrRemoveFontMemResourceEx ptrRemoveFontMemResourceEx;
 
-    QString uniqueFamilyName;
-
 #endif // Q_WS_WIN
 };
 
diff --git a/src/gui/text/qrawfont_qpa.cpp b/src/gui/text/qrawfont_qpa.cpp
new file mode 100644
index 0000000..103619c
--- /dev/null
+++ b/src/gui/text/qrawfont_qpa.cpp
@@ -0,0 +1,69 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtCore/qglobal.h>
+
+#if !defined(QT_NO_RAWFONT)
+
+#include "qrawfont_p.h"
+#include <QtGui/qplatformfontdatabase_qpa.h>
+#include <private/qapplication_p.h>
+
+QT_BEGIN_NAMESPACE
+
+void QRawFontPrivate::platformCleanUp()
+{
+}
+
+void QRawFontPrivate::platformLoadFromData(const QByteArray &fontData, int pixelSize,
+                                           QFont::HintingPreference hintingPreference)
+{
+    Q_ASSERT(fontEngine == 0);
+
+    QPlatformFontDatabase *pfdb = QApplicationPrivate::platformIntegration()->fontDatabase();
+    fontEngine = pfdb->fontEngine(fontData, pixelSize, hintingPreference);
+    if (fontEngine != 0)
+        fontEngine->ref.ref();
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_RAWFONT
diff --git a/src/gui/text/qrawfont_win.cpp b/src/gui/text/qrawfont_win.cpp
index fb5c6f4..d8acf57 100644
--- a/src/gui/text/qrawfont_win.cpp
+++ b/src/gui/text/qrawfont_win.cpp
@@ -559,7 +559,7 @@ void QRawFontPrivate::platformLoadFromData(const QByteArray &_fontData,
         GUID guid;
         CoCreateGuid(&guid);
 
-        uniqueFamilyName = QString::fromLatin1("f")
+        QString uniqueFamilyName = QString::fromLatin1("f")
                 + QString::number(guid.Data1, 36) + QLatin1Char('-')
                 + QString::number(guid.Data2, 36) + QLatin1Char('-')
                 + QString::number(guid.Data3, 36) + QLatin1Char('-')
@@ -613,6 +613,7 @@ void QRawFontPrivate::platformLoadFromData(const QByteArray &_fontData,
                 Q_ASSERT(fontEngine->cache_count == 0 && fontEngine->ref == 0);
 
                 // Override the generated font name
+                static_cast<QFontEngineWin *>(fontEngine)->uniqueFamilyName = uniqueFamilyName;
                 fontEngine->fontDef.family = actualFontName;
                 fontEngine->ref.ref();
             }
@@ -701,50 +702,6 @@ void QRawFontPrivate::platformLoadFromData(const QByteArray &_fontData,
     }
 }
 
-void QRawFontPrivate::platformSetPixelSize(int pixelSize)
-{
-    if (fontEngine == NULL)
-        return;
-
-    QFontEngine *oldFontEngine = fontEngine;
-
-#if !defined(QT_NO_DIRECTWRITE)
-    if (fontEngine->type() == QFontEngine::Win)
-#endif
-
-    {
-        QFontDef request = fontEngine->fontDef;
-        QString actualFontName = request.family;
-        if (!uniqueFamilyName.isEmpty())
-            request.family = uniqueFamilyName;
-        request.pixelSize = pixelSize;
-
-        fontEngine = qt_load_font_engine_win(request);
-        if (fontEngine != NULL) {
-            fontEngine->fontDef.family = actualFontName;
-            fontEngine->ref.ref();
-        }
-    }
-
-#if !defined(QT_NO_DIRECTWRITE)
-    else {
-        QFontEngineDirectWrite *dWriteFE = static_cast<QFontEngineDirectWrite *>(fontEngine);
-        fontEngine = new QFontEngineDirectWrite(dWriteFE->m_directWriteFactory,
-                                                dWriteFE->m_directWriteFontFace,
-                                                pixelSize);
-
-        fontEngine->fontDef = dWriteFE->fontDef;
-        fontEngine->fontDef.pixelSize = pixelSize;
-        fontEngine->ref.ref();
-    }
-#endif
-
-    Q_ASSERT(fontEngine != oldFontEngine);
-    oldFontEngine->ref.deref();
-    if (oldFontEngine->cache_count == 0 && oldFontEngine->ref == 0)
-        delete oldFontEngine;
-}
-
 QT_END_NAMESPACE
 
 #endif // QT_NO_RAWFONT
diff --git a/src/gui/text/qtextcursor.cpp b/src/gui/text/qtextcursor.cpp
index 6ddfdb0..4f6857a 100644
--- a/src/gui/text/qtextcursor.cpp
+++ b/src/gui/text/qtextcursor.cpp
@@ -362,20 +362,23 @@ bool QTextCursorPrivate::movePosition(QTextCursor::MoveOperation op, QTextCursor
     currentCharFormat = -1;
     bool adjustX = true;
     QTextBlock blockIt = block();
+    bool visualMovement = priv->defaultCursorMoveStyle == QTextCursor::Visual;
 
     if (!blockIt.isValid())
         return false;
 
-    if (op >= QTextCursor::Left && op <= QTextCursor::WordRight
-        && blockIt.textDirection() == Qt::RightToLeft) {
-        if (op == QTextCursor::Left)
-            op = QTextCursor::NextCharacter;
-        else if (op == QTextCursor::Right)
-            op = QTextCursor::PreviousCharacter;
-        else if (op == QTextCursor::WordLeft)
+    if (blockIt.textDirection() == Qt::RightToLeft) {
+        if (op == QTextCursor::WordLeft)
             op = QTextCursor::NextWord;
         else if (op == QTextCursor::WordRight)
             op = QTextCursor::PreviousWord;
+
+        if (!visualMovement) {
+            if (op == QTextCursor::Left)
+                op = QTextCursor::NextCharacter;
+            else if (op == QTextCursor::Right)
+                op = QTextCursor::PreviousCharacter;
+        }
     }
 
     const QTextLayout *layout = blockLayout(blockIt);
@@ -418,9 +421,12 @@ bool QTextCursorPrivate::movePosition(QTextCursor::MoveOperation op, QTextCursor
         break;
     }
     case QTextCursor::PreviousCharacter:
-    case QTextCursor::Left:
         newPosition = priv->previousCursorPosition(position, QTextLayout::SkipCharacters);
         break;
+    case QTextCursor::Left:
+        newPosition = visualMovement ? priv->leftCursorPosition(position)
+                                     : priv->previousCursorPosition(position, QTextLayout::SkipCharacters);
+        break;
     case QTextCursor::StartOfWord: {
         if (relativePos == 0)
             break;
@@ -529,9 +535,12 @@ bool QTextCursorPrivate::movePosition(QTextCursor::MoveOperation op, QTextCursor
         break;
     }
     case QTextCursor::NextCharacter:
-    case QTextCursor::Right:
         newPosition = priv->nextCursorPosition(position, QTextLayout::SkipCharacters);
         break;
+    case QTextCursor::Right:
+        newPosition = visualMovement ? priv->rightCursorPosition(position)
+                                     : priv->nextCursorPosition(position, QTextLayout::SkipCharacters);
+        break;
     case QTextCursor::NextWord:
     case QTextCursor::WordRight:
         newPosition = priv->nextCursorPosition(position, QTextLayout::SkipWords);
@@ -2558,4 +2567,19 @@ QTextDocument *QTextCursor::document() const
     return 0; // document went away
 }
 
+/*!
+    \enum QTextCursor::MoveStyle
+
+    This enum describes the movement style available to QTextCursor. The options
+    are:
+
+    \value Logical Within a left-to-right text block, increase cursor position
+    when pressing left arrow key, decrease cursor position when pressing the
+    right arrow key. If the text block is right-to-left, the opposite behavior
+    applies.
+    \value Visual Pressing the left arrow key will always cause the cursor to move
+    left, regardless of the text's writing direction. The same behavior applies to
+    right arrow key.
+*/
+
 QT_END_NAMESPACE
diff --git a/src/gui/text/qtextcursor.h b/src/gui/text/qtextcursor.h
index 4eaeb41..9e4c0b8 100644
--- a/src/gui/text/qtextcursor.h
+++ b/src/gui/text/qtextcursor.h
@@ -86,6 +86,10 @@ public:
         MoveAnchor,
         KeepAnchor
     };
+    enum MoveStyle {
+        Logical,
+        Visual
+    };
 
     void setPosition(int pos, MoveMode mode = MoveAnchor);
     int position() const;
diff --git a/src/gui/text/qtextdocument.cpp b/src/gui/text/qtextdocument.cpp
index 6dbd755..36f3c6c 100644
--- a/src/gui/text/qtextdocument.cpp
+++ b/src/gui/text/qtextdocument.cpp
@@ -586,6 +586,29 @@ void QTextDocument::setDefaultTextOption(const QTextOption &option)
 }
 
 /*!
+    \since 4.8
+
+    The default cursor movement style is used by all QTextCursor objects
+    created from the document. The default is QTextCursor::Logical.
+*/
+QTextCursor::MoveStyle QTextDocument::defaultCursorMoveStyle() const
+{
+    Q_D(const QTextDocument);
+    return d->defaultCursorMoveStyle;
+}
+
+/*!
+    \since 4.8
+
+    Set the default cursor movement style.
+*/
+void QTextDocument::setDefaultCursorMoveStyle(QTextCursor::MoveStyle style)
+{
+    Q_D(QTextDocument);
+    d->defaultCursorMoveStyle = style;
+}
+
+/*!
     \fn void QTextDocument::markContentsDirty(int position, int length)
 
     Marks the contents specified by the given \a position and \a length
diff --git a/src/gui/text/qtextdocument.h b/src/gui/text/qtextdocument.h
index f87ccc9..e515b36 100644
--- a/src/gui/text/qtextdocument.h
+++ b/src/gui/text/qtextdocument.h
@@ -46,6 +46,7 @@
 #include <QtCore/qsize.h>
 #include <QtCore/qrect.h>
 #include <QtGui/qfont.h>
+#include <QtGui/qtextcursor.h>
 
 QT_BEGIN_HEADER
 
@@ -60,7 +61,6 @@ class QPainter;
 class QPrinter;
 class QAbstractTextDocumentLayout;
 class QPoint;
-class QTextCursor;
 class QTextObject;
 class QTextFormat;
 class QTextFrame;
@@ -269,6 +269,9 @@ public:
     QTextOption defaultTextOption() const;
     void setDefaultTextOption(const QTextOption &option);
 
+    QTextCursor::MoveStyle defaultCursorMoveStyle() const;
+    void setDefaultCursorMoveStyle(QTextCursor::MoveStyle style);
+
 Q_SIGNALS:
     void contentsChange(int from, int charsRemoves, int charsAdded);
     void contentsChanged();
diff --git a/src/gui/text/qtextdocument_p.cpp b/src/gui/text/qtextdocument_p.cpp
index a997720..779b1ff 100644
--- a/src/gui/text/qtextdocument_p.cpp
+++ b/src/gui/text/qtextdocument_p.cpp
@@ -209,6 +209,7 @@ QTextDocumentPrivate::QTextDocumentPrivate()
 
     defaultTextOption.setTabStop(80); // same as in qtextengine.cpp
     defaultTextOption.setWrapMode(QTextOption::WrapAtWordBoundaryOrAnywhere);
+    defaultCursorMoveStyle = QTextCursor::Logical;
 
     indentWidth = 40;
     documentMargin = 4;
@@ -1382,6 +1383,20 @@ int QTextDocumentPrivate::previousCursorPosition(int position, QTextLayout::Curs
     return it.layout()->previousCursorPosition(position-start, mode) + start;
 }
 
+int QTextDocumentPrivate::leftCursorPosition(int position) const
+{
+    QTextBlock it = blocksFind(position);
+    int start = it.position();
+    return it.layout()->leftCursorPosition(position-start) + start;
+}
+
+int QTextDocumentPrivate::rightCursorPosition(int position) const
+{
+    QTextBlock it = blocksFind(position);
+    int start = it.position();
+    return it.layout()->rightCursorPosition(position-start) + start;
+}
+
 void QTextDocumentPrivate::changeObjectFormat(QTextObject *obj, int format)
 {
     beginEditBlock();
diff --git a/src/gui/text/qtextdocument_p.h b/src/gui/text/qtextdocument_p.h
index b464f2e..6563920 100644
--- a/src/gui/text/qtextdocument_p.h
+++ b/src/gui/text/qtextdocument_p.h
@@ -64,6 +64,7 @@
 #include "private/qtextformat_p.h"
 #include "QtGui/qtextdocument.h"
 #include "QtGui/qtextobject.h"
+#include "QtGui/qtextcursor.h"
 #include "QtCore/qmap.h"
 #include "QtCore/qvariant.h"
 #include "QtCore/qurl.h"
@@ -244,6 +245,8 @@ public:
 
     int nextCursorPosition(int position, QTextLayout::CursorMode mode) const;
     int previousCursorPosition(int position, QTextLayout::CursorMode mode) const;
+    int leftCursorPosition(int position) const;
+    int rightCursorPosition(int position) const;
 
     void changeObjectFormat(QTextObject *group, int format);
 
@@ -339,6 +342,7 @@ private:
 
 public:
     QTextOption defaultTextOption;
+    QTextCursor::MoveStyle defaultCursorMoveStyle;
 #ifndef QT_NO_CSSPARSER
     QCss::StyleSheet parsedDefaultStyleSheet;
 #endif
diff --git a/src/gui/text/qtextdocumentlayout.cpp b/src/gui/text/qtextdocumentlayout.cpp
index ce157be..f3dc975 100644
--- a/src/gui/text/qtextdocumentlayout.cpp
+++ b/src/gui/text/qtextdocumentlayout.cpp
@@ -2996,10 +2996,19 @@ void QTextDocumentLayout::resizeInlineObject(QTextInlineObject item, int posInDo
 
     QSizeF inlineSize = (pos == QTextFrameFormat::InFlow ? intrinsic : QSizeF(0, 0));
     item.setWidth(inlineSize.width());
-    if (f.verticalAlignment() == QTextCharFormat::AlignMiddle) {
+
+    QFontMetrics m(f.font());
+    switch (f.verticalAlignment())
+    {
+    case QTextCharFormat::AlignMiddle:
         item.setDescent(inlineSize.height() / 2);
         item.setAscent(inlineSize.height() / 2 - 1);
-    } else {
+        break;
+    case QTextCharFormat::AlignBaseline:
+        item.setDescent(m.descent());
+        item.setAscent(inlineSize.height() - m.descent() - 1);
+        break;
+    default:
         item.setDescent(0);
         item.setAscent(inlineSize.height() - 1);
     }
@@ -3081,6 +3090,7 @@ void QTextDocumentLayoutPrivate::ensureLayouted(QFixed y) const
     if (currentLazyLayoutPosition == -1)
         return;
     const QSizeF oldSize = q->dynamicDocumentSize();
+    Q_UNUSED(oldSize);
 
     if (checkPoints.isEmpty())
         layoutStep();
diff --git a/src/gui/text/qtextengine.cpp b/src/gui/text/qtextengine.cpp
index 08d0eca..ff27bc6 100644
--- a/src/gui/text/qtextengine.cpp
+++ b/src/gui/text/qtextengine.cpp
@@ -856,6 +856,21 @@ void QTextEngine::shapeLine(const QScriptLine &line)
     }
 }
 
+#if !defined(QT_ENABLE_HARFBUZZ_FOR_MAC)
+static bool enableHarfBuzz()
+{
+    static enum { Yes, No, Unknown } status = Unknown;
+
+    if (status == Unknown) {
+        QByteArray v = qgetenv("QT_ENABLE_HARFBUZZ");
+        bool value = !v.isEmpty() && v != "0" && v != "false";
+        if (value) status = Yes;
+        else status = No;
+    }
+    return status == Yes;
+}
+#endif
+
 void QTextEngine::shapeText(int item) const
 {
     Q_ASSERT(item < layoutData->items.size());
@@ -865,7 +880,24 @@ void QTextEngine::shapeText(int item) const
         return;
 
 #if defined(Q_WS_MAC)
-    shapeTextMac(item);
+#if !defined(QT_ENABLE_HARFBUZZ_FOR_MAC)
+    if (enableHarfBuzz()) {
+#endif
+        QFontEngine *actualFontEngine = fontEngine(si, &si.ascent, &si.descent, &si.leading);
+        if (actualFontEngine->type() == QFontEngine::Multi)
+            actualFontEngine = static_cast<QFontEngineMulti *>(actualFontEngine)->engine(0);
+
+        HB_Face face = actualFontEngine->harfbuzzFace();
+        HB_Script script = (HB_Script) si.analysis.script;
+        if (face->supported_scripts[script])
+            shapeTextWithHarfbuzz(item);
+        else
+            shapeTextMac(item);
+#if !defined(QT_ENABLE_HARFBUZZ_FOR_MAC)
+    } else {
+        shapeTextMac(item);
+    }
+#endif
 #elif defined(Q_WS_WINCE)
     shapeTextWithCE(item);
 #else
@@ -1242,6 +1274,10 @@ void QTextEngine::shapeTextWithHarfbuzz(int item) const
             actualFontEngine = static_cast<QFontEngineMulti *>(font)->engine(engineIdx);
         }
 
+        si.ascent = qMax(actualFontEngine->ascent(), si.ascent);
+        si.descent = qMax(actualFontEngine->descent(), si.descent);
+        si.leading = qMax(actualFontEngine->leading(), si.leading);
+
         shaper_item.font = actualFontEngine->harfbuzzFont();
         shaper_item.face = actualFontEngine->harfbuzzFace();
 
@@ -1304,6 +1340,7 @@ static void init(QTextEngine *e)
     e->ignoreBidi = false;
     e->cacheGlyphs = false;
     e->forceJustification = false;
+    e->visualMovement = false;
 
     e->layoutData = 0;
 
@@ -1565,6 +1602,8 @@ bool QTextEngine::isRightToLeft() const
     default:
         break;
     }
+    if (!layoutData)
+        itemize();
     // this places the cursor in the right position depending on the keyboard layout
     if (layoutData->string.isEmpty())
         return QApplication::keyboardInputDirection() == Qt::RightToLeft;
@@ -2737,6 +2776,182 @@ QFixed QTextEngine::leadingSpaceWidth(const QScriptLine &line)
     return width(line.from + pos, line.length - pos);
 }
 
+QFixed QTextEngine::alignLine(const QScriptLine &line)
+{
+    QFixed x = 0;
+    justify(line);
+    // if width is QFIXED_MAX that means we used setNumColumns() and that implicitly makes this line left aligned.
+    if (!line.justified && line.width != QFIXED_MAX) {
+        int align = option.alignment();
+        if (align & Qt::AlignLeft)
+            x -= leadingSpaceWidth(line);
+        if (align & Qt::AlignJustify && isRightToLeft())
+            align = Qt::AlignRight;
+        if (align & Qt::AlignRight)
+            x = line.width - (line.textAdvance + leadingSpaceWidth(line));
+        else if (align & Qt::AlignHCenter)
+            x = (line.width - (line.textAdvance + leadingSpaceWidth(line)))/2;
+    }
+    return x;
+}
+
+QFixed QTextEngine::offsetInLigature(const QScriptItem *si, int pos, int max, int glyph_pos)
+{
+    unsigned short *logClusters = this->logClusters(si);
+    const QGlyphLayout &glyphs = shapedGlyphs(si);
+
+    int offsetInCluster = 0;
+    for (int i = pos - 1; i >= 0; i--) {
+        if (logClusters[i] == glyph_pos)
+            offsetInCluster++;
+        else
+            break;
+    }
+
+    // in the case that the offset is inside a (multi-character) glyph,
+    // interpolate the position.
+    if (offsetInCluster > 0) {
+        int clusterLength = 0;
+        for (int i = pos - offsetInCluster; i < max; i++) {
+            if (logClusters[i] == glyph_pos)
+                clusterLength++;
+            else
+                break;
+        }
+        if (clusterLength)
+            return glyphs.advances_x[glyph_pos] * offsetInCluster / clusterLength;
+    }
+
+    return 0;
+}
+
+int QTextEngine::previousLogicalPosition(int oldPos) const
+{
+    const HB_CharAttributes *attrs = attributes();
+    if (!attrs || oldPos < 0)
+        return oldPos;
+
+    if (oldPos <= 0)
+        return 0;
+    oldPos--;
+    while (oldPos && !attrs[oldPos].charStop)
+        oldPos--;
+    return oldPos;
+}
+
+int QTextEngine::nextLogicalPosition(int oldPos) const
+{
+    const HB_CharAttributes *attrs = attributes();
+    int len = block.isValid() ? block.length() - 1
+                              : layoutData->string.length();
+    Q_ASSERT(len <= layoutData->string.length());
+    if (!attrs || oldPos < 0 || oldPos >= len)
+        return oldPos;
+
+    oldPos++;
+    while (oldPos < len && !attrs[oldPos].charStop)
+        oldPos++;
+    return oldPos;
+}
+
+int QTextEngine::lineNumberForTextPosition(int pos)
+{
+    if (!layoutData)
+        itemize();
+    if (pos == layoutData->string.length() && lines.size())
+        return lines.size() - 1;
+    for (int i = 0; i < lines.size(); ++i) {
+        const QScriptLine& line = lines[i];
+        if (line.from + line.length > pos)
+            return i;
+    }
+    return -1;
+}
+
+void QTextEngine::insertionPointsForLine(int lineNum, QVector<int> &insertionPoints)
+{
+    QTextLineItemIterator iterator(this, lineNum);
+    bool rtl = isRightToLeft();
+    bool lastLine = lineNum >= lines.size() - 1;
+
+    while (!iterator.atEnd()) {
+        iterator.next();
+        const QScriptItem *si = &layoutData->items[iterator.item];
+        if (si->analysis.bidiLevel % 2) {
+            int i = iterator.itemEnd - 1, min = iterator.itemStart;
+            if (lastLine && (rtl ? iterator.atBeginning() : iterator.atEnd()))
+                i++;
+            for (; i >= min; i--)
+                insertionPoints.push_back(i);
+        } else {
+            int i = iterator.itemStart, max = iterator.itemEnd;
+            if (lastLine && (rtl ? iterator.atBeginning() : iterator.atEnd()))
+                max++;
+            for (; i < max; i++)
+                insertionPoints.push_back(i);
+        }
+    }
+}
+
+int QTextEngine::endOfLine(int lineNum)
+{
+    QVector<int> insertionPoints;
+    insertionPointsForLine(lineNum, insertionPoints);
+
+    if (insertionPoints.size() > 0)
+        return insertionPoints.last();
+    return 0;
+}
+
+int QTextEngine::beginningOfLine(int lineNum)
+{
+    QVector<int> insertionPoints;
+    insertionPointsForLine(lineNum, insertionPoints);
+
+    if (insertionPoints.size() > 0)
+        return insertionPoints.first();
+    return 0;
+}
+
+int QTextEngine::positionAfterVisualMovement(int pos, QTextCursor::MoveOperation op)
+{
+    if (!layoutData)
+        itemize();
+
+    bool moveRight = (op == QTextCursor::Right);
+    bool alignRight = isRightToLeft();
+    if (!layoutData->hasBidi)
+        return moveRight ^ alignRight ? nextLogicalPosition(pos) : previousLogicalPosition(pos);
+
+    int lineNum = lineNumberForTextPosition(pos);
+    Q_ASSERT(lineNum >= 0);
+
+    QVector<int> insertionPoints;
+    insertionPointsForLine(lineNum, insertionPoints);
+    int i, max = insertionPoints.size();
+    for (i = 0; i < max; i++)
+        if (pos == insertionPoints[i]) {
+            if (moveRight) {
+                if (i + 1 < max)
+                    return insertionPoints[i + 1];
+            } else {
+                if (i > 0)
+                    return insertionPoints[i - 1];
+            }
+
+            if (moveRight ^ alignRight) {
+                if (lineNum + 1 < lines.size())
+                    return alignRight ? endOfLine(lineNum + 1) : beginningOfLine(lineNum + 1);
+            }
+            else {
+                if (lineNum > 0)
+                    return alignRight ? beginningOfLine(lineNum - 1) : endOfLine(lineNum - 1);
+            }
+        }
+
+    return pos;
+}
+
 QStackTextEngine::QStackTextEngine(const QString &string, const QFont &f)
     : QTextEngine(string, f),
       _layoutData(string, _memory, MemSize)
@@ -2841,5 +3056,127 @@ glyph_metrics_t glyph_metrics_t::transformed(const QTransform &matrix) const
     return m;
 }
 
+QTextLineItemIterator::QTextLineItemIterator(QTextEngine *_eng, int _lineNum, const QPointF &pos,
+                                             const QTextLayout::FormatRange *_selection)
+    : eng(_eng),
+      line(eng->lines[_lineNum]),
+      si(0),
+      lineNum(_lineNum),
+      lineEnd(line.from + line.length),
+      firstItem(eng->findItem(line.from)),
+      lastItem(eng->findItem(lineEnd - 1)),
+      nItems((firstItem >= 0 && lastItem >= firstItem)? (lastItem-firstItem+1) : 0),
+      logicalItem(-1),
+      item(-1),
+      visualOrder(nItems),
+      levels(nItems),
+      selection(_selection)
+{
+    pos_x = x = QFixed::fromReal(pos.x());
+
+    x += line.x;
+
+    x += eng->alignLine(line);
+
+    for (int i = 0; i < nItems; ++i)
+        levels[i] = eng->layoutData->items[i+firstItem].analysis.bidiLevel;
+    QTextEngine::bidiReorder(nItems, levels.data(), visualOrder.data());
+
+    eng->shapeLine(line);
+}
+
+QScriptItem &QTextLineItemIterator::next()
+{
+    x += itemWidth;
+
+    ++logicalItem;
+    item = visualOrder[logicalItem] + firstItem;
+    itemLength = eng->length(item);
+    si = &eng->layoutData->items[item];
+    if (!si->num_glyphs)
+        eng->shape(item);
+
+    if (si->analysis.flags >= QScriptAnalysis::TabOrObject) {
+        itemWidth = si->width;
+        return *si;
+    }
+
+    unsigned short *logClusters = eng->logClusters(si);
+    QGlyphLayout glyphs = eng->shapedGlyphs(si);
+
+    itemStart = qMax(line.from, si->position);
+    glyphsStart = logClusters[itemStart - si->position];
+    if (lineEnd < si->position + itemLength) {
+        itemEnd = lineEnd;
+        glyphsEnd = logClusters[itemEnd-si->position];
+    } else {
+        itemEnd = si->position + itemLength;
+        glyphsEnd = si->num_glyphs;
+    }
+    // show soft-hyphen at line-break
+    if (si->position + itemLength >= lineEnd
+        && eng->layoutData->string.at(lineEnd - 1) == 0x00ad)
+        glyphs.attributes[glyphsEnd - 1].dontPrint = false;
+
+    itemWidth = 0;
+    for (int g = glyphsStart; g < glyphsEnd; ++g)
+        itemWidth += glyphs.effectiveAdvance(g);
+
+    return *si;
+}
+
+bool QTextLineItemIterator::getSelectionBounds(QFixed *selectionX, QFixed *selectionWidth) const
+{
+    *selectionX = *selectionWidth = 0;
+
+    if (!selection)
+        return false;
+
+    if (si->analysis.flags >= QScriptAnalysis::TabOrObject) {
+        if (si->position >= selection->start + selection->length
+            || si->position + itemLength <= selection->start)
+            return false;
+
+        *selectionX = x;
+        *selectionWidth = itemWidth;
+    } else {
+        unsigned short *logClusters = eng->logClusters(si);
+        QGlyphLayout glyphs = eng->shapedGlyphs(si);
+
+        int from = qMax(itemStart, selection->start) - si->position;
+        int to = qMin(itemEnd, selection->start + selection->length) - si->position;
+        if (from >= to)
+            return false;
+
+        int start_glyph = logClusters[from];
+        int end_glyph = (to == eng->length(item)) ? si->num_glyphs : logClusters[to];
+        QFixed soff;
+        QFixed swidth;
+        if (si->analysis.bidiLevel %2) {
+            for (int g = glyphsEnd - 1; g >= end_glyph; --g)
+                soff += glyphs.effectiveAdvance(g);
+            for (int g = end_glyph - 1; g >= start_glyph; --g)
+                swidth += glyphs.effectiveAdvance(g);
+        } else {
+            for (int g = glyphsStart; g < start_glyph; ++g)
+                soff += glyphs.effectiveAdvance(g);
+            for (int g = start_glyph; g < end_glyph; ++g)
+                swidth += glyphs.effectiveAdvance(g);
+        }
+
+        // If the starting character is in the middle of a ligature,
+        // selection should only contain the right part of that ligature
+        // glyph, so we need to get the width of the left part here and
+        // add it to *selectionX
+        QFixed leftOffsetInLigature = eng->offsetInLigature(si, from, to, start_glyph);
+        *selectionX = x + soff + leftOffsetInLigature;
+        *selectionWidth = swidth - leftOffsetInLigature;
+        // If the ending character is also part of a ligature, swidth does
+        // not contain that part yet, we also need to find out the width of
+        // that left part
+        *selectionWidth += eng->offsetInLigature(si, to, eng->length(item), end_glyph);
+    }
+    return true;
+}
 
 QT_END_NAMESPACE
diff --git a/src/gui/text/qtextengine_mac.cpp b/src/gui/text/qtextengine_mac.cpp
index 97e8c5b..2c6e579 100644
--- a/src/gui/text/qtextengine_mac.cpp
+++ b/src/gui/text/qtextengine_mac.cpp
@@ -605,11 +605,11 @@ void QTextEngine::shapeTextMac(int item) const
     unsigned short *log_clusters = logClusters(&si);
 
     bool stringToCMapFailed = false;
-    if (!fe->stringToCMap(str, len, &g, &num_glyphs, flags, log_clusters, attributes())) {
+    if (!fe->stringToCMap(str, len, &g, &num_glyphs, flags, log_clusters, attributes(), &si)) {
         ensureSpace(num_glyphs);
         g = availableGlyphs(&si);
         stringToCMapFailed = !fe->stringToCMap(str, len, &g, &num_glyphs, flags, log_clusters,
-                                               attributes());
+                                               attributes(), &si);
     }
 
     if (!stringToCMapFailed) {
diff --git a/src/gui/text/qtextengine_p.h b/src/gui/text/qtextengine_p.h
index 366c5c3..c476485 100644
--- a/src/gui/text/qtextengine_p.h
+++ b/src/gui/text/qtextengine_p.h
@@ -64,6 +64,7 @@
 #include "QtGui/qpaintengine.h"
 #include "QtGui/qtextobject.h"
 #include "QtGui/qtextoption.h"
+#include "QtGui/qtextcursor.h"
 #include "QtCore/qset.h"
 #include "QtCore/qdebug.h"
 #ifndef QT_BUILD_COMPAT_LIB
@@ -471,6 +472,7 @@ public:
     void shape(int item) const;
 
     void justify(const QScriptLine &si);
+    QFixed alignLine(const QScriptLine &line);
 
     QFixed width(int charFrom, int numChars) const;
     glyph_metrics_t boundingBox(int from,  int len) const;
@@ -586,12 +588,18 @@ public:
     uint cacheGlyphs : 1;
     uint stackEngine : 1;
     uint forceJustification : 1;
+    uint visualMovement : 1;
 
     int *underlinePositions;
 
     mutable LayoutData *layoutData;
 
     inline bool hasFormats() const { return (block.docHandle() || specialData); }
+    inline bool visualCursorMovement() const
+    {
+        return (visualMovement ||
+                (block.docHandle() ? block.docHandle()->defaultCursorMoveStyle == QTextCursor::Visual : false));
+    }
 
     struct SpecialData {
         int preeditPosition;
@@ -611,6 +619,13 @@ public:
     void shapeLine(const QScriptLine &line);
     QFixed leadingSpaceWidth(const QScriptLine &line);
 
+    QFixed offsetInLigature(const QScriptItem *si, int pos, int max, int glyph_pos);
+    int previousLogicalPosition(int oldPos) const;
+    int nextLogicalPosition(int oldPos) const;
+    int lineNumberForTextPosition(int pos);
+    int positionAfterVisualMovement(int oldPos, QTextCursor::MoveOperation op);
+    void insertionPointsForLine(int lineNum, QVector<int> &insertionPoints);
+
 private:
     void setBoundary(int strPos) const;
     void addRequiredBoundaries() const;
@@ -625,6 +640,8 @@ private:
     void splitItem(int item, int pos) const;
 
     void resolveAdditionalFormats() const;
+    int endOfLine(int lineNum);
+    int beginningOfLine(int lineNum);
 };
 
 class QStackTextEngine : public QTextEngine {
@@ -635,6 +652,49 @@ public:
     void *_memory[MemSize];
 };
 
+struct QTextLineItemIterator
+{
+    QTextLineItemIterator(QTextEngine *eng, int lineNum, const QPointF &pos = QPointF(),
+                          const QTextLayout::FormatRange *_selection = 0);
+
+    inline bool atEnd() const { return logicalItem >= nItems - 1; }
+    inline bool atBeginning() const { return logicalItem <= 0; }
+    QScriptItem &next();
+
+    bool getSelectionBounds(QFixed *selectionX, QFixed *selectionWidth) const;
+    inline bool isOutsideSelection() const {
+        QFixed tmp1, tmp2;
+        return !getSelectionBounds(&tmp1, &tmp2);
+    }
+
+    QTextEngine *eng;
+
+    QFixed x;
+    QFixed pos_x;
+    const QScriptLine &line;
+    QScriptItem *si;
+
+    int lineNum;
+    int lineEnd;
+    int firstItem;
+    int lastItem;
+    int nItems;
+    int logicalItem;
+    int item;
+    int itemLength;
+
+    int glyphsStart;
+    int glyphsEnd;
+    int itemStart;
+    int itemEnd;
+
+    QFixed itemWidth;
+
+    QVarLengthArray<int> visualOrder;
+    QVarLengthArray<uchar> levels;
+
+    const QTextLayout::FormatRange *selection;
+};
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(QTextEngine::ShaperFlags)
 
diff --git a/src/gui/text/qtextformat.h b/src/gui/text/qtextformat.h
index ff28eaa..4f4752a 100644
--- a/src/gui/text/qtextformat.h
+++ b/src/gui/text/qtextformat.h
@@ -378,7 +378,8 @@ public:
         AlignSubScript,
         AlignMiddle,
         AlignTop,
-        AlignBottom
+        AlignBottom,
+        AlignBaseline
     };
     enum UnderlineStyle { // keep in sync with Qt::PenStyle!
         NoUnderline,
diff --git a/src/gui/text/qtextlayout.cpp b/src/gui/text/qtextlayout.cpp
index 93f71d3..01748b9 100644
--- a/src/gui/text/qtextlayout.cpp
+++ b/src/gui/text/qtextlayout.cpp
@@ -72,23 +72,6 @@ QT_BEGIN_NAMESPACE
 #define SuppressText 0x5012
 #define SuppressBackground 0x513
 
-static QFixed alignLine(QTextEngine *eng, const QScriptLine &line)
-{
-    QFixed x = 0;
-    eng->justify(line);
-    // if width is QFIXED_MAX that means we used setNumColumns() and that implicitly makes this line left aligned.
-    if (!line.justified && line.width != QFIXED_MAX) {
-        int align = eng->option.alignment();
-        if (align & Qt::AlignJustify && eng->isRightToLeft())
-            align = Qt::AlignRight;
-        if (align & Qt::AlignRight)
-            x = line.width - (line.textAdvance + eng->leadingSpaceWidth(line));
-        else if (align & Qt::AlignHCenter)
-            x = (line.width - line.textAdvance)/2;
-    }
-    return x;
-}
-
 /*!
     \class QTextLayout::FormatRange
     \reentrant
@@ -596,6 +579,30 @@ bool QTextLayout::cacheEnabled() const
 }
 
 /*!
+    Set the visual cursor movement style. If the QTextLayout is backed by
+    a document, you can ignore this and use the option in QTextDocument,
+    this option is for widgets like QLineEdit or custom widgets without
+    a QTextDocument. Default value is QTextCursor::Logical.
+
+    \sa setCursorMoveStyle()
+*/
+void QTextLayout::setCursorMoveStyle(QTextCursor::MoveStyle style)
+{
+    d->visualMovement = style == QTextCursor::Visual ? true : false;
+}
+
+/*!
+    The cursor movement style of this QTextLayout. The default is
+    QTextCursor::Logical.
+
+    \sa setCursorMoveStyle()
+*/
+QTextCursor::MoveStyle QTextLayout::cursorMoveStyle() const
+{
+    return d->visualMovement ? QTextCursor::Visual : QTextCursor::Logical;
+}
+
+/*!
     Begins the layout process.
 
     \sa endLayout()
@@ -718,6 +725,34 @@ int QTextLayout::previousCursorPosition(int oldPos, CursorMode mode) const
 }
 
 /*!
+    Returns the cursor position to the right of \a oldPos, next to it.
+    It's dependent on the visual position of characters, after bi-directional
+    reordering.
+
+    \sa leftCursorPosition(), nextCursorPosition()
+*/
+int QTextLayout::rightCursorPosition(int oldPos) const
+{
+    int newPos = d->positionAfterVisualMovement(oldPos, QTextCursor::Right);
+//    qDebug("%d -> %d", oldPos, newPos);
+    return newPos;
+}
+
+/*!
+    Returns the cursor position to the left of \a oldPos, next to it.
+    It's dependent on the visual position of characters, after bi-directional
+    reordering.
+
+    \sa rightCursorPosition(), previousCursorPosition()
+*/
+int QTextLayout::leftCursorPosition(int oldPos) const
+{
+    int newPos = d->positionAfterVisualMovement(oldPos, QTextCursor::Left);
+//    qDebug("%d -> %d", oldPos, newPos);
+    return newPos;
+}
+
+/*!/
     Returns true if position \a pos is a valid cursor position.
 
     In a Unicode context some positions in the text are not valid
@@ -815,16 +850,8 @@ QTextLine QTextLayout::lineAt(int i) const
 */
 QTextLine QTextLayout::lineForTextPosition(int pos) const
 {
-    for (int i = 0; i < d->lines.size(); ++i) {
-        const QScriptLine& line = d->lines[i];
-        if (line.from + (int)line.length > pos)
-            return QTextLine(i, d);
-    }
-    if (!d->layoutData)
-        d->itemize();
-    if (pos == d->layoutData->string.length() && d->lines.size())
-        return QTextLine(d->lines.size()-1, d);
-    return QTextLine();
+    int lineNum = d->lineNumberForTextPosition(pos);
+    return lineNum >= 0 ? lineAt(lineNum) : QTextLine();
 }
 
 /*!
@@ -919,201 +946,6 @@ void QTextLayout::setFlags(int flags)
     }
 }
 
-struct QTextLineItemIterator
-{
-    QTextLineItemIterator(QTextEngine *eng, int lineNum, const QPointF &pos = QPointF(),
-                          const QTextLayout::FormatRange *_selection = 0);
-
-    inline bool atEnd() const { return logicalItem >= nItems - 1; }
-    QScriptItem &next();
-
-    bool getSelectionBounds(QFixed *selectionX, QFixed *selectionWidth) const;
-    inline bool isOutsideSelection() const {
-        QFixed tmp1, tmp2;
-        return !getSelectionBounds(&tmp1, &tmp2);
-    }
-
-    QTextEngine *eng;
-
-    QFixed x;
-    QFixed pos_x;
-    const QScriptLine &line;
-    QScriptItem *si;
-
-    int lineEnd;
-    int firstItem;
-    int lastItem;
-    int nItems;
-    int logicalItem;
-    int item;
-    int itemLength;
-
-    int glyphsStart;
-    int glyphsEnd;
-    int itemStart;
-    int itemEnd;
-
-    QFixed itemWidth;
-
-    QVarLengthArray<int> visualOrder;
-    QVarLengthArray<uchar> levels;
-
-    const QTextLayout::FormatRange *selection;
-};
-
-QTextLineItemIterator::QTextLineItemIterator(QTextEngine *_eng, int lineNum, const QPointF &pos,
-                                             const QTextLayout::FormatRange *_selection)
-    : eng(_eng),
-      line(eng->lines[lineNum]),
-      si(0),
-      lineEnd(line.from + line.length),
-      firstItem(eng->findItem(line.from)),
-      lastItem(eng->findItem(lineEnd - 1)),
-      nItems((firstItem >= 0 && lastItem >= firstItem)? (lastItem-firstItem+1) : 0),
-      logicalItem(-1),
-      item(-1),
-      visualOrder(nItems),
-      levels(nItems),
-      selection(_selection)
-{
-    pos_x = x = QFixed::fromReal(pos.x());
-
-    x += line.x;
-
-    x += alignLine(eng, line);
-
-    for (int i = 0; i < nItems; ++i)
-        levels[i] = eng->layoutData->items[i+firstItem].analysis.bidiLevel;
-    QTextEngine::bidiReorder(nItems, levels.data(), visualOrder.data());
-
-    eng->shapeLine(line);
-}
-
-QScriptItem &QTextLineItemIterator::next()
-{
-    x += itemWidth;
-
-    ++logicalItem;
-    item = visualOrder[logicalItem] + firstItem;
-    itemLength = eng->length(item);
-    si = &eng->layoutData->items[item];
-    if (!si->num_glyphs)
-        eng->shape(item);
-
-    if (si->analysis.flags >= QScriptAnalysis::TabOrObject) {
-        itemWidth = si->width;
-        return *si;
-    }
-
-    unsigned short *logClusters = eng->logClusters(si);
-    QGlyphLayout glyphs = eng->shapedGlyphs(si);
-
-    itemStart = qMax(line.from, si->position);
-    glyphsStart = logClusters[itemStart - si->position];
-    if (lineEnd < si->position + itemLength) {
-        itemEnd = lineEnd;
-        glyphsEnd = logClusters[itemEnd-si->position];
-    } else {
-        itemEnd = si->position + itemLength;
-        glyphsEnd = si->num_glyphs;
-    }
-    // show soft-hyphen at line-break
-    if (si->position + itemLength >= lineEnd
-        && eng->layoutData->string.at(lineEnd - 1) == 0x00ad)
-        glyphs.attributes[glyphsEnd - 1].dontPrint = false;
-
-    itemWidth = 0;
-    for (int g = glyphsStart; g < glyphsEnd; ++g)
-        itemWidth += glyphs.effectiveAdvance(g);
-
-    return *si;
-}
-
-static QFixed offsetInLigature(const unsigned short *logClusters,
-                               const QGlyphLayout &glyphs,
-                               int pos, int max, int glyph_pos)
-{
-    int offsetInCluster = 0;
-    for (int i = pos - 1; i >= 0; i--) {
-        if (logClusters[i] == glyph_pos)
-            offsetInCluster++;
-        else
-            break;
-    }
-
-    // in the case that the offset is inside a (multi-character) glyph,
-    // interpolate the position.
-    if (offsetInCluster > 0) {
-        int clusterLength = 0;
-        for (int i = pos - offsetInCluster; i < max; i++) {
-            if (logClusters[i] == glyph_pos)
-                clusterLength++;
-            else
-                break;
-        }
-        if (clusterLength)
-            return glyphs.advances_x[glyph_pos] * offsetInCluster / clusterLength;
-    }
-
-    return 0;
-}
-
-bool QTextLineItemIterator::getSelectionBounds(QFixed *selectionX, QFixed *selectionWidth) const
-{
-    *selectionX = *selectionWidth = 0;
-
-    if (!selection)
-        return false;
-
-    if (si->analysis.flags >= QScriptAnalysis::TabOrObject) {
-        if (si->position >= selection->start + selection->length
-            || si->position + itemLength <= selection->start)
-            return false;
-
-        *selectionX = x;
-        *selectionWidth = itemWidth;
-    } else {
-        unsigned short *logClusters = eng->logClusters(si);
-        QGlyphLayout glyphs = eng->shapedGlyphs(si);
-
-        int from = qMax(itemStart, selection->start) - si->position;
-        int to = qMin(itemEnd, selection->start + selection->length) - si->position;
-        if (from >= to)
-            return false;
-
-        int start_glyph = logClusters[from];
-        int end_glyph = (to == eng->length(item)) ? si->num_glyphs : logClusters[to];
-        QFixed soff;
-        QFixed swidth;
-        if (si->analysis.bidiLevel %2) {
-            for (int g = glyphsEnd - 1; g >= end_glyph; --g)
-                soff += glyphs.effectiveAdvance(g);
-            for (int g = end_glyph - 1; g >= start_glyph; --g)
-                swidth += glyphs.effectiveAdvance(g);
-        } else {
-            for (int g = glyphsStart; g < start_glyph; ++g)
-                soff += glyphs.effectiveAdvance(g);
-            for (int g = start_glyph; g < end_glyph; ++g)
-                swidth += glyphs.effectiveAdvance(g);
-        }
-
-        // If the starting character is in the middle of a ligature,
-        // selection should only contain the right part of that ligature
-        // glyph, so we need to get the width of the left part here and
-        // add it to *selectionX
-        QFixed leftOffsetInLigature = offsetInLigature(logClusters, glyphs, from,
-                                                       to, start_glyph);
-        *selectionX = x + soff + leftOffsetInLigature;
-        *selectionWidth = swidth - leftOffsetInLigature;
-        // If the ending character is also part of a ligature, swidth does
-        // not contain that part yet, we also need to find out the width of
-        // that left part
-        *selectionWidth += offsetInLigature(logClusters, glyphs, to,
-                                            eng->length(item), end_glyph);
-    }
-    return true;
-}
-
 static void addSelectedRegionsToPath(QTextEngine *eng, int lineNumber, const QPointF &pos, QTextLayout::FormatRange *selection,
                                      QPainterPath *region, QRectF boundingRect)
 {
@@ -1228,6 +1060,7 @@ void QTextLayout::draw(QPainter *p, const QPointF &pos, const QVector<FormatRang
 
             QRectF lineRect(tl.naturalTextRect());
             lineRect.translate(position);
+            lineRect.adjust(0, 0, d->leadingSpaceWidth(sl).toReal(), 0);
 
             bool isLastLineInBlock = (line == d->lines.size()-1);
             int sl_length = sl.length + (isLastLineInBlock? 1 : 0); // the infamous newline
@@ -1378,22 +1211,11 @@ void QTextLayout::drawCursor(QPainter *p, const QPointF &pos, int cursorPosition
         d->itemize();
 
     QPointF position = pos + d->position;
-    QFixed pos_x = QFixed::fromReal(position.x());
-    QFixed pos_y = QFixed::fromReal(position.y());
 
     cursorPosition = qBound(0, cursorPosition, d->layoutData->string.length());
-    int line = 0;
-    if (cursorPosition == d->layoutData->string.length()) {
-        line = d->lines.size() - 1;
-    } else {
-        // ### binary search
-        for (line = 0; line < d->lines.size(); line++) {
-            const QScriptLine &sl = d->lines[line];
-            if (sl.from <= cursorPosition && sl.from + (int)sl.length > cursorPosition)
-                break;
-        }
-    }
-
+    int line = d->lineNumberForTextPosition(cursorPosition);
+    if (line < 0)
+        line = 0;
     if (line >= d->lines.size())
         return;
 
@@ -1402,7 +1224,15 @@ void QTextLayout::drawCursor(QPainter *p, const QPointF &pos, int cursorPosition
 
     qreal x = position.x() + l.cursorToX(cursorPosition);
 
-    int itm = d->findItem(cursorPosition - 1);
+    int itm;
+
+    if (d->visualCursorMovement()) {
+        if (cursorPosition == sl.from + sl.length)
+            cursorPosition--;
+        itm = d->findItem(cursorPosition);
+    } else
+        itm = d->findItem(cursorPosition - 1);
+
     QFixed base = sl.base();
     QFixed descent = sl.descent;
     bool rightToLeft = d->isRightToLeft();
@@ -1512,7 +1342,7 @@ QRectF QTextLine::rect() const
 QRectF QTextLine::naturalTextRect() const
 {
     const QScriptLine& sl = eng->lines[i];
-    QFixed x = sl.x + alignLine(eng, sl);
+    QFixed x = sl.x + eng->alignLine(sl);
 
     QFixed width = sl.textWidth;
     if (sl.justified)
@@ -2317,6 +2147,9 @@ QList<QGlyphs> QTextLine::glyphs(int from, int length) const
                     QGlyphLayout subLayout = glyphLayout.mid(start, end - start);
                     glyphLayoutHash.insertMulti(multiFontEngine->engine(which),
                                                 GlyphInfo(subLayout, pos, flags));
+                    for (int i = 0; i < subLayout.numGlyphs; i++)
+                        pos += QPointF(subLayout.advances_x[i].toReal(),
+                                       subLayout.advances_y[i].toReal());
 
                     start = end;
                     which = e;
@@ -2632,9 +2465,10 @@ qreal QTextLine::cursorToX(int *cursorPos, Edge edge) const
         eng->itemize();
 
     const QScriptLine &line = eng->lines[i];
+    bool lastLine = i >= eng->lines.size() - 1;
 
     QFixed x = line.x;
-    x += alignLine(eng, line);
+    x += eng->alignLine(line);
 
     if (!i && !eng->layoutData->items.size()) {
         *cursorPos = 0;
@@ -2720,21 +2554,29 @@ qreal QTextLine::cursorToX(int *cursorPos, Edge edge) const
     logClusters = eng->logClusters(si);
     glyphs = eng->shapedGlyphs(si);
     if (si->analysis.flags >= QScriptAnalysis::TabOrObject) {
-        if(pos == l)
+        if (pos == (reverse ? 0 : l))
             x += si->width;
     } else {
+        bool rtl = eng->isRightToLeft();
+        bool visual = eng->visualCursorMovement();
         if (reverse) {
             int end = qMin(lineEnd, si->position + l) - si->position;
             int glyph_end = end == l ? si->num_glyphs : logClusters[end];
-            for (int i = glyph_end - 1; i >= glyph_pos; i--)
+            int glyph_start = glyph_pos;
+            if (visual && !rtl && !(lastLine && itm == (visualOrder[nItems - 1] + firstItem)))
+                glyph_start++;
+            for (int i = glyph_end - 1; i >= glyph_start; i--)
                 x += glyphs.effectiveAdvance(i);
         } else {
             int start = qMax(line.from - si->position, 0);
             int glyph_start = logClusters[start];
-            for (int i = glyph_start; i < glyph_pos; i++)
+            int glyph_end = glyph_pos;
+            if (!visual || !rtl || (lastLine && itm == visualOrder[0] + firstItem))
+                glyph_end--;
+            for (int i = glyph_start; i <= glyph_end; i++)
                 x += glyphs.effectiveAdvance(i);
         }
-        x += offsetInLigature(logClusters, glyphs, pos, line.length, glyph_pos);
+        x += eng->offsetInLigature(si, pos, line.length, glyph_pos);
     }
 
     *cursorPos = pos + si->position;
@@ -2753,6 +2595,8 @@ int QTextLine::xToCursor(qreal _x, CursorPosition cpos) const
 {
     QFixed x = QFixed::fromReal(_x);
     const QScriptLine &line = eng->lines[i];
+    bool lastLine = i >= eng->lines.size() - 1;
+    int lineNum = i;
 
     if (!eng->layoutData)
         eng->itemize();
@@ -2770,7 +2614,7 @@ int QTextLine::xToCursor(qreal _x, CursorPosition cpos) const
         return 0;
 
     x -= line.x;
-    x -= alignLine(eng, line);
+    x -= eng->alignLine(line);
 //     qDebug("xToCursor: x=%f, cpos=%d", x.toReal(), cpos);
 
     QVarLengthArray<int> visualOrder(nItems);
@@ -2779,6 +2623,7 @@ int QTextLine::xToCursor(qreal _x, CursorPosition cpos) const
         levels[i] = eng->layoutData->items[i+firstItem].analysis.bidiLevel;
     QTextEngine::bidiReorder(nItems, levels.data(), visualOrder.data());
 
+    bool visual = eng->visualCursorMovement();
     if (x <= 0) {
         // left of first item
         int item = visualOrder[0]+firstItem;
@@ -2795,8 +2640,13 @@ int QTextLine::xToCursor(qreal _x, CursorPosition cpos) const
                || (line.justified && x < line.width)) {
         // has to be in one of the runs
         QFixed pos;
+        bool rtl = eng->isRightToLeft();
 
         eng->shapeLine(line);
+        QVector<int> insertionPoints;
+        if (visual && rtl)
+            eng->insertionPointsForLine(lineNum, insertionPoints);
+        int nchars = 0;
         for (int i = 0; i < nItems; ++i) {
             int item = visualOrder[i]+firstItem;
             QScriptItem &si = eng->layoutData->items[item];
@@ -2826,6 +2676,7 @@ int QTextLine::xToCursor(qreal _x, CursorPosition cpos) const
 
             if (pos + item_width < x) {
                 pos += item_width;
+                nchars += end;
                 continue;
             }
 //             qDebug("      inside run");
@@ -2870,27 +2721,60 @@ int QTextLine::xToCursor(qreal _x, CursorPosition cpos) const
             } else {
                 QFixed dist = INT_MAX/256;
                 if (si.analysis.bidiLevel % 2) {
-                    pos += item_width;
-                    while (gs <= ge) {
-                        if (glyphs.attributes[gs].clusterStart && qAbs(x-pos) < dist) {
-                            glyph_pos = gs;
-                            dist = qAbs(x-pos);
+                    if (!visual || rtl || (lastLine && i == nItems - 1)) {
+                        pos += item_width;
+                        while (gs <= ge) {
+                            if (glyphs.attributes[gs].clusterStart && qAbs(x-pos) < dist) {
+                                glyph_pos = gs;
+                                dist = qAbs(x-pos);
+                            }
+                            pos -= glyphs.effectiveAdvance(gs);
+                            ++gs;
+                        }
+                    } else {
+                        while (ge >= gs) {
+                            if (glyphs.attributes[ge].clusterStart && qAbs(x-pos) < dist) {
+                                glyph_pos = ge;
+                                dist = qAbs(x-pos);
+                            }
+                            pos += glyphs.effectiveAdvance(ge);
+                            --ge;
                         }
-                        pos -= glyphs.effectiveAdvance(gs);
-                        ++gs;
                     }
                 } else {
-                    while (gs <= ge) {
-                        if (glyphs.attributes[gs].clusterStart && qAbs(x-pos) < dist) {
-                            glyph_pos = gs;
-                            dist = qAbs(x-pos);
+                    if (!visual || !rtl || (lastLine && i == 0)) {
+                        while (gs <= ge) {
+                            if (glyphs.attributes[gs].clusterStart && qAbs(x-pos) < dist) {
+                                glyph_pos = gs;
+                                dist = qAbs(x-pos);
+                            }
+                            pos += glyphs.effectiveAdvance(gs);
+                            ++gs;
                         }
-                        pos += glyphs.effectiveAdvance(gs);
-                        ++gs;
+                    } else {
+                        QFixed oldPos = pos;
+                        while (gs <= ge) {
+                            pos += glyphs.effectiveAdvance(gs);
+                            if (glyphs.attributes[gs].clusterStart && qAbs(x-pos) < dist) {
+                                glyph_pos = gs;
+                                dist = qAbs(x-pos);
+                            }
+                            ++gs;
+                        }
+                        pos = oldPos;
                     }
                 }
-                if (qAbs(x-pos) < dist)
+                if (qAbs(x-pos) < dist) {
+                    if (visual) {
+                        if (!rtl && i < nItems - 1) {
+                            nchars += end;
+                            continue;
+                        }
+                        if (rtl && nchars > 0)
+                            return insertionPoints[lastLine ? nchars : nchars - 1];
+                    }
                     return si.position + end;
+                }
             }
             Q_ASSERT(glyph_pos != -1);
             int j;
diff --git a/src/gui/text/qtextlayout.h b/src/gui/text/qtextlayout.h
index 9dd8ebd..6aa81f9 100644
--- a/src/gui/text/qtextlayout.h
+++ b/src/gui/text/qtextlayout.h
@@ -50,6 +50,7 @@
 #include <QtGui/qevent.h>
 #include <QtGui/qtextformat.h>
 #include <QtGui/qglyphs.h>
+#include <QtGui/qtextcursor.h>
 
 QT_BEGIN_HEADER
 
@@ -136,6 +137,9 @@ public:
     void setCacheEnabled(bool enable);
     bool cacheEnabled() const;
 
+    void setCursorMoveStyle(QTextCursor::MoveStyle style);
+    QTextCursor::MoveStyle cursorMoveStyle() const;
+
     void beginLayout();
     void endLayout();
     void clearLayout();
@@ -153,6 +157,8 @@ public:
     bool isValidCursorPosition(int pos) const;
     int nextCursorPosition(int oldPos, CursorMode mode = SkipCharacters) const;
     int previousCursorPosition(int oldPos, CursorMode mode = SkipCharacters) const;
+    int leftCursorPosition(int oldPos) const;
+    int rightCursorPosition(int oldPos) const;
 
     void draw(QPainter *p, const QPointF &pos, const QVector<FormatRange> &selections = QVector<FormatRange>(),
               const QRectF &clip = QRectF()) const;
diff --git a/src/gui/text/text.pri b/src/gui/text/text.pri
index df9398c..e5d57d0 100644
--- a/src/gui/text/text.pri
+++ b/src/gui/text/text.pri
@@ -114,6 +114,9 @@ unix:x11 {
         OBJECTIVE_SOURCES += \
                 text/qfontengine_coretext.mm \
                 text/qfontengine_mac.mm
+        contains(QT_CONFIG, harfbuzz) {
+            DEFINES += QT_ENABLE_HARFBUZZ_FOR_MAC
+        }
 }
 
 embedded {
@@ -136,7 +139,8 @@ qpa {
 	SOURCES += \
                 text/qfont_qpa.cpp \
                 text/qfontengine_qpa.cpp \
-                text/qplatformfontdatabase_qpa.cpp
+                text/qplatformfontdatabase_qpa.cpp \
+                text/qrawfont_qpa.cpp
 
 	HEADERS += \
                 text/qplatformfontdatabase_qpa.h
diff --git a/src/gui/util/qflickgesture.cpp b/src/gui/util/qflickgesture.cpp
index fdd2a95..f87c84c 100644
--- a/src/gui/util/qflickgesture.cpp
+++ b/src/gui/util/qflickgesture.cpp
@@ -218,10 +218,10 @@ public:
             mouseTarget = 0;
         } else if (mouseTarget) {
             // we did send a press, so we need to fake a release now
-            Qt::MouseButtons mouseButtons = QApplication::mouseButtons();
 
             // release all pressed mouse buttons
-            /*for (int i = 0; i < 32; ++i) {
+            /* Qt::MouseButtons mouseButtons = QApplication::mouseButtons();
+            for (int i = 0; i < 32; ++i) {
                 if (mouseButtons & (1 << i)) {
                     Qt::MouseButton b = static_cast<Qt::MouseButton>(1 << i);
                     mouseButtons &= ~b;
diff --git a/src/gui/util/qscroller.cpp b/src/gui/util/qscroller.cpp
index db128c1..870d56f 100644
--- a/src/gui/util/qscroller.cpp
+++ b/src/gui/util/qscroller.cpp
@@ -1777,10 +1777,7 @@ void QScrollerPrivate::setState(QScroller::State newstate)
 */
 void QScrollerPrivate::setContentPositionHelperDragging(const QPointF &deltaPos)
 {
-    Q_Q(QScroller);
-    QPointF ppm = q->pixelPerMeter();
     const QScrollerPropertiesPrivate *sp = properties.d.data();
-    QPointF v = q->velocity();
 
     if (sp->overshootDragResistanceFactor)
         overshootPosition /= sp->overshootDragResistanceFactor;
diff --git a/src/gui/widgets/qdatetimeedit.cpp b/src/gui/widgets/qdatetimeedit.cpp
index 6337113..a4739a7 100644
--- a/src/gui/widgets/qdatetimeedit.cpp
+++ b/src/gui/widgets/qdatetimeedit.cpp
@@ -2538,20 +2538,32 @@ void QDateTimeEditPrivate::syncCalendarWidget()
 }
 
 QCalendarPopup::QCalendarPopup(QWidget * parent, QCalendarWidget *cw)
-    : QWidget(parent, Qt::Popup), calendar(0)
+    : QWidget(parent, Qt::Popup)
 {
     setAttribute(Qt::WA_WindowPropagation);
 
     dateChanged = false;
     if (!cw) {
-        cw = new QCalendarWidget(this);
+        verifyCalendarInstance();
+    } else {
+        setCalendarWidget(cw);
+    }
+}
+
+QCalendarWidget *QCalendarPopup::verifyCalendarInstance()
+{
+    if (calendar.isNull()) {
+        QCalendarWidget *cw = new QCalendarWidget(this);
         cw->setVerticalHeaderFormat(QCalendarWidget::NoVerticalHeader);
 #ifdef QT_KEYPAD_NAVIGATION
         if (QApplication::keypadNavigationEnabled())
             cw->setHorizontalHeaderFormat(QCalendarWidget::SingleLetterDayNames);
 #endif
+        setCalendarWidget(cw);
+        return cw;
+    } else {
+        return calendar.data();
     }
-    setCalendarWidget(cw);
 }
 
 void QCalendarPopup::setCalendarWidget(QCalendarWidget *cw)
@@ -2563,28 +2575,29 @@ void QCalendarPopup::setCalendarWidget(QCalendarWidget *cw)
         widgetLayout->setMargin(0);
         widgetLayout->setSpacing(0);
     }
-    delete calendar;
-    calendar = cw;
-    widgetLayout->addWidget(calendar);
+    delete calendar.data();
+    calendar = QWeakPointer<QCalendarWidget>(cw);
+    widgetLayout->addWidget(cw);
 
-    connect(calendar, SIGNAL(activated(QDate)), this, SLOT(dateSelected(QDate)));
-    connect(calendar, SIGNAL(clicked(QDate)), this, SLOT(dateSelected(QDate)));
-    connect(calendar, SIGNAL(selectionChanged()), this, SLOT(dateSelectionChanged()));
+    connect(cw, SIGNAL(activated(QDate)), this, SLOT(dateSelected(QDate)));
+    connect(cw, SIGNAL(clicked(QDate)), this, SLOT(dateSelected(QDate)));
+    connect(cw, SIGNAL(selectionChanged()), this, SLOT(dateSelectionChanged()));
 
-    calendar->setFocus();
+    cw->setFocus();
 }
 
 
 void QCalendarPopup::setDate(const QDate &date)
 {
     oldDate = date;
-    calendar->setSelectedDate(date);
+    verifyCalendarInstance()->setSelectedDate(date);
 }
 
 void QCalendarPopup::setDateRange(const QDate &min, const QDate &max)
 {
-    calendar->setMinimumDate(min);
-    calendar->setMaximumDate(max);
+    QCalendarWidget *cw = verifyCalendarInstance();
+    cw->setMinimumDate(min);
+    cw->setMaximumDate(max);
 }
 
 void QCalendarPopup::mousePressEvent(QMouseEvent *event)
@@ -2620,7 +2633,7 @@ bool QCalendarPopup::event(QEvent *event)
 void QCalendarPopup::dateSelectionChanged()
 {
     dateChanged = true;
-    emit newDateSelected(calendar->selectedDate());
+    emit newDateSelected(verifyCalendarInstance()->selectedDate());
 }
 void QCalendarPopup::dateSelected(const QDate &date)
 {
diff --git a/src/gui/widgets/qdatetimeedit_p.h b/src/gui/widgets/qdatetimeedit_p.h
index acdc878..c85c0fb 100644
--- a/src/gui/widgets/qdatetimeedit_p.h
+++ b/src/gui/widgets/qdatetimeedit_p.h
@@ -148,11 +148,11 @@ class QCalendarPopup : public QWidget
     Q_OBJECT
 public:
     QCalendarPopup(QWidget *parent = 0, QCalendarWidget *cw = 0);
-    QDate selectedDate() { return calendar->selectedDate(); }
+    QDate selectedDate() { return verifyCalendarInstance()->selectedDate(); }
     void setDate(const QDate &date);
     void setDateRange(const QDate &min, const QDate &max);
-    void setFirstDayOfWeek(Qt::DayOfWeek dow) { calendar->setFirstDayOfWeek(dow); }
-    QCalendarWidget *calendarWidget() const { return calendar; }
+    void setFirstDayOfWeek(Qt::DayOfWeek dow) { verifyCalendarInstance()->setFirstDayOfWeek(dow); }
+    QCalendarWidget *calendarWidget() const { return const_cast<QCalendarPopup*>(this)->verifyCalendarInstance(); }
     void setCalendarWidget(QCalendarWidget *cw);
 Q_SIGNALS:
     void activated(const QDate &date);
@@ -171,7 +171,9 @@ protected:
     bool event(QEvent *e);
 
 private:
-    QCalendarWidget *calendar;
+    QCalendarWidget *verifyCalendarInstance();
+
+    QWeakPointer<QCalendarWidget> calendar;
     QDate oldDate;
     bool dateChanged;
 };
diff --git a/src/gui/widgets/qdockarealayout.cpp b/src/gui/widgets/qdockarealayout.cpp
index 223421d..28c0388 100644
--- a/src/gui/widgets/qdockarealayout.cpp
+++ b/src/gui/widgets/qdockarealayout.cpp
@@ -2100,7 +2100,6 @@ bool QDockAreaLayoutInfo::updateTabBar() const
     bool gap = false;
 
     int tab_idx = 0;
-    bool changed = false;
     for (int i = 0; i < item_list.count(); ++i) {
         const QDockAreaLayoutItem &item = item_list.at(i);
         if (item.skip())
@@ -2121,7 +2120,6 @@ bool QDockAreaLayoutInfo::updateTabBar() const
             tabBar->setTabToolTip(tab_idx, title);
 #endif
             tabBar->setTabData(tab_idx, id);
-            changed = true;
         } else if (qvariant_cast<quintptr>(tabBar->tabData(tab_idx)) != id) {
             if (tab_idx + 1 < tabBar->count()
                     && qvariant_cast<quintptr>(tabBar->tabData(tab_idx + 1)) == id)
@@ -2133,7 +2131,6 @@ bool QDockAreaLayoutInfo::updateTabBar() const
 #endif
                 tabBar->setTabData(tab_idx, id);
             }
-            changed = true;
         }
 
         if (title != tabBar->tabText(tab_idx)) {
@@ -2141,7 +2138,6 @@ bool QDockAreaLayoutInfo::updateTabBar() const
 #ifndef QT_NO_TOOLTIP
             tabBar->setTabToolTip(tab_idx, title);
 #endif
-            changed = true;
         }
 
         ++tab_idx;
@@ -2149,7 +2145,6 @@ bool QDockAreaLayoutInfo::updateTabBar() const
 
     while (tab_idx < tabBar->count()) {
         tabBar->removeTab(tab_idx);
-        changed = true;
     }
 
     tabBar->blockSignals(blocked);
diff --git a/src/gui/widgets/qdockwidget.cpp b/src/gui/widgets/qdockwidget.cpp
index 9d1a737..16b60c8 100644
--- a/src/gui/widgets/qdockwidget.cpp
+++ b/src/gui/widgets/qdockwidget.cpp
@@ -161,7 +161,6 @@ void QDockWidgetTitleButton::paintEvent(QPaintEvent *)
 {
     QPainter p(this);
 
-    QRect r = rect();
     QStyleOptionToolButton opt;
     opt.init(this);
     opt.state |= QStyle::State_AutoRaise;
diff --git a/src/gui/widgets/qlinecontrol.cpp b/src/gui/widgets/qlinecontrol.cpp
index 289faa9..4fb0f0c 100644
--- a/src/gui/widgets/qlinecontrol.cpp
+++ b/src/gui/widgets/qlinecontrol.cpp
@@ -651,7 +651,12 @@ void QLineControl::internalSetText(const QString &txt, int pos, bool edited)
     m_modifiedState =  m_undoState = 0;
     m_cursor = (pos < 0 || pos > m_text.length()) ? m_text.length() : pos;
     m_textDirty = (oldText != m_text);
-    finishChange(-1, true, edited);
+    bool changed = finishChange(-1, true, edited);
+
+#ifndef QT_NO_ACCESSIBILITY
+    if (changed)
+        QAccessible::updateAccessibility(parent(), 0, QAccessible::TextUpdated);
+#endif
 }
 
 
@@ -1238,6 +1243,9 @@ void QLineControl::emitCursorPositionChanged()
         const int oldLast = m_lastCursorPos;
         m_lastCursorPos = m_cursor;
         cursorPositionChanged(oldLast, m_cursor);
+#ifndef QT_NO_ACCESSIBILITY
+        QAccessible::updateAccessibility(parent(), 0, QAccessible::TextCaretMoved);
+#endif
     }
 }
 
@@ -1585,6 +1593,7 @@ void QLineControl::processKeyEvent(QKeyEvent* event)
     }
 
     bool unknown = false;
+    bool visual = cursorMoveStyle() == QTextCursor::Visual;
 
     if (false) {
     }
@@ -1649,11 +1658,11 @@ void QLineControl::processKeyEvent(QKeyEvent* event)
 #endif
             moveCursor(selectionEnd(), false);
         } else {
-            cursorForward(0, layoutDirection() == Qt::LeftToRight ? 1 : -1);
+            cursorForward(0, visual ? 1 : (layoutDirection() == Qt::LeftToRight ? 1 : -1));
         }
     }
     else if (event == QKeySequence::SelectNextChar) {
-        cursorForward(1, layoutDirection() == Qt::LeftToRight ? 1 : -1);
+        cursorForward(1, visual ? 1 : (layoutDirection() == Qt::LeftToRight ? 1 : -1));
     }
     else if (event == QKeySequence::MoveToPreviousChar) {
 #if !defined(Q_WS_WIN) || defined(QT_NO_COMPLETER)
@@ -1664,11 +1673,11 @@ void QLineControl::processKeyEvent(QKeyEvent* event)
 #endif
             moveCursor(selectionStart(), false);
         } else {
-            cursorForward(0, layoutDirection() == Qt::LeftToRight ? -1 : 1);
+            cursorForward(0, visual ? -1 : (layoutDirection() == Qt::LeftToRight ? -1 : 1));
         }
     }
     else if (event == QKeySequence::SelectPreviousChar) {
-        cursorForward(1, layoutDirection() == Qt::LeftToRight ? -1 : 1);
+        cursorForward(1, visual ? -1 : (layoutDirection() == Qt::LeftToRight ? -1 : 1));
     }
     else if (event == QKeySequence::MoveToNextWord) {
         if (echoMode() == QLineEdit::Normal)
diff --git a/src/gui/widgets/qlinecontrol_p.h b/src/gui/widgets/qlinecontrol_p.h
index 3c505c8..0655276 100644
--- a/src/gui/widgets/qlinecontrol_p.h
+++ b/src/gui/widgets/qlinecontrol_p.h
@@ -61,10 +61,10 @@
 #include "QtGui/qtextlayout.h"
 #include "QtGui/qstyleoption.h"
 #include "QtCore/qpointer.h"
-#include "QtGui/qlineedit.h"
 #include "QtGui/qclipboard.h"
 #include "QtCore/qpoint.h"
 #include "QtGui/qcompleter.h"
+#include "QtGui/qaccessible.h"
 
 QT_BEGIN_HEADER
 
@@ -160,6 +160,8 @@ public:
     int cursorWidth() const { return m_cursorWidth; }
     void setCursorWidth(int value) { m_cursorWidth = value; }
 
+    QTextCursor::MoveStyle cursorMoveStyle() const { return m_textLayout.cursorMoveStyle(); }
+    void setCursorMoveStyle(QTextCursor::MoveStyle style) { m_textLayout.setCursorMoveStyle(style); }
 
     void moveCursor(int pos, bool mark = false);
     void cursorForward(bool mark, int steps)
@@ -167,10 +169,12 @@ public:
         int c = m_cursor;
         if (steps > 0) {
             while (steps--)
-                c = m_textLayout.nextCursorPosition(c);
+                c = cursorMoveStyle() == QTextCursor::Visual ? m_textLayout.rightCursorPosition(c)
+                                                             : m_textLayout.nextCursorPosition(c);
         } else if (steps < 0) {
             while (steps++)
-                c = m_textLayout.previousCursorPosition(c);
+                c = cursorMoveStyle() == QTextCursor::Visual ? m_textLayout.leftCursorPosition(c)
+                                                             : m_textLayout.previousCursorPosition(c);
         }
         moveCursor(c, mark);
     }
diff --git a/src/gui/widgets/qlineedit.cpp b/src/gui/widgets/qlineedit.cpp
index 07bd273..43c3f52 100644
--- a/src/gui/widgets/qlineedit.cpp
+++ b/src/gui/widgets/qlineedit.cpp
@@ -1112,6 +1112,34 @@ void QLineEdit::setDragEnabled(bool b)
 
 
 /*!
+  \property QLineEdit::cursorMoveStyle
+  \brief the movement style of cursor in this line edit
+  \since 4.8
+
+  When this property is set to QTextCursor::Visual, the line edit will use visual
+  movement style. Pressing the left arrow key will always cause the cursor to move
+  left, regardless of the text's writing direction. The same behavior applies to
+  right arrow key.
+
+  When the property is QTextCursor::Logical (the default), within a LTR text block,
+  increase cursor position when pressing left arrow key, decrease cursor position
+  when pressing the right arrow key. If the text block is right to left, the opposite
+  behavior applies.
+*/
+
+QTextCursor::MoveStyle QLineEdit::cursorMoveStyle() const
+{
+    Q_D(const QLineEdit);
+    return d->control->cursorMoveStyle();
+}
+
+void QLineEdit::setCursorMoveStyle(QTextCursor::MoveStyle style)
+{
+    Q_D(QLineEdit);
+    d->control->setCursorMoveStyle(style);
+}
+
+/*!
     \property QLineEdit::acceptableInput
     \brief whether the input satisfies the inputMask and the
     validator.
diff --git a/src/gui/widgets/qlineedit.h b/src/gui/widgets/qlineedit.h
index 636cee7..73a736c 100644
--- a/src/gui/widgets/qlineedit.h
+++ b/src/gui/widgets/qlineedit.h
@@ -43,6 +43,7 @@
 #define QLINEEDIT_H
 
 #include <QtGui/qframe.h>
+#include <QtGui/qtextcursor.h>
 #include <QtCore/qstring.h>
 #include <QtCore/qmargins.h>
 
@@ -158,6 +159,9 @@ public:
     void setDragEnabled(bool b);
     bool dragEnabled() const;
 
+    void setCursorMoveStyle(QTextCursor::MoveStyle style);
+    QTextCursor::MoveStyle cursorMoveStyle() const;
+
     QString inputMask() const;
     void setInputMask(const QString &inputMask);
     bool hasAcceptableInput() const;
diff --git a/src/gui/widgets/qlineedit_p.cpp b/src/gui/widgets/qlineedit_p.cpp
index 23ac613..03716d4 100644
--- a/src/gui/widgets/qlineedit_p.cpp
+++ b/src/gui/widgets/qlineedit_p.cpp
@@ -153,6 +153,7 @@ void QLineEditPrivate::init(const QString& txt)
 {
     Q_Q(QLineEdit);
     control = new QLineControl(txt);
+    control->setParent(q);
     control->setFont(q->font());
     QObject::connect(control, SIGNAL(textChanged(QString)),
             q, SIGNAL(textChanged(QString)));
diff --git a/src/gui/widgets/qlineedit_p.h b/src/gui/widgets/qlineedit_p.h
index 32f6077..3169776 100644
--- a/src/gui/widgets/qlineedit_p.h
+++ b/src/gui/widgets/qlineedit_p.h
@@ -84,7 +84,6 @@ public:
 
     ~QLineEditPrivate()
     {
-        delete control;
     }
 
     QLineControl *control;
diff --git a/src/gui/widgets/qmenu.cpp b/src/gui/widgets/qmenu.cpp
index b12e5c5..b0ea00f 100644
--- a/src/gui/widgets/qmenu.cpp
+++ b/src/gui/widgets/qmenu.cpp
@@ -228,6 +228,12 @@ QList<QPointer<QWidget> > QMenuPrivate::calcCausedStack() const
 void QMenuPrivate::updateActionRects() const
 {
     Q_Q(const QMenu);
+    updateActionRects(popupGeometry(q));
+}
+
+void QMenuPrivate::updateActionRects(const QRect &screen) const
+{
+    Q_Q(const QMenu);
     if (!itemsDirty)
         return;
 
@@ -237,20 +243,10 @@ void QMenuPrivate::updateActionRects() const
     actionRects.resize(actions.count());
     actionRects.fill(QRect());
 
-    //let's try to get the last visible action
-    int lastVisibleAction = actions.count() - 1;
-    for(;lastVisibleAction >= 0; --lastVisibleAction) {
-        const QAction *action = actions.at(lastVisibleAction);
-        if (action->isVisible()) {
-            //removing trailing separators
-            if (action->isSeparator() && collapsibleSeparators)
-                continue;
-            break;
-        }
-    }
+    int lastVisibleAction = getLastVisibleAction();
 
     int max_column_width = 0,
-        dh = popupGeometry(q).height(),
+        dh = screen.height(),
         y = 0;
     QStyle *style = q->style();
     QStyleOption opt;
@@ -351,7 +347,6 @@ void QMenuPrivate::updateActionRects() const
     const int min_column_width = q->minimumWidth() - (sfcMargin + leftmargin + rightmargin + 2 * (fw + hmargin));
     max_column_width = qMax(min_column_width, max_column_width);
 
-
     //calculate position
     const int base_y = vmargin + fw + topmargin +
         (scroll ? scroll->scrollOffset : 0) +
@@ -382,6 +377,34 @@ void QMenuPrivate::updateActionRects() const
     itemsDirty = 0;
 }
 
+QSize QMenuPrivate::adjustMenuSizeForScreen(const QRect &screen)
+{
+    Q_Q(QMenu);
+    QSize ret = screen.size();
+    itemsDirty = true;
+    updateActionRects(screen);
+    const int fw = q->style()->pixelMetric(QStyle::PM_MenuPanelWidth, 0, q);
+    ret.setWidth(actionRects.at(getLastVisibleAction()).right() + fw);
+    return ret;
+}
+
+int QMenuPrivate::getLastVisibleAction() const
+{
+    //let's try to get the last visible action
+    int lastVisibleAction = actions.count() - 1;
+    for (;lastVisibleAction >= 0; --lastVisibleAction) {
+        const QAction *action = actions.at(lastVisibleAction);
+        if (action->isVisible()) {
+            //removing trailing separators
+            if (action->isSeparator() && collapsibleSeparators)
+                continue;
+            break;
+        }
+    }
+    return lastVisibleAction;
+}
+
+
 QRect QMenuPrivate::actionRect(QAction *act) const
 {
     int index = actions.indexOf(act);
@@ -1813,9 +1836,20 @@ void QMenu::popup(const QPoint &p, QAction *atAction)
     else
 #endif
     screen = d->popupGeometry(QApplication::desktop()->screenNumber(p));
-
     const int desktopFrame = style()->pixelMetric(QStyle::PM_MenuDesktopFrameWidth, 0, this);
     bool adjustToDesktop = !window()->testAttribute(Qt::WA_DontShowOnScreen);
+
+    // if the screens have very different geometries and the menu is too big, we have to recalculate
+    if (size.height() > screen.height() || size.width() > screen.width()) {
+        size = d->adjustMenuSizeForScreen(screen);
+        adjustToDesktop = true;
+    }
+    // Layout is not right, we might be able to save horizontal space
+    if (d->ncols >1 && size.height() < screen.height()) {
+        size = d->adjustMenuSizeForScreen(screen);
+        adjustToDesktop = true;
+    }
+
 #ifdef QT_KEYPAD_NAVIGATION
     if (!atAction && QApplication::keypadNavigationEnabled()) {
         // Try to have one item activated
@@ -1909,6 +1943,27 @@ void QMenu::popup(const QPoint &p, QAction *atAction)
             }
         }
     }
+    const int subMenuOffset = style()->pixelMetric(QStyle::PM_SubMenuOverlap, 0, this);
+    const QSize menuSize(sizeHint());
+    QMenu *caused = qobject_cast<QMenu*>(d_func()->causedPopup.widget);
+    if (caused && caused->geometry().width() + menuSize.width() + subMenuOffset < screen.width()) {
+        QRect parentActionRect(caused->d_func()->actionRect(caused->d_func()->currentAction));
+        const QPoint actionTopLeft = caused->mapToGlobal(parentActionRect.topLeft());
+        parentActionRect.moveTopLeft(actionTopLeft);
+        if (isRightToLeft()) {
+            if ((pos.x() + menuSize.width() > parentActionRect.left() - subMenuOffset)
+                && (pos.x() < parentActionRect.right()))
+            {
+                    pos.rx() = parentActionRect.right();
+            }
+        } else {
+            if ((pos.x() < parentActionRect.right() + subMenuOffset)
+                && (pos.x() + menuSize.width() > parentActionRect.left()))
+            {
+                    pos.rx() = parentActionRect.left() - menuSize.width();
+            }
+        }
+    }
     setGeometry(QRect(pos, size));
 #ifndef QT_NO_EFFECTS
     int hGuess = isRightToLeft() ? QEffects::LeftScroll : QEffects::RightScroll;
@@ -2941,28 +2996,8 @@ void QMenu::internalDelayedPopup()
     const QRect actionRect(d->actionRect(d->currentAction));
     const QSize menuSize(d->activeMenu->sizeHint());
     const QPoint rightPos(mapToGlobal(QPoint(actionRect.right() + subMenuOffset + 1, actionRect.top())));
-    const QPoint leftPos(mapToGlobal(QPoint(actionRect.left() - subMenuOffset - menuSize.width(), actionRect.top())));
 
     QPoint pos(rightPos);
-    QMenu *caused = qobject_cast<QMenu*>(d->activeMenu->d_func()->causedPopup.widget);
-
-    const QRect availGeometry(d->popupGeometry(caused));
-    if (isRightToLeft()) {
-        pos = leftPos;
-        if ((caused && caused->x() < x()) || pos.x() < availGeometry.left()) {
-            if(rightPos.x() + menuSize.width() < availGeometry.right())
-                pos = rightPos;
-            else
-                pos.rx() = availGeometry.left();
-        }
-    } else {
-        if ((caused && caused->x() > x()) || pos.x() + menuSize.width() > availGeometry.right()) {
-            if(leftPos.x() < availGeometry.left())
-                pos.rx() = availGeometry.right() - menuSize.width();
-            else
-                pos = leftPos;
-        }
-    }
 
     //calc sloppy focus buffer
     if (style()->styleHint(QStyle::SH_Menu_SloppySubMenus, 0, this)) {
diff --git a/src/gui/widgets/qmenu_p.h b/src/gui/widgets/qmenu_p.h
index b6efde3..005ce1d 100644
--- a/src/gui/widgets/qmenu_p.h
+++ b/src/gui/widgets/qmenu_p.h
@@ -194,10 +194,13 @@ public:
     mutable QVector<QRect> actionRects;
     mutable QHash<QAction *, QWidget *> widgetItems;
     void updateActionRects() const;
+    void updateActionRects(const QRect &screen) const;
     QRect popupGeometry(const QWidget *widget) const;
     QRect popupGeometry(int screen = -1) const;
     mutable uint ncols : 4; //4 bits is probably plenty
     uint collapsibleSeparators : 1;
+    QSize adjustMenuSizeForScreen(const QRect & screen);
+    int getLastVisibleAction() const;
 
     bool activationRecursionGuard;
 
@@ -296,7 +299,6 @@ public:
 
     void updateLayoutDirection();
 
-
     //menu fading/scrolling effects
     bool doChildEffects;
 
diff --git a/src/gui/widgets/qplaintextedit.cpp b/src/gui/widgets/qplaintextedit.cpp
index 7435691..51c4ccb 100644
--- a/src/gui/widgets/qplaintextedit.cpp
+++ b/src/gui/widgets/qplaintextedit.cpp
@@ -483,6 +483,7 @@ int QPlainTextEditPrivate::verticalOffset(int topBlock, int topLine) const
         QPlainTextDocumentLayout *documentLayout = qobject_cast<QPlainTextDocumentLayout*>(doc->documentLayout());
         Q_ASSERT(documentLayout);
         QRectF r = documentLayout->blockBoundingRect(currentBlock);
+        Q_UNUSED(r);
         QTextLayout *layout = currentBlock.layout();
         if (layout && topLine <= layout->lineCount()) {
             QTextLine line = layout->lineAt(topLine - 1);
@@ -648,6 +649,11 @@ void QPlainTextEditPrivate::setTopBlock(int blockNumber, int lineNumber, int dx)
         }
         control->topBlock = blockNumber;
         topLine = lineNumber;
+
+        bool vbarSignalsBlocked = vbar->blockSignals(true);
+        vbar->setValue(block.firstLineNumber() + lineNumber);
+        vbar->blockSignals(vbarSignalsBlocked);
+
         if (dx || dy)
             viewport->scroll(q->isRightToLeft() ? -dx : dx, dy);
         else
diff --git a/src/gui/widgets/qtextedit.cpp b/src/gui/widgets/qtextedit.cpp
index ff924bf..8df436f 100644
--- a/src/gui/widgets/qtextedit.cpp
+++ b/src/gui/widgets/qtextedit.cpp
@@ -2614,7 +2614,6 @@ Qt::TextFormat QTextEdit::textFormat() const
 void QTextEdit::append(const QString &text)
 {
     Q_D(QTextEdit);
-    QTextBlock lastBlock = d->control->document()->lastBlock();
     const bool atBottom = isReadOnly() ?  d->verticalOffset() >= d->vbar->maximum() :
             d->control->textCursor().atEnd();
     d->control->append(text);
diff --git a/src/gui/widgets/qworkspace.cpp b/src/gui/widgets/qworkspace.cpp
index bf50d07..13ef13b 100644
--- a/src/gui/widgets/qworkspace.cpp
+++ b/src/gui/widgets/qworkspace.cpp
@@ -1239,7 +1239,6 @@ QWidget * QWorkspace::addWindow(QWidget *w, Qt::WindowFlags flags)
     int x = w->x();
     int y = w->y();
     bool hasPos = w->testAttribute(Qt::WA_Moved);
-    QSize s = w->size().expandedTo(qSmartMinSize(w));
     if (!hasSize && w->sizeHint().isValid())
         w->adjustSize();
 
diff --git a/src/network/access/qhttpthreaddelegate.cpp b/src/network/access/qhttpthreaddelegate.cpp
index 99f9376..0364dac 100644
--- a/src/network/access/qhttpthreaddelegate.cpp
+++ b/src/network/access/qhttpthreaddelegate.cpp
@@ -51,6 +51,7 @@
 #include "private/qnetworkaccesscache_p.h"
 #include "private/qnoncontiguousbytedevice_p.h"
 
+#ifndef QT_NO_HTTP
 
 QT_BEGIN_NAMESPACE
 
@@ -576,4 +577,6 @@ void  QHttpThreadDelegate::synchronousProxyAuthenticationRequiredSlot(const QNet
 
 #endif
 
+#endif // QT_NO_HTTP
+
 QT_END_NAMESPACE
diff --git a/src/network/access/qhttpthreaddelegate_p.h b/src/network/access/qhttpthreaddelegate_p.h
index 752bc09..c0f2077 100644
--- a/src/network/access/qhttpthreaddelegate_p.h
+++ b/src/network/access/qhttpthreaddelegate_p.h
@@ -68,6 +68,8 @@
 #include "private/qnoncontiguousbytedevice_p.h"
 #include "qnetworkaccessauthenticationmanager_p.h"
 
+#ifndef QT_NO_HTTP
+
 QT_BEGIN_NAMESPACE
 
 class QAuthenticator;
@@ -285,4 +287,6 @@ signals:
 
 QT_END_NAMESPACE
 
+#endif // QT_NO_HTTP
+
 #endif // QHTTPTHREADDELEGATE_H
diff --git a/src/network/access/qnetworkaccesscachebackend.cpp b/src/network/access/qnetworkaccesscachebackend.cpp
index 13f4cd9..c585848 100644
--- a/src/network/access/qnetworkaccesscachebackend.cpp
+++ b/src/network/access/qnetworkaccesscachebackend.cpp
@@ -66,6 +66,7 @@ void QNetworkAccessCacheBackend::open()
         QString msg = QCoreApplication::translate("QNetworkAccessCacheBackend", "Error opening %1")
                                                 .arg(this->url().toString());
         error(QNetworkReply::ContentNotFoundError, msg);
+    } else {
         setAttribute(QNetworkRequest::SourceIsFromCacheAttribute, true);
     }
     finished();
@@ -85,14 +86,18 @@ bool QNetworkAccessCacheBackend::sendCacheContents()
     QNetworkCacheMetaData::AttributesMap attributes = item.attributes();
     setAttribute(QNetworkRequest::HttpStatusCodeAttribute, attributes.value(QNetworkRequest::HttpStatusCodeAttribute));
     setAttribute(QNetworkRequest::HttpReasonPhraseAttribute, attributes.value(QNetworkRequest::HttpReasonPhraseAttribute));
-    setAttribute(QNetworkRequest::SourceIsFromCacheAttribute, true);
 
     // set the raw headers
     QNetworkCacheMetaData::RawHeaderList rawHeaders = item.rawHeaders();
     QNetworkCacheMetaData::RawHeaderList::ConstIterator it = rawHeaders.constBegin(),
                                                        end = rawHeaders.constEnd();
-    for ( ; it != end; ++it)
+    for ( ; it != end; ++it) {
+        if (it->first.toLower() == "cache-control" &&
+            it->second.toLower().contains("must-revalidate")) {
+            return false;
+        }
         setRawHeader(it->first, it->second);
+    }
 
     // handle a possible redirect
     QVariant redirectionTarget = attributes.value(QNetworkRequest::RedirectionTargetAttribute);
diff --git a/src/network/access/qnetworkaccesshttpbackend.cpp b/src/network/access/qnetworkaccesshttpbackend.cpp
index c619114..a45c2de 100644
--- a/src/network/access/qnetworkaccesshttpbackend.cpp
+++ b/src/network/access/qnetworkaccesshttpbackend.cpp
@@ -262,13 +262,11 @@ bool QNetworkAccessHttpBackend::loadFromCacheIfAllowed(QHttpNetworkRequest &http
     if (lastModified.isValid())
         httpRequest.setHeaderField("If-Modified-Since", QNetworkHeadersPrivate::toHttpDate(lastModified));
 
-    if (CacheLoadControlAttribute == QNetworkRequest::PreferNetwork) {
-        it = cacheHeaders.findRawHeader("Cache-Control");
-        if (it != cacheHeaders.rawHeaders.constEnd()) {
-            QHash<QByteArray, QByteArray> cacheControl = parseHttpOptionHeader(it->second);
-            if (cacheControl.contains("must-revalidate"))
-                return false;
-        }
+    it = cacheHeaders.findRawHeader("Cache-Control");
+    if (it != cacheHeaders.rawHeaders.constEnd()) {
+        QHash<QByteArray, QByteArray> cacheControl = parseHttpOptionHeader(it->second);
+        if (cacheControl.contains("must-revalidate"))
+            return false;
     }
 
     QDateTime currentDateTime = QDateTime::currentDateTime();
diff --git a/src/network/access/qnetworkaccessmanager.cpp b/src/network/access/qnetworkaccessmanager.cpp
index 5a7521e..0d7b52a 100644
--- a/src/network/access/qnetworkaccessmanager.cpp
+++ b/src/network/access/qnetworkaccessmanager.cpp
@@ -861,7 +861,7 @@ QNetworkAccessManager::NetworkAccessibility QNetworkAccessManager::networkAccess
     device will be uploaded to the server; in that case, data must be open for
     reading and must remain valid until the finished() signal is emitted for this reply.
 
-    \note This feature is currently available for HTTP only.
+    \note This feature is currently available for HTTP(S) only.
 
     \sa get(), post(), put(), deleteResource()
 */
diff --git a/src/network/access/qnetworkcookie.cpp b/src/network/access/qnetworkcookie.cpp
index 52eb345..eec8507 100644
--- a/src/network/access/qnetworkcookie.cpp
+++ b/src/network/access/qnetworkcookie.cpp
@@ -395,8 +395,8 @@ static QPair<QByteArray, QByteArray> nextField(const QByteArray &text, int &posi
         // qdtext         = <any TEXT except <">>
         // quoted-pair    = "\" CHAR
 
-        // If its NAME=VALUE, retain the value as is
-        // refer to ttp://bugreports.qt.nokia.com/browse/QTBUG-17746
+        // If it is NAME=VALUE, retain the value as is
+        // refer to http://bugreports.qt.nokia.com/browse/QTBUG-17746
         if (isNameValue)
             second += '"';
         ++i;
@@ -432,7 +432,9 @@ static QPair<QByteArray, QByteArray> nextField(const QByteArray &text, int &posi
         position = i;
         for ( ; i < length; ++i) {
             register char c = text.at(i);
-            if (c == ',' || c == ';' || isLWS(c))
+            // for name value pairs, we want to parse until reaching the next ';'
+            // and not break when reaching a space char
+            if (c == ',' || c == ';' || ((isNameValue && (c == '\n' || c == '\r')) || (!isNameValue && isLWS(c))))
                 break;
         }
 
@@ -487,7 +489,6 @@ QByteArray QNetworkCookie::toRawForm(RawForm form) const
     result += '=';
     if ((d->value.contains(';') ||
         d->value.contains(',') ||
-        d->value.contains(' ') ||
         d->value.contains('"')) &&
         (!d->value.startsWith('"') &&
         !d->value.endsWith('"'))) {
diff --git a/src/network/bearer/qnetworkconfigmanager_p.cpp b/src/network/bearer/qnetworkconfigmanager_p.cpp
index c108ad3..e9b6703 100644
--- a/src/network/bearer/qnetworkconfigmanager_p.cpp
+++ b/src/network/bearer/qnetworkconfigmanager_p.cpp
@@ -60,7 +60,7 @@ Q_GLOBAL_STATIC_WITH_ARGS(QFactoryLoader, loader,
 #endif
 
 QNetworkConfigurationManagerPrivate::QNetworkConfigurationManagerPrivate()
-    : QObject(), mutex(QMutex::Recursive), forcedPolling(0), firstUpdate(true)
+    : QObject(), pollTimer(0), mutex(QMutex::Recursive), forcedPolling(0), firstUpdate(true)
 {
     qRegisterMetaType<QNetworkConfiguration>("QNetworkConfiguration");
     qRegisterMetaType<QNetworkConfigurationPrivatePointer>("QNetworkConfigurationPrivatePointer");
@@ -442,9 +442,19 @@ void QNetworkConfigurationManagerPrivate::startPolling()
 {
     QMutexLocker locker(&mutex);
 
+    if(!pollTimer) {
+        pollTimer = new QTimer(this);
+        pollTimer->setInterval(10000);
+        pollTimer->setSingleShot(true);
+        connect(pollTimer, SIGNAL(timeout()), this, SLOT(pollEngines()));
+    }
+
+    if(pollTimer->isActive())
+        return;
+
     foreach (QBearerEngine *engine, sessionEngines) {
         if (engine->requiresPolling() && (forcedPolling || engine->configurationsInUse())) {
-            QTimer::singleShot(10000, this, SLOT(pollEngines()));
+            pollTimer->start();
             break;
         }
     }
diff --git a/src/network/bearer/qnetworkconfigmanager_p.h b/src/network/bearer/qnetworkconfigmanager_p.h
index 81f38c5..abc4b9b 100644
--- a/src/network/bearer/qnetworkconfigmanager_p.h
+++ b/src/network/bearer/qnetworkconfigmanager_p.h
@@ -64,6 +64,7 @@
 QT_BEGIN_NAMESPACE
 
 class QBearerEngine;
+class QTimer;
 
 class Q_NETWORK_EXPORT QNetworkConfigurationManagerPrivate : public QObject
 {
@@ -107,6 +108,7 @@ private Q_SLOTS:
 
 private:
     void startPolling();
+    QTimer *pollTimer;
 
 private:
     mutable QMutex mutex;
diff --git a/src/network/socket/qabstractsocket.cpp b/src/network/socket/qabstractsocket.cpp
index 7af71cc..cfb1413 100644
--- a/src/network/socket/qabstractsocket.cpp
+++ b/src/network/socket/qabstractsocket.cpp
@@ -1877,7 +1877,7 @@ bool QAbstractSocket::waitForReadyRead(int msecs)
     }
 
     Q_ASSERT(d->socketEngine);
-    forever {
+    do {
         bool readyToRead = false;
         bool readyToWrite = false;
         if (!d->socketEngine->waitForReadOrWrite(&readyToRead, &readyToWrite, true, !d->writeBuffer.isEmpty(),
@@ -1904,7 +1904,7 @@ bool QAbstractSocket::waitForReadyRead(int msecs)
 
         if (state() != ConnectedState)
             return false;
-    }
+    } while (qt_timeout_value(msecs, stopWatch.elapsed()) > 0);
     return false;
 }
 
diff --git a/src/network/ssl/qsslconfiguration.cpp b/src/network/ssl/qsslconfiguration.cpp
index 70d7dd8..ab4d7f1 100644
--- a/src/network/ssl/qsslconfiguration.cpp
+++ b/src/network/ssl/qsslconfiguration.cpp
@@ -233,7 +233,7 @@ void QSslConfiguration::setProtocol(QSsl::SslProtocol protocol)
     client), and whether it should require that this certificate is valid.
 
     The default mode is AutoVerifyPeer, which tells QSslSocket to use
-    VerifyPeer for clients, QueryPeer for clients.
+    VerifyPeer for clients, QueryPeer for servers.
 
     \sa setPeerVerifyMode()
 */
@@ -249,7 +249,7 @@ QSslSocket::PeerVerifyMode QSslConfiguration::peerVerifyMode() const
     client), and whether it should require that this certificate is valid.
 
     The default mode is AutoVerifyPeer, which tells QSslSocket to use
-    VerifyPeer for clients, QueryPeer for clients.
+    VerifyPeer for clients, QueryPeer for servers.
 
     \sa peerVerifyMode()
 */
diff --git a/src/opengl/gl2paintengineex/qglengineshadermanager.cpp b/src/opengl/gl2paintengineex/qglengineshadermanager.cpp
index 8068aa8..207ab3d 100644
--- a/src/opengl/gl2paintengineex/qglengineshadermanager.cpp
+++ b/src/opengl/gl2paintengineex/qglengineshadermanager.cpp
@@ -495,6 +495,8 @@ GLuint QGLEngineShaderManager::getUniformLocation(Uniform id)
         "fmp",
         "fmp2_m_radius2",
         "inverse_2_fmp2_m_radius2",
+        "sqrfr",
+        "bradius",
         "invertedTextureSize",
         "brushTransform",
         "brushTexture",
diff --git a/src/opengl/gl2paintengineex/qglengineshadermanager_p.h b/src/opengl/gl2paintengineex/qglengineshadermanager_p.h
index 7cc9dc3..bf2fe42 100644
--- a/src/opengl/gl2paintengineex/qglengineshadermanager_p.h
+++ b/src/opengl/gl2paintengineex/qglengineshadermanager_p.h
@@ -442,6 +442,8 @@ public:
         Fmp,
         Fmp2MRadius2,
         Inverse2Fmp2MRadius2,
+        SqrFr,
+        BRadius,
         InvertedTextureSize,
         BrushTransform,
         BrushTexture,
diff --git a/src/opengl/gl2paintengineex/qglengineshadersource_p.h b/src/opengl/gl2paintengineex/qglengineshadersource_p.h
index fc8b9ef..9362c58 100644
--- a/src/opengl/gl2paintengineex/qglengineshadersource_p.h
+++ b/src/opengl/gl2paintengineex/qglengineshadersource_p.h
@@ -241,6 +241,7 @@ static const char* const qglslPositionWithRadialGradientBrushVertexShader = "\n\
     uniform   mediump vec2      halfViewportSize; \n\
     uniform   highp   mat3      brushTransform; \n\
     uniform   highp   vec2      fmp; \n\
+    uniform   highp   vec3      bradius; \n\
     varying   highp   float     b; \n\
     varying   highp   vec2      A; \n\
     void setPosition(void) \n\
@@ -253,7 +254,7 @@ static const char* const qglslPositionWithRadialGradientBrushVertexShader = "\n\
         mediump float invertedHTexCoordsZ = 1.0 / hTexCoords.z; \n\
         gl_Position = vec4(gl_Position.xy * invertedHTexCoordsZ, 0.0, invertedHTexCoordsZ); \n\
         A = hTexCoords.xy * invertedHTexCoordsZ; \n\
-        b = 2.0 * dot(A, fmp); \n\
+        b = bradius.x + 2.0 * dot(A, fmp); \n\
     }\n";
 
 static const char* const qglslAffinePositionWithRadialGradientBrushVertexShader
@@ -263,13 +264,22 @@ static const char* const qglslRadialGradientBrushSrcFragmentShader = "\n\
     uniform           sampler2D brushTexture; \n\
     uniform   highp   float     fmp2_m_radius2; \n\
     uniform   highp   float     inverse_2_fmp2_m_radius2; \n\
+    uniform   highp   float     sqrfr; \n\
     varying   highp   float     b; \n\
     varying   highp   vec2      A; \n\
+    uniform   highp   vec3      bradius; \n\
     lowp vec4 srcPixel() \n\
     { \n\
-        highp float c = -dot(A, A); \n\
-        highp vec2 val = vec2((-b + sqrt(b*b - 4.0*fmp2_m_radius2*c)) * inverse_2_fmp2_m_radius2, 0.5); \n\
-        return texture2D(brushTexture, val); \n\
+        highp float c = sqrfr-dot(A, A); \n\
+        highp float det = b*b - 4.0*fmp2_m_radius2*c; \n\
+        lowp vec4 result = vec4(0.0); \n\
+        if (det >= 0.0) { \n\
+            highp float detSqrt = sqrt(det); \n\
+            highp float w = max((-b - detSqrt) * inverse_2_fmp2_m_radius2, (-b + detSqrt) * inverse_2_fmp2_m_radius2); \n\
+            if (bradius.y + w * bradius.z >= 0.0) \n\
+                result = texture2D(brushTexture, vec2(w, 0.5)); \n\
+        } \n\
+        return result; \n\
     }\n";
 
 
diff --git a/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp b/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp
index 18c684f..38bd58d 100644
--- a/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp
+++ b/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp
@@ -301,7 +301,7 @@ void QGL2PaintEngineExPrivate::updateBrushUniforms()
             const QRadialGradient *g = static_cast<const QRadialGradient *>(currentBrush.gradient());
             QPointF realCenter = g->center();
             QPointF realFocal  = g->focalPoint();
-            qreal   realRadius = g->radius();
+            qreal   realRadius = g->centerRadius() - g->focalRadius();
             translationPoint   = realFocal;
 
             QPointF fmp = realCenter - realFocal;
@@ -311,6 +311,12 @@ void QGL2PaintEngineExPrivate::updateBrushUniforms()
             shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::Fmp2MRadius2), fmp2_m_radius2);
             shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::Inverse2Fmp2MRadius2),
                                                              GLfloat(1.0 / (2.0*fmp2_m_radius2)));
+            shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::SqrFr),
+                                                             GLfloat(g->focalRadius() * g->focalRadius()));
+            shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::BRadius),
+                                                             GLfloat(2 * (g->centerRadius() - g->focalRadius()) * g->focalRadius()),
+                                                             g->focalRadius(),
+                                                             g->centerRadius() - g->focalRadius());
 
             QVector2D halfViewportSize(width*0.5, height*0.5);
             shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::HalfViewportSize), halfViewportSize);
@@ -1548,6 +1554,14 @@ namespace {
 
 }
 
+#if defined(Q_WS_WIN)
+static bool fontSmoothingApproximately(qreal target)
+{
+    extern Q_GUI_EXPORT qreal qt_fontsmoothing_gamma; // qapplication_win.cpp
+    return (qAbs(qt_fontsmoothing_gamma - target) < 0.2);
+}
+#endif
+
 // #define QT_OPENGL_DRAWCACHEDGLYPHS_INDEX_ARRAY_VBO
 
 void QGL2PaintEngineExPrivate::drawCachedGlyphs(QFontEngineGlyphCache::Type glyphType,
@@ -1786,7 +1800,6 @@ void QGL2PaintEngineExPrivate::drawCachedGlyphs(QFontEngineGlyphCache::Type glyp
         shaderManager->setMaskType(QGLEngineShaderManager::PixelMask);
         prepareForDraw(false); // Text always causes src pixels to be transparent
     }
-    //### TODO: Gamma correction
 
     QGLTextureGlyphCache::FilterMode filterMode = (s->matrix.type() > QTransform::TxTranslate)?QGLTextureGlyphCache::Linear:QGLTextureGlyphCache::Nearest;
     if (lastMaskTextureUsed != cache->texture() || cache->filterMode() != filterMode) {
@@ -1809,12 +1822,31 @@ void QGL2PaintEngineExPrivate::drawCachedGlyphs(QFontEngineGlyphCache::Type glyp
         }
     }
 
+    bool srgbFrameBufferEnabled = false;
+    if (ctx->d_ptr->extension_flags & QGLExtensions::SRGBFrameBuffer) {
+#if defined(Q_WS_MAC)
+        if (glyphType == QFontEngineGlyphCache::Raster_RGBMask)
+#elif defined(Q_WS_WIN)
+        if (glyphType != QFontEngineGlyphCache::Raster_RGBMask || fontSmoothingApproximately(2.1))
+#else
+        if (false)
+#endif
+        {
+            glEnable(FRAMEBUFFER_SRGB_EXT);
+            srgbFrameBufferEnabled = true;
+        }
+    }
+
 #if defined(QT_OPENGL_DRAWCACHEDGLYPHS_INDEX_ARRAY_VBO)
     glDrawElements(GL_TRIANGLE_STRIP, 6 * numGlyphs, GL_UNSIGNED_SHORT, 0);
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
 #else
     glDrawElements(GL_TRIANGLE_STRIP, 6 * numGlyphs, GL_UNSIGNED_SHORT, elementIndices.data());
 #endif
+
+    if (srgbFrameBufferEnabled)
+        glDisable(FRAMEBUFFER_SRGB_EXT);
+
 }
 
 void QGL2PaintEngineEx::drawPixmapFragments(const QPainter::PixmapFragment *fragments, int fragmentCount, const QPixmap &pixmap,
@@ -1986,7 +2018,8 @@ bool QGL2PaintEngineEx::begin(QPaintDevice *pdev)
 
 #if !defined(QT_OPENGL_ES_2)
 #if defined(Q_WS_WIN)
-    if (qt_cleartype_enabled)
+    if (qt_cleartype_enabled
+        && (fontSmoothingApproximately(1.0) || fontSmoothingApproximately(2.1)))
 #endif
 #if defined(Q_WS_MAC)
     if (qt_applefontsmoothing_enabled)
diff --git a/src/opengl/qgl.cpp b/src/opengl/qgl.cpp
index 057fb55..099cc00 100644
--- a/src/opengl/qgl.cpp
+++ b/src/opengl/qgl.cpp
@@ -5490,6 +5490,13 @@ QGLExtensions::Extensions QGLExtensions::currentContextExtensions()
     if (extensions.match("GL_EXT_bgra"))
         glExtensions |= BGRATextureFormat;
 
+    {
+        GLboolean srgbCapableFramebuffers;
+        glGetBooleanv(FRAMEBUFFER_SRGB_CAPABLE_EXT, &srgbCapableFramebuffers);
+        if (srgbCapableFramebuffers)
+            glExtensions |= SRGBFrameBuffer;
+    }
+
     return glExtensions;
 }
 
diff --git a/src/opengl/qgl_p.h b/src/opengl/qgl_p.h
index 50d13c9..ac54e2f 100644
--- a/src/opengl/qgl_p.h
+++ b/src/opengl/qgl_p.h
@@ -288,7 +288,8 @@ public:
         PVRTCTextureCompression = 0x00020000,
         FragmentShader          = 0x00040000,
         ElementIndexUint        = 0x00080000,
-        Depth24                 = 0x00100000
+        Depth24                 = 0x00100000,
+        SRGBFrameBuffer         = 0x00200000
     };
     Q_DECLARE_FLAGS(Extensions, Extension)
 
diff --git a/src/opengl/qglextensions_p.h b/src/opengl/qglextensions_p.h
index 529c7a1..ac80ce8 100644
--- a/src/opengl/qglextensions_p.h
+++ b/src/opengl/qglextensions_p.h
@@ -477,6 +477,14 @@ struct QGLExtensionFuncs
 
 // OpenGL constants
 
+#ifndef FRAMEBUFFER_SRGB_CAPABLE_EXT
+#define FRAMEBUFFER_SRGB_CAPABLE_EXT 0x8DBA
+#endif
+
+#ifndef FRAMEBUFFER_SRGB_EXT
+#define FRAMEBUFFER_SRGB_EXT 0x8DB9
+#endif
+
 #ifndef GL_ARRAY_BUFFER
 #define GL_ARRAY_BUFFER                   0x8892
 #endif
diff --git a/src/opengl/qpaintengine_opengl.cpp b/src/opengl/qpaintengine_opengl.cpp
index 9da811a..5fa9f32 100644
--- a/src/opengl/qpaintengine_opengl.cpp
+++ b/src/opengl/qpaintengine_opengl.cpp
@@ -2119,6 +2119,7 @@ void QOpenGLPaintEnginePrivate::fillPath(const QPainterPath &path)
     updateGLMatrix();
 }
 
+extern bool qt_isExtendedRadialGradient(const QBrush &brush);
 
 static inline bool needsEmulation(Qt::BrushStyle style)
 {
@@ -2129,9 +2130,11 @@ static inline bool needsEmulation(Qt::BrushStyle style)
 
 void QOpenGLPaintEnginePrivate::updateUseEmulation()
 {
-    use_emulation = !use_fragment_programs
-                    && ((has_pen && needsEmulation(pen_brush_style))
-                        || (has_brush && needsEmulation(brush_style)));
+    use_emulation = (!use_fragment_programs
+                     && ((has_pen && needsEmulation(pen_brush_style))
+                         || (has_brush && needsEmulation(brush_style))))
+                    || (has_pen && qt_isExtendedRadialGradient(cpen.brush()))
+                    || (has_brush && qt_isExtendedRadialGradient(cbrush));
 }
 
 void QOpenGLPaintEngine::updatePen(const QPen &pen)
@@ -5447,50 +5450,7 @@ void QOpenGLPaintEngine::transformChanged()
     updateMatrix(state()->matrix);
 }
 
-static QPainterPath painterPathFromVectorPath(const QVectorPath &path)
-{
-    const qreal *points = path.points();
-    const QPainterPath::ElementType *types = path.elements();
-
-    QPainterPath p;
-    if (types) {
-        int id = 0;
-        for (int i=0; i<path.elementCount(); ++i) {
-            switch(types[i]) {
-            case QPainterPath::MoveToElement:
-                p.moveTo(QPointF(points[id], points[id+1]));
-                id+=2;
-                break;
-            case QPainterPath::LineToElement:
-                p.lineTo(QPointF(points[id], points[id+1]));
-                id+=2;
-                break;
-            case QPainterPath::CurveToElement: {
-                QPointF p1(points[id], points[id+1]);
-                QPointF p2(points[id+2], points[id+3]);
-                QPointF p3(points[id+4], points[id+5]);
-                p.cubicTo(p1, p2, p3);
-                id+=6;
-                break;
-            }
-            case QPainterPath::CurveToDataElement:
-                ;
-                break;
-            }
-        }
-    } else {
-        p.moveTo(QPointF(points[0], points[1]));
-        int id = 2;
-        for (int i=1; i<path.elementCount(); ++i) {
-            p.lineTo(QPointF(points[id], points[id+1]));
-            id+=2;
-        }
-    }
-    if (path.hints() & QVectorPath::WindingFill)
-        p.setFillRule(Qt::WindingFill);
-
-    return p;
-}
+extern QPainterPath qt_painterPathFromVectorPath(const QVectorPath &path);
 
 void QOpenGLPaintEngine::fill(const QVectorPath &path, const QBrush &brush)
 {
@@ -5499,11 +5459,11 @@ void QOpenGLPaintEngine::fill(const QVectorPath &path, const QBrush &brush)
     if (brush.style() == Qt::NoBrush)
         return;
 
-    if (!d->use_fragment_programs && needsEmulation(brush.style())) {
+    if ((!d->use_fragment_programs && needsEmulation(brush.style())) || qt_isExtendedRadialGradient(brush)) {
         QPainter *p = painter();
         QBrush oldBrush = p->brush();
         p->setBrush(brush);
-        qt_draw_helper(p->d_ptr.data(), painterPathFromVectorPath(path), QPainterPrivate::FillDraw);
+        qt_draw_helper(p->d_ptr.data(), qt_painterPathFromVectorPath(path), QPainterPrivate::FillDraw);
         p->setBrush(oldBrush);
         return;
     }
@@ -5520,7 +5480,7 @@ void QOpenGLPaintEngine::fill(const QVectorPath &path, const QBrush &brush)
         drawRects(&r, 1);
         updatePen(old_pen);
     } else {
-        d->fillPath(painterPathFromVectorPath(path));
+        d->fillPath(qt_painterPathFromVectorPath(path));
     }
 
     updateBrush(old_brush, state()->brushOrigin);
diff --git a/src/opengl/qwindowsurface_gl.cpp b/src/opengl/qwindowsurface_gl.cpp
index 56e2c3b..49b3dc2 100644
--- a/src/opengl/qwindowsurface_gl.cpp
+++ b/src/opengl/qwindowsurface_gl.cpp
@@ -184,7 +184,9 @@ QGLGraphicsSystem::QGLGraphicsSystem(bool useX11GL)
 class QGLGlobalShareWidget
 {
 public:
-    QGLGlobalShareWidget() : firstPixmap(0), widgetRefCount(0), widget(0), initializing(false) {}
+    QGLGlobalShareWidget() : firstPixmap(0), widgetRefCount(0), widget(0), initializing(false) {
+        created = true;
+    }
 
     QGLWidget *shareWidget() {
         if (!initializing && !widget && !cleanedUp) {
@@ -223,6 +225,7 @@ public:
     }
 
     static bool cleanedUp;
+    static bool created;
 
     QGLPixmapData *firstPixmap;
     int widgetRefCount;
@@ -233,6 +236,7 @@ private:
 };
 
 bool QGLGlobalShareWidget::cleanedUp = false;
+bool QGLGlobalShareWidget::created = false;
 
 static void qt_cleanup_gl_share_widget();
 Q_GLOBAL_STATIC_WITH_INITIALIZER(QGLGlobalShareWidget, _qt_gl_share_widget,
@@ -242,7 +246,8 @@ Q_GLOBAL_STATIC_WITH_INITIALIZER(QGLGlobalShareWidget, _qt_gl_share_widget,
 
 static void qt_cleanup_gl_share_widget()
 {
-    _qt_gl_share_widget()->cleanup();
+    if (QGLGlobalShareWidget::created)
+        _qt_gl_share_widget()->cleanup();
 }
 
 QGLWidget* qt_gl_share_widget()
@@ -254,7 +259,8 @@ QGLWidget* qt_gl_share_widget()
 
 void qt_destroy_gl_share_widget()
 {
-    _qt_gl_share_widget()->destroy();
+    if (QGLGlobalShareWidget::created)
+        _qt_gl_share_widget()->destroy();
 }
 
 const QGLContext *qt_gl_share_context()
@@ -610,6 +616,17 @@ void QGLWindowSurface::flush(QWidget *widget, const QRegion &rgn, const QPoint &
     if (!d_ptr->destructive_swap_buffers && !d_ptr->did_paint)
         return;
 
+#ifdef Q_OS_SYMBIAN
+    if (window() != widget) {
+        // For performance reasons we don't support
+        // flushing native child widgets on Symbian.
+        // It breaks overlapping native child widget
+        // rendering in some cases but we prefer performance.
+        return;
+    }
+#endif
+
+
     QWidget *parent = widget->internalWinId() ? widget : widget->nativeParentWidget();
     Q_ASSERT(parent);
 
diff --git a/src/openvg/qpaintengine_vg.cpp b/src/openvg/qpaintengine_vg.cpp
index 588c35a..68a6a0b 100644
--- a/src/openvg/qpaintengine_vg.cpp
+++ b/src/openvg/qpaintengine_vg.cpp
@@ -173,6 +173,9 @@ public:
     bool forcePenChange;    // Force a pen change, even if the same.
     bool forceBrushChange;  // Force a brush change, even if the same.
 
+    bool hasExtendedRadialGradientPen; // Current pen's brush is extended radial gradient.
+    bool hasExtendedRadialGradientBrush; // Current brush is extended radial gradient.
+
     VGPaintType penType;    // Type of the last pen that was set.
     VGPaintType brushType;  // Type of the last brush that was set.
 
@@ -275,6 +278,27 @@ public:
         }
     }
 
+    inline bool needsEmulation(const QBrush &brush) const
+    {
+        extern bool qt_isExtendedRadialGradient(const QBrush &brush);
+        return qt_isExtendedRadialGradient(brush);
+    }
+
+    inline bool needsEmulation() const
+    {
+        return hasExtendedRadialGradientPen || hasExtendedRadialGradientBrush;
+    }
+
+    inline bool needsPenEmulation() const
+    {
+        return hasExtendedRadialGradientPen;
+    }
+
+    inline bool needsBrushEmulation() const
+    {
+        return hasExtendedRadialGradientBrush;
+    }
+
     // Set various modes, but only if different.
     inline void setImageMode(VGImageMode mode);
     inline void setRenderingQuality(VGRenderingQuality mode);
@@ -355,6 +379,10 @@ void QVGPaintEnginePrivate::init()
 
     forcePenChange = true;
     forceBrushChange = true;
+
+    hasExtendedRadialGradientPen = false;
+    hasExtendedRadialGradientBrush = false;
+
     penType = (VGPaintType)0;
     brushType = (VGPaintType)0;
 
@@ -1530,12 +1558,18 @@ bool QVGPaintEngine::begin(QPaintDevice *pdev)
 
 bool QVGPaintEngine::end()
 {
+    vgSeti(VG_SCISSORING, VG_FALSE);
+    vgSeti(VG_MASKING, VG_FALSE);
     return true;
 }
 
 void QVGPaintEngine::draw(const QVectorPath &path)
 {
     Q_D(QVGPaintEngine);
+    if (d->needsEmulation()) {
+        QPaintEngineEx::draw(path);
+        return;
+    }
     QVGPainterState *s = state();
     VGPath vgpath = d->vectorPathToVGPath(path);
     if (!path.hasWindingFill())
@@ -1545,9 +1579,19 @@ void QVGPaintEngine::draw(const QVectorPath &path)
     vgDestroyPath(vgpath);
 }
 
+extern QPainterPath qt_painterPathFromVectorPath(const QVectorPath &path);
+
 void QVGPaintEngine::fill(const QVectorPath &path, const QBrush &brush)
 {
     Q_D(QVGPaintEngine);
+    if (d->needsEmulation(brush)) {
+        QPainter *p = painter();
+        QBrush oldBrush = p->brush();
+        p->setBrush(brush);
+        qt_draw_helper(p->d_ptr.data(), qt_painterPathFromVectorPath(path), QPainterPrivate::FillDraw);
+        p->setBrush(oldBrush);
+        return;
+    }
     VGPath vgpath = d->vectorPathToVGPath(path);
     if (!path.hasWindingFill())
         d->fill(vgpath, brush, VG_EVEN_ODD);
@@ -1559,6 +1603,10 @@ void QVGPaintEngine::fill(const QVectorPath &path, const QBrush &brush)
 void QVGPaintEngine::stroke(const QVectorPath &path, const QPen &pen)
 {
     Q_D(QVGPaintEngine);
+    if (d->needsEmulation(pen.brush())) {
+        QPaintEngineEx::stroke(path, pen);
+        return;
+    }
     VGPath vgpath = d->vectorPathToVGPath(path);
     d->stroke(vgpath, pen);
     vgDestroyPath(vgpath);
@@ -2362,12 +2410,17 @@ void QVGPaintEngine::penChanged()
 {
     Q_D(QVGPaintEngine);
     d->dirty |= QPaintEngine::DirtyPen;
+
+    d->hasExtendedRadialGradientPen =
+        state()->pen.style() != Qt::NoPen && d->needsEmulation(state()->pen.brush());
 }
 
 void QVGPaintEngine::brushChanged()
 {
     Q_D(QVGPaintEngine);
     d->dirty |= QPaintEngine::DirtyBrush;
+
+    d->hasExtendedRadialGradientPen = d->needsEmulation(state()->brush);
 }
 
 void QVGPaintEngine::brushOriginChanged()
@@ -2546,6 +2599,11 @@ void QVGPaintEngine::fillRect(const QRectF &rect, const QBrush &brush)
         return;
     }
 
+    if (d->needsEmulation(brush)) {
+        QPaintEngineEx::fillRect(rect, brush);
+        return;
+    }
+
 #if !defined(QVG_NO_MODIFY_PATH)
     VGfloat coords[8];
     if (d->simpleTransform) {
@@ -2623,6 +2681,10 @@ void QVGPaintEngine::fillRect(const QRectF &rect, const QColor &color)
 void QVGPaintEngine::drawRoundedRect(const QRectF &rect, qreal xrad, qreal yrad, Qt::SizeMode mode)
 {
     Q_D(QVGPaintEngine);
+    if (d->needsEmulation()) {
+        QPaintEngineEx::drawRoundedRect(rect, xrad, yrad, mode);
+        return;
+    }
     if (d->simpleTransform) {
         QVGPainterState *s = state();
         VGPath vgpath = d->roundedRectPath(rect, xrad, yrad, mode);
@@ -2639,6 +2701,10 @@ void QVGPaintEngine::drawRects(const QRect *rects, int rectCount)
 {
 #if !defined(QVG_NO_MODIFY_PATH)
     Q_D(QVGPaintEngine);
+    if (d->needsEmulation()) {
+        QPaintEngineEx::drawRects(rects, rectCount);
+        return;
+    }
     QVGPainterState *s = state();
     for (int i = 0; i < rectCount; ++i, ++rects) {
         VGfloat coords[8];
@@ -2680,6 +2746,10 @@ void QVGPaintEngine::drawRects(const QRectF *rects, int rectCount)
 {
 #if !defined(QVG_NO_MODIFY_PATH)
     Q_D(QVGPaintEngine);
+    if (d->needsEmulation()) {
+        QPaintEngineEx::drawRects(rects, rectCount);
+        return;
+    }
     QVGPainterState *s = state();
     for (int i = 0; i < rectCount; ++i, ++rects) {
         VGfloat coords[8];
@@ -2718,6 +2788,10 @@ void QVGPaintEngine::drawLines(const QLine *lines, int lineCount)
 {
 #if !defined(QVG_NO_MODIFY_PATH)
     Q_D(QVGPaintEngine);
+    if (d->needsEmulation()) {
+        QPaintEngineEx::drawLines(lines, lineCount);
+        return;
+    }
     QVGPainterState *s = state();
     for (int i = 0; i < lineCount; ++i, ++lines) {
         VGfloat coords[4];
@@ -2746,6 +2820,10 @@ void QVGPaintEngine::drawLines(const QLineF *lines, int lineCount)
 {
 #if !defined(QVG_NO_MODIFY_PATH)
     Q_D(QVGPaintEngine);
+    if (d->needsEmulation()) {
+        QPaintEngineEx::drawLines(lines, lineCount);
+        return;
+    }
     QVGPainterState *s = state();
     for (int i = 0; i < lineCount; ++i, ++lines) {
         VGfloat coords[4];
@@ -2775,6 +2853,10 @@ void QVGPaintEngine::drawEllipse(const QRectF &r)
     // Based on the description of vguEllipse() in the OpenVG specification.
     // We don't use vguEllipse(), to avoid unnecessary library dependencies.
     Q_D(QVGPaintEngine);
+    if (d->needsEmulation()) {
+        QPaintEngineEx::drawEllipse(r);
+        return;
+    }
     if (d->simpleTransform) {
         QVGPainterState *s = state();
         VGPath path = vgCreatePath(VG_PATH_FORMAT_STANDARD,
@@ -2825,6 +2907,10 @@ void QVGPaintEngine::drawPath(const QPainterPath &path)
     // Shortcut past the QPainterPath -> QVectorPath conversion,
     // converting the QPainterPath directly into a VGPath.
     Q_D(QVGPaintEngine);
+    if (d->needsEmulation()) {
+        QPaintEngineEx::drawPath(path);
+        return;
+    }
     QVGPainterState *s = state();
     VGPath vgpath = d->painterPathToVGPath(path);
     if (path.fillRule() == Qt::OddEvenFill)
@@ -2839,6 +2925,11 @@ void QVGPaintEngine::drawPoints(const QPointF *points, int pointCount)
 #if !defined(QVG_NO_MODIFY_PATH)
     Q_D(QVGPaintEngine);
 
+    if (d->needsPenEmulation()) {
+        QPaintEngineEx::drawPoints(points, pointCount);
+        return;
+    }
+
     // Set up a new pen if necessary.
     QPen pen = state()->pen;
     if (pen.style() == Qt::NoPen)
@@ -2873,6 +2964,11 @@ void QVGPaintEngine::drawPoints(const QPoint *points, int pointCount)
 #if !defined(QVG_NO_MODIFY_PATH)
     Q_D(QVGPaintEngine);
 
+    if (d->needsEmulation()) {
+        QPaintEngineEx::drawPoints(points, pointCount);
+        return;
+    }
+
     // Set up a new pen if necessary.
     QPen pen = state()->pen;
     if (pen.style() == Qt::NoPen)
@@ -2905,6 +3001,12 @@ void QVGPaintEngine::drawPoints(const QPoint *points, int pointCount)
 void QVGPaintEngine::drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode)
 {
     Q_D(QVGPaintEngine);
+
+    if (d->needsEmulation()) {
+        QPaintEngineEx::drawPolygon(points, pointCount, mode);
+        return;
+    }
+
     QVGPainterState *s = state();
     VGPath path = vgCreatePath(VG_PATH_FORMAT_STANDARD,
                                VG_PATH_DATATYPE_F,
@@ -2952,6 +3054,12 @@ void QVGPaintEngine::drawPolygon(const QPointF *points, int pointCount, PolygonD
 void QVGPaintEngine::drawPolygon(const QPoint *points, int pointCount, PolygonDrawMode mode)
 {
     Q_D(QVGPaintEngine);
+
+    if (d->needsEmulation()) {
+        QPaintEngineEx::drawPolygon(points, pointCount, mode);
+        return;
+    }
+
     QVGPainterState *s = state();
     VGPath path = vgCreatePath(VG_PATH_FORMAT_STANDARD,
                                VG_PATH_DATATYPE_F,
@@ -3611,6 +3719,11 @@ void QVGPaintEngine::drawTextItem(const QPointF &p, const QTextItem &textItem)
         return;
     }
 
+    if (d->needsPenEmulation()) {
+        QPaintEngineEx::drawTextItem(p, textItem);
+        return;
+    }
+
     // Get the glyphs and positions associated with the text item.
     QVarLengthArray<QFixedPoint> positions;
     QVarLengthArray<glyph_t> glyphs;
@@ -3756,6 +3869,8 @@ void QVGPaintEngine::beginNativePainting()
 #if !defined(QVG_NO_DRAW_GLYPHS)
     d->setTransform(VG_MATRIX_GLYPH_USER_TO_SURFACE, d->pathTransform);
 #endif
+    vgSeti(VG_SCISSORING, VG_FALSE);
+    vgSeti(VG_MASKING, VG_FALSE);
     d->rawVG = true;
 }
 
@@ -3816,6 +3931,7 @@ void QVGPaintEngine::restoreState(QPaintEngine::DirtyFlags dirty)
     if ((dirty & QPaintEngine::DirtyBrushOrigin) != 0)
         brushOriginChanged();
     d->fillRule = 0;
+    d->clearColor = QColor();
     if ((dirty & QPaintEngine::DirtyOpacity) != 0)
         opacityChanged();
     if ((dirty & QPaintEngine::DirtyTransform) != 0)
diff --git a/src/openvg/qpixmapdata_vg.cpp b/src/openvg/qpixmapdata_vg.cpp
index ea93748..e52722d 100644
--- a/src/openvg/qpixmapdata_vg.cpp
+++ b/src/openvg/qpixmapdata_vg.cpp
@@ -378,7 +378,7 @@ VGImage QVGPixmapData::toVGImage()
         QVGImagePool::instance()->useImage(this);
     }
 
-    if (!source.isNull() && recreate) {
+    if (!source.isNull() && (recreate || source.paintingActive())) {
         source.beginDataAccess();
         vgImageSubData
             (vgImage,
diff --git a/src/openvg/qwindowsurface_vg.cpp b/src/openvg/qwindowsurface_vg.cpp
index eedfea5..dcc5d6a 100644
--- a/src/openvg/qwindowsurface_vg.cpp
+++ b/src/openvg/qwindowsurface_vg.cpp
@@ -78,6 +78,17 @@ QPaintDevice *QVGWindowSurface::paintDevice()
 void QVGWindowSurface::flush(QWidget *widget, const QRegion &region, const QPoint &offset)
 {
     Q_UNUSED(offset);
+
+#ifdef Q_OS_SYMBIAN
+    if (window() != widget) {
+        // For performance reasons we don't support
+        // flushing native child widgets on Symbian.
+        // It breaks overlapping native child widget
+        // rendering in some cases but we prefer performance.
+        return;
+    }
+#endif
+
     QWidget *parent = widget->internalWinId() ? widget : widget->nativeParentWidget();
     d_ptr->endPaint(parent, region);
 }
diff --git a/src/plugins/accessible/widgets/complexwidgets.cpp b/src/plugins/accessible/widgets/complexwidgets.cpp
index e638413..85be0b0 100644
--- a/src/plugins/accessible/widgets/complexwidgets.cpp
+++ b/src/plugins/accessible/widgets/complexwidgets.cpp
@@ -971,7 +971,11 @@ QString QAccessibleItemView::text(Text t, int child) const
             return QAccessibleAbstractScrollArea::text(t, child);
 
         QAccessibleItemRow item(itemView(), childIndex(child));
-        return item.text(t, 1);
+        if (item.isValid()) {
+            return item.text(t, 1);
+        } else {
+            return QString();
+        }
     } else {
         return QAccessibleAbstractScrollArea::text(t, child);
     }
diff --git a/src/plugins/accessible/widgets/qaccessiblewidgets.cpp b/src/plugins/accessible/widgets/qaccessiblewidgets.cpp
index 09b5015..4402932 100644
--- a/src/plugins/accessible/widgets/qaccessiblewidgets.cpp
+++ b/src/plugins/accessible/widgets/qaccessiblewidgets.cpp
@@ -401,9 +401,14 @@ int QAccessibleStackedWidget::childCount() const
 
 int QAccessibleStackedWidget::indexOfChild(const QAccessibleInterface *child) const
 {
-    if (!child || (stackedWidget()->currentWidget() != child->object()))
+    if (!child)
         return -1;
-    return 1;
+
+    QWidget* widget = qobject_cast<QWidget*>(child->object());
+    int index = stackedWidget()->indexOf(widget);
+    if (index >= 0) // one based counting of children
+        return index + 1;
+    return -1;
 }
 
 int QAccessibleStackedWidget::navigate(RelationFlag relation, int entry, QAccessibleInterface **target) const
@@ -413,9 +418,9 @@ int QAccessibleStackedWidget::navigate(RelationFlag relation, int entry, QAccess
     QObject *targetObject = 0;
     switch (relation) {
     case Child:
-        if (entry != 1)
+        if (entry < 1 || entry > stackedWidget()->count())
             return -1;
-        targetObject = stackedWidget()->currentWidget();
+        targetObject = stackedWidget()->widget(entry-1);
         break;
     default:
         return QAccessibleWidgetEx::navigate(relation, entry, target);
@@ -1334,7 +1339,7 @@ QRect QAccessibleTextEdit::characterRect(int offset, CoordinateType coordType)
 
     QRect r = edit->cursorRect(cursor);
     if (cursor.movePosition(QTextCursor::NextCharacter)) {
-        r.setWidth(edit->cursorRect(cursor).y() - r.y());
+        r.setWidth(edit->cursorRect(cursor).x() - r.x());
     } else {
         // we don't know the width of the character - maybe because we're at document end
         // in that case, IAccessible2 tells us to return the width of a default character
@@ -1603,7 +1608,7 @@ void QAccessibleTextEdit::setAttributes(int startOffset, int endOffset, const QS
 
 #ifndef QT_NO_MAINWINDOW
 QAccessibleMainWindow::QAccessibleMainWindow(QWidget *widget)
-    : QAccessibleWidgetEx(widget, Application) { }
+    : QAccessibleWidgetEx(widget, Window) { }
 
 QVariant QAccessibleMainWindow::invokeMethodEx(QAccessible::Method /*method*/, int /*child*/, const QVariantList & /*params*/)
 {
diff --git a/src/plugins/accessible/widgets/simplewidgets.cpp b/src/plugins/accessible/widgets/simplewidgets.cpp
index 21d2d67..aa64630 100644
--- a/src/plugins/accessible/widgets/simplewidgets.cpp
+++ b/src/plugins/accessible/widgets/simplewidgets.cpp
@@ -131,7 +131,7 @@ QString QAccessibleButton::actionText(int action, Text text, int child) const
 /*! \reimp */
 bool QAccessibleButton::doAction(int action, int child, const QVariantList &params)
 {
-    if (child || !widget()->isEnabled() || !widget()->isVisible())
+    if (child || !widget()->isEnabled())
         return false;
 
     switch (action) {
@@ -155,9 +155,6 @@ bool QAccessibleButton::doAction(int action, int child, const QVariantList &para
 QString QAccessibleButton::text(Text t, int child) const
 {
     QString str;
-    if (!widget()->isVisible())
-        return str;
-
     switch (t) {
     case Accelerator:
         {
@@ -227,6 +224,9 @@ QString QAccessibleButton::description(int actionIndex)
 {
     switch (actionIndex) {
     case 0:
+        if (button()->isCheckable()) {
+            return QLatin1String("Toggles the button.");
+        }
         return QLatin1String("Clicks the button.");
     default:
         return QString();
@@ -237,6 +237,13 @@ QString QAccessibleButton::name(int actionIndex)
 {
     switch (actionIndex) {
     case 0:
+        if (button()->isCheckable()) {
+            if (button()->isChecked()) {
+                return QLatin1String("Uncheck");
+            } else {
+                return QLatin1String("Check");
+            }
+        }
         return QLatin1String("Press");
     default:
         return QString();
@@ -247,6 +254,13 @@ QString QAccessibleButton::localizedName(int actionIndex)
 {
     switch (actionIndex) {
     case 0:
+        if (button()->isCheckable()) {
+            if (button()->isChecked()) {
+                return tr("Uncheck");
+            } else {
+                return tr("Check");
+            }
+        }
         return tr("Press");
     default:
         return QString();
@@ -380,9 +394,6 @@ QRect QAccessibleToolButton::rect(int child) const
 QString QAccessibleToolButton::text(Text t, int child) const
 {
     QString str;
-    if (!toolButton()->isVisible())
-        return str;
-
     switch (t) {
     case Name:
         str = toolButton()->text();
@@ -454,7 +465,7 @@ QString QAccessibleToolButton::actionText(int action, Text text, int child) cons
 */
 bool QAccessibleToolButton::doAction(int action, int child, const QVariantList &params)
 {
-    if (!widget()->isEnabled() || !widget()->isVisible())
+    if (!widget()->isEnabled())
         return false;
     if (action == 1 || child == ButtonDropMenu) {
         if(!child)
@@ -513,8 +524,6 @@ QAccessible::Role QAccessibleDisplay::role(int child) const
 QString QAccessibleDisplay::text(Text t, int child) const
 {
     QString str;
-    if (!widget()->isVisible())
-        return str;
     switch (t) {
     case Name:
         str = widget()->accessibleName();
@@ -674,8 +683,6 @@ QLineEdit *QAccessibleLineEdit::lineEdit() const
 QString QAccessibleLineEdit::text(Text t, int child) const
 {
     QString str;
-    if (!lineEdit()->isVisible())
-        return str;
     switch (t) {
     case Value:
         if (lineEdit()->echoMode() == QLineEdit::Normal)
@@ -692,8 +699,6 @@ QString QAccessibleLineEdit::text(Text t, int child) const
 /*! \reimp */
 void QAccessibleLineEdit::setText(Text t, int control, const QString &text)
 {
-    if (!lineEdit()->isVisible())
-        return;
     if (t != Value || control) {
         QAccessibleWidgetEx::setText(t, control, text);
         return;
diff --git a/src/plugins/platforms/uikit/quikiteventloop.mm b/src/plugins/platforms/uikit/quikiteventloop.mm
index 8d2603c..2b9728c 100644
--- a/src/plugins/platforms/uikit/quikiteventloop.mm
+++ b/src/plugins/platforms/uikit/quikiteventloop.mm
@@ -69,13 +69,8 @@
 - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
 {
     Q_UNUSED(launchOptions)
+    Q_UNUSED(application)
     foreach (QWidget *widget, qApp->topLevelWidgets()) {
-        QRect geom = widget->geometry();
-        CGRect bar = application.statusBarFrame;
-        if (geom.y() <= bar.size.height) {
-            geom.setY(bar.size.height);
-            widget->setGeometry(geom);
-        }
         QUIKitWindow *platformWindow = static_cast<QUIKitWindow *>(widget->platformWindow());
         platformWindow->ensureNativeWindow();
     }
diff --git a/src/plugins/platforms/uikit/quikitintegration.mm b/src/plugins/platforms/uikit/quikitintegration.mm
index d4b4192..3a432d1 100644
--- a/src/plugins/platforms/uikit/quikitintegration.mm
+++ b/src/plugins/platforms/uikit/quikitintegration.mm
@@ -66,7 +66,7 @@ QUIKitIntegration::~QUIKitIntegration()
 
 QPixmapData *QUIKitIntegration::createPixmapData(QPixmapData::PixelType type) const
 {
-        return new QRasterPixmapData(type);
+    return new QRasterPixmapData(type);
 }
 
 QPlatformWindow *QUIKitIntegration::createPlatformWindow(QWidget *widget, WId winId) const
diff --git a/src/plugins/platforms/uikit/quikitscreen.mm b/src/plugins/platforms/uikit/quikitscreen.mm
index 21494c9..78389f2 100644
--- a/src/plugins/platforms/uikit/quikitscreen.mm
+++ b/src/plugins/platforms/uikit/quikitscreen.mm
@@ -54,7 +54,7 @@ QUIKitScreen::QUIKitScreen(int screenIndex)
     NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
     UIScreen *screen = [[UIScreen screens] objectAtIndex:screenIndex];
     CGRect bounds = [screen bounds];
-    m_geometry = QRect(0, 0, bounds.size.width, bounds.size.height);
+    m_geometry = QRect(bounds.origin.x, bounds.origin.y, bounds.size.width, bounds.size.height);
 
     m_format = QImage::Format_ARGB32;
 
@@ -62,7 +62,7 @@ QUIKitScreen::QUIKitScreen(int screenIndex)
 
     const qreal inch = 25.4;
     qreal dpi = 160.;
-    int dragDistance = 14;
+    int dragDistance = 12;
     if ([[UIDevice currentDevice] userInterfaceIdiom] == UIUserInterfaceIdiomPad) {
         dpi = 132.;
         dragDistance = 10;
diff --git a/src/plugins/platforms/uikit/quikitwindow.h b/src/plugins/platforms/uikit/quikitwindow.h
index 9e73754..5c6496a 100644
--- a/src/plugins/platforms/uikit/quikitwindow.h
+++ b/src/plugins/platforms/uikit/quikitwindow.h
@@ -47,6 +47,8 @@
 #import <UIKit/UIKit.h>
 #import <OpenGLES/ES1/gl.h>
 #import <OpenGLES/ES1/glext.h>
+#import <OpenGLES/ES2/gl.h>
+#import <OpenGLES/ES2/glext.h>
 #import <OpenGLES/EAGL.h>
 
 @interface EAGLView : UIView <UIKeyInput>
@@ -59,6 +61,7 @@
 
     GLuint mFramebuffer, mColorRenderbuffer, mDepthRenderbuffer;
 
+    id delegate;
     // ------- Text Input ----------
     UITextAutocapitalizationType autocapitalizationType;
     UITextAutocorrectionType autocorrectionType;
@@ -77,6 +80,8 @@
 - (void)setWindow:(QPlatformWindow *)window;
 - (void)sendMouseEventForTouches:(NSSet *)touches withEvent:(UIEvent *)event fakeButtons:(Qt::MouseButtons)buttons;
 
+@property (readonly,getter=fbo) GLint fbo;
+@property (nonatomic, assign) id delegate;
 
 // ------- Text Input ----------
 
@@ -90,6 +95,10 @@
 
 @end
 
+@protocol EAGLViewDelegate
+- (void)eaglView:(EAGLView *)view usesFramebuffer:(GLuint)buffer;
+@end
+
 class EAGLPlatformContext;
 
 QT_BEGIN_NAMESPACE
@@ -103,7 +112,7 @@ public:
     ~QUIKitWindow();
 
     UIWindow *nativeWindow() const { return mWindow; }
-    UIView *nativeView() const { return mView; }
+    EAGLView *nativeView() const { return mView; }
     void setGeometry(const QRect &rect);
 
     UIWindow *ensureNativeWindow();
diff --git a/src/plugins/platforms/uikit/quikitwindow.mm b/src/plugins/platforms/uikit/quikitwindow.mm
index 52d1846..1f57baa 100644
--- a/src/plugins/platforms/uikit/quikitwindow.mm
+++ b/src/plugins/platforms/uikit/quikitwindow.mm
@@ -79,7 +79,11 @@ public:
         mFormat.setStereo(false);
         mFormat.setDirectRendering(false);
 
+#if defined(QT_OPENGL_ES_2)
+        EAGLContext *aContext = [[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES2];
+#else
         EAGLContext *aContext = [[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES1];
+#endif
         [mView setContext:aContext];
     }
 
@@ -116,6 +120,8 @@ private:
 
 @implementation EAGLView
 
+@synthesize delegate;
+
 + (Class)layerClass
 {
     return [CAEAGLLayer class];
@@ -156,8 +162,8 @@ private:
 {
     if (mContext) {
         [EAGLContext setCurrentContext:mContext];
-        glBindRenderbufferOES(GL_RENDERBUFFER_OES, mColorRenderbuffer);
-        [mContext presentRenderbuffer:GL_RENDERBUFFER_OES];
+        glBindRenderbuffer(GL_RENDERBUFFER, mColorRenderbuffer);
+        [mContext presentRenderbuffer:GL_RENDERBUFFER];
     }
 }
 
@@ -167,15 +173,15 @@ private:
     {
         [EAGLContext setCurrentContext:mContext];
         if (mFramebuffer) {
-            glDeleteFramebuffersOES(1, &mFramebuffer);
+            glDeleteFramebuffers(1, &mFramebuffer);
             mFramebuffer = 0;
         }
         if (mColorRenderbuffer) {
-            glDeleteRenderbuffersOES(1, &mColorRenderbuffer);
+            glDeleteRenderbuffers(1, &mColorRenderbuffer);
             mColorRenderbuffer = 0;
         }
         if (mDepthRenderbuffer) {
-            glDeleteRenderbuffersOES(1, &mDepthRenderbuffer);
+            glDeleteRenderbuffers(1, &mDepthRenderbuffer);
             mDepthRenderbuffer = 0;
         }
     }
@@ -186,24 +192,27 @@ private:
     if (mContext && !mFramebuffer)
     {
         [EAGLContext setCurrentContext:mContext];
-        glGenFramebuffersOES(1, &mFramebuffer);
-        glBindFramebufferOES(GL_FRAMEBUFFER_OES, mFramebuffer);
-
-        glGenRenderbuffersOES(1, &mColorRenderbuffer);
-        glBindRenderbufferOES(GL_RENDERBUFFER_OES, mColorRenderbuffer);
-        [mContext renderbufferStorage:GL_RENDERBUFFER_OES fromDrawable:(CAEAGLLayer *)self.layer];
-        glGetRenderbufferParameterivOES(GL_RENDERBUFFER_OES, GL_RENDERBUFFER_WIDTH_OES, &mFramebufferWidth);
-        glGetRenderbufferParameterivOES(GL_RENDERBUFFER_OES, GL_RENDERBUFFER_HEIGHT_OES, &mFramebufferHeight);
-        glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_COLOR_ATTACHMENT0_OES, GL_RENDERBUFFER_OES, mColorRenderbuffer);
-
-        glGenRenderbuffersOES(1, &mDepthRenderbuffer);
-        glBindRenderbufferOES(GL_RENDERBUFFER_OES, mDepthRenderbuffer);
-        glRenderbufferStorageOES(GL_RENDERBUFFER_OES, GL_DEPTH24_STENCIL8_OES, mFramebufferWidth, mFramebufferHeight);
-        glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_DEPTH_ATTACHMENT_OES, GL_RENDERBUFFER_OES, mDepthRenderbuffer);
-        glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_STENCIL_ATTACHMENT_OES, GL_RENDERBUFFER_OES, mDepthRenderbuffer);
-
-        if (glCheckFramebufferStatusOES(GL_FRAMEBUFFER_OES) != GL_FRAMEBUFFER_COMPLETE_OES)
-            NSLog(@"Failed to make complete framebuffer object %x", glCheckFramebufferStatusOES(GL_FRAMEBUFFER_OES));
+        glGenFramebuffers(1, &mFramebuffer);
+        glBindFramebuffer(GL_FRAMEBUFFER, mFramebuffer);
+
+        glGenRenderbuffers(1, &mColorRenderbuffer);
+        glBindRenderbuffer(GL_RENDERBUFFER, mColorRenderbuffer);
+        [mContext renderbufferStorage:GL_RENDERBUFFER fromDrawable:(CAEAGLLayer *)self.layer];
+        glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_WIDTH, &mFramebufferWidth);
+        glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_HEIGHT, &mFramebufferHeight);
+        glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, mColorRenderbuffer);
+
+        glGenRenderbuffers(1, &mDepthRenderbuffer);
+        glBindRenderbuffer(GL_RENDERBUFFER, mDepthRenderbuffer);
+        glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8_OES, mFramebufferWidth, mFramebufferHeight);
+        glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, mDepthRenderbuffer);
+        glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, mDepthRenderbuffer);
+
+        if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
+            NSLog(@"Failed to make complete framebuffer object %x", glCheckFramebufferStatus(GL_FRAMEBUFFER));
+        if (delegate && [delegate respondsToSelector:@selector(eaglView:usesFramebuffer:)]) {
+            [delegate eaglView:self usesFramebuffer:mFramebuffer];
+        }
     }
 }
 
@@ -214,11 +223,16 @@ private:
         [EAGLContext setCurrentContext:mContext];
         if (!mFramebuffer)
             [self createFramebuffer];
-        glBindFramebufferOES(GL_FRAMEBUFFER_OES, mFramebuffer);
+        glBindFramebuffer(GL_FRAMEBUFFER, mFramebuffer);
         glViewport(0, 0, mFramebufferWidth, mFramebufferHeight);
     }
 }
 
+- (GLint)fbo
+{
+    return mFramebuffer;
+}
+
 - (void)setWindow:(QPlatformWindow *)window
 {
     mWindow = window;
@@ -322,6 +336,7 @@ QUIKitWindow::QUIKitWindow(QWidget *tlw) :
     CGRect screenBounds = [mScreen->uiScreen() bounds];
     QRect geom(screenBounds.origin.x, screenBounds.origin.y, screenBounds.size.width, screenBounds.size.height);
     setGeometry(geom);
+    mView = [[EAGLView alloc] initWithFrame:CGRectMake(0, 0, 0, 0)];
     // TODO ensure the native window if the application is already running
 }
 
@@ -334,7 +349,7 @@ QUIKitWindow::~QUIKitWindow()
 
 void QUIKitWindow::setGeometry(const QRect &rect)
 {
-    if (mWindow) {
+    if (mWindow && rect != geometry()) {
         mWindow.frame = CGRectMake(rect.x(), rect.y(), rect.width(), rect.height());
         mView.frame = CGRectMake(0, 0, rect.width(), rect.height());
         [mView deleteFramebuffer];
@@ -347,14 +362,16 @@ UIWindow *QUIKitWindow::ensureNativeWindow()
 {
     if (!mWindow) {
         // window
-        QRect geom = geometry();
-        CGRect frame = CGRectMake(geom.x(), geom.y(), geom.width(), geom.height());
-        mWindow = [[UIWindow alloc] initWithFrame:frame];
+        CGRect frame = [mScreen->uiScreen() applicationFrame];
+        QRect geom = QRect(frame.origin.x, frame.origin.y, frame.size.width, frame.size.height);
+        widget()->setGeometry(geom);
+        mWindow = [[UIWindow alloc] init];
         mWindow.screen = mScreen->uiScreen();
-        mWindow.frame = frame; // for some reason setting the screen resets frame.origin
+        mWindow.frame = frame; // for some reason setting the screen resets frame.origin, so we need to set the frame afterwards
 
         // view
-        mView = [[EAGLView alloc] initWithFrame:CGRectMake(0, 0, geom.width(), geom.height())];
+        [mView deleteFramebuffer];
+        mView.frame = CGRectMake(0, 0, frame.size.width, frame.size.height); // fill
         [mView setMultipleTouchEnabled:YES];
         [mView setWindow:this];
         [mWindow addSubview:mView];
diff --git a/src/plugins/platforms/uikit/quikitwindowsurface.mm b/src/plugins/platforms/uikit/quikitwindowsurface.mm
index bb7dcd7..8caa15f 100644
--- a/src/plugins/platforms/uikit/quikitwindowsurface.mm
+++ b/src/plugins/platforms/uikit/quikitwindowsurface.mm
@@ -47,27 +47,64 @@
 
 #include <QtDebug>
 
+class EAGLPaintDevice;
+
+@interface PaintDeviceHelper : NSObject {
+    EAGLPaintDevice *device;
+}
+
+@property (nonatomic, assign) EAGLPaintDevice *device;
+
+- (void)eaglView:(EAGLView *)view usesFramebuffer:(GLuint)buffer;
+
+@end
+
 class EAGLPaintDevice : public QGLPaintDevice
 {
 public:
     EAGLPaintDevice(QPlatformWindow *window)
         :QGLPaintDevice(), mWindow(window)
     {
+#if defined(QT_OPENGL_ES_2)
+        helper = [[PaintDeviceHelper alloc] init];
+        helper.device = this;
+        EAGLView *view = static_cast<QUIKitWindow *>(window)->nativeView();
+        view.delegate = helper;
+        m_thisFBO = view.fbo;
+#endif
     }
 
+    ~EAGLPaintDevice()
+    {
+#if defined(QT_OPENGL_ES_2)
+        [helper release];
+#endif
+    }
+
+    void setFramebuffer(GLuint buffer) { m_thisFBO = buffer; }
     int devType() const { return QInternal::OpenGL; }
     QSize size() const { return mWindow->geometry().size(); }
     QGLContext* context() const { return QGLContext::fromPlatformGLContext(mWindow->glContext()); }
 
     QPaintEngine *paintEngine() const { return qt_qgl_paint_engine(); }
 
-    void  beginPaint(){
-        QGLPaintDevice::beginPaint();
-    }
 private:
     QPlatformWindow *mWindow;
+    PaintDeviceHelper *helper;
 };
 
+@implementation PaintDeviceHelper
+@synthesize device;
+
+- (void)eaglView:(EAGLView *)view usesFramebuffer:(GLuint)buffer
+{
+    Q_UNUSED(view)
+    if (device)
+        device->setFramebuffer(buffer);
+}
+
+@end
+
 QT_BEGIN_NAMESPACE
 
 QUIKitWindowSurface::QUIKitWindowSurface(QWidget *window)
diff --git a/src/plugins/platforms/wayland/gl_integration/wayland_egl/qwaylandeglintegration.cpp b/src/plugins/platforms/wayland/gl_integration/wayland_egl/qwaylandeglintegration.cpp
index 39e7be5..ddd1763 100644
--- a/src/plugins/platforms/wayland/gl_integration/wayland_egl/qwaylandeglintegration.cpp
+++ b/src/plugins/platforms/wayland/gl_integration/wayland_egl/qwaylandeglintegration.cpp
@@ -49,7 +49,6 @@
 
 QWaylandEglIntegration::QWaylandEglIntegration(struct wl_display *waylandDisplay)
     : mWaylandDisplay(waylandDisplay)
-    , mNativeEglDisplay(wl_egl_display_create(mWaylandDisplay))
 {
     qDebug() << "Using Wayland-EGL";
 }
@@ -63,7 +62,7 @@ QWaylandEglIntegration::~QWaylandEglIntegration()
 void QWaylandEglIntegration::initialize()
 {
     EGLint major,minor;
-    mEglDisplay = eglGetDisplay((EGLNativeDisplayType)mNativeEglDisplay);
+    mEglDisplay = eglGetDisplay(mWaylandDisplay);
     if (mEglDisplay == NULL) {
         qWarning("EGL not available");
     } else {
@@ -84,11 +83,6 @@ EGLDisplay QWaylandEglIntegration::eglDisplay() const
     return mEglDisplay;
 }
 
-wl_egl_display * QWaylandEglIntegration::nativeDisplay() const
-{
-    return mNativeEglDisplay;
-}
-
 QWaylandGLIntegration *QWaylandGLIntegration::createGLIntegration(QWaylandDisplay *waylandDisplay)
 {
     return new QWaylandEglIntegration(waylandDisplay->wl_display());
diff --git a/src/plugins/platforms/wayland/gl_integration/wayland_egl/qwaylandeglintegration.h b/src/plugins/platforms/wayland/gl_integration/wayland_egl/qwaylandeglintegration.h
index bf4c3fe..3a26f97 100644
--- a/src/plugins/platforms/wayland/gl_integration/wayland_egl/qwaylandeglintegration.h
+++ b/src/plugins/platforms/wayland/gl_integration/wayland_egl/qwaylandeglintegration.h
@@ -65,9 +65,6 @@ private:
     struct wl_display *mWaylandDisplay;
 
     EGLDisplay mEglDisplay;
-    struct wl_egl_display *mNativeEglDisplay;
-
-
 };
 
 #endif // QWAYLANDEGLINTEGRATION_H
diff --git a/src/plugins/platforms/wayland/gl_integration/wayland_egl/qwaylandeglwindow.cpp b/src/plugins/platforms/wayland/gl_integration/wayland_egl/qwaylandeglwindow.cpp
index d7cf0a5..cf52f39 100644
--- a/src/plugins/platforms/wayland/gl_integration/wayland_egl/qwaylandeglwindow.cpp
+++ b/src/plugins/platforms/wayland/gl_integration/wayland_egl/qwaylandeglwindow.cpp
@@ -103,7 +103,7 @@ void QWaylandEglWindow::newSurfaceCreated()
     if (!size.isValid())
         size = QSize(0,0);
 
-    mWaylandEglWindow = wl_egl_window_create(mEglIntegration->nativeDisplay(),mSurface,size.width(),size.height(),visual);
+    mWaylandEglWindow = wl_egl_window_create(mSurface,size.width(),size.height(),visual);
     if (mGLContext) {
         EGLNativeWindowType window(reinterpret_cast<EGLNativeWindowType>(mWaylandEglWindow));
         EGLSurface surface = eglCreateWindowSurface(mEglIntegration->eglDisplay(),mGLContext->eglConfig(),window,NULL);
diff --git a/src/plugins/platforms/wayland/gl_integration/wayland_egl/qwaylandeglwindow.h b/src/plugins/platforms/wayland/gl_integration/wayland_egl/qwaylandeglwindow.h
index 549d039..856321d 100644
--- a/src/plugins/platforms/wayland/gl_integration/wayland_egl/qwaylandeglwindow.h
+++ b/src/plugins/platforms/wayland/gl_integration/wayland_egl/qwaylandeglwindow.h
@@ -63,7 +63,6 @@ private:
     QWaylandEglIntegration *mEglIntegration;
     QWaylandGLContext *mGLContext;
     struct wl_egl_window *mWaylandEglWindow;
-    EGLConfig mConfig;
 
     const QWaylandWindow *mParentWindow;
 };
diff --git a/src/plugins/platforms/wayland/gl_integration/wayland_egl/wayland_egl.pri b/src/plugins/platforms/wayland/gl_integration/wayland_egl/wayland_egl.pri
index bc97864..cd07011 100644
--- a/src/plugins/platforms/wayland/gl_integration/wayland_egl/wayland_egl.pri
+++ b/src/plugins/platforms/wayland/gl_integration/wayland_egl/wayland_egl.pri
@@ -1,12 +1,11 @@
+include (../../../eglconvenience/eglconvenience.pri)
+
 LIBS += -lwayland-egl -lEGL
 INCLUDEPATH += $$PWD
 SOURCES += $$PWD/qwaylandeglintegration.cpp \
            $$PWD/qwaylandglcontext.cpp \
-           $$PWD/qwaylandeglwindow.cpp \
-           $$PWD/../../../eglconvenience/qeglconvenience.cpp
+           $$PWD/qwaylandeglwindow.cpp
 
 HEADERS += $$PWD/qwaylandeglintegration.h \
            $$PWD/qwaylandglcontext.h \
-           $$PWD/qwaylandeglwindow.h \
-           $$PWD/../../../eglconvenience/qeglconvenience.h \
-    gl_integration/wayland_egl/qwaylandeglinclude.h
+           $$PWD/qwaylandeglwindow.h
diff --git a/src/plugins/platforms/wayland/gl_integration/xcomposite_egl/qwaylandxcompositeeglintegration.cpp b/src/plugins/platforms/wayland/gl_integration/xcomposite_egl/qwaylandxcompositeeglintegration.cpp
index 95b4112..7537b52 100644
--- a/src/plugins/platforms/wayland/gl_integration/xcomposite_egl/qwaylandxcompositeeglintegration.cpp
+++ b/src/plugins/platforms/wayland/gl_integration/xcomposite_egl/qwaylandxcompositeeglintegration.cpp
@@ -111,9 +111,9 @@ const struct wl_xcomposite_listener QWaylandXCompositeEGLIntegration::xcomposite
 void QWaylandXCompositeEGLIntegration::wlDisplayHandleGlobal(wl_display *display, uint32_t id, const char *interface, uint32_t version, void *data)
 {
     Q_UNUSED(version);
-    if (strcmp(interface, "xcomposite") == 0) {
+    if (strcmp(interface, "wl_xcomposite") == 0) {
         QWaylandXCompositeEGLIntegration *integration = static_cast<QWaylandXCompositeEGLIntegration *>(data);
-        integration->mWaylandComposite = wl_xcomposite_create(display,id);
+        integration->mWaylandComposite = wl_xcomposite_create(display,id,1);
         wl_xcomposite_add_listener(integration->mWaylandComposite,&xcomposite_listener,integration);
     }
 
diff --git a/src/plugins/platforms/wayland/gl_integration/xcomposite_glx/qwaylandxcompositeglxintegration.cpp b/src/plugins/platforms/wayland/gl_integration/xcomposite_glx/qwaylandxcompositeglxintegration.cpp
index 43c0135..5cb6ef3 100644
--- a/src/plugins/platforms/wayland/gl_integration/xcomposite_glx/qwaylandxcompositeglxintegration.cpp
+++ b/src/plugins/platforms/wayland/gl_integration/xcomposite_glx/qwaylandxcompositeglxintegration.cpp
@@ -106,9 +106,9 @@ const struct wl_xcomposite_listener QWaylandXCompositeGLXIntegration::xcomposite
 void QWaylandXCompositeGLXIntegration::wlDisplayHandleGlobal(wl_display *display, uint32_t id, const char *interface, uint32_t version, void *data)
 {
     Q_UNUSED(version);
-    if (strcmp(interface, "xcomposite") == 0) {
+    if (strcmp(interface, "wl_xcomposite") == 0) {
         QWaylandXCompositeGLXIntegration *integration = static_cast<QWaylandXCompositeGLXIntegration *>(data);
-        integration->mWaylandComposite = wl_xcomposite_create(display,id);
+        integration->mWaylandComposite = wl_xcomposite_create(display,id,1);
         wl_xcomposite_add_listener(integration->mWaylandComposite,&xcomposite_listener,integration);
     }
 
diff --git a/src/plugins/platforms/wayland/gl_integration/xcomposite_share/wayland-xcomposite-client-protocol.h b/src/plugins/platforms/wayland/gl_integration/xcomposite_share/wayland-xcomposite-client-protocol.h
index 72376e1..85da7a9 100644
--- a/src/plugins/platforms/wayland/gl_integration/xcomposite_share/wayland-xcomposite-client-protocol.h
+++ b/src/plugins/platforms/wayland/gl_integration/xcomposite_share/wayland-xcomposite-client-protocol.h
@@ -39,7 +39,6 @@
 **
 ****************************************************************************/
 
-
 #ifndef XCOMPOSITE_CLIENT_PROTOCOL_H
 #define XCOMPOSITE_CLIENT_PROTOCOL_H
 
@@ -55,84 +54,63 @@ struct wl_client;
 
 struct wl_xcomposite;
 
-struct wl_proxy;
-
-extern void
-wl_proxy_marshal(struct wl_proxy *p, uint32_t opcode, ...);
-extern struct wl_proxy *
-wl_proxy_create(struct wl_proxy *factory,
-		const struct wl_interface *interface);
-extern struct wl_proxy *
-wl_proxy_create_for_id(struct wl_display *display,
-		       const struct wl_interface *interface, uint32_t id);
-extern void
-wl_proxy_destroy(struct wl_proxy *proxy);
-
-extern int
-wl_proxy_add_listener(struct wl_proxy *proxy,
-		      void (**implementation)(void), void *data);
-
-extern void
-wl_proxy_set_user_data(struct wl_proxy *proxy, void *user_data);
-
-extern void *
-wl_proxy_get_user_data(struct wl_proxy *proxy);
-
 extern const struct wl_interface wl_xcomposite_interface;
 
 struct wl_xcomposite_listener {
 	void (*root)(void *data,
-		     struct wl_xcomposite *xcomposite,
+		     struct wl_xcomposite *wl_xcomposite,
 		     const char *display_name,
 		     uint32_t root_window);
 };
 
 static inline int
-wl_xcomposite_add_listener(struct wl_xcomposite *xcomposite,
-			   const struct wl_xcomposite_listener *listener, void *data)
+wl_xcomposite_add_listener(struct wl_xcomposite *wl_xcomposite,
+			      const struct wl_xcomposite_listener *listener, void *data)
 {
-	return wl_proxy_add_listener((struct wl_proxy *) xcomposite,
+	return wl_proxy_add_listener((struct wl_proxy *) wl_xcomposite,
 				     (void (**)(void)) listener, data);
 }
 
 #define WL_XCOMPOSITE_CREATE_BUFFER	0
 
 static inline struct wl_xcomposite *
-wl_xcomposite_create(struct wl_display *display, uint32_t id)
+wl_xcomposite_create(struct wl_display *display, uint32_t id, uint32_t version)
 {
+	wl_display_bind(display, id, "wl_xcomposite", version);
+
 	return (struct wl_xcomposite *)
 		wl_proxy_create_for_id(display, &wl_xcomposite_interface, id);
 }
 
 static inline void
-wl_xcomposite_set_user_data(struct wl_xcomposite *xcomposite, void *user_data)
+wl_xcomposite_set_user_data(struct wl_xcomposite *wl_xcomposite, void *user_data)
 {
-	wl_proxy_set_user_data((struct wl_proxy *) xcomposite, user_data);
+	wl_proxy_set_user_data((struct wl_proxy *) wl_xcomposite, user_data);
 }
 
 static inline void *
-wl_xcomposite_get_user_data(struct wl_xcomposite *xcomposite)
+wl_xcomposite_get_user_data(struct wl_xcomposite *wl_xcomposite)
 {
-	return wl_proxy_get_user_data((struct wl_proxy *) xcomposite);
+	return wl_proxy_get_user_data((struct wl_proxy *) wl_xcomposite);
 }
 
 static inline void
-wl_xcomposite_destroy(struct wl_xcomposite *xcomposite)
+wl_xcomposite_destroy(struct wl_xcomposite *wl_xcomposite)
 {
-	wl_proxy_destroy((struct wl_proxy *) xcomposite);
+	wl_proxy_destroy((struct wl_proxy *) wl_xcomposite);
 }
 
 static inline struct wl_buffer *
-wl_xcomposite_create_buffer(struct wl_xcomposite *xcomposite, uint32_t x_window, int width, int height, struct wl_visual *visual)
+wl_xcomposite_create_buffer(struct wl_xcomposite *wl_xcomposite, uint32_t x_window, int width, int height, struct wl_visual *visual)
 {
 	struct wl_proxy *id;
 
-	id = wl_proxy_create((struct wl_proxy *) xcomposite,
+	id = wl_proxy_create((struct wl_proxy *) wl_xcomposite,
 			     &wl_buffer_interface);
 	if (!id)
 		return NULL;
 
-	wl_proxy_marshal((struct wl_proxy *) xcomposite,
+	wl_proxy_marshal((struct wl_proxy *) wl_xcomposite,
 			 WL_XCOMPOSITE_CREATE_BUFFER, id, x_window, width, height, visual);
 
 	return (struct wl_buffer *) id;
diff --git a/src/plugins/platforms/wayland/gl_integration/xcomposite_share/wayland-xcomposite-protocol.c b/src/plugins/platforms/wayland/gl_integration/xcomposite_share/wayland-xcomposite-protocol.c
index 5c966fd..a1b6325 100644
--- a/src/plugins/platforms/wayland/gl_integration/xcomposite_share/wayland-xcomposite-protocol.c
+++ b/src/plugins/platforms/wayland/gl_integration/xcomposite_share/wayland-xcomposite-protocol.c
@@ -43,17 +43,17 @@
 #include <stdint.h>
 #include "wayland-util.h"
 
-static const struct wl_message xcomposite_requests[] = {
+static const struct wl_message wl_xcomposite_requests[] = {
 	{ "create_buffer", "nuiio" },
 };
 
-static const struct wl_message xcomposite_events[] = {
+static const struct wl_message wl_xcomposite_events[] = {
 	{ "root", "su" },
 };
 
 WL_EXPORT const struct wl_interface wl_xcomposite_interface = {
-	"xcomposite", 1,
-	ARRAY_LENGTH(xcomposite_requests), xcomposite_requests,
-	ARRAY_LENGTH(xcomposite_events), xcomposite_events,
+	"wl_xcomposite", 1,
+	ARRAY_LENGTH(wl_xcomposite_requests), wl_xcomposite_requests,
+	ARRAY_LENGTH(wl_xcomposite_events), wl_xcomposite_events,
 };
 
diff --git a/src/plugins/platforms/wayland/qwaylandbuffer.h b/src/plugins/platforms/wayland/qwaylandbuffer.h
index 8779d5f..faeb3e8 100644
--- a/src/plugins/platforms/wayland/qwaylandbuffer.h
+++ b/src/plugins/platforms/wayland/qwaylandbuffer.h
@@ -44,6 +44,7 @@
 
 #include <QtCore/QSize>
 
+#include <wayland-client.h>
 #include <wayland-client-protocol.h>
 
 class QWaylandBuffer {
diff --git a/src/plugins/platforms/wayland/qwaylanddisplay.cpp b/src/plugins/platforms/wayland/qwaylanddisplay.cpp
index 1c56561..876b46a 100644
--- a/src/plugins/platforms/wayland/qwaylanddisplay.cpp
+++ b/src/plugins/platforms/wayland/qwaylanddisplay.cpp
@@ -126,6 +126,7 @@ QWaylandDisplay::QWaylandDisplay(void)
 #ifdef QT_WAYLAND_GL_SUPPORT
     mEglIntegration = QWaylandGLIntegration::createGLIntegration(this);
 #endif
+    blockingReadEvents();
 
     qRegisterMetaType<uint32_t>("uint32_t");
 
@@ -216,9 +217,6 @@ void QWaylandDisplay::outputHandleGeometry(void *data,
                                            int32_t x, int32_t y,
                                            int32_t width, int32_t height)
 {
-    //call back function called from another thread;
-    //but its safe to call createScreen from another thread since
-    //QWaylandScreen does a moveToThread
     QWaylandDisplay *waylandDisplay = static_cast<QWaylandDisplay *>(data);
     QRect outputRect = QRect(x, y, width, height);
     waylandDisplay->createNewScreen(output,outputRect);
@@ -252,17 +250,17 @@ void QWaylandDisplay::displayHandleGlobal(uint32_t id,
 {
     Q_UNUSED(version);
 
-    if (interface == "output") {
-        struct wl_output *output = wl_output_create(mDisplay, id);
+    if (interface == "wl_output") {
+        struct wl_output *output = wl_output_create(mDisplay, id, 1);
         wl_output_add_listener(output, &outputListener, this);
-    } else if (interface == "compositor") {
-        mCompositor = wl_compositor_create(mDisplay, id);
-    } else if (interface == "shm") {
-        mShm = wl_shm_create(mDisplay, id);
-    } else if (interface == "shell"){
-        mShell = wl_shell_create(mDisplay, id);
+    } else if (interface == "wl_compositor") {
+        mCompositor = wl_compositor_create(mDisplay, id, 1);
+    } else if (interface == "wl_shm") {
+        mShm = wl_shm_create(mDisplay, id, 1);
+    } else if (interface == "wl_shell"){
+        mShell = wl_shell_create(mDisplay, id, 1);
         wl_shell_add_listener(mShell, &shellListener, this);
-    } else if (interface == "input_device") {
+    } else if (interface == "wl_input_device") {
         QWaylandInputDevice *inputDevice =
             new QWaylandInputDevice(mDisplay, id);
         mInputDevices.append(inputDevice);
diff --git a/src/plugins/platforms/wayland/qwaylandinputdevice.cpp b/src/plugins/platforms/wayland/qwaylandinputdevice.cpp
index 6c2f341..f9e7c95 100644
--- a/src/plugins/platforms/wayland/qwaylandinputdevice.cpp
+++ b/src/plugins/platforms/wayland/qwaylandinputdevice.cpp
@@ -61,7 +61,7 @@
 QWaylandInputDevice::QWaylandInputDevice(struct wl_display *display,
 					 uint32_t id)
     : mDisplay(display)
-    , mInputDevice(wl_input_device_create(display, id))
+    , mInputDevice(wl_input_device_create(display, id, 1))
     , mPointerFocus(NULL)
     , mKeyboardFocus(NULL)
     , mButtons(0)
@@ -101,6 +101,12 @@ void QWaylandInputDevice::inputHandleMotion(void *data,
     QWaylandInputDevice *inputDevice = (QWaylandInputDevice *) data;
     QWaylandWindow *window = inputDevice->mPointerFocus;
 
+    if (window == NULL) {
+	/* We destroyed the pointer focus surface, but the server
+	 * didn't get the message yet. */
+	return;
+    }
+
     inputDevice->mSurfacePos = QPoint(surface_x, surface_y);
     inputDevice->mGlobalPos = QPoint(x, y);
     inputDevice->mTime = time;
@@ -120,6 +126,12 @@ void QWaylandInputDevice::inputHandleButton(void *data,
     QWaylandWindow *window = inputDevice->mPointerFocus;
     Qt::MouseButton qt_button;
 
+    if (window == NULL) {
+	/* We destroyed the pointer focus surface, but the server
+	 * didn't get the message yet. */
+	return;
+    }
+
     switch (button) {
     case 272:
 	qt_button = Qt::LeftButton;
@@ -229,6 +241,12 @@ void QWaylandInputDevice::inputHandleKey(void *data,
     QEvent::Type type;
     char s[2];
 
+    if (window == NULL) {
+	/* We destroyed the keyboard focus surface, but the server
+	 * didn't get the message yet. */
+	return;
+    }
+
     code = key + inputDevice->mXkb->min_key_code;
 
     level = 0;
@@ -250,9 +268,6 @@ void QWaylandInputDevice::inputHandleKey(void *data,
 
     sym = translateKey(sym, s, sizeof s);
 
-    qWarning("keycode %d, sym %d, string %d, modifiers 0x%x",
-	     code, sym, s[0], (int) inputDevice->mModifiers);
-
     if (window) {
         QWindowSystemInterface::handleKeyEvent(window->widget(),
                                                time, type, sym,
diff --git a/src/plugins/platforms/wayland/qwaylandintegration.cpp b/src/plugins/platforms/wayland/qwaylandintegration.cpp
index 3f3ee5e..b6401f6 100644
--- a/src/plugins/platforms/wayland/qwaylandintegration.cpp
+++ b/src/plugins/platforms/wayland/qwaylandintegration.cpp
@@ -44,6 +44,7 @@
 #include "qwaylanddisplay.h"
 #include "qwaylandshmsurface.h"
 #include "qwaylandshmwindow.h"
+#include "qwaylandnativeinterface.h"
 
 #include "qgenericunixfontdatabase.h"
 
@@ -62,9 +63,15 @@ QWaylandIntegration::QWaylandIntegration(bool useOpenGL)
     : mFontDb(new QGenericUnixFontDatabase())
     , mDisplay(new QWaylandDisplay())
     , mUseOpenGL(useOpenGL)
+    , mNativeInterface(new QWaylandNativeInterface)
 {
 }
 
+QPlatformNativeInterface * QWaylandIntegration::nativeInterface() const
+{
+    return mNativeInterface;
+}
+
 QList<QPlatformScreen *>
 QWaylandIntegration::screens() const
 {
diff --git a/src/plugins/platforms/wayland/qwaylandintegration.h b/src/plugins/platforms/wayland/qwaylandintegration.h
index fc9b8d6..71f6d9c 100644
--- a/src/plugins/platforms/wayland/qwaylandintegration.h
+++ b/src/plugins/platforms/wayland/qwaylandintegration.h
@@ -63,12 +63,15 @@ public:
 
     QPlatformFontDatabase *fontDatabase() const;
 
+    QPlatformNativeInterface *nativeInterface() const;
+
 private:
     bool hasOpenGL() const;
 
     QPlatformFontDatabase *mFontDb;
     QWaylandDisplay *mDisplay;
     bool mUseOpenGL;
+    QPlatformNativeInterface *mNativeInterface;
 };
 
 QT_END_NAMESPACE
diff --git a/src/plugins/platforms/wayland/qwaylandnativeinterface.cpp b/src/plugins/platforms/wayland/qwaylandnativeinterface.cpp
new file mode 100644
index 0000000..c3bfba0
--- /dev/null
+++ b/src/plugins/platforms/wayland/qwaylandnativeinterface.cpp
@@ -0,0 +1,72 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qwaylandnativeinterface.h"
+
+#include "qwaylanddisplay.h"
+#include "qwaylandwindow.h"
+#include <QtGui/private/qapplication_p.h>
+
+void *QWaylandNativeInterface::nativeResourceForWidget(const QByteArray &resourceString, QWidget *widget)
+{
+    QByteArray lowerCaseResource = resourceString.toLower();
+
+    if (lowerCaseResource == "display")
+	return qPlatformScreenForWidget(widget)->display()->wl_display();
+    if (lowerCaseResource == "surface") {
+	return ((QWaylandWindow *) widget->platformWindow())->wl_surface();
+    }
+
+    return NULL;
+}
+
+
+QWaylandScreen * QWaylandNativeInterface::qPlatformScreenForWidget(QWidget *widget)
+{
+    QWaylandScreen *screen;
+
+    if (widget) {
+        screen = static_cast<QWaylandScreen *>(QPlatformScreen::platformScreenForWidget(widget));
+    } else {
+        screen = static_cast<QWaylandScreen *>(QApplicationPrivate::platformIntegration()->screens()[0]);
+    }
+    return screen;
+}
diff --git a/src/plugins/platforms/wayland/qwaylandnativeinterface.h b/src/plugins/platforms/wayland/qwaylandnativeinterface.h
new file mode 100644
index 0000000..ac4cdb9
--- /dev/null
+++ b/src/plugins/platforms/wayland/qwaylandnativeinterface.h
@@ -0,0 +1,60 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QWAYLANDNATIVEINTERFACE_H
+#define QWAYLANDNATIVEINTERFACE_H
+
+#include "qwaylandscreen.h"
+
+#include <QtGui/QPlatformNativeInterface>
+
+class QWaylandNativeInterface : public QPlatformNativeInterface
+{
+public:
+    void *nativeResourceForWidget(const QByteArray &resourceString,
+				  QWidget *widget);
+
+private:
+    static QWaylandScreen *qPlatformScreenForWidget(QWidget *widget);
+};
+
+
+#endif // QWAYLANDNATIVEINTERFACE_H
diff --git a/src/plugins/platforms/wayland/qwaylandwindow.cpp b/src/plugins/platforms/wayland/qwaylandwindow.cpp
index 6f52291..53f2f48 100644
--- a/src/plugins/platforms/wayland/qwaylandwindow.cpp
+++ b/src/plugins/platforms/wayland/qwaylandwindow.cpp
@@ -146,6 +146,7 @@ void QWaylandWindow::newSurfaceCreated()
 void QWaylandWindow::frameCallback(struct wl_surface *surface, void *data, uint32_t time)
 {
     Q_UNUSED(time);
+    Q_UNUSED(surface);
     QWaylandWindow *self = static_cast<QWaylandWindow*>(data);
     self->mWaitingForFrameSync = false;
 }
diff --git a/src/plugins/platforms/wayland/qwaylandwindow.h b/src/plugins/platforms/wayland/qwaylandwindow.h
index 1e60508..47d49a7 100644
--- a/src/plugins/platforms/wayland/qwaylandwindow.h
+++ b/src/plugins/platforms/wayland/qwaylandwindow.h
@@ -74,6 +74,9 @@ public:
     void damage(const QRegion &region);
 
     void waitForFrameSync();
+
+    struct wl_surface *wl_surface() const { return mSurface; }
+
 protected:
     struct wl_surface *mSurface;
     virtual void newSurfaceCreated();
diff --git a/src/plugins/platforms/wayland/wayland.pro b/src/plugins/platforms/wayland/wayland.pro
index 5945438..8d2d4b5 100644
--- a/src/plugins/platforms/wayland/wayland.pro
+++ b/src/plugins/platforms/wayland/wayland.pro
@@ -8,6 +8,7 @@ DEFINES += $$QMAKE_DEFINES_WAYLAND
 
 SOURCES =   main.cpp \
             qwaylandintegration.cpp \
+            qwaylandnativeinterface.cpp \
             qwaylandshmsurface.cpp \
             qwaylandinputdevice.cpp \
             qwaylandcursor.cpp \
@@ -17,6 +18,7 @@ SOURCES =   main.cpp \
             qwaylandshmwindow.cpp
 
 HEADERS =   qwaylandintegration.h \
+            qwaylandnativeinterface.h \
             qwaylandcursor.h \
             qwaylanddisplay.h \
             qwaylandwindow.h \
diff --git a/src/qt3support/text/q3richtext.cpp b/src/qt3support/text/q3richtext.cpp
index 668a322..6c77405 100644
--- a/src/qt3support/text/q3richtext.cpp
+++ b/src/qt3support/text/q3richtext.cpp
@@ -63,6 +63,7 @@
 #include "qstyleoption.h"
 #include "q3stylesheet.h"
 #include "qtextstream.h"
+#include <private/qtextdocument_p.h>
 #include <private/qtextengine_p.h>
 
 #include <stdlib.h>
diff --git a/src/sql/drivers/mysql/qsql_mysql.cpp b/src/sql/drivers/mysql/qsql_mysql.cpp
index 49e7f13..4250b61 100644
--- a/src/sql/drivers/mysql/qsql_mysql.cpp
+++ b/src/sql/drivers/mysql/qsql_mysql.cpp
@@ -1374,12 +1374,16 @@ QStringList QMYSQLDriver::tables(QSql::TableType type) const
     } else {
         QSqlQuery q(createResult());
         if(type & QSql::Tables) {
-            q.exec(QLatin1String("select table_name from information_schema.tables where table_type = 'BASE TABLE'"));
+            QString sql = QLatin1String("select table_name from information_schema.tables where table_schema = '") + QLatin1String(d->mysql->db) + QLatin1String("' and table_type = 'BASE TABLE'");
+            q.exec(sql);
+            
             while(q.next())
                 tl.append(q.value(0).toString());
         }
         if(type & QSql::Views) {
-            q.exec(QLatin1String("select table_name from information_schema.tables where table_type = 'VIEW'"));
+            QString sql = QLatin1String("select table_name from information_schema.tables where table_schema = '") + QLatin1String(d->mysql->db) + QLatin1String("' and table_type = 'VIEW'");
+            q.exec(sql);
+            
             while(q.next())
                 tl.append(q.value(0).toString());
         }