Merge branch 'master' of git@scm.dev.nokia.troll.no:qt/qt

Conflicts:
	src/gui/graphicsview/qgraphicsitem_p.h

50 files changed, 620 insertions, 431 deletions

diff --git a/doc/src/snippets/qstring/stringbuilder.cpp b/doc/src/snippets/qstring/stringbuilder.cpp
new file mode 100644
index 0000000..90803e2
--- /dev/null
+++ b/doc/src/snippets/qstring/stringbuilder.cpp
@@ -0,0 +1,28 @@
+
+//! [0]
+    QString foo;
+    QString type = "long";
+
+    foo->setText(QLatin1String("vector<") + type + QLatin1String(">::iterator"));
+
+    if (foo.startsWith("(" + type + ") 0x"))
+        ...
+//! [0]
+
+//! [3]
+    #define QT_USE_FAST_CONCATENATION        
+//! [3]
+
+//! [4]
+    #define QT_USE_FAST_CONCATENATION 
+    #define QT_USE_FAST_OPERATOR_PLUS 
+//! [4]
+
+//! [5]
+    #include <QStringBuilder>
+
+    QString hello("hello");
+    QStringRef el(&hello, 2, 3);
+    QLatin1String world("world");
+    QString message =  hello % el % world % QChar('!');
+//! [5]
diff --git a/doc/src/statemachine.qdoc b/doc/src/statemachine.qdoc
index c017827..d2b508d 100644
--- a/doc/src/statemachine.qdoc
+++ b/doc/src/statemachine.qdoc
@@ -85,36 +85,20 @@
   The following snippet shows the code needed to create such a state machine.
   First, we create the state machine and states:
 
-  \code
-    QStateMachine machine;
-    QState *s1 = new QState();
-    QState *s2 = new QState();
-    QState *s3 = new QState();
-  \endcode
+  \snippet doc/src/snippets/statemachine/main.cpp 0
 
   Then, we create the transitions by using the QState::addTransition()
   function:
 
-  \code
-    s1->addTransition(button, SIGNAL(clicked()), s2);
-    s2->addTransition(button, SIGNAL(clicked()), s3);
-    s3->addTransition(button, SIGNAL(clicked()), s1);
-  \endcode
+  \snippet doc/src/snippets/statemachine/main.cpp 1
 
   Next, we add the states to the machine and set the machine's initial state:
 
-  \code
-    machine.addState(s1);
-    machine.addState(s2);
-    machine.addState(s3);
-    machine.setInitialState(s1);
-  \endcode
+  \snippet doc/src/snippets/statemachine/main.cpp 2
 
   Finally, we start the state machine:
 
-  \code
-    machine.start();
-  \endcode
+  \snippet doc/src/snippets/statemachine/main.cpp 3
 
   The state machine executes asynchronously, i.e. it becomes part of your
   application's event loop.
@@ -127,11 +111,7 @@
   entered. In the following snippet, the value that should be assigned to a
   QLabel's text property is specified for each state:
 
-  \code
-    s1->assignProperty(label, "text", "In state s1");
-    s2->assignProperty(label, "text", "In state s2");
-    s3->assignProperty(label, "text", "In state s3");
-  \endcode
+  \snippet doc/src/snippets/statemachine/main.cpp 4
 
   When any of the states is entered, the label's text will be changed
   accordingly.
@@ -142,10 +122,7 @@
   state \c s3 is entered, and the button's showMinimized() slot will be called
   when \c s3 is exited:
 
-  \code
-    QObject::connect(s3, SIGNAL(entered()), button, SLOT(showMaximized()));
-    QObject::connect(s3, SIGNAL(exited()), button, SLOT(showMinimized()));
-  \endcode
+  \snippet doc/src/snippets/statemachine/main.cpp 5
 
   Custom states can reimplement QAbstractState::onEntry() and
   QAbstractState::onExit().
@@ -194,22 +171,9 @@
   initial one (i.e. which child state the state machine should enter when the
   parent state is the target of a transition).
 
-  \code
-    QState *s1 = new QState();
-    QState *s11 = new QState(s1);
-    QState *s12 = new QState(s1);
-    QState *s13 = new QState(s1);
-    s1->setInitialState(s11);
-    machine.addState(s1);
-  \endcode
+  \snippet doc/src/snippets/statemachine/main2.cpp 0
 
-  \code
-    QFinalState *s2 = new QFinalState();
-    s1->addTransition(quitButton, SIGNAL(clicked()), s2);
-    machine.addState(s2);
-
-    QObject::connect(&machine, SIGNAL(finished()), QApplication::instance(), SLOT(quit()));
-  \endcode
+  \snippet doc/src/snippets/statemachine/main2.cpp 1
 
   In this case we want the application to quit when the state machine is
   finished, so the machine's finished() signal is connected to the
@@ -219,9 +183,7 @@
   following code adds a transition that effectively causes the Quit button to
   be ignored when the state machine is in state \c s12.
 
-  \code
-    s12>addTransition(quitButton, SIGNAL(clicked()), s12);
-  \endcode
+  \snippet doc/src/snippets/statemachine/main2.cpp 2
 
   A transition can have any state as its target, i.e. the target state does
   not have to be on the same level in the state hierarchy as the source state.
@@ -259,21 +221,7 @@
   simply display a message box when \c s3 is entered, then immediately return
   to the previous child state of \c s1 via the history state.
 
-  \code
-    QHistoryState *s1h = s1->addHistoryState();
-
-    QState *s3 = new QState();
-    s3->assignProperty(label, "text", "In s3");
-    QMessageBox mbox;
-    mbox.addButton(QMessageBox::Ok);
-    mbox.setText("Interrupted!");
-    mbox.setIcon(QMessageBox::Information);
-    QObject::connect(s3, SIGNAL(entered()), &mbox, SLOT(exec()));
-    s3->addTransition(s1h);
-    machine.addState(s3);
-
-    s1->addTransition(interruptButton, SIGNAL(clicked()), s3);
-  \endcode
+  \snippet doc/src/snippets/statemachine/main2.cpp 3
 
   \section1 Using Parallel States to Avoid a Combinatorial Explosion of States
 
@@ -305,12 +253,7 @@
   To create a parallel state group, pass QState::ParallelStates to the QState
   constructor.
 
-  \code
-    QState *s1 = new QState(QState::ParallelStates);
-    // s11 and s12 will be entered in parallel
-    QState *s11 = new QState(s1);
-    QState *s12 = new QState(s1);
-  \endcode
+  \snippet doc/src/snippets/statemachine/main3.cpp 0
 
   When a parallel state group is entered, all its child states will be
   simultaneously entered. Transitions within the individual child states
@@ -334,9 +277,7 @@
   finished(). We use a signal transition to cause this event to trigger a
   state change:
 
-  \code
-  s1->addTransition(s1, SIGNAL(finished()), s2);
-  \endcode
+  \snippet doc/src/snippets/statemachine/main3.cpp 1
 
   Using final states in composite states is useful when you want to hide the
   internal details of a composite state; i.e. the only thing the outside world
@@ -372,42 +313,12 @@
   Here we define our own custom event type, \c StringEvent, for posting
   strings to the state machine:
 
-  \code
-    struct StringEvent : public QEvent
-    {
-        StringEvent(const QString &val)
-        : QEvent(QEvent::Type(QEvent::User+1)),
-          value(val) {}
-
-        QString value;
-    };
-  \endcode
+  \snippet doc/src/snippets/statemachine/main4.cpp 0
 
   Next, we define a transition that only triggers when the event's string
   matches a particular string (a \e guarded transition):
 
-  \code
-    class StringTransition : public QAbstractTransition
-    {
-    public:
-        StringTransition(const QString &value)
-            : m_value(value) {}
-
-    protected:
-        virtual bool eventTest(QEvent *e) const
-        {
-            if (e->type() != QEvent::Type(QEvent::User+1)) // StringEvent
-                return false;
-            StringEvent *se = static_cast<StringEvent*>(e);
-            return (m_value == se->value);
-        }
-    
-        virtual void onTransition(QEvent *) {}
-
-    private:
-        QString m_value;
-    };
-  \endcode
+  \snippet doc/src/snippets/statemachine/main4.cpp 1
 
   In the eventTest() reimplementation, we first check if the event type is the
   desired one; if so, we cast the event to a StringEvent and perform the
@@ -422,31 +333,11 @@
 
   Here's what the implementation of the statechart looks like:
 
-  \code
-    QStateMachine machine;
-    QState *s1 = new QState();
-    QState *s2 = new QState();
-    QFinalState *done = new QFinalState();
-
-    StringTransition *t1 = new StringTransition("Hello");
-    t1->setTargetState(s2);
-    s1->addTransition(t1);
-    StringTransition *t2 = new StringTransition("world");
-    t2->setTargetState(done);
-    s2->addTransition(t2);
-
-    machine.addState(s1);
-    machine.addState(s2);
-    machine.addState(done);
-    machine.setInitialState(s1);
-  \endcode
+  \snippet doc/src/snippets/statemachine/main4.cpp 2
 
   Once the machine is started, we can post events to it.
 
-  \code
-  machine.postEvent(new StringEvent("Hello"));
-  machine.postEvent(new StringEvent("world"));
-  \endcode
+  \snippet doc/src/snippets/statemachine/main4.cpp 3
 
   An event that is not handled by any relevant transition will be silently
   consumed by the state machine. It can be useful to group states and provide
diff --git a/examples/graphicsview/diagramscene/mainwindow.cpp b/examples/graphicsview/diagramscene/mainwindow.cpp
index ad8006e..4783280 100644
--- a/examples/graphicsview/diagramscene/mainwindow.cpp
+++ b/examples/graphicsview/diagramscene/mainwindow.cpp
@@ -76,6 +76,7 @@ MainWindow::MainWindow()
 
     setCentralWidget(widget);
     setWindowTitle(tr("Diagramscene"));
+    setUnifiedTitleAndToolBarOnMac(true);
 }
 //! [0]
 
diff --git a/examples/webkit/fancybrowser/mainwindow.cpp b/examples/webkit/fancybrowser/mainwindow.cpp
index 9f899b4..6d477db 100644
--- a/examples/webkit/fancybrowser/mainwindow.cpp
+++ b/examples/webkit/fancybrowser/mainwindow.cpp
@@ -94,6 +94,7 @@ MainWindow::MainWindow()
     toolsMenu->addAction(tr("Remove all embedded elements"), this, SLOT(removeEmbeddedElements()));
 
     setCentralWidget(view);
+    setUnifiedTitleAndToolBarOnMac(true);
 }
 //! [3]
 
diff --git a/examples/webkit/formextractor/mainwindow.cpp b/examples/webkit/formextractor/mainwindow.cpp
index bc92f85..f774737 100644
--- a/examples/webkit/formextractor/mainwindow.cpp
+++ b/examples/webkit/formextractor/mainwindow.cpp
@@ -48,6 +48,7 @@ MainWindow::MainWindow()
     createMenus();
     centralWidget = new FormExtractor(this);
     setCentralWidget(centralWidget);
+    setUnifiedTitleAndToolBarOnMac(true);
 }
 
 void MainWindow::createActions()
diff --git a/src/corelib/io/qiodevice.cpp b/src/corelib/io/qiodevice.cpp
index d3fa6a8..2977c7f 100644
--- a/src/corelib/io/qiodevice.cpp
+++ b/src/corelib/io/qiodevice.cpp
@@ -1454,11 +1454,11 @@ QByteArray QIODevice::peek(qint64 maxSize)
 }
 
 /*!
-    Blocks until data is available for reading and the readyRead()
+    Blocks until new data is available for reading and the readyRead()
     signal has been emitted, or until \a msecs milliseconds have
     passed. If msecs is -1, this function will not time out.
 
-    Returns true if data is available for reading; otherwise returns
+    Returns true if new data is available for reading; otherwise returns
     false (if the operation timed out or if an error occurred).
 
     This function can operate without an event loop. It is
diff --git a/src/corelib/tools/qstring.cpp b/src/corelib/tools/qstring.cpp
index ced6dd5..3b70f44 100644
--- a/src/corelib/tools/qstring.cpp
+++ b/src/corelib/tools/qstring.cpp
@@ -663,6 +663,74 @@ const QString::Null QString::null = { };
     formats, the \e precision represents the maximum number of
     significant digits (trailing zeroes are omitted).
 
+    \section1 More Efficient String Construction 
+
+    Using the QString \c{'+'} operator, it is easy to construct a
+    complex string from multiple substrings. You will often write code
+    like this:
+
+    \snippet doc/src/snippets/qstring/stringbuilder.cpp 0
+
+    There is nothing wrong with either of these string constructions,
+    but there are a few hidden inefficiencies. Beginning with Qt 4.6,
+    you can eliminate them.
+
+    First, multiple uses of the \c{'+'} operator usually means
+    multiple memory allocations. When concatenating \e{n} substrings,
+    where \e{n > 2}, there can be as many as \e{n - 1} calls to the
+    memory allocator.
+
+    Second, QLatin1String does not store its length internally but
+    calls qstrlen() when it needs to know its length.
+
+    In 4.6, an internal template class \c{QStringBuilder} has been
+    added along with a few helper functions. This class is marked
+    internal and does not appear in the documentation, because you
+    aren't meant to instantiate it in your code. Its use will be
+    automatic, as described below. The class is found in
+    \c {src/corelib/tools/qstringbuilder.cpp} if you want to have a
+    look at it.
+
+    \c{QStringBuilder} uses expression templates and reimplements the
+    \c{'%'} operator so that when you use \c{'%'} for string
+    concatenation instead of \c{'+'}, multiple substring
+    concatenations will be postponed until the final result is about
+    to be assigned to a QString. At this point, the amount of memory
+    required for the final result is known. The memory allocator is
+    then called \e{once} to get the required space, and the substrings
+    are copied into it one by one.
+
+    \c{QLatin1Literal} is a second internal class that can replace
+    QLatin1String, which can't be changed for compatibility reasons.
+    \c{QLatin1Literal} stores its length, thereby saving time when
+    \c{QStringBuilder} computes the amount of memory required for the
+    final string.
+
+    Additional efficiency is gained by inlining and reduced reference
+    counting (the QString created from a \c{QStringBuilder} typically
+    has a ref count of 1, whereas QString::append() needs an extra
+    test).
+
+    There are three ways you can access this improved method of string
+    construction. The straightforward way is to include
+    \c{QStringBuilder} wherever you want to use it, and use the
+    \c{'%'} operator instead of \c{'+'} when concatenating strings:
+
+    \snippet doc/src/snippets/qstring/stringbuilder.cpp 5
+
+    A more global approach is to include this define:
+
+    \snippet doc/src/snippets/qstring/stringbuilder.cpp 3
+
+    and use \c{'%'} instead of \c{'+'} for string concatenation
+    everywhere. The third approach, which is the most convenient but
+    not entirely source compatible, is to include two defines:
+
+    \snippet doc/src/snippets/qstring/stringbuilder.cpp 4
+
+    and the \c{'+'} will automatically be performed as the
+    \c{QStringBuilder} \c{'%'} everywhere.
+
     \sa fromRawData(), QChar, QLatin1String, QByteArray, QStringRef
 */
 
diff --git a/src/corelib/tools/qstringbuilder.cpp b/src/corelib/tools/qstringbuilder.cpp
index 17e2cec..fbb784e 100644
--- a/src/corelib/tools/qstringbuilder.cpp
+++ b/src/corelib/tools/qstringbuilder.cpp
@@ -43,6 +43,7 @@
 
 /*!
     \class QLatin1Literal
+    \internal
     \reentrant
     \since 4.6
 
@@ -83,6 +84,7 @@
 
 /*!
     \class QStringBuilder
+    \internal
     \reentrant
     \since 4.6
 
diff --git a/src/gui/graphicsview/qgraphicsitem_p.h b/src/gui/graphicsview/qgraphicsitem_p.h
index 688130b..a0d061b 100644
--- a/src/gui/graphicsview/qgraphicsitem_p.h
+++ b/src/gui/graphicsview/qgraphicsitem_p.h
@@ -56,6 +56,7 @@
 #include "qgraphicsitem.h"
 #include "qset.h"
 #include "qpixmapcache.h"
+#include "qgraphicsview_p.h"
 
 #include <QtCore/qpoint.h>
 
@@ -158,6 +159,8 @@ public:
         geometryChanged(0),
         inDestructor(0),
         isObject(0),
+        ignoreVisible(0),
+        ignoreOpacity(0),
         acceptTouchEvents(0),
         acceptedTouchBeginEvent(0),
         globalStackingOrder(-1),
@@ -181,7 +184,7 @@ public:
 
     void combineTransformToParent(QTransform *x, const QTransform *viewTransform = 0) const;
     void combineTransformFromParent(QTransform *x, const QTransform *viewTransform = 0) const;
-    
+
     // ### Qt 5: Remove. Workaround for reimplementation added after Qt 4.4.
     virtual QVariant inputMethodQueryHelper(Qt::InputMethodQuery query) const;
     static bool movableAncestorIsSelected(const QGraphicsItem *item);
@@ -250,7 +253,7 @@ public:
             }
         }
     }
-    
+
     struct ExtraStruct {
         ExtraStruct(Extra type, QVariant value)
             : type(type), value(value)
@@ -262,7 +265,7 @@ public:
         bool operator<(Extra extra) const
         { return type < extra; }
     };
-    
+
     QList<ExtraStruct> extras;
 
     QGraphicsItemCache *maybeExtraItemCache() const;
@@ -337,6 +340,15 @@ public:
         return calcEffectiveOpacity();
     }
 
+    inline qreal combineOpacityFromParent(qreal parentOpacity) const
+    {
+        if (parent && !(flags & QGraphicsItem::ItemIgnoresParentOpacity)
+            && !(parent->d_ptr->flags & QGraphicsItem::ItemDoesntPropagateOpacityToChildren)) {
+            return parentOpacity * opacity;
+        }
+        return opacity;
+    }
+
     inline bool childrenCombineOpacity() const
     {
         if (!children.size())
@@ -423,8 +435,8 @@ public:
     quint32 cacheMode : 2;
     quint32 hasBoundingRegionGranularity : 1;
     quint32 isWidget : 1;
-    quint32 dirty : 1;    
-    quint32 dirtyChildren : 1;    
+    quint32 dirty : 1;
+    quint32 dirtyChildren : 1;
     quint32 localCollisionHack : 1;
     quint32 dirtyClipPath : 1;
     quint32 emptyClipPath : 1;
@@ -441,9 +453,11 @@ public:
     quint32 geometryChanged : 1;
     quint32 inDestructor : 1;
     quint32 isObject : 1;
+    quint32 ignoreVisible : 1;
+    quint32 ignoreOpacity : 1;
     quint32 acceptTouchEvents : 1;
     quint32 acceptedTouchBeginEvent : 1;
-    quint32 unused : 12; // feel free to use
+    quint32 unused : 10; // feel free to use
 
     // Optional stacking order
     int globalStackingOrder;
diff --git a/src/gui/graphicsview/qgraphicsscene.cpp b/src/gui/graphicsview/qgraphicsscene.cpp
index 13b1b5a..7428d79 100644
--- a/src/gui/graphicsview/qgraphicsscene.cpp
+++ b/src/gui/graphicsview/qgraphicsscene.cpp
@@ -5180,14 +5180,7 @@ void QGraphicsScenePrivate::drawSubtreeRecursive(QGraphicsItem *item, QPainter *
     if (item) {
         if (!item->d_ptr->visible)
             return;
-        QGraphicsItem *p = item->d_ptr->parent;
-        bool itemIgnoresParentOpacity = item->d_ptr->flags & QGraphicsItem::ItemIgnoresParentOpacity;
-        bool parentDoesntPropagateOpacity = (p && (p->d_ptr->flags & QGraphicsItem::ItemDoesntPropagateOpacityToChildren));
-        if (!itemIgnoresParentOpacity && !parentDoesntPropagateOpacity) {
-            opacity = parentOpacity * item->opacity();
-        } else {
-            opacity = item->d_ptr->opacity;
-        }
+        opacity = item->d_ptr->combineOpacityFromParent(parentOpacity);
         if (opacity == 0.0 && !(item->d_ptr->flags & QGraphicsItem::ItemDoesntPropagateOpacityToChildren)) {
             invisibleButChildIgnoresParentOpacity = !item->d_ptr->childrenCombineOpacity();
             if (!invisibleButChildIgnoresParentOpacity)
@@ -5337,7 +5330,11 @@ void QGraphicsScenePrivate::drawSubtreeRecursive(QGraphicsItem *item, QPainter *
         if (clipsToShape)
             painter->setClipPath(item->shape(), Qt::IntersectClip);
         painter->setOpacity(opacity);
-        drawItemHelper(item, painter, &styleOptionTmp, widget, painterStateProtection);
+
+        if (!item->d_ptr->cacheMode && !item->d_ptr->isWidget)
+            item->paint(painter, &styleOptionTmp, widget);
+        else
+            drawItemHelper(item, painter, &styleOptionTmp, widget, painterStateProtection);
 
         if (savePainter)
             painter->restore();
@@ -5421,6 +5418,11 @@ void QGraphicsScenePrivate::markDirty(QGraphicsItem *item, const QRectF &rect, b
         item->d_ptr->dirtyChildren = 1;
     }
 
+    if (force)
+        item->d_ptr->ignoreVisible = 1;
+    if (ignoreOpacity)
+        item->d_ptr->ignoreOpacity = 1;
+
     QGraphicsItem *p = item->d_ptr->parent;
     while (p && !p->d_ptr->dirtyChildren) {
         p->d_ptr->dirtyChildren = 1;
@@ -5428,34 +5430,58 @@ void QGraphicsScenePrivate::markDirty(QGraphicsItem *item, const QRectF &rect, b
     }
 }
 
-void QGraphicsScenePrivate::processDirtyItemsRecursive(QGraphicsItem *item, bool dirtyAncestorContainsChildren)
+static inline bool updateHelper(QGraphicsViewPrivate *view, QGraphicsItemPrivate *item,
+                                const QRectF &rect, const QTransform &xform)
+{
+    Q_ASSERT(view);
+    Q_ASSERT(item);
+    if (item->hasBoundingRegionGranularity)
+        return view->updateRegion(xform.map(QRegion(rect.toRect())));
+    return view->updateRect(xform.mapRect(rect).toRect());
+}
+
+void QGraphicsScenePrivate::processDirtyItemsRecursive(QGraphicsItem *item, bool dirtyAncestorContainsChildren,
+                                                       qreal parentOpacity)
 {
     Q_Q(QGraphicsScene);
 
-    // Calculate the full scene transform for this item.
+    bool wasDirtyParentViewBoundingRects = false;
     bool wasDirtyParentSceneTransform = false;
-    if (item && item->d_ptr->dirtySceneTransform && !item->d_ptr->itemIsUntransformable()) {
-        item->d_ptr->sceneTransform = item->d_ptr->parent ? item->d_ptr->parent->d_ptr->sceneTransform
-                                                          : QTransform();
-        item->d_ptr->combineTransformFromParent(&item->d_ptr->sceneTransform);
-        item->d_ptr->dirtySceneTransform = 0;
-        wasDirtyParentSceneTransform = true;
+    qreal opacity = parentOpacity;
+
+    if (item) {
+        wasDirtyParentViewBoundingRects = item->d_ptr->paintedViewBoundingRectsNeedRepaint;
+        opacity = item->d_ptr->combineOpacityFromParent(parentOpacity);
+        const bool itemIsHidden = !item->d_ptr->ignoreVisible && !item->d_ptr->visible;
+        const bool itemIsFullyTransparent = !item->d_ptr->ignoreOpacity && opacity == 0.0;
+
+        if (item->d_ptr->dirtySceneTransform && !itemIsHidden && !item->d_ptr->itemIsUntransformable()
+            && !(itemIsFullyTransparent && item->d_ptr->childrenCombineOpacity())) {
+            // Calculate the full scene transform for this item.
+            item->d_ptr->sceneTransform = item->d_ptr->parent ? item->d_ptr->parent->d_ptr->sceneTransform
+                                                              : QTransform();
+            item->d_ptr->combineTransformFromParent(&item->d_ptr->sceneTransform);
+            item->d_ptr->dirtySceneTransform = 0;
+            wasDirtyParentSceneTransform = true;
+        }
+
+        if (itemIsHidden || itemIsFullyTransparent || (item->d_ptr->flags & QGraphicsItem::ItemHasNoContents)) {
+            // Make sure we don't process invisible items or items with no content.
+            item->d_ptr->dirty = 0;
+            item->d_ptr->paintedViewBoundingRectsNeedRepaint = 0;
+        }
     }
 
     // Process item.
-    bool wasDirtyParentViewBoundingRects = false;
     if (item && (item->d_ptr->dirty || item->d_ptr->paintedViewBoundingRectsNeedRepaint)) {
         const bool useCompatUpdate = views.isEmpty() || (connectedSignals & changedSignalMask);
         const bool untransformableItem = item->d_ptr->itemIsUntransformable();
-        const QRectF itemBoundingRect = item->boundingRect();
+        const QRectF itemBoundingRect = adjustedItemBoundingRect(item);
 
         if (item->d_ptr->geometryChanged) {
             // Update growingItemsBoundingRect.
-            if (!hasSceneRect) {
-                QRectF itemSceneBoundingRect = item->d_ptr->sceneTransform.mapRect(itemBoundingRect);
-                _q_adjustRect(&itemSceneBoundingRect);
-                growingItemsBoundingRect |= itemSceneBoundingRect;
-            }
+            if (!hasSceneRect)
+                growingItemsBoundingRect |= item->d_ptr->sceneTransform.mapRect(itemBoundingRect);
             item->d_ptr->geometryChanged = 0;
         }
 
@@ -5484,11 +5510,12 @@ void QGraphicsScenePrivate::processDirtyItemsRecursive(QGraphicsItem *item, bool
                     break;
                 }
 
+                QRect &paintedViewBoundingRect = item->d_ptr->paintedViewBoundingRects[viewPrivate->viewport];
                 if (item->d_ptr->paintedViewBoundingRectsNeedRepaint) {
                     wasDirtyParentViewBoundingRects = true;
-                    QRect rect = item->d_ptr->paintedViewBoundingRects.value(viewPrivate->viewport);
-                    rect.translate(viewPrivate->dirtyScrollOffset);
-                    viewPrivate->updateRect(rect);
+                    paintedViewBoundingRect.translate(viewPrivate->dirtyScrollOffset);
+                    if (!viewPrivate->updateRect(paintedViewBoundingRect))
+                        paintedViewBoundingRect = QRect();
                 }
 
                 if (!item->d_ptr->dirty)
@@ -5496,7 +5523,6 @@ void QGraphicsScenePrivate::processDirtyItemsRecursive(QGraphicsItem *item, bool
 
                 if (uninitializedDirtyRect) {
                     dirtyRect = itemBoundingRect;
-                    _q_adjustRect(&dirtyRect);
                     if (!item->d_ptr->fullUpdatePending) {
                         _q_adjustRect(&item->d_ptr->needsRepaint);
                         dirtyRect &= item->d_ptr->needsRepaint;
@@ -5507,17 +5533,19 @@ void QGraphicsScenePrivate::processDirtyItemsRecursive(QGraphicsItem *item, bool
                 if (dirtyRect.isEmpty())
                     continue; // Discard updates outside the bounding rect.
 
-                QTransform deviceTransform = item->d_ptr->sceneTransform;
-                if (view->isTransformed()) {
-                    if (!untransformableItem)
-                        deviceTransform *= view->viewportTransform();
-                    else
-                        deviceTransform = item->deviceTransform(view->viewportTransform());
+                bool valid = false;
+                if (untransformableItem) {
+                    valid = updateHelper(viewPrivate, item->d_ptr, dirtyRect,
+                                         item->deviceTransform(view->viewportTransform()));
+                } else if (!view->isTransformed()) {
+                    valid = updateHelper(viewPrivate, item->d_ptr, dirtyRect, item->d_ptr->sceneTransform);
+                } else {
+                    QTransform deviceTransform = item->d_ptr->sceneTransform;
+                    deviceTransform *= view->viewportTransform();
+                    valid = updateHelper(viewPrivate, item->d_ptr, dirtyRect, deviceTransform);
                 }
-                if (item->d_ptr->hasBoundingRegionGranularity)
-                    viewPrivate->updateRegion(deviceTransform.map(QRegion(dirtyRect.toRect())));
-                else
-                    viewPrivate->updateRect(deviceTransform.mapRect(dirtyRect).toRect());
+                if (!valid)
+                    paintedViewBoundingRect = QRect();
             }
         }
     }
@@ -5530,12 +5558,18 @@ void QGraphicsScenePrivate::processDirtyItemsRecursive(QGraphicsItem *item, bool
             dirtyAncestorContainsChildren = item && item->d_ptr->fullUpdatePending
                                             && (item->d_ptr->flags & QGraphicsItem::ItemClipsChildrenToShape);
         }
+        const bool parentIgnoresVisible = item && item->d_ptr->ignoreVisible;
+        const bool parentIgnoresOpacity = item && item->d_ptr->ignoreOpacity;
         for (int i = 0; i < children->size(); ++i) {
             QGraphicsItem *child = children->at(i);
             if (wasDirtyParentSceneTransform)
                 child->d_ptr->dirtySceneTransform = 1;
             if (wasDirtyParentViewBoundingRects)
                 child->d_ptr->paintedViewBoundingRectsNeedRepaint = 1;
+            if (parentIgnoresVisible)
+                child->d_ptr->ignoreVisible = 1;
+            if (parentIgnoresOpacity)
+                child->d_ptr->ignoreOpacity = 1;
 
             if (allChildrenDirty) {
                 child->d_ptr->dirty = 1;
@@ -5558,7 +5592,7 @@ void QGraphicsScenePrivate::processDirtyItemsRecursive(QGraphicsItem *item, bool
                     child->d_ptr->paintedViewBoundingRectsNeedRepaint = 0;
             }
 
-            processDirtyItemsRecursive(child, dirtyAncestorContainsChildren);
+            processDirtyItemsRecursive(child, dirtyAncestorContainsChildren, opacity);
         }
     } else if (wasDirtyParentSceneTransform) {
         item->d_ptr->invalidateChildrenSceneTransform();
diff --git a/src/gui/graphicsview/qgraphicsscene_p.h b/src/gui/graphicsview/qgraphicsscene_p.h
index b3f168c..983486f 100644
--- a/src/gui/graphicsview/qgraphicsscene_p.h
+++ b/src/gui/graphicsview/qgraphicsscene_p.h
@@ -271,7 +271,8 @@ public:
     void markDirty(QGraphicsItem *item, const QRectF &rect = QRectF(), bool invalidateChildren = false,
                    bool maybeDirtyClipPath = false, bool force = false, bool ignoreOpacity = false,
                    bool removingItemFromScene = false);
-    void processDirtyItemsRecursive(QGraphicsItem *item, bool dirtyAncestorContainsChildren = false);
+    void processDirtyItemsRecursive(QGraphicsItem *item, bool dirtyAncestorContainsChildren = false,
+                                    qreal parentOpacity = qreal(1.0));
 
     inline void resetDirtyItem(QGraphicsItem *item)
     {
@@ -283,6 +284,8 @@ public:
         item->d_ptr->needsRepaint = QRectF();
         item->d_ptr->allChildrenDirty = 0;
         item->d_ptr->fullUpdatePending = 0;
+        item->d_ptr->ignoreVisible = 0;
+        item->d_ptr->ignoreOpacity = 0;
     }
 
     QStyle *style;
diff --git a/src/gui/graphicsview/qgraphicsview.cpp b/src/gui/graphicsview/qgraphicsview.cpp
index 47a492b..6ac2914 100644
--- a/src/gui/graphicsview/qgraphicsview.cpp
+++ b/src/gui/graphicsview/qgraphicsview.cpp
@@ -846,19 +846,22 @@ void QGraphicsViewPrivate::processPendingUpdates()
     dirtyRegion = QRegion();
 }
 
-void QGraphicsViewPrivate::updateRegion(const QRegion &r)
+bool QGraphicsViewPrivate::updateRegion(const QRegion &r)
 {
-    if (r.isEmpty() || fullUpdatePending)
-        return;
+    if (fullUpdatePending || viewportUpdateMode == QGraphicsView::NoViewportUpdate || r.isEmpty())
+        return false;
+
+    const QRect boundingRect = r.boundingRect();
+    if (!boundingRect.intersects(viewport->rect()))
+        return false; // Update region outside viewport.
 
-    // Rect intersects viewport - update everything?
     switch (viewportUpdateMode) {
     case QGraphicsView::FullViewportUpdate:
         fullUpdatePending = true;
         viewport->update();
         break;
     case QGraphicsView::BoundingRectViewportUpdate:
-        dirtyBoundingRect |= r.boundingRect();
+        dirtyBoundingRect |= boundingRect;
         if (dirtyBoundingRect.contains(viewport->rect())) {
             fullUpdatePending = true;
             viewport->update();
@@ -876,18 +879,20 @@ void QGraphicsViewPrivate::updateRegion(const QRegion &r)
         }
         break;
     }
-    case QGraphicsView::NoViewportUpdate:
-        // Unreachable
+    default:
         break;
     }
+
+    return true;
 }
 
-void QGraphicsViewPrivate::updateRect(const QRect &r)
+bool QGraphicsViewPrivate::updateRect(const QRect &r)
 {
-    if (r.isEmpty() || fullUpdatePending)
-        return;
+    if (fullUpdatePending || viewportUpdateMode == QGraphicsView::NoViewportUpdate
+        || !r.intersects(viewport->rect())) {
+        return false;
+    }
 
-    // Rect intersects viewport - update everything?
     switch (viewportUpdateMode) {
     case QGraphicsView::FullViewportUpdate:
         fullUpdatePending = true;
@@ -907,10 +912,11 @@ void QGraphicsViewPrivate::updateRect(const QRect &r)
         else
             dirtyRegion += r.adjusted(-2, -2, 2, 2);
         break;
-    case QGraphicsView::NoViewportUpdate:
-        // Unreachable
+    default:
         break;
     }
+
+    return true;
 }
 
 QStyleOptionGraphicsItem *QGraphicsViewPrivate::allocStyleOptionsArray(int numItems)
@@ -3288,10 +3294,6 @@ void QGraphicsView::paintEvent(QPaintEvent *event)
 
     // Determine the exposed region
     d->exposedRegion = event->region();
-    if (!d->accelerateScrolling)
-        d->exposedRegion = viewport()->rect();
-    else if (d->viewportUpdateMode == BoundingRectViewportUpdate)
-        d->exposedRegion = event->rect();
     QRectF exposedSceneRect = mapToScene(d->exposedRegion.boundingRect()).boundingRect();
 
     // Set up the painter
@@ -3305,8 +3307,10 @@ void QGraphicsView::paintEvent(QPaintEvent *event)
     painter.setRenderHints(d->renderHints, true);
 
     // Set up viewport transform
-    const QTransform viewTransform = viewportTransform();
-    painter.setWorldTransform(viewTransform);
+    const bool viewTransformed = isTransformed();
+    if (viewTransformed)
+        painter.setWorldTransform(viewportTransform());
+    const QTransform viewTransform = painter.worldTransform();
 
     // Draw background
     if ((d->cacheMode & CacheBackground)
@@ -3331,16 +3335,21 @@ void QGraphicsView::paintEvent(QPaintEvent *event)
         if (!d->backgroundPixmapExposed.isEmpty()) {
             QPainter backgroundPainter(&d->backgroundPixmap);
             backgroundPainter.setClipRegion(d->backgroundPixmapExposed, Qt::ReplaceClip);
-            backgroundPainter.setTransform(viewportTransform());
+            if (viewTransformed)
+                backgroundPainter.setTransform(viewTransform);
             backgroundPainter.setCompositionMode(QPainter::CompositionMode_Source);
             drawBackground(&backgroundPainter, exposedSceneRect);
             d->backgroundPixmapExposed = QRegion();
         }
 
         // Blit the background from the background pixmap
-        painter.setWorldTransform(QTransform());
-        painter.drawPixmap(QPoint(), d->backgroundPixmap);
-        painter.setWorldTransform(viewTransform);
+        if (viewTransformed) {
+            painter.setWorldTransform(QTransform());
+            painter.drawPixmap(QPoint(), d->backgroundPixmap);
+            painter.setWorldTransform(viewTransform);
+        } else {
+            painter.drawPixmap(QPoint(), d->backgroundPixmap);
+        }
     } else {
         if (!(d->optimizationFlags & DontSavePainterState))
             painter.save();
@@ -3363,8 +3372,10 @@ void QGraphicsView::paintEvent(QPaintEvent *event)
             const int numItems = itemList.size();
             QGraphicsItem **itemArray = &itemList[0]; // Relies on QList internals, but is perfectly valid.
             QStyleOptionGraphicsItem *styleOptionArray = d->allocStyleOptionsArray(numItems);
-            for (int i = 0; i < numItems; ++i)
-                itemArray[i]->d_ptr->initStyleOption(&styleOptionArray[i], viewTransform, d->exposedRegion, allItems);
+            for (int i = 0; i < numItems; ++i) {
+                itemArray[i]->d_ptr->initStyleOption(&styleOptionArray[i], viewTransform,
+                                                     d->exposedRegion, allItems);
+            }
             // Draw the items.
             drawItems(&painter, numItems, itemArray, styleOptionArray);
             d->freeStyleOptionsArray(styleOptionArray);
diff --git a/src/gui/graphicsview/qgraphicsview_p.h b/src/gui/graphicsview/qgraphicsview_p.h
index 903ca2b..5682138 100644
--- a/src/gui/graphicsview/qgraphicsview_p.h
+++ b/src/gui/graphicsview/qgraphicsview_p.h
@@ -171,8 +171,8 @@ public:
         dirtyBoundingRect = QRect();
         dirtyRegion = QRegion();
     }
-    void updateRect(const QRect &rect);
-    void updateRegion(const QRegion &region);
+    bool updateRect(const QRect &rect);
+    bool updateRegion(const QRegion &region);
     bool updateSceneSlotReimplementedChecked;
     QRegion exposedRegion;
 
diff --git a/src/gui/itemviews/qlistview.cpp b/src/gui/itemviews/qlistview.cpp
index 9b25730..f1b0d19 100644
--- a/src/gui/itemviews/qlistview.cpp
+++ b/src/gui/itemviews/qlistview.cpp
@@ -827,6 +827,8 @@ void QListView::rowsAboutToBeRemoved(const QModelIndex &parent, int start, int e
 */
 void QListView::mouseMoveEvent(QMouseEvent *e)
 {
+    if (!isVisible())
+	return;
     Q_D(QListView);
     QAbstractItemView::mouseMoveEvent(e);
     if (state() == DragSelectingState
diff --git a/src/gui/kernel/qapplication_x11.cpp b/src/gui/kernel/qapplication_x11.cpp
index fef51f9..19c5928 100644
--- a/src/gui/kernel/qapplication_x11.cpp
+++ b/src/gui/kernel/qapplication_x11.cpp
@@ -4617,6 +4617,46 @@ void fetchWacomToolId(int &deviceType, qint64 &serialId)
 }
 #endif
 
+struct qt_tablet_motion_data
+{
+    Time timestamp;
+    int tabletMotionType;
+    bool error; // found a reason to stop searching
+};
+
+static Bool qt_mouseMotion_scanner(Display *, XEvent *event, XPointer arg)
+{
+    qt_tablet_motion_data *data = (qt_tablet_motion_data *) arg;
+    if (data->error)
+        return false;
+
+    if (event->type == MotionNotify)
+        return true;
+
+    data->error = event->type != data->tabletMotionType; // we stop compression when another event gets in between.
+    return false;
+}
+
+static Bool qt_tabletMotion_scanner(Display *, XEvent *event, XPointer arg)
+{
+    qt_tablet_motion_data *data = (qt_tablet_motion_data *) arg;
+    if (data->error)
+        return false;
+
+    if (event->type == data->tabletMotionType) {
+        if (data->timestamp > 0) {
+            if ((reinterpret_cast<const XDeviceMotionEvent*>(event))->time > data->timestamp) {
+                data->error = true;
+                return false;
+            }
+        }
+        return true;
+    }
+
+    data->error = event->type != MotionNotify; // we stop compression when another event gets in between.
+    return false;
+}
+
 bool QETWidget::translateXinputEvent(const XEvent *ev, QTabletDeviceData *tablet)
 {
 #if defined (Q_OS_IRIX)
@@ -4643,7 +4683,6 @@ bool QETWidget::translateXinputEvent(const XEvent *ev, QTabletDeviceData *tablet
     qreal rotation = 0;
     int deviceType = QTabletEvent::NoDevice;
     int pointerType = QTabletEvent::UnknownPointer;
-    XEvent xinputMotionEvent;
     XEvent mouseMotionEvent;
     const XDeviceMotionEvent *motion = 0;
     XDeviceButtonEvent *button = 0;
@@ -4651,8 +4690,6 @@ bool QETWidget::translateXinputEvent(const XEvent *ev, QTabletDeviceData *tablet
     QEvent::Type t;
     Qt::KeyboardModifiers modifiers = 0;
     bool reinsertMouseEvent = false;
-    bool neverFoundMouseEvent = true;
-    XEvent xinputMotionEventNext;
     XEvent mouseMotionEventSave;
 #if !defined (Q_OS_IRIX)
     XID device_id;
@@ -4660,72 +4697,41 @@ bool QETWidget::translateXinputEvent(const XEvent *ev, QTabletDeviceData *tablet
 
     if (ev->type == tablet->xinput_motion) {
         motion = reinterpret_cast<const XDeviceMotionEvent*>(ev);
-        for (;;) {
-            // get the corresponding mouseMotionEvent for motion
-            if (XCheckTypedWindowEvent(X11->display, internalWinId(), MotionNotify, &mouseMotionEvent)) {
+
+        // Do event compression.  Skip over tablet+mouse move events if there are newer ones.
+        qt_tablet_motion_data tabletMotionData;
+        tabletMotionData.tabletMotionType = tablet->xinput_motion;
+        while (true) {
+            // Find first mouse event since we expect them in pairs inside Qt
+            tabletMotionData.error =false;
+            tabletMotionData.timestamp = 0;
+            if (XCheckIfEvent(X11->display, &mouseMotionEvent, &qt_mouseMotion_scanner, (XPointer) &tabletMotionData)) {
                 mouseMotionEventSave = mouseMotionEvent;
                 reinsertMouseEvent = true;
-                neverFoundMouseEvent = false;
-
-                if (mouseMotionEvent.xmotion.time > motion->time) {
-                    XEvent xinputMotionEventLoop = *ev;
-
-                    // xinput event is older than the mouse event --> search for the corresponding xinput event for the given mouse event
-                    while (mouseMotionEvent.xmotion.time > (reinterpret_cast<const XDeviceMotionEvent*>(&xinputMotionEventLoop))->time) {
-                        if (XCheckTypedWindowEvent(X11->display, internalWinId(), tablet->xinput_motion, &xinputMotionEventLoop)) {
-                            xinputMotionEvent = xinputMotionEventLoop;
-                        }
-                        else {
-                            break;
-                        }
-                    }
-                    motion = reinterpret_cast<const XDeviceMotionEvent*>(&xinputMotionEvent);
-                }
-
-                // get the next xinputMotionEvent, for the next loop run
-                if (!XCheckTypedWindowEvent(X11->display, internalWinId(), tablet->xinput_motion, &xinputMotionEventNext)) {
-                    XPutBackEvent(X11->display, &mouseMotionEvent);
-                    reinsertMouseEvent = false;
-                    break;
-                }
-
-                if (mouseMotionEvent.xmotion.time != motion->time) {
-                    // reinsert in order
-                    if (mouseMotionEvent.xmotion.time >= motion->time) {
-                        XPutBackEvent(X11->display, &mouseMotionEvent);
-                        XPutBackEvent(X11->display, &xinputMotionEventNext);
-                        // next entry in queue is xinputMotionEventNext
-                    }
-                    else {
-                        XPutBackEvent(X11->display, &xinputMotionEventNext);
-                        XPutBackEvent(X11->display, &mouseMotionEvent);
-                        // next entry in queue is mouseMotionEvent
-                    }
-                    reinsertMouseEvent = false;
-                    break;
-                }
-            }
-            else {
+            } else {
                 break;
             }
 
-            xinputMotionEvent = xinputMotionEventNext;
-            motion = (reinterpret_cast<const XDeviceMotionEvent*>(&xinputMotionEvent));
-        }
+            // Now discard any duplicate tablet events.
+            XEvent dummy;
+            tabletMotionData.error = false;
+            tabletMotionData.timestamp = mouseMotionEvent.xmotion.time;
+            while (XCheckIfEvent(X11->display, &dummy, &qt_tabletMotion_scanner, (XPointer) &tabletMotionData)) {
+                motion = reinterpret_cast<const XDeviceMotionEvent*>(&dummy);
+            }
 
-        if (reinsertMouseEvent) {
-          XPutBackEvent(X11->display, &mouseMotionEventSave);
+            // now check if there are more recent tablet motion events since we'll compress the current one with
+            // newer ones in that case
+            tabletMotionData.error = false;
+            tabletMotionData.timestamp = 0;
+            if (! XCheckIfEvent(X11->display, &dummy, &qt_tabletMotion_scanner, (XPointer) &tabletMotionData)) {
+                break; // done with compression
+            }
+            motion = reinterpret_cast<const XDeviceMotionEvent*>(&dummy);
         }
 
-        if (neverFoundMouseEvent) {
-            XEvent xinputMotionEventLoop;
-            bool eventFound = false;
-            // xinput event without mouseMotionEvent --> search the newest xinputMotionEvent
-            while (XCheckTypedWindowEvent(X11->display, internalWinId(), tablet->xinput_motion, &xinputMotionEventLoop)) {
-                xinputMotionEvent = xinputMotionEventLoop;
-                eventFound = true;
-            }
-            if (eventFound) motion = reinterpret_cast<const XDeviceMotionEvent*>(&xinputMotionEvent);
+        if (reinsertMouseEvent) {
+            XPutBackEvent(X11->display, &mouseMotionEventSave);
         }
 
         t = QEvent::TabletMove;
diff --git a/src/gui/widgets/qmenubar.cpp b/src/gui/widgets/qmenubar.cpp
index 3857e30..34de252 100644
--- a/src/gui/widgets/qmenubar.cpp
+++ b/src/gui/widgets/qmenubar.cpp
@@ -1253,7 +1253,8 @@ void QMenuBar::mouseMoveEvent(QMouseEvent *e)
 void QMenuBar::leaveEvent(QEvent *)
 {
     Q_D(QMenuBar);
-    if(!hasFocus() && !d->popupState)
+    if((!hasFocus() && !d->popupState) ||
+        (d->currentAction && d->currentAction->menu() == 0))
         d->setCurrentAction(0);
 }
 
diff --git a/src/network/access/qnetworkaccesscache_p.h b/src/network/access/qnetworkaccesscache_p.h
index 3fdfbb4..439b3a0 100644
--- a/src/network/access/qnetworkaccesscache_p.h
+++ b/src/network/access/qnetworkaccesscache_p.h
@@ -64,6 +64,9 @@ QT_BEGIN_NAMESPACE
 class QNetworkRequest;
 class QUrl;
 
+// this class is not about caching files but about
+// caching objects used by QNetworkAccessManager, e.g. existing TCP connections
+// or credentials.
 class QNetworkAccessCache: public QObject
 {
     Q_OBJECT
diff --git a/src/network/access/qnetworkaccessftpbackend.cpp b/src/network/access/qnetworkaccessftpbackend.cpp
index 9be433d..d6276a3 100644
--- a/src/network/access/qnetworkaccessftpbackend.cpp
+++ b/src/network/access/qnetworkaccessftpbackend.cpp
@@ -82,11 +82,11 @@ QNetworkAccessFtpBackendFactory::create(QNetworkAccessManager::Operation op,
     return 0;
 }
 
-class QNetworkAccessFtpFtp: public QFtp, public QNetworkAccessCache::CacheableObject
+class QNetworkAccessCachedFtpConnection: public QFtp, public QNetworkAccessCache::CacheableObject
 {
     // Q_OBJECT
 public:
-    QNetworkAccessFtpFtp()
+    QNetworkAccessCachedFtpConnection()
     {
         setExpires(true);
         setShareable(false);
@@ -148,11 +148,11 @@ void QNetworkAccessFtpBackend::open()
     }
     state = LoggingIn;
 
-    QNetworkAccessCache* cache = QNetworkAccessManagerPrivate::getCache(this);
+    QNetworkAccessCache* objectCache = QNetworkAccessManagerPrivate::getObjectCache(this);
     QByteArray cacheKey = makeCacheKey(url);
-    if (!cache->requestEntry(cacheKey, this,
+    if (!objectCache->requestEntry(cacheKey, this,
                              SLOT(ftpConnectionReady(QNetworkAccessCache::CacheableObject*)))) {
-        ftp = new QNetworkAccessFtpFtp;
+        ftp = new QNetworkAccessCachedFtpConnection;
 #ifndef QT_NO_NETWORKPROXY
         if (proxy.type() == QNetworkProxy::FtpCachingProxy)
             ftp->setProxy(proxy.hostName(), proxy.port());
@@ -160,7 +160,7 @@ void QNetworkAccessFtpBackend::open()
         ftp->connectToHost(url.host(), url.port(DefaultFtpPort));
         ftp->login(url.userName(), url.password());
 
-        cache->addEntry(cacheKey, ftp);
+        objectCache->addEntry(cacheKey, ftp);
         ftpConnectionReady(ftp);
     }
 
@@ -207,7 +207,7 @@ void QNetworkAccessFtpBackend::downstreamReadyWrite()
 
 void QNetworkAccessFtpBackend::ftpConnectionReady(QNetworkAccessCache::CacheableObject *o)
 {
-    ftp = static_cast<QNetworkAccessFtpFtp *>(o);
+    ftp = static_cast<QNetworkAccessCachedFtpConnection *>(o);
     connect(ftp, SIGNAL(done(bool)), SLOT(ftpDone()));
     connect(ftp, SIGNAL(rawCommandReply(int,QString)), SLOT(ftpRawCommandReply(int,QString)));
     connect(ftp, SIGNAL(readyRead()), SLOT(ftpReadyRead()));
@@ -227,7 +227,7 @@ void QNetworkAccessFtpBackend::disconnectFromFtp()
         disconnect(ftp, 0, this, 0);
 
         QByteArray key = makeCacheKey(url());
-        QNetworkAccessManagerPrivate::getCache(this)->releaseEntry(key);
+        QNetworkAccessManagerPrivate::getObjectCache(this)->releaseEntry(key);
 
         ftp = 0;
     }
@@ -278,7 +278,7 @@ void QNetworkAccessFtpBackend::ftpDone()
 
         // we're not connected, so remove the cache entry:
         QByteArray key = makeCacheKey(url());
-        QNetworkAccessManagerPrivate::getCache(this)->removeEntry(key);
+        QNetworkAccessManagerPrivate::getObjectCache(this)->removeEntry(key);
 
         disconnect(ftp, 0, this, 0);
         ftp->dispose();
diff --git a/src/network/access/qnetworkaccessftpbackend_p.h b/src/network/access/qnetworkaccessftpbackend_p.h
index 9626403..bb6d766 100644
--- a/src/network/access/qnetworkaccessftpbackend_p.h
+++ b/src/network/access/qnetworkaccessftpbackend_p.h
@@ -66,7 +66,7 @@
 QT_BEGIN_NAMESPACE
 
 class QNetworkAccessFtpIODevice;
-class QNetworkAccessFtpFtp;
+class QNetworkAccessCachedFtpConnection;
 
 class QNetworkAccessFtpBackend: public QNetworkAccessBackend
 {
@@ -101,7 +101,7 @@ public slots:
 
 private:
     friend class QNetworkAccessFtpIODevice;
-    QPointer<QNetworkAccessFtpFtp> ftp;
+    QPointer<QNetworkAccessCachedFtpConnection> ftp;
     QIODevice *uploadDevice;
     qint64 totalBytes;
     int helpId, sizeId, mdtmId;
diff --git a/src/network/access/qnetworkaccesshttpbackend.cpp b/src/network/access/qnetworkaccesshttpbackend.cpp
index 460cbe3..71808d4 100644
--- a/src/network/access/qnetworkaccesshttpbackend.cpp
+++ b/src/network/access/qnetworkaccesshttpbackend.cpp
@@ -270,12 +270,12 @@ static QNetworkReply::NetworkError statusCodeFromHttp(int httpStatusCode, const
     return code;
 }
 
-class QNetworkAccessHttpBackendCache: public QHttpNetworkConnection,
+class QNetworkAccessCachedHttpConnection: public QHttpNetworkConnection,
                                       public QNetworkAccessCache::CacheableObject
 {
     // Q_OBJECT
 public:
-    QNetworkAccessHttpBackendCache(const QString &hostName, quint16 port, bool encrypt)
+    QNetworkAccessCachedHttpConnection(const QString &hostName, quint16 port, bool encrypt)
         : QHttpNetworkConnection(hostName, port, encrypt)
     {
         setExpires(true);
@@ -311,11 +311,15 @@ QNetworkAccessHttpBackend::~QNetworkAccessHttpBackend()
 void QNetworkAccessHttpBackend::disconnectFromHttp()
 {
     if (http) {
+        // This is abut disconnecting signals, not about disconnecting TCP connections
         disconnect(http, 0, this, 0);
-        QNetworkAccessCache *cache = QNetworkAccessManagerPrivate::getCache(this);
+
+        // Get the object cache that stores our QHttpNetworkConnection objects
+        QNetworkAccessCache *cache = QNetworkAccessManagerPrivate::getObjectCache(this);
         cache->releaseEntry(cacheKey);
     }
 
+    // This is abut disconnecting signals, not about disconnecting TCP connections
     if (httpReply)
         disconnect(httpReply, 0, this, 0);
 
@@ -582,16 +586,20 @@ void QNetworkAccessHttpBackend::open()
 
     // check if we have an open connection to this host
     cacheKey = makeCacheKey(this, theProxy);
-    QNetworkAccessCache *cache = QNetworkAccessManagerPrivate::getCache(this);
-    if ((http = static_cast<QNetworkAccessHttpBackendCache *>(cache->requestEntryNow(cacheKey))) == 0) {
+    QNetworkAccessCache *cache = QNetworkAccessManagerPrivate::getObjectCache(this);
+    // the http object is actually a QHttpNetworkConnection
+    http = static_cast<QNetworkAccessCachedHttpConnection *>(cache->requestEntryNow(cacheKey));
+    if (http == 0) {
         // no entry in cache; create an object
-        http = new QNetworkAccessHttpBackendCache(url.host(), url.port(), encrypt);
+        // the http object is actually a QHttpNetworkConnection
+        http = new QNetworkAccessCachedHttpConnection(url.host(), url.port(), encrypt);
 
 #ifndef QT_NO_NETWORKPROXY
         http->setTransparentProxy(transparentProxy);
         http->setCacheProxy(cacheProxy);
 #endif
 
+        // cache the QHttpNetworkConnection corresponding to this cache key
         cache->addEntry(cacheKey, http);
     }
 
diff --git a/src/network/access/qnetworkaccesshttpbackend_p.h b/src/network/access/qnetworkaccesshttpbackend_p.h
index e0801ce..dec69d0 100644
--- a/src/network/access/qnetworkaccesshttpbackend_p.h
+++ b/src/network/access/qnetworkaccesshttpbackend_p.h
@@ -66,7 +66,7 @@
 
 QT_BEGIN_NAMESPACE
 
-class QNetworkAccessHttpBackendCache;
+class QNetworkAccessCachedHttpConnection;
 
 class QNetworkAccessHttpBackendIODevice;
 
@@ -106,7 +106,7 @@ private slots:
 
 private:
     QHttpNetworkReply *httpReply;
-    QPointer<QNetworkAccessHttpBackendCache> http;
+    QPointer<QNetworkAccessCachedHttpConnection> http;
     QByteArray cacheKey;
     QNetworkAccessBackendUploadIODevice *uploadDevice;
 
diff --git a/src/network/access/qnetworkaccessmanager.cpp b/src/network/access/qnetworkaccessmanager.cpp
index 0ae920b..ed2f220 100644
--- a/src/network/access/qnetworkaccessmanager.cpp
+++ b/src/network/access/qnetworkaccessmanager.cpp
@@ -836,7 +836,7 @@ void QNetworkAccessManagerPrivate::addCredentials(const QNetworkProxy &p,
 
             QNetworkAuthenticationCache *auth = new QNetworkAuthenticationCache;
             auth->insert(QString(), authenticator->user(), authenticator->password());
-            cache.addEntry(cacheKey, auth); // replace the existing one, if there's any
+            objectCache.addEntry(cacheKey, auth); // replace the existing one, if there's any
 
             if (realm.isEmpty()) {
                 break;
@@ -870,13 +870,13 @@ QNetworkAccessManagerPrivate::fetchCachedCredentials(const QNetworkProxy &p,
     QByteArray cacheKey = proxyAuthenticationKey(proxy, realm);
     if (cacheKey.isEmpty())
         return 0;
-    if (!cache.hasEntry(cacheKey))
+    if (!objectCache.hasEntry(cacheKey))
         return 0;
 
     QNetworkAuthenticationCache *auth =
-        static_cast<QNetworkAuthenticationCache *>(cache.requestEntryNow(cacheKey));
+        static_cast<QNetworkAuthenticationCache *>(objectCache.requestEntryNow(cacheKey));
     QNetworkAuthenticationCredential *cred = auth->findClosestMatch(QString());
-    cache.releaseEntry(cacheKey);
+    objectCache.releaseEntry(cacheKey);
 
     // proxy cache credentials always have exactly one item
     Q_ASSERT_X(cred, "QNetworkAccessManager",
@@ -917,15 +917,15 @@ void QNetworkAccessManagerPrivate::addCredentials(const QUrl &url,
     copy.setUserName(authenticator->user());
     do {
         QByteArray cacheKey = authenticationKey(copy, realm);
-        if (cache.hasEntry(cacheKey)) {
+        if (objectCache.hasEntry(cacheKey)) {
             QNetworkAuthenticationCache *auth =
-                static_cast<QNetworkAuthenticationCache *>(cache.requestEntryNow(cacheKey));
+                static_cast<QNetworkAuthenticationCache *>(objectCache.requestEntryNow(cacheKey));
             auth->insert(domain, authenticator->user(), authenticator->password());
-            cache.releaseEntry(cacheKey);
+            objectCache.releaseEntry(cacheKey);
         } else {
             QNetworkAuthenticationCache *auth = new QNetworkAuthenticationCache;
             auth->insert(domain, authenticator->user(), authenticator->password());
-            cache.addEntry(cacheKey, auth);
+            objectCache.addEntry(cacheKey, auth);
         }
 
         if (copy.userName().isEmpty()) {
@@ -959,19 +959,19 @@ QNetworkAccessManagerPrivate::fetchCachedCredentials(const QUrl &url,
         realm = authentication->realm();
 
     QByteArray cacheKey = authenticationKey(url, realm);
-    if (!cache.hasEntry(cacheKey))
+    if (!objectCache.hasEntry(cacheKey))
         return 0;
 
     QNetworkAuthenticationCache *auth =
-        static_cast<QNetworkAuthenticationCache *>(cache.requestEntryNow(cacheKey));
+        static_cast<QNetworkAuthenticationCache *>(objectCache.requestEntryNow(cacheKey));
     QNetworkAuthenticationCredential *cred = auth->findClosestMatch(url.path());
-    cache.releaseEntry(cacheKey);
+    objectCache.releaseEntry(cacheKey);
     return cred;
 }
 
 void QNetworkAccessManagerPrivate::clearCache(QNetworkAccessManager *manager)
 {
-    manager->d_func()->cache.clear();
+    manager->d_func()->objectCache.clear();
 }
 
 QT_END_NAMESPACE
diff --git a/src/network/access/qnetworkaccessmanager_p.h b/src/network/access/qnetworkaccessmanager_p.h
index c80613b..bcf9a2b 100644
--- a/src/network/access/qnetworkaccessmanager_p.h
+++ b/src/network/access/qnetworkaccessmanager_p.h
@@ -98,10 +98,12 @@ public:
 
     QNetworkAccessBackend *findBackend(QNetworkAccessManager::Operation op, const QNetworkRequest &request);
 
+    // this is the cache for storing downloaded files
     QAbstractNetworkCache *networkCache;
+
     QNetworkCookieJar *cookieJar;
 
-    QNetworkAccessCache cache;
+
 #ifndef QT_NO_NETWORKPROXY
     QNetworkProxy proxy;
     QNetworkProxyFactory *proxyFactory;
@@ -109,8 +111,12 @@ public:
 
     bool cookieJarCreated;
 
-    static inline QNetworkAccessCache *getCache(QNetworkAccessBackend *backend)
-    { return &backend->manager->cache; }
+
+    // this cache can be used by individual backends to cache e.g. their TCP connections to a server
+    // and use the connections for multiple requests.
+    QNetworkAccessCache objectCache;
+    static inline QNetworkAccessCache *getObjectCache(QNetworkAccessBackend *backend)
+    { return &backend->manager->objectCache; }
     Q_AUTOTEST_EXPORT static void clearCache(QNetworkAccessManager *manager);
 
     Q_DECLARE_PUBLIC(QNetworkAccessManager)
diff --git a/src/network/socket/qabstractsocket.cpp b/src/network/socket/qabstractsocket.cpp
index 19bfe51..d099382 100644
--- a/src/network/socket/qabstractsocket.cpp
+++ b/src/network/socket/qabstractsocket.cpp
@@ -1658,13 +1658,13 @@ bool QAbstractSocket::waitForConnected(int msecs)
 }
 
 /*!
-    This function blocks until data is available for reading and the
+    This function blocks until new data is available for reading and the
     \l{QIODevice::}{readyRead()} signal has been emitted. The function
     will timeout after \a msecs milliseconds; the default timeout is
     30000 milliseconds.
 
     The function returns true if the readyRead() signal is emitted and
-    there is data available for reading; otherwise it returns false
+    there is new data available for reading; otherwise it returns false
     (if an error occurred or the operation timed out).
 
     \sa waitForBytesWritten() 
diff --git a/src/network/ssl/qsslcertificate.cpp b/src/network/ssl/qsslcertificate.cpp
index d2cd0d6..9d8cfb0 100644
--- a/src/network/ssl/qsslcertificate.cpp
+++ b/src/network/ssl/qsslcertificate.cpp
@@ -71,9 +71,10 @@
     After loading a certificate, you can find information about the
     certificate, its subject, and its issuer, by calling one of the
     many accessor functions, including version(), serialNumber(),
-    issuerInfo() and subjectInfo(). You can call notValidBefore() and
-    notValidAfter() to check when the certificate was issued, and when
-    it expires. The publicKey() function returns the certificate
+    issuerInfo() and subjectInfo(). You can call effectiveDate() and
+    expiryDate() to check when the certificate starts being
+    effective and when it expires.
+    The publicKey() function returns the certificate
     subject's public key as a QSslKey. You can call issuerInfo() or
     subjectInfo() to get detailed information about the certificate
     issuer and its subject.
diff --git a/src/opengl/qpaintengine_opengl.cpp b/src/opengl/qpaintengine_opengl.cpp
index 84ad4d5..b594f5b 100644
--- a/src/opengl/qpaintengine_opengl.cpp
+++ b/src/opengl/qpaintengine_opengl.cpp
@@ -662,6 +662,7 @@ public:
         , txop(QTransform::TxNone)
         , inverseScale(1)
         , moveToCount(0)
+        , last_created_state(0)
         , shader_ctx(0)
         , grad_palette(0)
         , drawable_texture(0)
@@ -788,6 +789,8 @@ public:
 
     void updateGLMatrix() const;
 
+    mutable QPainterState *last_created_state;
+
     QGLContext *shader_ctx;
     GLuint grad_palette;
 
@@ -2219,6 +2222,8 @@ void QOpenGLPaintEnginePrivate::updateDepthClip()
 {
     Q_Q(QOpenGLPaintEngine);
 
+    ++q->state()->depthClipId;
+
     glDisable(GL_DEPTH_TEST);
     glDisable(GL_SCISSOR_TEST);
 
@@ -5501,9 +5506,20 @@ void QOpenGLPaintEngine::clip(const QVectorPath &path, Qt::ClipOperation op)
 void QOpenGLPaintEngine::setState(QPainterState *s)
 {
     Q_D(QOpenGLPaintEngine);
+    QOpenGLPaintEngineState *new_state = static_cast<QOpenGLPaintEngineState *>(s);
+    QOpenGLPaintEngineState *old_state = state();
+
     QPaintEngineEx::setState(s);
+
+    // are we in a save() ?
+    if (s == d->last_created_state) {
+        d->last_created_state = 0;
+        return;
+    }
+
     if (isActive()) {
-        d->updateDepthClip();
+        if (old_state->depthClipId != new_state->depthClipId)
+            d->updateDepthClip();
         penChanged();
         brushChanged();
         opacityChanged();
@@ -5515,12 +5531,15 @@ void QOpenGLPaintEngine::setState(QPainterState *s)
 
 QPainterState *QOpenGLPaintEngine::createState(QPainterState *orig) const
 {
+    const Q_D(QOpenGLPaintEngine);
+
     QOpenGLPaintEngineState *s;
     if (!orig)
         s = new QOpenGLPaintEngineState();
     else
         s = new QOpenGLPaintEngineState(*static_cast<QOpenGLPaintEngineState *>(orig));
 
+    d->last_created_state = s;
     return s;
 }
 
@@ -5534,11 +5553,13 @@ QOpenGLPaintEngineState::QOpenGLPaintEngineState(QOpenGLPaintEngineState &other)
     clipRegion = other.clipRegion;
     hasClipping = other.hasClipping;
     fastClip = other.fastClip;
+    depthClipId = other.depthClipId;
 }
 
 QOpenGLPaintEngineState::QOpenGLPaintEngineState()
 {
     hasClipping = false;
+    depthClipId = 0;
 }
 
 QOpenGLPaintEngineState::~QOpenGLPaintEngineState()
diff --git a/src/opengl/qpaintengine_opengl_p.h b/src/opengl/qpaintengine_opengl_p.h
index 891cbd6..439782b 100644
--- a/src/opengl/qpaintengine_opengl_p.h
+++ b/src/opengl/qpaintengine_opengl_p.h
@@ -69,6 +69,7 @@ public:
     QRegion clipRegion;
     bool hasClipping;
     QRect fastClip;
+    uint depthClipId;
 };
 
 class QOpenGLPaintEngine : public QPaintEngineEx
diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbpaintdevice.cpp b/src/plugins/gfxdrivers/directfb/qdirectfbpaintdevice.cpp
index 52f6a37..905fec3 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbpaintdevice.cpp
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbpaintdevice.cpp
@@ -129,18 +129,14 @@ int QDirectFBPaintDevice::metric(QPaintDevice::PaintDeviceMetric metric) const
     if (!dfbSurface)
         return 0;
 
-    int w, h;
-    dfbSurface->GetSize(dfbSurface, &w, &h);
-
     switch (metric) {
     case QPaintDevice::PdmWidth:
-        return w;
     case QPaintDevice::PdmHeight:
-        return h;
+        return (metric == PdmWidth ? size().width() : size().height());
     case QPaintDevice::PdmWidthMM:
-        return (w * 1000) / dotsPerMeterX();
+        return (size().width() * 1000) / dotsPerMeterX();
     case QPaintDevice::PdmHeightMM:
-        return (h * 1000) / dotsPerMeterY();
+        return (size().height() * 1000) / dotsPerMeterY();
     case QPaintDevice::PdmPhysicalDpiX:
     case QPaintDevice::PdmDpiX:
         return (dotsPerMeterX() * 254) / 10000; // 0.0254 meters-per-inch
diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbpixmap.cpp b/src/plugins/gfxdrivers/directfb/qdirectfbpixmap.cpp
index c239248..1c86466 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbpixmap.cpp
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbpixmap.cpp
@@ -72,9 +72,10 @@ void QDirectFBPixmapData::resize(int width, int height)
     }
 
     format = screen->pixelFormat();
-    dfbSurface = QDirectFBScreen::instance()->createDFBSurface(QSize(width, height),
-                                                               format,
-                                                               QDirectFBScreen::TrackSurface);
+    dfbSurface = screen->createDFBSurface(QSize(width, height),
+                                          format,
+                                          QDirectFBScreen::TrackSurface);
+    d = screen->depth();
     alpha = false;
     if (!dfbSurface) {
         invalidate();
@@ -195,8 +196,8 @@ void QDirectFBPixmapData::fromImage(const QImage &i,
         invalidate();
         return;
     }
-    w = metric(QPaintDevice::PdmWidth);
-    h = metric(QPaintDevice::PdmHeight);
+    w = img.width();
+    h = img.height();
     is_null = (w <= 0 || h <= 0);
     d = metric(QPaintDevice::PdmDepth);
     setSerialNumber(++global_ser_no);
@@ -209,7 +210,8 @@ void QDirectFBPixmapData::copy(const QPixmapData *data, const QRect &rect)
         return;
     }
 
-    IDirectFBSurface *src = static_cast<const QDirectFBPixmapData*>(data)->directFBSurface();
+    const QDirectFBPixmapData *otherData = static_cast<const QDirectFBPixmapData*>(data);
+    IDirectFBSurface *src = otherData->directFBSurface();
     alpha = data->hasAlphaChannel();
     format = (alpha
               ? QDirectFBScreen::instance()->alphaPixmapFormat()
@@ -232,6 +234,9 @@ void QDirectFBPixmapData::copy(const QPixmapData *data, const QRect &rect)
     }
     const DFBRectangle blitRect = { rect.x(), rect.y(),
                                     rect.width(), rect.height() };
+    w = rect.width();
+    h = rect.height();
+    d = otherData->d;
     DFBResult result = dfbSurface->Blit(dfbSurface, src, &blitRect, 0, 0);
 #if (Q_DIRECTFB_VERSION >= 0x010000)
     dfbSurface->ReleaseSource(dfbSurface);
@@ -303,9 +308,6 @@ QPixmap QDirectFBPixmapData::transformed(const QTransform &transform,
         return QPixmap(data);
     }
 
-    int w, h;
-    dfbSurface->GetSize(dfbSurface, &w, &h);
-
     const QSize size = transform.mapRect(QRect(0, 0, w, h)).size();
     if (size.isEmpty())
         return QPixmap();
@@ -326,6 +328,8 @@ QPixmap QDirectFBPixmapData::transformed(const QTransform &transform,
 
     const DFBRectangle destRect = { 0, 0, size.width(), size.height() };
     data->dfbSurface->StretchBlit(data->dfbSurface, dfbSurface, 0, &destRect);
+    data->w = size.width();
+    data->h = size.height();
 #if (Q_DIRECTFB_VERSION >= 0x010000)
     data->dfbSurface->ReleaseSource(data->dfbSurface);
 #endif
@@ -338,7 +342,7 @@ QImage QDirectFBPixmapData::toImage() const
         return QImage();
 
 #ifndef QT_NO_DIRECTFB_PREALLOCATED
-    QImage ret(size(), QDirectFBScreen::getImageFormat(dfbSurface));
+    QImage ret(w, h, QDirectFBScreen::getImageFormat(dfbSurface));
     if (IDirectFBSurface *imgSurface = screen->createDFBSurface(ret, QDirectFBScreen::DontTrackSurface)) {
         if (hasAlphaChannel()) {
             imgSurface->SetBlittingFlags(imgSurface, DSBLIT_BLEND_ALPHACHANNEL);
@@ -387,6 +391,7 @@ void QDirectFBPixmapData::invalidate()
 {
     setSerialNumber(0);
     alpha = false;
+    d = w = h = 0;
     format = QImage::Format_Invalid;
 }
 
diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbscreen.cpp b/src/plugins/gfxdrivers/directfb/qdirectfbscreen.cpp
index 5d89994..62fef5b 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbscreen.cpp
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbscreen.cpp
@@ -751,12 +751,7 @@ QPixmapData *QDirectFBScreenPrivate::createPixmapData(QPixmapData::PixelType typ
     return new QDirectFBPixmapData(type);
 }
 
-#ifdef QT_NO_DEBUG
-struct FlagDescription;
-static const FlagDescription *accelerationDescriptions = 0;
-static const FlagDescription *blitDescriptions = 0;
-static const FlagDescription *drawDescriptions = 0;
-#else
+#ifndef QT_NO_DEBUG
 struct FlagDescription {
     const char *name;
     uint flag;
diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbscreen.h b/src/plugins/gfxdrivers/directfb/qdirectfbscreen.h
index c2c9a59..4239156 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbscreen.h
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbscreen.h
@@ -118,6 +118,7 @@ public:
                                      SurfaceCreationOptions options);
     void releaseDFBSurface(IDirectFBSurface *surface);
 
+    using QScreen::depth;
     static int depth(DFBSurfacePixelFormat format);
 
     static DFBSurfacePixelFormat getSurfacePixelFormat(QImage::Format format);
diff --git a/src/scripttools/debugging/qscriptdebugger.cpp b/src/scripttools/debugging/qscriptdebugger.cpp
index 9cca8ad..20de788 100644
--- a/src/scripttools/debugging/qscriptdebugger.cpp
+++ b/src/scripttools/debugging/qscriptdebugger.cpp
@@ -75,10 +75,6 @@
 #include "qscriptdebuggerjob_p_p.h"
 #include "qscriptxmlparser_p.h"
 
-#include "qscriptenginedebuggerfrontend_p.h"
-#include "qscriptdebuggerbackend_p.h"
-#include <QtScript/qscriptengine.h>
-
 #include "private/qobject_p.h"
 
 #include <QtScript/qscriptcontext.h>
@@ -1946,6 +1942,12 @@ QToolBar *QScriptDebugger::createStandardToolBar(QWidget *widgetParent, QObject
     return tb;
 }
 
+bool QScriptDebugger::isInteractive() const
+{
+    Q_D(const QScriptDebugger);
+    return d->interactive;
+}
+
 /*!
   \reimp
 */
diff --git a/src/scripttools/debugging/qscriptdebugger_p.h b/src/scripttools/debugging/qscriptdebugger_p.h
index 9ed7e0a..ba27200 100644
--- a/src/scripttools/debugging/qscriptdebugger_p.h
+++ b/src/scripttools/debugging/qscriptdebugger_p.h
@@ -172,6 +172,8 @@ public:
 
     bool eventFilter(QObject *, QEvent *e);
 
+    bool isInteractive() const;
+
 Q_SIGNALS:
     void stopped() const;
     void started() const;
diff --git a/src/scripttools/debugging/qscriptdebuggerbackend.cpp b/src/scripttools/debugging/qscriptdebuggerbackend.cpp
index 9eaf571..7f4211c 100644
--- a/src/scripttools/debugging/qscriptdebuggerbackend.cpp
+++ b/src/scripttools/debugging/qscriptdebuggerbackend.cpp
@@ -412,14 +412,15 @@ void QScriptDebuggerBackend::attachTo(QScriptEngine *engine)
     detach();
     d->agent = new QScriptDebuggerAgent(d, engine);
     QScriptValue global = engine->globalObject();
+    d->origTraceFunction = global.property(QString::fromLatin1("print"));
     global.setProperty(QString::fromLatin1("print"), traceFunction());
 //    global.setProperty(QString::fromLatin1("qAssert"), assertFunction());
+    d->origFileNameFunction = global.property(QString::fromLatin1("__FILE__"));
     global.setProperty(QString::fromLatin1("__FILE__"), fileNameFunction(),
-                       QScriptValue::PropertyGetter | QScriptValue::PropertySetter
-                       | QScriptValue::ReadOnly);
+                       QScriptValue::PropertyGetter | QScriptValue::ReadOnly);
+    d->origLineNumberFunction = global.property(QString::fromLatin1("__LINE__"));
     global.setProperty(QString::fromLatin1("__LINE__"), lineNumberFunction(),
-                       QScriptValue::PropertyGetter | QScriptValue::PropertySetter
-                       | QScriptValue::ReadOnly);
+                       QScriptValue::PropertyGetter | QScriptValue::ReadOnly);
     engine->setAgent(d->agent);
 }
 
@@ -433,21 +434,25 @@ void QScriptDebuggerBackend::attachTo(QScriptEngine *engine)
 void QScriptDebuggerBackend::detach()
 {
     Q_D(QScriptDebuggerBackend);
-    if (!d->agent)
-        return;
-    QScriptEngine *eng = d->agent->engine();
-    if (eng && eng->agent() == d->agent) {
-        eng->setAgent(0);
-        QScriptValue global = eng->globalObject();
-        if (global.property(QString::fromLatin1("print")).strictlyEquals(traceFunction()))
-            global.setProperty(QString::fromLatin1("print"), QScriptValue());
-//        global.setProperty(QString::fromLatin1("qAssert"), QScriptValue());
-        if (global.property(QString::fromLatin1("__FILE__")).strictlyEquals(fileNameFunction()))
-            global.setProperty(QString::fromLatin1("__FILE__"), QScriptValue());
-        if (global.property(QString::fromLatin1("__LINE__")).strictlyEquals(lineNumberFunction()))
-            global.setProperty(QString::fromLatin1("__LINE__"), QScriptValue());
-        d->agent->nullifyBackendPointer();
-        d->agent = 0; // agent is owned by engine
+    if (d->agent) {
+        QScriptEngine *eng = d->agent->engine();
+        if (eng && eng->agent() == d->agent) {
+            eng->setAgent(0);
+            QScriptValue global = eng->globalObject();
+            global.setProperty(QString::fromLatin1("print"), d->origTraceFunction);
+            d->origTraceFunction = QScriptValue();
+//            global.setProperty(QString::fromLatin1("qAssert"), QScriptValue());
+            global.setProperty(QString::fromLatin1("__FILE__"), QScriptValue(),
+                               QScriptValue::PropertyGetter);
+            global.setProperty(QString::fromLatin1("__FILE__"), d->origFileNameFunction);
+            d->origFileNameFunction = QScriptValue();
+            global.setProperty(QString::fromLatin1("__LINE__"), QScriptValue(),
+                               QScriptValue::PropertyGetter);
+            global.setProperty(QString::fromLatin1("__LINE__"), d->origLineNumberFunction);
+            d->origLineNumberFunction = QScriptValue();
+            d->agent->nullifyBackendPointer();
+            d->agent = 0; // agent is owned by engine
+        }
     }
 
     d->pendingEvaluateLineNumber = -1;
diff --git a/src/scripttools/debugging/qscriptdebuggerbackend_p_p.h b/src/scripttools/debugging/qscriptdebuggerbackend_p_p.h
index de18304..a356762 100644
--- a/src/scripttools/debugging/qscriptdebuggerbackend_p_p.h
+++ b/src/scripttools/debugging/qscriptdebuggerbackend_p_p.h
@@ -57,6 +57,7 @@
 
 #include <QtCore/qhash.h>
 #include <QtCore/qlist.h>
+#include <QtScript/qscriptvalue.h>
 
 #include "qscriptdebuggerbackend_p.h"
 
@@ -66,7 +67,6 @@ class QEvent;
 class QString;
 class QScriptContext;
 class QScriptEngine;
-class QScriptValue;
 class QScriptValueIterator;
 class QScriptObjectSnapshot;
 class QScriptDebuggerAgent;
@@ -126,6 +126,10 @@ public:
     QObject *eventReceiver;
 
     QScriptDebuggerBackend *q_ptr;
+
+    QScriptValue origTraceFunction;
+    QScriptValue origFileNameFunction;
+    QScriptValue origLineNumberFunction;
 };
 
 QT_END_NAMESPACE
diff --git a/src/scripttools/debugging/qscriptenginedebugger.cpp b/src/scripttools/debugging/qscriptenginedebugger.cpp
index 948a01a..f2245cc 100644
--- a/src/scripttools/debugging/qscriptenginedebugger.cpp
+++ b/src/scripttools/debugging/qscriptenginedebugger.cpp
@@ -126,7 +126,7 @@ public:
   mode in which it accepts input from the user. The
   evaluationResumed() signal is emitted when script evaluation is
   resumed, i.e, when execution control is given back to the script
-  engine.
+  engine. The state() function returns the debugger's current state.
 
   When calling QScriptEngine::evaluate() it is useful to pass a
   descriptive script name (file name) as second argument, as this is
@@ -226,6 +226,16 @@ public:
     \value GoToLineAction Shows the "Go to Line" dialog.
 */
 
+/*!
+    \enum QScriptEngineDebugger::DebuggerState
+    \since 4.6
+
+    This enum specifies the current state of the debugger.
+
+    \value RunningState   The debugger is running.  (Script evaluation is allowed.)
+    \value SuspendedState The debugger has suspended script evaluation.
+*/
+
 class QScriptEngineDebuggerPrivate
     : public QObjectPrivate
 {
@@ -387,6 +397,20 @@ void QScriptEngineDebugger::detach()
 }
 
 /*!
+  \since 4.6
+
+  Returns the current state of the debugger.
+
+  \sa evaluationResumed()
+  \sa evaluationSuspended()
+*/
+QScriptEngineDebugger::DebuggerState QScriptEngineDebugger::state() const
+{
+    Q_D(const QScriptEngineDebugger);
+    return !d->debugger || !d->debugger->isInteractive() ? SuspendedState : RunningState;
+}
+
+/*!
 
     Returns a pointer to the instance of the specified standard \a
     widget. The widgets available are defined by the DebuggerWidget
diff --git a/src/scripttools/debugging/qscriptenginedebugger.h b/src/scripttools/debugging/qscriptenginedebugger.h
index 0fd4963..b9061a2 100644
--- a/src/scripttools/debugging/qscriptenginedebugger.h
+++ b/src/scripttools/debugging/qscriptenginedebugger.h
@@ -92,6 +92,11 @@ public:
         GoToLineAction
     };
 
+    enum DebuggerState {
+        RunningState,
+        SuspendedState
+    };
+
     QScriptEngineDebugger(QObject *parent = 0);
     ~QScriptEngineDebugger();
 
@@ -108,6 +113,8 @@ public:
     QWidget *widget(DebuggerWidget widget) const;
     QAction *action(DebuggerAction action) const;
 
+    DebuggerState state() const;
+
 Q_SIGNALS:
     void evaluationSuspended();
     void evaluationResumed();
diff --git a/tests/auto/modeltest/modeltest.cpp b/tests/auto/modeltest/modeltest.cpp
index 68b723f..c4cc820 100644
--- a/tests/auto/modeltest/modeltest.cpp
+++ b/tests/auto/modeltest/modeltest.cpp
@@ -475,7 +475,7 @@ void ModelTest::data()
 void ModelTest::rowsAboutToBeInserted ( const QModelIndex &parent, int start, int end )
 {
 //     Q_UNUSED(end);
-    qDebug() << "rowsAboutToBeInserted" << "start=" << start << "end=" << end << "parent=" << model->data ( parent ).value<QString>()
+    qDebug() << "rowsAboutToBeInserted" << "start=" << start << "end=" << end << "parent=" << model->data ( parent ).toString()
     << "current count of parent=" << model->rowCount ( parent ); // << "display of last=" << model->data( model->index(start-1, 0, parent) );
 //     qDebug() << model->index(start-1, 0, parent) << model->data( model->index(start-1, 0, parent) );
     Changing c;
@@ -496,7 +496,7 @@ void ModelTest::rowsInserted ( const QModelIndex & parent, int start, int end )
     Changing c = insert.pop();
     Q_ASSERT ( c.parent == parent );
     qDebug() << "rowsInserted"  << "start=" << start << "end=" << end << "oldsize=" << c.oldSize
-    << "parent=" << model->data ( parent ).value<QString>() << "current rowcount of parent=" << model->rowCount ( parent );
+    << "parent=" << model->data ( parent ).toString() << "current rowcount of parent=" << model->rowCount ( parent );
 
     for (int ii=start; ii <= end; ii++)
     {
diff --git a/tests/auto/qanimationgroup/tst_qanimationgroup.cpp b/tests/auto/qanimationgroup/tst_qanimationgroup.cpp
index 0457f8f..0e98797 100644
--- a/tests/auto/qanimationgroup/tst_qanimationgroup.cpp
+++ b/tests/auto/qanimationgroup/tst_qanimationgroup.cpp
@@ -206,9 +206,9 @@ void tst_QAnimationGroup::setCurrentTime()
 
     // sequence operating on same object/property
     QSequentialAnimationGroup *sequence = new QSequentialAnimationGroup();
-    QVariantAnimation *a1_s_o1 = new QPropertyAnimation(&s_o1, "value");
-    QVariantAnimation *a2_s_o1 = new QPropertyAnimation(&s_o1, "value");
-    QVariantAnimation *a3_s_o1 = new QPropertyAnimation(&s_o1, "value");
+    QAbstractAnimation *a1_s_o1 = new QPropertyAnimation(&s_o1, "value");
+    QAbstractAnimation *a2_s_o1 = new QPropertyAnimation(&s_o1, "value");
+    QAbstractAnimation *a3_s_o1 = new QPropertyAnimation(&s_o1, "value");
     a2_s_o1->setLoopCount(3);
     sequence->addAnimation(a1_s_o1);
     sequence->addAnimation(a2_s_o1);
@@ -216,25 +216,25 @@ void tst_QAnimationGroup::setCurrentTime()
 
     // sequence operating on different object/properties
     QAnimationGroup *sequence2 = new QSequentialAnimationGroup();
-    QVariantAnimation *a1_s_o2 = new QPropertyAnimation(&s_o2, "value");
-    QVariantAnimation *a1_s_o3 = new QPropertyAnimation(&s_o3, "value");
+    QAbstractAnimation *a1_s_o2 = new QPropertyAnimation(&s_o2, "value");
+    QAbstractAnimation *a1_s_o3 = new QPropertyAnimation(&s_o3, "value");
     sequence2->addAnimation(a1_s_o2);
     sequence2->addAnimation(a1_s_o3);
 
     // parallel operating on different object/properties
     QAnimationGroup *parallel = new QParallelAnimationGroup();
-    QVariantAnimation *a1_p_o1 = new QPropertyAnimation(&p_o1, "value");
-    QVariantAnimation *a1_p_o2 = new QPropertyAnimation(&p_o2, "value");
-    QVariantAnimation *a1_p_o3 = new QPropertyAnimation(&p_o3, "value");
+    QAbstractAnimation *a1_p_o1 = new QPropertyAnimation(&p_o1, "value");
+    QAbstractAnimation *a1_p_o2 = new QPropertyAnimation(&p_o2, "value");
+    QAbstractAnimation *a1_p_o3 = new QPropertyAnimation(&p_o3, "value");
     a1_p_o2->setLoopCount(3);
     parallel->addAnimation(a1_p_o1);
     parallel->addAnimation(a1_p_o2);
     parallel->addAnimation(a1_p_o3);
 
-    UncontrolledAnimation *notTimeDriven = new UncontrolledAnimation(&t_o1, "value");
+    QAbstractAnimation *notTimeDriven = new UncontrolledAnimation(&t_o1, "value");
     QCOMPARE(notTimeDriven->totalDuration(), -1);
 
-    QVariantAnimation *loopsForever = new QPropertyAnimation(&t_o2, "value");
+    QAbstractAnimation *loopsForever = new QPropertyAnimation(&t_o2, "value");
     loopsForever->setLoopCount(-1);
     QCOMPARE(loopsForever->totalDuration(), -1);
 
@@ -318,7 +318,7 @@ void tst_QAnimationGroup::setParentAutoAdd()
 {
     QParallelAnimationGroup group;
     QVariantAnimation *animation = new QPropertyAnimation(&group);
-    QCOMPARE(animation->group(), &group);
+    QCOMPARE(animation->group(), static_cast<QAnimationGroup*>(&group));
 }
 
 void tst_QAnimationGroup::beginNestedGroup()
@@ -347,8 +347,8 @@ void tst_QAnimationGroup::beginNestedGroup()
 
 void tst_QAnimationGroup::addChildTwice()
 {
-    QPropertyAnimation *subGroup;
-    QPropertyAnimation *subGroup2;
+    QAbstractAnimation *subGroup;
+    QAbstractAnimation *subGroup2;
     QAnimationGroup *parent = new QSequentialAnimationGroup();
 
     subGroup = new QPropertyAnimation();
diff --git a/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp b/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp
index e8a6d10..981efeb 100644
--- a/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp
+++ b/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp
@@ -3952,7 +3952,7 @@ void tst_QGraphicsItem::itemChange()
         QCOMPARE(tester.changes.size(), changeCount);
         QCOMPARE(tester.changes.at(tester.changes.size() - 2), QGraphicsItem::ItemFlagsChange);
         QCOMPARE(tester.changes.at(tester.changes.size() - 1), QGraphicsItem::ItemFlagsHaveChanged);
-        QVariant expectedFlags = qVariantFromValue<quint32>(QGraphicsItem::ItemIsSelectable | QGraphicsItem::ItemSendsGeometryChanges);
+        QVariant expectedFlags = qVariantFromValue<quint32>(QGraphicsItem::GraphicsItemFlags(QGraphicsItem::ItemIsSelectable | QGraphicsItem::ItemSendsGeometryChanges));
         QCOMPARE(tester.values.at(tester.values.size() - 2), expectedFlags);
         QCOMPARE(tester.values.at(tester.values.size() - 1), qVariantFromValue<quint32>(QGraphicsItem::ItemIsSelectable));
     }
diff --git a/tests/auto/qhttpnetworkconnection/qhttpnetworkconnection.pro b/tests/auto/qhttpnetworkconnection/qhttpnetworkconnection.pro
index bc750c5..3283873 100644
--- a/tests/auto/qhttpnetworkconnection/qhttpnetworkconnection.pro
+++ b/tests/auto/qhttpnetworkconnection/qhttpnetworkconnection.pro
@@ -1,4 +1,5 @@
 load(qttest_p4)
 SOURCES  += tst_qhttpnetworkconnection.cpp
+INCLUDEPATH += $$(QTDIR)/src/3rdparty/zlib
 
 QT = core network
diff --git a/tests/auto/qhttpnetworkreply/qhttpnetworkreply.pro b/tests/auto/qhttpnetworkreply/qhttpnetworkreply.pro
index 9593c55..0755055 100644
--- a/tests/auto/qhttpnetworkreply/qhttpnetworkreply.pro
+++ b/tests/auto/qhttpnetworkreply/qhttpnetworkreply.pro
@@ -1,4 +1,5 @@
 load(qttest_p4)
 SOURCES  += tst_qhttpnetworkreply.cpp
+INCLUDEPATH += $$(QTDIR)/src/3rdparty/zlib
 
 QT = core network
diff --git a/tests/auto/qmenubar/tst_qmenubar.cpp b/tests/auto/qmenubar/tst_qmenubar.cpp
index 5404d46..8a38782 100644
--- a/tests/auto/qmenubar/tst_qmenubar.cpp
+++ b/tests/auto/qmenubar/tst_qmenubar.cpp
@@ -149,6 +149,7 @@ private slots:
     void check_shortcutPress();
     void check_menuPosition();
     void task223138_triggered();
+    void task256322_highlight();
     
 #if defined(QT3_SUPPORT)
     void indexBasedInsertion_data();
@@ -1520,6 +1521,41 @@ void tst_QMenuBar::task223138_triggered()
     QCOMPARE(submenuSpy.count(), 1);
 }
 
+void tst_QMenuBar::task256322_highlight()
+{
+    QMainWindow win;
+    QMenu menu;
+    QAction *file = win.menuBar()->addMenu(&menu);
+    file->setText("file");
+    QMenu menu2;
+    QAction *file2 = win.menuBar()->addMenu(&menu2);
+    file2->setText("file2");
+    QAction *nothing = win.menuBar()->addAction("nothing");
+
+    win.show();
+
+    QTest::mouseClick(win.menuBar(), Qt::LeftButton, 0, win.menuBar()->actionGeometry(file).center());
+    QVERIFY(menu.isVisible());
+    QVERIFY(!menu2.isVisible());
+    QCOMPARE(win.menuBar()->activeAction(), file);
+
+    QTest::mouseMove(win.menuBar(), win.menuBar()->actionGeometry(file2).center());
+    QVERIFY(!menu.isVisible());
+    QVERIFY(menu2.isVisible());
+    QCOMPARE(win.menuBar()->activeAction(), file2);
+
+    QTest::mouseMove(win.menuBar(), win.menuBar()->actionGeometry(nothing).center());
+    QVERIFY(!menu.isVisible());
+    QVERIFY(!menu2.isVisible());
+    QCOMPARE(win.menuBar()->activeAction(), nothing);
+
+    QTest::mouseMove(&win, win.menuBar()->geometry().bottomLeft() + QPoint(1,1));
+
+    QVERIFY(!menu.isVisible());
+    QVERIFY(!menu2.isVisible());
+    QVERIFY(!win.menuBar()->activeAction());
+}
+
 
 #if defined(QT3_SUPPORT)
 void tst_QMenuBar::indexBasedInsertion_data()
diff --git a/tests/auto/qparallelanimationgroup/tst_qparallelanimationgroup.cpp b/tests/auto/qparallelanimationgroup/tst_qparallelanimationgroup.cpp
index 9f66fe0..d7d6b88 100644
--- a/tests/auto/qparallelanimationgroup/tst_qparallelanimationgroup.cpp
+++ b/tests/auto/qparallelanimationgroup/tst_qparallelanimationgroup.cpp
@@ -253,16 +253,16 @@ void tst_QParallelAnimationGroup::setCurrentTime()
 void tst_QParallelAnimationGroup::clearGroup()
 {
     QParallelAnimationGroup group;
+	static const int animationCount = 10;
 
-    for (int i = 0; i < 10; ++i) {
+    for (int i = 0; i < animationCount; ++i) {
         new QParallelAnimationGroup(&group);
     }
 
-    QCOMPARE(group.animationCount(), 10);
+    QCOMPARE(group.animationCount(), animationCount);
 
-    int count = group.animationCount();
-    QPointer<QAbstractAnimation> *children = new QPointer<QAbstractAnimation>[count];
-    for (int i = 0; i < count; ++i) {
+    QPointer<QAbstractAnimation> children[animationCount];
+    for (int i = 0; i < animationCount; ++i) {
         QVERIFY(group.animationAt(i) != 0);
         children[i] = group.animationAt(i);
     }
@@ -270,10 +270,8 @@ void tst_QParallelAnimationGroup::clearGroup()
     group.clearAnimations();
     QCOMPARE(group.animationCount(), 0);
     QCOMPARE(group.currentTime(), 0);
-    for (int i = 0; i < count; ++i)
-        QCOMPARE(children[i], QPointer<QAbstractAnimation>());
-
-    delete[] children;
+    for (int i = 0; i < animationCount; ++i)
+        QVERIFY(children[i].isNull());
 }
 
 void tst_QParallelAnimationGroup::propagateGroupUpdateToChildren()
@@ -807,15 +805,15 @@ void tst_QParallelAnimationGroup::autoAdd()
     QParallelAnimationGroup group;
     QCOMPARE(group.duration(), 0);
     TestAnimation2 *test = new TestAnimation2(250, &group);      // 0, duration = 250;
-    QCOMPARE(test->group(), &group);
+    QCOMPARE(test->group(), static_cast<QAnimationGroup*>(&group));
     QCOMPARE(test->duration(), 250);
     QCOMPARE(group.duration(), 250);
 
     test = new TestAnimation2(750, &group);     // 1
-    QCOMPARE(test->group(), &group);
+    QCOMPARE(test->group(), static_cast<QAnimationGroup*>(&group));
     QCOMPARE(group.duration(), 750);
     test = new TestAnimation2(500, &group);     // 2
-    QCOMPARE(test->group(), &group);
+    QCOMPARE(test->group(), static_cast<QAnimationGroup*>(&group));
     QCOMPARE(group.duration(), 750);
 
     delete group.animationAt(1);    // remove the one with duration = 750
diff --git a/tests/auto/qscriptenginedebugger/tst_qscriptenginedebugger.cpp b/tests/auto/qscriptenginedebugger/tst_qscriptenginedebugger.cpp
index 5d9f56f..cbdaf1e 100644
--- a/tests/auto/qscriptenginedebugger/tst_qscriptenginedebugger.cpp
+++ b/tests/auto/qscriptenginedebugger/tst_qscriptenginedebugger.cpp
@@ -111,9 +111,11 @@ void tst_QScriptEngineDebugger::attachAndDetach()
 {
     {
         QScriptEngineDebugger debugger;
+        QCOMPARE(debugger.state(), QScriptEngineDebugger::SuspendedState);
         debugger.attachTo(0);
         QScriptEngine engine;
         debugger.attachTo(&engine);
+        QCOMPARE(debugger.state(), QScriptEngineDebugger::SuspendedState);
     }
     {
         QScriptEngineDebugger debugger;
@@ -129,11 +131,9 @@ void tst_QScriptEngineDebugger::attachAndDetach()
         QVERIFY(!engine.globalObject().property("print").strictlyEquals(oldPrint));
 
         debugger.detach();
-        QEXPECT_FAIL("", "Task 256184", Continue);
-        QVERIFY(!engine.globalObject().property("print").isValid());
-        QEXPECT_FAIL("", "Task 256184", Continue);
+        QVERIFY(engine.globalObject().property("print").strictlyEquals(oldPrint));
         QVERIFY(!engine.globalObject().property("__FILE__").isValid());
-//        QVERIFY(!engine.globalObject().property("__LINE__").isValid());
+        QVERIFY(!engine.globalObject().property("__LINE__").isValid());
     }
     {
         QScriptEngineDebugger debugger;
@@ -161,6 +161,14 @@ void tst_QScriptEngineDebugger::attachAndDetach()
         debugger2.attachTo(&engine);
     }
 #endif
+    {
+        QScriptEngine *engine = new QScriptEngine;
+        QScriptEngineDebugger debugger;
+        debugger.attachTo(engine);
+        delete engine;
+        QScriptEngine engine2;
+        debugger.attachTo(&engine2);
+    }
 }
 
 void tst_QScriptEngineDebugger::action()
diff --git a/tests/auto/qsequentialanimationgroup/tst_qsequentialanimationgroup.cpp b/tests/auto/qsequentialanimationgroup/tst_qsequentialanimationgroup.cpp
index 522a900..97ff04b 100644
--- a/tests/auto/qsequentialanimationgroup/tst_qsequentialanimationgroup.cpp
+++ b/tests/auto/qsequentialanimationgroup/tst_qsequentialanimationgroup.cpp
@@ -321,15 +321,15 @@ void tst_QSequentialAnimationGroup::setCurrentTimeWithUncontrolledAnimation()
 
     // sequence operating on different object/properties
     QAnimationGroup *sequence = new QSequentialAnimationGroup();
-    QVariantAnimation *a1_s_o1 = new QPropertyAnimation(&s_o1, "value");
-    QVariantAnimation *a1_s_o2 = new QPropertyAnimation(&s_o2, "value");
+    QAbstractAnimation *a1_s_o1 = new QPropertyAnimation(&s_o1, "value");
+    QAbstractAnimation *a1_s_o2 = new QPropertyAnimation(&s_o2, "value");
     sequence->addAnimation(a1_s_o1);
     sequence->addAnimation(a1_s_o2);
 
-    UncontrolledAnimation *notTimeDriven = new UncontrolledAnimation(&t_o1, "value");
+    QAbstractAnimation *notTimeDriven = new UncontrolledAnimation(&t_o1, "value");
     QCOMPARE(notTimeDriven->totalDuration(), -1);
 
-    QVariantAnimation *loopsForever = new QPropertyAnimation(&t_o2, "value");
+    QAbstractAnimation *loopsForever = new QPropertyAnimation(&t_o2, "value");
     loopsForever->setLoopCount(-1);
     QCOMPARE(loopsForever->totalDuration(), -1);
 
@@ -818,7 +818,7 @@ void tst_QSequentialAnimationGroup::restart()
 
     QCOMPARE(seqCurrentAnimChangedSpy.count(), 6);
     for(int i=0; i<seqCurrentAnimChangedSpy.count(); i++)
-            QCOMPARE(anims[i%3], qVariantValue<QAbstractAnimation*>(seqCurrentAnimChangedSpy.at(i).at(0)));
+            QCOMPARE(static_cast<QAbstractAnimation*>(anims[i%3]), qVariantValue<QAbstractAnimation*>(seqCurrentAnimChangedSpy.at(i).at(0)));
 
     group.start();
 
@@ -836,9 +836,9 @@ void tst_QSequentialAnimationGroup::looping()
 
     // sequence operating on same object/property
     QSequentialAnimationGroup *sequence = new QSequentialAnimationGroup();
-    QVariantAnimation *a1_s_o1 = new QPropertyAnimation(&s_o1, "value");
-    QVariantAnimation *a2_s_o1 = new QPropertyAnimation(&s_o1, "value");
-    QVariantAnimation *a3_s_o1 = new QPropertyAnimation(&s_o1, "value");
+    QAbstractAnimation *a1_s_o1 = new QPropertyAnimation(&s_o1, "value");
+    QAbstractAnimation *a2_s_o1 = new QPropertyAnimation(&s_o1, "value");
+    QAbstractAnimation *a3_s_o1 = new QPropertyAnimation(&s_o1, "value");
 
     QSignalSpy a1Spy(a1_s_o1, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));
     QSignalSpy a2Spy(a2_s_o1, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));
@@ -951,18 +951,19 @@ void tst_QSequentialAnimationGroup::startDelay()
 void tst_QSequentialAnimationGroup::clearGroup()
 {
     QSequentialAnimationGroup group;
+	
+	static const int animationCount = 20;
 
-    for (int i = 0; i < 10; ++i) {
+    for (int i = 0; i < animationCount/2; ++i) {
         QSequentialAnimationGroup *subGroup = new QSequentialAnimationGroup(&group);
         group.addPause(100);
         subGroup->addPause(10);
     }
 
-    QCOMPARE(group.animationCount(), 20);
+    QCOMPARE(group.animationCount(), animationCount);
 
-    int count = group.animationCount();
-    QPointer<QAbstractAnimation> *children = new QPointer<QAbstractAnimation>[count];
-    for (int i = 0; i < count; ++i) {
+    QPointer<QAbstractAnimation> children[animationCount];
+    for (int i = 0; i < animationCount; ++i) {
         QVERIFY(group.animationAt(i) != 0);
         children[i] = group.animationAt(i);
     }
@@ -970,10 +971,8 @@ void tst_QSequentialAnimationGroup::clearGroup()
     group.clearAnimations();
     QCOMPARE(group.animationCount(), 0);
     QCOMPARE(group.currentTime(), 0);
-    for (int i = 0; i < count; ++i)
-        QCOMPARE(children[i], QPointer<QAbstractAnimation>());
-
-    delete[] children;
+    for (int i = 0; i < animationCount; ++i)
+        QVERIFY(children[i].isNull());
 }
 
 void tst_QSequentialAnimationGroup::groupWithZeroDurationAnimations()
@@ -995,7 +994,7 @@ void tst_QSequentialAnimationGroup::groupWithZeroDurationAnimations()
 
     //this should just run fine and change nothing
     group.setCurrentTime(0);
-    QCOMPARE(group.currentAnimation(), a1);
+    QCOMPARE(group.currentAnimation(), static_cast<QAbstractAnimation*>(a1));
 
     QVariantAnimation *a2 = new QPropertyAnimation(&o2, "myOtherProperty");
     a2->setDuration(500);
@@ -1457,7 +1456,7 @@ void tst_QSequentialAnimationGroup::finishWithUncontrolledAnimation()
     group.setCurrentTime(300);
     QCOMPARE(group.state(), QAnimationGroup::Stopped);
     QCOMPARE(notTimeDriven.currentTime(), actualDuration);
-    QCOMPARE(group.currentAnimation(), &anim);
+    QCOMPARE(group.currentAnimation(), static_cast<QAbstractAnimation*>(&anim));
 
     //3rd case:
     //now let's add a perfectly defined animation at the end
@@ -1474,7 +1473,7 @@ void tst_QSequentialAnimationGroup::finishWithUncontrolledAnimation()
     QCOMPARE(notTimeDriven.state(), QAnimationGroup::Stopped);
     QCOMPARE(group.state(), QAnimationGroup::Running);
     QCOMPARE(anim.state(), QAnimationGroup::Running);
-    QCOMPARE(group.currentAnimation(), &anim);
+    QCOMPARE(group.currentAnimation(), static_cast<QAbstractAnimation*>(&anim));
     QCOMPARE(animStateChangedSpy.count(), 1);
     QTest::qWait(300); //wait for the end of anim
 
@@ -1494,21 +1493,21 @@ void tst_QSequentialAnimationGroup::addRemoveAnimation()
 
     QCOMPARE(group.duration(), 0);
     QCOMPARE(group.currentTime(), 0);
-    QVariantAnimation *anim1 = new QPropertyAnimation;
+    QAbstractAnimation *anim1 = new QPropertyAnimation;
     group.addAnimation(anim1);
     QCOMPARE(group.duration(), 250);
     QCOMPARE(group.currentTime(), 0);
     QCOMPARE(group.currentAnimation(), anim1);
 
     //let's append an animation
-    QVariantAnimation *anim2 = new QPropertyAnimation;
+    QAbstractAnimation *anim2 = new QPropertyAnimation;
     group.addAnimation(anim2);
     QCOMPARE(group.duration(), 500);
     QCOMPARE(group.currentTime(), 0);
     QCOMPARE(group.currentAnimation(), anim1);
 
     //let's prepend an animation
-    QVariantAnimation *anim0 = new QPropertyAnimation;
+    QAbstractAnimation *anim0 = new QPropertyAnimation;
     group.insertAnimationAt(0, anim0);
     QCOMPARE(group.duration(), 750);
     QCOMPARE(group.currentTime(), 0);
@@ -1545,7 +1544,7 @@ void tst_QSequentialAnimationGroup::currentAnimation()
     QPropertyAnimation anim;
     anim.setDuration(0);
     group.addAnimation(&anim);
-    QCOMPARE(group.currentAnimation(), &anim);
+    QCOMPARE(group.currentAnimation(), static_cast<QAbstractAnimation*>(&anim));
 }
 
 void tst_QSequentialAnimationGroup::currentAnimationWithZeroDuration()
@@ -1572,21 +1571,21 @@ void tst_QSequentialAnimationGroup::currentAnimationWithZeroDuration()
     group.addAnimation(&zero3);
     group.addAnimation(&zero4);
 
-    QCOMPARE(group.currentAnimation(), &zero1);
+    QCOMPARE(group.currentAnimation(), static_cast<QAbstractAnimation*>(&zero1));
 
     group.setCurrentTime(0);
-    QCOMPARE(group.currentAnimation(), &anim);
+    QCOMPARE(group.currentAnimation(), static_cast<QAbstractAnimation*>(&anim));
 
     group.setCurrentTime(group.duration());
-    QCOMPARE(group.currentAnimation(), &zero4);
+    QCOMPARE(group.currentAnimation(), static_cast<QAbstractAnimation*>(&zero4));
 
     group.setDirection(QAbstractAnimation::Backward);
 
     group.setCurrentTime(0);
-    QCOMPARE(group.currentAnimation(), &zero1);
+    QCOMPARE(group.currentAnimation(), static_cast<QAbstractAnimation*>(&zero1));
 
     group.setCurrentTime(group.duration());
-    QCOMPARE(group.currentAnimation(), &anim);
+    QCOMPARE(group.currentAnimation(), static_cast<QAbstractAnimation*>(&anim));
 }
 
 void tst_QSequentialAnimationGroup::insertAnimation()
diff --git a/tests/auto/qstatemachine/tst_qstatemachine.cpp b/tests/auto/qstatemachine/tst_qstatemachine.cpp
index cd0c71d..b39f0a1 100644
--- a/tests/auto/qstatemachine/tst_qstatemachine.cpp
+++ b/tests/auto/qstatemachine/tst_qstatemachine.cpp
@@ -413,7 +413,7 @@ void tst_QStateMachine::customGlobalErrorState()
     machine.start();
     QCoreApplication::processEvents();
 
-    QCOMPARE(machine.errorState(), customErrorState);
+    QCOMPARE(machine.errorState(), static_cast<QAbstractState*>(customErrorState));
     QCOMPARE(machine.configuration().count(), 1);
     QVERIFY(machine.configuration().contains(initialState));
 
@@ -778,7 +778,7 @@ void tst_QStateMachine::customErrorStateIsNull()
     QTest::ignoreMessage(QtWarningMsg, "Unrecoverable error detected in running state machine: Missing initial state in compound state ''");
     QCoreApplication::processEvents();
 
-    QCOMPARE(machine.errorState(), reinterpret_cast<void *>(0));
+    QCOMPARE(machine.errorState(), reinterpret_cast<QAbstractState *>(0));
     QCOMPARE(machine.configuration().count(), 1);
     QVERIFY(machine.configuration().contains(oldErrorState));
 }
@@ -1103,29 +1103,29 @@ void tst_QStateMachine::stateEntryAndExit()
         TestTransition *t = new TestTransition(s2);
         QCOMPARE(t->machine(), (QStateMachine*)0);
         QCOMPARE(t->sourceState(), (QState*)0);
-        QCOMPARE(t->targetState(), s2);
+        QCOMPARE(t->targetState(), (QAbstractState*)s2);
         QCOMPARE(t->targetStates().size(), 1);
-        QCOMPARE(t->targetStates().at(0), s2);
+        QCOMPARE(t->targetStates().at(0), (QAbstractState*)s2);
         t->setTargetState(0);
-        QCOMPARE(t->targetState(), (QState*)0);
+        QCOMPARE(t->targetState(), (QAbstractState*)0);
         QVERIFY(t->targetStates().isEmpty());
         t->setTargetState(s2);
-        QCOMPARE(t->targetState(), s2);
+        QCOMPARE(t->targetState(), (QAbstractState*)s2);
         QTest::ignoreMessage(QtWarningMsg, "QAbstractTransition::setTargetStates: target state(s) cannot be null");
         t->setTargetStates(QList<QAbstractState*>() << 0);
-        QCOMPARE(t->targetState(), s2);
+        QCOMPARE(t->targetState(), (QAbstractState*)s2);
         t->setTargetStates(QList<QAbstractState*>() << s2);
-        QCOMPARE(t->targetState(), s2);
+        QCOMPARE(t->targetState(), (QAbstractState*)s2);
         QCOMPARE(t->targetStates().size(), 1);
-        QCOMPARE(t->targetStates().at(0), s2);
+        QCOMPARE(t->targetStates().at(0), (QAbstractState*)s2);
         QCOMPARE(s1->addTransition(t), (QAbstractTransition*)t);
-        QCOMPARE(t->sourceState(), s1);
+        QCOMPARE(t->sourceState(), (QState*)s1);
         QCOMPARE(t->machine(), &machine);
 
         {
             QAbstractTransition *trans = s2->addTransition(s3);
             QVERIFY(trans != 0);
-            QCOMPARE(trans->sourceState(), (QAbstractState*)s2);
+            QCOMPARE(trans->sourceState(), (QState*)s2);
             QCOMPARE(trans->targetState(), (QAbstractState*)s3);
             {
                 char warning[256];
@@ -1134,10 +1134,10 @@ void tst_QStateMachine::stateEntryAndExit()
                 s1->removeTransition(trans);
             }
             s2->removeTransition(trans);
-            QCOMPARE(trans->sourceState(), (QAbstractState*)0);
+            QCOMPARE(trans->sourceState(), (QState*)0);
             QCOMPARE(trans->targetState(), (QAbstractState*)s3);
             QCOMPARE(s2->addTransition(trans), trans);
-            QCOMPARE(trans->sourceState(), (QAbstractState*)s2);
+            QCOMPARE(trans->sourceState(), (QState*)s2);
         }
 
         QSignalSpy startedSpy(&machine, SIGNAL(started()));
@@ -1724,18 +1724,18 @@ void tst_QStateMachine::signalTransitions()
         QStateMachine machine;
         QState *s0 = new QState(machine.rootState());
         QTest::ignoreMessage(QtWarningMsg, "QState::addTransition: sender cannot be null");
-        QCOMPARE(s0->addTransition(0, SIGNAL(noSuchSignal()), 0), (QObject*)0);
+        QCOMPARE(s0->addTransition(0, SIGNAL(noSuchSignal()), 0), (QSignalTransition*)0);
 
         SignalEmitter emitter;
         QTest::ignoreMessage(QtWarningMsg, "QState::addTransition: signal cannot be null");
-        QCOMPARE(s0->addTransition(&emitter, 0, 0), (QObject*)0);
+        QCOMPARE(s0->addTransition(&emitter, 0, 0), (QSignalTransition*)0);
 
         QTest::ignoreMessage(QtWarningMsg, "QState::addTransition: cannot add transition to null state");
-        QCOMPARE(s0->addTransition(&emitter, SIGNAL(signalWithNoArg()), 0), (QObject*)0);
+        QCOMPARE(s0->addTransition(&emitter, SIGNAL(signalWithNoArg()), 0), (QSignalTransition*)0);
 
         QFinalState *s1 = new QFinalState(machine.rootState());
         QTest::ignoreMessage(QtWarningMsg, "QState::addTransition: no such signal SignalEmitter::noSuchSignal()");
-        QCOMPARE(s0->addTransition(&emitter, SIGNAL(noSuchSignal()), s1), (QObject*)0);
+        QCOMPARE(s0->addTransition(&emitter, SIGNAL(noSuchSignal()), s1), (QSignalTransition*)0);
 
         QSignalTransition *trans = s0->addTransition(&emitter, SIGNAL(signalWithNoArg()), s1);
         QVERIFY(trans != 0);
diff --git a/tests/auto/qtabbar/tst_qtabbar.cpp b/tests/auto/qtabbar/tst_qtabbar.cpp
index 29f42df..f908d3f 100644
--- a/tests/auto/qtabbar/tst_qtabbar.cpp
+++ b/tests/auto/qtabbar/tst_qtabbar.cpp
@@ -370,7 +370,7 @@ void tst_QTabBar::tabButton()
 
     tabbar.setTabButton(0, position, button);
 
-    QCOMPARE(tabbar.tabButton(0, position), static_cast<const QWidget *>(button));
+    QCOMPARE(tabbar.tabButton(0, position), static_cast<QWidget *>(button));
     QTRY_VERIFY(!button->isHidden());
     QVERIFY(tabbar.tabButton(0, otherSide) == 0);
     QCOMPARE(button->parent(), static_cast<QObject *>(&tabbar));
diff --git a/tests/auto/windowsmobile/test/tst_windowsmobile.cpp b/tests/auto/windowsmobile/test/tst_windowsmobile.cpp
index 843974d..8c7c021 100644
--- a/tests/auto/windowsmobile/test/tst_windowsmobile.cpp
+++ b/tests/auto/windowsmobile/test/tst_windowsmobile.cpp
@@ -44,8 +44,10 @@
 #include <QtCore/QDebug>
 #include <QtCore/QObject>
 #include <QtGui>
+#ifdef Q_OS_WINCE_WM
 #include <windows.h>
 #include <ddhelper.h>
+#endif
 
 
 
diff --git a/tools/qtconfig/mainwindow.cpp b/tools/qtconfig/mainwindow.cpp
index eabaec6..a59f790 100644
--- a/tools/qtconfig/mainwindow.cpp
+++ b/tools/qtconfig/mainwindow.cpp
@@ -829,7 +829,7 @@ void MainWindow::removeSubstitute()
 
     int item = sublistbox->currentItem();
     QStringList subs = QFont::substitutes(familysubcombo->currentText());
-    subs.remove(subs.at(sublistbox->currentItem()));
+    subs.removeAt(sublistbox->currentItem());
     sublistbox->clear();
     sublistbox->insertStringList(subs);
     if (uint(item) > sublistbox->count())
@@ -909,7 +909,7 @@ void MainWindow::removeFontpath()
         return;
 
     int item = fontpathlistbox->currentItem();
-    fontpaths.remove(fontpaths.at(fontpathlistbox->currentItem()));
+    fontpaths.removeAt(fontpathlistbox->currentItem());
     fontpathlistbox->clear();
     fontpathlistbox->insertStringList(fontpaths);
     if (uint(item) > fontpathlistbox->count())