Merge commit 'refs/merge-requests/1220' of git://gitorious.org/qt/qt into merge-requests/1220

129 files changed, 2433 insertions, 1727 deletions

diff --git a/configure b/configure
index 26ef7f3251..5bdf8af730 100755
--- a/configure
+++ b/configure
@@ -7519,10 +7519,8 @@ EOF
         canBuildQtConcurrent="no"
 	;;
     symbian-gcce)
-        canBuildQtConcurrent="no"
         ;;
     symbian-armcc)
-        canBuildQtConcurrent="no"
         ;;
 esac
 
@@ -8235,7 +8233,7 @@ if [ "$XPLATFORM_SYMBIAN" = "yes" ]; then
     # We cannot use Linux's default export rules since they export everything.
     QCONFIG_FLAGS="$QCONFIG_FLAGS QT_DLL"
     # Disable non-working features.
-    QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_CONCURRENT QT_NO_QFUTURE QT_NO_CRASHHANDLER QT_NO_PRINTER QT_NO_SYSTEMTRAYICON"
+    QCONFIG_FLAGS="$QCONFIG_FLAGS QT_NO_CRASHHANDLER QT_NO_PRINTER QT_NO_SYSTEMTRAYICON"
 fi
 
 if [ -n "$QCONFIG_FLAGS" ]; then
diff --git a/demos/declarative/samegame/SamegameCore/samegame.js b/demos/declarative/samegame/SamegameCore/samegame.js
index bb587bc6f3..d7b827a173 100755
--- a/demos/declarative/samegame/SamegameCore/samegame.js
+++ b/demos/declarative/samegame/SamegameCore/samegame.js
@@ -8,6 +8,7 @@ var blockSrc = "SamegameCore/BoomBlock.qml";
 var scoresURL = "";
 var gameDuration;
 var component = Qt.createComponent(blockSrc);
+var highScoreBar = 0;
 
 // Index function used instead of a 2D array
 function index(column, row)
@@ -152,11 +153,15 @@ function victoryCheck()
     // Checks for game over
     if (deservesBonus || !(floodMoveCheck(0, maxRow - 1, -1))) {
         gameDuration = new Date() - gameDuration;
-        nameInputDialog.show("You won! Please enter your name:                 ");
-        nameInputDialog.initialWidth = nameInputDialog.text.width + 20;
-        if (nameInputDialog.name == "")
-            nameInputDialog.width = nameInputDialog.initialWidth;
-        nameInputDialog.text.opacity = 0; // Just a spacer
+        if(gameCanvas.score > highScoreBar){
+            nameInputDialog.show("You won! Please enter your name:                 ");
+            nameInputDialog.initialWidth = nameInputDialog.text.width + 20;
+            if (nameInputDialog.name == "")
+                nameInputDialog.width = nameInputDialog.initialWidth;
+            nameInputDialog.text.opacity = 0; // Just a spacer
+        }else{
+            dialog.show("You won!");
+        }
     }
 }
 
@@ -203,6 +208,30 @@ function createBlock(column,row)
     return true;
 }
 
+function initHighScoreBar()
+{
+    if(scoresURL != "")
+        return true;//don't query remote scores
+    var db = openDatabaseSync(
+        "SameGameScores",
+        "1.0",
+        "Local SameGame High Scores",
+        100
+    );
+    db.transaction(
+        function(tx) {
+            tx.executeSql('CREATE TABLE IF NOT EXISTS Scores(name TEXT, score NUMBER, gridSize TEXT, time NUMBER)');
+            // Only show results for the current grid size
+            var rs = tx.executeSql('SELECT * FROM Scores WHERE gridSize = "'
+                + maxColumn + "x" + maxRow + '" ORDER BY score desc LIMIT 10');
+            if(rs.rows.length < 10)
+                highScoreBar = 0;
+            else 
+                highScoreBar = rs.rows.item(rs.rows.length - 1).score;
+        }
+    );
+}
+
 function saveHighScore(name)
 {
     if (scoresURL != "")
@@ -235,6 +264,8 @@ function saveHighScore(name)
                     + rs.rows.item(i).score + ' points in '
                     + rs.rows.item(i).time + ' seconds.\n';
             }
+            if(rs.rows.length == 10)
+                highScoreBar = rs.rows.item(9).score;
             dialog.show(r);
         }
     );
diff --git a/src/corelib/animation/qabstractanimation.cpp b/src/corelib/animation/qabstractanimation.cpp
index 602cf8a6fd..0a1f5d74da 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 ba92960f6b..0ccc502789 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 e392212b12..63dcc4b192 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 f31f7d2877..98506a597a 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 80edf7e136..a857ab5917 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/io/qfilesystemengine_unix.cpp b/src/corelib/io/qfilesystemengine_unix.cpp
index c9ebaa48bc..742b05e942 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
diff --git a/src/corelib/io/qfilesystemengine_win.cpp b/src/corelib/io/qfilesystemengine_win.cpp
index 82c6ebad05..1dbc40f3ed 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/qsettings.cpp b/src/corelib/io/qsettings.cpp
index b084ca5d62..f43fb31856 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/qcoreapplication.cpp b/src/corelib/kernel/qcoreapplication.cpp
index be86c58d47..c0b174801c 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 add2a3553e..eb46ae5e7b 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 80e927bcc9..d9aac00cf1 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/tools/qdatetime.cpp b/src/corelib/tools/qdatetime.cpp
index a3a8884374..d9a054ae77 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 5c4085af41..c8ed94b35f 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/qstring.h b/src/corelib/tools/qstring.h
index 66cfa744df..6418a8cbd4 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/declarative/debugger/qdeclarativedebug.cpp b/src/declarative/debugger/qdeclarativedebug.cpp
index 62eb8fea3e..049e05ea06 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/graphicsitems/qdeclarativetextedit.cpp b/src/declarative/graphicsitems/qdeclarativetextedit.cpp
index af2c8f38d7..ca78593631 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/qml/qdeclarativeobjectscriptclass.cpp b/src/declarative/qml/qdeclarativeobjectscriptclass.cpp
index 9eecc65e3c..edc1755a72 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 dc941e2601..a63656bc28 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 d7085f8784..335a825be3 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/graphicsview/qgraphicsanchorlayout_p.cpp b/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp
index 48cbec3d62..78918cc086 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 904a3deda2..a67ae48cc7 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 c622fb881e..60311744a2 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 c325602cc6..f73fb6af31 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 5591638395..40f9b1de71 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/qgraphicswidget.cpp b/src/gui/graphicsview/qgraphicswidget.cpp
index 675a5c5c77..141e305acd 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 45800551cb..63d7298024 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/itemviews/qtableview.cpp b/src/gui/itemviews/qtableview.cpp
index 59a3d15a62..e70f3569aa 100644
--- a/src/gui/itemviews/qtableview.cpp
+++ b/src/gui/itemviews/qtableview.cpp
@@ -1300,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();
 
diff --git a/src/gui/kernel/qcursor_x11.cpp b/src/gui/kernel/qcursor_x11.cpp
index d0ed98e1fe..0bc725036c 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 cff05f5836..6257a8bc06 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 abee8a101e..d6ed686a3f 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 5359fb37e8..7aa7dffd9b 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 d559c53355..8ff12ebf9c 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 19bf7a9f29..f3654b676d 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 ef532d7981..68685b4fed 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_x11.cpp b/src/gui/kernel/qwidget_x11.cpp
index 5ece7d65c6..241a13f842 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();
diff --git a/src/gui/painting/qdrawhelper_sse2.cpp b/src/gui/painting/qdrawhelper_sse2.cpp
index be6dc91922..75bb619d09 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);
diff --git a/src/gui/painting/qpaintbuffer.cpp b/src/gui/painting/qpaintbuffer.cpp
index 7870defd22..51171c5411 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_x11.cpp b/src/gui/painting/qpaintengine_x11.cpp
index 94828fba53..6ba9a99f09 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/qpainterpath.cpp b/src/gui/painting/qpainterpath.cpp
index 27aed3226f..9fbac13f47 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/qstroker.cpp b/src/gui/painting/qstroker.cpp
index fca46b45f7..dd723edc45 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/styles/qcleanlooksstyle.cpp b/src/gui/styles/qcleanlooksstyle.cpp
index cc5fe10692..786aab34c3 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 3d04c9a897..95ebdb4662 100644
--- a/src/gui/styles/qcommonstyle.cpp
+++ b/src/gui/styles/qcommonstyle.cpp
@@ -916,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);
@@ -933,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 68ade04984..6258fe4730 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 277e3025b5..d6dd52790f 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/qplastiquestyle.cpp b/src/gui/styles/qplastiquestyle.cpp
index 02ce60efab..1d33212457 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 1dcfd0047f..754486ee16 100644
--- a/src/gui/styles/qwindowsstyle.cpp
+++ b/src/gui/styles/qwindowsstyle.cpp
@@ -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/text/qtextdocumentlayout.cpp b/src/gui/text/qtextdocumentlayout.cpp
index 130f012639..f3dc975259 100644
--- a/src/gui/text/qtextdocumentlayout.cpp
+++ b/src/gui/text/qtextdocumentlayout.cpp
@@ -3090,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/qtextlayout.cpp b/src/gui/text/qtextlayout.cpp
index 122382fd02..8fdf4b2f6d 100644
--- a/src/gui/text/qtextlayout.cpp
+++ b/src/gui/text/qtextlayout.cpp
@@ -1211,8 +1211,6 @@ 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 = d->lineNumberForTextPosition(cursorPosition);
diff --git a/src/gui/util/qflickgesture.cpp b/src/gui/util/qflickgesture.cpp
index fdd2a95333..f87c84ccef 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 db128c136a..870d56fcb7 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/qdockarealayout.cpp b/src/gui/widgets/qdockarealayout.cpp
index 223421dfb2..28c0388078 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 9d1a737cf1..16b60c8295 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/qplaintextedit.cpp b/src/gui/widgets/qplaintextedit.cpp
index 7435691bf0..51c4ccbeb7 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 ff924bf377..8df436f932 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 bf50d07947..13ef13b2fe 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/qnetworkaccessmanager.cpp b/src/network/access/qnetworkaccessmanager.cpp
index 5a7521e33e..0d7b52ac2a 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 52eb3453b8..eec850797b 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 c108ad34cf..e9b6703dd9 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 81f38c5183..abc4b9b4fa 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 7af71ccc8b..cfb141398c 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 70d7dd8df1..ab4d7f1d76 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/plugins/platforms/uikit/quikiteventloop.mm b/src/plugins/platforms/uikit/quikiteventloop.mm
index 8d2603c60d..2b9728cea5 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 d4b4192b60..3a432d11a4 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 21494c9385..78389f21fd 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 9e73754fc8..5c6496a2ce 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 52d184636e..1f57baad69 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 bb7dcd794b..8caa15fbbe 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 39e7be5ac6..ddd17636c1 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 bf4c3fe45c..3a26f97b32 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 d7cf0a55e1..cf52f39d15 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 549d039bf8..856321dec8 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 bc978645c4..cd0701150f 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 95b4112cdc..7537b52d59 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 43c0135c6e..5cb6ef336b 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 72376e1dcb..85da7a9521 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 5c966fda46..a1b63254cb 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 8779d5fda0..faeb3e85b1 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 1c56561904..876b46ae9a 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 6c2f341f64..f9e7c95861 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 3f3ee5e571..b6401f6d06 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 fc9b8d6a6e..71f6d9c7b3 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 0000000000..c3bfba03cc
--- /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 0000000000..ac4cdb9a22
--- /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 6f522911d7..53f2f483e9 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 1e605088ad..47d49a70d9 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 59454384c2..8d2d4b50af 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/tests/auto/declarative/qdeclarativedebug/tst_qdeclarativedebug.cpp b/tests/auto/declarative/qdeclarativedebug/tst_qdeclarativedebug.cpp
index de4ddcc360..e63b14ef61 100644
--- a/tests/auto/declarative/qdeclarativedebug/tst_qdeclarativedebug.cpp
+++ b/tests/auto/declarative/qdeclarativedebug/tst_qdeclarativedebug.cpp
@@ -664,7 +664,13 @@ void tst_QDeclarativeDebug::queryAvailableEngines()
         QCOMPARE(e.name(), m_engine->objectName());
     }
 
+    // Make query invalid by deleting client
+    q_engines = m_dbg->queryAvailableEngines(this);
+    QCOMPARE(q_engines->state(), QDeclarativeDebugQuery::Waiting);
+    delete m_dbg;
+    QCOMPARE(q_engines->state(), QDeclarativeDebugQuery::Error);
     delete q_engines;
+    m_dbg = new QDeclarativeEngineDebug(m_conn, this);
 }
 
 void tst_QDeclarativeDebug::queryRootContexts()
@@ -672,6 +678,7 @@ void tst_QDeclarativeDebug::queryRootContexts()
     QDeclarativeDebugEnginesQuery *q_engines = m_dbg->queryAvailableEngines(this);
     waitForQuery(q_engines);
     int engineId = q_engines->engines()[0].debugId();
+    delete q_engines;
 
     QDeclarativeDebugRootContextQuery *q_context;
     
@@ -703,8 +710,13 @@ void tst_QDeclarativeDebug::queryRootContexts()
     QVERIFY(context.contexts()[0].debugId() >= 0);
     QCOMPARE(context.contexts()[0].name(), QString("tst_QDeclarativeDebug_childContext"));
 
-    delete q_engines;
+    // Make query invalid by deleting client
+    q_context = m_dbg->queryRootContexts(engineId, this);
+    QCOMPARE(q_context->state(), QDeclarativeDebugQuery::Waiting);
+    delete m_dbg;
+    QCOMPARE(q_context->state(), QDeclarativeDebugQuery::Error);
     delete q_context;
+    m_dbg = new QDeclarativeEngineDebug(m_conn, this);
 }
 
 void tst_QDeclarativeDebug::queryObject()
@@ -736,7 +748,14 @@ void tst_QDeclarativeDebug::queryObject()
 
     delete q_engines;
     delete q_context;
+
+    // Make query invalid by deleting client
+    q_obj = recursive ? m_dbg->queryObjectRecursive(rootObject, this) : m_dbg->queryObject(rootObject, this);
+    QCOMPARE(q_obj->state(), QDeclarativeDebugQuery::Waiting);
+    delete m_dbg;
+    QCOMPARE(q_obj->state(), QDeclarativeDebugQuery::Error);
     delete q_obj;
+    m_dbg = new QDeclarativeEngineDebug(m_conn, this);
 
     // check source as defined in main()
     QDeclarativeDebugFileReference source = obj.source();
@@ -811,7 +830,14 @@ void tst_QDeclarativeDebug::queryExpressionResult()
 
     delete q_engines;
     delete q_context;
+
+    // Make query invalid by deleting client
+    q_expr = m_dbg->queryExpressionResult(objectId, expr, this);
+    QCOMPARE(q_expr->state(), QDeclarativeDebugQuery::Waiting);
+    delete m_dbg;
+    QCOMPARE(q_expr->state(), QDeclarativeDebugQuery::Error);
     delete q_expr;
+    m_dbg = new QDeclarativeEngineDebug(m_conn, this);
 }
 
 void tst_QDeclarativeDebug::queryExpressionResult_data()
@@ -1001,7 +1027,7 @@ void tst_QDeclarativeDebug::setBindingForObject()
     // set handler
     //
     rootObject = findRootObject();
-    QCOMPARE(rootObject.children().size(), 3);
+    QCOMPARE(rootObject.children().size(), 4); // Rectangle, Text, MouseArea, QDeclarativeComponentAttached
     QDeclarativeDebugObjectReference mouseAreaObject = rootObject.children().at(2);
     QDeclarativeDebugObjectQuery *q_obj = m_dbg->queryObjectRecursive(mouseAreaObject, this);
     waitForQuery(q_obj);
diff --git a/tests/auto/declarative/qdeclarativeecmascript/data/realToInt.qml b/tests/auto/declarative/qdeclarativeecmascript/data/realToInt.qml
new file mode 100644
index 0000000000..cbbbbf921a
--- /dev/null
+++ b/tests/auto/declarative/qdeclarativeecmascript/data/realToInt.qml
@@ -0,0 +1,11 @@
+import QtQuick 1.0
+import Qt.test 1.0
+
+MyQmlObject {
+    function test1() {
+        value = 4.2
+    }
+    function test2() {
+        value = 7.9
+    }
+}
diff --git a/tests/auto/declarative/qdeclarativeecmascript/tst_qdeclarativeecmascript.cpp b/tests/auto/declarative/qdeclarativeecmascript/tst_qdeclarativeecmascript.cpp
index 1ec12fec01..be8f221b12 100644
--- a/tests/auto/declarative/qdeclarativeecmascript/tst_qdeclarativeecmascript.cpp
+++ b/tests/auto/declarative/qdeclarativeecmascript/tst_qdeclarativeecmascript.cpp
@@ -176,6 +176,7 @@ private slots:
     void aliasBindingsOverrideTarget();
     void aliasWritesOverrideBindings();
     void pushCleanContext();
+    void realToInt();
 
     void include();
 
@@ -3081,6 +3082,18 @@ void tst_qdeclarativeecmascript::pushCleanContext()
     QCOMPARE(func2.call().toInt32(), 6);
 }
 
+void tst_qdeclarativeecmascript::realToInt()
+{
+    QDeclarativeComponent component(&engine, TEST_FILE("realToInt.qml"));
+    MyQmlObject *object = qobject_cast<MyQmlObject*>(component.create());
+    QVERIFY(object != 0);
+
+    QMetaObject::invokeMethod(object, "test1");
+    QCOMPARE(object->value(), int(4));
+    QMetaObject::invokeMethod(object, "test2");
+    QCOMPARE(object->value(), int(8));
+}
+
 QTEST_MAIN(tst_qdeclarativeecmascript)
 
 #include "tst_qdeclarativeecmascript.moc"
diff --git a/tests/auto/declarative/qmetaobjectbuilder/tst_qmetaobjectbuilder.cpp b/tests/auto/declarative/qmetaobjectbuilder/tst_qmetaobjectbuilder.cpp
index 1b9831c1ad..f12bcc32db 100644
--- a/tests/auto/declarative/qmetaobjectbuilder/tst_qmetaobjectbuilder.cpp
+++ b/tests/auto/declarative/qmetaobjectbuilder/tst_qmetaobjectbuilder.cpp
@@ -546,6 +546,8 @@ void tst_QMetaObjectBuilder::property()
     QVERIFY(!nullProp.isUser());
     QVERIFY(!nullProp.hasStdCppSet());
     QVERIFY(!nullProp.isEnumOrFlag());
+    QVERIFY(!nullProp.isConstant());
+    QVERIFY(!nullProp.isFinal());
     QCOMPARE(nullProp.index(), 0);
 
     // Add a property and check its attributes.
@@ -563,6 +565,8 @@ void tst_QMetaObjectBuilder::property()
     QVERIFY(!prop1.isUser());
     QVERIFY(!prop1.hasStdCppSet());
     QVERIFY(!prop1.isEnumOrFlag());
+    QVERIFY(!prop1.isConstant());
+    QVERIFY(!prop1.isFinal());
     QCOMPARE(prop1.index(), 0);
     QCOMPARE(builder.propertyCount(), 1);
 
@@ -581,6 +585,8 @@ void tst_QMetaObjectBuilder::property()
     QVERIFY(!prop2.isUser());
     QVERIFY(!prop2.hasStdCppSet());
     QVERIFY(!prop2.isEnumOrFlag());
+    QVERIFY(!prop2.isConstant());
+    QVERIFY(!prop2.isFinal());
     QCOMPARE(prop2.index(), 1);
     QCOMPARE(builder.propertyCount(), 2);
 
@@ -602,6 +608,8 @@ void tst_QMetaObjectBuilder::property()
     prop1.setUser(true);
     prop1.setStdCppSet(true);
     prop1.setEnumOrFlag(true);
+    prop1.setConstant(true);
+    prop1.setFinal(true);
 
     // Check that prop1 is changed, but prop2 is not.
     QCOMPARE(prop1.name(), QByteArray("foo"));
@@ -616,6 +624,8 @@ void tst_QMetaObjectBuilder::property()
     QVERIFY(prop1.isUser());
     QVERIFY(prop1.hasStdCppSet());
     QVERIFY(prop1.isEnumOrFlag());
+    QVERIFY(prop1.isConstant());
+    QVERIFY(prop1.isFinal());
     QVERIFY(prop2.isReadable());
     QVERIFY(prop2.isWritable());
     QCOMPARE(prop2.name(), QByteArray("bar"));
@@ -628,6 +638,8 @@ void tst_QMetaObjectBuilder::property()
     QVERIFY(!prop2.isUser());
     QVERIFY(!prop2.hasStdCppSet());
     QVERIFY(!prop2.isEnumOrFlag());
+    QVERIFY(!prop2.isConstant());
+    QVERIFY(!prop2.isFinal());
 
     // Remove prop1 and check that prop2 becomes index 0.
     builder.removeProperty(0);
@@ -643,6 +655,8 @@ void tst_QMetaObjectBuilder::property()
     QVERIFY(!prop2.isUser());
     QVERIFY(!prop2.hasStdCppSet());
     QVERIFY(!prop2.isEnumOrFlag());
+    QVERIFY(!prop2.isConstant());
+    QVERIFY(!prop2.isFinal());
     QCOMPARE(prop2.index(), 0);
 
     // Perform index-based lookup again.
@@ -666,6 +680,8 @@ void tst_QMetaObjectBuilder::property()
             prop2.setUser(false); \
             prop2.setStdCppSet(false); \
             prop2.setEnumOrFlag(false); \
+            prop2.setConstant(false); \
+            prop2.setFinal(false); \
         } while (0)
 #define COUNT_FLAGS() \
         ((prop2.isReadable() ? 1 : 0) + \
@@ -677,7 +693,9 @@ void tst_QMetaObjectBuilder::property()
          (prop2.isEditable() ? 1 : 0) + \
          (prop2.isUser() ? 1 : 0) + \
          (prop2.hasStdCppSet() ? 1 : 0) + \
-         (prop2.isEnumOrFlag() ? 1 : 0))
+         (prop2.isEnumOrFlag() ? 1 : 0) + \
+         (prop2.isConstant() ? 1 : 0) + \
+         (prop2.isFinal() ? 1 : 0))
 #define CHECK_FLAG(setFunc,isFunc) \
         do { \
             CLEAR_FLAGS(); \
@@ -696,6 +714,8 @@ void tst_QMetaObjectBuilder::property()
     CHECK_FLAG(setUser, isUser);
     CHECK_FLAG(setStdCppSet, hasStdCppSet);
     CHECK_FLAG(setEnumOrFlag, isEnumOrFlag);
+    CHECK_FLAG(setConstant, isConstant);
+    CHECK_FLAG(setFinal, isFinal);
 
     // Check that nothing else changed.
     QVERIFY(checkForSideEffects(builder, QMetaObjectBuilder::Properties));
diff --git a/tests/auto/q3combobox/tst_q3combobox.cpp b/tests/auto/q3combobox/tst_q3combobox.cpp
index 17bd861f2f..825acb255b 100644
--- a/tests/auto/q3combobox/tst_q3combobox.cpp
+++ b/tests/auto/q3combobox/tst_q3combobox.cpp
@@ -1004,6 +1004,10 @@ void tst_Q3ComboBox::wheelEvent()
 
 void tst_Q3ComboBox::task231724_clear()
 {
+#ifdef Q_WS_MACX
+    return; // On Mac, we don't use a ListBox for the popup
+#endif
+
     Q3ComboBox box;
     
     for ( int i = 0; i <50; i++ ) {
diff --git a/tests/auto/q3progressbar/tst_q3progressbar.cpp b/tests/auto/q3progressbar/tst_q3progressbar.cpp
index 745e2d5528..3a0c3e21cc 100644
--- a/tests/auto/q3progressbar/tst_q3progressbar.cpp
+++ b/tests/auto/q3progressbar/tst_q3progressbar.cpp
@@ -45,6 +45,7 @@
 #include <qapplication.h>
 #include <qdebug.h>
 #include <q3progressbar.h>
+#include "../../shared/util.h"
 
 //TESTED_CLASS=
 //TESTED_FILES=
@@ -106,7 +107,7 @@ void tst_Q3ProgressBar::setProgress()
 {
     MyCustomProgressBar * m_progressBar = new MyCustomProgressBar();
     m_progressBar->show();
-    QApplication::processEvents();
+    QTest::qWaitForWindowShown(m_progressBar);
 
     //case with total steps = 0
     m_progressBar->setTotalSteps(0);
@@ -114,10 +115,9 @@ void tst_Q3ProgressBar::setProgress()
     m_progressBar->paintNumber = 0;
     m_progressBar->setProgress(m_progressBar->progress() + 1);
     QCOMPARE(oldValue + 1,m_progressBar->progress());
-    QApplication::processEvents();
 
     // It might be > 1 because it is animated.
-    QVERIFY(m_progressBar->paintNumber >= 1);
+    QTRY_VERIFY(m_progressBar->paintNumber >= 1);
     qDebug() << "Animation test: paintNumber =" << m_progressBar->paintNumber;
     
     //standard case
@@ -125,10 +125,9 @@ void tst_Q3ProgressBar::setProgress()
     m_progressBar->setProgress(0);
     m_progressBar->paintNumber = 0;
     m_progressBar->setProgress(m_progressBar->progress() + 1);
-    QApplication::processEvents();
 
     // It might be > 1 because other events might cause painting.
-    QVERIFY(m_progressBar->paintNumber >= 1);
+    QTRY_VERIFY(m_progressBar->paintNumber >= 1);
     qDebug() << "Standard test: paintNumber =" << m_progressBar->paintNumber;
 }
 
diff --git a/tests/auto/qdatetime/tst_qdatetime.cpp b/tests/auto/qdatetime/tst_qdatetime.cpp
index f8836a6b79..d612911727 100644
--- a/tests/auto/qdatetime/tst_qdatetime.cpp
+++ b/tests/auto/qdatetime/tst_qdatetime.cpp
@@ -85,6 +85,8 @@ private slots:
     void setTime_t();
     void setMSecsSinceEpoch_data();
     void setMSecsSinceEpoch();
+    void toString_isoDate_data();
+    void toString_isoDate();
     void toString_enumformat();
     void toString_strformat_data();
     void toString_strformat();
@@ -506,6 +508,36 @@ void tst_QDateTime::setMSecsSinceEpoch()
     QCOMPARE(dt, reference.addMSecs(msecs));
 }
 
+void tst_QDateTime::toString_isoDate_data()
+{
+    QTest::addColumn<QDateTime>("dt");
+    QTest::addColumn<QString>("formatted");
+
+    QTest::newRow("localtime")
+            << QDateTime(QDate(1978, 11, 9), QTime(13, 28, 34))
+            << QString("1978-11-09T13:28:34");
+    QTest::newRow("UTC")
+            << QDateTime(QDate(1978, 11, 9), QTime(13, 28, 34), Qt::UTC)
+            << QString("1978-11-09T13:28:34Z");
+    QDateTime dt(QDate(1978, 11, 9), QTime(13, 28, 34));
+    dt.setUtcOffset(19800);
+    QTest::newRow("positive OffsetFromUTC")
+            << dt
+            << QString("1978-11-09T13:28:34+05:30");
+    dt.setUtcOffset(-7200);
+    QTest::newRow("negative OffsetFromUTC")
+            << dt
+            << QString("1978-11-09T13:28:34-02:00");
+}
+
+void tst_QDateTime::toString_isoDate()
+{
+    QFETCH(QDateTime, dt);
+    QFETCH(QString, formatted);
+
+    QCOMPARE(dt.toString(Qt::ISODate), formatted);
+}
+
 void tst_QDateTime::toString_enumformat()
 {
     QDateTime dt1(QDate(1995, 5, 20), QTime(12, 34, 56));
diff --git a/tests/auto/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp b/tests/auto/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp
index e7c63d540e..447385a7d8 100644
--- a/tests/auto/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp
+++ b/tests/auto/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp
@@ -1091,6 +1091,9 @@ void tst_QGraphicsAnchorLayout::setSpacing()
 #ifdef Q_WS_MAC
     QTest::qWait(200);
 #endif
+
+    // 21x21
+    QCOMPARE(p->size(), QSizeF(41, 41));
     QCOMPARE(a->geometry(), QRectF(0, 0, 20, 20));
     QCOMPARE(b->geometry(), QRectF(21, 0, 20, 20));
     QCOMPARE(c->geometry(), QRectF(0, 21, 41, 20));
diff --git a/tests/auto/qgraphicslayout/tst_qgraphicslayout.cpp b/tests/auto/qgraphicslayout/tst_qgraphicslayout.cpp
index 979f03df64..29ea07460e 100644
--- a/tests/auto/qgraphicslayout/tst_qgraphicslayout.cpp
+++ b/tests/auto/qgraphicslayout/tst_qgraphicslayout.cpp
@@ -62,6 +62,7 @@ private slots:
     void compressLayoutRequest();
     void automaticReparenting();
     void verifyActivate();
+    void invalidate();
     void constructors();
     void alternativeLayoutItems();
     void ownership();
@@ -95,6 +96,14 @@ void tst_QGraphicsLayout::sizeHints()
 
 }
 
+enum FunctionType {
+    SetGeometry = 0,
+    Invalidate,
+    NumFunctionTypes
+};
+
+
+
 class TestGraphicsWidget : public QGraphicsWidget {
 public:
     TestGraphicsWidget(QGraphicsWidget *parent = 0) : QGraphicsWidget(parent)
@@ -108,9 +117,28 @@ public:
     int eventCount(QEvent::Type type) {
         return m_eventCount.value(int(type));
     }
+
     void clearEventCount() {
         m_eventCount.clear();
     }
+
+    void clearCounters() {
+        m_eventCount.clear();
+        functionCount.clear();
+    }
+
+    void setGeometry(const QRectF &rect)
+    {
+        QGraphicsWidget::setGeometry(rect);
+        ++(functionCount[SetGeometry]);
+    }
+
+    void callUpdateGeometry()
+    {
+        // updateGeometry() is protected
+        QGraphicsWidget::updateGeometry();
+    }
+    QMap<FunctionType, int> functionCount;
 private:
     QMap<int, int> m_eventCount;
 };
@@ -122,6 +150,8 @@ void tst_QGraphicsLayout::compressLayoutRequest()
     TestGraphicsWidget *tw = new TestGraphicsWidget();
     scene.addItem(tw);
     view.show();
+
+    QTest::qWaitForWindowShown(&view);
     QGraphicsLinearLayout *lout = new QGraphicsLinearLayout(tw);
     for (int i = 0; i < 4; ++i) {
         QGraphicsWidget *gw = new QGraphicsWidget(tw);
@@ -217,17 +247,27 @@ class TestLayout : public QGraphicsLinearLayout
     TestLayout(QGraphicsLayoutItem *parent = 0)
         : QGraphicsLinearLayout(parent)
     {
-        m_count = 0;
+        setContentsMargins(0,0,0,0);
+        setSpacing(0);
     }
 
-    void setGeometry(const QRectF &rect) {
-
-        ++m_count;
+    void setGeometry(const QRectF &rect)
+    {
+        ++(functionCount[SetGeometry]);
         QGraphicsLinearLayout::setGeometry(rect);
     }
 
+    void invalidate()
+    {
+        ++(functionCount[Invalidate]);
+        QGraphicsLinearLayout::invalidate();
+    }
+
+    void clearCounters() {
+        functionCount.clear();
+    }
 
-    int m_count;
+    QMap<FunctionType, int> functionCount;
 };
 
 void tst_QGraphicsLayout::verifyActivate()
@@ -242,13 +282,278 @@ void tst_QGraphicsLayout::verifyActivate()
     lout->addItem(w);
     window->setLayout(lout);
 
-    QCOMPARE(lout->m_count, 0);
+    QCOMPARE(lout->functionCount[SetGeometry], 0);
     window->setVisible(false);
-    QCOMPARE(lout->m_count, 0);
+    QCOMPARE(lout->functionCount[SetGeometry], 0);
     window->setVisible(true);
     // on polish or the first time a widget is shown, the widget is resized.
-    QCOMPARE(lout->m_count, 1);
+    QCOMPARE(lout->functionCount[SetGeometry], 1);
+
+}
+
+static void clearAllCounters(TestGraphicsWidget *widget)
+{
+    if (!widget)
+        return;
+    widget->clearCounters();
+    TestLayout *layout = static_cast<TestLayout *>(widget->layout());
+    if (layout) {
+        layout->clearCounters();
+        for (int i = layout->count() - 1; i >=0; --i) {
+            QGraphicsLayoutItem *item = layout->itemAt(i);
+            if (item->isLayout()) {
+                // ### Not used ATM
+                //TestLayout *lay = static_cast<TestLayout*>(static_cast<QGraphicsLayout*>(item));
+                //clearAllCounters(lay);
+            } else {
+                TestGraphicsWidget *wid = static_cast<TestGraphicsWidget *>(item);
+                clearAllCounters(wid);
+            }
+        }
+    }
+}
+
+static void activateAndReset(TestGraphicsWidget *widget)
+{
+    QApplication::sendPostedEvents();
+    QApplication::processEvents();
+    if (widget->layout())
+        widget->layout()->activate();
+    clearAllCounters(widget);
+}
+
+
+void tst_QGraphicsLayout::invalidate()
+{
+    QGraphicsLayout::setInstantInvalidatePropagation(true);
+    QGraphicsScene scene;
+    QGraphicsView view(&scene);
+
+    TestGraphicsWidget *a = new TestGraphicsWidget;
+    a->setData(0, QString("a"));
+    scene.addItem(a);
+    TestLayout *alay = new TestLayout(a);
+    TestGraphicsWidget *b = new TestGraphicsWidget;
+    b->setData(0, QString("b"));
+    alay->addItem(b);
+    TestLayout *blay = new TestLayout(b);
+    TestGraphicsWidget *e = new TestGraphicsWidget;
+    e->setData(0, QString("e"));
+    blay->addItem(e);
+
+
+    TestGraphicsWidget *c = new TestGraphicsWidget;
+    c->setData(0, QString("c"));
+    alay->addItem(c);
+    TestLayout *clay = new TestLayout(c);
+    TestGraphicsWidget *f = new TestGraphicsWidget;
+    f->setData(0, QString("f"));
+    clay->addItem(f);
+
+    TestGraphicsWidget *d = new TestGraphicsWidget;
+    d->setData(0, QString("d"));
+    alay->addItem(d);
+    TestLayout *dlay = new TestLayout(d);
+    TestGraphicsWidget *g = new TestGraphicsWidget;
+    g->setData(0, QString("g"));
+    dlay->addItem(g);
+
+    view.show();
+
+    {
+        clearAllCounters(a);
+
+        QCoreApplication::sendPostedEvents();
+        QCoreApplication::processEvents();
+
+        alay->activate();
+        QCOMPARE(alay->isActivated(), true);
+        QCOMPARE(blay->isActivated(), true);
+        QCOMPARE(clay->isActivated(), true);
+        QCOMPARE(dlay->isActivated(), true);
+    }
+
+    {
+        clearAllCounters(a);
+        e->callUpdateGeometry();
+        QCOMPARE(alay->isActivated(), false);
+        QCOMPARE(blay->isActivated(), false);
+        QCOMPARE(clay->isActivated(), true);
+        QCOMPARE(dlay->isActivated(), true);
+        QCOMPARE(a->eventCount(QEvent::LayoutRequest), 0);
+        QCOMPARE(b->eventCount(QEvent::LayoutRequest), 0);
+        QCOMPARE(c->eventCount(QEvent::LayoutRequest), 0);
+        QCOMPARE(d->eventCount(QEvent::LayoutRequest), 0);
+
+        // should only invalidate ascendants of e
+        QCOMPARE(blay->functionCount[Invalidate], 1);
+        QCOMPARE(alay->functionCount[Invalidate], 1);
+        // not siblings
+        QCOMPARE(clay->functionCount[Invalidate], 0);
+        QCOMPARE(dlay->functionCount[Invalidate], 0);
+
+        QApplication::sendPostedEvents();
+        QCOMPARE(a->eventCount(QEvent::LayoutRequest), 1);
+        QCOMPARE(b->eventCount(QEvent::LayoutRequest), 1);
+        QCOMPARE(c->eventCount(QEvent::LayoutRequest), 0);
+        QCOMPARE(d->eventCount(QEvent::LayoutRequest), 0);
+    }
 
+
+    {
+        activateAndReset(a);
+        f->callUpdateGeometry();
+        QCOMPARE(alay->isActivated(), false);
+        QCOMPARE(blay->isActivated(), true);
+        QCOMPARE(clay->isActivated(), false);
+        QCOMPARE(dlay->isActivated(), true);
+
+        QCoreApplication::sendPostedEvents();
+        QCOMPARE(a->eventCount(QEvent::LayoutRequest), 1);
+        QCOMPARE(b->eventCount(QEvent::LayoutRequest), 0);
+        QCOMPARE(c->eventCount(QEvent::LayoutRequest), 1);
+        QCOMPARE(d->eventCount(QEvent::LayoutRequest), 0);
+
+        QCOMPARE(a->functionCount[SetGeometry], 1);
+        QCOMPARE(alay->functionCount[SetGeometry], 1);
+
+        QCOMPARE(b->functionCount[SetGeometry], 1);
+        QCOMPARE(c->functionCount[SetGeometry], 1);
+        QCOMPARE(d->functionCount[SetGeometry], 1);
+        // Since nothing really changed, blay and dlay don't need
+        // to be resized.
+        QCOMPARE(blay->functionCount[SetGeometry], 0);
+        QCOMPARE(clay->functionCount[SetGeometry], 1);
+        QCOMPARE(dlay->functionCount[SetGeometry], 0);
+
+        QCOMPARE(f->functionCount[SetGeometry], 1);
+
+        QCOMPARE(a->size(), QSizeF(150, 50));
+    }
+
+    {
+        activateAndReset(a);
+        f->setPreferredSize(QSizeF(60,50));
+        QCOMPARE(alay->isActivated(), false);
+        QCOMPARE(blay->isActivated(), true);
+        QCOMPARE(clay->isActivated(), false);
+        QCOMPARE(dlay->isActivated(), true);
+
+        QCOMPARE(c->eventCount(QEvent::LayoutRequest), 0);
+        QCoreApplication::sendPostedEvents();
+        QCOMPARE(a->eventCount(QEvent::LayoutRequest), 1);
+        QCOMPARE(b->eventCount(QEvent::LayoutRequest), 0);
+        QCOMPARE(c->eventCount(QEvent::LayoutRequest), 1);
+        QCOMPARE(d->eventCount(QEvent::LayoutRequest), 0);
+
+        QCOMPARE(a->functionCount[SetGeometry], 1);
+        QCOMPARE(alay->functionCount[SetGeometry], 1);
+
+        QCOMPARE(b->functionCount[SetGeometry], 1);
+        QCOMPARE(c->functionCount[SetGeometry], 1);
+        QCOMPARE(d->functionCount[SetGeometry], 1);
+        // f actually got wider, need to rearrange its siblings
+        QCOMPARE(blay->functionCount[SetGeometry], 1);
+        QCOMPARE(clay->functionCount[SetGeometry], 1);
+        QCOMPARE(dlay->functionCount[SetGeometry], 1);
+
+        QCOMPARE(e->functionCount[SetGeometry], 1);
+        QCOMPARE(f->functionCount[SetGeometry], 1);
+        QCOMPARE(g->functionCount[SetGeometry], 1);
+
+        QVERIFY(e->size().width() < f->size().width());
+        QVERIFY(g->size().width() < f->size().width());
+    }
+
+    {
+        // resize f so much that it'll force a resize of the top widget
+        // this will currently generate two setGeometry() calls on the child layout
+        // of the top widget.
+        activateAndReset(a);
+        f->setPreferredSize(QSizeF());
+        f->setMinimumSize(QSizeF(200,50));
+        QCOMPARE(alay->isActivated(), false);
+        QCOMPARE(blay->isActivated(), true);
+        QCOMPARE(clay->isActivated(), false);
+        QCOMPARE(dlay->isActivated(), true);
+
+        QCOMPARE(c->eventCount(QEvent::LayoutRequest), 0);
+        QCoreApplication::sendPostedEvents();
+        QCOMPARE(a->eventCount(QEvent::LayoutRequest), 1);
+        QCOMPARE(b->eventCount(QEvent::LayoutRequest), 0);
+        QCOMPARE(c->eventCount(QEvent::LayoutRequest), 1);
+        QCOMPARE(d->eventCount(QEvent::LayoutRequest), 0);
+
+        QCOMPARE(a->functionCount[SetGeometry], 1);
+
+        /* well, ideally one call to setGeometry(), but it will currently
+         * get two calls to setGeometry():
+         *   1. The first LayoutRequest will call activate() - that will call
+         *      setGeometry() on the layout. This geometry will be based on
+         *      the widget geometry which is not correct at this moment.
+         *      (it is still 150 wide)
+         *   2. Next, we check if the widget is top level, and then we call
+         *      parentWidget->resize(parentWidget->size());
+         *      This will be adjusted to be minimum 200 pixels wide.
+         *      The new size will then be propagated down to the layout
+         *
+         */
+        QCOMPARE(alay->functionCount[SetGeometry], 2);
+
+        QCOMPARE(b->functionCount[SetGeometry], 2);
+        QCOMPARE(c->functionCount[SetGeometry], 2);
+        QCOMPARE(d->functionCount[SetGeometry], 2);
+        // f actually got wider, need to rearrange its siblings
+        QCOMPARE(blay->functionCount[SetGeometry], 1);
+        QCOMPARE(clay->functionCount[SetGeometry], 1);
+        QCOMPARE(dlay->functionCount[SetGeometry], 1);
+
+        QCOMPARE(e->functionCount[SetGeometry], 1);
+        QCOMPARE(f->functionCount[SetGeometry], 1);
+        QCOMPARE(g->functionCount[SetGeometry], 1);
+
+        QVERIFY(e->size().width() < f->size().width());
+        QVERIFY(g->size().width() < f->size().width());
+    }
+
+    {
+        f->setPreferredSize(QSizeF());
+        f->setMinimumSize(QSizeF());
+        a->adjustSize();
+        activateAndReset(a);
+        // update two different leaf widgets,
+        // eventCount and functionCount should never be >= 2
+        e->callUpdateGeometry();
+        g->callUpdateGeometry();
+        QCOMPARE(alay->isActivated(), false);
+        QCOMPARE(blay->isActivated(), false);
+        QCOMPARE(clay->isActivated(), true);
+        QCOMPARE(dlay->isActivated(), false);
+
+        QCoreApplication::sendPostedEvents();
+        QCOMPARE(a->eventCount(QEvent::LayoutRequest), 1);
+        QCOMPARE(b->eventCount(QEvent::LayoutRequest), 1);
+        QCOMPARE(c->eventCount(QEvent::LayoutRequest), 0);
+        QCOMPARE(d->eventCount(QEvent::LayoutRequest), 1);
+
+        QCOMPARE(a->functionCount[SetGeometry], 1);
+        QCOMPARE(alay->functionCount[SetGeometry], 1);
+
+        QCOMPARE(b->functionCount[SetGeometry], 1);
+        QCOMPARE(c->functionCount[SetGeometry], 1);
+        QCOMPARE(d->functionCount[SetGeometry], 1);
+        // f actually got wider, need to rearrange its siblings
+        QCOMPARE(blay->functionCount[SetGeometry], 1);
+        QCOMPARE(clay->functionCount[SetGeometry], 0);
+        QCOMPARE(dlay->functionCount[SetGeometry], 1);
+
+        QCOMPARE(e->functionCount[SetGeometry], 1);
+        QCOMPARE(f->functionCount[SetGeometry], 0);
+        QCOMPARE(g->functionCount[SetGeometry], 1);
+
+    }
+
+    QGraphicsLayout::setInstantInvalidatePropagation(false);
 }
 
 class Layout : public QGraphicsLayout
diff --git a/tests/auto/qgraphicslinearlayout/tst_qgraphicslinearlayout.cpp b/tests/auto/qgraphicslinearlayout/tst_qgraphicslinearlayout.cpp
index 62ba1b4981..8f8ac67d09 100644
--- a/tests/auto/qgraphicslinearlayout/tst_qgraphicslinearlayout.cpp
+++ b/tests/auto/qgraphicslinearlayout/tst_qgraphicslinearlayout.cpp
@@ -94,6 +94,7 @@ private slots:
     void itemSpacing();
     void setStretchFactor_data();
     void setStretchFactor();
+    void testStretch();
     void defaultStretchFactors_data();
     void defaultStretchFactors();
     void sizeHint_data();
@@ -667,6 +668,10 @@ void tst_QGraphicsLinearLayout::invalidate()
     layout.setContentsMargins(0, 0, 0, 0);
     view.show();
     widget->show();
+    //QTest::qWait(1000);
+    QTest::qWaitForWindowShown(&view);
+    qApp->processEvents();
+    layout.layoutRequest = 0;
 
     layout.setContentsMargins(1, 2, 3, 4);
     QApplication::sendPostedEvents(0, 0);
@@ -1130,6 +1135,41 @@ void tst_QGraphicsLinearLayout::setStretchFactor()
     delete widget;
 }
 
+void tst_QGraphicsLinearLayout::testStretch()
+{
+    QGraphicsScene scene;
+    QGraphicsView *view = new QGraphicsView(&scene);
+    QGraphicsWidget *form = new QGraphicsWidget(0, Qt::Window);
+
+    scene.addItem(form);
+    form->setMinimumSize(600, 600);
+    form->setMaximumSize(600, 600);
+    QGraphicsLinearLayout *layout = new QGraphicsLinearLayout(Qt::Horizontal, form);
+    QGraphicsWidget *w1 = new RectWidget;
+    w1->setPreferredSize(100,100);
+    w1->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
+    QGraphicsWidget *w2 = new RectWidget;
+    w2->setPreferredSize(200,200);
+    w2->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
+    layout->setSpacing(0);
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->addItem(w1);
+    layout->addStretch(2);
+    layout->addItem(w2);
+    QCOMPARE(layout->count(), 2);
+    QVERIFY(layout->itemAt(0) == w1);
+    QVERIFY(layout->itemAt(1) == w2);
+    layout->activate();
+
+    //view->setSceneRect(-50, -50, 800, 800);
+    //view->show();
+    //QTest::qWaitForWindowShown(view);
+    //QTest::qWait(5000);
+    QCOMPARE(form->geometry().size(), QSizeF(600,600));
+    QCOMPARE(w1->geometry(), QRectF(0, 0, 100, 100));
+    QCOMPARE(w2->geometry(), QRectF(400, 0, 200, 200));
+}
+
 void tst_QGraphicsLinearLayout::defaultStretchFactors_data()
 {
     QTest::addColumn<Qt::Orientation>("orientation");
diff --git a/tests/auto/qgraphicswidget/tst_qgraphicswidget.cpp b/tests/auto/qgraphicswidget/tst_qgraphicswidget.cpp
index e8e2e23a9e..887026caf4 100644
--- a/tests/auto/qgraphicswidget/tst_qgraphicswidget.cpp
+++ b/tests/auto/qgraphicswidget/tst_qgraphicswidget.cpp
@@ -186,7 +186,6 @@ private slots:
     void task250119_shortcutContext();
     void QT_BUG_6544_tabFocusFirstUnsetWhenRemovingItems();
     void QT_BUG_12056_tabFocusFirstUnsetWhenRemovingItems();
-    void QT_BUG_13865_doublePaintWhenAddingASubItem();
 };
 
 
@@ -3367,46 +3366,6 @@ void tst_QGraphicsWidget::QT_BUG_12056_tabFocusFirstUnsetWhenRemovingItems()
     //This should not crash
 }
 
-
-struct GreenWidget : public QGraphicsWidget
-{
-    GreenWidget() : count(0)
-    {
-    }
-
-    void paint ( QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * )
-    {
-        count++;
-        painter->setPen(Qt::green);
-        painter->drawRect(option->rect.adjusted(0,0,-1,-1));
-    }
-
-    int count;
-};
-
-void tst_QGraphicsWidget::QT_BUG_13865_doublePaintWhenAddingASubItem()
-{
-    QGraphicsScene scene;
-    QGraphicsView view(&scene);
-    QGraphicsWidget *widget =  new QGraphicsWidget;
-    widget->resize(100, 100);
-    scene.addItem(widget);
-    QGraphicsLinearLayout *layout = new QGraphicsLinearLayout(widget);
-
-    view.show();
-    QTest::qWaitForWindowShown(&view);
-    QApplication::processEvents();
-
-
-    GreenWidget *sub =  new GreenWidget;
-    layout->addItem(sub);
-
-    QTest::qWait(100);
-    QCOMPARE(sub->count, 1); //it should only be painted once
-
-}
-
-
 QTEST_MAIN(tst_QGraphicsWidget)
 #include "tst_qgraphicswidget.moc"
 
diff --git a/tests/auto/qnetworkcookie/tst_qnetworkcookie.cpp b/tests/auto/qnetworkcookie/tst_qnetworkcookie.cpp
index e0c477b2df..9a58482de0 100644
--- a/tests/auto/qnetworkcookie/tst_qnetworkcookie.cpp
+++ b/tests/auto/qnetworkcookie/tst_qnetworkcookie.cpp
@@ -182,6 +182,14 @@ void tst_QNetworkCookie::parseSingleCookie_data()
     cookie.setValue("\"\\\"a, b; c\\\"\"");
     QTest::newRow("with-value-with-special5") << "a = \"\\\"a, b; c\\\"\"" << cookie;
 
+    cookie.setValue("b c");
+    QTest::newRow("with-value-with-whitespace") << "a = b c" << cookie;
+
+    cookie.setValue("\"b\"");
+    QTest::newRow("quoted-value") << "a = \"b\"" << cookie;
+    cookie.setValue("\"b c\"");
+    QTest::newRow("quoted-value-with-whitespace") << "a = \"b c\"" << cookie;
+
     cookie.setValue("b");
     cookie.setSecure(true);
     QTest::newRow("secure") << "a=b;secure" << cookie;
diff --git a/tests/auto/qplaintextedit/tst_qplaintextedit.cpp b/tests/auto/qplaintextedit/tst_qplaintextedit.cpp
index d3e4fd0258..8da5ba5d9a 100644
--- a/tests/auto/qplaintextedit/tst_qplaintextedit.cpp
+++ b/tests/auto/qplaintextedit/tst_qplaintextedit.cpp
@@ -150,6 +150,7 @@ private slots:
     void lineWrapProperty();
     void selectionChanged();
     void blockCountChanged();
+    void insertAndScrollToBottom();
 
 private:
     void createSelection();
@@ -1504,5 +1505,22 @@ void tst_QPlainTextEdit::blockCountChanged()
 }
 
 
+void tst_QPlainTextEdit::insertAndScrollToBottom()
+{
+    ed->setPlainText("First Line");
+    ed->show();
+    QString text;
+    for(int i = 0; i < 2000; ++i) {
+        text += QLatin1String("this is another line of text to be appended. It is quite long and will probably wrap around, meaning the number of lines is larger than the number of blocks in the text.\n");
+    }
+    QTextCursor cursor = ed->textCursor();
+    cursor.beginEditBlock();
+    cursor.insertText(text);
+    cursor.endEditBlock();
+    ed->verticalScrollBar()->setValue(ed->verticalScrollBar()->maximum());
+    QCOMPARE(ed->verticalScrollBar()->value(), ed->verticalScrollBar()->maximum());
+}
+
+
 QTEST_MAIN(tst_QPlainTextEdit)
 #include "tst_qplaintextedit.moc"
diff --git a/tests/auto/qpluginloader/tst_qpluginloader.cpp b/tests/auto/qpluginloader/tst_qpluginloader.cpp
index 591ef5ee52..76c2f6e5b3 100644
--- a/tests/auto/qpluginloader/tst_qpluginloader.cpp
+++ b/tests/auto/qpluginloader/tst_qpluginloader.cpp
@@ -370,15 +370,15 @@ if (sizeof(void*) == 8) {
 
     QPluginLoader lib1(SRCDIR "elftest/corrupt1.elf64.so");
     QCOMPARE(lib1.load(), false);
-    QVERIFY(lib1.errorString().contains("not an ELF object"));
+    QVERIFY(lib1.errorString().contains("not a valid Qt plugin"));
 
     QPluginLoader lib2(SRCDIR "elftest/corrupt2.elf64.so");
     QCOMPARE(lib2.load(), false);
-    QVERIFY(lib2.errorString().contains("invalid"));
+    QVERIFY(lib2.errorString().contains("not a valid Qt plugin"));
 
     QPluginLoader lib3(SRCDIR "elftest/corrupt3.elf64.so");
     QCOMPARE(lib3.load(), false);
-    QVERIFY(lib3.errorString().contains("invalid"));
+    QVERIFY(lib3.errorString().contains("not a valid Qt plugin"));
 } else if (sizeof(void*) == 4) {
     QPluginLoader libW(SRCDIR "elftest/corrupt3.elf64.so");
     QCOMPARE(libW.load(), false);
diff --git a/tests/auto/qscriptengine/tst_qscriptengine.cpp b/tests/auto/qscriptengine/tst_qscriptengine.cpp
index bc4091d93f..7ba2be2aa3 100644
--- a/tests/auto/qscriptengine/tst_qscriptengine.cpp
+++ b/tests/auto/qscriptengine/tst_qscriptengine.cpp
@@ -5815,6 +5815,7 @@ void tst_QScriptEngine::dateConversionJSQt()
         QString qtUTCDateStr = qtDate.toUTC().toString(Qt::ISODate);
         QString jsUTCDateStr = jsDate.property("toISOString").call(jsDate).toString();
         jsUTCDateStr.chop(5); // get rid of milliseconds (".000Z")
+        jsUTCDateStr.append("Z"); // append the timezone specifier again
         if (qtUTCDateStr != jsUTCDateStr)
             QFAIL(qPrintable(jsDate.toString()));
         secs += 2*60*60;
@@ -5829,6 +5830,7 @@ void tst_QScriptEngine::dateConversionQtJS()
         QScriptValue jsDate = eng.newDate(qtDate);
         QString jsUTCDateStr = jsDate.property("toISOString").call(jsDate).toString();
         jsUTCDateStr.chop(5); // get rid of milliseconds (".000Z")
+        jsUTCDateStr.append("Z"); // append the timezone specifier again
         QString qtUTCDateStr = qtDate.toUTC().toString(Qt::ISODate);
         if (jsUTCDateStr != qtUTCDateStr)
             QFAIL(qPrintable(qtDate.toString()));
diff --git a/tests/benchmarks/declarative/script/tst_script.cpp b/tests/benchmarks/declarative/script/tst_script.cpp
index 2020a18440..b07ffa101b 100644
--- a/tests/benchmarks/declarative/script/tst_script.cpp
+++ b/tests/benchmarks/declarative/script/tst_script.cpp
@@ -70,6 +70,9 @@ private slots:
     void property_qobject();
     void property_qmlobject();
 
+    void setproperty_js();
+    void setproperty_qmlobject();
+
     void function_js();
     void function_cpp();
     void function_qobject();
@@ -108,12 +111,13 @@ inline QUrl TEST_FILE(const QString &filename)
 class TestObject : public QObject
 {
     Q_OBJECT
-    Q_PROPERTY(int x READ x)
+    Q_PROPERTY(int x READ x WRITE setX)
 
 public:
     TestObject(QObject *parent = 0);
 
     int x();
+    void setX(int x) { m_x = x; }
 
     void emitMySignal() { emit mySignal(); }
     void emitMySignalWithArgs(int n) { emit mySignalWithArgs(n); }
@@ -323,6 +327,49 @@ void tst_script::property_qmlobject()
     }
 }
 
+#define SETPROPERTY_PROGRAM \
+    "(function(testObject) { return (function() { " \
+    "    for (var ii = 0; ii < 10000; ++ii) { " \
+    "        testObject.x = ii; " \
+    "    } " \
+    "}); })"
+
+void tst_script::setproperty_js()
+{
+    QScriptEngine engine;
+
+    QScriptValue v = engine.newObject();
+    v.setProperty(QLatin1String("x"), 0);
+
+    QScriptValueList args;
+    args << v;
+    QScriptValue prog = engine.evaluate(SETPROPERTY_PROGRAM).call(engine.globalObject(), args);
+    prog.call();
+
+    QBENCHMARK {
+        prog.call();
+    }
+}
+
+void tst_script::setproperty_qmlobject()
+{
+    QDeclarativeEngine qmlengine;
+
+    QScriptEngine *engine = QDeclarativeEnginePrivate::getScriptEngine(&qmlengine);
+    TestObject to;
+
+    QScriptValue v = QDeclarativeEnginePrivate::get(&qmlengine)->objectClass->newQObject(&to);
+
+    QScriptValueList args;
+    args << v;
+    QScriptValue prog = engine->evaluate(SETPROPERTY_PROGRAM).call(engine->globalObject(), args);
+    prog.call();
+
+    QBENCHMARK {
+        prog.call();
+    }
+}
+
 #define FUNCTION_PROGRAM \
     "(function(testObject) { return (function() { " \
     "    var test = 0; " \
diff --git a/tests/benchmarks/gui/graphicsview/graphicsview.pro b/tests/benchmarks/gui/graphicsview/graphicsview.pro
index e4fed197e9..1509466728 100644
--- a/tests/benchmarks/gui/graphicsview/graphicsview.pro
+++ b/tests/benchmarks/gui/graphicsview/graphicsview.pro
@@ -3,6 +3,7 @@ SUBDIRS = \
         functional \
         qgraphicsanchorlayout \
         qgraphicsitem \
+        qgraphicslayout \
         qgraphicsscene \
         qgraphicsview \
         qgraphicswidget
diff --git a/tests/benchmarks/gui/graphicsview/qgraphicslayout/qgraphicslayout.pro b/tests/benchmarks/gui/graphicsview/qgraphicslayout/qgraphicslayout.pro
new file mode 100644
index 0000000000..19e2979d98
--- /dev/null
+++ b/tests/benchmarks/gui/graphicsview/qgraphicslayout/qgraphicslayout.pro
@@ -0,0 +1,6 @@
+load(qttest_p4)
+TEMPLATE = app
+TARGET = tst_bench_qgraphicslayout
+
+SOURCES += tst_qgraphicslayout.cpp
+
diff --git a/tests/benchmarks/gui/graphicsview/qgraphicslayout/tst_qgraphicslayout.cpp b/tests/benchmarks/gui/graphicsview/qgraphicslayout/tst_qgraphicslayout.cpp
new file mode 100644
index 0000000000..4bdcfb3ecf
--- /dev/null
+++ b/tests/benchmarks/gui/graphicsview/qgraphicslayout/tst_qgraphicslayout.cpp
@@ -0,0 +1,153 @@
+/****************************************************************************
+**
+** 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 test suite 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 <QtTest/QtTest>
+#include <QtGui/qgraphicslayout.h>
+#include <QtGui/qgraphicslinearlayout.h>
+#include <QtGui/qgraphicswidget.h>
+#include <QtGui/qgraphicsview.h>
+
+class tst_QGraphicsLayout : public QObject
+{
+    Q_OBJECT
+public:
+    tst_QGraphicsLayout() {}
+    ~tst_QGraphicsLayout() {}
+
+private slots:
+    void invalidate();
+};
+
+
+class RectWidget : public QGraphicsWidget
+{
+public:
+    RectWidget(QGraphicsItem *parent = 0, Qt::WindowFlags wFlags = 0) : QGraphicsWidget(parent, wFlags), setGeometryCalls(0) {}
+
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
+    {
+        Q_UNUSED(option);
+        Q_UNUSED(widget);
+        painter->drawRoundRect(rect());
+        painter->drawLine(rect().topLeft(), rect().bottomRight());
+        painter->drawLine(rect().bottomLeft(), rect().topRight());
+    }
+
+    void setGeometry(const QRectF &rect)
+    {
+        //qDebug() << "setGeometry():" << this->data(0).toString();
+        setGeometryCalls->insert(this, rect);
+        QGraphicsWidget::setGeometry(rect);
+    }
+
+    void callUpdateGeometry() {
+        QGraphicsWidget::updateGeometry();
+    }
+
+    QMap<RectWidget*, QRectF> *setGeometryCalls;
+};
+
+/**
+ * Test to see how much time is needed to resize all widgets in a
+ * layout-widget-layout-widget-.... hierarchy from the point where a
+ * leaf widget changes its size hint. (updateGeometry() is called).
+ *
+ * If you run the test for 4.7 you'll get some really high numbers, but
+ * that's because they also include painting (and possible processing of
+ * some other events).
+ */
+void tst_QGraphicsLayout::invalidate()
+{
+    QGraphicsLayout::setInstantInvalidatePropagation(true);
+    QGraphicsScene scene;
+    QGraphicsView *view = new QGraphicsView(&scene);
+    QMap<RectWidget*, QRectF> setGeometryCalls;
+
+    RectWidget *window = new RectWidget(0, Qt::Window);
+    window->setGeometryCalls = &setGeometryCalls;
+    window->setData(0, QString(QChar('a')));
+
+    scene.addItem(window);
+    RectWidget *leaf = 0;
+    const int depth = 100;
+    RectWidget *parent = window;
+    for (int i = 1; i < depth; ++i) {
+        QGraphicsLinearLayout *l = new QGraphicsLinearLayout(parent);
+        l->setContentsMargins(0,0,0,0);
+        RectWidget *child = new RectWidget;
+        child->setData(0, QString(QChar('a' + i)));
+        child->setGeometryCalls = &setGeometryCalls;
+        l->addItem(child);
+        parent = child;
+    }
+    leaf = parent;
+    leaf->setMinimumSize(QSizeF(1,1));
+
+    view->show();
+
+    QTest::qWaitForWindowShown(view);
+
+    // ...then measure...
+
+    int pass = 1;
+
+    // should be as small as possible, to reduce overhead of painting
+    QSizeF size(1, 1);
+    setGeometryCalls.clear();
+    QBENCHMARK {
+        leaf->setMinimumSize(size);
+        leaf->setMaximumSize(size);
+        while (setGeometryCalls.count() < depth) {
+            QApplication::sendPostedEvents();
+        }
+        // force a resize on each widget, this will ensure
+        // that each iteration will resize all 50 widgets
+        int w = int(size.width());
+        w^=2;
+        size.setWidth(w);
+    }
+    delete view;
+    QGraphicsLayout::setInstantInvalidatePropagation(false);
+}
+
+QTEST_MAIN(tst_QGraphicsLayout)
+
+#include "tst_qgraphicslayout.moc"
diff --git a/tests/manual/qgraphicslayout/flicker/flicker.pro b/tests/manual/qgraphicslayout/flicker/flicker.pro
new file mode 100644
index 0000000000..323a30f7bf
--- /dev/null
+++ b/tests/manual/qgraphicslayout/flicker/flicker.pro
@@ -0,0 +1,8 @@
+TEMPLATE = app
+TARGET =
+DEPENDPATH += .
+INCLUDEPATH += .
+
+# Input
+HEADERS += window.h
+SOURCES += main.cpp window.cpp
diff --git a/tests/manual/qgraphicslayout/flicker/main.cpp b/tests/manual/qgraphicslayout/flicker/main.cpp
new file mode 100644
index 0000000000..7e75c2bec6
--- /dev/null
+++ b/tests/manual/qgraphicslayout/flicker/main.cpp
@@ -0,0 +1,56 @@
+/****************************************************************************
+**
+** 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 test suite 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 <QtGui>
+#include <windows.h>
+#include "window.h"
+
+int main(int argc, char **argv)
+{
+    QApplication app(argc, argv);
+    Window *window = new Window();
+    window->resize(800, 600);
+
+    window->show();
+
+    return app.exec();
+
+}
diff --git a/tests/manual/qgraphicslayout/flicker/window.cpp b/tests/manual/qgraphicslayout/flicker/window.cpp
new file mode 100644
index 0000000000..ee4db3fa59
--- /dev/null
+++ b/tests/manual/qgraphicslayout/flicker/window.cpp
@@ -0,0 +1,73 @@
+/****************************************************************************
+**
+** 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 test suite 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 "window.h"
+
+void SlowWidget::setGeometry(const QRectF &rect)
+{
+    bool reiterate = false;
+    Statistics &stats = *m_stats;
+    if (stats.relayoutClicked) {
+        ++(stats.setGeometryTracker[this]);
+        ++stats.setGeometryCount;
+        qDebug() << "setGeometryCount:" << stats.setGeometryCount;
+        if (stats.setGeometryTracker.count() == m_window->m_depthSpinBox->value()) {
+            ++stats.currentBenchmarkIteration;
+            qDebug() << "currentBenchmarkIteration:" << stats.currentBenchmarkIteration;
+            if (stats.currentBenchmarkIteration == m_window->m_benchmarkIterationsSpinBox->value()) {
+                if (stats.output)
+                    stats.output->setText(tr("DONE. Elapsed: %1, setGeometryCount: %2").arg(stats.time.elapsed()).arg(stats.setGeometryCount));
+            } else {
+                reiterate = true;
+            }
+            stats.setGeometryTracker.clear();
+
+        }
+    }
+
+    QGraphicsWidget::setGeometry(rect);
+
+    if (reiterate) {
+        m_window->doAgain();
+        //QTimer::singleShot(0, m_window, SLOT(doAgain()));
+    }
+}
+
diff --git a/tests/manual/qgraphicslayout/flicker/window.h b/tests/manual/qgraphicslayout/flicker/window.h
new file mode 100644
index 0000000000..b4c42c058f
--- /dev/null
+++ b/tests/manual/qgraphicslayout/flicker/window.h
@@ -0,0 +1,284 @@
+/****************************************************************************
+**
+** 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 test suite 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 WINDOW_H
+#define WINDOW_H
+
+
+#include <QtGui>
+
+static void qSleep(int msec)
+{
+
+    struct Thread : public QThread
+    {
+        static void wait(int msec)
+        {
+            QThread::msleep(msec);
+        }
+    };
+    Thread::wait(msec);
+}
+
+struct Statistics {
+    Statistics() : output(0),
+        setGeometryCount(0), currentBenchmarkIteration(0), relayoutClicked(false), sleepMsecs(0)
+    {
+    }
+    QMap<QGraphicsWidget*, int> setGeometryTracker;
+    QTime time;
+    int setGeometryCount;
+    int sleepMsecs;
+    QLabel *output;
+    void sleep()
+    {
+        qSleep(sleepMsecs);
+    }
+    int currentBenchmarkIteration;
+    bool relayoutClicked;
+
+};
+
+
+class Window;
+
+class SlowWidget : public QGraphicsWidget {
+public:
+    SlowWidget(QGraphicsWidget *w = 0, Qt::WindowFlags wFlags = 0) : QGraphicsWidget(w, wFlags)
+    {
+        m_window = 0;
+    }
+
+    void setStats(Statistics *stats)
+    {
+        m_stats = stats;
+    }
+
+    void setWindow(Window *window)
+    {
+        m_window = window;
+    }
+
+    void setGeometry(const QRectF &rect);
+
+    bool event(QEvent *e)
+    {
+        if (e->type() == QEvent::LayoutRequest) {
+            if (m_stats->sleepMsecs > 0) {
+                m_stats->sleep();
+                qDebug("sleep %d ms\n", m_stats->sleepMsecs);
+            }
+        }
+        return QGraphicsWidget::event(e);
+    }
+
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
+    {
+        Q_UNUSED(option);
+        Q_UNUSED(widget);
+        painter->setBrush(m_brush);
+        painter->drawRoundRect(rect());
+        painter->drawLine(rect().topLeft(), rect().bottomRight());
+        painter->drawLine(rect().bottomLeft(), rect().topRight());
+    }
+
+    void setBrush(const QBrush &brush)
+    {
+        m_brush = brush;
+    }
+private:
+    QBrush m_brush;
+    Statistics *m_stats;
+    Window *m_window;
+};
+
+class Window : public QWidget {
+    Q_OBJECT
+public:
+    Window() : QWidget()
+    {
+        QGraphicsView *m_view = new QGraphicsView(&scene);
+
+        m_window = 0;
+        m_leaf = 0;
+
+        m_button = new QPushButton(tr("Relayout"));
+        m_button->setObjectName("button");
+
+        m_sleepLabel = new QLabel(tr("Sleep:"));
+        m_sleepSpinBox = new QSpinBox;
+        m_sleepSpinBox->setRange(0, 1000);
+        m_sleepSpinBox->setSingleStep(10);
+
+        m_depthLabel = new QLabel(tr("Depth:"));
+        m_depthSpinBox = new QSpinBox;
+        m_depthSpinBox->setObjectName("depthSpinBox");
+        m_depthSpinBox->setRange(1, 200);
+        m_depthSpinBox->setSingleStep(5);
+
+        m_benchmarkIterationsLabel = new QLabel(tr("Benchmark iterations"));
+        m_benchmarkIterationsSpinBox = new QSpinBox;
+        m_benchmarkIterationsSpinBox->setObjectName("benchmarkIterationsSpinBox");
+        m_benchmarkIterationsSpinBox->setRange(1, 1000);
+        m_benchmarkIterationsSpinBox->setValue(41);
+        m_benchmarkIterationsSpinBox->setSingleStep(10);
+
+        m_instantCheckBox = new QCheckBox(tr("Instant propagation"));
+        m_instantCheckBox->setObjectName("instantPropagationCheckbox");
+        QGraphicsLayout::setInstantInvalidatePropagation(true);
+        m_instantCheckBox->setChecked(QGraphicsLayout::instantInvalidatePropagation());
+
+        m_resultLabel = new QLabel(tr("Press relayout to start test"));
+
+        QHBoxLayout *hbox = new QHBoxLayout;
+        hbox->addWidget(m_sleepLabel);
+        hbox->addWidget(m_sleepSpinBox);
+        hbox->addWidget(m_depthLabel);
+        hbox->addWidget(m_depthSpinBox);
+        hbox->addWidget(m_benchmarkIterationsLabel);
+        hbox->addWidget(m_benchmarkIterationsSpinBox);
+        hbox->addWidget(m_instantCheckBox);
+        hbox->addWidget(m_resultLabel);
+        hbox->addStretch();
+        hbox->addWidget(m_button);
+
+        QVBoxLayout *vbox = new QVBoxLayout;
+        vbox->addWidget(m_view);
+        vbox->addLayout(hbox);
+        setLayout(vbox);
+
+        metaObject()->connectSlotsByName(this);
+
+        m_depthSpinBox->setValue(20);   // triggers purposedly on_depthSpinBox_valueChanged
+    }
+
+private slots:
+    void on_depthSpinBox_valueChanged(int value)
+    {
+        m_stats.relayoutClicked = false;
+        if (m_window) {
+            QApplication::processEvents();
+            delete m_window;
+        }
+        m_window = new SlowWidget(0, Qt::Window);
+        m_window->setStats(&m_stats);
+        m_window->setWindow(this);
+        QColor col(Qt::black);
+        m_window->setBrush(col);
+        scene.addItem(m_window);
+        m_leaf = 0;
+        const int depth = value;
+        SlowWidget *parent = m_window;
+        for (int i = 1; i < depth; ++i) {
+            QGraphicsLinearLayout *l = new QGraphicsLinearLayout(parent);
+            l->setContentsMargins(2,2,2,2);
+            SlowWidget *child = new SlowWidget;
+            QColor col;
+            col.setHsl(0, 0, 255*i/(depth - 1));
+            child->setBrush(col);
+            child->setStats(&m_stats);
+            child->setWindow(this);
+            l->addItem(child);
+            parent = child;
+        }
+        m_leaf = parent;
+    }
+
+    void on_button_clicked(bool /*check = false*/)
+    {
+        m_stats.relayoutClicked = true;
+        if (m_leaf) {
+            QSizeF sz = m_leaf->size();
+            int w = int(sz.width());
+            w^=16;
+            sz = QSizeF(w,w);
+            m_stats.output = m_resultLabel;
+            m_stats.output->setText(QString("wait..."));
+            m_stats.setGeometryCount = 0;
+            m_stats.setGeometryTracker.clear();
+            m_stats.sleepMsecs = m_sleepSpinBox->value();
+            m_stats.time.start();
+            m_stats.currentBenchmarkIteration = 0;
+            m_leaf->setMinimumSize(sz);
+            m_leaf->setMaximumSize(sz);
+        }
+    }
+
+    void on_instantPropagationCheckbox_toggled(bool checked)
+    {
+        QGraphicsLayout::setInstantInvalidatePropagation(checked);
+    }
+
+public slots:
+    void doAgain()
+    {
+        if (m_leaf) {
+            QSizeF sz = m_leaf->size();
+            int w = int(sz.width());
+            w^=16;
+            sz = QSizeF(w,w);
+            m_leaf->setMinimumSize(sz);
+            m_leaf->setMaximumSize(sz);
+        }
+    }
+
+private:
+public:
+    QGraphicsScene scene;
+    QGraphicsView *m_view;
+    QPushButton *m_button;
+    QLabel *m_sleepLabel;
+    QSpinBox *m_sleepSpinBox;
+    QLabel *m_depthLabel;
+    QSpinBox *m_depthSpinBox;
+    QLabel *m_benchmarkIterationsLabel;
+    QSpinBox *m_benchmarkIterationsSpinBox;
+    QCheckBox *m_instantCheckBox;
+    QLabel *m_resultLabel;
+    QGraphicsWidget *m_leaf;
+    SlowWidget *m_window;
+    Statistics m_stats;
+
+
+};
+
+
+#endif //WINDOW_H
diff --git a/tools/configure/configure.pro b/tools/configure/configure.pro
index 124564667c..c2f1b6576d 100644
--- a/tools/configure/configure.pro
+++ b/tools/configure/configure.pro
@@ -79,6 +79,8 @@ SOURCES  = main.cpp configureapp.cpp environment.cpp tools.cpp \
            $$QT_SOURCE_TREE/src/corelib/tools/qhash.cpp \
            $$QT_SOURCE_TREE/src/corelib/tools/qlist.cpp \
            $$QT_SOURCE_TREE/src/corelib/tools/qlocale.cpp \
+           $$QT_SOURCE_TREE/src/corelib/tools/qlocale_win.cpp \
+           $$QT_SOURCE_TREE/src/corelib/tools/qlocale_tools.cpp \
            $$QT_SOURCE_TREE/src/corelib/tools/qvector.cpp \
            $$QT_SOURCE_TREE/src/corelib/codecs/qutfcodec.cpp \
            $$QT_SOURCE_TREE/src/corelib/codecs/qtextcodec.cpp \
diff --git a/tools/configure/configureapp.cpp b/tools/configure/configureapp.cpp
index 494ea52ec5..47e2ef9969 100644
--- a/tools/configure/configureapp.cpp
+++ b/tools/configure/configureapp.cpp
@@ -3216,8 +3216,6 @@ void Configure::generateConfigfiles()
 
         if (dictionary.contains("XQMAKESPEC") && dictionary["XQMAKESPEC"].startsWith("symbian")) {
             // These features are not ported to Symbian (yet)
-            qconfigList += "QT_NO_CONCURRENT";
-            qconfigList += "QT_NO_QFUTURE";
             qconfigList += "QT_NO_CRASHHANDLER";
             qconfigList += "QT_NO_PRINTER";
             qconfigList += "QT_NO_SYSTEMTRAYICON";
diff --git a/tools/qdoc3/codemarker.h b/tools/qdoc3/codemarker.h
index 21bc31f68a..00660e7aa4 100644
--- a/tools/qdoc3/codemarker.h
+++ b/tools/qdoc3/codemarker.h
@@ -165,10 +165,11 @@ class CodeMarker
     static const Node *nodeForString(const QString& string);
     static QString stringForNode(const Node *node);
 
+    QString typified(const QString &string);
+
  protected:
     virtual QString sortName(const Node *node);
     QString protect(const QString &string);
-    QString typified(const QString &string);
     QString taggedNode(const Node* node);
 #ifdef QDOC_QML
     QString taggedQmlNode(const Node* node);
diff --git a/tools/qdoc3/config.cpp b/tools/qdoc3/config.cpp
index 838f6ac205..eaec327225 100644
--- a/tools/qdoc3/config.cpp
+++ b/tools/qdoc3/config.cpp
@@ -48,7 +48,7 @@
 #include <QFile>
 #include <QTemporaryFile>
 #include <QTextStream>
-
+#include <qdebug.h>
 #include "config.h"
 #include <stdlib.h>
 
@@ -175,6 +175,7 @@ Config::Config(const QString& programName)
 }
 
 /*!
+  The destructor has nothing special to do.
  */
 Config::~Config()
 {
@@ -202,6 +203,30 @@ void Config::load(const QString& fileName)
 }
 
 /*!
+  Writes the qdoc configuration data to the named file.
+  The previous contents of the file are overwritten.
+ */
+void Config::unload(const QString& fileName)
+{
+    
+    QStringMultiMap::ConstIterator v = stringValueMap.begin();
+    while (v != stringValueMap.end()) {
+        qDebug() << v.key() << " = " << v.value();
+#if 0        
+        if (v.key().startsWith(varDot)) {
+            QString subVar = v.key().mid(varDot.length());
+            int dot = subVar.indexOf(QLatin1Char('.'));
+            if (dot != -1)
+                subVar.truncate(dot);
+            t.insert(subVar,v.value());
+        }
+#endif
+        ++v;
+    }
+    qDebug() << "fileName:" << fileName;
+}
+
+/*!
   Joins all the strings in \a values into a single string with the
   individual \a values separated by ' '. Then it inserts the result
   into the string list map with \a var as the key.
diff --git a/tools/qdoc3/config.h b/tools/qdoc3/config.h
index 8e19ed23d0..94f0060be5 100644
--- a/tools/qdoc3/config.h
+++ b/tools/qdoc3/config.h
@@ -63,6 +63,7 @@ class Config
     ~Config();
 
     void load(const QString& fileName);
+    void unload(const QString& fileName);
     void setStringList(const QString& var, const QStringList& values);
 
     const QString& programName() const { return prog; }
diff --git a/tools/qdoc3/ditaxmlgenerator.cpp b/tools/qdoc3/ditaxmlgenerator.cpp
index 69afde9e9f..5f44cd8363 100644
--- a/tools/qdoc3/ditaxmlgenerator.cpp
+++ b/tools/qdoc3/ditaxmlgenerator.cpp
@@ -92,6 +92,7 @@ QString DitaXmlGenerator::ditaTags[] =
         "apiDesc",
         "APIMap",
         "apiName",
+        "apiRelation",
         "audience",
         "author",
         "b",
@@ -284,14 +285,15 @@ void DitaXmlGenerator::writeCharacters(const QString& text)
   with the \a href attribute and the \a text.
  */
 void DitaXmlGenerator::addLink(const QString& href,
-                               const QStringRef& text)
+                               const QStringRef& text,
+                               DitaTag t)
 {
     if (!href.isEmpty()) {
-        writeStartTag(DT_xref);
+        writeStartTag(t);
         // formathtml
         xmlWriter().writeAttribute("href", href);
         writeCharacters(text.toString());
-        writeEndTag(); // </xref>
+        writeEndTag(); // </t>
     }
     else {
         writeCharacters(text.toString());
@@ -767,6 +769,7 @@ int DitaXmlGenerator::generateAtom(const Atom *atom,
     case Atom::Code:
         {
             writeStartTag(DT_codeblock);
+            xmlWriter().writeAttribute("outputclass","cpp");
             QString chars = trimmedTrailing(atom->string()); 
             writeText(chars, marker, relative);
             writeEndTag(); // </codeblock>
@@ -774,6 +777,7 @@ int DitaXmlGenerator::generateAtom(const Atom *atom,
 	break;
     case Atom::Qml:
         writeStartTag(DT_codeblock);
+        xmlWriter().writeAttribute("outputclass","qml");
         writeText(trimmedTrailing(atom->string()), marker, relative);
         writeEndTag(); // </codeblock>
 	break;
@@ -1718,7 +1722,7 @@ DitaXmlGenerator::generateClassLikeNode(const InnerNode* inner, CodeMarker* mark
          */
         generateHeader(inner, fullTitle);
         generateBrief(inner, marker); // <shortdesc>
-        writeProlog(inner,marker);
+        writeProlog(inner);
             
         writeStartTag(DT_cxxClassDetail);
         writeStartTag(DT_cxxClassDefinition);
@@ -1838,7 +1842,7 @@ DitaXmlGenerator::generateClassLikeNode(const InnerNode* inner, CodeMarker* mark
 
         generateHeader(inner, fullTitle);
         generateBrief(inner, marker); // <shortdesc>
-        writeProlog(inner,marker);
+        writeProlog(inner);
     
         writeStartTag(DT_cxxClassDetail);
         writeStartTag(DT_cxxClassDefinition);
@@ -1974,7 +1978,7 @@ DitaXmlGenerator::generateClassLikeNode(const InnerNode* inner, CodeMarker* mark
          */
         generateHeader(inner, fullTitle);
         generateBrief(inner, marker); // <shortdesc>
-        writeProlog(inner,marker);
+        writeProlog(inner);
 
         writeStartTag(DT_cxxClassDetail);
         enterApiDesc(QString(),title);
@@ -2093,7 +2097,7 @@ DitaXmlGenerator::generateClassLikeNode(const InnerNode* inner, CodeMarker* mark
 
         generateHeader(inner, fullTitle);
         generateBrief(inner, marker); // <shortdesc>
-        writeProlog(inner,marker);
+        writeProlog(inner);
 
         writeStartTag(DT_cxxClassDetail);
         enterApiDesc(QString(),title);
@@ -2195,7 +2199,7 @@ void DitaXmlGenerator::generateFakeNode(const FakeNode* fake, CodeMarker* marker
 
     generateHeader(fake, fullTitle);
     generateBrief(fake, marker); // <shortdesc>
-    writeProlog(fake, marker);
+    writeProlog(fake);
 
     writeStartTag(DT_body);
     enterSection(QString(),QString());
@@ -4712,7 +4716,7 @@ void DitaXmlGenerator::writeLocation(const Node* n)
   Write the <cxxFunction> elements.
  */
 void DitaXmlGenerator::writeFunctions(const Section& s, 
-                                      const Node* n, 
+                                      const InnerNode* parent, 
                                       CodeMarker* marker,
                                       const QString& attribute)
 {
@@ -4775,7 +4779,7 @@ void DitaXmlGenerator::writeFunctions(const Section& s,
                 }
             }
             
-            if (fn->name() == n->name()) {
+            if (fn->name() == parent->name()) {
                 writeStartTag(DT_cxxFunctionConstructor);
                 xmlWriter().writeAttribute("name","constructor");
                 xmlWriter().writeAttribute("value","constructor");
@@ -4789,7 +4793,8 @@ void DitaXmlGenerator::writeFunctions(const Section& s,
             }
             else {
                 writeStartTag(DT_cxxFunctionDeclaredType);
-                writeCharacters(fn->returnType());
+                QString src = marker->typified(fn->returnType());
+                replaceTypesWithLinks(fn,parent,marker,src);
                 writeEndTag(); // <cxxFunctionDeclaredType>
             }
 
@@ -4825,7 +4830,7 @@ void DitaXmlGenerator::writeFunctions(const Section& s,
                     writeEndTag(); // </cxxFunctionReimplemented>
                 }
             }
-            writeParameters(fn);
+            writeParameters(fn,parent,marker);
             writeLocation(fn);
             writeEndTag(); // <cxxFunctionDefinition>
 
@@ -4846,10 +4851,51 @@ void DitaXmlGenerator::writeFunctions(const Section& s,
     }
 }
 
+static const QString typeTag("type");
+static const QChar charLangle = '<';
+static const QChar charAt = '@';
+
+/*!
+  This function replaces class and enum names with <apiRelation>
+  elements, i.e. links.
+ */
+void DitaXmlGenerator::replaceTypesWithLinks(const Node* n,
+                                             const InnerNode* parent,
+                                             CodeMarker* marker,
+                                             QString& src)
+{
+    QStringRef arg;
+    QStringRef par1;
+    int srcSize = src.size();
+    QString text;
+    for (int i=0; i<srcSize;) {
+        if (src.at(i) == charLangle && src.at(i+1) == charAt) {
+            if (!text.isEmpty()) {
+                writeCharacters(text);
+                text.clear();
+            }
+            i += 2;
+            if (parseArg(src, typeTag, &i, srcSize, &arg, &par1)) {
+                const Node* tn = marker->resolveTarget(arg.toString(), myTree, parent, n);
+                addLink(linkForNode(tn,parent),arg,DT_apiRelation);
+            }
+        }
+        else {
+            text += src.at(i++);
+        }
+    }
+    if (!text.isEmpty()) {
+        writeCharacters(text);
+        text.clear();
+    }
+}
+
 /*!
   This function writes the <cxxFunctionParameters> element.
  */
-void DitaXmlGenerator::writeParameters(const FunctionNode* fn)
+void DitaXmlGenerator::writeParameters(const FunctionNode* fn,
+                                       const InnerNode* parent,
+                                       CodeMarker* marker)
 {
     const QList<Parameter>& parameters = fn->parameters();
     if (!parameters.isEmpty()) {
@@ -4858,7 +4904,9 @@ void DitaXmlGenerator::writeParameters(const FunctionNode* fn)
         while (p != parameters.end()) {
             writeStartTag(DT_cxxFunctionParameter);
             writeStartTag(DT_cxxFunctionParameterDeclaredType);
-            writeCharacters((*p).leftType());
+            QString src = marker->typified((*p).leftType());
+            replaceTypesWithLinks(fn,parent,marker,src);
+            //writeCharacters((*p).leftType());
             if (!(*p).rightType().isEmpty())
                 writeCharacters((*p).rightType());
             writeEndTag(); // <cxxFunctionParameterDeclaredType>
@@ -5695,7 +5743,7 @@ QString DitaXmlGenerator::metadataDefault(DitaTag t) const
   
  */
 void
-DitaXmlGenerator::writeProlog(const InnerNode* inner, CodeMarker* marker)
+DitaXmlGenerator::writeProlog(const InnerNode* inner)
 {
     if (!inner)
         return;
diff --git a/tools/qdoc3/ditaxmlgenerator.h b/tools/qdoc3/ditaxmlgenerator.h
index ffca234fd9..0044eff5a7 100644
--- a/tools/qdoc3/ditaxmlgenerator.h
+++ b/tools/qdoc3/ditaxmlgenerator.h
@@ -87,6 +87,7 @@ class DitaXmlGenerator : public PageGenerator
         DT_apiDesc,
         DT_APIMap,
         DT_apiName,
+        DT_apiRelation,
         DT_audience,
         DT_author,
         DT_b,
@@ -292,11 +293,15 @@ class DitaXmlGenerator : public PageGenerator
     void writeDerivations(const ClassNode* cn, CodeMarker* marker);
     void writeLocation(const Node* n);
     void writeFunctions(const Section& s, 
-                        const Node* n, 
+                        const InnerNode* parent, 
                         CodeMarker* marker,
                         const QString& attribute = QString());
     void writeNestedClasses(const Section& s, const Node* n);
-    void writeParameters(const FunctionNode* fn);
+    void replaceTypesWithLinks(const Node* n,
+                               const InnerNode* parent,
+                               CodeMarker* marker,
+                               QString& src);
+    void writeParameters(const FunctionNode* fn, const InnerNode* parent, CodeMarker* marker);
     void writeEnumerations(const Section& s, 
                            CodeMarker* marker,
                            const QString& attribute = QString());
@@ -315,7 +320,7 @@ class DitaXmlGenerator : public PageGenerator
     void writePropertyParameter(const QString& tag, const NodeList& nlist);
     void writeRelatedLinks(const FakeNode* fake, CodeMarker* marker);
     void writeLink(const Node* node, const QString& tex, const QString& role);
-    void writeProlog(const InnerNode* inner, CodeMarker* marker);
+    void writeProlog(const InnerNode* inner);
     bool writeMetadataElement(const InnerNode* inner, 
                               DitaXmlGenerator::DitaTag t, 
                               bool force=true);
@@ -438,7 +443,7 @@ class DitaXmlGenerator : public PageGenerator
     virtual void generateInnerNode(const InnerNode* node);
     QXmlStreamWriter& xmlWriter();
     void writeApiDesc(const Node* node, CodeMarker* marker, const QString& title);
-    void addLink(const QString& href, const QStringRef& text);
+    void addLink(const QString& href, const QStringRef& text, DitaTag t = DT_xref);
     void writeDitaMap();
     void writeStartTag(DitaTag t);
     void writeEndTag(DitaTag t=DT_NONE);
diff --git a/tools/qdoc3/doc/corefeatures.qdoc b/tools/qdoc3/doc/corefeatures.qdoc
new file mode 100644
index 0000000000..ee579cf2e7
--- /dev/null
+++ b/tools/qdoc3/doc/corefeatures.qdoc
@@ -0,0 +1,35 @@
+/****************************************************************************
+**
+** 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 documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** 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 Free Documentation License
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of this
+** file.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \page corefeatures.html
+    \title Core Features
+
+    \input examples/signalandslots.qdocinc
+    \input examples/objectmodel.qdocinc
+    \input examples/layoutmanagement.qdocinc
+*/
diff --git a/tools/qdoc3/htmlgenerator.cpp b/tools/qdoc3/htmlgenerator.cpp
index 88bc3e2fc2..a6cf6465f0 100644
--- a/tools/qdoc3/htmlgenerator.cpp
+++ b/tools/qdoc3/htmlgenerator.cpp
@@ -93,104 +93,6 @@ static QRegExp typeTag("(<@(type|headerfile|func)(?: +[^>]*)?>)(.*)(</@\\2>)");
 static QRegExp spanTag("</@(?:comment|preprocessor|string|char|number|op|type|name|keyword)>");
 static QRegExp unknownTag("</?@[^>]*>");
 
-bool parseArg(const QString &src,
-              const QString &tag,
-              int *pos,
-              int n,
-              QStringRef *contents,
-              QStringRef *par1 = 0,
-              bool debug = false)
-{
-#define SKIP_CHAR(c) \
-    if (debug) \
-        qDebug() << "looking for " << c << " at " << QString(src.data() + i, n - i); \
-    if (i >= n || src[i] != c) { \
-        if (debug) \
-            qDebug() << " char '" << c << "' not found"; \
-        return false; \
-    } \
-    ++i;
-
-
-#define SKIP_SPACE \
-    while (i < n && src[i] == ' ') \
-        ++i;
-
-    int i = *pos;
-    int j = i;
-
-    // assume "<@" has been parsed outside
-    //SKIP_CHAR('<');
-    //SKIP_CHAR('@');
-
-    if (tag != QStringRef(&src, i, tag.length())) {
-        if (0 && debug)
-            qDebug() << "tag " << tag << " not found at " << i;
-        return false;
-    }
-
-    if (debug)
-        qDebug() << "haystack:" << src << "needle:" << tag << "i:" <<i;
-
-    // skip tag
-    i += tag.length();
-
-    // parse stuff like:  linkTag("(<@link node=\"([^\"]+)\">).*(</@link>)");
-    if (par1) {
-        SKIP_SPACE;
-        // read parameter name
-        j = i;
-        while (i < n && src[i].isLetter())
-            ++i;
-        if (src[i] == '=') {
-            if (debug)
-                qDebug() << "read parameter" << QString(src.data() + j, i - j);
-            SKIP_CHAR('=');
-            SKIP_CHAR('"');
-            // skip parameter name
-            j = i;
-            while (i < n && src[i] != '"')
-                ++i;
-            *par1 = QStringRef(&src, j, i - j);
-            SKIP_CHAR('"');
-            SKIP_SPACE;
-        } else {
-            if (debug)
-                qDebug() << "no optional parameter found";
-        }
-    }
-    SKIP_SPACE;
-    SKIP_CHAR('>');
-
-    // find contents up to closing "</@tag>
-    j = i;
-    for (; true; ++i) {
-        if (i + 4 + tag.length() > n)
-            return false;
-        if (src[i] != '<')
-            continue;
-        if (src[i + 1] != '/')
-            continue;
-        if (src[i + 2] != '@')
-            continue;
-        if (tag != QStringRef(&src, i + 3, tag.length()))
-            continue;
-        if (src[i + 3 + tag.length()] != '>')
-            continue;
-        break;
-    }
-
-    *contents = QStringRef(&src, j, i - j);
-
-    i += tag.length() + 4;
-
-    *pos = i;
-    if (debug)
-        qDebug() << " tag " << tag << " found: pos now: " << i;
-    return true;
-#undef SKIP_CHAR
-}
-
 static void addLink(const QString &linkTarget,
                     const QStringRef &nestedStuff,
                     QString *res)
@@ -2849,7 +2751,7 @@ QString HtmlGenerator::highlightedCode(const QString& markedCode,
     static const QString headerTag("headerfile");
     static const QString funcTag("func");
     static const QString linkTag("link");
-    
+
     // replace all <@link> tags: "(<@link node=\"([^\"]+)\">).*(</@link>)"
     bool done = false;
     for (int i = 0, srcSize = src.size(); i < srcSize;) {
@@ -2884,6 +2786,7 @@ QString HtmlGenerator::highlightedCode(const QString& markedCode,
         if (src.at(i) == charLangle && src.at(i + 1) == charAt) {
             i += 2;
             if (parseArg(src, funcTag, &i, srcSize, &arg, &par1)) {
+
                 const Node* n = marker->resolveTarget(par1.toString(),
                                                       myTree,
                                                       relative);
diff --git a/tools/qdoc3/pagegenerator.cpp b/tools/qdoc3/pagegenerator.cpp
index d5564f73b7..d331d41a83 100644
--- a/tools/qdoc3/pagegenerator.cpp
+++ b/tools/qdoc3/pagegenerator.cpp
@@ -70,12 +70,6 @@ PageGenerator::~PageGenerator()
 	endSubPage();
 }
 
-static QRegExp linkTag("(<@link node=\"([^\"]+)\">).*(</@link>)");
-static QRegExp funcTag("(<@func target=\"([^\"]*)\">)(.*)(</@func>)");
-static QRegExp typeTag("(<@(type|headerfile|func)(?: +[^>]*)?>)(.*)(</@\\2>)");
-static QRegExp spanTag("</@(?:comment|preprocessor|string|char)>");
-static QRegExp unknownTag("</?@[^>]*>");
-
 bool PageGenerator::parseArg(const QString& src,
                              const QString& tag,
                              int* pos,
diff --git a/tools/qml/loggerwidget.cpp b/tools/qml/loggerwidget.cpp
index 3f2337a622..9a07402eb0 100644
--- a/tools/qml/loggerwidget.cpp
+++ b/tools/qml/loggerwidget.cpp
@@ -139,10 +139,10 @@ QAction *LoggerWidget::showAction()
 void LoggerWidget::readSettings()
 {
     QSettings settings;
-    QString warningsPreferences = settings.value("warnings", "hide").toString();
-    if (warningsPreferences == "show") {
+    QString warningsPreferences = settings.value(QLatin1String("warnings"), QLatin1String("hide")).toString();
+    if (warningsPreferences == QLatin1String("show")) {
         m_visibility = ShowWarnings;
-    } else if (warningsPreferences == "hide") {
+    } else if (warningsPreferences == QLatin1String("hide")) {
         m_visibility = HideWarnings;
     } else {
         m_visibility = AutoShowWarnings;
@@ -154,15 +154,15 @@ void LoggerWidget::saveSettings()
     if (m_visibilityOrigin != SettingsOrigin)
         return;
 
-    QString value = "autoShow";
+    QString value = QLatin1String("autoShow");
     if (defaultVisibility() == ShowWarnings) {
-        value = "show";
+        value = QLatin1String("show");
     } else if (defaultVisibility() == HideWarnings) {
-        value = "hide";
+        value = QLatin1String("hide");
     }
 
     QSettings settings;
-    settings.setValue("warnings", value);
+    settings.setValue(QLatin1String("warnings"), value);
 }
 
 void LoggerWidget::warningsPreferenceChanged(QAction *action)
diff --git a/tools/qml/main.cpp b/tools/qml/main.cpp
index b2c7f4f730..24a4940915 100644
--- a/tools/qml/main.cpp
+++ b/tools/qml/main.cpp
@@ -50,6 +50,7 @@
 #include <QDebug>
 #include <QMessageBox>
 #include <QAtomicInt>
+#include <QLibraryInfo>
 #include "qdeclarativetester.h"
 #include <private/qdeclarativedebughelper_p.h>
 
@@ -67,7 +68,7 @@ void exitApp(int i)
     // Debugging output is not visible by default on Windows -
     // therefore show modal dialog with errors instead.
     if (!warnings.isEmpty()) {
-        QMessageBox::warning(0, QApplication::tr("Qt QML Viewer"), warnings);
+        QMessageBox::warning(0, QApplication::translate("QDeclarativeViewer", "Qt QML Viewer"), warnings);
     }
 #endif
     exit(i);
@@ -123,7 +124,7 @@ void myMessageOutput(QtMsgType type, const char *msg)
 static QDeclarativeViewer* globalViewer = 0;
 
 // The qml file that is shown if the user didn't specify a QML file
-QString initialFile = "qrc:/startup/startup.qml";
+QString initialFile = QLatin1String("qrc:/startup/startup.qml");
 
 void usage()
 {
@@ -156,7 +157,9 @@ void usage()
     qWarning("  -P <directory> ........................... prepend to the plugin search path");
 #if defined(Q_WS_MAC)
     qWarning("  -no-opengl ............................... don't use a QGLWidget for the viewport");
+    qWarning("  -opengl .................................. use a QGLWidget for the viewport (default)");
 #else
+    qWarning("  -no-opengl ............................... don't use a QGLWidget for the viewport (default)");
     qWarning("  -opengl .................................. use a QGLWidget for the viewport");
 #endif
     qWarning("  -script <path> ........................... set the script to use");
@@ -197,7 +200,7 @@ struct ViewerOptions
           fps(0.0),
           autorecord_from(0),
           autorecord_to(0),
-          dither("none"),
+          dither(QLatin1String("none")),
           runScript(false),
           devkeys(false),
           cache(0),
@@ -334,57 +337,54 @@ static void parseCommandLineOptions(const QStringList &arguments)
     for (int i = 1; i < arguments.count(); ++i) {
         bool lastArg = (i == arguments.count() - 1);
         QString arg = arguments.at(i);
-        if (arg == "-frameless") {
+        if (arg == QLatin1String("-frameless")) {
             opts.frameless = true;
-        } else if (arg == "-maximized") {
+        } else if (arg == QLatin1String("-maximized")) {
             opts.maximized = true;
-        } else if (arg == "-fullscreen") {
+        } else if (arg == QLatin1String("-fullscreen")) {
             opts.fullScreen = true;
-        } else if (arg == "-stayontop") {
+        } else if (arg == QLatin1String("-stayontop")) {
             opts.stayOnTop = true;
-        } else if (arg == "-netcache") {
+        } else if (arg == QLatin1String("-netcache")) {
             if (lastArg) usage();
             opts.cache = arguments.at(++i).toInt();
-        } else if (arg == "-recordrate") {
+        } else if (arg == QLatin1String("-recordrate")) {
             if (lastArg) usage();
             opts.fps = arguments.at(++i).toDouble();
-        } else if (arg == "-recordfile") {
+        } else if (arg == QLatin1String("-recordfile")) {
             if (lastArg) usage();
             opts.recordfile = arguments.at(++i);
-        } else if (arg == "-record") {
+        } else if (arg == QLatin1String("-record")) {
             if (lastArg) usage();
             opts.recordargs << arguments.at(++i);
-        } else if (arg == "-recorddither") {
+        } else if (arg == QLatin1String("-recorddither")) {
             if (lastArg) usage();
             opts.dither = arguments.at(++i);
-        } else if (arg == "-autorecord") {
+        } else if (arg == QLatin1String("-autorecord")) {
             if (lastArg) usage();
             QString range = arguments.at(++i);
-            int dash = range.indexOf('-');
+            int dash = range.indexOf(QLatin1Char('-'));
             if (dash > 0)
                 opts.autorecord_from = range.left(dash).toInt();
             opts.autorecord_to = range.mid(dash+1).toInt();
-        } else if (arg == "-devicekeys") {
+        } else if (arg == QLatin1String("-devicekeys")) {
             opts.devkeys = true;
-        } else if (arg == "-dragthreshold") {
+        } else if (arg == QLatin1String("-dragthreshold")) {
             if (lastArg) usage();
             qApp->setStartDragDistance(arguments.at(++i).toInt());
         } else if (arg == QLatin1String("-v") || arg == QLatin1String("-version")) {
             qWarning("Qt QML Viewer version %s", QT_VERSION_STR);
             exitApp(0);
-        } else if (arg == "-translation") {
+        } else if (arg == QLatin1String("-translation")) {
             if (lastArg) usage();
             opts.translationFile = arguments.at(++i);
-#if defined(Q_WS_MAC)
-        } else if (arg == "-no-opengl") {
+        } else if (arg == QLatin1String("-no-opengl")) {
             opts.useGL = false;
-#else
-        } else if (arg == "-opengl") {
+        } else if (arg == QLatin1String("-opengl")) {
             opts.useGL = true;
-#endif
-        } else if (arg == "-qmlbrowser") {
+        } else if (arg == QLatin1String("-qmlbrowser")) {
             opts.useNativeFileBrowser = false;
-        } else if (arg == "-warnings") {
+        } else if (arg == QLatin1String("-warnings")) {
             if (lastArg) usage();
             QString warningsStr = arguments.at(++i);
             if (warningsStr == QLatin1String("show")) {
@@ -394,8 +394,8 @@ static void parseCommandLineOptions(const QStringList &arguments)
             } else {
                 usage();
             }
-        } else if (arg == "-I" || arg == "-L") {
-            if (arg == "-L")
+        } else if (arg == QLatin1String("-I") || arg == QLatin1String("-L")) {
+            if (arg == QLatin1String("-L"))
                 qWarning("-L option provided for compatibility only, use -I instead");
             if (lastArg) {
                 QDeclarativeEngine tmpEngine;
@@ -404,32 +404,32 @@ static void parseCommandLineOptions(const QStringList &arguments)
                 exitApp(0);
             }
             opts.imports << arguments.at(++i);
-        } else if (arg == "-P") {
+        } else if (arg == QLatin1String("-P")) {
             if (lastArg) usage();
             opts.plugins << arguments.at(++i);
-        } else if (arg == "-script") {
+        } else if (arg == QLatin1String("-script")) {
             if (lastArg) usage();
             opts.script = arguments.at(++i);
-        } else if (arg == "-scriptopts") {
+        } else if (arg == QLatin1String("-scriptopts")) {
             if (lastArg) usage();
             opts.scriptopts = arguments.at(++i);
-        } else if (arg == "-savescript") {
+        } else if (arg == QLatin1String("-savescript")) {
             if (lastArg) usage();
             opts.script = arguments.at(++i);
             opts.runScript = false;
-        } else if (arg == "-playscript") {
+        } else if (arg == QLatin1String("-playscript")) {
             if (lastArg) usage();
             opts.script = arguments.at(++i);
             opts.runScript = true;
-        } else if (arg == "-sizeviewtorootobject") {
+        } else if (arg == QLatin1String("-sizeviewtorootobject")) {
             opts.sizeToView = false;
-        } else if (arg == "-sizerootobjecttoview") {
+        } else if (arg == QLatin1String("-sizerootobjecttoview")) {
             opts.sizeToView = true;
-        } else if (arg == "-experimentalgestures") {
+        } else if (arg == QLatin1String("-experimentalgestures")) {
             opts.experimentalGestures = true;
-        } else if (!arg.startsWith('-')) {
+        } else if (!arg.startsWith(QLatin1Char('-'))) {
             fileNames.append(arg);
-        } else if (true || arg == "-help") {
+        } else if (true || arg == QLatin1String("-help")) {
             usage();
         }
     }
@@ -528,29 +528,41 @@ int main(int argc, char ** argv)
     //### default to using raster graphics backend for now
     bool gsSpecified = false;
     for (int i = 0; i < argc; ++i) {
-        QString arg = argv[i];
-        if (arg == "-graphicssystem") {
+        QString arg = QString::fromAscii(argv[i]);
+        if (arg == QLatin1String("-graphicssystem")) {
             gsSpecified = true;
             break;
         }
     }
 
     if (!gsSpecified)
-        QApplication::setGraphicsSystem("raster");
+        QApplication::setGraphicsSystem(QLatin1String("raster"));
 #endif
 
     QDeclarativeDebugHelper::enableDebugging();
 
     Application app(argc, argv);
-    app.setApplicationName("QtQmlViewer");
-    app.setOrganizationName("Nokia");
-    app.setOrganizationDomain("nokia.com");
+    app.setApplicationName(QLatin1String("QtQmlViewer"));
+    app.setOrganizationName(QLatin1String("Nokia"));
+    app.setOrganizationDomain(QLatin1String("nokia.com"));
 
     QDeclarativeViewer::registerTypes();
     QDeclarativeTester::registerTypes();
 
     parseCommandLineOptions(app.arguments());
 
+    QTranslator translator;
+    QTranslator qtTranslator;
+    QString sysLocale = QLocale::system().name();
+    if (translator.load(QLatin1String("qmlviewer_") + sysLocale, QLibraryInfo::location(QLibraryInfo::TranslationsPath))) {
+        app.installTranslator(&translator);
+        if (qtTranslator.load(QLatin1String("qt_") + sysLocale, QLibraryInfo::location(QLibraryInfo::TranslationsPath))) {
+            app.installTranslator(&qtTranslator);
+        } else {
+            app.removeTranslator(&translator);
+        }
+    }
+
     QTranslator qmlTranslator;
     if (!opts.translationFile.isEmpty()) {
         if (qmlTranslator.load(opts.translationFile)) {
diff --git a/tools/qml/proxysettings.cpp b/tools/qml/proxysettings.cpp
index c4dc087263..78963da9a6 100644
--- a/tools/qml/proxysettings.cpp
+++ b/tools/qml/proxysettings.cpp
@@ -54,17 +54,17 @@ ProxySettings::ProxySettings (QWidget * parent)
 
 #if !defined Q_WS_MAEMO_5
     // the onscreen keyboard can't cope with masks
-    proxyServerEdit->setInputMask ("000.000.000.000;_");
+    proxyServerEdit->setInputMask(QLatin1String("000.000.000.000;_"));
 #endif
     QIntValidator *validator = new QIntValidator (0, 9999, this);
-    proxyPortEdit->setValidator (validator);
+    proxyPortEdit->setValidator(validator);
 
     QSettings settings;
-    proxyCheckBox->setChecked (settings.value ("http_proxy/use", 0).toBool ());
-    proxyServerEdit->insert (settings.value ("http_proxy/hostname", "").toString ());
-    proxyPortEdit->insert (settings.value ("http_proxy/port", "80").toString ());
-    usernameEdit->insert (settings.value ("http_proxy/username", "").toString ());
-    passwordEdit->insert (settings.value ("http_proxy/password", "").toString ());
+    proxyCheckBox->setChecked(settings.value(QLatin1String("http_proxy/use"), 0).toBool());
+    proxyServerEdit->insert(settings.value(QLatin1String("http_proxy/hostname")).toString());
+    proxyPortEdit->insert(settings.value(QLatin1String("http_proxy/port"), QLatin1String("80")).toString ());
+    usernameEdit->insert(settings.value(QLatin1String("http_proxy/username")).toString ());
+    passwordEdit->insert(settings.value(QLatin1String("http_proxy/password")).toString ());
 }
 
 ProxySettings::~ProxySettings()
@@ -75,11 +75,11 @@ void ProxySettings::accept ()
 {
     QSettings settings;
 
-    settings.setValue ("http_proxy/use", proxyCheckBox->isChecked ());
-    settings.setValue ("http_proxy/hostname", proxyServerEdit->text ());
-    settings.setValue ("http_proxy/port", proxyPortEdit->text ());
-    settings.setValue ("http_proxy/username", usernameEdit->text ());
-    settings.setValue ("http_proxy/password", passwordEdit->text ());
+    settings.setValue(QLatin1String("http_proxy/use"), proxyCheckBox->isChecked());
+    settings.setValue(QLatin1String("http_proxy/hostname"), proxyServerEdit->text());
+    settings.setValue(QLatin1String("http_proxy/port"), proxyPortEdit->text());
+    settings.setValue(QLatin1String("http_proxy/username"), usernameEdit->text());
+    settings.setValue(QLatin1String("http_proxy/password"), passwordEdit->text());
 
     QDialog::accept ();
 }
@@ -89,13 +89,13 @@ QNetworkProxy ProxySettings::httpProxy ()
     QSettings settings;
     QNetworkProxy proxy;
 
-    bool proxyInUse = settings.value ("http_proxy/use", 0).toBool ();
+    bool proxyInUse = settings.value(QLatin1String("http_proxy/use"), 0).toBool();
     if (proxyInUse) {
         proxy.setType (QNetworkProxy::HttpProxy);
-        proxy.setHostName (settings.value ("http_proxy/hostname", "").toString ());// "192.168.220.5"
-        proxy.setPort (settings.value ("http_proxy/port", 80).toInt ());  // 8080
-        proxy.setUser (settings.value ("http_proxy/username", "").toString ());
-        proxy.setPassword (settings.value ("http_proxy/password", "").toString ());
+        proxy.setHostName (settings.value(QLatin1String("http_proxy/hostname")).toString());// "192.168.220.5"
+        proxy.setPort (settings.value(QLatin1String("http_proxy/port"), 80).toInt());  // 8080
+        proxy.setUser (settings.value(QLatin1String("http_proxy/username")).toString());
+        proxy.setPassword (settings.value(QLatin1String("http_proxy/password")).toString());
         //QNetworkProxy::setApplicationProxy (proxy);
     }
     else {
@@ -107,7 +107,7 @@ QNetworkProxy ProxySettings::httpProxy ()
 bool ProxySettings::httpProxyInUse()
 {
     QSettings settings;
-    return settings.value ("http_proxy/use", 0).toBool ();
+    return settings.value(QLatin1String("http_proxy/use"), 0).toBool();
 }
 
 QT_END_NAMESPACE
diff --git a/tools/qml/proxysettings_maemo5.ui b/tools/qml/proxysettings_maemo5.ui
index 83f0c2a9de..75875d835b 100644
--- a/tools/qml/proxysettings_maemo5.ui
+++ b/tools/qml/proxysettings_maemo5.ui
@@ -6,8 +6,8 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>449</width>
-    <height>164</height>
+    <width>447</width>
+    <height>162</height>
    </rect>
   </property>
   <property name="windowTitle">
@@ -88,7 +88,7 @@
       <item row="1" column="1">
        <widget class="QLineEdit" name="proxyPortEdit">
         <property name="text">
-         <string>8080</string>
+         <string notr="true">8080</string>
         </property>
        </widget>
       </item>
diff --git a/tools/qml/qdeclarativetester.cpp b/tools/qml/qdeclarativetester.cpp
index 11f81fc169..fa8af8f314 100644
--- a/tools/qml/qdeclarativetester.cpp
+++ b/tools/qml/qdeclarativetester.cpp
@@ -205,7 +205,7 @@ void QDeclarativeTester::save()
     QString filename = m_script + QLatin1String(".qml");
     QFileInfo filenameInfo(filename);
     QDir saveDir = filenameInfo.absoluteDir();
-    saveDir.mkpath(".");
+    saveDir.mkpath(QLatin1String("."));
 
     QFile file(filename);
     file.open(QIODevice::WriteOnly);
@@ -224,8 +224,8 @@ void QDeclarativeTester::save()
         if (!fe.hash.isEmpty()) {
             ts << "        hash: \"" << fe.hash.toHex() << "\"\n";
         } else if (!fe.image.isNull()) {
-            QString filename = filenameInfo.baseName() + "." + QString::number(imgCount) + ".png";
-            fe.image.save(m_script + "." + QString::number(imgCount) + ".png");
+            QString filename = filenameInfo.baseName() + QLatin1String(".") + QString::number(imgCount) + QLatin1String(".png");
+            fe.image.save(m_script + QLatin1String(".") + QString::number(imgCount) + QLatin1String(".png"));
             imgCount++;
             ts << "        image: \"" << filename << "\"\n";
         }
@@ -375,7 +375,7 @@ void QDeclarativeTester::updateCurrentTime(int msec)
                     imagefailure();
                 }
                 if (goodImage != img) {
-                    QString reject(frame->image().toLocalFile() + ".reject.png");
+                    QString reject(frame->image().toLocalFile() + QLatin1String(".reject.png"));
                     qWarning() << "QDeclarativeTester(" << m_script << "): Image mismatch.  Reject saved to:"
                                << reject;
                     img.save(reject);
@@ -393,7 +393,7 @@ void QDeclarativeTester::updateCurrentTime(int msec)
                                 }
                             }
                         }
-                        QString diff(frame->image().toLocalFile() + ".diff.png");
+                        QString diff(frame->image().toLocalFile() + QLatin1String(".diff.png"));
                         diffimg.save(diff);
                         qWarning().nospace() << "                    Diff (" << diffCount << " pixels differed) saved to: " << diff;
                     }
diff --git a/tools/qml/qml.pro b/tools/qml/qml.pro
index 84ebba828b..defc368220 100644
--- a/tools/qml/qml.pro
+++ b/tools/qml/qml.pro
@@ -10,6 +10,8 @@ INCLUDEPATH += ../../include/QtDeclarative
 INCLUDEPATH += ../../src/declarative/util
 INCLUDEPATH += ../../src/declarative/graphicsitems
 
+DEFINES += QT_NO_CAST_FROM_ASCII QT_NO_CAST_TO_ASCII
+
 target.path = $$[QT_INSTALL_BINS]
 INSTALLS += target
 
diff --git a/tools/qml/qmlruntime.cpp b/tools/qml/qmlruntime.cpp
index 36915d12bf..7422032fb5 100644
--- a/tools/qml/qmlruntime.cpp
+++ b/tools/qml/qmlruntime.cpp
@@ -265,7 +265,7 @@ public:
         hz->setValidator(new QDoubleValidator(hz));
 #endif
         for (int i=0; ffmpegprofiles[i].name; ++i) {
-            profile->addItem(ffmpegprofiles[i].name);
+            profile->addItem(QString::fromAscii(ffmpegprofiles[i].name));
         }
     }
 
@@ -273,9 +273,9 @@ public:
     {
         int i;
         for (i=0; ffmpegprofiles[i].args[0]; ++i) {
-            if (ffmpegprofiles[i].args == a) {
+            if (QString::fromAscii(ffmpegprofiles[i].args) == a) {
                 profile->setCurrentIndex(i);
-                args->setText(QLatin1String(ffmpegprofiles[i].args));
+                args->setText(QString::fromAscii(ffmpegprofiles[i].args));
                 return;
             }
         }
@@ -465,14 +465,14 @@ private:
             }
         }
         QSettings settings;
-        settings.setValue("Cookies",data);
+        settings.setValue(QLatin1String("Cookies"), data);
     }
 
     void load()
     {
         QMutexLocker lock(&mutex);
         QSettings settings;
-        QByteArray data = settings.value("Cookies").toByteArray();
+        QByteArray data = settings.value(QLatin1String("Cookies")).toByteArray();
         setAllCookies(QNetworkCookie::parseCookies(data));
     }
 
@@ -490,7 +490,7 @@ public:
         if (proxyDirty)
             setupProxy();
         QString protocolTag = query.protocolTag();
-        if (httpProxyInUse && (protocolTag == "http" || protocolTag == "https")) {
+        if (httpProxyInUse && (protocolTag == QLatin1String("http") || protocolTag == QLatin1String("https"))) {
             QList<QNetworkProxy> ret;
             ret << httpProxy;
             return ret;
@@ -597,7 +597,7 @@ QString QDeclarativeViewer::getVideoFileName()
     if (convertAvailable) types += tr("GIF Animation")+QLatin1String(" (*.gif)");
     types += tr("Individual PNG frames")+QLatin1String(" (*.png)");
     if (ffmpegAvailable) types += tr("All ffmpeg formats (*.*)");
-    return QFileDialog::getSaveFileName(this, title, "", types.join(";; "));
+    return QFileDialog::getSaveFileName(this, title, QString(), types.join(QLatin1String(";; ")));
 }
 
 QDeclarativeViewer::QDeclarativeViewer(QWidget *parent, Qt::WindowFlags flags)
@@ -725,18 +725,18 @@ void QDeclarativeViewer::createMenu()
     connect(reloadAction, SIGNAL(triggered()), this, SLOT(reload()));
 
     QAction *snapshotAction = new QAction(tr("&Take Snapshot"), this);
-    snapshotAction->setShortcut(QKeySequence("F3"));
+    snapshotAction->setShortcut(QKeySequence(tr("F3")));
     connect(snapshotAction, SIGNAL(triggered()), this, SLOT(takeSnapShot()));
 
     recordAction = new QAction(tr("Start Recording &Video"), this);
-    recordAction->setShortcut(QKeySequence("F9"));
+    recordAction->setShortcut(QKeySequence(tr("F9")));
     connect(recordAction, SIGNAL(triggered()), this, SLOT(toggleRecordingWithSelection()));
 
     QAction *recordOptions = new QAction(tr("Video &Options..."), this);
     connect(recordOptions, SIGNAL(triggered()), this, SLOT(chooseRecordingOptions()));
 
     QAction *slowAction = new QAction(tr("&Slow Down Animations"), this);
-    slowAction->setShortcut(QKeySequence("Ctrl+."));
+    slowAction->setShortcut(QKeySequence(tr("Ctrl+.")));
     slowAction->setCheckable(true);
     connect(slowAction, SIGNAL(triggered(bool)), this, SLOT(setSlowMode(bool)));
 
@@ -755,7 +755,7 @@ void QDeclarativeViewer::createMenu()
     connect(fullscreenAction, SIGNAL(triggered()), this, SLOT(toggleFullScreen()));
 
     rotateAction = new QAction(tr("Rotate orientation"), this);
-    rotateAction->setShortcut(QKeySequence("Ctrl+T"));
+    rotateAction->setShortcut(QKeySequence(tr("Ctrl+T")));
     connect(rotateAction, SIGNAL(triggered()), this, SLOT(rotateOrientation()));
 
     orientation = new QActionGroup(this);
@@ -963,7 +963,7 @@ void QDeclarativeViewer::chooseRecordingOptions()
 
 
     // Profile
-    recdlg->setArguments(record_args.join(" "));
+    recdlg->setArguments(record_args.join(QLatin1String(" ")));
     if (recdlg->exec()) {
         // File
         record_file = recdlg->file->text();
@@ -972,7 +972,7 @@ void QDeclarativeViewer::chooseRecordingOptions()
         // Rate
         record_rate = recdlg->videoRate();
         // Profile
-        record_args = recdlg->arguments().split(" ",QString::SkipEmptyParts);
+        record_args = recdlg->arguments().split(QLatin1Char(' '),QString::SkipEmptyParts);
     }
 }
 
@@ -983,8 +983,8 @@ void QDeclarativeViewer::toggleRecordingWithSelection()
             QString fileName = getVideoFileName();
             if (fileName.isEmpty())
                 return;
-            if (!fileName.contains(QRegExp(".[^\\/]*$")))
-                fileName += ".avi";
+            if (!fileName.contains(QRegExp(QLatin1String(".[^\\/]*$"))))
+                fileName += QLatin1String(".avi");
             setRecordFile(fileName);
         }
     }
@@ -1026,7 +1026,7 @@ void QDeclarativeViewer::openFile()
 {
     QString cur = canvas->source().toLocalFile();
     if (useQmlFileBrowser) {
-        open("qrc:/browser/Browser.qml");
+        open(QLatin1String("qrc:/browser/Browser.qml"));
     } else {
         QString fileName = QFileDialog::getOpenFileName(this, tr("Open QML file"), cur, tr("QML Files (*.qml)"));
         if (!fileName.isEmpty()) {
@@ -1072,7 +1072,7 @@ void QDeclarativeViewer::loadTranslationFile(const QString& directory)
 
 void QDeclarativeViewer::loadDummyDataFiles(const QString& directory)
 {
-    QDir dir(directory+"/dummydata", "*.qml");
+    QDir dir(directory + QLatin1String("/dummydata"), QLatin1String("*.qml"));
     QStringList list = dir.entryList();
     for (int i = 0; i < list.size(); ++i) {
         QString qml = list.at(i);
@@ -1114,14 +1114,14 @@ bool QDeclarativeViewer::open(const QString& file_or_url)
     delete canvas->rootObject();
     canvas->engine()->clearComponentCache();
     QDeclarativeContext *ctxt = canvas->rootContext();
-    ctxt->setContextProperty("qmlViewer", this);
+    ctxt->setContextProperty(QLatin1String("qmlViewer"), this);
 #ifdef Q_OS_SYMBIAN
-    ctxt->setContextProperty("qmlViewerFolder", "E:\\"); // Documents on your S60 phone
+    ctxt->setContextProperty(QLatin1String("qmlViewerFolder"), QLatin1String("E:\\")); // Documents on your S60 phone
 #else
-    ctxt->setContextProperty("qmlViewerFolder", QDir::currentPath());
+    ctxt->setContextProperty(QLatin1String("qmlViewerFolder"), QDir::currentPath());
 #endif
 
-    ctxt->setContextProperty("runtime", Runtime::instance());
+    ctxt->setContextProperty(QLatin1String("runtime"), Runtime::instance());
 
     QString fileName = url.toLocalFile();
     if (!fileName.isEmpty()) {
@@ -1224,26 +1224,26 @@ bool QDeclarativeViewer::event(QEvent *event)
 void QDeclarativeViewer::senseImageMagick()
 {
     QProcess proc;
-    proc.start("convert", QStringList() << "-h");
+    proc.start(QLatin1String("convert"), QStringList() << QLatin1String("-h"));
     proc.waitForFinished(2000);
-    QString help = proc.readAllStandardOutput();
-    convertAvailable = help.contains("ImageMagick");
+    QString help = QString::fromAscii(proc.readAllStandardOutput());
+    convertAvailable = help.contains(QLatin1String("ImageMagick"));
 }
 
 void QDeclarativeViewer::senseFfmpeg()
 {
     QProcess proc;
-    proc.start("ffmpeg", QStringList() << "-h");
+    proc.start(QLatin1String("ffmpeg"), QStringList() << QLatin1String("-h"));
     proc.waitForFinished(2000);
-    QString ffmpegHelp = proc.readAllStandardOutput();
-    ffmpegAvailable = ffmpegHelp.contains("-s ");
-    ffmpegHelp = tr("Video recording uses ffmpeg:")+"\n\n"+ffmpegHelp;
+    QString ffmpegHelp = QString::fromAscii(proc.readAllStandardOutput());
+    ffmpegAvailable = ffmpegHelp.contains(QLatin1String("-s "));
+    ffmpegHelp = tr("Video recording uses ffmpeg:") + QLatin1String("\n\n") + ffmpegHelp;
 
     QDialog *d = new QDialog(recdlg);
     QVBoxLayout *l = new QVBoxLayout(d);
     QTextBrowser *b = new QTextBrowser(d);
     QFont f = b->font();
-    f.setFamily("courier");
+    f.setFamily(QLatin1String("courier"));
     b->setFont(f);
     b->setText(ffmpegHelp);
     l->addWidget(b);
@@ -1266,7 +1266,7 @@ void QDeclarativeViewer::setRecording(bool on)
         recordTimer.start();
         frame_fmt = record_file.right(4).toLower();
         frame = QImage(canvas->width(),canvas->height(),QImage::Format_RGB32);
-        if (frame_fmt != ".png" && (!convertAvailable || frame_fmt != ".gif")) {
+        if (frame_fmt != QLatin1String(".png") && (!convertAvailable || frame_fmt != QLatin1String(".gif"))) {
             // Stream video to ffmpeg
 
             QProcess *proc = new QProcess(this);
@@ -1274,19 +1274,19 @@ void QDeclarativeViewer::setRecording(bool on)
             frame_stream = proc;
 
             QStringList args;
-            args << "-y";
-            args << "-r" << QString::number(record_rate);
-            args << "-f" << "rawvideo";
-            args << "-pix_fmt" << (frame_fmt == ".gif" ? "rgb24" : "rgb32");
-            args << "-s" << QString("%1x%2").arg(canvas->width()).arg(canvas->height());
-            args << "-i" << "-";
+            args << QLatin1String("-y");
+            args << QLatin1String("-r") << QString::number(record_rate);
+            args << QLatin1String("-f") << QLatin1String("rawvideo");
+            args << QLatin1String("-pix_fmt") << (frame_fmt == QLatin1String(".gif") ? QLatin1String("rgb24") : QLatin1String("rgb32"));
+            args << QLatin1String("-s") << QString::fromAscii("%1x%2").arg(canvas->width()).arg(canvas->height());
+            args << QLatin1String("-i") << QLatin1String("-");
             if (record_outsize.isValid()) {
-                args << "-s" << QString("%1x%2").arg(record_outsize.width()).arg(record_outsize.height());
-                args << "-aspect" << QString::number(double(canvas->width())/canvas->height());
+                args << QLatin1String("-s") << QString::fromAscii("%1x%2").arg(record_outsize.width()).arg(record_outsize.height());
+                args << QLatin1String("-aspect") << QString::number(double(canvas->width())/canvas->height());
             }
             args += record_args;
             args << record_file;
-            proc->start("ffmpeg",args);
+            proc->start(QLatin1String("ffmpeg"), args);
 
         } else {
             // Store frames, save to GIF/PNG
@@ -1309,14 +1309,14 @@ void QDeclarativeViewer::setRecording(bool on)
 
             QString framename;
             bool png_output = false;
-            if (record_file.right(4).toLower()==".png") {
-                if (record_file.contains('%'))
+            if (record_file.right(4).toLower() == QLatin1String(".png")) {
+                if (record_file.contains(QLatin1Char('%')))
                     framename = record_file;
                 else
-                    framename = record_file.left(record_file.length()-4)+"%04d"+record_file.right(4);
+                    framename = record_file.left(record_file.length()-4) + QLatin1String("%04d") + record_file.right(4);
                 png_output = true;
             } else {
-                framename = "tmp-frame%04d.png";
+                framename = QLatin1String("tmp-frame%04d.png");
                 png_output = false;
             }
             foreach (QImage* img, frames) {
@@ -1327,11 +1327,11 @@ void QDeclarativeViewer::setRecording(bool on)
                 name.sprintf(framename.toLocal8Bit(),frame++);
                 if (record_outsize.isValid())
                     *img = img->scaled(record_outsize,Qt::IgnoreAspectRatio,Qt::SmoothTransformation);
-                if (record_dither=="ordered")
+                if (record_dither==QLatin1String("ordered"))
                     img->convertToFormat(QImage::Format_Indexed8,Qt::PreferDither|Qt::OrderedDither).save(name);
-                else if (record_dither=="threshold")
+                else if (record_dither==QLatin1String("threshold"))
                     img->convertToFormat(QImage::Format_Indexed8,Qt::PreferDither|Qt::ThresholdDither).save(name);
-                else if (record_dither=="floyd")
+                else if (record_dither==QLatin1String("floyd"))
                     img->convertToFormat(QImage::Format_Indexed8,Qt::PreferDither).save(name);
                 else
                     img->save(name);
@@ -1341,25 +1341,26 @@ void QDeclarativeViewer::setRecording(bool on)
 
             if (!progress.wasCanceled()) {
                 if (png_output) {
-                    framename.replace(QRegExp("%\\d*."),"*");
+                    framename.replace(QRegExp(QLatin1String("%\\d*.")), QLatin1String("*"));
                     qDebug() << "Wrote frames" << framename;
                     inputs.clear(); // don't remove them
                 } else {
                     // ImageMagick and gifsicle for GIF encoding
                     progress.setLabelText(tr("Converting frames to GIF file..."));
                     QStringList args;
-                    args << "-delay" << QString::number(period/10);
+                    args << QLatin1String("-delay") << QString::number(period/10);
                     args << inputs;
                     args << record_file;
                     qDebug() << "Converting..." << record_file << "(this may take a while)";
-                    if (0!=QProcess::execute("convert", args)) {
+                    if (0!=QProcess::execute(QLatin1String("convert"), args)) {
                         qWarning() << "Cannot run ImageMagick 'convert' - recorded frames not converted";
                         inputs.clear(); // don't remove them
                         qDebug() << "Wrote frames tmp-frame*.png";
                     } else {
-                        if (record_file.right(4).toLower() == ".gif") {
+                        if (record_file.right(4).toLower() == QLatin1String(".gif")) {
                             qDebug() << "Compressing..." << record_file;
-                            if (0!=QProcess::execute("gifsicle", QStringList() << "-O2" << "-o" << record_file << record_file))
+                            if (0!=QProcess::execute(QLatin1String("gifsicle"), QStringList() << QLatin1String("-O2")
+                                                     << QLatin1String("-o") << record_file << record_file))
                                 qWarning() << "Cannot run 'gifsicle' - not compressed";
                         }
                         qDebug() << "Wrote" << record_file;
@@ -1410,7 +1411,7 @@ void QDeclarativeViewer::recordFrame()
 {
     canvas->QWidget::render(&frame);
     if (frame_stream) {
-        if (frame_fmt == ".gif") {
+        if (frame_fmt == QLatin1String(".gif")) {
             // ffmpeg can't do 32bpp with gif
             QImage rgb24 = frame.convertToFormat(QImage::Format_RGB888);
             frame_stream->write((char*)rgb24.bits(),rgb24.numBytes());
@@ -1541,8 +1542,8 @@ void QDeclarativeViewer::registerTypes()
 
     if (!registered) {
         // registering only for exposing the DeviceOrientation::Orientation enum
-        qmlRegisterUncreatableType<DeviceOrientation>("Qt",4,7,"Orientation","");
-        qmlRegisterUncreatableType<DeviceOrientation>("QtQuick",1,0,"Orientation","");
+        qmlRegisterUncreatableType<DeviceOrientation>("Qt", 4, 7, "Orientation", QString());
+        qmlRegisterUncreatableType<DeviceOrientation>("QtQuick", 1, 0, "Orientation", QString());
         registered = true;
     }
 }
diff --git a/translations/translations.pro b/translations/translations.pro
index 311b032557..dc99bebf57 100644
--- a/translations/translations.pro
+++ b/translations/translations.pro
@@ -55,6 +55,7 @@ addTsTargets(assistant, ../tools/assistant/tools/tools.pro)
 addTsTargets(qt_help, ../tools/assistant/lib/lib.pro)
 addTsTargets(qtconfig, ../tools/qtconfig/qtconfig.pro)
 addTsTargets(qvfb, ../tools/qvfb/qvfb.pro)
+addTsTargets(qmlviewer, ../tools/qml/qml.pro)
 
 check-ts.commands = (cd $$PWD && perl check-ts.pl)
 check-ts.depends = ts-all