Merge branch 'kinetic-declarativeui' of git@scm.dev.nokia.troll.no:qt/kinetic into kinetic-declarativeui

45 files changed, 3646 insertions, 1896 deletions

diff --git a/src/3rdparty/phonon/ds9/videowidget.cpp b/src/3rdparty/phonon/ds9/videowidget.cpp
index 0ef653f..34ff8cb 100644
--- a/src/3rdparty/phonon/ds9/videowidget.cpp
+++ b/src/3rdparty/phonon/ds9/videowidget.cpp
@@ -153,7 +153,7 @@ namespace Phonon
                     }
                 } else if (!isEmbedded()) {
                     m_currentRenderer = m_node->switchRendering(m_currentRenderer);
-                    setAttribute(Qt::WA_PaintOnScreen, true);
+                    setAttribute(Qt::WA_PaintOnScreen, false);
                 }
             }
 
diff --git a/src/corelib/kernel/qabstracteventdispatcher.cpp b/src/corelib/kernel/qabstracteventdispatcher.cpp
index a98d005..e2682f5 100644
--- a/src/corelib/kernel/qabstracteventdispatcher.cpp
+++ b/src/corelib/kernel/qabstracteventdispatcher.cpp
@@ -398,20 +398,23 @@ void QAbstractEventDispatcher::closingDown()
 */
 
 /*!
-    Sets the event filter \a filter. Returns a pointer to the filter
-    function previously defined.
-
-    The event filter is a function that receives all messages taken
-    from the system event loop before the event is dispatched to the
-    respective target. This includes messages that are not sent to Qt
+    Replaces the event filter function for this
+    QAbstractEventDispatcher with \a filter and returns the replaced
+    event filter function. Only the current event filter function is
+    called. If you want to use both filter functions, save the
+    replaced EventFilter in a place where yours can call it.
+
+    The event filter function set here is called for all messages
+    taken from the system event loop before the event is dispatched to
+    the respective target, including the messages not meant for Qt
     objects.
 
-    The function can return true to stop the event to be processed by
-    Qt, or false to continue with the standard event processing.
+    The event filter function should return true if the message should
+    be filtered, (i.e. stopped). It should return false to allow
+    processing the message to continue.
 
-    Only one filter can be defined, but the filter can use the return
-    value to call the previously set event filter. By default, no
-    filter is set (i.e. the function returns 0).
+    By default, no event filter function is set (i.e., this function
+    returns a null EventFilter the first time it is called).
 */
 QAbstractEventDispatcher::EventFilter QAbstractEventDispatcher::setEventFilter(EventFilter filter)
 {
diff --git a/src/corelib/kernel/qcore_unix_p.h b/src/corelib/kernel/qcore_unix_p.h
index 1bf2425..8d43897 100644
--- a/src/corelib/kernel/qcore_unix_p.h
+++ b/src/corelib/kernel/qcore_unix_p.h
@@ -69,19 +69,19 @@
 
 struct sockaddr;
 
-QT_BEGIN_NAMESPACE
-
 #if defined(Q_OS_LINUX) && defined(O_CLOEXEC) && defined(__GLIBC__) && (__GLIBC__ * 0x100 + __GLIBC_MINOR__) >= 0x0204
 // Linux supports thread-safe FD_CLOEXEC
 # define QT_UNIX_SUPPORTS_THREADSAFE_CLOEXEC 1
 
+QT_BEGIN_NAMESPACE
 namespace QtLibcSupplement {
     Q_CORE_EXPORT int accept4(int, sockaddr *, QT_SOCKLEN_T *, int flags);
     Q_CORE_EXPORT int dup3(int oldfd, int newfd, int flags);
     Q_CORE_EXPORT int pipe2(int pipes[], int flags);
 }
+QT_END_NAMESPACE
+using namespace QT_PREPEND_NAMESPACE(QtLibcSupplement);
 
-using namespace QtLibcSupplement;
 #else
 # define QT_UNIX_SUPPORTS_THREADSAFE_CLOEXEC 0
 #endif
@@ -91,6 +91,7 @@ using namespace QtLibcSupplement;
         var = cmd;                              \
     } while (var == -1 && errno == EINTR)
 
+QT_BEGIN_NAMESPACE
 
 // don't call QT_OPEN or ::open
 // call qt_safe_open
diff --git a/src/corelib/kernel/qcoreapplication.cpp b/src/corelib/kernel/qcoreapplication.cpp
index 054be70..706dc54 100644
--- a/src/corelib/kernel/qcoreapplication.cpp
+++ b/src/corelib/kernel/qcoreapplication.cpp
@@ -2183,21 +2183,37 @@ void QCoreApplication::removeLibraryPath(const QString &path)
 /*!
     \fn EventFilter QCoreApplication::setEventFilter(EventFilter filter)
 
-    Sets the event filter \a filter. Returns a pointer to the filter
-    function previously defined.
-
-    The event filter is a function that is called for every message
-    received in all threads. This does \e not include messages to
+    Replaces the event filter function for the QCoreApplication with
+    \a filter and returns the pointer to the replaced event filter
+    function. Only the current event filter function is called. If you
+    want to use both filter functions, save the replaced EventFilter
+    in a place where yours can call it.
+
+    The event filter function set here is called for all messages
+    received by all threads meant for all Qt objects. It is \e not
+    called for messages that are not meant for Qt objects.
+
+    The event filter function should return true if the message should
+    be filtered, (i.e. stopped). It should return false to allow
+    processing the message to continue.
+
+    By default, no event filter function is set (i.e., this function
+    returns a null EventFilter the first time it is called).
+    
+    \note The filter function set here receives native messages,
+    i.e. MSG or XEvent structs, that are going to Qt objects. It is
+    called by QCoreApplication::filterEvent(). If the filter function
+    returns false to indicate the message should be processed further,
+    the native message can then be translated into a QEvent and
+    handled by the standard Qt \l{QEvent} {event} filering, e.g.
+    QObject::installEventFilter().
+
+    \note The filter function set here is different form the filter
+    function set via QAbstractEventDispatcher::setEventFilter(), which
+    gets all messages received by its thread, even messages meant for
     objects that are not handled by Qt.
 
-    The function can return true to stop the event to be processed by
-    Qt, or false to continue with the standard event processing.
-
-    Only one filter can be defined, but the filter can use the return
-    value to call the previously set event filter. By default, no
-    filter is set (i.e., the function returns 0).
-
-    \sa installEventFilter()
+    \sa QObject::installEventFilter(), QAbstractEventDispatcher::setEventFilter()
 */
 QCoreApplication::EventFilter
 QCoreApplication::setEventFilter(QCoreApplication::EventFilter filter)
diff --git a/src/declarative/canvas/qsimplecanvas_graphicsview.cpp b/src/declarative/canvas/qsimplecanvas_graphicsview.cpp
index dd4012b..d9ff39b 100644
--- a/src/declarative/canvas/qsimplecanvas_graphicsview.cpp
+++ b/src/declarative/canvas/qsimplecanvas_graphicsview.cpp
@@ -64,6 +64,12 @@ QSimpleCanvasGraphicsView::~QSimpleCanvasGraphicsView()
     sceneMap.remove(&_scene);
 }
 
+void QSimpleCanvasGraphicsView::resizeEvent(QResizeEvent *e)
+{
+    _scene.setSceneRect(QRect(QPoint(0, 0), e->size()));
+    QGraphicsView::resizeEvent(e);
+}
+
 QSimpleGraphicsItem::QSimpleGraphicsItem(QSimpleCanvasItem *canvasItem)
 : /*scene(0),*/ owner(canvasItem)
 {
diff --git a/src/declarative/canvas/qsimplecanvas_p.h b/src/declarative/canvas/qsimplecanvas_p.h
index c900ccf..c2b5130 100644
--- a/src/declarative/canvas/qsimplecanvas_p.h
+++ b/src/declarative/canvas/qsimplecanvas_p.h
@@ -98,6 +98,7 @@ public:
 protected:
     virtual void paintEvent(QPaintEvent *);
     virtual void focusInEvent(QFocusEvent *);
+    virtual void resizeEvent(QResizeEvent *);
 
 private:
     QSimpleCanvasPrivate *canvas;
diff --git a/src/gui/dialogs/qsidebar.cpp b/src/gui/dialogs/qsidebar.cpp
index 1915e21..e4821ad 100644
--- a/src/gui/dialogs/qsidebar.cpp
+++ b/src/gui/dialogs/qsidebar.cpp
@@ -247,11 +247,16 @@ void QUrlModel::addUrls(const QList<QUrl> &list, int row, bool move)
         QUrl url = list.at(i);
         if (!url.isValid() || url.scheme() != QLatin1String("file"))
             continue;
+        //this makes sure the url is clean
+        const QString cleanUrl = QDir::cleanPath(url.toLocalFile());
+        url = QUrl::fromLocalFile(cleanUrl);
+
         for (int j = 0; move && j < rowCount(); ++j) {
+            QString local = index(j, 0).data(UrlRole).toUrl().toLocalFile();
 #if defined(Q_OS_WIN)
-            if (QDir::cleanPath(index(j, 0).data(UrlRole).toUrl().toLocalFile()).toLower() == QDir::cleanPath(url.toLocalFile()).toLower()) {
+            if (index(j, 0).data(UrlRole).toUrl().toLocalFile().toLower() == cleanUrl.toLower()) {
 #else
-            if (QDir::cleanPath(index(j, 0).data(UrlRole).toUrl().toLocalFile()) == QDir::cleanPath(url.toLocalFile())) {
+            if (index(j, 0).data(UrlRole).toUrl().toLocalFile() == cleanUrl) {
 #endif
                 removeRow(j);
                 if (j <= row)
@@ -260,12 +265,12 @@ void QUrlModel::addUrls(const QList<QUrl> &list, int row, bool move)
             }
         }
         row = qMax(row, 0);
-        QModelIndex idx = fileSystemModel->index(url.toLocalFile());
+        QModelIndex idx = fileSystemModel->index(cleanUrl);
         if (!fileSystemModel->isDir(idx))
             continue;
         insertRows(row, 1);
         setUrl(index(row, 0), url, idx);
-        watching.append(QPair<QModelIndex, QString>(idx, url.toLocalFile()));
+        watching.append(qMakePair(idx, cleanUrl));
     }
 }
 
diff --git a/src/gui/graphicsview/graphicsview.pri b/src/gui/graphicsview/graphicsview.pri
index 4cee6d6..0c0747e 100644
--- a/src/gui/graphicsview/graphicsview.pri
+++ b/src/gui/graphicsview/graphicsview.pri
@@ -1,37 +1,42 @@
 # Qt graphicsview module
-HEADERS += graphicsview/qgraphicsitem.h \
+HEADERS += graphicsview/qgraphicsgridlayout.h \
+    graphicsview/qgraphicsitem.h \
     graphicsview/qgraphicsitem_p.h \
     graphicsview/qgraphicsitemanimation.h \
-    graphicsview/qgraphicsscene.h \
-    graphicsview/qgraphicsscene_p.h \
-    graphicsview/qgraphicsscene_bsp_p.h \
-    graphicsview/qgraphicssceneevent.h \
-    graphicsview/qgraphicsview_p.h \
-    graphicsview/qgraphicsview.h
-SOURCES += graphicsview/qgraphicsitem.cpp \
-    graphicsview/qgraphicsitemanimation.cpp \
-    graphicsview/qgraphicsscene.cpp \
-    graphicsview/qgraphicsscene_bsp.cpp \
-    graphicsview/qgraphicssceneevent.cpp \
-    graphicsview/qgraphicsview.cpp
-
-# Widgets on the canvas
-HEADERS += graphicsview/qgraphicslayout.h \
+    graphicsview/qgraphicslayout.h \
     graphicsview/qgraphicslayout_p.h \
     graphicsview/qgraphicslayoutitem.h \
     graphicsview/qgraphicslayoutitem_p.h \
     graphicsview/qgraphicslinearlayout.h \
+    graphicsview/qgraphicsproxywidget.h \
+    graphicsview/qgraphicsscene.h \
+    graphicsview/qgraphicsscene_bsp_p.h \
+    graphicsview/qgraphicsscene_p.h \
+    graphicsview/qgraphicsscenebsptreeindex_p.h \
+    graphicsview/qgraphicssceneevent.h \
+    graphicsview/qgraphicssceneindex_p.h \
+    graphicsview/qgraphicsscenelinearindex_p.h \
+    graphicsview/qgraphicsview.h \
+    graphicsview/qgraphicsview_p.h \
     graphicsview/qgraphicswidget.h \
     graphicsview/qgraphicswidget_p.h \
-    graphicsview/qgridlayoutengine_p.h \
-    graphicsview/qgraphicsproxywidget.h \
-    graphicsview/qgraphicsgridlayout.h
-SOURCES += graphicsview/qgraphicslayout.cpp \
+    graphicsview/qgridlayoutengine_p.h
+
+SOURCES += graphicsview/qgraphicsgridlayout.cpp \
+    graphicsview/qgraphicsitem.cpp \
+    graphicsview/qgraphicsitemanimation.cpp \
+    graphicsview/qgraphicslayout.cpp \
     graphicsview/qgraphicslayout_p.cpp \
     graphicsview/qgraphicslayoutitem.cpp \
     graphicsview/qgraphicslinearlayout.cpp \
+    graphicsview/qgraphicsproxywidget.cpp \
+    graphicsview/qgraphicsscene.cpp \
+    graphicsview/qgraphicsscene_bsp.cpp \
+    graphicsview/qgraphicsscenebsptreeindex.cpp \
+    graphicsview/qgraphicssceneevent.cpp \
+    graphicsview/qgraphicssceneindex.cpp \
+    graphicsview/qgraphicsscenelinearindex.cpp \
+    graphicsview/qgraphicsview.cpp \
     graphicsview/qgraphicswidget.cpp \
     graphicsview/qgraphicswidget_p.cpp \
-    graphicsview/qgridlayoutengine.cpp \
-    graphicsview/qgraphicsproxywidget.cpp \
-    graphicsview/qgraphicsgridlayout.cpp
+    graphicsview/qgridlayoutengine.cpp
diff --git a/src/gui/graphicsview/qgraphicsitem.cpp b/src/gui/graphicsview/qgraphicsitem.cpp
index 7b2d7bc..f0512e2 100644
--- a/src/gui/graphicsview/qgraphicsitem.cpp
+++ b/src/gui/graphicsview/qgraphicsitem.cpp
@@ -558,6 +558,7 @@
 #include "qgraphicsview.h"
 #include "qgraphicswidget.h"
 #include "qgraphicsproxywidget.h"
+#include "qgraphicsscenebsptreeindex_p.h"
 #include <QtCore/qbitarray.h>
 #include <QtCore/qdebug.h>
 #include <QtCore/qpoint.h>
@@ -588,17 +589,6 @@
 
 QT_BEGIN_NAMESPACE
 
-// QRectF::intersects() returns false always if either the source or target
-// rectangle's width or height are 0. This works around that problem.
-static inline void _q_adjustRect(QRectF *rect)
-{
-    Q_ASSERT(rect);
-    if (!rect->width())
-        rect->adjust(-0.00001, 0, 0.00001, 0);
-    if (!rect->height())
-        rect->adjust(0, -0.00001, 0, 0.00001);
-}
-
 static inline void _q_adjustRect(QRect *rect)
 {
     Q_ASSERT(rect);
@@ -832,6 +822,42 @@ void QGraphicsItemPrivate::combineTransformFromParent(QTransform *x, const QTran
     }
 }
 
+void QGraphicsItemPrivate::updateSceneTransformFromParent()
+{
+    if (parent) {
+        Q_ASSERT(!parent->d_ptr->dirtySceneTransform);
+        if (parent->d_ptr->sceneTransformTranslateOnly) {
+            sceneTransform = QTransform::fromTranslate(parent->d_ptr->sceneTransform.dx() + pos.x(),
+                                                       parent->d_ptr->sceneTransform.dy() + pos.y());
+        } else {
+            sceneTransform = parent->d_ptr->sceneTransform;
+            sceneTransform.translate(pos.x(), pos.y());
+        }
+        if (transformData) {
+            sceneTransform = transformData->computedFullTransform(&sceneTransform);
+            sceneTransformTranslateOnly = (sceneTransform.type() <= QTransform::TxTranslate);
+        } else {
+            sceneTransformTranslateOnly = parent->d_ptr->sceneTransformTranslateOnly;
+        }
+    } else if (!transformData) {
+        sceneTransform = QTransform::fromTranslate(pos.x(), pos.y());
+        sceneTransformTranslateOnly = 1;
+    } else if (transformData->onlyTransform) {
+        sceneTransform = transformData->transform;
+        if (!pos.isNull())
+            sceneTransform *= QTransform::fromTranslate(pos.x(), pos.y());
+        sceneTransformTranslateOnly = (sceneTransform.type() <= QTransform::TxTranslate);
+    } else if (pos.isNull()) {
+        sceneTransform = transformData->computedFullTransform();
+        sceneTransformTranslateOnly = (sceneTransform.type() <= QTransform::TxTranslate);
+    } else {
+        sceneTransform = QTransform::fromTranslate(pos.x(), pos.y());
+        sceneTransform = transformData->computedFullTransform(&sceneTransform);
+        sceneTransformTranslateOnly = (sceneTransform.type() <= QTransform::TxTranslate);
+    }
+    dirtySceneTransform = 0;
+}
+
 /*!
     \internal
 
@@ -871,6 +897,11 @@ void QGraphicsItemPrivate::setParentItemHelper(QGraphicsItem *newParent)
     if (newParent == parent)
         return;
 
+    if (scene) {
+        // Deliver the change to the index
+        scene->d_func()->index->itemChange(q, QGraphicsItem::ItemParentChange, newParentVariant);
+    }
+
     if (QGraphicsWidget *w = isWidget ? static_cast<QGraphicsWidget *>(q) : q->parentWidget()) {
         // Update the child focus chain; when reparenting a widget that has a
         // focus child, ensure that that focus child clears its focus child
@@ -958,12 +989,6 @@ void QGraphicsItemPrivate::setParentItemHelper(QGraphicsItem *newParent)
         }
     }
 
-    if (scene) {
-        // Invalidate any sort caching; arrival of a new item means we need to
-        // resort.
-        scene->d_func()->invalidateSortCache();
-    }
-
     // Resolve depth.
     resolveDepth(parent ? parent->d_ptr->depth : -1);
     dirtySceneTransform = 1;
@@ -1442,6 +1467,8 @@ void QGraphicsItem::setFlags(GraphicsItemFlags flags)
     flags = GraphicsItemFlags(itemChange(ItemFlagsChange, quint32(flags)).toUInt());
     if (quint32(d_ptr->flags) == quint32(flags))
         return;
+    if (d_ptr->scene)
+        d_ptr->scene->d_func()->index->itemChange(this, ItemFlagsChange, quint32(flags));
 
     // Flags that alter the geometry of the item (or its children).
     const quint32 geomChangeFlagsMask = (ItemClipsChildrenToShape | ItemClipsToShape | ItemIgnoresTransformations);
@@ -1800,6 +1827,8 @@ void QGraphicsItemPrivate::setVisibleHelper(bool newVisible, bool explicitly, bo
         if (q_ptr->isSelected())
             q_ptr->setSelected(false);
     } else {
+        geometryChanged = 1;
+        paintedViewBoundingRectsNeedRepaint = 1;
         if (isWidget && scene) {
             QGraphicsWidget *widget = static_cast<QGraphicsWidget *>(q_ptr);
             if (widget->windowType() == Qt::Popup)
@@ -3160,7 +3189,8 @@ void QGraphicsItem::setTransformOrigin(const QPointF &origin)
 */
 QMatrix QGraphicsItem::sceneMatrix() const
 {
-    return sceneTransform().toAffine();
+    d_ptr->ensureSceneTransform();
+    return d_ptr->sceneTransform.toAffine();
 }
 
 
@@ -3183,16 +3213,7 @@ QMatrix QGraphicsItem::sceneMatrix() const
 */
 QTransform QGraphicsItem::sceneTransform() const
 {
-    if (d_ptr->dirtySceneTransform) {
-        // This item and all its descendants have dirty scene transforms.
-        // We're about to validate this item's scene transform, so we have to
-        // invalidate all the children; otherwise there's no way for the descendants
-        // to detect that the ancestor has changed.
-        d_ptr->invalidateChildrenSceneTransform();
-    }
-
-    QGraphicsItem *that = const_cast<QGraphicsItem *>(this);
-    d_ptr->ensureSceneTransformRecursive(&that);
+    d_ptr->ensureSceneTransform();
     return d_ptr->sceneTransform;
 }
 
@@ -3222,8 +3243,10 @@ QTransform QGraphicsItem::sceneTransform() const
 QTransform QGraphicsItem::deviceTransform(const QTransform &viewportTransform) const
 {
     // Ensure we return the standard transform if we're not untransformable.
-    if (!d_ptr->itemIsUntransformable())
-        return sceneTransform() * viewportTransform;
+    if (!d_ptr->itemIsUntransformable()) {
+        d_ptr->ensureSceneTransform();
+        return d_ptr->sceneTransform * viewportTransform;
+    }
 
     // Find the topmost item that ignores view transformations.
     const QGraphicsItem *untransformedAncestor = this;
@@ -3242,7 +3265,8 @@ QTransform QGraphicsItem::deviceTransform(const QTransform &viewportTransform) c
     }
 
     // First translate the base untransformable item.
-    QPointF mappedPoint = (untransformedAncestor->sceneTransform() * viewportTransform).map(QPointF(0, 0));
+    untransformedAncestor->d_ptr->ensureSceneTransform();
+    QPointF mappedPoint = (untransformedAncestor->d_ptr->sceneTransform * viewportTransform).map(QPointF(0, 0));
 
     // COMBINE
     QTransform matrix = QTransform::fromTranslate(mappedPoint.x(), mappedPoint.y());
@@ -3335,8 +3359,11 @@ QTransform QGraphicsItem::itemTransform(const QGraphicsItem *other, bool *ok) co
     // Find the closest common ancestor. If the two items don't share an
     // ancestor, then the only way is to combine their scene transforms.
     const QGraphicsItem *commonAncestor = commonAncestorItem(other);
-    if (!commonAncestor)
-        return sceneTransform() * other->sceneTransform().inverted(ok);
+    if (!commonAncestor) {
+        d_ptr->ensureSceneTransform();
+        other->d_ptr->ensureSceneTransform();
+        return d_ptr->sceneTransform * other->d_ptr->sceneTransform.inverted(ok);
+    }
 
     // If the two items are cousins (in sibling branches), map both to the
     // common ancestor, and combine the two transforms.
@@ -3627,18 +3654,20 @@ void QGraphicsItem::setZValue(qreal z)
     qreal newZ = qreal(newZVariant.toDouble());
     if (newZ == d_ptr->z)
         return;
+
+    if (d_ptr->scene) {
+        // Z Value has changed, we have to notify the index.
+        d_ptr->scene->d_func()->index->itemChange(this, ItemZValueChange, newZVariant);
+    }
+
     d_ptr->z = newZ;
     if (d_ptr->parent)
         d_ptr->parent->d_ptr->needSortChildren = 1;
     else if (d_ptr->scene)
         d_ptr->scene->d_func()->needSortTopLevelItems = 1;
 
-    if (d_ptr->scene) {
+    if (d_ptr->scene)
         d_ptr->scene->d_func()->markDirty(this, QRectF(), /*invalidateChildren=*/true);
-        // Invalidate any sort caching; arrival of a new item means we need to
-        // resort.
-        d_ptr->scene->d_func()->invalidateSortCache();
-    }
 
     itemChange(ItemZValueHasChanged, newZVariant);
 
@@ -3729,7 +3758,13 @@ QRectF QGraphicsItem::sceneBoundingRect() const
 
     QRectF br = boundingRect();
     br.translate(offset);
-    return !parentItem ? br : parentItem->sceneTransform().mapRect(br);
+    if (!parentItem)
+        return br;
+    if (parentItem->d_ptr->hasTranslateOnlySceneTransform()) {
+        br.translate(parentItem->d_ptr->sceneTransform.dx(), parentItem->d_ptr->sceneTransform.dy());
+        return br;
+    }
+    return parentItem->d_ptr->sceneTransform.mapRect(br);
 }
 
 /*!
@@ -4104,7 +4139,7 @@ bool QGraphicsItem::isObscuredBy(const QGraphicsItem *item) const
 {
     if (!item)
         return false;
-    return QGraphicsScenePrivate::closestItemFirst_withoutCache(item, this)
+    return QGraphicsSceneBspTreeIndexPrivate::closestItemFirst_withoutCache(item, this)
         && qt_QGraphicsItem_isObscured(this, item, boundingRect());
 }
 
@@ -4297,12 +4332,11 @@ bool QGraphicsItemPrivate::discardUpdateRequest(bool ignoreClipping, bool ignore
 {
     // No scene, or if the scene is updating everything, means we have nothing
     // to do. The only exception is if the scene tracks the growing scene rect.
-    return (!visible && !ignoreVisibleBit)
+    return !scene
+           || (!visible && !ignoreVisibleBit && !this->ignoreVisible)
            || (!ignoreDirtyBit && fullUpdatePending)
-           || !scene
-           || (scene->d_func()->updateAll && scene->d_func()->hasSceneRect)
            || (!ignoreClipping && (childrenClippedToShape() && isClippedAway()))
-           || (!ignoreOpacity && childrenCombineOpacity() && isFullyTransparent());
+           || (!ignoreOpacity && !this->ignoreOpacity && childrenCombineOpacity() && isFullyTransparent());
 }
 
 /*!
@@ -4323,6 +4357,7 @@ void QGraphicsItemPrivate::resolveDepth(int parentDepth)
 void QGraphicsItemPrivate::addChild(QGraphicsItem *child)
 {
     needSortChildren = 1;
+    child->d_ptr->siblingIndex = children.size();
     children.append(child);
 }
 
@@ -4332,6 +4367,10 @@ void QGraphicsItemPrivate::addChild(QGraphicsItem *child)
 void QGraphicsItemPrivate::removeChild(QGraphicsItem *child)
 {
     children.removeOne(child);
+    // NB! Do not use children.removeAt(child->d_ptr->siblingIndex) because
+    // the child is not guaranteed to be at the index after the list is sorted.
+    // (see ensureSortedChildren()).
+    child->d_ptr->siblingIndex = -1;
 }
 
 /*!
@@ -4492,9 +4531,22 @@ void QGraphicsItemPrivate::ensureSceneTransformRecursive(QGraphicsItem **topMost
     }
 
     // COMBINE my transform with the parent's scene transform.
-    sceneTransform = parent ? parent->d_ptr->sceneTransform : QTransform();
-    combineTransformFromParent(&sceneTransform);
-    dirtySceneTransform = 0;
+    updateSceneTransformFromParent();
+    Q_ASSERT(!dirtySceneTransform);
+}
+
+void QGraphicsItemPrivate::ensureSceneTransform()
+{
+    if (dirtySceneTransform) {
+        // This item and all its descendants have dirty scene transforms.
+        // We're about to validate this item's scene transform, so we have to
+        // invalidate all the children; otherwise there's no way for the descendants
+        // to detect that the ancestor has changed.
+        invalidateChildrenSceneTransform();
+    }
+
+    QGraphicsItem *that = q_func();
+    ensureSceneTransformRecursive(&that);
 }
 
 /*!
@@ -4835,7 +4887,9 @@ QPointF QGraphicsItem::mapToParent(const QPointF &point) const
 */
 QPointF QGraphicsItem::mapToScene(const QPointF &point) const
 {
-    return sceneTransform().map(point);
+    if (d_ptr->hasTranslateOnlySceneTransform())
+        return QPointF(point.x() + d_ptr->sceneTransform.dx(), point.y() + d_ptr->sceneTransform.dy());
+    return d_ptr->sceneTransform.map(point);
 }
 
 /*!
@@ -4902,7 +4956,9 @@ QPolygonF QGraphicsItem::mapToParent(const QRectF &rect) const
 */
 QPolygonF QGraphicsItem::mapToScene(const QRectF &rect) const
 {
-    return sceneTransform().map(rect);
+    if (d_ptr->hasTranslateOnlySceneTransform())
+        return rect.translated(d_ptr->sceneTransform.dx(), d_ptr->sceneTransform.dy());
+    return d_ptr->sceneTransform.map(rect);
 }
 
 /*!
@@ -4975,7 +5031,9 @@ QRectF QGraphicsItem::mapRectToParent(const QRectF &rect) const
 */
 QRectF QGraphicsItem::mapRectToScene(const QRectF &rect) const
 {
-    return sceneTransform().mapRect(rect);
+    if (d_ptr->hasTranslateOnlySceneTransform())
+        return rect.translated(d_ptr->sceneTransform.dx(), d_ptr->sceneTransform.dy());
+    return d_ptr->sceneTransform.mapRect(rect);
 }
 
 /*!
@@ -5049,7 +5107,9 @@ QRectF QGraphicsItem::mapRectFromParent(const QRectF &rect) const
 */
 QRectF QGraphicsItem::mapRectFromScene(const QRectF &rect) const
 {
-    return sceneTransform().inverted().mapRect(rect);
+    if (d_ptr->hasTranslateOnlySceneTransform())
+        return rect.translated(-d_ptr->sceneTransform.dx(), -d_ptr->sceneTransform.dy());
+    return d_ptr->sceneTransform.inverted().mapRect(rect);
 }
 
 /*!
@@ -5101,7 +5161,9 @@ QPolygonF QGraphicsItem::mapToParent(const QPolygonF &polygon) const
 */
 QPolygonF QGraphicsItem::mapToScene(const QPolygonF &polygon) const
 {
-    return sceneTransform().map(polygon);
+    if (d_ptr->hasTranslateOnlySceneTransform())
+        return polygon.translated(d_ptr->sceneTransform.dx(), d_ptr->sceneTransform.dy());
+    return d_ptr->sceneTransform.map(polygon);
 }
 
 /*!
@@ -5146,7 +5208,9 @@ QPainterPath QGraphicsItem::mapToParent(const QPainterPath &path) const
 */
 QPainterPath QGraphicsItem::mapToScene(const QPainterPath &path) const
 {
-    return sceneTransform().map(path);
+    if (d_ptr->hasTranslateOnlySceneTransform())
+        return path.translated(d_ptr->sceneTransform.dx(), d_ptr->sceneTransform.dy());
+    return d_ptr->sceneTransform.map(path);
 }
 
 /*!
@@ -5207,7 +5271,9 @@ QPointF QGraphicsItem::mapFromParent(const QPointF &point) const
 */
 QPointF QGraphicsItem::mapFromScene(const QPointF &point) const
 {
-    return sceneTransform().inverted().map(point);
+    if (d_ptr->hasTranslateOnlySceneTransform())
+        return QPointF(point.x() - d_ptr->sceneTransform.dx(), point.y() - d_ptr->sceneTransform.dy());
+    return d_ptr->sceneTransform.inverted().map(point);
 }
 
 /*!
@@ -5275,7 +5341,9 @@ QPolygonF QGraphicsItem::mapFromParent(const QRectF &rect) const
 */
 QPolygonF QGraphicsItem::mapFromScene(const QRectF &rect) const
 {
-    return sceneTransform().inverted().map(rect);
+    if (d_ptr->hasTranslateOnlySceneTransform())
+        return rect.translated(-d_ptr->sceneTransform.dx(), -d_ptr->sceneTransform.dy());
+    return d_ptr->sceneTransform.inverted().map(rect);
 }
 
 /*!
@@ -5325,7 +5393,9 @@ QPolygonF QGraphicsItem::mapFromParent(const QPolygonF &polygon) const
 */
 QPolygonF QGraphicsItem::mapFromScene(const QPolygonF &polygon) const
 {
-    return sceneTransform().inverted().map(polygon);
+    if (d_ptr->hasTranslateOnlySceneTransform())
+        return polygon.translated(-d_ptr->sceneTransform.dx(), -d_ptr->sceneTransform.dy());
+    return d_ptr->sceneTransform.inverted().map(polygon);
 }
 
 /*!
@@ -5368,7 +5438,9 @@ QPainterPath QGraphicsItem::mapFromParent(const QPainterPath &path) const
 */
 QPainterPath QGraphicsItem::mapFromScene(const QPainterPath &path) const
 {
-    return sceneTransform().inverted().map(path);
+    if (d_ptr->hasTranslateOnlySceneTransform())
+        return path.translated(-d_ptr->sceneTransform.dx(), -d_ptr->sceneTransform.dy());
+    return d_ptr->sceneTransform.inverted().map(path);
 }
 
 /*!
@@ -6333,7 +6405,7 @@ void QGraphicsItem::addToIndex()
         return;
     }
     if (d_ptr->scene)
-        d_ptr->scene->d_func()->addToIndex(this);
+        d_ptr->scene->d_func()->index->addItem(this);
 }
 
 /*!
@@ -6350,7 +6422,7 @@ void QGraphicsItem::removeFromIndex()
         return;
     }
     if (d_ptr->scene)
-        d_ptr->scene->d_func()->removeFromIndex(this);
+        d_ptr->scene->d_func()->index->removeItem(this);
 }
 
 /*!
@@ -6369,10 +6441,12 @@ void QGraphicsItem::removeFromIndex()
 void QGraphicsItem::prepareGeometryChange()
 {
     if (d_ptr->scene) {
+        d_ptr->scene->d_func()->dirtyGrowingItemsBoundingRect = true;
         d_ptr->geometryChanged = 1;
         d_ptr->paintedViewBoundingRectsNeedRepaint = 1;
 
         QGraphicsScenePrivate *scenePrivate = d_ptr->scene->d_func();
+        scenePrivate->index->prepareBoundingRectChange(this);
         scenePrivate->markDirty(this, QRectF(),
                                 /*invalidateChildren=*/true,
                                 /*maybeDirtyClipPath=*/!d_ptr->inSetPosHelper);
@@ -6383,10 +6457,13 @@ void QGraphicsItem::prepareGeometryChange()
         // _q_processDirtyItems is called before _q_emitUpdated.
 	if ((scenePrivate->connectedSignals[0] & scenePrivate->changedSignalMask)
             || scenePrivate->views.isEmpty()) {
-            d_ptr->scene->update(sceneTransform().mapRect(boundingRect()));
+            if (d_ptr->hasTranslateOnlySceneTransform()) {
+                d_ptr->scene->update(boundingRect().translated(d_ptr->sceneTransform.dx(),
+                                                               d_ptr->sceneTransform.dy()));
+            } else {
+                d_ptr->scene->update(d_ptr->sceneTransform.mapRect(boundingRect()));
+            }
         }
-
-        scenePrivate->removeFromIndex(this);
     }
 
     QGraphicsItem *parent = this;
@@ -9706,17 +9783,11 @@ QDebug operator<<(QDebug debug, QGraphicsItem *item)
         return debug;
     }
 
-    QStringList flags;
-    if (item->isVisible()) flags << QLatin1String("isVisible");
-    if (item->isEnabled()) flags << QLatin1String("isEnabled");
-    if (item->isSelected()) flags << QLatin1String("isSelected");
-    if (item->hasFocus()) flags << QLatin1String("HasFocus");
-
     debug << "QGraphicsItem(this =" << ((void*)item)
           << ", parent =" << ((void*)item->parentItem())
           << ", pos =" << item->pos()
-          << ", z =" << item->zValue() << ", flags = {"
-          << flags.join(QLatin1String("|")) << " })";
+          << ", z =" << item->zValue() << ", flags = "
+          << item->flags() << ")";
     return debug;
 }
 
diff --git a/src/gui/graphicsview/qgraphicsitem.h b/src/gui/graphicsview/qgraphicsitem.h
index 374dadf..1f6ebf4 100644
--- a/src/gui/graphicsview/qgraphicsitem.h
+++ b/src/gui/graphicsview/qgraphicsitem.h
@@ -142,7 +142,7 @@ public:
 
     QGraphicsItem(QGraphicsItem *parent = 0
 #ifndef Q_QDOC
-                  // obsolete argument
+                  // ### obsolete argument
                   , QGraphicsScene *scene = 0
 #endif
         );
@@ -209,8 +209,8 @@ public:
     Qt::MouseButtons acceptedMouseButtons() const;
     void setAcceptedMouseButtons(Qt::MouseButtons buttons);
 
-    bool acceptsHoverEvents() const; // obsolete
-    void setAcceptsHoverEvents(bool enabled); // obsolete
+    bool acceptsHoverEvents() const; // ### obsolete
+    void setAcceptsHoverEvents(bool enabled); // ### obsolete
     bool acceptHoverEvents() const;
     void setAcceptHoverEvents(bool enabled);
     bool acceptTouchEvents() const;
@@ -437,11 +437,16 @@ private:
     friend class QGraphicsScene;
     friend class QGraphicsScenePrivate;
     friend class QGraphicsSceneFindItemBspTreeVisitor;
+    friend class QGraphicsSceneBspTree;
     friend class QGraphicsView;
     friend class QGraphicsViewPrivate;
     friend class QGraphicsWidget;
     friend class QGraphicsWidgetPrivate;
     friend class QGraphicsProxyWidgetPrivate;
+    friend class QGraphicsSceneIndex;
+    friend class QGraphicsSceneIndexPrivate;
+    friend class QGraphicsSceneBspTreeIndex;
+    friend class QGraphicsSceneBspTreeIndexPrivate;
     friend class ::tst_QGraphicsItem;
     friend bool qt_closestLeaf(const QGraphicsItem *, const QGraphicsItem *);
     friend bool qt_closestItemFirst(const QGraphicsItem *, const QGraphicsItem *);
@@ -534,7 +539,7 @@ class Q_GUI_EXPORT QAbstractGraphicsShapeItem : public QGraphicsItem
 public:
     QAbstractGraphicsShapeItem(QGraphicsItem *parent = 0
 #ifndef Q_QDOC
-                               // obsolete argument
+                               // ### obsolete argument
                                , QGraphicsScene *scene = 0
 #endif
         );
@@ -564,13 +569,13 @@ class Q_GUI_EXPORT QGraphicsPathItem : public QAbstractGraphicsShapeItem
 public:
     QGraphicsPathItem(QGraphicsItem *parent = 0
 #ifndef Q_QDOC
-                      // obsolete argument
+                      // ### obsolete argument
                       , QGraphicsScene *scene = 0
 #endif
         );
     QGraphicsPathItem(const QPainterPath &path, QGraphicsItem *parent = 0
 #ifndef Q_QDOC
-                      // obsolete argument
+                      // ### obsolete argument
                       , QGraphicsScene *scene = 0
 #endif
         );
@@ -607,19 +612,19 @@ class Q_GUI_EXPORT QGraphicsRectItem : public QAbstractGraphicsShapeItem
 public:
     QGraphicsRectItem(QGraphicsItem *parent = 0
 #ifndef Q_QDOC
-                      // obsolete argument
+                      // ### obsolete argument
                       , QGraphicsScene *scene = 0
 #endif
         );
     QGraphicsRectItem(const QRectF &rect, QGraphicsItem *parent = 0
 #ifndef Q_QDOC
-                      // obsolete argument
+                      // ### obsolete argument
                       , QGraphicsScene *scene = 0
 #endif
         );
     QGraphicsRectItem(qreal x, qreal y, qreal w, qreal h, QGraphicsItem *parent = 0
 #ifndef Q_QDOC
-                      // obsolete argument
+                      // ### obsolete argument
                       , QGraphicsScene *scene = 0
 #endif
         );
@@ -660,19 +665,19 @@ class Q_GUI_EXPORT QGraphicsEllipseItem : public QAbstractGraphicsShapeItem
 public:
     QGraphicsEllipseItem(QGraphicsItem *parent = 0
 #ifndef Q_QDOC
-                         // obsolete argument
+                         // ### obsolete argument
                          , QGraphicsScene *scene = 0
 #endif
         );
     QGraphicsEllipseItem(const QRectF &rect, QGraphicsItem *parent = 0
 #ifndef Q_QDOC
-                         // obsolete argument
+                         // ### obsolete argument
                          , QGraphicsScene *scene = 0
 #endif
         );
     QGraphicsEllipseItem(qreal x, qreal y, qreal w, qreal h, QGraphicsItem *parent = 0
 #ifndef Q_QDOC
-                         // obsolete argument
+                         // ### obsolete argument
                          , QGraphicsScene *scene = 0
 #endif
         );
@@ -719,14 +724,14 @@ class Q_GUI_EXPORT QGraphicsPolygonItem : public QAbstractGraphicsShapeItem
 public:
     QGraphicsPolygonItem(QGraphicsItem *parent = 0
 #ifndef Q_QDOC
-                         // obsolete argument
+                         // ### obsolete argument
                          , QGraphicsScene *scene = 0
 #endif
         );
     QGraphicsPolygonItem(const QPolygonF &polygon,
                          QGraphicsItem *parent = 0
 #ifndef Q_QDOC
-                         // obsolete argument
+                         // ### obsolete argument
                          , QGraphicsScene *scene = 0
 #endif
         );
@@ -766,19 +771,19 @@ class Q_GUI_EXPORT QGraphicsLineItem : public QGraphicsItem
 public:
     QGraphicsLineItem(QGraphicsItem *parent = 0
 #ifndef Q_QDOC
-                      // obsolete argument
+                      // ### obsolete argument
                       , QGraphicsScene *scene = 0
 #endif
         );
     QGraphicsLineItem(const QLineF &line, QGraphicsItem *parent = 0
 #ifndef Q_QDOC
-                      // obsolete argument
+                      // ### obsolete argument
                       , QGraphicsScene *scene = 0
 #endif
         );
     QGraphicsLineItem(qreal x1, qreal y1, qreal x2, qreal y2, QGraphicsItem *parent = 0
 #ifndef Q_QDOC
-                      // obsolete argument
+                      // ### obsolete argument
                       , QGraphicsScene *scene = 0
 #endif
         );
@@ -826,13 +831,13 @@ public:
 
     QGraphicsPixmapItem(QGraphicsItem *parent = 0
 #ifndef Q_QDOC
-                        // obsolete argument
+                        // ### obsolete argument
                         , QGraphicsScene *scene = 0
 #endif
         );
     QGraphicsPixmapItem(const QPixmap &pixmap, QGraphicsItem *parent = 0
 #ifndef Q_QDOC
-                        // obsolete argument
+                        // ### obsolete argument
                         , QGraphicsScene *scene = 0
 #endif
         );
@@ -888,13 +893,13 @@ class Q_GUI_EXPORT QGraphicsTextItem : public QGraphicsObject
 public:
     QGraphicsTextItem(QGraphicsItem *parent = 0
 #ifndef Q_QDOC
-                      // obsolete argument
+                      // ### obsolete argument
                       , QGraphicsScene *scene = 0
 #endif
         );
     QGraphicsTextItem(const QString &text, QGraphicsItem *parent = 0
 #ifndef Q_QDOC
-                      // obsolete argument
+                      // ### obsolete argument
                       , QGraphicsScene *scene = 0
 #endif
         );
@@ -989,13 +994,13 @@ class Q_GUI_EXPORT QGraphicsSimpleTextItem : public QAbstractGraphicsShapeItem
 public:
     QGraphicsSimpleTextItem(QGraphicsItem *parent = 0
 #ifndef Q_QDOC
-                            // obsolete argument
+                            // ### obsolete argument
                             , QGraphicsScene *scene = 0
 #endif
         );
     QGraphicsSimpleTextItem(const QString &text, QGraphicsItem *parent = 0
 #ifndef Q_QDOC
-                            // obsolete argument
+                            // ### obsolete argument
                             , QGraphicsScene *scene = 0
 #endif
         );
@@ -1035,7 +1040,7 @@ class Q_GUI_EXPORT QGraphicsItemGroup : public QGraphicsItem
 public:
     QGraphicsItemGroup(QGraphicsItem *parent = 0
 #ifndef Q_QDOC
-                       // obsolete argument
+                       // ### obsolete argument
                        , QGraphicsScene *scene = 0
 #endif
         );
diff --git a/src/gui/graphicsview/qgraphicsitem_p.h b/src/gui/graphicsview/qgraphicsitem_p.h
index 46ec6fe..ed1982e 100644
--- a/src/gui/graphicsview/qgraphicsitem_p.h
+++ b/src/gui/graphicsview/qgraphicsitem_p.h
@@ -119,6 +119,7 @@ public:
         parent(0),
         transformData(0),
         index(-1),
+        siblingIndex(-1),
         depth(0),
         acceptedMouseButtons(0x1f),
         visible(1),
@@ -149,13 +150,14 @@ public:
         dirtyChildrenBoundingRect(1),
         paintedViewBoundingRectsNeedRepaint(0),
         dirtySceneTransform(1),
-        geometryChanged(0),
+        geometryChanged(1),
         inDestructor(0),
         isObject(0),
         ignoreVisible(0),
         ignoreOpacity(0),
         acceptTouchEvents(0),
         acceptedTouchBeginEvent(0),
+        sceneTransformTranslateOnly(0),
         globalStackingOrder(-1),
         q_ptr(0)
     {
@@ -164,6 +166,15 @@ public:
     inline virtual ~QGraphicsItemPrivate()
     { }
 
+    static const QGraphicsItemPrivate *get(const QGraphicsItem *item)
+    {
+        return item->d_ptr;
+    }
+    static QGraphicsItemPrivate *get(QGraphicsItem *item)
+    {
+        return item->d_ptr;
+    }
+
     void updateAncestorFlag(QGraphicsItem::GraphicsItemFlag childFlag,
                             AncestorFlag flag = NoFlag, bool enabled = false, bool root = true);
     void setIsMemberOfGroup(bool enabled);
@@ -177,6 +188,7 @@ public:
 
     void combineTransformToParent(QTransform *x, const QTransform *viewTransform = 0) const;
     void combineTransformFromParent(QTransform *x, const QTransform *viewTransform = 0) const;
+    void updateSceneTransformFromParent();
 
     // ### Qt 5: Remove. Workaround for reimplementation added after Qt 4.4.
     virtual QVariant inputMethodQueryHelper(Qt::InputMethodQuery query) const;
@@ -286,6 +298,13 @@ public:
     void invalidateCachedClipPathRecursively(bool childrenOnly = false, const QRectF &emptyIfOutsideThisRect = QRectF());
     void updateCachedClipPathFromSetPosHelper(const QPointF &newPos);
     void ensureSceneTransformRecursive(QGraphicsItem **topMostDirtyItem);
+    void ensureSceneTransform();
+
+    inline bool hasTranslateOnlySceneTransform()
+    {
+        ensureSceneTransform();
+        return sceneTransformTranslateOnly;
+    }
 
     inline void invalidateChildrenSceneTransform()
     {
@@ -370,6 +389,7 @@ public:
     }
 
     inline QTransform transformToParent() const;
+    inline void ensureSortedChildren();
 
     QPainterPath cachedClipPath;
     QRectF childrenBoundingRect;
@@ -385,6 +405,7 @@ public:
     TransformData *transformData;
     QTransform sceneTransform;
     int index;
+    int siblingIndex;
     int depth;
 
     // Packed 32 bytes
@@ -426,7 +447,8 @@ public:
     quint32 ignoreOpacity : 1;
     quint32 acceptTouchEvents : 1;
     quint32 acceptedTouchBeginEvent : 1;
-    quint32 unused : 9; // feel free to use
+    quint32 sceneTransformTranslateOnly : 1;
+    quint32 unused : 8; // feel free to use
 
     // Optional stacking order
     int globalStackingOrder;
@@ -457,6 +479,10 @@ struct QGraphicsItemPrivate::TransformData {
         if (onlyTransform) {
             if (!postmultiplyTransform)
                 return transform;
+            if (postmultiplyTransform->isIdentity())
+                return transform;
+            if (transform.isIdentity())
+                return *postmultiplyTransform;
             QTransform x(transform);
             x *= *postmultiplyTransform;
             return x;
@@ -477,6 +503,12 @@ struct QGraphicsItemPrivate::TransformData {
     }
 };
 
+/*!
+    \internal
+*/
+static inline bool qt_notclosestLeaf(const QGraphicsItem *item1, const QGraphicsItem *item2)
+{ return qt_closestLeaf(item2, item1); }
+
 /*
    return the full transform of the item to the parent.  This include the position and all the transform data
 */
@@ -487,6 +519,14 @@ inline QTransform QGraphicsItemPrivate::transformToParent() const
     return matrix;
 }
 
+inline void QGraphicsItemPrivate::ensureSortedChildren()
+{
+    if (needSortChildren) {
+        qSort(children.begin(), children.end(), qt_notclosestLeaf);
+        needSortChildren = 0;
+    }
+}
+
 QT_END_NAMESPACE
 
 #endif // QT_NO_GRAPHICSVIEW
diff --git a/src/gui/graphicsview/qgraphicsscene.cpp b/src/gui/graphicsview/qgraphicsscene.cpp
index b7d948d..d886d03 100644
--- a/src/gui/graphicsview/qgraphicsscene.cpp
+++ b/src/gui/graphicsview/qgraphicsscene.cpp
@@ -39,7 +39,6 @@
 **
 ****************************************************************************/
 
-
 /*!
     \class QGraphicsScene
     \brief The QGraphicsScene class provides a surface for managing a large
@@ -218,6 +217,9 @@
 #include "qgraphicsview_p.h"
 #include "qgraphicswidget.h"
 #include "qgraphicswidget_p.h"
+#include "qgraphicssceneindex_p.h"
+#include "qgraphicsscenebsptreeindex_p.h"
+#include "qgraphicsscenelinearindex_p.h"
 
 #include <QtCore/qdebug.h>
 #include <QtCore/qlist.h>
@@ -251,67 +253,6 @@
 
 QT_BEGIN_NAMESPACE
 
-static inline bool qt_notclosestLeaf(const QGraphicsItem *item1, const QGraphicsItem *item2);
-
-static inline bool QRectF_intersects(const QRectF &s, const QRectF &r)
-{
-    qreal xp = s.left();
-    qreal yp = s.top();
-    qreal w = s.width();
-    qreal h = s.height();
-    qreal l1 = xp;
-    qreal r1 = xp;
-    if (w < 0)
-        l1 += w;
-    else
-        r1 += w;
-
-    qreal l2 = r.left();
-    qreal r2 = r.left();
-    if (w < 0)
-        l2 += r.width();
-    else
-        r2 += r.width();
-
-    if (l1 >= r2 || l2 >= r1)
-        return false;
-
-    qreal t1 = yp;
-    qreal b1 = yp;
-    if (h < 0)
-        t1 += h;
-    else
-        b1 += h;
-
-    qreal t2 = r.top();
-    qreal b2 = r.top();
-    if (r.height() < 0)
-        t2 += r.height();
-    else
-        b2 += r.height();
-
-    return !(t1 >= b2 || t2 >= b1);
-}
-
-// QRectF::intersects() returns false always if either the source or target
-// rectangle's width or height are 0. This works around that problem.
-static inline void _q_adjustRect(QRectF *rect)
-{
-    Q_ASSERT(rect);
-    if (!rect->width())
-        rect->adjust(-0.00001, 0, 0.00001, 0);
-    if (!rect->height())
-        rect->adjust(0, -0.00001, 0, 0.00001);
-}
-
-static inline QRectF adjustedItemBoundingRect(const QGraphicsItem *item)
-{
-    Q_ASSERT(item);
-    QRectF boundingRect(item->boundingRect());
-    _q_adjustRect(&boundingRect);
-    return boundingRect;
-}
-
 static void _q_hoverFromMouseEvent(QGraphicsSceneHoverEvent *hover, const QGraphicsSceneMouseEvent *mouseEvent)
 {
     hover->setWidget(mouseEvent->widget());
@@ -331,18 +272,15 @@ static void _q_hoverFromMouseEvent(QGraphicsSceneHoverEvent *hover, const QGraph
 QGraphicsScenePrivate::QGraphicsScenePrivate()
     : changedSignalMask(0),
       indexMethod(QGraphicsScene::BspTreeIndex),
-      bspTreeDepth(0),
+      index(0),
       lastItemCount(0),
       hasSceneRect(false),
+      dirtyGrowingItemsBoundingRect(true),
       updateAll(false),
       calledEmitUpdated(false),
       processDirtyItemsEmitted(false),
       selectionChanging(0),
       needSortTopLevelItems(true),
-      regenerateIndex(true),
-      purgePending(false),
-      indexTimerId(0),
-      restartIndexTimer(false),
       stickyFocus(false),
       hasFocus(false),
       focusItem(0),
@@ -359,7 +297,6 @@ QGraphicsScenePrivate::QGraphicsScenePrivate()
       allItemsUseDefaultCursor(true),
       painterStateProtection(true),
       sortCacheEnabled(false),
-      updatingSortCache(false),
       style(0),
       allItemsIgnoreTouchEvents(true)
 {
@@ -372,6 +309,8 @@ void QGraphicsScenePrivate::init()
 {
     Q_Q(QGraphicsScene);
 
+    index = new QGraphicsSceneBspTreeIndex(q);
+
     // Keep this index so we can check for connected slots later on.
     changedSignalMask = (1 << q->metaObject()->indexOfSignal("changed(QList<QRectF>)"));
     qApp->d_func()->scene_list.append(q);
@@ -381,223 +320,25 @@ void QGraphicsScenePrivate::init()
 /*!
     \internal
 */
-QList<QGraphicsItem *> QGraphicsScenePrivate::estimateItemsInRect(const QRectF &rect) const
-{
-    const_cast<QGraphicsScenePrivate *>(this)->purgeRemovedItems();
-    const_cast<QGraphicsScenePrivate *>(this)->_q_updateSortCache();
-
-    if (indexMethod == QGraphicsScene::BspTreeIndex) {
-        // ### Only do this once in a while.
-        QGraphicsScenePrivate *that = const_cast<QGraphicsScenePrivate *>(this);
-
-        // Get items from BSP tree
-        QList<QGraphicsItem *> items = that->bspTree.items(rect);
-
-        // Fill in with any unindexed items
-        for (int i = 0; i < unindexedItems.size(); ++i) {
-            if (QGraphicsItem *item = unindexedItems.at(i)) {
-                if (!item->d_ptr->itemDiscovered && item->d_ptr->visible && !(item->d_ptr->ancestorFlags & QGraphicsItemPrivate::AncestorClipsChildren)) {
-                    QRectF boundingRect = item->sceneBoundingRect();
-                    if (QRectF_intersects(boundingRect, rect)) {
-                        item->d_ptr->itemDiscovered = 1;
-                        items << item;
-                    }
-                }
-            }
-        }
-
-        // Reset the discovered state of all discovered items
-        for (int i = 0; i < items.size(); ++i)
-            items.at(i)->d_func()->itemDiscovered = 0;
-        return items;
-    }
-
-    QList<QGraphicsItem *> itemsInRect;
-    for (int i = 0; i < unindexedItems.size(); ++i) {
-        if (QGraphicsItem *item = unindexedItems.at(i)) {
-            if (item->d_ptr->ancestorFlags & QGraphicsItemPrivate::AncestorClipsChildren)
-                continue;
-            if (item->d_ptr->visible && !item->d_ptr->isFullyTransparent())
-                itemsInRect << item;
-        }
-    }
-    for (int i = 0; i < indexedItems.size(); ++i) {
-        if (QGraphicsItem *item = indexedItems.at(i)) {
-            if (item->d_ptr->ancestorFlags & QGraphicsItemPrivate::AncestorClipsChildren)
-                continue;
-            if (item->d_ptr->visible && !item->d_ptr->isFullyTransparent())
-                itemsInRect << item;
-        }
-    }
-
-    return itemsInRect;
-}
-
-/*!
-    \internal
-*/
-void QGraphicsScenePrivate::addToIndex(QGraphicsItem *item)
-{
-    if (indexMethod == QGraphicsScene::BspTreeIndex) {
-        if (item->d_func()->index != -1) {
-            bspTree.insertItem(item, item->sceneBoundingRect());
-            foreach (QGraphicsItem *child, item->children())
-                child->addToIndex();
-        } else {
-            // The BSP tree is regenerated if the number of items grows to a
-            // certain threshold, or if the bounding rect of the graph doubles in
-            // size.
-            startIndexTimer();
-        }
-    }
-}
-
-/*!
-    \internal
-*/
-void QGraphicsScenePrivate::removeFromIndex(QGraphicsItem *item)
-{
-    if (indexMethod == QGraphicsScene::BspTreeIndex) {
-        int index = item->d_func()->index;
-        if (index != -1) {
-            bspTree.removeItem(item, item->sceneBoundingRect());
-            freeItemIndexes << index;
-            indexedItems[index] = 0;
-            item->d_func()->index = -1;
-            unindexedItems << item;
-
-            foreach (QGraphicsItem *child, item->children())
-                child->removeFromIndex();
-        }
-
-        startIndexTimer();
-    }
-}
-
-/*!
-    \internal
-*/
-void QGraphicsScenePrivate::resetIndex()
-{
-    purgeRemovedItems();
-    if (indexMethod == QGraphicsScene::BspTreeIndex) {
-        for (int i = 0; i < indexedItems.size(); ++i) {
-            if (QGraphicsItem *item = indexedItems.at(i)) {
-                item->d_ptr->index = -1;
-                unindexedItems << item;
-            }
-        }
-        indexedItems.clear();
-        freeItemIndexes.clear();
-        regenerateIndex = true;
-        startIndexTimer();
-    }
-}
-
-static inline int intmaxlog(int n)
+QGraphicsScenePrivate *QGraphicsScenePrivate::get(QGraphicsScene *q)
 {
-    return  (n > 0 ? qMax(qCeil(qLn(qreal(n)) / qLn(qreal(2))), 5) : 0);
+    return q->d_func();
 }
 
-/*!
-    \internal
-*/
-void QGraphicsScenePrivate::_q_updateIndex()
+void QGraphicsScenePrivate::_q_emitUpdated()
 {
-    if (!indexTimerId)
-        return;
-
     Q_Q(QGraphicsScene);
-    q->killTimer(indexTimerId);
-    indexTimerId = 0;
-
-    purgeRemovedItems();
-
-    // Add unindexedItems to indexedItems
-    QRectF unindexedItemsBoundingRect;
-    for (int i = 0; i < unindexedItems.size(); ++i) {
-        if (QGraphicsItem *item = unindexedItems.at(i)) {
-            unindexedItemsBoundingRect |= item->sceneBoundingRect();
-            if (!freeItemIndexes.isEmpty()) {
-                int freeIndex = freeItemIndexes.takeFirst();
-                item->d_func()->index = freeIndex;
-                indexedItems[freeIndex] = item;
-            } else {
-                item->d_func()->index = indexedItems.size();
-                indexedItems << item;
-            }
-        }
-    }
-
-    // Update growing scene rect.
-    QRectF oldGrowingItemsBoundingRect = growingItemsBoundingRect;
-    growingItemsBoundingRect |= unindexedItemsBoundingRect;
-
-    // Determine whether we should regenerate the BSP tree.
-    if (indexMethod == QGraphicsScene::BspTreeIndex) {
-        int depth = bspTreeDepth;
-        if (depth == 0) {
-            int oldDepth = intmaxlog(lastItemCount);
-            depth = intmaxlog(indexedItems.size());
-            static const int slack = 100;
-            if (bspTree.leafCount() == 0 || (oldDepth != depth && qAbs(lastItemCount - indexedItems.size()) > slack)) {
-                // ### Crude algorithm.
-                regenerateIndex = true;
-            }
-        }
-
-        // Regenerate the tree.
-        if (regenerateIndex) {
-            regenerateIndex = false;
-            bspTree.initialize(q->sceneRect(), depth);
-            unindexedItems = indexedItems;
-            lastItemCount = indexedItems.size();
-            q->update();
-
-            // Take this opportunity to reset our largest-item counter for
-            // untransformable items. When the items are inserted into the BSP
-            // tree, we'll get an accurate calculation.
-            largestUntransformableItem = QRectF();
-        }
-    }
+    calledEmitUpdated = false;
 
-    // Insert all unindexed items into the tree.
-    for (int i = 0; i < unindexedItems.size(); ++i) {
-        if (QGraphicsItem *item = unindexedItems.at(i)) {
-            QRectF rect = item->sceneBoundingRect();
-            if (item->d_ptr->ancestorFlags & QGraphicsItemPrivate::AncestorClipsChildren)
-                continue;
-            if (indexMethod == QGraphicsScene::BspTreeIndex)
-                bspTree.insertItem(item, rect);
-
-            // If the item ignores view transformations, update our
-            // largest-item-counter to ensure that the view can accurately
-            // discover untransformable items when drawing.
-            if (item->d_ptr->itemIsUntransformable()) {
-                QGraphicsItem *topmostUntransformable = item;
-                while (topmostUntransformable && (topmostUntransformable->d_ptr->ancestorFlags
-                                                  & QGraphicsItemPrivate::AncestorIgnoresTransformations)) {
-                    topmostUntransformable = topmostUntransformable->parentItem();
-                }
-                // ### Verify that this is the correct largest untransformable rectangle.
-                largestUntransformableItem |= item->mapToItem(topmostUntransformable, item->boundingRect()).boundingRect();
-            }
+    if (dirtyGrowingItemsBoundingRect) {
+        if (!hasSceneRect) {
+            const QRectF oldGrowingItemsBoundingRect = growingItemsBoundingRect;
+            growingItemsBoundingRect |= q->itemsBoundingRect();
+            if (oldGrowingItemsBoundingRect != growingItemsBoundingRect)
+                emit q->sceneRectChanged(growingItemsBoundingRect);
         }
+        dirtyGrowingItemsBoundingRect = false;
     }
-    unindexedItems.clear();
-
-    // Notify scene rect changes.
-    if (!hasSceneRect && growingItemsBoundingRect != oldGrowingItemsBoundingRect)
-        emit q->sceneRectChanged(growingItemsBoundingRect);
-}
-
-/*!
-    \internal
-*/
-void QGraphicsScenePrivate::_q_emitUpdated()
-{
-    Q_Q(QGraphicsScene);
-    calledEmitUpdated = false;
 
     // Ensure all views are connected if anything is connected. This disables
     // the optimization that items send updates directly to the views, but it
@@ -633,6 +374,7 @@ void QGraphicsScenePrivate::_q_emitUpdated()
 void QGraphicsScenePrivate::registerTopLevelItem(QGraphicsItem *item)
 {
     needSortTopLevelItems = true;
+    item->d_ptr->siblingIndex = topLevelItems.size();
     topLevelItems.append(item);
 }
 
@@ -642,19 +384,10 @@ void QGraphicsScenePrivate::registerTopLevelItem(QGraphicsItem *item)
 void QGraphicsScenePrivate::unregisterTopLevelItem(QGraphicsItem *item)
 {
     topLevelItems.removeOne(item);
-}
-
-/*!
-    \internal
-
-    Updates all items in the pending update list. At this point, the list is
-    unlikely to contain partially constructed items.
-*/
-void QGraphicsScenePrivate::_q_updateLater()
-{
-    foreach (QGraphicsItem *item, pendingUpdateItems)
-        item->update();
-    pendingUpdateItems.clear();
+    // NB! Do not use topLevelItems.removeAt(item->d_ptr->siblingIndex) because
+    // the item is not guaranteed to be at the index after the list is sorted
+    // (see ensureSortedTopLevelItems()).
+    item->d_ptr->siblingIndex = -1;
 }
 
 /*!
@@ -680,9 +413,23 @@ void QGraphicsScenePrivate::_q_processDirtyItems()
 {
     processDirtyItemsEmitted = false;
 
+    if (updateAll) {
+        Q_ASSERT(calledEmitUpdated);
+        // No need for further processing (except resetting the dirty states).
+        // The growingItemsBoundingRect is updated in _q_emitUpdated.
+        for (int i = 0; i < topLevelItems.size(); ++i)
+            resetDirtyItem(topLevelItems.at(i), /*recursive=*/true);
+        return;
+    }
+
     const bool wasPendingSceneUpdate = calledEmitUpdated;
     const QRectF oldGrowingItemsBoundingRect = growingItemsBoundingRect;
-    processDirtyItemsRecursive(0);
+
+    // Process items recursively.
+    for (int i = 0; i < topLevelItems.size(); ++i)
+        processDirtyItemsRecursive(topLevelItems.at(i));
+
+    dirtyGrowingItemsBoundingRect = false;
     if (!hasSceneRect && oldGrowingItemsBoundingRect != growingItemsBoundingRect)
         emit q_func()->sceneRectChanged(growingItemsBoundingRect);
 
@@ -727,22 +474,16 @@ void QGraphicsScenePrivate::removeItemHelper(QGraphicsItem *item)
 
     // Clear focus on the item to remove any reference in the focusWidget chain.
     item->clearFocus();
+
     markDirty(item, QRectF(), false, false, false, false, /*removingItemFromScene=*/true);
 
-    if (!item->d_ptr->inDestructor) {
+    if (item->d_ptr->inDestructor) {
+        // The item is actually in its destructor, we call the special method in the index.
+        index->deleteItem(item);
+    } else {
         // Can potentially call item->boundingRect() (virtual function), that's why
         // we only can call this function if the item is not in its destructor.
-        removeFromIndex(item);
-    } else if (item->d_ptr->index != -1) {
-        // Important: The index is useless until purgeRemovedItems() is called.
-        indexedItems[item->d_ptr->index] = (QGraphicsItem *)0;
-        if (!purgePending)
-            purgePending = true;
-        removedItems << item;
-    } else {
-        // Recently added items are purged immediately. unindexedItems() never
-        // contains stale items.
-        unindexedItems.removeAll(item);
+        index->removeItem(item);
     }
 
     if (!item->d_ptr->inDestructor && item == tabFocusFirst) {
@@ -763,17 +504,6 @@ void QGraphicsScenePrivate::removeItemHelper(QGraphicsItem *item)
         unregisterTopLevelItem(item);
     }
 
-    if (!item->d_ptr->inDestructor) {
-        // Remove from our item lists.
-        int index = item->d_func()->index;
-        if (index != -1) {
-            freeItemIndexes << index;
-            indexedItems[index] = 0;
-        } else {
-            unindexedItems.removeAll(item);
-        }
-    }
-
     // Reset the mouse grabber and focus item data.
     if (item == focusItem)
         focusItem = 0;
@@ -793,7 +523,6 @@ void QGraphicsScenePrivate::removeItemHelper(QGraphicsItem *item)
     hoverItems.removeAll(item);
     cachedItemsUnderMouse.removeAll(item);
     unpolishedItems.removeAll(item);
-    pendingUpdateItems.removeAll(item);
     resetDirtyItem(item);
 
     //We remove all references of item from the sceneEventFilter arrays
@@ -831,45 +560,6 @@ void QGraphicsScenePrivate::removeItemHelper(QGraphicsItem *item)
 
 /*!
     \internal
-
-    Removes stale pointers from all data structures.
-*/
-void QGraphicsScenePrivate::purgeRemovedItems()
-{
-    if (!purgePending && removedItems.isEmpty())
-        return;
-
-    // Remove stale items from the BSP tree.
-    if (indexMethod != QGraphicsScene::NoIndex)
-        bspTree.removeItems(removedItems);
-
-    // Purge this list.
-    removedItems.clear();
-    freeItemIndexes.clear();
-    for (int i = 0; i < indexedItems.size(); ++i) {
-        if (!indexedItems.at(i))
-            freeItemIndexes << i;
-    }
-    purgePending = false;
-}
-
-/*!
-    \internal
-
-    Starts or restarts the timer used for reindexing unindexed items.
-*/
-void QGraphicsScenePrivate::startIndexTimer(int interval)
-{
-    Q_Q(QGraphicsScene);
-    if (indexTimerId) {
-        restartIndexTimer = true;
-    } else {
-        indexTimerId = q->startTimer(interval);
-    }
-}
-
-/*!
-    \internal
 */
 void QGraphicsScenePrivate::addPopup(QGraphicsWidget *widget)
 {
@@ -1104,41 +794,20 @@ QList<QGraphicsItem *> QGraphicsScenePrivate::itemsAtPosition(const QPoint &scre
 {
     Q_Q(const QGraphicsScene);
     QGraphicsView *view = widget ? qobject_cast<QGraphicsView *>(widget->parentWidget()) : 0;
-    QList<QGraphicsItem *> items;
-    if (view)
-        items = view->items(view->viewport()->mapFromGlobal(screenPos));
-    else
-        items = q->items(scenePos);
-    return items;
-}
+    if (!view)
+        return q->items(scenePos, Qt::IntersectsItemShape, Qt::AscendingOrder, QTransform());
 
-/*!
-    \internal
+    const QRectF pointRect(QPointF(widget->mapFromGlobal(screenPos)), QSizeF(1, 1));
+    if (!view->isTransformed())
+        return q->items(pointRect, Qt::IntersectsItemShape, Qt::AscendingOrder);
 
-    Checks if item collides with the path and mode, but also checks that if it
-    doesn't collide, maybe its frame rect will.
-*/
-bool QGraphicsScenePrivate::itemCollidesWithPath(QGraphicsItem *item,
-                                                 const QPainterPath &path,
-                                                 Qt::ItemSelectionMode mode)
-{
-    if (item->collidesWithPath(path, mode))
-        return true;
-    if (item->isWidget()) {
-        // Check if this is a window, and if its frame rect collides.
-        QGraphicsWidget *widget = static_cast<QGraphicsWidget *>(item);
-        if (widget->isWindow()) {
-            QRectF frameRect = widget->windowFrameRect();
-            QPainterPath framePath;
-            framePath.addRect(frameRect);
-            bool intersects = path.intersects(frameRect);
-            if (mode == Qt::IntersectsItemShape || mode == Qt::IntersectsItemBoundingRect)
-                return intersects || path.contains(frameRect.topLeft())
-                    || framePath.contains(path.elementAt(0));
-            return !intersects && path.contains(frameRect.topLeft());
-        }
+    const QTransform viewTransform = view->viewportTransform();
+    if (viewTransform.type() <= QTransform::TxScale) {
+        return q->items(viewTransform.inverted().mapRect(pointRect), Qt::IntersectsItemShape,
+                        Qt::AscendingOrder, viewTransform);
     }
-    return false;
+    return q->items(viewTransform.inverted().map(pointRect), Qt::IntersectsItemShape,
+                    Qt::AscendingOrder, viewTransform);
 }
 
 /*!
@@ -1150,7 +819,7 @@ void QGraphicsScenePrivate::storeMouseButtonsForMouseGrabber(QGraphicsSceneMouse
         if (event->buttons() & i) {
             mouseGrabberButtonDownPos.insert(Qt::MouseButton(i),
                                              mouseGrabberItems.last()->d_ptr->genericMapFromScene(event->scenePos(),
-                                                                                          event->widget()));
+                                                                                                  event->widget()));
             mouseGrabberButtonDownScenePos.insert(Qt::MouseButton(i), event->scenePos());
             mouseGrabberButtonDownScreenPos.insert(Qt::MouseButton(i), event->screenPos());
         }
@@ -1428,779 +1097,6 @@ QGraphicsWidget *QGraphicsScenePrivate::windowForItem(const QGraphicsItem *item)
     return 0;
 }
 
-QList<QGraphicsItem *> QGraphicsScenePrivate::topLevelItemsInStackingOrder(const QTransform *const viewTransform,
-                                                                           QRegion *exposedRegion)
-{
-    if (indexMethod == QGraphicsScene::NoIndex || !exposedRegion) {
-        if (needSortTopLevelItems) {
-            needSortTopLevelItems = false;
-            qStableSort(topLevelItems.begin(), topLevelItems.end(), qt_notclosestLeaf);
-        }
-        return topLevelItems;
-    }
-
-    const QRectF exposedRect = exposedRegion->boundingRect().adjusted(-1, -1, 1, 1);
-    QRectF sceneRect;
-    QTransform invertedViewTransform(Qt::Uninitialized);
-    if (!viewTransform) {
-        sceneRect = exposedRect;
-    } else {
-        invertedViewTransform = viewTransform->inverted();
-        sceneRect = invertedViewTransform.mapRect(exposedRect);
-    }
-    if (!largestUntransformableItem.isEmpty()) {
-        // ### Nuke this when we move the indexing code into a separate
-        // class.  All the largestUntransformableItem code should then go
-        // away, and the estimate function should return untransformable
-        // items as well.
-        QRectF untr = largestUntransformableItem;
-        QRectF ltri = !viewTransform ? untr : invertedViewTransform.mapRect(untr);
-        ltri.adjust(-untr.width(), -untr.height(), untr.width(), untr.height());
-        sceneRect.adjust(-ltri.width(), -ltri.height(), ltri.width(), ltri.height());
-    }
-
-    QList<QGraphicsItem *> tmp = estimateItemsInRect(sceneRect);
-    for (int i = 0; i < tmp.size(); ++i)
-        tmp.at(i)->topLevelItem()->d_ptr->itemDiscovered = 1;
-
-    // Sort if the toplevel list is unsorted.
-    if (needSortTopLevelItems) {
-        needSortTopLevelItems = false;
-        qStableSort(topLevelItems.begin(), topLevelItems.end(), qt_notclosestLeaf);
-    }
-
-    QList<QGraphicsItem *> tli;
-    for (int i = 0; i < topLevelItems.size(); ++i) {
-        // ### Investigate smarter ways. Looping through all top level
-        // items is not optimal. If the BSP tree is to have maximum
-        // effect, it should be possible to sort the subset of items
-        // quickly. We must use this approach for now, as it's the only
-        // current way to keep the stable sorting order (insertion order).
-        QGraphicsItem *item = topLevelItems.at(i);
-        if (item->d_ptr->itemDiscovered) {
-            item->d_ptr->itemDiscovered = 0;
-            tli << item;
-        }
-    }
-    return tli;
-}
-
-void QGraphicsScenePrivate::recursive_items_helper(QGraphicsItem *item, QRectF rect,
-                                                   QList<QGraphicsItem *> *items,
-                                                   const QTransform &parentTransform,
-                                                   const QTransform &viewTransform,
-                                                   Qt::ItemSelectionMode mode, Qt::SortOrder order,
-                                                   qreal parentOpacity) const
-{
-    // Calculate opacity.
-    qreal opacity;
-    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;
-        }
-        if (opacity == 0.0 && !(item->d_ptr->flags & QGraphicsItem::ItemDoesntPropagateOpacityToChildren))
-            return;
-    } else {
-        opacity = parentOpacity;
-    }
-
-    // Calculate the full transform for this item.
-    QTransform transform = parentTransform;
-    bool keep = false;
-    if (item) {
-        item->d_ptr->combineTransformFromParent(&transform, &viewTransform);
-
-        // ### This does not take the clip into account.
-        QRectF brect = item->boundingRect();
-        _q_adjustRect(&brect);
-
-        keep = true;
-        if (mode == Qt::ContainsItemShape || mode == Qt::ContainsItemBoundingRect)
-            keep = rect.contains(transform.mapRect(brect)) && rect != brect;
-        else
-            keep = rect.intersects(transform.mapRect(brect));
-
-        if (keep && (mode == Qt::ContainsItemShape || mode == Qt::IntersectsItemShape)) {
-            QPainterPath rectPath;
-            rectPath.addRect(rect);
-            keep = itemCollidesWithPath(item, transform.inverted().map(rectPath), mode);
-        }
-    }
-
-    bool childClip = (item && (item->d_ptr->flags & QGraphicsItem::ItemClipsChildrenToShape));
-    bool dontProcessItem = !item || !keep;
-    bool dontProcessChildren = item && dontProcessItem && childClip;
-
-    // Find and sort children.
-    QList<QGraphicsItem *> &children = item ? item->d_ptr->children : const_cast<QGraphicsScenePrivate *>(this)->topLevelItems;
-    if (!dontProcessChildren) {
-        if (item && item->d_ptr->needSortChildren) {
-            item->d_ptr->needSortChildren = 0;
-            qStableSort(children.begin(), children.end(), qt_notclosestLeaf);
-        } else if (!item && needSortTopLevelItems) {
-            const_cast<QGraphicsScenePrivate *>(this)->needSortTopLevelItems = false;
-            qStableSort(children.begin(), children.end(), qt_notclosestLeaf);
-        }
-    }
-
-    childClip &= !dontProcessChildren & !children.isEmpty();
-
-    // Clip.
-    if (childClip)
-        rect &= transform.map(item->shape()).controlPointRect();
-
-    // Process children behind
-    int i = 0;
-    if (!dontProcessChildren) {
-        for (i = 0; i < children.size(); ++i) {
-            QGraphicsItem *child = children.at(i);
-            if (!(child->d_ptr->flags & QGraphicsItem::ItemStacksBehindParent))
-                break;
-            recursive_items_helper(child, rect, items, transform, viewTransform,
-                                   mode, order, opacity);
-        }
-    }
-
-    // Process item
-    if (!dontProcessItem)
-        items->append(item);
-
-    // Process children in front
-    if (!dontProcessChildren) {
-        for (; i < children.size(); ++i)
-            recursive_items_helper(children.at(i), rect, items, transform, viewTransform,
-                                   mode, order, opacity);
-    }
-
-    if (!item && order == Qt::AscendingOrder) {
-        int n = items->size();
-        for (int i = 0; i < n / 2; ++i) {
-            QGraphicsItem *tmp = (*items)[n - i - 1];
-            (*items)[n - i - 1] = (*items)[i];
-            (*items)[i] = tmp;
-        }
-    }
-}
-
-QList<QGraphicsItem *> QGraphicsScenePrivate::items_helper(const QPointF &pos) const
-{
-    QList<QGraphicsItem *> items;
-
-    // The index returns a rough estimate of what items are inside the rect.
-    // Refine it by iterating through all returned items.
-    QRectF adjustedRect = QRectF(pos, QSize(1,1));
-    foreach (QGraphicsItem *item, estimateItemsInRect(adjustedRect)) {
-        // Find the item's scene transform in a clever way.
-        QTransform x = item->sceneTransform();
-        bool keep = false;
-
-        // ### _q_adjustedRect is only needed because QRectF::intersects,
-        // QRectF::contains and QTransform::map() and friends don't work with
-        // flat rectangles.
-        const QRectF br(adjustedItemBoundingRect(item));
-            // Rect intersects/contains item's shape
-        if (QRectF_intersects(adjustedRect, x.mapRect(br))) {
-            bool ok;
-            QTransform xinv = x.inverted(&ok);
-            if (ok) {
-                if (item->contains(xinv.map(pos))) {
-                    items << item;
-                    keep = true;
-                }
-            }
-        }
-
-        if (keep && (item->flags() & QGraphicsItem::ItemClipsChildrenToShape)) {
-            // Recurse into children that clip children.
-            bool ok;
-            QTransform xinv = x.inverted(&ok);
-            if (ok)
-                childItems_helper(&items, item, xinv.map(pos));
-        }
-    }
-
-    sortItems(&items, Qt::AscendingOrder, sortCacheEnabled);
-    return items;
-}
-
-QList<QGraphicsItem *> QGraphicsScenePrivate::items_helper(const QRectF &rect,
-                                                           Qt::ItemSelectionMode mode,
-                                                           Qt::SortOrder order) const
-{
-    QList<QGraphicsItem *> items;
-
-    QPainterPath path;
-
-    // The index returns a rough estimate of what items are inside the rect.
-    // Refine it by iterating through all returned items.
-    QRectF adjustedRect(rect);
-    _q_adjustRect(&adjustedRect);
-    foreach (QGraphicsItem *item, estimateItemsInRect(adjustedRect)) {
-        // Find the item's scene transform in a clever way.
-        QTransform x = item->sceneTransform();
-        bool keep = false;
-
-        // ### _q_adjustedRect is only needed because QRectF::intersects,
-        // QRectF::contains and QTransform::map() and friends don't work with
-        // flat rectangles.
-        const QRectF br(adjustedItemBoundingRect(item));
-        if (mode >= Qt::ContainsItemBoundingRect) {
-            // Rect intersects/contains item's bounding rect
-            QRectF mbr = x.mapRect(br);
-            if ((mode == Qt::IntersectsItemBoundingRect && QRectF_intersects(rect, mbr))
-                || (mode == Qt::ContainsItemBoundingRect && rect != mbr && rect.contains(mbr))) {
-                items << item;
-                keep = true;
-            }
-        } else {
-            // Rect intersects/contains item's shape
-            if (QRectF_intersects(adjustedRect, x.mapRect(br))) {
-                bool ok;
-                QTransform xinv = x.inverted(&ok);
-                if (ok) {
-                    if (path.isEmpty())
-                        path.addRect(rect);
-                    if (itemCollidesWithPath(item, xinv.map(path), mode)) {
-                        items << item;
-                        keep = true;
-                    }
-                }
-            }
-        }
-
-        if (keep && (item->flags() & QGraphicsItem::ItemClipsChildrenToShape)) {
-            // Recurse into children that clip children.
-            bool ok;
-            QTransform xinv = x.inverted(&ok);
-            if (ok) {
-                if (x.type() <= QTransform::TxScale) {
-                    // Rect
-                    childItems_helper(&items, item, xinv.mapRect(rect), mode);
-                } else {
-                    // Polygon
-                    childItems_helper(&items, item, xinv.map(rect), mode);
-                }
-            }
-        }
-    }
-
-    if (order != Qt::SortOrder(-1))
-        sortItems(&items, order, sortCacheEnabled);
-    return items;
-}
-
-QList<QGraphicsItem *> QGraphicsScenePrivate::items_helper(const QPolygonF &polygon,
-                                                           Qt::ItemSelectionMode mode,
-                                                           Qt::SortOrder order) const
-{
-    QList<QGraphicsItem *> items;
-
-    QRectF polyRect(polygon.boundingRect());
-     _q_adjustRect(&polyRect);
-    QPainterPath path;
-
-    // The index returns a rough estimate of what items are inside the rect.
-    // Refine it by iterating through all returned items.
-    foreach (QGraphicsItem *item, estimateItemsInRect(polyRect)) {
-        // Find the item's scene transform in a clever way.
-        QTransform x = item->sceneTransform();
-        bool keep = false;
-
-        // ### _q_adjustedRect is only needed because QRectF::intersects,
-        // QRectF::contains and QTransform::map() and friends don't work with
-        // flat rectangles.
-        const QRectF br(adjustedItemBoundingRect(item));
-        if (mode >= Qt::ContainsItemBoundingRect) {
-            // Polygon contains/intersects item's bounding rect
-            if (path == QPainterPath())
-                path.addPolygon(polygon);
-            if ((mode == Qt::IntersectsItemBoundingRect && path.intersects(x.mapRect(br)))
-                || (mode == Qt::ContainsItemBoundingRect && path.contains(x.mapRect(br)))) {
-                items << item;
-                keep = true;
-            }
-        } else {
-            // Polygon contains/intersects item's shape
-            if (QRectF_intersects(polyRect, x.mapRect(br))) {
-                bool ok;
-                QTransform xinv = x.inverted(&ok);
-                if (ok) {
-                    if (path == QPainterPath())
-                        path.addPolygon(polygon);
-                    if (itemCollidesWithPath(item, xinv.map(path), mode)) {
-                        items << item;
-                        keep = true;
-                    }
-                }
-            }
-        }
-
-        if (keep && (item->flags() & QGraphicsItem::ItemClipsChildrenToShape)) {
-            // Recurse into children that clip children.
-            bool ok;
-            QTransform xinv = x.inverted(&ok);
-            if (ok)
-                childItems_helper(&items, item, xinv.map(polygon), mode);
-        }
-    }
-
-    if (order != Qt::SortOrder(-1))
-        sortItems(&items, order, sortCacheEnabled);
-    return items;
-}
-
-QList<QGraphicsItem *> QGraphicsScenePrivate::items_helper(const QPainterPath &path,
-                                                           Qt::ItemSelectionMode mode,
-                                                           Qt::SortOrder order) const
-{
-    QList<QGraphicsItem *> items;
-    QRectF pathRect(path.controlPointRect());
-    _q_adjustRect(&pathRect);
-
-    // The index returns a rough estimate of what items are inside the rect.
-    // Refine it by iterating through all returned items.
-    foreach (QGraphicsItem *item, estimateItemsInRect(pathRect)) {
-        // Find the item's scene transform in a clever way.
-        QTransform x = item->sceneTransform();
-        bool keep = false;
-
-        // ### _q_adjustedRect is only needed because QRectF::intersects,
-        // QRectF::contains and QTransform::map() and friends don't work with
-        // flat rectangles.
-        const QRectF br(adjustedItemBoundingRect(item));
-        if (mode >= Qt::ContainsItemBoundingRect) {
-            // Path contains/intersects item's bounding rect
-            if ((mode == Qt::IntersectsItemBoundingRect && path.intersects(x.mapRect(br)))
-                || (mode == Qt::ContainsItemBoundingRect && path.contains(x.mapRect(br)))) {
-                items << item;
-                keep = true;
-            }
-        } else {
-            // Path contains/intersects item's shape
-            if (QRectF_intersects(pathRect, x.mapRect(br))) {
-                bool ok;
-                QTransform xinv = x.inverted(&ok);
-                if (ok) {
-                    if (itemCollidesWithPath(item, xinv.map(path), mode)) {
-                        items << item;
-                        keep = true;
-                    }
-                }
-            }
-        }
-
-        if (keep && (item->flags() & QGraphicsItem::ItemClipsChildrenToShape)) {
-            bool ok;
-            QTransform xinv = x.inverted(&ok);
-            if (ok)
-                childItems_helper(&items, item, xinv.map(path), mode);
-        }
-    }
-
-    if (order != Qt::SortOrder(-1))
-        sortItems(&items, order, sortCacheEnabled);
-    return items;
-}
-
-void QGraphicsScenePrivate::childItems_helper(QList<QGraphicsItem *> *items,
-                                              const QGraphicsItem *parent,
-                                              const QPointF &pos) const
-{
-    bool parentClip = (parent->flags() & QGraphicsItem::ItemClipsChildrenToShape);
-    if (parentClip && parent->d_ptr->isClippedAway())
-        return;
-    // ### is this needed?
-    if (parentClip && !parent->boundingRect().contains(pos))
-        return;
-
-    QList<QGraphicsItem *> &children = parent->d_ptr->children;
-    for (int i = 0; i < children.size(); ++i) {
-        QGraphicsItem *item = children.at(i);
-        if (item->d_ptr->transformData && !item->d_ptr->transformData->computedFullTransform().isInvertible())
-            continue;
-
-        // Skip invisible items and all their children.
-        if (item->d_ptr->isInvisible())
-            continue;
-
-        bool keep = false;
-        if (!item->d_ptr->isClippedAway()) {
-            if (item->contains(item->mapFromParent(pos))) {
-                items->append(item);
-                keep = true;
-            }
-        }
-
-        if ((keep || !(item->flags() & QGraphicsItem::ItemClipsChildrenToShape)) && !item->d_ptr->children.isEmpty())
-            // Recurse into children.
-            childItems_helper(items, item, item->mapFromParent(pos));
-    }
-}
-
-
-void QGraphicsScenePrivate::childItems_helper(QList<QGraphicsItem *> *items,
-                                              const QGraphicsItem *parent,
-                                              const QRectF &rect,
-                                              Qt::ItemSelectionMode mode) const
-{
-    bool parentClip = (parent->flags() & QGraphicsItem::ItemClipsChildrenToShape);
-    if (parentClip && parent->d_ptr->isClippedAway())
-        return;
-    QRectF adjustedRect(rect);
-    _q_adjustRect(&adjustedRect);
-    QRectF r = !parentClip ? adjustedRect : adjustedRect.intersected(adjustedItemBoundingRect(parent));
-    if (r.isEmpty())
-        return;
-
-    QPainterPath path;
-    QList<QGraphicsItem *> &children = parent->d_ptr->children;
-    for (int i = 0; i < children.size(); ++i) {
-        QGraphicsItem *item = children.at(i);
-        if (item->d_ptr->transformData && !item->d_ptr->transformData->computedFullTransform().isInvertible())
-            continue;
-
-        // Skip invisible items and all their children.
-        if (item->d_ptr->isInvisible())
-            continue;
-
-        bool keep = false;
-        if (!item->d_ptr->isClippedAway()) {
-            // ### _q_adjustedRect is only needed because QRectF::intersects,
-            // QRectF::contains and QTransform::map() and friends don't work with
-            // flat rectangles.
-            const QRectF br(adjustedItemBoundingRect(item));
-            QRectF mbr = item->mapRectToParent(br);
-            if (mode >= Qt::ContainsItemBoundingRect) {
-                // Rect intersects/contains item's bounding rect
-                if ((mode == Qt::IntersectsItemBoundingRect && QRectF_intersects(rect, mbr))
-                    || (mode == Qt::ContainsItemBoundingRect && rect != mbr && rect.contains(br))) {
-                    items->append(item);
-                    keep = true;
-                }
-            } else {
-                // Rect intersects/contains item's shape
-                if (QRectF_intersects(rect, mbr)) {
-                    if (path == QPainterPath())
-                        path.addRect(rect);
-                    if (itemCollidesWithPath(item, item->mapFromParent(path), mode)) {
-                        items->append(item);
-                        keep = true;
-                    }
-                }
-            }
-        }
-
-        if ((keep || !(item->flags() & QGraphicsItem::ItemClipsChildrenToShape)) && !item->d_ptr->children.isEmpty()) {
-            // Recurse into children.
-            if (!item->d_ptr->transformData || item->d_ptr->transformData->computedFullTransform().type() <= QTransform::TxScale) {
-                // Rect
-                childItems_helper(items, item, item->mapRectFromParent(rect), mode);
-            } else {
-                // Polygon
-                childItems_helper(items, item, item->mapFromParent(rect), mode);
-            }
-        }
-    }
-}
-
-
-void QGraphicsScenePrivate::childItems_helper(QList<QGraphicsItem *> *items,
-                                              const QGraphicsItem *parent,
-                                              const QPolygonF &polygon,
-                                              Qt::ItemSelectionMode mode) const
-{
-    bool parentClip = (parent->flags() & QGraphicsItem::ItemClipsChildrenToShape);
-    if (parentClip && parent->d_ptr->isClippedAway())
-        return;
-    QRectF polyRect(polygon.boundingRect());
-    _q_adjustRect(&polyRect);
-    QRectF r = !parentClip ? polyRect : polyRect.intersected(adjustedItemBoundingRect(parent));
-    if (r.isEmpty())
-        return;
-
-    QPainterPath path;
-    QList<QGraphicsItem *> &children = parent->d_ptr->children;
-    for (int i = 0; i < children.size(); ++i) {
-        QGraphicsItem *item = children.at(i);
-        if (item->d_ptr->transformData && !item->d_ptr->transformData->computedFullTransform().isInvertible())
-            continue;
-
-        // Skip invisible items.
-        if (item->d_ptr->isInvisible())
-            continue;
-
-        bool keep = false;
-        if (!item->d_ptr->isClippedAway()) {
-            // ### _q_adjustedRect is only needed because QRectF::intersects,
-            // QRectF::contains and QTransform::map() and friends don't work with
-            // flat rectangles.
-            const QRectF br(adjustedItemBoundingRect(item));
-            if (mode >= Qt::ContainsItemBoundingRect) {
-                // Polygon contains/intersects item's bounding rect
-                if (path == QPainterPath())
-                    path.addPolygon(polygon);
-                if ((mode == Qt::IntersectsItemBoundingRect && path.intersects(item->mapRectToParent(br)))
-                    || (mode == Qt::ContainsItemBoundingRect && path.contains(item->mapRectToParent(br)))) {
-                    items->append(item);
-                    keep = true;
-                }
-            } else {
-                // Polygon contains/intersects item's shape
-                if (QRectF_intersects(polyRect, item->mapRectToParent(br))) {
-                    if (path == QPainterPath())
-                        path.addPolygon(polygon);
-                    if (itemCollidesWithPath(item, item->mapFromParent(path), mode)) {
-                        items->append(item);
-                        keep = true;
-                    }
-                }
-            }
-        }
-
-        if ((keep || !(item->flags() & QGraphicsItem::ItemClipsChildrenToShape)) && !item->d_ptr->children.isEmpty()) {
-            // Recurse into children that clip children.
-            childItems_helper(items, item, item->mapFromParent(polygon), mode);
-        }
-    }
-}
-
-void QGraphicsScenePrivate::childItems_helper(QList<QGraphicsItem *> *items,
-                                              const QGraphicsItem *parent,
-                                              const QPainterPath &path,
-                                              Qt::ItemSelectionMode mode) const
-{
-    bool parentClip = (parent->flags() & QGraphicsItem::ItemClipsChildrenToShape);
-    if (parentClip && parent->d_ptr->isClippedAway())
-        return;
-    QRectF pathRect(path.boundingRect());
-    _q_adjustRect(&pathRect);
-    QRectF r = !parentClip ? pathRect : pathRect.intersected(adjustedItemBoundingRect(parent));
-    if (r.isEmpty())
-        return;
-
-    QList<QGraphicsItem *> &children = parent->d_ptr->children;
-    for (int i = 0; i < children.size(); ++i) {
-        QGraphicsItem *item = children.at(i);
-        if (item->d_ptr->transformData && !item->d_ptr->transformData->computedFullTransform().isInvertible())
-            continue;
-
-        // Skip invisible items.
-        if (item->d_ptr->isInvisible())
-            continue;
-
-        bool keep = false;
-        if (!item->d_ptr->isClippedAway()) {
-            // ### _q_adjustedRect is only needed because QRectF::intersects,
-            // QRectF::contains and QTransform::map() and friends don't work with
-            // flat rectangles.
-            const QRectF br(adjustedItemBoundingRect(item));
-            if (mode >= Qt::ContainsItemBoundingRect) {
-                // Polygon contains/intersects item's bounding rect
-                if ((mode == Qt::IntersectsItemBoundingRect && path.intersects(item->mapRectToParent(br)))
-                    || (mode == Qt::ContainsItemBoundingRect && path.contains(item->mapRectToParent(br)))) {
-                    items->append(item);
-                    keep = true;
-                }
-            } else {
-                // Path contains/intersects item's shape
-                if (QRectF_intersects(pathRect, item->mapRectToParent(br))) {
-                    if (itemCollidesWithPath(item, item->mapFromParent(path), mode)) {
-                        items->append(item);
-                        keep = true;
-                    }
-                }
-            }
-        }
-
-        if ((keep || !(item->flags() & QGraphicsItem::ItemClipsChildrenToShape)) && !item->d_ptr->children.isEmpty()) {
-            // Recurse into children that clip children.
-            childItems_helper(items, item, item->mapFromParent(path), mode);
-        }
-    }
-}
-
-void QGraphicsScenePrivate::invalidateSortCache()
-{
-    Q_Q(QGraphicsScene);
-    if (!sortCacheEnabled || updatingSortCache)
-        return;
-
-    updatingSortCache = true;
-    QMetaObject::invokeMethod(q, "_q_updateSortCache", Qt::QueuedConnection);
-}
-
-/*!
-    \internal
-
-    Should not be exported, but we can't change that now.
-    ### Qt 5: Remove symbol / make static
-*/
-inline bool qt_closestLeaf(const QGraphicsItem *item1, const QGraphicsItem *item2)
-{
-    // Return true if sibling item1 is on top of item2.
-    const QGraphicsItemPrivate *d1 = item1->d_ptr;
-    const QGraphicsItemPrivate *d2 = item2->d_ptr;
-    bool f1 = d1->flags & QGraphicsItem::ItemStacksBehindParent;
-    bool f2 = d2->flags & QGraphicsItem::ItemStacksBehindParent;
-    if (f1 != f2) return f2;
-    qreal z1 = d1->z;
-    qreal z2 = d2->z;
-    return z1 > z2;
-}
-
-static inline bool qt_notclosestLeaf(const QGraphicsItem *item1, const QGraphicsItem *item2)
-{
-    return qt_closestLeaf(item2, item1);
-}
-
-/*!
-    \internal
-
-    Should not be exported, but we can't change that now.
-*/
-inline bool qt_closestItemFirst(const QGraphicsItem *item1, const QGraphicsItem *item2)
-{
-    return QGraphicsScenePrivate::closestItemFirst_withoutCache(item1, item2);
-}
-
-/*!
-    Returns true if \a item1 is on top of \a item2.
-
-    \internal
-*/
-bool QGraphicsScenePrivate::closestItemFirst_withoutCache(const QGraphicsItem *item1, const QGraphicsItem *item2)
-{
-    // Siblings? Just check their z-values.
-    const QGraphicsItemPrivate *d1 = item1->d_ptr;
-    const QGraphicsItemPrivate *d2 = item2->d_ptr;
-    if (d1->parent == d2->parent)
-        return qt_closestLeaf(item1, item2);
-
-    // Find common ancestor, and each item's ancestor closest to the common
-    // ancestor.
-    int item1Depth = d1->depth;
-    int item2Depth = d2->depth;
-    const QGraphicsItem *p = item1;
-    const QGraphicsItem *t1 = item1;
-    while (item1Depth > item2Depth && (p = p->d_ptr->parent)) {
-        if (p == item2) {
-            // item2 is one of item1's ancestors; item1 is on top
-            return !(t1->d_ptr->flags & QGraphicsItem::ItemStacksBehindParent);
-        }
-        t1 = p;
-        --item1Depth;
-    }
-    p = item2;
-    const QGraphicsItem *t2 = item2;
-    while (item2Depth > item1Depth && (p = p->d_ptr->parent)) {
-        if (p == item1) {
-            // item1 is one of item2's ancestors; item1 is not on top
-            return (t2->d_ptr->flags & QGraphicsItem::ItemStacksBehindParent);
-        }
-        t2 = p;
-        --item2Depth;
-    }
-
-    // item1Ancestor is now at the same level as item2Ancestor, but not the same.
-    const QGraphicsItem *a1 = t1;
-    const QGraphicsItem *a2 = t2;
-    while (a1) {
-        const QGraphicsItem *p1 = a1;
-        const QGraphicsItem *p2 = a2;
-        a1 = a1->parentItem();
-        a2 = a2->parentItem();
-        if (a1 && a1 == a2)
-            return qt_closestLeaf(p1, p2);
-    }
-
-    // No common ancestor? Then just compare the items' toplevels directly.
-    return qt_closestLeaf(t1->topLevelItem(), t2->topLevelItem());
-}
-
-/*!
-    Returns true if \a item2 is on top of \a item1.
-
-    \internal
-*/
-bool QGraphicsScenePrivate::closestItemLast_withoutCache(const QGraphicsItem *item1, const QGraphicsItem *item2)
-{
-    return closestItemFirst_withoutCache(item2, item1);
-}
-
-void QGraphicsScenePrivate::climbTree(QGraphicsItem *item, int *stackingOrder)
-{
-    if (!item->d_ptr->children.isEmpty()) {
-        QList<QGraphicsItem *> childList = item->d_ptr->children;
-        qSort(childList.begin(), childList.end(), qt_closestLeaf);
-        for (int i = 0; i < childList.size(); ++i) {
-            QGraphicsItem *item = childList.at(i);
-            if (!(item->flags() & QGraphicsItem::ItemStacksBehindParent))
-                climbTree(childList.at(i), stackingOrder);
-        }
-        item->d_ptr->globalStackingOrder = (*stackingOrder)++;
-        for (int i = 0; i < childList.size(); ++i) {
-            QGraphicsItem *item = childList.at(i);
-            if (item->flags() & QGraphicsItem::ItemStacksBehindParent)
-                climbTree(childList.at(i), stackingOrder);
-        }
-    } else {
-        item->d_ptr->globalStackingOrder = (*stackingOrder)++;
-    }
-}
-
-void QGraphicsScenePrivate::_q_updateSortCache()
-{
-    _q_updateIndex();
-
-    if (!sortCacheEnabled || !updatingSortCache)
-        return;
-
-    updatingSortCache = false;
-    int stackingOrder = 0;
-
-    QList<QGraphicsItem *> topLevels;
-
-    for (int i = 0; i < indexedItems.size(); ++i) {
-        QGraphicsItem *item = indexedItems.at(i);
-        if (item && item->parentItem() == 0)
-            topLevels << item;
-    }
-    for (int i = 0; i < unindexedItems.size(); ++i) {
-        QGraphicsItem *item = unindexedItems.at(i);
-        if (item->parentItem() == 0)
-            topLevels << item;
-    }
-
-    qSort(topLevels.begin(), topLevels.end(), qt_closestLeaf);
-    for (int i = 0; i < topLevels.size(); ++i)
-        climbTree(topLevels.at(i), &stackingOrder);
-}
-
-void QGraphicsScenePrivate::sortItems(QList<QGraphicsItem *> *itemList, Qt::SortOrder order,
-                                      bool sortCacheEnabled)
-{
-    if (sortCacheEnabled) {
-        if (order == Qt::AscendingOrder) {
-            qSort(itemList->begin(), itemList->end(), closestItemFirst_withCache);
-        } else if (order == Qt::DescendingOrder) {
-            qSort(itemList->begin(), itemList->end(), closestItemLast_withCache);
-        }
-    } else {
-        if (order == Qt::AscendingOrder) {
-            qSort(itemList->begin(), itemList->end(), closestItemFirst_withoutCache);
-        } else if (order == Qt::DescendingOrder) {
-            qSort(itemList->begin(), itemList->end(), closestItemLast_withoutCache);
-        }
-    }
-}
-
 /*!
     \internal
 
@@ -2333,8 +1229,8 @@ QGraphicsScene::QGraphicsScene(QObject *parent)
 QGraphicsScene::QGraphicsScene(const QRectF &sceneRect, QObject *parent)
     : QObject(*new QGraphicsScenePrivate, parent)
 {
-    setSceneRect(sceneRect);
     d_func()->init();
+    setSceneRect(sceneRect);
 }
 
 /*!
@@ -2348,8 +1244,8 @@ QGraphicsScene::QGraphicsScene(const QRectF &sceneRect, QObject *parent)
 QGraphicsScene::QGraphicsScene(qreal x, qreal y, qreal width, qreal height, QObject *parent)
     : QObject(*new QGraphicsScenePrivate, parent)
 {
-    setSceneRect(x, y, width, height);
     d_func()->init();
+    setSceneRect(x, y, width, height);
 }
 
 /*!
@@ -2386,8 +1282,19 @@ QGraphicsScene::~QGraphicsScene()
 QRectF QGraphicsScene::sceneRect() const
 {
     Q_D(const QGraphicsScene);
-    const_cast<QGraphicsScenePrivate *>(d)->_q_updateIndex();
-    return d->hasSceneRect ? d->sceneRect : d->growingItemsBoundingRect;
+    if (d->hasSceneRect)
+        return d->sceneRect;
+
+    if (d->dirtyGrowingItemsBoundingRect) {
+        // Lazily update the growing items bounding rect
+        QGraphicsScenePrivate *thatd = const_cast<QGraphicsScenePrivate *>(d);
+        QRectF oldGrowingBoundingRect = thatd->growingItemsBoundingRect;
+        thatd->growingItemsBoundingRect |= itemsBoundingRect();
+        thatd->dirtyGrowingItemsBoundingRect = false;
+        if (oldGrowingBoundingRect != thatd->growingItemsBoundingRect)
+            emit const_cast<QGraphicsScene *>(this)->sceneRectChanged(thatd->growingItemsBoundingRect);
+    }
+    return d->growingItemsBoundingRect;
 }
 void QGraphicsScene::setSceneRect(const QRectF &rect)
 {
@@ -2395,8 +1302,7 @@ void QGraphicsScene::setSceneRect(const QRectF &rect)
     if (rect != d->sceneRect) {
         d->hasSceneRect = !rect.isNull();
         d->sceneRect = rect;
-        d->resetIndex();
-        emit sceneRectChanged(rect);
+        emit sceneRectChanged(d->hasSceneRect ? rect : d->growingItemsBoundingRect);
     }
 }
 
@@ -2437,6 +1343,8 @@ void QGraphicsScene::setSceneRect(const QRectF &rect)
 void QGraphicsScene::render(QPainter *painter, const QRectF &target, const QRectF &source,
                             Qt::AspectRatioMode aspectRatioMode)
 {
+    // ### Switch to using the recursive rendering algorithm instead.
+
     // Default source rect = scene rect
     QRectF sourceRect = source;
     if (sourceRect.isNull())
@@ -2531,8 +1439,19 @@ QGraphicsScene::ItemIndexMethod QGraphicsScene::itemIndexMethod() const
 void QGraphicsScene::setItemIndexMethod(ItemIndexMethod method)
 {
     Q_D(QGraphicsScene);
-    d->resetIndex();
+    if (d->indexMethod == method)
+        return;
+
     d->indexMethod = method;
+
+    QList<QGraphicsItem *> oldItems = d->index->items(Qt::AscendingOrder);
+    delete d->index;
+    if (method == BspTreeIndex)
+        d->index = new QGraphicsSceneBspTreeIndex(this);
+    else
+        d->index = new QGraphicsSceneLinearIndex(this);
+    for (int i = oldItems.size() - 1; i >= 0; --i)
+        d->index->addItem(oldItems.at(i));
 }
 
 /*!
@@ -2570,35 +1489,32 @@ void QGraphicsScene::setItemIndexMethod(ItemIndexMethod method)
 int QGraphicsScene::bspTreeDepth() const
 {
     Q_D(const QGraphicsScene);
-    return d->bspTreeDepth;
+    QGraphicsSceneBspTreeIndex *bspTree = qobject_cast<QGraphicsSceneBspTreeIndex *>(d->index);
+    return bspTree ? bspTree->bspTreeDepth() : 0;
 }
 void QGraphicsScene::setBspTreeDepth(int depth)
 {
     Q_D(QGraphicsScene);
-    if (d->bspTreeDepth == depth)
-        return;
-
     if (depth < 0) {
         qWarning("QGraphicsScene::setBspTreeDepth: invalid depth %d ignored; must be >= 0", depth);
         return;
     }
 
-    d->bspTreeDepth = depth;
-    d->resetIndex();
+    QGraphicsSceneBspTreeIndex *bspTree = qobject_cast<QGraphicsSceneBspTreeIndex *>(d->index);
+    if (!bspTree) {
+        qWarning("QGraphicsScene::setBspTreeDepth: can not apply if indexing method is not BSP");
+        return;
+    }
+    bspTree->setBspTreeDepth(depth);
 }
 
 /*!
     \property QGraphicsScene::sortCacheEnabled
     \brief whether sort caching is enabled
     \since 4.5
+    \obsolete
 
-    When enabled, this property adds a cache that speeds up sorting and
-    transformations for scenes with deep hierarchies (i.e., items with many
-    levels of descendents), at the cost of using more memory (approx. 100 more
-    bytes of memory per item).
-
-    Items that are not part of a deep hierarchy suffer no penalty from this
-    cache.
+    Since Qt 4.6, this property has no effect.
 */
 bool QGraphicsScene::isSortCacheEnabled() const
 {
@@ -2608,10 +1524,9 @@ bool QGraphicsScene::isSortCacheEnabled() const
 void QGraphicsScene::setSortCacheEnabled(bool enabled)
 {
     Q_D(QGraphicsScene);
-    if (enabled == d->sortCacheEnabled)
+    if (d->sortCacheEnabled == enabled)
         return;
-    if ((d->sortCacheEnabled = enabled))
-        d->invalidateSortCache();
+    d->sortCacheEnabled = enabled;
 }
 
 /*!
@@ -2623,6 +1538,7 @@ void QGraphicsScene::setSortCacheEnabled(bool enabled)
 */
 QRectF QGraphicsScene::itemsBoundingRect() const
 {
+    // Does not take untransformable items into account.
     QRectF boundingRect;
     foreach (QGraphicsItem *item, items())
         boundingRect |= item->sceneBoundingRect();
@@ -2637,29 +1553,24 @@ QRectF QGraphicsScene::itemsBoundingRect() const
 QList<QGraphicsItem *> QGraphicsScene::items() const
 {
     Q_D(const QGraphicsScene);
-    const_cast<QGraphicsScenePrivate *>(d)->purgeRemovedItems();
+    return d->index->items(Qt::AscendingOrder);
+}
 
-    // If freeItemIndexes is empty, we know there are no holes in indexedItems and
-    // unindexedItems.
-    if (d->freeItemIndexes.isEmpty()) {
-        if (d->unindexedItems.isEmpty())
-            return d->indexedItems;
-        return d->indexedItems + d->unindexedItems;
-    }
+/*!
+    Returns an ordered list of all items on the scene. \a order decides the
+    sorting.
 
-    // Rebuild the list of items to avoid holes. ### We could also just
-    // compress the item lists at this point.
-    QList<QGraphicsItem *> itemList;
-    foreach (QGraphicsItem *item, d->indexedItems + d->unindexedItems) {
-        if (item)
-            itemList << item;
-    }
-    return itemList;
+    \sa addItem(), removeItem()
+*/
+QList<QGraphicsItem *> QGraphicsScene::items(Qt::SortOrder order) const
+{
+    Q_D(const QGraphicsScene);
+    return d->index->items(order);
 }
 
 /*!
     Returns all visible items at position \a pos in the scene. The items are
-    listed in descending Z order (i.e., the first item in the list is the
+    listed in descending stacking order (i.e., the first item in the list is the
     top-most item, and the last item is the bottom-most item).
 
     \sa itemAt()
@@ -2667,7 +1578,7 @@ QList<QGraphicsItem *> QGraphicsScene::items() const
 QList<QGraphicsItem *> QGraphicsScene::items(const QPointF &pos) const
 {
     Q_D(const QGraphicsScene);
-    return d->items_helper(pos);
+    return d->index->items(pos, Qt::IntersectsItemShape, Qt::AscendingOrder);
 }
 
 /*!
@@ -2686,9 +1597,7 @@ QList<QGraphicsItem *> QGraphicsScene::items(const QPointF &pos) const
 QList<QGraphicsItem *> QGraphicsScene::items(const QRectF &rect, Qt::ItemSelectionMode mode) const
 {
     Q_D(const QGraphicsScene);
-    QList<QGraphicsItem *> itemList;
-    d->recursive_items_helper(0, rect, &itemList, QTransform(), QTransform(), mode, Qt::AscendingOrder);
-    return itemList;
+    return d->index->items(rect, mode, Qt::AscendingOrder);
 }
 
 /*!
@@ -2712,7 +1621,7 @@ QList<QGraphicsItem *> QGraphicsScene::items(const QRectF &rect, Qt::ItemSelecti
 QList<QGraphicsItem *> QGraphicsScene::items(const QPolygonF &polygon, Qt::ItemSelectionMode mode) const
 {
     Q_D(const QGraphicsScene);
-    return d->items_helper(polygon, mode, Qt::AscendingOrder);
+    return d->index->items(polygon, mode, Qt::AscendingOrder);
 }
 
 /*!
@@ -2729,7 +1638,85 @@ QList<QGraphicsItem *> QGraphicsScene::items(const QPolygonF &polygon, Qt::ItemS
 QList<QGraphicsItem *> QGraphicsScene::items(const QPainterPath &path, Qt::ItemSelectionMode mode) const
 {
     Q_D(const QGraphicsScene);
-    return d->items_helper(path, mode, Qt::AscendingOrder);
+    return d->index->items(path, mode, Qt::AscendingOrder);
+}
+
+/*!
+    Returns all visible items that, depending on \a mode, are at the specified \a pos
+    and return a list sorted using \a order.
+
+    The default value for \a mode is Qt::IntersectsItemShape; all items whose
+    exact shape intersects with \a pos are returned.
+
+    \a deviceTransform is the transformation apply to the view.
+
+    \sa itemAt()
+*/
+QList<QGraphicsItem *> QGraphicsScene::items(const QPointF &pos, Qt::ItemSelectionMode mode,
+                                             Qt::SortOrder order, const QTransform &deviceTransform) const
+{
+    Q_D(const QGraphicsScene);
+    return d->index->items(pos, mode, order, deviceTransform);
+}
+
+/*!
+    \overload
+
+    Returns all visible items that, depending on \a mode, are either inside or
+    intersect with the specified \a rect and return a list sorted using \a order.
+
+    The default value for \a mode is Qt::IntersectsItemShape; all items whose
+    exact shape intersects with or is contained by \a rect are returned.
+
+    \a deviceTransform is the transformation apply to the view.
+
+    \sa itemAt()
+*/
+QList<QGraphicsItem *> QGraphicsScene::items(const QRectF &rect, Qt::ItemSelectionMode mode,
+                                             Qt::SortOrder order, const QTransform &deviceTransform) const
+{
+    Q_D(const QGraphicsScene);
+    return d->index->items(rect, mode, order, deviceTransform);
+}
+
+/*!
+    \overload
+
+    Returns all visible items that, depending on \a mode, are either inside or
+    intersect with the specified \a polygon and return a list sorted using \a order.
+
+    The default value for \a mode is Qt::IntersectsItemShape; all items whose
+    exact shape intersects with or is contained by \a polygon are returned.
+
+    \a deviceTransform is the transformation apply to the view.
+
+    \sa itemAt()
+*/
+QList<QGraphicsItem *> QGraphicsScene::items(const QPolygonF &polygon, Qt::ItemSelectionMode mode,
+                                             Qt::SortOrder order, const QTransform &deviceTransform) const
+{
+    Q_D(const QGraphicsScene);
+    return d->index->items(polygon, mode, order, deviceTransform);
+}
+
+/*!
+   \overload
+
+    Returns all visible items that, depending on \a mode, are either inside or
+    intersect with the specified \a path and return a list sorted using \a order.
+
+    The default value for \a mode is Qt::IntersectsItemShape; all items whose
+    exact shape intersects with or is contained by \a path are returned.
+
+    \a deviceTransform is the transformation apply to the view.
+
+    \sa itemAt()
+*/
+QList<QGraphicsItem *> QGraphicsScene::items(const QPainterPath &path, Qt::ItemSelectionMode mode,
+                                             Qt::SortOrder order, const QTransform &deviceTransform) const
+{
+    Q_D(const QGraphicsScene);
+    return d->index->items(path, mode, order, deviceTransform);
 }
 
 /*!
@@ -2752,12 +1739,12 @@ QList<QGraphicsItem *> QGraphicsScene::collidingItems(const QGraphicsItem *item,
         return QList<QGraphicsItem *>();
     }
 
+    // Does not support ItemIgnoresTransformations.
     QList<QGraphicsItem *> tmp;
-    foreach (QGraphicsItem *itemInVicinity, d->estimateItemsInRect(item->sceneBoundingRect())) {
+    foreach (QGraphicsItem *itemInVicinity, d->index->estimateItems(item->sceneBoundingRect(), Qt::AscendingOrder)) {
         if (item != itemInVicinity && item->collidesWithItem(itemInVicinity, mode))
             tmp << itemInVicinity;
     }
-    d->sortItems(&tmp, Qt::AscendingOrder, d->sortCacheEnabled);
     return tmp;
 }
 
@@ -2777,6 +1764,13 @@ QGraphicsItem *QGraphicsScene::itemAt(const QPointF &pos) const
     return itemsAtPoint.isEmpty() ? 0 : itemsAtPoint.first();
 }
 
+QGraphicsItem *QGraphicsScene::itemAt(const QPointF &pos, const QTransform &deviceTransform) const
+{
+    QList<QGraphicsItem *> itemsAtPoint = items(pos, Qt::IntersectsItemShape,
+                                                Qt::AscendingOrder, deviceTransform);
+    return itemsAtPoint.isEmpty() ? 0 : itemsAtPoint.first();
+}
+
 /*!
     \fn QGraphicsScene::itemAt(qreal x, qreal y) const
     \overload
@@ -2852,6 +1846,21 @@ void QGraphicsScene::setSelectionArea(const QPainterPath &path)
 */
 void QGraphicsScene::setSelectionArea(const QPainterPath &path, Qt::ItemSelectionMode mode)
 {
+    setSelectionArea(path, mode, QTransform());
+}
+
+/*!
+    \overload
+    \since 4.3
+
+    Sets the selection area to \a path using \a mode to determine if items are
+    included in the selection area.
+
+    \sa clearSelection(), selectionArea()
+*/
+void QGraphicsScene::setSelectionArea(const QPainterPath &path, Qt::ItemSelectionMode mode,
+                                      const QTransform &deviceTransform)
+{
     Q_D(QGraphicsScene);
 
     // Note: with boolean path operations, we can improve performance here
@@ -2867,7 +1876,7 @@ void QGraphicsScene::setSelectionArea(const QPainterPath &path, Qt::ItemSelectio
     bool changed = false;
 
     // Set all items in path to selected.
-    foreach (QGraphicsItem *item, items(path, mode)) {
+    foreach (QGraphicsItem *item, items(path, mode, Qt::AscendingOrder, deviceTransform)) {
         if (item->flags() & QGraphicsItem::ItemIsSelectable) {
             if (!item->isSelected())
                 changed = true;
@@ -2924,26 +1933,13 @@ void QGraphicsScene::clearSelection()
 void QGraphicsScene::clear()
 {
     Q_D(QGraphicsScene);
-    // Recursive descent delete
-    for (int i = 0; i < d->indexedItems.size(); ++i) {
-        if (QGraphicsItem *item = d->indexedItems.at(i)) {
-            if (!item->parentItem())
-                delete item;
-        }
-    }
-    QList<QGraphicsItem *> unindexedParents;
-    for (int i = 0; i < d->unindexedItems.size(); ++i) {
-        QGraphicsItem *item = d->unindexedItems.at(i);
-        if (!item->parentItem())
-            unindexedParents << item;
-    }
-    d->unindexedItems.clear();
-    qDeleteAll(unindexedParents);
-    d->indexedItems.clear();
-    d->freeItemIndexes.clear();
+    // NB! We have to clear the index before deleting items; otherwise the
+    // index might try to access dangling item pointers.
+    d->index->clear();
+    const QList<QGraphicsItem *> items = d->topLevelItems;
+    qDeleteAll(items);
+    Q_ASSERT(d->topLevelItems.isEmpty());
     d->lastItemCount = 0;
-    d->bspTree.clear();
-    d->largestUntransformableItem = QRectF();
     d->allItemsIgnoreHoverEvents = true;
     d->allItemsUseDefaultCursor = true;
     d->allItemsIgnoreTouchEvents = true;
@@ -3065,14 +2061,6 @@ void QGraphicsScene::addItem(QGraphicsItem *item)
         return;
     }
 
-    // Prevent reusing a recently deleted pointer: purge all removed items
-    // from our lists.
-    d->purgeRemovedItems();
-
-    // Invalidate any sort caching; arrival of a new item means we need to
-    // resort.
-    d->invalidateSortCache();
-
     // Detach this item from its parent if the parent's scene is different
     // from this scene.
     if (QGraphicsItem *itemParent = item->parentItem()) {
@@ -3083,29 +2071,18 @@ void QGraphicsScene::addItem(QGraphicsItem *item)
     // Add the item to this scene
     item->d_func()->scene = targetScene;
 
-    // Indexing requires sceneBoundingRect(), but because \a item might
-    // not be completely constructed at this point, we need to store it in
-    // a temporary list and schedule an indexing for later.
-    d->unindexedItems << item;
-    item->d_func()->index = -1;
-    d->startIndexTimer(0);
+    // Add the item in the index
+    d->index->addItem(item);
 
     // Add to list of toplevels if this item is a toplevel.
     if (!item->d_ptr->parent)
         d->registerTopLevelItem(item);
 
-    // Update the scene's sort cache settings.
-    item->d_ptr->globalStackingOrder = -1;
-    d->invalidateSortCache();
-
     // Add to list of items that require an update. We cannot assume that the
     // item is fully constructed, so calling item->update() can lead to a pure
     // virtual function call to boundingRect().
-    if (!d->updateAll) {
-        if (d->pendingUpdateItems.isEmpty())
-            QMetaObject::invokeMethod(this, "_q_updateLater", Qt::QueuedConnection);
-        d->pendingUpdateItems << item;
-    }
+    d->markDirty(item);
+    d->dirtyGrowingItemsBoundingRect = true;
 
     // Disable selectionChanged() for individual items
     ++d->selectionChanging;
@@ -4039,16 +3016,6 @@ bool QGraphicsScene::event(QEvent *event)
     case QEvent::TouchEnd:
         d->touchEventHandler(static_cast<QTouchEvent *>(event));
         break;
-    case QEvent::Timer:
-        if (d->indexTimerId && static_cast<QTimerEvent *>(event)->timerId() == d->indexTimerId) {
-            if (d->restartIndexTimer) {
-                d->restartIndexTimer = false;
-            } else {
-                // this call will kill the timer
-                d->_q_updateIndex();
-            }
-        }
-        // Fallthrough intended - support timers in subclasses.
     default:
         return QObject::event(event);
     }
@@ -5137,6 +4104,20 @@ void QGraphicsScenePrivate::drawItemHelper(QGraphicsItem *item, QPainter *painte
     }
 }
 
+void QGraphicsScenePrivate::drawItems(QPainter *painter, const QTransform *const viewTransform,
+                                      QRegion *exposedRegion, QWidget *widget)
+{
+    QRectF exposedSceneRect;
+    if (exposedRegion && indexMethod != QGraphicsScene::NoIndex) {
+        exposedSceneRect = exposedRegion->boundingRect().adjusted(-1, -1, 1, 1);
+        if (viewTransform)
+            exposedSceneRect = viewTransform->inverted().mapRect(exposedSceneRect);
+    }
+    const QList<QGraphicsItem *> tli = index->estimateTopLevelItems(exposedSceneRect, Qt::DescendingOrder);
+    for (int i = 0; i < tli.size(); ++i)
+        drawSubtreeRecursive(tli.at(i), painter, viewTransform, exposedRegion, widget);
+}
+
 void QGraphicsScenePrivate::drawSubtreeRecursive(QGraphicsItem *item, QPainter *painter,
                                                  const QTransform *const viewTransform,
                                                  QRegion *exposedRegion, QWidget *widget,
@@ -5159,6 +4140,7 @@ void QGraphicsScenePrivate::drawSubtreeRecursive(QGraphicsItem *item, QPainter *
 
     QTransform transform(Qt::Uninitialized);
     QTransform *transformPtr = 0;
+    bool translateOnlyTransform = false;
 #define ENSURE_TRANSFORM_PTR \
     if (!transformPtr) { \
         Q_ASSERT(!itemIsUntransformable); \
@@ -5168,6 +4150,7 @@ void QGraphicsScenePrivate::drawSubtreeRecursive(QGraphicsItem *item, QPainter *
             transformPtr = &transform; \
         } else { \
             transformPtr = &item->d_ptr->sceneTransform; \
+            translateOnlyTransform = item->d_ptr->sceneTransformTranslateOnly; \
         } \
     }
 
@@ -5179,10 +4162,8 @@ void QGraphicsScenePrivate::drawSubtreeRecursive(QGraphicsItem *item, QPainter *
         transform = item->deviceTransform(viewTransform ? *viewTransform : QTransform());
         transformPtr = &transform;
     } else if (item->d_ptr->dirtySceneTransform) {
-        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;
+        item->d_ptr->updateSceneTransformFromParent();
+        Q_ASSERT(!item->d_ptr->dirtySceneTransform);
         wasDirtyParentSceneTransform = true;
     }
 
@@ -5191,7 +4172,8 @@ void QGraphicsScenePrivate::drawSubtreeRecursive(QGraphicsItem *item, QPainter *
     if (drawItem) {
         const QRectF brect = adjustedItemBoundingRect(item);
         ENSURE_TRANSFORM_PTR
-        QRect viewBoundingRect = transformPtr->mapRect(brect).toRect();
+        QRect viewBoundingRect = translateOnlyTransform ? brect.translated(transformPtr->dx(), transformPtr->dy()).toRect()
+                                                        : transformPtr->mapRect(brect).toRect();
         item->d_ptr->paintedViewBoundingRects.insert(widget, viewBoundingRect);
         viewBoundingRect.adjust(-1, -1, 1, 1);
         drawItem = exposedRegion ? exposedRegion->intersects(viewBoundingRect) : !viewBoundingRect.isEmpty();
@@ -5208,10 +4190,7 @@ void QGraphicsScenePrivate::drawSubtreeRecursive(QGraphicsItem *item, QPainter *
 
     int i = 0;
     if (itemHasChildren) {
-        if (item->d_ptr->needSortChildren) {
-            item->d_ptr->needSortChildren = 0;
-            qStableSort(item->d_ptr->children.begin(), item->d_ptr->children.end(), qt_notclosestLeaf);
-        }
+        item->d_ptr->ensureSortedChildren();
 
         if (itemClipsChildrenToShape) {
             painter->save();
@@ -5237,7 +4216,8 @@ void QGraphicsScenePrivate::drawSubtreeRecursive(QGraphicsItem *item, QPainter *
     if (drawItem) {
         Q_ASSERT(!itemIsFullyTransparent);
         Q_ASSERT(itemHasContents);
-        item->d_ptr->initStyleOption(&styleOptionTmp, transform, exposedRegion
+        ENSURE_TRANSFORM_PTR
+        item->d_ptr->initStyleOption(&styleOptionTmp, *transformPtr, exposedRegion
                                      ? *exposedRegion : QRegion(), exposedRegion == 0);
 
         const bool itemClipsToShape = item->d_ptr->flags & QGraphicsItem::ItemClipsToShape;
@@ -5245,10 +4225,9 @@ void QGraphicsScenePrivate::drawSubtreeRecursive(QGraphicsItem *item, QPainter *
         if (savePainter)
             painter->save();
 
-        if (!itemHasChildren || !itemClipsChildrenToShape) {
-            ENSURE_TRANSFORM_PTR
+        if (!itemHasChildren || !itemClipsChildrenToShape)
             painter->setWorldTransform(*transformPtr);
-        }
+
         if (itemClipsToShape)
             painter->setClipPath(item->shape(), Qt::IntersectClip);
         painter->setOpacity(opacity);
@@ -5291,6 +4270,16 @@ void QGraphicsScenePrivate::markDirty(QGraphicsItem *item, const QRectF &rect, b
                                           /*ignoreVisibleBit=*/force,
                                           /*ignoreDirtyBit=*/removingItemFromScene || invalidateChildren,
                                           /*ignoreOpacity=*/ignoreOpacity)) {
+        if (item->d_ptr->dirty) {
+            // The item is already marked as dirty and will be processed later. However,
+            // we have to make sure ignoreVisible and ignoreOpacity are set properly;
+            // otherwise things like: item->update(); item->hide() (force is now true)
+            // won't work as expected.
+            if (force)
+                item->d_ptr->ignoreVisible = 1;
+            if (ignoreOpacity)
+                item->d_ptr->ignoreOpacity = 1;
+        }
         return;
     }
 
@@ -5350,65 +4339,121 @@ void QGraphicsScenePrivate::markDirty(QGraphicsItem *item, const QRectF &rect, b
 }
 
 static inline bool updateHelper(QGraphicsViewPrivate *view, QGraphicsItemPrivate *item,
-                                const QRectF &rect, const QTransform &xform)
+                                const QRectF &rect, bool itemIsUntransformable)
 {
     Q_ASSERT(view);
     Q_ASSERT(item);
-    if (item->hasBoundingRegionGranularity)
+
+    QGraphicsItem *itemq = static_cast<QGraphicsItem *>(item->q_ptr);
+    QGraphicsView *viewq = static_cast<QGraphicsView *>(view->q_ptr);
+
+    if (itemIsUntransformable) {
+        const QTransform xform = itemq->deviceTransform(viewq->viewportTransform());
+        if (!item->hasBoundingRegionGranularity)
+            return view->updateRect(xform.mapRect(rect).toRect());
         return view->updateRegion(xform.map(QRegion(rect.toRect())));
-    return view->updateRect(xform.mapRect(rect).toRect());
+    }
+
+    if (item->sceneTransformTranslateOnly && view->identityMatrix) {
+        const qreal dx = item->sceneTransform.dx();
+        const qreal dy = item->sceneTransform.dy();
+        if (!item->hasBoundingRegionGranularity) {
+            QRectF r(rect);
+            r.translate(dx - view->horizontalScroll(), dy - view->verticalScroll());
+            return view->updateRect(r.toRect());
+        }
+        QRegion r(rect.toRect());
+        r.translate(qRound(dx) - view->horizontalScroll(), qRound(dy) - view->verticalScroll());
+        return view->updateRegion(r);
+    }
+
+    if (!viewq->isTransformed()) {
+        if (!item->hasBoundingRegionGranularity)
+            return view->updateRect(item->sceneTransform.mapRect(rect).toRect());
+        return view->updateRegion(item->sceneTransform.map(QRegion(rect.toRect())));
+    }
+
+    QTransform xform = item->sceneTransform;
+    xform *= viewq->viewportTransform();
+    if (!item->hasBoundingRegionGranularity)
+        return view->updateRect(xform.mapRect(rect).toRect());
+    return view->updateRegion(xform.map(QRegion(rect.toRect())));
 }
 
 void QGraphicsScenePrivate::processDirtyItemsRecursive(QGraphicsItem *item, bool dirtyAncestorContainsChildren,
                                                        qreal parentOpacity)
 {
     Q_Q(QGraphicsScene);
+    Q_ASSERT(item);
+    Q_ASSERT(!updateAll);
 
-    bool wasDirtyParentViewBoundingRects = false;
-    bool wasDirtyParentSceneTransform = false;
-    qreal opacity = parentOpacity;
+    if (!item->d_ptr->dirty && !item->d_ptr->dirtyChildren) {
+        resetDirtyItem(item);
+        return;
+    }
 
-    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;
-        }
+    const bool itemIsHidden = !item->d_ptr->ignoreVisible && !item->d_ptr->visible;
+    if (itemIsHidden) {
+        resetDirtyItem(item, /*recursive=*/true);
+        return;
+    }
+
+    const bool itemHasContents = !(item->d_ptr->flags & QGraphicsItem::ItemHasNoContents);
+    const bool itemHasChildren = !item->d_ptr->children.isEmpty();
+    if (!itemHasContents && !itemHasChildren) {
+        resetDirtyItem(item);
+        return; // Item has neither contents nor children!(?)
+    }
+
+    const qreal opacity = item->d_ptr->combineOpacityFromParent(parentOpacity);
+    const bool itemIsFullyTransparent = !item->d_ptr->ignoreOpacity && opacity < 0.0001;
+    if (itemIsFullyTransparent && (!itemHasChildren || item->d_ptr->childrenCombineOpacity())) {
+        resetDirtyItem(item, /*recursive=*/itemHasChildren);
+        return;
+    }
 
-        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;
+    bool wasDirtyParentSceneTransform = item->d_ptr->dirtySceneTransform;
+    const bool itemIsUntransformable = item->d_ptr->itemIsUntransformable();
+    if (wasDirtyParentSceneTransform && !itemIsUntransformable) {
+        item->d_ptr->updateSceneTransformFromParent();
+        Q_ASSERT(!item->d_ptr->dirtySceneTransform);
+    }
+
+    const bool wasDirtyParentViewBoundingRects = item->d_ptr->paintedViewBoundingRectsNeedRepaint;
+    if (itemIsFullyTransparent || !itemHasContents || dirtyAncestorContainsChildren) {
+        // Make sure we don't process invisible items or items with no content.
+        item->d_ptr->dirty = 0;
+        item->d_ptr->fullUpdatePending = 0;
+        // Might have a dirty view bounding rect otherwise.
+        if (itemIsFullyTransparent || !itemHasContents)
             item->d_ptr->paintedViewBoundingRectsNeedRepaint = 0;
+    }
+
+    if (!hasSceneRect && item->d_ptr->geometryChanged && item->d_ptr->visible) {
+        // Update growingItemsBoundingRect.
+        if (item->d_ptr->sceneTransformTranslateOnly) {
+            growingItemsBoundingRect |= item->boundingRect().translated(item->d_ptr->sceneTransform.dx(),
+                                                                        item->d_ptr->sceneTransform.dy());
+        } else {
+            growingItemsBoundingRect |= item->d_ptr->sceneTransform.mapRect(item->boundingRect());
         }
     }
 
     // Process item.
-    if (item && (item->d_ptr->dirty || item->d_ptr->paintedViewBoundingRectsNeedRepaint)) {
+    if (item->d_ptr->dirty || item->d_ptr->paintedViewBoundingRectsNeedRepaint) {
         const bool useCompatUpdate = views.isEmpty() || (connectedSignals[0] & changedSignalMask);
-        const bool untransformableItem = item->d_ptr->itemIsUntransformable();
         const QRectF itemBoundingRect = adjustedItemBoundingRect(item);
 
-        if (item->d_ptr->geometryChanged) {
-            // Update growingItemsBoundingRect.
-            if (!hasSceneRect)
-                growingItemsBoundingRect |= item->d_ptr->sceneTransform.mapRect(itemBoundingRect);
-            item->d_ptr->geometryChanged = 0;
-        }
-
-        if (useCompatUpdate && !untransformableItem && qFuzzyIsNull(item->boundingRegionGranularity())) {
+        if (useCompatUpdate && !itemIsUntransformable && qFuzzyIsNull(item->boundingRegionGranularity())) {
             // This block of code is kept for compatibility. Since 4.5, by default
             // QGraphicsView does not connect the signal and we use the below
             // method of delivering updates.
-            q->update(item->d_ptr->sceneTransform.mapRect(itemBoundingRect));
+            if (item->d_ptr->sceneTransformTranslateOnly) {
+                q->update(itemBoundingRect.translated(item->d_ptr->sceneTransform.dx(),
+                                                      item->d_ptr->sceneTransform.dy()));
+            } else {
+                q->update(item->d_ptr->sceneTransform.mapRect(itemBoundingRect));
+            }
         } else {
             QRectF dirtyRect;
             bool uninitializedDirtyRect = true;
@@ -5416,30 +4461,31 @@ void QGraphicsScenePrivate::processDirtyItemsRecursive(QGraphicsItem *item, bool
             for (int j = 0; j < views.size(); ++j) {
                 QGraphicsView *view = views.at(j);
                 QGraphicsViewPrivate *viewPrivate = view->d_func();
-                if (viewPrivate->fullUpdatePending)
-                    continue;
-                switch (viewPrivate->viewportUpdateMode) {
-                case QGraphicsView::NoViewportUpdate:
-                    continue;
-                case QGraphicsView::FullViewportUpdate:
-                    view->viewport()->update();
-                    viewPrivate->fullUpdatePending = 1;
+                QRect &paintedViewBoundingRect = item->d_ptr->paintedViewBoundingRects[viewPrivate->viewport];
+                if (viewPrivate->fullUpdatePending
+                    || viewPrivate->viewportUpdateMode == QGraphicsView::NoViewportUpdate) {
+                    // Okay, if we have a full update pending or no viewport update, this item's
+                    // paintedViewBoundingRect  will be updated correctly in the next paintEvent if
+                    // it is inside the viewport, but for now we can pretend that it is outside.
+                    paintedViewBoundingRect = QRect(-1, -1, -1, -1);
                     continue;
-                default:
-                    break;
                 }
 
-                QRect &paintedViewBoundingRect = item->d_ptr->paintedViewBoundingRects[viewPrivate->viewport];
-                if (item->d_ptr->paintedViewBoundingRectsNeedRepaint) {
-                    wasDirtyParentViewBoundingRects = true;
+                if (item->d_ptr->paintedViewBoundingRectsNeedRepaint && !paintedViewBoundingRect.isEmpty()) {
                     paintedViewBoundingRect.translate(viewPrivate->dirtyScrollOffset);
                     if (!viewPrivate->updateRect(paintedViewBoundingRect))
-                        paintedViewBoundingRect = QRect();
+                        paintedViewBoundingRect = QRect(-1, -1, -1, -1); // Outside viewport.
                 }
 
                 if (!item->d_ptr->dirty)
                     continue;
 
+                if (!item->d_ptr->paintedViewBoundingRectsNeedRepaint
+                    && paintedViewBoundingRect.x() == -1 && paintedViewBoundingRect.y() == -1
+                    && paintedViewBoundingRect.width() == -1 && paintedViewBoundingRect.height() == -1) {
+                    continue; // Outside viewport.
+                }
+
                 if (uninitializedDirtyRect) {
                     dirtyRect = itemBoundingRect;
                     if (!item->d_ptr->fullUpdatePending) {
@@ -5452,35 +4498,25 @@ void QGraphicsScenePrivate::processDirtyItemsRecursive(QGraphicsItem *item, bool
                 if (dirtyRect.isEmpty())
                     continue; // Discard updates outside the bounding rect.
 
-                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 (!updateHelper(viewPrivate, item->d_ptr, dirtyRect, itemIsUntransformable)
+                    && item->d_ptr->paintedViewBoundingRectsNeedRepaint) {
+                    paintedViewBoundingRect = QRect(-1, -1, -1, -1); // Outside viewport.
                 }
-                if (!valid)
-                    paintedViewBoundingRect = QRect();
             }
         }
     }
 
-    // Process root items / children.
-    if (!item || item->d_ptr->dirtyChildren) {
-        QList<QGraphicsItem *> *children = item ? &item->d_ptr->children : &topLevelItems;
-        const bool allChildrenDirty = item && item->d_ptr->allChildrenDirty;
+    // Process children.
+    if (itemHasChildren && item->d_ptr->dirtyChildren) {
         if (!dirtyAncestorContainsChildren) {
-            dirtyAncestorContainsChildren = item && item->d_ptr->fullUpdatePending
+            dirtyAncestorContainsChildren = 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);
+        const bool allChildrenDirty = item->d_ptr->allChildrenDirty;
+        const bool parentIgnoresVisible = item->d_ptr->ignoreVisible;
+        const bool parentIgnoresOpacity = item->d_ptr->ignoreOpacity;
+        for (int i = 0; i < item->d_ptr->children.size(); ++i) {
+            QGraphicsItem *child = item->d_ptr->children.at(i);
             if (wasDirtyParentSceneTransform)
                 child->d_ptr->dirtySceneTransform = 1;
             if (wasDirtyParentViewBoundingRects)
@@ -5489,36 +4525,19 @@ void QGraphicsScenePrivate::processDirtyItemsRecursive(QGraphicsItem *item, bool
                 child->d_ptr->ignoreVisible = 1;
             if (parentIgnoresOpacity)
                 child->d_ptr->ignoreOpacity = 1;
-
             if (allChildrenDirty) {
                 child->d_ptr->dirty = 1;
                 child->d_ptr->fullUpdatePending = 1;
                 child->d_ptr->dirtyChildren = 1;
                 child->d_ptr->allChildrenDirty = 1;
-            } else if (!child->d_ptr->dirty && !child->d_ptr->dirtyChildren) {
-                resetDirtyItem(child);
-                continue;
-            }
-
-            if (dirtyAncestorContainsChildren || updateAll) {
-                // No need to process this child's dirty rect, hence reset the dirty state.
-                // However, we have to continue the recursion because it might have a dirty
-                // view bounding rect that needs repaint. We also have to reset the dirty
-                // state of its descendants.
-                child->d_ptr->dirty = 0;
-                child->d_ptr->fullUpdatePending = 0;
-                if (updateAll)
-                    child->d_ptr->paintedViewBoundingRectsNeedRepaint = 0;
             }
-
             processDirtyItemsRecursive(child, dirtyAncestorContainsChildren, opacity);
         }
     } else if (wasDirtyParentSceneTransform) {
         item->d_ptr->invalidateChildrenSceneTransform();
     }
 
-    if (item)
-        resetDirtyItem(item);
+    resetDirtyItem(item);
 }
 
 /*!
diff --git a/src/gui/graphicsview/qgraphicsscene.h b/src/gui/graphicsview/qgraphicsscene.h
index 6aaeb91..d790f90 100644
--- a/src/gui/graphicsview/qgraphicsscene.h
+++ b/src/gui/graphicsview/qgraphicsscene.h
@@ -83,6 +83,7 @@ class QGraphicsSimpleTextItem;
 class QGraphicsTextItem;
 class QGraphicsView;
 class QGraphicsWidget;
+class QGraphicsSceneIndex;
 class QHelpEvent;
 class QInputMethodEvent;
 class QKeyEvent;
@@ -152,22 +153,38 @@ public:
     QRectF itemsBoundingRect() const;
 
     QList<QGraphicsItem *> items() const;
-    QList<QGraphicsItem *> items(const QPointF &pos) const;
-    QList<QGraphicsItem *> items(const QRectF &rect, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const;
-    QList<QGraphicsItem *> items(const QPolygonF &polygon, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const;
-    QList<QGraphicsItem *> items(const QPainterPath &path, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const;
+    QList<QGraphicsItem *> items(Qt::SortOrder order) const; // ### Qt 5: unify
+
+    QList<QGraphicsItem *> items(const QPointF &pos, Qt::ItemSelectionMode mode, Qt::SortOrder order, const QTransform &deviceTransform = QTransform()) const;
+    QList<QGraphicsItem *> items(const QRectF &rect, Qt::ItemSelectionMode mode, Qt::SortOrder order, const QTransform &deviceTransform = QTransform()) const;
+    QList<QGraphicsItem *> items(const QPolygonF &polygon, Qt::ItemSelectionMode mode, Qt::SortOrder order, const QTransform &deviceTransform = QTransform()) const;
+    QList<QGraphicsItem *> items(const QPainterPath &path, Qt::ItemSelectionMode mode, Qt::SortOrder order, const QTransform &deviceTransform = QTransform()) const;
+
+    QList<QGraphicsItem *> items(const QPointF &pos) const; // ### obsolete
+    QList<QGraphicsItem *> items(const QRectF &rect, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const; // ### obsolete
+    QList<QGraphicsItem *> items(const QPolygonF &polygon, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const; // ### obsolete
+    QList<QGraphicsItem *> items(const QPainterPath &path, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const; // ### obsolete
+
     QList<QGraphicsItem *> collidingItems(const QGraphicsItem *item, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const;
-    QGraphicsItem *itemAt(const QPointF &pos) const;
+
+    QGraphicsItem *itemAt(const QPointF &pos) const; // ### obsolete
+    QGraphicsItem *itemAt(const QPointF &pos, const QTransform &deviceTransform) const;
 
     inline QList<QGraphicsItem *> items(qreal x, qreal y, qreal w, qreal h, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const
-    { return items(QRectF(x, y, w, h), mode); }
-    inline QGraphicsItem *itemAt(qreal x, qreal y) const
+    { return items(QRectF(x, y, w, h), mode); } // ### obsolete
+    inline QList<QGraphicsItem *> items(qreal x, qreal y, qreal w, qreal h, Qt::ItemSelectionMode mode, Qt::SortOrder order,
+                                        const QTransform &deviceTransform = QTransform()) const
+    { return items(QRectF(x, y, w, h), mode, order, deviceTransform); }
+    inline QGraphicsItem *itemAt(qreal x, qreal y) const // ### obsolete
     { return itemAt(QPointF(x, y)); }
+    inline QGraphicsItem *itemAt(qreal x, qreal y, const QTransform &deviceTransform) const
+    { return itemAt(QPointF(x, y), deviceTransform); }
 
     QList<QGraphicsItem *> selectedItems() const;
     QPainterPath selectionArea() const;
     void setSelectionArea(const QPainterPath &path);
-    void setSelectionArea(const QPainterPath &path, Qt::ItemSelectionMode);
+    void setSelectionArea(const QPainterPath &path, Qt::ItemSelectionMode mode);
+    void setSelectionArea(const QPainterPath &path, Qt::ItemSelectionMode mode, const QTransform &deviceTransform);
 
     QGraphicsItemGroup *createItemGroup(const QList<QGraphicsItem *> &items);
     void destroyItemGroup(QGraphicsItemGroup *group);
@@ -275,11 +292,8 @@ Q_SIGNALS:
 private:
     Q_DECLARE_PRIVATE(QGraphicsScene)
     Q_DISABLE_COPY(QGraphicsScene)
-    Q_PRIVATE_SLOT(d_func(), void _q_updateIndex())
     Q_PRIVATE_SLOT(d_func(), void _q_emitUpdated())
-    Q_PRIVATE_SLOT(d_func(), void _q_updateLater())
     Q_PRIVATE_SLOT(d_func(), void _q_polishItems())
-    Q_PRIVATE_SLOT(d_func(), void _q_updateSortCache())
     Q_PRIVATE_SLOT(d_func(), void _q_processDirtyItems())
     friend class QGraphicsItem;
     friend class QGraphicsItemPrivate;
@@ -287,6 +301,10 @@ private:
     friend class QGraphicsViewPrivate;
     friend class QGraphicsWidget;
     friend class QGraphicsWidgetPrivate;
+    friend class QGraphicsSceneIndex;
+    friend class QGraphicsSceneIndexPrivate;
+    friend class QGraphicsSceneBspTreeIndex;
+    friend class QGraphicsSceneBspTreeIndexPrivate;
 };
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(QGraphicsScene::SceneLayers)
diff --git a/src/gui/graphicsview/qgraphicsscene_bsp.cpp b/src/gui/graphicsview/qgraphicsscene_bsp.cpp
index 3f3e58b..fb4b9a4 100644
--- a/src/gui/graphicsview/qgraphicsscene_bsp.cpp
+++ b/src/gui/graphicsview/qgraphicsscene_bsp.cpp
@@ -70,12 +70,15 @@ class QGraphicsSceneFindItemBspTreeVisitor : public QGraphicsSceneBspTreeVisitor
 {
 public:
     QList<QGraphicsItem *> *foundItems;
+    bool onlyTopLevelItems;
 
     void visit(QList<QGraphicsItem *> *items)
     {
         for (int i = 0; i < items->size(); ++i) {
             QGraphicsItem *item = items->at(i);
-            if (!item->d_func()->itemDiscovered && item->isVisible()) {
+            if (onlyTopLevelItems && item->d_ptr->parent)
+                item = item->topLevelItem();
+            if (!item->d_func()->itemDiscovered && item->d_ptr->visible) {
                 item->d_func()->itemDiscovered = 1;
                 foundItems->prepend(item);
             }
@@ -143,19 +146,15 @@ void QGraphicsSceneBspTree::removeItems(const QSet<QGraphicsItem *> &items)
     }
 }
 
-QList<QGraphicsItem *> QGraphicsSceneBspTree::items(const QRectF &rect)
+QList<QGraphicsItem *> QGraphicsSceneBspTree::items(const QRectF &rect, bool onlyTopLevelItems) const
 {
     QList<QGraphicsItem *> tmp;
     findVisitor->foundItems = &tmp;
+    findVisitor->onlyTopLevelItems = onlyTopLevelItems;
     climbTree(findVisitor, rect);
-    return tmp;
-}
-
-QList<QGraphicsItem *> QGraphicsSceneBspTree::items(const QPointF &pos)
-{
-    QList<QGraphicsItem *> tmp;
-    findVisitor->foundItems = &tmp;
-    climbTree(findVisitor, pos);
+    // Reset discovery bits.
+    for (int i = 0; i < tmp.size(); ++i)
+        tmp.at(i)->d_ptr->itemDiscovered = 0;
     return tmp;
 }
 
@@ -235,47 +234,17 @@ void QGraphicsSceneBspTree::initialize(const QRectF &rect, int depth, int index)
     }
 }
 
-void QGraphicsSceneBspTree::climbTree(QGraphicsSceneBspTreeVisitor *visitor, const QPointF &pos, int index)
-{
-    if (nodes.isEmpty())
-        return;
-
-    const Node &node = nodes.at(index);
-    int childIndex = firstChildIndex(index);
-
-    switch (node.type) {
-    case Node::Leaf: {
-        visitor->visit(&leaves[node.leafIndex]);
-        break;
-    }
-    case Node::Vertical:
-        if (pos.x() < node.offset) {
-            climbTree(visitor, pos, childIndex);
-        } else {
-            climbTree(visitor, pos, childIndex + 1);
-        }
-        break;
-    case Node::Horizontal:
-        if (pos.y() < node.offset) {
-            climbTree(visitor, pos, childIndex);
-        } else {
-            climbTree(visitor, pos, childIndex + 1);
-        }
-        break;
-    }
-}
-
-void QGraphicsSceneBspTree::climbTree(QGraphicsSceneBspTreeVisitor *visitor, const QRectF &rect, int index)
+void QGraphicsSceneBspTree::climbTree(QGraphicsSceneBspTreeVisitor *visitor, const QRectF &rect, int index) const
 {
     if (nodes.isEmpty())
         return;
 
     const Node &node = nodes.at(index);
-    int childIndex = firstChildIndex(index);
+    const int childIndex = firstChildIndex(index);
 
     switch (node.type) {
     case Node::Leaf: {
-        visitor->visit(&leaves[node.leafIndex]);
+        visitor->visit(const_cast<QList<QGraphicsItem*>*>(&leaves[node.leafIndex]));
         break;
     }
     case Node::Vertical:
@@ -288,7 +257,6 @@ void QGraphicsSceneBspTree::climbTree(QGraphicsSceneBspTreeVisitor *visitor, con
         }
         break;
     case Node::Horizontal:
-        int childIndex = firstChildIndex(index);
         if (rect.top() < node.offset) {
             climbTree(visitor, rect, childIndex);
             if (rect.bottom() >= node.offset)
diff --git a/src/gui/graphicsview/qgraphicsscene_bsp_p.h b/src/gui/graphicsview/qgraphicsscene_bsp_p.h
index 73a937f..4cac64a 100644
--- a/src/gui/graphicsview/qgraphicsscene_bsp_p.h
+++ b/src/gui/graphicsview/qgraphicsscene_bsp_p.h
@@ -92,8 +92,7 @@ public:
     void removeItem(QGraphicsItem *item, const QRectF &rect);
     void removeItems(const QSet<QGraphicsItem *> &items);
 
-    QList<QGraphicsItem *> items(const QRectF &rect);
-    QList<QGraphicsItem *> items(const QPointF &pos);
+    QList<QGraphicsItem *> items(const QRectF &rect, bool onlyTopLevelItems = false) const;
     int leafCount() const;
 
     inline int firstChildIndex(int index) const
@@ -106,11 +105,7 @@ public:
 
 private:
     void initialize(const QRectF &rect, int depth, int index);
-    void climbTree(QGraphicsSceneBspTreeVisitor *visitor, const QPointF &pos, int index = 0);
-    void climbTree(QGraphicsSceneBspTreeVisitor *visitor, const QRectF &rect, int index = 0);
-
-    void findItems(QList<QGraphicsItem *> *foundItems, const QRectF &rect, int index);
-    void findItems(QList<QGraphicsItem *> *foundItems, const QPointF &pos, int index);
+    void climbTree(QGraphicsSceneBspTreeVisitor *visitor, const QRectF &rect, int index = 0) const;
     QRectF rectForIndex(int index) const;
 
     QVector<Node> nodes;
diff --git a/src/gui/graphicsview/qgraphicsscene_p.h b/src/gui/graphicsview/qgraphicsscene_p.h
index dc720a7..ffd62d5 100644
--- a/src/gui/graphicsview/qgraphicsscene_p.h
+++ b/src/gui/graphicsview/qgraphicsscene_p.h
@@ -59,7 +59,6 @@
 
 #include "qgraphicssceneevent.h"
 #include "qgraphicsview.h"
-#include "qgraphicsscene_bsp_p.h"
 #include "qgraphicsitem_p.h"
 
 #include <private/qobject_p.h>
@@ -72,10 +71,9 @@
 #include <QtGui/qstyle.h>
 #include <QtGui/qstyleoption.h>
 
-static const int QGRAPHICSSCENE_INDEXTIMER_TIMEOUT = 2000;
-
 QT_BEGIN_NAMESPACE
 
+class QGraphicsSceneIndex;
 class QGraphicsView;
 class QGraphicsWidget;
 
@@ -86,24 +84,19 @@ public:
     QGraphicsScenePrivate();
     void init();
 
+    static QGraphicsScenePrivate *get(QGraphicsScene *q);
+
     quint32 changedSignalMask;
 
     QGraphicsScene::ItemIndexMethod indexMethod;
-    int bspTreeDepth;
-
-    QList<QGraphicsItem *> estimateItemsInRect(const QRectF &rect) const;
-    void addToIndex(QGraphicsItem *item);
-    void removeFromIndex(QGraphicsItem *item);
-    void resetIndex();
+    QGraphicsSceneIndex *index;
 
-    QGraphicsSceneBspTree bspTree;
-    void _q_updateIndex();
     int lastItemCount;
 
     QRectF sceneRect;
     bool hasSceneRect;
+    bool dirtyGrowingItemsBoundingRect;
     QRectF growingItemsBoundingRect;
-    QRectF largestUntransformableItem;
 
     void _q_emitUpdated();
     QList<QRectF> updatedRects;
@@ -114,9 +107,6 @@ public:
     QPainterPath selectionArea;
     int selectionChanging;
     QSet<QGraphicsItem *> selectedItems;
-    QList<QGraphicsItem *> unindexedItems;
-    QList<QGraphicsItem *> indexedItems;
-    QList<QGraphicsItem *> pendingUpdateItems;
     QList<QGraphicsItem *> unpolishedItems;
     QList<QGraphicsItem *> topLevelItems;
     bool needSortTopLevelItems;
@@ -128,21 +118,11 @@ public:
 
     void _q_processDirtyItems();
 
-    QList<int> freeItemIndexes;
-    bool regenerateIndex;
-
-    bool purgePending;
     void removeItemHelper(QGraphicsItem *item);
-    QSet<QGraphicsItem *> removedItems;
-    void purgeRemovedItems();
 
     QBrush backgroundBrush;
     QBrush foregroundBrush;
 
-    int indexTimerId;
-    bool restartIndexTimer;
-    void startIndexTimer(int interval = QGRAPHICSSCENE_INDEXTIMER_TIMEOUT);
-
     bool stickyFocus;
     bool hasFocus;
     QGraphicsItem *focusItem;
@@ -181,7 +161,6 @@ public:
     QList<QGraphicsItem *> itemsAtPosition(const QPoint &screenPos,
                                            const QPointF &scenePos,
                                            QWidget *widget) const;
-    static bool itemCollidesWithPath(QGraphicsItem *item, const QPainterPath &path, Qt::ItemSelectionMode mode);
     void storeMouseButtonsForMouseGrabber(QGraphicsSceneMouseEvent *event);
 
     QList<QGraphicsView *> views;
@@ -210,69 +189,14 @@ public:
     void mousePressEventHandler(QGraphicsSceneMouseEvent *mouseEvent);
     QGraphicsWidget *windowForItem(const QGraphicsItem *item) const;
 
-    QList<QGraphicsItem *> topLevelItemsInStackingOrder(const QTransform *const, QRegion *);
-    void recursive_items_helper(QGraphicsItem *item, QRectF rect, QList<QGraphicsItem *> *items,
-                                const QTransform &parentTransform, const QTransform &viewTransform,
-                                Qt::ItemSelectionMode mode, Qt::SortOrder order, qreal parentOpacity = 1.0) const;
-
-    QList<QGraphicsItem *> items_helper(const QPointF &pos) const;
-    QList<QGraphicsItem *> items_helper(const QRectF &rect,
-                                        Qt::ItemSelectionMode mode,
-                                        Qt::SortOrder order) const;
-    QList<QGraphicsItem *> items_helper(const QPolygonF &rect,
-                                        Qt::ItemSelectionMode mode,
-                                        Qt::SortOrder order) const;
-    QList<QGraphicsItem *> items_helper(const QPainterPath &rect,
-                                        Qt::ItemSelectionMode mode,
-                                        Qt::SortOrder order) const;
-    void childItems_helper(QList<QGraphicsItem *> *items,
-                           const QGraphicsItem *parent,
-                           const QPointF &pos) const;
-    void childItems_helper(QList<QGraphicsItem *> *items,
-                           const QGraphicsItem *parent,
-                           const QRectF &rect,
-                           Qt::ItemSelectionMode mode) const;
-    void childItems_helper(QList<QGraphicsItem *> *items,
-                           const QGraphicsItem *parent,
-                           const QPolygonF &polygon,
-                           Qt::ItemSelectionMode mode) const;
-    void childItems_helper(QList<QGraphicsItem *> *items,
-                           const QGraphicsItem *parent,
-                           const QPainterPath &path,
-                           Qt::ItemSelectionMode mode) const;
-
-    bool sortCacheEnabled;
-    bool updatingSortCache;
-    void invalidateSortCache();
-    static void climbTree(QGraphicsItem *item, int *stackingOrder);
-    void _q_updateSortCache();
-
-    static bool closestItemFirst_withoutCache(const QGraphicsItem *item1, const QGraphicsItem *item2);
-    static bool closestItemLast_withoutCache(const QGraphicsItem *item1, const QGraphicsItem *item2);
-
-    static inline bool closestItemFirst_withCache(const QGraphicsItem *item1, const QGraphicsItem *item2)
-    {
-        return item1->d_ptr->globalStackingOrder < item2->d_ptr->globalStackingOrder;
-    }
-    static inline bool closestItemLast_withCache(const QGraphicsItem *item1, const QGraphicsItem *item2)
-    {
-        return item1->d_ptr->globalStackingOrder >= item2->d_ptr->globalStackingOrder;
-    }
-
-    static void sortItems(QList<QGraphicsItem *> *itemList, Qt::SortOrder order, bool cached);
+    bool sortCacheEnabled; // for compatibility
 
     void drawItemHelper(QGraphicsItem *item, QPainter *painter,
                         const QStyleOptionGraphicsItem *option, QWidget *widget,
                         bool painterStateProtection);
 
-    inline void drawItems(QPainter *painter, const QTransform *const viewTransform,
-                          QRegion *exposedRegion, QWidget *widget)
-    {
-        const QList<QGraphicsItem *> tli = topLevelItemsInStackingOrder(viewTransform, exposedRegion);
-        for (int i = 0; i < tli.size(); ++i)
-            drawSubtreeRecursive(tli.at(i), painter, viewTransform, exposedRegion, widget);
-        return;
-    }
+    void drawItems(QPainter *painter, const QTransform *const viewTransform,
+                   QRegion *exposedRegion, QWidget *widget);
 
     void drawSubtreeRecursive(QGraphicsItem *item, QPainter *painter, const QTransform *const,
                               QRegion *exposedRegion, QWidget *widget, qreal parentOpacity = qreal(1.0));
@@ -282,18 +206,32 @@ public:
     void processDirtyItemsRecursive(QGraphicsItem *item, bool dirtyAncestorContainsChildren = false,
                                     qreal parentOpacity = qreal(1.0));
 
-    inline void resetDirtyItem(QGraphicsItem *item)
+    inline void resetDirtyItem(QGraphicsItem *item, bool recursive = false)
     {
         Q_ASSERT(item);
         item->d_ptr->dirty = 0;
         item->d_ptr->paintedViewBoundingRectsNeedRepaint = 0;
         item->d_ptr->geometryChanged = 0;
+        if (!item->d_ptr->dirtyChildren)
+            recursive = false;
         item->d_ptr->dirtyChildren = 0;
         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;
+        if (recursive) {
+            for (int i = 0; i < item->d_ptr->children.size(); ++i)
+                resetDirtyItem(item->d_ptr->children.at(i), recursive);
+        }
+    }
+
+    inline void ensureSortedTopLevelItems()
+    {
+        if (needSortTopLevelItems) {
+            qSort(topLevelItems.begin(), topLevelItems.end(), qt_notclosestLeaf);
+            needSortTopLevelItems = false;
+        }
     }
 
     QStyle *style;
@@ -320,6 +258,25 @@ public:
     void updateInputMethodSensitivityInViews();
 };
 
+// QRectF::intersects() returns false always if either the source or target
+// rectangle's width or height are 0. This works around that problem.
+static inline void _q_adjustRect(QRectF *rect)
+{
+    Q_ASSERT(rect);
+    if (!rect->width())
+        rect->adjust(-0.00001, 0, 0.00001, 0);
+    if (!rect->height())
+        rect->adjust(0, -0.00001, 0, 0.00001);
+}
+
+static inline QRectF adjustedItemBoundingRect(const QGraphicsItem *item)
+{
+    Q_ASSERT(item);
+    QRectF boundingRect(item->boundingRect());
+    _q_adjustRect(&boundingRect);
+    return boundingRect;
+}
+
 QT_END_NAMESPACE
 
 #endif // QT_NO_GRAPHICSVIEW
diff --git a/src/gui/graphicsview/qgraphicsscenebsptreeindex.cpp b/src/gui/graphicsview/qgraphicsscenebsptreeindex.cpp
new file mode 100644
index 0000000..a54ade9
--- /dev/null
+++ b/src/gui/graphicsview/qgraphicsscenebsptreeindex.cpp
@@ -0,0 +1,782 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \class QGraphicsSceneBspTreeIndex
+    \brief The QGraphicsSceneBspTreeIndex class provides an implementation of
+    a BSP indexing algorithm for discovering items in QGraphicsScene.
+    \since 4.6
+    \ingroup multimedia
+    \ingroup graphicsview-api
+    \mainclass
+    \internal
+
+    QGraphicsSceneBspTreeIndex index use a BSP(Binary Space Partitioning)
+    implementation to discover items quickly. This implementation is
+    very efficient for static scene. It has a depth that you can set.
+    The depth directly affects performance and memory usage; the latter
+    growing exponentially with the depth of the tree. With an optimal tree
+    depth, the index can instantly determine the locality of items, even
+    for scenes with thousands or millions of items. This also greatly improves
+    rendering performance.
+
+    By default, the value is 0, in which case Qt will guess a reasonable
+    default depth based on the size, location and number of items in the
+    scene. If these parameters change frequently, however, you may experience
+    slowdowns as the index retunes the depth internally. You can avoid
+    potential slowdowns by fixating the tree depth through setting this
+    property.
+
+    The depth of the tree and the size of the scene rectangle decide the
+    granularity of the scene's partitioning. The size of each scene segment is
+    determined by the following algorithm:
+
+    The BSP tree has an optimal size when each segment contains between 0 and
+    10 items.
+
+    \sa QGraphicsScene, QGraphicsView, QGraphicsSceneIndex
+*/
+
+#ifndef QT_NO_GRAPHICSVIEW
+
+#include <private/qgraphicsscene_p.h>
+#include <private/qgraphicsscenebsptreeindex_p.h>
+#include <private/qgraphicssceneindex_p.h>
+
+#include <QtCore/qmath.h>
+#include <QtCore/qdebug.h>
+
+QT_BEGIN_NAMESPACE
+
+static inline int intmaxlog(int n)
+{
+    return  (n > 0 ? qMax(qCeil(qLn(qreal(n)) / qLn(qreal(2))), 5) : 0);
+}
+
+/*!
+    Constructs a private scene bsp index.
+*/
+QGraphicsSceneBspTreeIndexPrivate::QGraphicsSceneBspTreeIndexPrivate(QGraphicsScene *scene)
+    : QGraphicsSceneIndexPrivate(scene),
+    bspTreeDepth(0),
+    indexTimerId(0),
+    restartIndexTimer(false),
+    regenerateIndex(true),
+    lastItemCount(0),
+    purgePending(false),
+    sortCacheEnabled(false),
+    updatingSortCache(false)
+{
+}
+
+
+/*!
+    This method will update the BSP index by removing the items from the temporary
+    unindexed list and add them in the indexedItems list. This will also
+    update the growingItemsBoundingRect if needed. This will update the BSP
+    implementation as well.
+
+    \internal
+*/
+void QGraphicsSceneBspTreeIndexPrivate::_q_updateIndex()
+{
+    Q_Q(QGraphicsSceneBspTreeIndex);
+    if (!indexTimerId)
+        return;
+
+    q->killTimer(indexTimerId);
+    indexTimerId = 0;
+
+    purgeRemovedItems();
+
+     // Add unindexedItems to indexedItems
+    for (int i = 0; i < unindexedItems.size(); ++i) {
+        if (QGraphicsItem *item = unindexedItems.at(i)) {
+            Q_ASSERT(!item->d_ptr->itemDiscovered);
+            if (!freeItemIndexes.isEmpty()) {
+                int freeIndex = freeItemIndexes.takeFirst();
+                item->d_func()->index = freeIndex;
+                indexedItems[freeIndex] = item;
+            } else {
+                item->d_func()->index = indexedItems.size();
+                indexedItems << item;
+            }
+        }
+    }
+
+    // Determine whether we should regenerate the BSP tree.
+    if (bspTreeDepth == 0) {
+        int oldDepth = intmaxlog(lastItemCount);
+        bspTreeDepth = intmaxlog(indexedItems.size());
+        static const int slack = 100;
+        if (bsp.leafCount() == 0 || (oldDepth != bspTreeDepth && qAbs(lastItemCount - indexedItems.size()) > slack)) {
+            // ### Crude algorithm.
+            regenerateIndex = true;
+        }
+    }
+
+    // Regenerate the tree.
+    if (regenerateIndex) {
+        regenerateIndex = false;
+        bsp.initialize(sceneRect, bspTreeDepth);
+        unindexedItems = indexedItems;
+        lastItemCount = indexedItems.size();
+    }
+
+    // Insert all unindexed items into the tree.
+    for (int i = 0; i < unindexedItems.size(); ++i) {
+        if (QGraphicsItem *item = unindexedItems.at(i)) {
+            if (item->d_ptr->itemIsUntransformable()) {
+                untransformableItems << item;
+                continue;
+            }
+            if (item->d_ptr->ancestorFlags & QGraphicsItemPrivate::AncestorClipsChildren)
+                continue;
+
+            bsp.insertItem(item, item->sceneBoundingRect());
+        }
+    }
+    unindexedItems.clear();
+}
+
+
+/*!
+    \internal
+
+    Removes stale pointers from all data structures.
+*/
+void QGraphicsSceneBspTreeIndexPrivate::purgeRemovedItems()
+{
+    if (!purgePending && removedItems.isEmpty())
+        return;
+
+    // Remove stale items from the BSP tree.
+    bsp.removeItems(removedItems);
+    // Purge this list.
+    removedItems.clear();
+    freeItemIndexes.clear();
+    for (int i = 0; i < indexedItems.size(); ++i) {
+        if (!indexedItems.at(i))
+            freeItemIndexes << i;
+    }
+    purgePending = false;
+}
+
+/*!
+    \internal
+
+    Starts or restarts the timer used for reindexing unindexed items.
+*/
+void QGraphicsSceneBspTreeIndexPrivate::startIndexTimer(int interval)
+{
+    Q_Q(QGraphicsSceneBspTreeIndex);
+    if (indexTimerId) {
+        restartIndexTimer = true;
+    } else {
+        indexTimerId = q->startTimer(interval);
+    }
+}
+
+/*!
+    \internal
+*/
+void QGraphicsSceneBspTreeIndexPrivate::resetIndex()
+{
+    purgeRemovedItems();
+    for (int i = 0; i < indexedItems.size(); ++i) {
+        if (QGraphicsItem *item = indexedItems.at(i)) {
+            item->d_ptr->index = -1;
+            Q_ASSERT(!item->d_ptr->itemDiscovered);
+            unindexedItems << item;
+        }
+    }
+    indexedItems.clear();
+    freeItemIndexes.clear();
+    untransformableItems.clear();
+    regenerateIndex = true;
+    startIndexTimer();
+}
+
+/*!
+    \internal
+*/
+void QGraphicsSceneBspTreeIndexPrivate::climbTree(QGraphicsItem *item, int *stackingOrder)
+{
+    if (!item->d_ptr->children.isEmpty()) {
+        QList<QGraphicsItem *> childList = item->d_ptr->children;
+        qSort(childList.begin(), childList.end(), qt_closestLeaf);
+        for (int i = 0; i < childList.size(); ++i) {
+            QGraphicsItem *item = childList.at(i);
+            if (!(item->flags() & QGraphicsItem::ItemStacksBehindParent))
+                climbTree(childList.at(i), stackingOrder);
+        }
+        item->d_ptr->globalStackingOrder = (*stackingOrder)++;
+        for (int i = 0; i < childList.size(); ++i) {
+            QGraphicsItem *item = childList.at(i);
+            if (item->flags() & QGraphicsItem::ItemStacksBehindParent)
+                climbTree(childList.at(i), stackingOrder);
+        }
+    } else {
+        item->d_ptr->globalStackingOrder = (*stackingOrder)++;
+    }
+}
+
+/*!
+    \internal
+*/
+void QGraphicsSceneBspTreeIndexPrivate::_q_updateSortCache()
+{
+    Q_Q(QGraphicsSceneBspTreeIndex);
+    _q_updateIndex();
+
+    if (!sortCacheEnabled || !updatingSortCache)
+        return;
+
+    updatingSortCache = false;
+    int stackingOrder = 0;
+
+    QList<QGraphicsItem *> topLevels;
+    const QList<QGraphicsItem *> items = q->items();
+    for (int i = 0; i < items.size(); ++i) {
+        QGraphicsItem *item = items.at(i);
+        if (item && !item->d_ptr->parent)
+            topLevels << item;
+    }
+
+    qSort(topLevels.begin(), topLevels.end(), qt_closestLeaf);
+    for (int i = 0; i < topLevels.size(); ++i)
+        climbTree(topLevels.at(i), &stackingOrder);
+}
+
+/*!
+    \internal
+*/
+void QGraphicsSceneBspTreeIndexPrivate::invalidateSortCache()
+{
+    Q_Q(QGraphicsSceneBspTreeIndex);
+    if (!sortCacheEnabled || updatingSortCache)
+        return;
+
+    updatingSortCache = true;
+    QMetaObject::invokeMethod(q, "_q_updateSortCache", Qt::QueuedConnection);
+}
+
+void QGraphicsSceneBspTreeIndexPrivate::addItem(QGraphicsItem *item, bool recursive)
+{
+    if (!item)
+        return;
+
+    // Prevent reusing a recently deleted pointer: purge all removed item from our lists.
+    purgeRemovedItems();
+
+    // Invalidate any sort caching; arrival of a new item means we need to resort.
+    // Update the scene's sort cache settings.
+    item->d_ptr->globalStackingOrder = -1;
+    invalidateSortCache();
+
+    // Indexing requires sceneBoundingRect(), but because \a item might
+    // not be completely constructed at this point, we need to store it in
+    // a temporary list and schedule an indexing for later.
+    if (item->d_ptr->index == -1) {
+        Q_ASSERT(!unindexedItems.contains(item));
+        unindexedItems << item;
+        startIndexTimer(0);
+    } else {
+        Q_ASSERT(indexedItems.contains(item));
+        qWarning("QGraphicsSceneBspTreeIndex::addItem: item has already been added to this BSP");
+    }
+
+    if (recursive) {
+        for (int i = 0; i < item->d_ptr->children.size(); ++i)
+            addItem(item->d_ptr->children.at(i), recursive);
+    }
+}
+
+void QGraphicsSceneBspTreeIndexPrivate::removeItem(QGraphicsItem *item, bool recursive,
+                                                   bool moveToUnindexedItems)
+{
+    if (!item)
+        return;
+
+    if (item->d_ptr->index != -1) {
+        Q_ASSERT(item->d_ptr->index < indexedItems.size());
+        Q_ASSERT(indexedItems.at(item->d_ptr->index) == item);
+        Q_ASSERT(!item->d_ptr->itemDiscovered);
+        freeItemIndexes << item->d_ptr->index;
+        indexedItems[item->d_ptr->index] = 0;
+        item->d_ptr->index = -1;
+
+        if (item->d_ptr->itemIsUntransformable()) {
+            untransformableItems.removeOne(item);
+        } else if (item->d_ptr->inDestructor) {
+            // Avoid virtual function calls from the destructor.
+            purgePending = true;
+            removedItems << item;
+        } else if (!(item->d_ptr->ancestorFlags & QGraphicsItemPrivate::AncestorClipsChildren)) {
+            bsp.removeItem(item, item->sceneBoundingRect());
+        }
+    } else {
+        unindexedItems.removeOne(item);
+    }
+    invalidateSortCache(); // ### Only do this when removing from BSP?
+
+    Q_ASSERT(item->d_ptr->index == -1);
+    Q_ASSERT(!indexedItems.contains(item));
+    Q_ASSERT(!unindexedItems.contains(item));
+    Q_ASSERT(!untransformableItems.contains(item));
+
+    if (moveToUnindexedItems)
+        addItem(item);
+
+    if (recursive) {
+        for (int i = 0; i < item->d_ptr->children.size(); ++i)
+            removeItem(item->d_ptr->children.at(i), recursive, moveToUnindexedItems);
+    }
+}
+
+QList<QGraphicsItem *> QGraphicsSceneBspTreeIndexPrivate::estimateItems(const QRectF &rect, Qt::SortOrder order,
+                                                                        bool onlyTopLevelItems)
+{
+    Q_Q(QGraphicsSceneBspTreeIndex);
+    if (onlyTopLevelItems && rect.isNull())
+        return q->QGraphicsSceneIndex::estimateTopLevelItems(rect, order);
+
+    purgeRemovedItems();
+    _q_updateSortCache();
+    Q_ASSERT(unindexedItems.isEmpty());
+
+    QList<QGraphicsItem *> rectItems = bsp.items(rect, onlyTopLevelItems);
+    if (onlyTopLevelItems) {
+        for (int i = 0; i < untransformableItems.size(); ++i) {
+            QGraphicsItem *item = untransformableItems.at(i);
+            if (!item->d_ptr->parent) {
+                rectItems << item;
+            } else {
+                item = item->topLevelItem();
+                if (!rectItems.contains(item))
+                    rectItems << item;
+            }
+        }
+    } else {
+        rectItems += untransformableItems;
+    }
+
+    sortItems(&rectItems, order, sortCacheEnabled, onlyTopLevelItems);
+    return rectItems;
+}
+
+/*!
+    Returns true if \a item1 is on top of \a item2.
+
+    \internal
+*/
+bool QGraphicsSceneBspTreeIndexPrivate::closestItemFirst_withoutCache(const QGraphicsItem *item1, const QGraphicsItem *item2)
+{
+    // Siblings? Just check their z-values.
+    const QGraphicsItemPrivate *d1 = item1->d_ptr;
+    const QGraphicsItemPrivate *d2 = item2->d_ptr;
+    if (d1->parent == d2->parent)
+        return qt_closestLeaf(item1, item2);
+
+    // Find common ancestor, and each item's ancestor closest to the common
+    // ancestor.
+    int item1Depth = d1->depth;
+    int item2Depth = d2->depth;
+    const QGraphicsItem *p = item1;
+    const QGraphicsItem *t1 = item1;
+    while (item1Depth > item2Depth && (p = p->d_ptr->parent)) {
+        if (p == item2) {
+            // item2 is one of item1's ancestors; item1 is on top
+            return !(t1->d_ptr->flags & QGraphicsItem::ItemStacksBehindParent);
+        }
+        t1 = p;
+        --item1Depth;
+    }
+    p = item2;
+    const QGraphicsItem *t2 = item2;
+    while (item2Depth > item1Depth && (p = p->d_ptr->parent)) {
+        if (p == item1) {
+            // item1 is one of item2's ancestors; item1 is not on top
+            return (t2->d_ptr->flags & QGraphicsItem::ItemStacksBehindParent);
+        }
+        t2 = p;
+        --item2Depth;
+    }
+
+    // item1Ancestor is now at the same level as item2Ancestor, but not the same.
+    const QGraphicsItem *a1 = t1;
+    const QGraphicsItem *a2 = t2;
+    while (a1) {
+        const QGraphicsItem *p1 = a1;
+        const QGraphicsItem *p2 = a2;
+        a1 = a1->parentItem();
+        a2 = a2->parentItem();
+        if (a1 && a1 == a2)
+            return qt_closestLeaf(p1, p2);
+    }
+
+    // No common ancestor? Then just compare the items' toplevels directly.
+    return qt_closestLeaf(t1->topLevelItem(), t2->topLevelItem());
+}
+
+/*!
+    Returns true if \a item2 is on top of \a item1.
+
+    \internal
+*/
+bool QGraphicsSceneBspTreeIndexPrivate::closestItemLast_withoutCache(const QGraphicsItem *item1, const QGraphicsItem *item2)
+{
+    return closestItemFirst_withoutCache(item2, item1);
+}
+
+/*!
+    Sort a list of \a itemList in a specific \a order and use the cache if requested.
+
+    \internal
+*/
+void QGraphicsSceneBspTreeIndexPrivate::sortItems(QList<QGraphicsItem *> *itemList, Qt::SortOrder order,
+                                                  bool sortCacheEnabled, bool onlyTopLevelItems)
+{
+    if (order == Qt::SortOrder(-1))
+        return;
+
+    if (onlyTopLevelItems) {
+        if (order == Qt::AscendingOrder)
+            qSort(itemList->begin(), itemList->end(), qt_closestLeaf);
+        else if (order == Qt::DescendingOrder)
+            qSort(itemList->begin(), itemList->end(), qt_notclosestLeaf);
+        return;
+    }
+
+    if (sortCacheEnabled) {
+        if (order == Qt::AscendingOrder) {
+            qSort(itemList->begin(), itemList->end(), closestItemFirst_withCache);
+        } else if (order == Qt::DescendingOrder) {
+            qSort(itemList->begin(), itemList->end(), closestItemLast_withCache);
+        }
+    } else {
+        if (order == Qt::AscendingOrder) {
+            qSort(itemList->begin(), itemList->end(), closestItemFirst_withoutCache);
+        } else if (order == Qt::DescendingOrder) {
+            qSort(itemList->begin(), itemList->end(), closestItemLast_withoutCache);
+        }
+    }
+}
+
+/*!
+    Constructs a BSP scene index for the given \a scene.
+*/
+QGraphicsSceneBspTreeIndex::QGraphicsSceneBspTreeIndex(QGraphicsScene *scene)
+    : QGraphicsSceneIndex(*new QGraphicsSceneBspTreeIndexPrivate(scene), scene)
+{
+
+}
+
+QGraphicsSceneBspTreeIndex::~QGraphicsSceneBspTreeIndex()
+{
+    Q_D(QGraphicsSceneBspTreeIndex);
+    for (int i = 0; i < d->indexedItems.size(); ++i) {
+        // Ensure item bits are reset properly.
+        if (QGraphicsItem *item = d->indexedItems.at(i)) {
+            Q_ASSERT(!item->d_ptr->itemDiscovered);
+            item->d_ptr->index = -1;
+        }
+    }
+}
+
+/*!
+    \reimp
+    Clear the all the BSP index.
+*/
+void QGraphicsSceneBspTreeIndex::clear()
+{
+    Q_D(QGraphicsSceneBspTreeIndex);
+    d->bsp.clear();
+    d->lastItemCount = 0;
+    d->freeItemIndexes.clear();
+    for (int i = 0; i < d->indexedItems.size(); ++i) {
+        // Ensure item bits are reset properly.
+        if (QGraphicsItem *item = d->indexedItems.at(i)) {
+            Q_ASSERT(!item->d_ptr->itemDiscovered);
+            item->d_ptr->index = -1;
+        }
+    }
+    d->indexedItems.clear();
+    d->unindexedItems.clear();
+    d->untransformableItems.clear();
+}
+
+/*!
+    Add the \a item into the BSP index.
+*/
+void QGraphicsSceneBspTreeIndex::addItem(QGraphicsItem *item)
+{
+    Q_D(QGraphicsSceneBspTreeIndex);
+    d->addItem(item);
+}
+
+/*!
+    Remove the \a item from the BSP index.
+*/
+void QGraphicsSceneBspTreeIndex::removeItem(QGraphicsItem *item)
+{
+    Q_D(QGraphicsSceneBspTreeIndex);
+    d->removeItem(item);
+}
+
+/*!
+    \reimp
+    Update the BSP when the \a item 's bounding rect has changed.
+*/
+void QGraphicsSceneBspTreeIndex::prepareBoundingRectChange(const QGraphicsItem *item)
+{
+    if (!item)
+        return;
+
+    if (item->d_ptr->index == -1 || item->d_ptr->itemIsUntransformable()
+        || (item->d_ptr->ancestorFlags & QGraphicsItemPrivate::AncestorClipsChildren)) {
+        return; // Item is not in BSP tree; nothing to do.
+    }
+
+    Q_D(QGraphicsSceneBspTreeIndex);
+    QGraphicsItem *thatItem = const_cast<QGraphicsItem *>(item);
+    d->removeItem(thatItem, /*recursive=*/false, /*moveToUnindexedItems=*/true);
+    for (int i = 0; i < item->d_ptr->children.size(); ++i)  // ### Do we really need this?
+        prepareBoundingRectChange(item->d_ptr->children.at(i));
+}
+
+/*!
+    Returns an estimation visible items that are either inside or
+    intersect with the specified \a rect and return a list sorted using \a order.
+
+    \a deviceTransform is the transformation apply to the view.
+
+*/
+QList<QGraphicsItem *> QGraphicsSceneBspTreeIndex::estimateItems(const QRectF &rect, Qt::SortOrder order) const
+{
+    Q_D(const QGraphicsSceneBspTreeIndex);
+    return const_cast<QGraphicsSceneBspTreeIndexPrivate*>(d)->estimateItems(rect, order);
+}
+
+QList<QGraphicsItem *> QGraphicsSceneBspTreeIndex::estimateTopLevelItems(const QRectF &rect, Qt::SortOrder order) const
+{
+    Q_D(const QGraphicsSceneBspTreeIndex);
+    return const_cast<QGraphicsSceneBspTreeIndexPrivate*>(d)->estimateItems(rect, order, /*onlyTopLevels=*/true);
+}
+
+/*!
+    \fn QList<QGraphicsItem *> QGraphicsSceneBspTreeIndex::items(Qt::SortOrder order = Qt::AscendingOrder) const;
+
+    Return all items in the BSP index and sort them using \a order.
+*/
+QList<QGraphicsItem *> QGraphicsSceneBspTreeIndex::items(Qt::SortOrder order) const
+{
+    Q_D(const QGraphicsSceneBspTreeIndex);
+    const_cast<QGraphicsSceneBspTreeIndexPrivate*>(d)->purgeRemovedItems();
+    QList<QGraphicsItem *> itemList;
+
+    // If freeItemIndexes is empty, we know there are no holes in indexedItems and
+    // unindexedItems.
+    if (d->freeItemIndexes.isEmpty()) {
+        if (d->unindexedItems.isEmpty()) {
+            itemList = d->indexedItems;
+        } else {
+            itemList = d->indexedItems + d->unindexedItems;
+        }
+    } else {
+        // Rebuild the list of items to avoid holes. ### We could also just
+        // compress the item lists at this point.
+        foreach (QGraphicsItem *item, d->indexedItems + d->unindexedItems) {
+            if (item)
+                itemList << item;
+        }
+    }
+    if (order != -1) {
+        //We sort descending order
+        d->sortItems(&itemList, order, d->sortCacheEnabled);
+    }
+    return itemList;
+}
+
+/*!
+    \property QGraphicsSceneBspTreeIndex::bspTreeDepth
+    \brief the depth of the BSP index tree
+    \since 4.6
+
+    This value determines the depth of BSP tree. The depth
+    directly affects performance and memory usage; the latter
+    growing exponentially with the depth of the tree. With an optimal tree
+    depth, the index can instantly determine the locality of items, even
+    for scenes with thousands or millions of items. This also greatly improves
+    rendering performance.
+
+    By default, the value is 0, in which case Qt will guess a reasonable
+    default depth based on the size, location and number of items in the
+    scene. If these parameters change frequently, however, you may experience
+    slowdowns as the index retunes the depth internally. You can avoid
+    potential slowdowns by fixating the tree depth through setting this
+    property.
+
+    The depth of the tree and the size of the scene rectangle decide the
+    granularity of the scene's partitioning. The size of each scene segment is
+    determined by the following algorithm:
+
+    The BSP tree has an optimal size when each segment contains between 0 and
+    10 items.
+
+*/
+int QGraphicsSceneBspTreeIndex::bspTreeDepth()
+{
+    Q_D(const QGraphicsSceneBspTreeIndex);
+    return d->bspTreeDepth;
+}
+
+void QGraphicsSceneBspTreeIndex::setBspTreeDepth(int depth)
+{
+    Q_D(QGraphicsSceneBspTreeIndex);
+    if (d->bspTreeDepth == depth)
+        return;
+    d->bspTreeDepth = depth;
+    d->resetIndex();
+}
+
+/*!
+    \reimp
+
+    This method react to the  \a rect change of the scene and
+    reset the BSP tree index.
+*/
+void QGraphicsSceneBspTreeIndex::updateSceneRect(const QRectF &rect)
+{
+    Q_D(QGraphicsSceneBspTreeIndex);
+    d->sceneRect = rect;
+    d->resetIndex();
+}
+
+/*!
+    \reimp
+
+    This method react to the \a change of the \a item and use the \a value to
+    update the BSP tree if necessary.
+
+*/
+void QGraphicsSceneBspTreeIndex::itemChange(const QGraphicsItem *item, QGraphicsItem::GraphicsItemChange change, const QVariant &value)
+{
+    Q_D(QGraphicsSceneBspTreeIndex);
+    switch (change) {
+    case QGraphicsItem::ItemFlagsChange: {
+        // Handle ItemIgnoresTransformations
+        bool ignoredTransform = item->d_ptr->flags & QGraphicsItem::ItemIgnoresTransformations;
+        bool willIgnoreTransform = value.toUInt() & QGraphicsItem::ItemIgnoresTransformations;
+        bool clipsChildren = item->d_ptr->flags & QGraphicsItem::ItemClipsChildrenToShape;
+        bool willClipChildren = value.toUInt() & QGraphicsItem::ItemClipsChildrenToShape;
+        if ((ignoredTransform != willIgnoreTransform) || (clipsChildren != willClipChildren)) {
+            QGraphicsItem *thatItem = const_cast<QGraphicsItem *>(item);
+            // Remove item and its descendants from the index and append
+            // them to the list of unindexed items. Then, when the index
+            // is updated, they will be put into the bsp-tree or the list
+            // of untransformable items.
+            d->removeItem(thatItem, /*recursive=*/true, /*moveToUnidexedItems=*/true);
+        }
+        break;
+    }
+    case QGraphicsItem::ItemZValueChange:
+        d->invalidateSortCache();
+        break;
+    case QGraphicsItem::ItemParentChange: {
+        d->invalidateSortCache();
+        // Handle ItemIgnoresTransformations
+        QGraphicsItem *newParent = qVariantValue<QGraphicsItem *>(value);
+        bool ignoredTransform = item->d_ptr->itemIsUntransformable();
+        bool willIgnoreTransform = (item->d_ptr->flags & QGraphicsItem::ItemIgnoresTransformations)
+                                   || (newParent && newParent->d_ptr->itemIsUntransformable());
+        bool ancestorClippedChildren = item->d_ptr->ancestorFlags & QGraphicsItemPrivate::AncestorClipsChildren;
+        bool ancestorWillClipChildren = newParent
+                            && ((newParent->d_ptr->flags & QGraphicsItem::ItemClipsChildrenToShape)
+                                || (newParent->d_ptr->ancestorFlags & QGraphicsItemPrivate::AncestorClipsChildren));
+        if ((ignoredTransform != willIgnoreTransform) || (ancestorClippedChildren != ancestorWillClipChildren)) {
+            QGraphicsItem *thatItem = const_cast<QGraphicsItem *>(item);
+            // Remove item and its descendants from the index and append
+            // them to the list of unindexed items. Then, when the index
+            // is updated, they will be put into the bsp-tree or the list
+            // of untransformable items.
+            d->removeItem(thatItem, /*recursive=*/true, /*moveToUnidexedItems=*/true);
+        }
+        break;
+    }
+    default:
+        break;
+    }
+    return QGraphicsSceneIndex::itemChange(item, change, value);
+}
+/*!
+    \reimp
+
+    Used to catch the timer event.
+
+    \internal
+*/
+bool QGraphicsSceneBspTreeIndex::event(QEvent *event)
+{
+    Q_D(QGraphicsSceneBspTreeIndex);
+    switch (event->type()) {
+    case QEvent::Timer:
+            if (d->indexTimerId && static_cast<QTimerEvent *>(event)->timerId() == d->indexTimerId) {
+                if (d->restartIndexTimer) {
+                    d->restartIndexTimer = false;
+                } else {
+                    // this call will kill the timer
+                    d->_q_updateIndex();
+                }
+            }
+     // Fallthrough intended - support timers in subclasses.
+    default:
+        return QObject::event(event);
+    }
+    return true;
+}
+
+QT_END_NAMESPACE
+
+#include "moc_qgraphicsscenebsptreeindex_p.cpp"
+
+#endif  // QT_NO_GRAPHICSVIEW
+
diff --git a/src/gui/graphicsview/qgraphicsscenebsptreeindex_p.h b/src/gui/graphicsview/qgraphicsscenebsptreeindex_p.h
new file mode 100644
index 0000000..3ac922b
--- /dev/null
+++ b/src/gui/graphicsview/qgraphicsscenebsptreeindex_p.h
@@ -0,0 +1,231 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of qapplication_*.cpp, qwidget*.cpp and qfiledialog.cpp.  This header
+// file may change from version to version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#ifndef QGRAPHICSBSPTREEINDEX_H
+#define QGRAPHICSBSPTREEINDEX_H
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+#if !defined(QT_NO_GRAPHICSVIEW) || (QT_EDITION & QT_MODULE_GRAPHICSVIEW) != QT_MODULE_GRAPHICSVIEW
+
+#include "qgraphicssceneindex_p.h"
+#include "qgraphicsitem_p.h"
+#include "qgraphicsscene_bsp_p.h"
+
+#include <QtCore/qglobal.h>
+#include <QtCore/qrect.h>
+#include <QtCore/qlist.h>
+
+static const int QGRAPHICSSCENE_INDEXTIMER_TIMEOUT = 2000;
+
+class QGraphicsScene;
+class QGraphicsSceneBspTreeIndexPrivate;
+
+class Q_AUTOTEST_EXPORT QGraphicsSceneBspTreeIndex : public QGraphicsSceneIndex
+{
+    Q_OBJECT
+    Q_PROPERTY(int bspTreeDepth READ bspTreeDepth WRITE setBspTreeDepth)
+public:
+    QGraphicsSceneBspTreeIndex(QGraphicsScene *scene = 0);
+    ~QGraphicsSceneBspTreeIndex();
+
+    QList<QGraphicsItem *> estimateItems(const QRectF &rect, Qt::SortOrder order) const;
+    QList<QGraphicsItem *> estimateTopLevelItems(const QRectF &rect, Qt::SortOrder order) const;
+    QList<QGraphicsItem *> items(Qt::SortOrder order = Qt::AscendingOrder) const;
+
+    int bspTreeDepth();
+    void setBspTreeDepth(int depth);
+
+protected Q_SLOTS:
+    void updateSceneRect(const QRectF &rect);
+
+protected:
+    bool event(QEvent *event);
+    void clear();
+
+    void addItem(QGraphicsItem *item);
+    void removeItem(QGraphicsItem *item);
+    void prepareBoundingRectChange(const QGraphicsItem *item);
+
+    void itemChange(const QGraphicsItem *item, QGraphicsItem::GraphicsItemChange change, const QVariant &value);
+
+private :
+    Q_DECLARE_PRIVATE(QGraphicsSceneBspTreeIndex)
+    Q_DISABLE_COPY(QGraphicsSceneBspTreeIndex)
+    Q_PRIVATE_SLOT(d_func(), void _q_updateSortCache())
+    Q_PRIVATE_SLOT(d_func(), void _q_updateIndex())
+
+    friend class QGraphicsScene;
+    friend class QGraphicsScenePrivate;
+};
+
+class QGraphicsSceneBspTreeIndexPrivate : public QGraphicsSceneIndexPrivate
+{
+    Q_DECLARE_PUBLIC(QGraphicsSceneBspTreeIndex)
+public:
+    QGraphicsSceneBspTreeIndexPrivate(QGraphicsScene *scene);
+
+    QGraphicsSceneBspTree bsp;
+    QRectF sceneRect;
+    int bspTreeDepth;
+    int indexTimerId;
+    bool restartIndexTimer;
+    bool regenerateIndex;
+    int lastItemCount;
+
+    QList<QGraphicsItem *> indexedItems;
+    QList<QGraphicsItem *> unindexedItems;
+    QList<QGraphicsItem *> untransformableItems;
+    QList<int> freeItemIndexes;
+
+    bool purgePending;
+    QSet<QGraphicsItem *> removedItems;
+    void purgeRemovedItems();
+
+    void _q_updateIndex();
+    void startIndexTimer(int interval = QGRAPHICSSCENE_INDEXTIMER_TIMEOUT);
+    void resetIndex();
+
+    void _q_updateSortCache();
+    bool sortCacheEnabled;
+    bool updatingSortCache;
+    void invalidateSortCache();
+    void addItem(QGraphicsItem *item, bool recursive = false);
+    void removeItem(QGraphicsItem *item, bool recursive = false, bool moveToUnindexedItems = false);
+    QList<QGraphicsItem *> estimateItems(const QRectF &, Qt::SortOrder, bool b = false);
+
+    static void climbTree(QGraphicsItem *item, int *stackingOrder);
+    static bool closestItemFirst_withoutCache(const QGraphicsItem *item1, const QGraphicsItem *item2);
+    static bool closestItemLast_withoutCache(const QGraphicsItem *item1, const QGraphicsItem *item2);
+
+    static inline bool closestItemFirst_withCache(const QGraphicsItem *item1, const QGraphicsItem *item2)
+    {
+        return item1->d_ptr->globalStackingOrder < item2->d_ptr->globalStackingOrder;
+    }
+    static inline bool closestItemLast_withCache(const QGraphicsItem *item1, const QGraphicsItem *item2)
+    {
+        return item1->d_ptr->globalStackingOrder >= item2->d_ptr->globalStackingOrder;
+    }
+
+    static void sortItems(QList<QGraphicsItem *> *itemList, Qt::SortOrder order,
+                          bool cached, bool onlyTopLevelItems = false);
+};
+
+
+/*!
+    \internal
+*/
+inline bool qt_closestLeaf(const QGraphicsItem *item1, const QGraphicsItem *item2)
+{
+    // Return true if sibling item1 is on top of item2.
+    const QGraphicsItemPrivate *d1 = item1->d_ptr;
+    const QGraphicsItemPrivate *d2 = item2->d_ptr;
+    bool f1 = d1->flags & QGraphicsItem::ItemStacksBehindParent;
+    bool f2 = d2->flags & QGraphicsItem::ItemStacksBehindParent;
+    if (f1 != f2)
+        return f2;
+    if (d1->z != d2->z)
+        return d1->z > d2->z;
+    return d1->siblingIndex > d2->siblingIndex;
+}
+
+static inline bool QRectF_intersects(const QRectF &s, const QRectF &r)
+{
+    qreal xp = s.left();
+    qreal yp = s.top();
+    qreal w = s.width();
+    qreal h = s.height();
+    qreal l1 = xp;
+    qreal r1 = xp;
+    if (w < 0)
+        l1 += w;
+    else
+        r1 += w;
+
+    qreal l2 = r.left();
+    qreal r2 = r.left();
+    if (w < 0)
+        l2 += r.width();
+    else
+        r2 += r.width();
+
+    if (l1 >= r2 || l2 >= r1)
+        return false;
+
+    qreal t1 = yp;
+    qreal b1 = yp;
+    if (h < 0)
+        t1 += h;
+    else
+        b1 += h;
+
+    qreal t2 = r.top();
+    qreal b2 = r.top();
+    if (r.height() < 0)
+        t2 += r.height();
+    else
+        b2 += r.height();
+
+    return !(t1 >= b2 || t2 >= b1);
+}
+
+#endif // QT_NO_GRAPHICSVIEW
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QGRAPHICSBSPTREEINDEX_H
diff --git a/src/gui/graphicsview/qgraphicssceneindex.cpp b/src/gui/graphicsview/qgraphicssceneindex.cpp
new file mode 100644
index 0000000..01efde4
--- /dev/null
+++ b/src/gui/graphicsview/qgraphicssceneindex.cpp
@@ -0,0 +1,659 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+/*!
+    \class QGraphicsSceneIndex
+    \brief The QGraphicsSceneIndex class provides a base class to implement
+    a custom indexing algorithm for discovering items in QGraphicsScene.
+    \since 4.6
+    \ingroup multimedia
+    \ingroup graphicsview-api
+    \mainclass
+    \internal
+
+    The QGraphicsSceneIndex class provides a base class to implement
+    a custom indexing algorithm for discovering items in QGraphicsScene. You
+    need to subclass it and reimplement addItem, removeItem, estimateItems
+    and items in order to have an functional indexing.
+
+    \sa QGraphicsScene, QGraphicsView
+*/
+
+#include "qdebug.h"
+#include "qgraphicsscene.h"
+#include "qgraphicsitem_p.h"
+#include "qgraphicsscene_p.h"
+#include "qgraphicswidget.h"
+#include "qgraphicssceneindex_p.h"
+#include "qgraphicsscenebsptreeindex_p.h"
+
+#ifndef QT_NO_GRAPHICSVIEW
+
+QT_BEGIN_NAMESPACE
+
+class QGraphicsSceneIndexRectIntersector : public QGraphicsSceneIndexIntersector
+{
+public:
+    bool intersect(const QGraphicsItem *item, const QRectF &exposeRect, Qt::ItemSelectionMode mode,
+                   const QTransform &deviceTransform) const
+    {
+        QRectF brect = item->boundingRect();
+        _q_adjustRect(&brect);
+
+        // ### Add test for this (without making things slower?)
+        Q_UNUSED(exposeRect);
+
+        bool keep = true;
+        const QGraphicsItemPrivate *itemd = QGraphicsItemPrivate::get(item);
+        if (itemd->itemIsUntransformable()) {
+            // Untransformable items; map the scene rect to item coordinates.
+            const QTransform transform = item->deviceTransform(deviceTransform);
+            QRectF itemRect = (deviceTransform * transform.inverted()).mapRect(sceneRect);
+            if (mode == Qt::ContainsItemShape || mode == Qt::ContainsItemBoundingRect)
+                keep = itemRect.contains(brect) && itemRect != brect;
+            else
+                keep = itemRect.intersects(brect);
+            if (keep && (mode == Qt::ContainsItemShape || mode == Qt::IntersectsItemShape)) {
+                QPainterPath itemPath;
+                itemPath.addRect(itemRect);
+                keep = QGraphicsSceneIndexPrivate::itemCollidesWithPath(item, itemPath, mode);
+            }
+        } else {
+            Q_ASSERT(!itemd->dirtySceneTransform);
+            const QRectF itemSceneBoundingRect = itemd->sceneTransformTranslateOnly
+                                               ? brect.translated(itemd->sceneTransform.dx(),
+                                                                  itemd->sceneTransform.dy())
+                                               : itemd->sceneTransform.mapRect(brect);
+            if (mode == Qt::ContainsItemShape || mode == Qt::ContainsItemBoundingRect)
+                keep = sceneRect != brect && sceneRect.contains(itemSceneBoundingRect);
+            else
+                keep = sceneRect.intersects(itemSceneBoundingRect);
+            if (keep && (mode == Qt::ContainsItemShape || mode == Qt::IntersectsItemShape)) {
+                QPainterPath rectPath;
+                rectPath.addRect(sceneRect);
+                if (itemd->sceneTransformTranslateOnly)
+                    rectPath.translate(-itemd->sceneTransform.dx(), -itemd->sceneTransform.dy());
+                else
+                    rectPath = itemd->sceneTransform.inverted().map(rectPath);
+                keep = QGraphicsSceneIndexPrivate::itemCollidesWithPath(item, rectPath, mode);
+            }
+        }
+        return keep;
+    }
+
+    QRectF sceneRect;
+};
+
+class QGraphicsSceneIndexPointIntersector : public QGraphicsSceneIndexIntersector
+{
+public:
+    bool intersect(const QGraphicsItem *item, const QRectF &exposeRect, Qt::ItemSelectionMode mode,
+                   const QTransform &deviceTransform) const
+    {
+        QRectF brect = item->boundingRect();
+        _q_adjustRect(&brect);
+
+        // ### Add test for this (without making things slower?)
+        Q_UNUSED(exposeRect);
+
+        bool keep = false;
+        const QGraphicsItemPrivate *itemd = QGraphicsItemPrivate::get(item);
+        if (itemd->itemIsUntransformable()) {
+            // Untransformable items; map the scene point to item coordinates.
+            const QTransform transform = item->deviceTransform(deviceTransform);
+            QPointF itemPoint = (deviceTransform * transform.inverted()).map(scenePoint);
+            keep = brect.contains(itemPoint);
+            if (keep && (mode == Qt::ContainsItemShape || mode == Qt::IntersectsItemShape)) {
+                QPainterPath pointPath;
+                pointPath.addRect(QRectF(itemPoint, QSizeF(1, 1)));
+                keep = QGraphicsSceneIndexPrivate::itemCollidesWithPath(item, pointPath, mode);
+            }
+        } else {
+            Q_ASSERT(!itemd->dirtySceneTransform);
+            QRectF sceneBoundingRect = itemd->sceneTransformTranslateOnly
+                                     ? brect.translated(itemd->sceneTransform.dx(),
+                                                        itemd->sceneTransform.dy())
+                                     : itemd->sceneTransform.mapRect(brect);
+            keep = sceneBoundingRect.intersects(QRectF(scenePoint, QSizeF(1, 1)));
+            if (keep) {
+                QPointF p = itemd->sceneTransformTranslateOnly
+                          ? QPointF(scenePoint.x() - itemd->sceneTransform.dx(),
+                                    scenePoint.y() - itemd->sceneTransform.dy())
+                          : itemd->sceneTransform.inverted().map(scenePoint);
+                keep = item->contains(p);
+            }
+        }
+
+        return keep;
+    }
+
+    QPointF scenePoint;
+};
+
+class QGraphicsSceneIndexPathIntersector : public QGraphicsSceneIndexIntersector
+{
+public:
+    bool intersect(const QGraphicsItem *item, const QRectF &exposeRect, Qt::ItemSelectionMode mode,
+                   const QTransform &deviceTransform) const
+    {
+        QRectF brect = item->boundingRect();
+        _q_adjustRect(&brect);
+
+        // ### Add test for this (without making things slower?)
+        Q_UNUSED(exposeRect);
+
+        bool keep = true;
+        const QGraphicsItemPrivate *itemd = QGraphicsItemPrivate::get(item);
+        if (itemd->itemIsUntransformable()) {
+            // Untransformable items; map the scene rect to item coordinates.
+            const QTransform transform = item->deviceTransform(deviceTransform);
+            QPainterPath itemPath = (deviceTransform * transform.inverted()).map(scenePath);
+            if (mode == Qt::ContainsItemShape || mode == Qt::ContainsItemBoundingRect)
+                keep = itemPath.contains(brect);
+            else
+                keep = itemPath.intersects(brect);
+            if (keep && (mode == Qt::ContainsItemShape || mode == Qt::IntersectsItemShape))
+                keep = QGraphicsSceneIndexPrivate::itemCollidesWithPath(item, itemPath, mode);
+        } else {
+            Q_ASSERT(!itemd->dirtySceneTransform);
+            const QRectF itemSceneBoundingRect = itemd->sceneTransformTranslateOnly
+                                               ? brect.translated(itemd->sceneTransform.dx(),
+                                                                  itemd->sceneTransform.dy())
+                                               : itemd->sceneTransform.mapRect(brect);
+            if (mode == Qt::ContainsItemShape || mode == Qt::ContainsItemBoundingRect)
+                keep = scenePath.contains(itemSceneBoundingRect);
+            else
+                keep = scenePath.intersects(itemSceneBoundingRect);
+            if (keep && (mode == Qt::ContainsItemShape || mode == Qt::IntersectsItemShape)) {
+                QPainterPath itemPath = itemd->sceneTransformTranslateOnly
+                                      ? scenePath.translated(-itemd->sceneTransform.dx(),
+                                                             -itemd->sceneTransform.dy())
+                                      : itemd->sceneTransform.inverted().map(scenePath);
+                keep = QGraphicsSceneIndexPrivate::itemCollidesWithPath(item, itemPath, mode);
+            }
+        }
+        return keep;
+    }
+
+    QPainterPath scenePath;
+};
+
+/*!
+    Constructs a private scene index.
+*/
+QGraphicsSceneIndexPrivate::QGraphicsSceneIndexPrivate(QGraphicsScene *scene) : scene(scene)
+{
+    pointIntersector = new QGraphicsSceneIndexPointIntersector;
+    rectIntersector = new QGraphicsSceneIndexRectIntersector;
+    pathIntersector =  new QGraphicsSceneIndexPathIntersector;
+}
+
+/*!
+    Destructor of private scene index.
+*/
+QGraphicsSceneIndexPrivate::~QGraphicsSceneIndexPrivate()
+{
+    delete pointIntersector;
+    delete rectIntersector;
+    delete pathIntersector;
+}
+
+/*!
+    \internal
+
+    Checks if item collides with the path and mode, but also checks that if it
+    doesn't collide, maybe its frame rect will.
+*/
+bool QGraphicsSceneIndexPrivate::itemCollidesWithPath(const QGraphicsItem *item,
+                                                      const QPainterPath &path,
+                                                      Qt::ItemSelectionMode mode)
+{
+    if (item->collidesWithPath(path, mode))
+        return true;
+    if (item->isWidget()) {
+        // Check if this is a window, and if its frame rect collides.
+        const QGraphicsWidget *widget = static_cast<const QGraphicsWidget *>(item);
+        if (widget->isWindow()) {
+            QRectF frameRect = widget->windowFrameRect();
+            QPainterPath framePath;
+            framePath.addRect(frameRect);
+            bool intersects = path.intersects(frameRect);
+            if (mode == Qt::IntersectsItemShape || mode == Qt::IntersectsItemBoundingRect)
+                return intersects || path.contains(frameRect.topLeft())
+                    || framePath.contains(path.elementAt(0));
+            return !intersects && path.contains(frameRect.topLeft());
+        }
+    }
+    return false;
+}
+
+/*!
+    \internal
+*/
+void QGraphicsSceneIndexPrivate::recursive_items_helper(QGraphicsItem *item, QRectF exposeRect,
+                                                        QGraphicsSceneIndexIntersector *intersector,
+                                                        QList<QGraphicsItem *> *items,
+                                                        const QTransform &viewTransform,
+                                                        Qt::ItemSelectionMode mode, Qt::SortOrder order,
+                                                        qreal parentOpacity) const
+{
+    Q_ASSERT(item);
+    if (!item->d_ptr->visible)
+        return;
+
+    const qreal opacity = item->d_ptr->combineOpacityFromParent(parentOpacity);
+    const bool itemIsFullyTransparent = (opacity < 0.0001);
+    const bool itemHasChildren = !item->d_ptr->children.isEmpty();
+    if (itemIsFullyTransparent && (!itemHasChildren || item->d_ptr->childrenCombineOpacity()))
+        return;
+
+    // Update the item's scene transform if dirty.
+    const bool itemIsUntransformable = item->d_ptr->itemIsUntransformable();
+    const bool wasDirtyParentSceneTransform = item->d_ptr->dirtySceneTransform && !itemIsUntransformable;
+    if (wasDirtyParentSceneTransform) {
+        item->d_ptr->updateSceneTransformFromParent();
+        Q_ASSERT(!item->d_ptr->dirtySceneTransform);
+    }
+
+    const bool itemClipsChildrenToShape = (item->d_ptr->flags & QGraphicsItem::ItemClipsChildrenToShape);
+    bool processItem = !itemIsFullyTransparent;
+    if (processItem) {
+        processItem = intersector->intersect(item, exposeRect, mode, viewTransform);
+        if (!processItem && (!itemHasChildren || itemClipsChildrenToShape)) {
+            if (wasDirtyParentSceneTransform)
+                item->d_ptr->invalidateChildrenSceneTransform();
+            return;
+        }
+    } // else we know for sure this item has children we must process.
+
+    int i = 0;
+    if (itemHasChildren) {
+        // Sort children.
+        item->d_ptr->ensureSortedChildren();
+
+        // Clip to shape.
+        if (itemClipsChildrenToShape && !itemIsUntransformable) {
+            QPainterPath mappedShape = item->d_ptr->sceneTransformTranslateOnly
+                                     ? item->shape().translated(item->d_ptr->sceneTransform.dx(),
+                                                                item->d_ptr->sceneTransform.dy())
+                                     : item->d_ptr->sceneTransform.map(item->shape());
+            exposeRect &= mappedShape.controlPointRect();
+        }
+
+        // Process children behind
+        for (i = 0; i < item->d_ptr->children.size(); ++i) {
+            QGraphicsItem *child = item->d_ptr->children.at(i);
+            if (wasDirtyParentSceneTransform)
+                child->d_ptr->dirtySceneTransform = 1;
+            if (!(child->d_ptr->flags & QGraphicsItem::ItemStacksBehindParent))
+                break;
+            if (itemIsFullyTransparent && !(child->d_ptr->flags & QGraphicsItem::ItemIgnoresParentOpacity))
+                continue;
+            recursive_items_helper(child, exposeRect, intersector, items, viewTransform,
+                                   mode, order, opacity);
+        }
+    }
+
+    // Process item
+    if (processItem)
+        items->append(item);
+
+    // Process children in front
+    if (itemHasChildren) {
+        for (; i < item->d_ptr->children.size(); ++i) {
+            QGraphicsItem *child = item->d_ptr->children.at(i);
+            if (wasDirtyParentSceneTransform)
+                child->d_ptr->dirtySceneTransform = 1;
+            if (itemIsFullyTransparent && !(child->d_ptr->flags & QGraphicsItem::ItemIgnoresParentOpacity))
+                continue;
+            recursive_items_helper(child, exposeRect, intersector, items, viewTransform,
+                                   mode, order, opacity);
+        }
+    }
+}
+
+void QGraphicsSceneIndexPrivate::init()
+{
+    if (!scene)
+        return;
+
+    QObject::connect(scene, SIGNAL(sceneRectChanged(const QRectF&)),
+                     q_func(), SLOT(updateSceneRect(const QRectF&)));
+}
+
+/*!
+    Constructs an abstract scene index for a given \a scene.
+*/
+QGraphicsSceneIndex::QGraphicsSceneIndex(QGraphicsScene *scene)
+: QObject(*new QGraphicsSceneIndexPrivate(scene), scene)
+{
+    d_func()->init();
+}
+
+/*!
+    \internal
+*/
+QGraphicsSceneIndex::QGraphicsSceneIndex(QGraphicsSceneIndexPrivate &dd, QGraphicsScene *scene)
+    : QObject(dd, scene)
+{
+    d_func()->init();
+}
+
+/*!
+    Destroys the scene index.
+*/
+QGraphicsSceneIndex::~QGraphicsSceneIndex()
+{
+
+}
+
+/*!
+    Returns the scene of this index.
+*/
+QGraphicsScene* QGraphicsSceneIndex::scene() const
+{
+    Q_D(const QGraphicsSceneIndex);
+    return d->scene;
+}
+
+/*!
+    \fn QList<QGraphicsItem *> QGraphicsSceneIndex::items(const QPointF &pos,
+    Qt::ItemSelectionMode mode, Qt::SortOrder order, const QTransform
+    &deviceTransform) const
+
+    Returns all visible items that, depending on \a mode, are at the specified
+    \a pos and return a list sorted using \a order.
+
+    The default value for \a mode is Qt::IntersectsItemShape; all items whose
+    exact shape intersects with \a pos are returned.
+
+    \a deviceTransform is the transformation apply to the view.
+
+    This method use the estimation of the index (estimateItems) and refine the
+    list to get an exact result. If you want to implement your own refinement
+    algorithm you can reimplement this method.
+
+    \sa estimateItems()
+
+*/
+QList<QGraphicsItem *> QGraphicsSceneIndex::items(const QPointF &pos, Qt::ItemSelectionMode mode,
+                                                  Qt::SortOrder order, const QTransform &deviceTransform) const
+{
+
+    Q_D(const QGraphicsSceneIndex);
+    QList<QGraphicsItem *> itemList;
+    d->pointIntersector->scenePoint = pos;
+    d->items_helper(QRectF(pos, QSizeF(1, 1)), d->pointIntersector, &itemList, deviceTransform, mode, order);
+    return itemList;
+}
+
+/*!
+    \fn QList<QGraphicsItem *> QGraphicsSceneIndex::items(const QRectF &rect,
+    Qt::ItemSelectionMode mode, Qt::SortOrder order, const QTransform
+    &deviceTransform) const
+
+    \overload
+
+    Returns all visible items that, depending on \a mode, are either inside or
+    intersect with the specified \a rect and return a list sorted using \a order.
+
+    The default value for \a mode is Qt::IntersectsItemShape; all items whose
+    exact shape intersects with or is contained by \a rect are returned.
+
+    \a deviceTransform is the transformation apply to the view.
+
+    This method use the estimation of the index (estimateItems) and refine
+    the list to get an exact result. If you want to implement your own
+    refinement algorithm you can reimplement this method.
+
+    \sa estimateItems()
+
+*/
+QList<QGraphicsItem *> QGraphicsSceneIndex::items(const QRectF &rect, Qt::ItemSelectionMode mode,
+                                                  Qt::SortOrder order, const QTransform &deviceTransform) const
+{
+    Q_D(const QGraphicsSceneIndex);
+    QRectF exposeRect = rect;
+    _q_adjustRect(&exposeRect);
+    QList<QGraphicsItem *> itemList;
+    d->rectIntersector->sceneRect = rect;
+    d->items_helper(exposeRect, d->rectIntersector, &itemList, deviceTransform, mode, order);
+    return itemList;
+}
+
+/*!
+    \fn QList<QGraphicsItem *> QGraphicsSceneIndex::items(const QPolygonF
+    &polygon, Qt::ItemSelectionMode mode, Qt::SortOrder order, const
+    QTransform &deviceTransform) const
+
+    \overload
+
+    Returns all visible items that, depending on \a mode, are either inside or
+    intersect with the specified \a polygon and return a list sorted using \a order.
+
+    The default value for \a mode is Qt::IntersectsItemShape; all items whose
+    exact shape intersects with or is contained by \a polygon are returned.
+
+    \a deviceTransform is the transformation apply to the view.
+
+    This method use the estimation of the index (estimateItems) and refine
+    the list to get an exact result. If you want to implement your own
+    refinement algorithm you can reimplement this method.
+
+    \sa estimateItems()
+
+*/
+QList<QGraphicsItem *> QGraphicsSceneIndex::items(const QPolygonF &polygon, Qt::ItemSelectionMode mode,
+                                                  Qt::SortOrder order, const QTransform &deviceTransform) const
+{
+    Q_D(const QGraphicsSceneIndex);
+    QList<QGraphicsItem *> itemList;
+    QRectF exposeRect = polygon.boundingRect();
+    _q_adjustRect(&exposeRect);
+    QPainterPath path;
+    path.addPolygon(polygon);
+    d->pathIntersector->scenePath = path;
+    d->items_helper(exposeRect, d->pathIntersector, &itemList, deviceTransform, mode, order);
+    return itemList;
+}
+
+/*!
+    \fn QList<QGraphicsItem *> QGraphicsSceneIndex::items(const QPainterPath
+    &path, Qt::ItemSelectionMode mode, Qt::SortOrder order, const QTransform
+    &deviceTransform) const
+
+    \overload
+
+    Returns all visible items that, depending on \a mode, are either inside or
+    intersect with the specified \a path and return a list sorted using \a order.
+
+    The default value for \a mode is Qt::IntersectsItemShape; all items whose
+    exact shape intersects with or is contained by \a path are returned.
+
+    \a deviceTransform is the transformation apply to the view.
+
+    This method use the estimation of the index (estimateItems) and refine
+    the list to get an exact result. If you want to implement your own
+    refinement algorithm you can reimplement this method.
+
+    \sa estimateItems()
+
+*/
+QList<QGraphicsItem *> QGraphicsSceneIndex::items(const QPainterPath &path, Qt::ItemSelectionMode mode,
+                                                  Qt::SortOrder order, const QTransform &deviceTransform) const
+{
+    Q_D(const QGraphicsSceneIndex);
+    QList<QGraphicsItem *> itemList;
+    QRectF exposeRect = path.controlPointRect();
+    _q_adjustRect(&exposeRect);
+    d->pathIntersector->scenePath = path;
+    d->items_helper(exposeRect, d->pathIntersector, &itemList, deviceTransform, mode, order);
+    return itemList;
+}
+
+/*!
+    This virtual function return an estimation of items at position \a point.
+    This method return a list sorted using \a order.
+*/
+QList<QGraphicsItem *> QGraphicsSceneIndex::estimateItems(const QPointF &point, Qt::SortOrder order) const
+{
+    return estimateItems(QRectF(point, QSize(1, 1)), order);
+}
+
+QList<QGraphicsItem *> QGraphicsSceneIndex::estimateTopLevelItems(const QRectF &rect, Qt::SortOrder order) const
+{
+    Q_D(const QGraphicsSceneIndex);
+    Q_UNUSED(rect);
+    QGraphicsScenePrivate *scened = d->scene->d_func();
+    scened->ensureSortedTopLevelItems();
+    if (order == Qt::AscendingOrder) {
+        QList<QGraphicsItem *> sorted;
+        for (int i = scened->topLevelItems.size() - 1; i >= 0; --i)
+            sorted << scened->topLevelItems.at(i);
+        return sorted;
+    }
+    return scened->topLevelItems;
+}
+
+/*!
+    \fn virtual QList<QGraphicsItem *>
+    QGraphicsSceneIndex::estimateItems(const QRectF &rect, Qt::SortOrder
+    order, const QTransform &deviceTransform) const = 0
+
+    This pure virtual function return an estimation of items in the \a rect.
+    This method return a list sorted using \a order.
+
+    \a deviceTransform is the transformation apply to the view.
+*/
+
+/*!
+    \fn virtual QList<QGraphicsItem *>
+    QGraphicsSceneIndex::items(Qt::SortOrder order = Qt::AscendingOrder) const
+    = 0; This pure virtual function all items in the index and sort them using
+    \a order.
+*/
+
+
+/*!
+    Notifies the index that the scene's scene rect has changed. \a rect
+    is thew new scene rect.
+
+    \sa QGraphicsScene::sceneRect()
+*/
+void QGraphicsSceneIndex::updateSceneRect(const QRectF &rect)
+{
+    Q_UNUSED(rect);
+}
+
+/*!
+    This virtual function removes all items in the scene index.
+*/
+void QGraphicsSceneIndex::clear()
+{
+    const QList<QGraphicsItem *> allItems = items();
+    for (int i = 0 ; i < allItems.size(); ++i)
+        removeItem(allItems.at(i));
+}
+
+/*!
+    \fn virtual void QGraphicsSceneIndex::addItem(QGraphicsItem *item) = 0
+
+    This pure virtual function inserts an \a item to the scene index.
+
+    \sa removeItem(), deleteItem()
+*/
+
+/*!
+    \fn virtual void QGraphicsSceneIndex::removeItem(QGraphicsItem *item) = 0
+
+    This pure virtual function removes an \a item to the scene index.
+
+    \sa addItem(), deleteItem()
+*/
+
+/*!
+    This method is called when an \a item has been deleted.
+    The default implementation call removeItem. Be carefull,
+    if your implementation of removeItem use pure virtual method
+    of QGraphicsItem like boundingRect(), then you should reimplement
+    this method.
+
+    \sa addItem(), removeItem()
+*/
+void QGraphicsSceneIndex::deleteItem(QGraphicsItem *item)
+{
+    removeItem(item);
+}
+
+/*!
+    This virtual function is called by QGraphicsItem to notify the index
+    that some part of the \a item 's state changes. By reimplementing this
+    function, your can react to a change, and in some cases, (depending on \a
+    change,) adjustments in the index can be made.
+
+    \a change is the parameter of the item that is changing. \a value is the
+    value that changed; the type of the value depends on \a change.
+
+    The default implementation does nothing.
+
+    \sa QGraphicsItem::GraphicsItemChange
+*/
+void QGraphicsSceneIndex::itemChange(const QGraphicsItem *item, QGraphicsItem::GraphicsItemChange change, const QVariant &value)
+{
+    Q_UNUSED(item);
+    Q_UNUSED(change);
+    Q_UNUSED(value);
+}
+
+/*!
+    Notify the index for a geometry change of an \a item.
+
+    \sa QGraphicsItem::prepareGeometryChange()
+*/
+void QGraphicsSceneIndex::prepareBoundingRectChange(const QGraphicsItem *item)
+{
+    Q_UNUSED(item);
+}
+
+QT_END_NAMESPACE
+
+#include "moc_qgraphicssceneindex_p.cpp"
+
+#endif // QT_NO_GRAPHICSVIEW
diff --git a/src/gui/graphicsview/qgraphicssceneindex_p.h b/src/gui/graphicsview/qgraphicssceneindex_p.h
new file mode 100644
index 0000000..8cf0294
--- /dev/null
+++ b/src/gui/graphicsview/qgraphicssceneindex_p.h
@@ -0,0 +1,182 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QGRAPHICSSCENEINDEX_H
+#define QGRAPHICSSCENEINDEX_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of qapplication_*.cpp, qwidget*.cpp and qfiledialog.cpp.  This header
+// file may change from version to version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qgraphicsscene_p.h"
+#include "qgraphicsscene.h"
+#include <private/qobject_p.h>
+
+#include <QtCore/qnamespace.h>
+#include <QtCore/qobject.h>
+#include <QtGui/qtransform.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+#if !defined(QT_NO_GRAPHICSVIEW) || (QT_EDITION & QT_MODULE_GRAPHICSVIEW) != QT_MODULE_GRAPHICSVIEW
+
+class QGraphicsSceneIndexIntersector;
+class QGraphicsSceneIndexPointIntersector;
+class QGraphicsSceneIndexRectIntersector;
+class QGraphicsSceneIndexPathIntersector;
+class QGraphicsSceneIndexPrivate;
+class QPointF;
+class QRectF;
+template<typename T> class QList;
+
+class Q_AUTOTEST_EXPORT QGraphicsSceneIndex : public QObject
+{
+    Q_OBJECT
+
+public:
+    QGraphicsSceneIndex(QGraphicsScene *scene = 0);
+    virtual ~QGraphicsSceneIndex();
+
+    QGraphicsScene *scene() const;
+
+    virtual QList<QGraphicsItem *> items(Qt::SortOrder order = Qt::AscendingOrder) const  = 0;
+    virtual QList<QGraphicsItem *> items(const QPointF &pos, Qt::ItemSelectionMode mode,
+                                         Qt::SortOrder order, const QTransform &deviceTransform = QTransform()) const;
+    virtual QList<QGraphicsItem *> items(const QRectF &rect, Qt::ItemSelectionMode mode,
+                                         Qt::SortOrder order, const QTransform &deviceTransform = QTransform()) const;
+    virtual QList<QGraphicsItem *> items(const QPolygonF &polygon, Qt::ItemSelectionMode mode,
+                                         Qt::SortOrder order, const QTransform &deviceTransform = QTransform()) const;
+    virtual QList<QGraphicsItem *> items(const QPainterPath &path, Qt::ItemSelectionMode mode,
+                                         Qt::SortOrder order, const QTransform &deviceTransform = QTransform()) const;
+    virtual QList<QGraphicsItem *> estimateItems(const QPointF &point, Qt::SortOrder order) const;
+    virtual QList<QGraphicsItem *> estimateItems(const QRectF &rect, Qt::SortOrder order) const = 0;
+    virtual QList<QGraphicsItem *> estimateTopLevelItems(const QRectF &, Qt::SortOrder order) const;
+
+protected Q_SLOTS:
+    virtual void updateSceneRect(const QRectF &rect);
+
+protected:
+    virtual void clear();
+    virtual void addItem(QGraphicsItem *item) = 0;
+    virtual void removeItem(QGraphicsItem *item) = 0;
+    virtual void deleteItem(QGraphicsItem *item);
+
+    virtual void itemChange(const QGraphicsItem *item, QGraphicsItem::GraphicsItemChange, const QVariant &value);
+    virtual void prepareBoundingRectChange(const QGraphicsItem *item);
+
+    QGraphicsSceneIndex(QGraphicsSceneIndexPrivate &dd, QGraphicsScene *scene);
+
+    friend class QGraphicsScene;
+    friend class QGraphicsScenePrivate;
+    friend class QGraphicsItem;
+    friend class QGraphicsItemPrivate;
+    friend class QGraphicsSceneBspTreeIndex;
+private:
+    Q_DISABLE_COPY(QGraphicsSceneIndex)
+    Q_DECLARE_PRIVATE(QGraphicsSceneIndex)
+};
+
+class QGraphicsSceneIndexPrivate : public QObjectPrivate
+{
+    Q_DECLARE_PUBLIC(QGraphicsSceneIndex)
+public:
+    QGraphicsSceneIndexPrivate(QGraphicsScene *scene);
+    ~QGraphicsSceneIndexPrivate();
+
+    void init();
+    static bool itemCollidesWithPath(const QGraphicsItem *item, const QPainterPath &path, Qt::ItemSelectionMode mode);
+
+    void recursive_items_helper(QGraphicsItem *item, QRectF exposeRect,
+                                QGraphicsSceneIndexIntersector *intersector, QList<QGraphicsItem *> *items,
+                                const QTransform &viewTransform,
+                                Qt::ItemSelectionMode mode, Qt::SortOrder order, qreal parentOpacity = 1.0) const;
+    inline void items_helper(const QRectF &rect, QGraphicsSceneIndexIntersector *intersector,
+                             QList<QGraphicsItem *> *items, const QTransform &viewTransform,
+                             Qt::ItemSelectionMode mode, Qt::SortOrder order) const;
+
+    QGraphicsScene *scene;
+    QGraphicsSceneIndexPointIntersector *pointIntersector;
+    QGraphicsSceneIndexRectIntersector *rectIntersector;
+    QGraphicsSceneIndexPathIntersector *pathIntersector;
+};
+
+inline void QGraphicsSceneIndexPrivate::items_helper(const QRectF &rect, QGraphicsSceneIndexIntersector *intersector,
+                                                     QList<QGraphicsItem *> *items, const QTransform &viewTransform,
+                                                     Qt::ItemSelectionMode mode, Qt::SortOrder order) const
+{
+    Q_Q(const QGraphicsSceneIndex);
+    const QList<QGraphicsItem *> tli = q->estimateTopLevelItems(rect, Qt::DescendingOrder);
+    for (int i = 0; i < tli.size(); ++i)
+        recursive_items_helper(tli.at(i), rect, intersector, items, viewTransform, mode, order);
+    if (order == Qt::AscendingOrder) {
+        const int n = items->size();
+        for (int i = 0; i < n / 2; ++i)
+            items->swap(i, n - i - 1);
+    }
+}
+
+class QGraphicsSceneIndexIntersector
+{
+public:
+    QGraphicsSceneIndexIntersector() { }
+    virtual ~QGraphicsSceneIndexIntersector() { }
+    virtual bool intersect(const QGraphicsItem *item, const QRectF &exposeRect, Qt::ItemSelectionMode mode,
+                           const QTransform &deviceTransform) const = 0;
+};
+
+#endif // QT_NO_GRAPHICSVIEW
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QGRAPHICSSCENEINDEX_H
diff --git a/src/gui/graphicsview/qgraphicsscenelinearindex.cpp b/src/gui/graphicsview/qgraphicsscenelinearindex.cpp
new file mode 100644
index 0000000..5e6ac30
--- /dev/null
+++ b/src/gui/graphicsview/qgraphicsscenelinearindex.cpp
@@ -0,0 +1,62 @@
+/*!
+    \class QGraphicsSceneLinearIndex
+    \brief The QGraphicsSceneLinearIndex class provides an implementation of
+    a linear indexing algorithm for discovering items in QGraphicsScene.
+    \since 4.6
+    \ingroup multimedia
+    \ingroup graphicsview-api
+    \mainclass
+    \internal
+
+    QGraphicsSceneLinearIndex index is default linear implementation to discover items.
+    It basically store all items in a list and return them to the scene.
+
+    \sa QGraphicsScene, QGraphicsView, QGraphicsSceneIndex, QGraphicsSceneBspTreeIndex
+*/
+
+#include <private/qgraphicsscenelinearindex_p.h>
+
+/*!
+    \fn QGraphicsSceneLinearIndex::QGraphicsSceneLinearIndex(QGraphicsScene *scene = 0):
+
+    Construct a linear index for the given \a scene.
+*/
+
+/*!
+    \fn QList<QGraphicsItem *> QGraphicsSceneLinearIndex::items(Qt::SortOrder order = Qt::AscendingOrder) const;
+
+    Return all items in the index and sort them using \a order.
+*/
+
+
+/*!
+    \fn virtual QList<QGraphicsItem *> QGraphicsSceneLinearIndex::estimateItems(const QRectF &rect, Qt::SortOrder order) const;
+
+    Returns an estimation visible items that are either inside or
+    intersect with the specified \a rect and return a list sorted using \a order.
+*/
+
+/*!
+    \fn QRectF QGraphicsSceneLinearIndex::indexedRect() const;
+    \reimp
+    Return the rect indexed by the the index.
+*/
+
+/*!
+    \fn void QGraphicsSceneLinearIndex::clear();
+    \reimp
+    Clear the all the BSP index.
+*/
+
+/*!
+    \fn virtual void QGraphicsSceneLinearIndex::addItem(QGraphicsItem *item);
+
+    Add the \a item into the index.
+*/
+
+/*!
+    \fn virtual void QGraphicsSceneLinearIndex::removeItem(QGraphicsItem *item);
+
+    Add the \a item from the index.
+*/
+
diff --git a/src/gui/graphicsview/qgraphicsscenelinearindex_p.h b/src/gui/graphicsview/qgraphicsscenelinearindex_p.h
new file mode 100644
index 0000000..56dde3a
--- /dev/null
+++ b/src/gui/graphicsview/qgraphicsscenelinearindex_p.h
@@ -0,0 +1,109 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QGRAPHICSSCENELINEARINDEX_H
+#define QGRAPHICSSCENELINEARINDEX_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of other Qt classes.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtCore/qlist.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+#if !defined(QT_NO_GRAPHICSVIEW) || (QT_EDITION & QT_MODULE_GRAPHICSVIEW) != QT_MODULE_GRAPHICSVIEW
+
+#include <QtCore/qrect.h>
+#include <QtCore/qlist.h>
+#include <QtGui/qgraphicsitem.h>
+#include <private/qgraphicssceneindex_p.h>
+
+class Q_AUTOTEST_EXPORT QGraphicsSceneLinearIndex : public QGraphicsSceneIndex
+{
+    Q_OBJECT
+
+public:
+    QGraphicsSceneLinearIndex(QGraphicsScene *scene = 0) : QGraphicsSceneIndex(scene)
+    { }
+
+    QList<QGraphicsItem *> items(Qt::SortOrder order = Qt::AscendingOrder) const
+    { Q_UNUSED(order); return m_items; }
+
+    virtual QList<QGraphicsItem *> estimateItems(const QRectF &rect, Qt::SortOrder order) const
+    {
+        Q_UNUSED(rect);
+        Q_UNUSED(order);
+        return m_items;
+    }
+
+protected :
+    virtual void clear()
+    { m_items.clear(); }
+
+    virtual void addItem(QGraphicsItem *item)
+    { m_items << item; }
+
+    virtual void removeItem(QGraphicsItem *item)
+    { m_items.removeOne(item); }
+
+private:
+    QList<QGraphicsItem*> m_items;
+};
+
+#endif // QT_NO_GRAPHICSVIEW
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QGRAPHICSSCENELINEARINDEX_H
diff --git a/src/gui/graphicsview/qgraphicsview.cpp b/src/gui/graphicsview/qgraphicsview.cpp
index 3b29552..3a8a696 100644
--- a/src/gui/graphicsview/qgraphicsview.cpp
+++ b/src/gui/graphicsview/qgraphicsview.cpp
@@ -813,19 +813,9 @@ QRegion QGraphicsViewPrivate::mapToViewRegion(const QGraphicsItem *item, const Q
     return item->boundingRegion(itv) & itv.mapRect(rect).toAlignedRect();
 }
 
-// QRectF::intersects() returns false always if either the source or target
-// rectangle's width or height are 0. This works around that problem.
-static inline QRectF adjustedItemBoundingRect(const QGraphicsItem *item)
-{
-    Q_ASSERT(item);
-    QRectF boundingRect(item->boundingRect());
-    if (!boundingRect.width())
-        boundingRect.adjust(-0.00001, 0, 0.00001, 0);
-    if (!boundingRect.height())
-        boundingRect.adjust(0, -0.00001, 0, 0.00001);
-    return boundingRect;
-}
-
+/*!
+    \internal
+*/
 void QGraphicsViewPrivate::processPendingUpdates()
 {
     if (!scene)
@@ -850,13 +840,29 @@ void QGraphicsViewPrivate::processPendingUpdates()
     dirtyRegion = QRegion();
 }
 
+static inline bool intersectsViewport(const QRect &r, int width, int height)
+{ return !(r.left() > width) && !(r.right() < 0) && !(r.top() >= height) && !(r.bottom() < 0); }
+
+static inline bool containsViewport(const QRect &r, int width, int height)
+{ return r.left() <= 0 && r.top() <= 0 && r.right() >= width - 1 && r.bottom() >= height - 1; }
+
+static inline void QRect_unite(QRect *rect, const QRect &other)
+{
+    if (rect->isEmpty()) {
+        *rect = other;
+    } else {
+        rect->setCoords(qMin(rect->left(), other.left()), qMin(rect->top(), other.top()),
+                        qMax(rect->right(), other.right()), qMax(rect->bottom(), other.bottom()));
+    }
+}
+
 bool QGraphicsViewPrivate::updateRegion(const QRegion &r)
 {
     if (fullUpdatePending || viewportUpdateMode == QGraphicsView::NoViewportUpdate || r.isEmpty())
         return false;
 
     const QRect boundingRect = r.boundingRect();
-    if (!boundingRect.intersects(viewport->rect()))
+    if (!intersectsViewport(boundingRect, viewport->width(), viewport->height()))
         return false; // Update region outside viewport.
 
     switch (viewportUpdateMode) {
@@ -865,8 +871,8 @@ bool QGraphicsViewPrivate::updateRegion(const QRegion &r)
         viewport->update();
         break;
     case QGraphicsView::BoundingRectViewportUpdate:
-        dirtyBoundingRect |= boundingRect;
-        if (dirtyBoundingRect.contains(viewport->rect())) {
+        QRect_unite(&dirtyBoundingRect, boundingRect);
+        if (containsViewport(dirtyBoundingRect, viewport->width(), viewport->height())) {
             fullUpdatePending = true;
             viewport->update();
         }
@@ -893,7 +899,7 @@ bool QGraphicsViewPrivate::updateRegion(const QRegion &r)
 bool QGraphicsViewPrivate::updateRect(const QRect &r)
 {
     if (fullUpdatePending || viewportUpdateMode == QGraphicsView::NoViewportUpdate
-        || !r.intersects(viewport->rect())) {
+        || !intersectsViewport(r, viewport->width(), viewport->height())) {
         return false;
     }
 
@@ -903,8 +909,8 @@ bool QGraphicsViewPrivate::updateRect(const QRect &r)
         viewport->update();
         break;
     case QGraphicsView::BoundingRectViewportUpdate:
-        dirtyBoundingRect |= r;
-        if (dirtyBoundingRect.contains(viewport->rect())) {
+        QRect_unite(&dirtyBoundingRect, r);
+        if (containsViewport(dirtyBoundingRect, viewport->width(), viewport->height())) {
             fullUpdatePending = true;
             viewport->update();
         }
@@ -955,47 +961,32 @@ extern QPainterPath qt_regionToPath(const QRegion &region);
     is at risk of painting 1 pixel outside the bounding rect. Therefore we
     must search for items with an adjustment of (-1, -1, 1, 1).
 */
-QList<QGraphicsItem *> QGraphicsViewPrivate::findItems(const QRegion &exposedRegion, bool *allItems) const
+QList<QGraphicsItem *> QGraphicsViewPrivate::findItems(const QRegion &exposedRegion, bool *allItems,
+                                                       const QTransform &viewTransform) const
 {
     Q_Q(const QGraphicsView);
 
     // Step 1) If all items are contained within the expose region, then
-    // return a list of all visible items.
+    // return a list of all visible items. ### the scene's growing bounding
+    // rect does not take into account untransformable items.
     const QRectF exposedRegionSceneBounds = q->mapToScene(exposedRegion.boundingRect().adjusted(-1, -1, 1, 1))
                                             .boundingRect();
     if (exposedRegionSceneBounds.contains(scene->d_func()->growingItemsBoundingRect)) {
         Q_ASSERT(allItems);
         *allItems = true;
 
-        // All items are guaranteed within the exposed region, don't bother using the index.
-        QList<QGraphicsItem *> itemList(scene->items());
-        int i = 0;
-        while (i < itemList.size()) {
-            const QGraphicsItem *item = itemList.at(i);
-            // But we only want to include items that are visible
-            // The following check is basically the same as item->d_ptr->isInvisible(), except
-            // that we don't check whether the item clips children to shape or propagates its
-            // opacity (we loop through all items, so those checks are wrong in this context).
-            if (!item->isVisible() || item->d_ptr->isClippedAway() || item->d_ptr->isFullyTransparent())
-                itemList.removeAt(i);
-            else
-                ++i;
-        }
-
-        // Sort the items.
-        QGraphicsScenePrivate::sortItems(&itemList, Qt::DescendingOrder, scene->d_func()->sortCacheEnabled);
-        return itemList;
+        // All items are guaranteed within the exposed region.
+        return scene->items(Qt::DescendingOrder);
     }
 
     // Step 2) If the expose region is a simple rect and the view is only
     // translated or scaled, search for items using
     // QGraphicsScene::items(QRectF).
-    bool simpleRectLookup =  (scene->d_func()->largestUntransformableItem.isNull()
-                              && exposedRegion.numRects() == 1 && matrix.type() <= QTransform::TxScale);
+    bool simpleRectLookup =  exposedRegion.numRects() == 1 && matrix.type() <= QTransform::TxScale;
     if (simpleRectLookup) {
-        return scene->d_func()->items_helper(exposedRegionSceneBounds,
-                                             Qt::IntersectsItemBoundingRect,
-                                             Qt::DescendingOrder);
+        return scene->items(exposedRegionSceneBounds,
+                            Qt::IntersectsItemBoundingRect,
+                            Qt::DescendingOrder, viewTransform);
     }
 
     // If the region is complex or the view has a complex transform, adjust
@@ -1005,16 +996,9 @@ QList<QGraphicsItem *> QGraphicsViewPrivate::findItems(const QRegion &exposedReg
     foreach (const QRect &r, exposedRegion.rects())
         adjustedRegion += r.adjusted(-1, -1, 1, 1);
 
-    const QPainterPath exposedPath(qt_regionToPath(adjustedRegion));
-    if (scene->d_func()->largestUntransformableItem.isNull()) {
-        const QPainterPath exposedScenePath(q->mapToScene(exposedPath));
-        return scene->d_func()->items_helper(exposedScenePath,
-                                             Qt::IntersectsItemBoundingRect,
-                                             Qt::DescendingOrder);
-    }
-
-    // NB! Path must be in viewport coordinates.
-    return itemsInArea(exposedPath, Qt::IntersectsItemBoundingRect, Qt::DescendingOrder);
+    const QPainterPath exposedScenePath(q->mapToScene(qt_regionToPath(adjustedRegion)));
+    return scene->items(exposedScenePath, Qt::IntersectsItemBoundingRect,
+                        Qt::DescendingOrder, viewTransform);
 }
 
 /*!
@@ -1915,7 +1899,12 @@ void QGraphicsView::fitInView(const QRectF &rect, Qt::AspectRatioMode aspectRati
 void QGraphicsView::fitInView(const QGraphicsItem *item, Qt::AspectRatioMode aspectRatioMode)
 {
     QPainterPath path = item->isClipped() ? item->clipPath() : item->shape();
-    fitInView(item->sceneTransform().map(path).boundingRect(), aspectRatioMode);
+    if (item->d_ptr->hasTranslateOnlySceneTransform()) {
+        path.translate(item->d_ptr->sceneTransform.dx(), item->d_ptr->sceneTransform.dy());
+        fitInView(path.boundingRect(), aspectRatioMode);
+    } else {
+        fitInView(item->d_ptr->sceneTransform.map(path).boundingRect(), aspectRatioMode);
+    }
 }
 
 /*!
@@ -1941,6 +1930,8 @@ void QGraphicsView::fitInView(const QGraphicsItem *item, Qt::AspectRatioMode asp
 void QGraphicsView::render(QPainter *painter, const QRectF &target, const QRect &source,
                            Qt::AspectRatioMode aspectRatioMode)
 {
+    // ### Switch to using the recursive rendering algorithm instead.
+
     Q_D(QGraphicsView);
     if (!d->scene || !(painter && painter->isActive()))
         return;
@@ -2037,69 +2028,6 @@ QList<QGraphicsItem *> QGraphicsView::items() const
 }
 
 /*!
-    Returns all items in the area \a path, which is in viewport coordinates,
-    also taking untransformable items into consideration. This function is
-    considerably slower than just checking the scene directly. There is
-    certainly room for improvement.
-*/
-QList<QGraphicsItem *> QGraphicsViewPrivate::itemsInArea(const QPainterPath &path,
-                                                         Qt::ItemSelectionMode mode,
-                                                         Qt::SortOrder order) const
-{
-    Q_Q(const QGraphicsView);
-
-    // Determine the size of the largest untransformable subtree of children
-    // mapped to scene coordinates.
-    QRectF untr = scene->d_func()->largestUntransformableItem;
-    QRectF ltri = matrix.inverted().mapRect(untr);
-    ltri.adjust(-untr.width(), -untr.height(), untr.width(), untr.height());
-
-    QRectF rect = path.controlPointRect();
-
-    // Find all possible items in the relevant area.
-    // ### Improve this algorithm; it might be searching a too large area.
-    QRectF adjustedRect = q->mapToScene(rect.adjusted(-1, -1, 1, 1).toRect()).boundingRect();
-    adjustedRect.adjust(-ltri.width(), -ltri.height(), ltri.width(), ltri.height());
-
-    // First build a (potentially large) list of all items in the vicinity
-    // that might be untransformable.
-    QList<QGraphicsItem *> allCandidates = scene->d_func()->estimateItemsInRect(adjustedRect);
-
-    // Then find the minimal list of items that are inside \a path, and
-    // convert it to a set.
-    QList<QGraphicsItem *> regularCandidates = scene->items(q->mapToScene(path), mode);
-    QSet<QGraphicsItem *> candSet = QSet<QGraphicsItem *>::fromList(regularCandidates);
-
-    QTransform viewMatrix = q->viewportTransform();
-
-    QList<QGraphicsItem *> result;
-
-    // Run through all candidates and keep all items that are in candSet, or
-    // are untransformable and collide with \a path. ### We can improve this
-    // algorithm.
-    QList<QGraphicsItem *>::Iterator it = allCandidates.begin();
-    while (it != allCandidates.end()) {
-        QGraphicsItem *item = *it;
-        if (item->d_ptr->itemIsUntransformable()) {
-            // Check if this untransformable item collides with the
-            // original selection rect.
-            QTransform itemTransform = item->deviceTransform(viewMatrix);
-            if (QGraphicsScenePrivate::itemCollidesWithPath(item, itemTransform.inverted().map(path), mode))
-                result << item;
-        } else {
-            if (candSet.contains(item))
-                result << item;
-        }
-        ++it;
-    }
-
-    // ### Insertion sort would be faster.
-    if (order != Qt::SortOrder(-1))
-        QGraphicsScenePrivate::sortItems(&result, order, scene->d_func()->sortCacheEnabled);
-    return result;
-}
-
-/*!
     Returns a list of all the items at the position \a pos in the view. The
     items are listed in descending Z order (i.e., the first item in the list
     is the top-most item, and the last item is the bottom-most item). \a pos
@@ -2118,17 +2046,22 @@ QList<QGraphicsItem *> QGraphicsView::items(const QPoint &pos) const
     Q_D(const QGraphicsView);
     if (!d->scene)
         return QList<QGraphicsItem *>();
-    if (d->scene->d_func()->largestUntransformableItem.isNull()) {
-        if ((d->identityMatrix || d->matrix.type() <= QTransform::TxScale)) {
-            QTransform xinv = viewportTransform().inverted();
-            return d->scene->items(xinv.mapRect(QRectF(pos.x(), pos.y(), 1, 1)));
-        }
-        return d->scene->items(mapToScene(pos.x(), pos.y(), 1, 1));
+    // ### Unify these two, and use the items(QPointF) version in
+    // QGraphicsScene instead. The scene items function could use the viewport
+    // transform to map the point to a rect/polygon.
+    if ((d->identityMatrix || d->matrix.type() <= QTransform::TxScale)) {
+        // Use the rect version
+        QTransform xinv = viewportTransform().inverted();
+        return d->scene->items(xinv.mapRect(QRectF(pos.x(), pos.y(), 1, 1)),
+                               Qt::IntersectsItemShape,
+                               Qt::AscendingOrder,
+                               viewportTransform());
     }
-
-    QPainterPath path;
-    path.addRect(QRectF(pos.x(), pos.y(), 1, 1));
-    return d->itemsInArea(path);
+    // Use the polygon version
+    return d->scene->items(mapToScene(pos.x(), pos.y(), 1, 1),
+                           Qt::IntersectsItemShape,
+                           Qt::AscendingOrder,
+                           viewportTransform());
 }
 
 /*!
@@ -2155,12 +2088,7 @@ QList<QGraphicsItem *> QGraphicsView::items(const QRect &rect, Qt::ItemSelection
     Q_D(const QGraphicsView);
     if (!d->scene)
         return QList<QGraphicsItem *>();
-    if (d->scene->d_func()->largestUntransformableItem.isNull())
-        return d->scene->items(mapToScene(rect), mode);
-
-    QPainterPath path;
-    path.addRect(rect);
-    return d->itemsInArea(path);
+    return d->scene->items(mapToScene(rect), mode, Qt::AscendingOrder, viewportTransform());
 }
 
 /*!
@@ -2188,13 +2116,7 @@ QList<QGraphicsItem *> QGraphicsView::items(const QPolygon &polygon, Qt::ItemSel
     Q_D(const QGraphicsView);
     if (!d->scene)
         return QList<QGraphicsItem *>();
-    if (d->scene->d_func()->largestUntransformableItem.isNull())
-        return d->scene->items(mapToScene(polygon), mode);
-
-    QPainterPath path;
-    path.addPolygon(polygon);
-    path.closeSubpath();
-    return d->itemsInArea(path);
+    return d->scene->items(mapToScene(polygon), mode, Qt::AscendingOrder, viewportTransform());
 }
 
 /*!
@@ -2214,9 +2136,7 @@ QList<QGraphicsItem *> QGraphicsView::items(const QPainterPath &path, Qt::ItemSe
     Q_D(const QGraphicsView);
     if (!d->scene)
         return QList<QGraphicsItem *>();
-    if (d->scene->d_func()->largestUntransformableItem.isNull())
-        return d->scene->items(mapToScene(path), mode);
-    return d->itemsInArea(path);
+    return d->scene->items(mapToScene(path), mode, Qt::AscendingOrder, viewportTransform());
 }
 
 /*!
@@ -3169,7 +3089,8 @@ void QGraphicsView::mouseMoveEvent(QMouseEvent *event)
             selectionArea.addPolygon(mapToScene(d->rubberBandRect));
             selectionArea.closeSubpath();
             if (d->scene)
-                d->scene->setSelectionArea(selectionArea, d->rubberBandSelectionMode);
+                d->scene->setSelectionArea(selectionArea, d->rubberBandSelectionMode,
+                                           viewportTransform());
             return;
         }
     } else
@@ -3382,8 +3303,7 @@ void QGraphicsView::paintEvent(QPaintEvent *event)
     } else {
         // Find all exposed items
         bool allItems = false;
-        QList<QGraphicsItem *> itemList = d->findItems(d->exposedRegion, &allItems);
-
+        QList<QGraphicsItem *> itemList = d->findItems(d->exposedRegion, &allItems, viewTransform);
         if (!itemList.isEmpty()) {
             // Generate the style options.
             const int numItems = itemList.size();
diff --git a/src/gui/graphicsview/qgraphicsview_p.h b/src/gui/graphicsview/qgraphicsview_p.h
index 09d842d..28b4bdc 100644
--- a/src/gui/graphicsview/qgraphicsview_p.h
+++ b/src/gui/graphicsview/qgraphicsview_p.h
@@ -63,7 +63,7 @@
 
 QT_BEGIN_NAMESPACE
 
-class QGraphicsViewPrivate : public QAbstractScrollAreaPrivate
+class Q_AUTOTEST_EXPORT QGraphicsViewPrivate : public QAbstractScrollAreaPrivate
 {
     Q_DECLARE_PUBLIC(QGraphicsView)
 public:
@@ -84,10 +84,6 @@ public:
     qint64 horizontalScroll() const;
     qint64 verticalScroll() const;
 
-    QList<QGraphicsItem *> itemsInArea(const QPainterPath &path,
-                                       Qt::ItemSelectionMode mode = Qt::IntersectsItemShape,
-                                       Qt::SortOrder = Qt::AscendingOrder) const;
-
     QPointF mousePressItemPoint;
     QPointF mousePressScenePoint;
     QPoint mousePressViewPoint;
@@ -176,7 +172,8 @@ public:
     bool updateSceneSlotReimplementedChecked;
     QRegion exposedRegion;
 
-    QList<QGraphicsItem *> findItems(const QRegion &exposedRegion, bool *allItems) const;
+    QList<QGraphicsItem *> findItems(const QRegion &exposedRegion, bool *allItems,
+                                     const QTransform &viewTransform) const;
 
     QPointF mapToScene(const QPointF &point) const;
     QRectF mapToScene(const QRectF &rect) const;
diff --git a/src/gui/itemviews/qabstractitemview.cpp b/src/gui/itemviews/qabstractitemview.cpp
index dd84304..5f347dd 100644
--- a/src/gui/itemviews/qabstractitemview.cpp
+++ b/src/gui/itemviews/qabstractitemview.cpp
@@ -3883,28 +3883,35 @@ bool QAbstractItemViewPrivate::openEditor(const QModelIndex &index, QEvent *even
 
 QPixmap QAbstractItemViewPrivate::renderToPixmap(const QModelIndexList &indexes, QRect *r) const
 {
+    Q_ASSERT(r);
     Q_Q(const QAbstractItemView);
-    QRect rect = q->visualRect(indexes.at(0));
+    QRect &rect = *r;
+    const QRect viewportRect = viewport->rect();
     QList<QRect> rects;
+    QModelIndexList paintedIndexes;
     for (int i = 0; i < indexes.count(); ++i) {
-        rects.append(q->visualRect(indexes.at(i)));
-        rect |= rects.at(i);
+        const QModelIndex &index = indexes.at(i);
+        const QRect current = q->visualRect(index);
+        if (current.intersects(viewportRect)) {
+            paintedIndexes += index;
+            rects += current;
+            rect |= current;
+        }
     }
-    rect = rect.intersected(viewport->rect());
-    if (rect.width() <= 0 || rect.height() <= 0)
+    rect = rect.intersected(viewportRect);
+    if (rect.isEmpty())
         return QPixmap();
-    QImage image(rect.size(), QImage::Format_ARGB32_Premultiplied);
-    image.fill(0);
-    QPainter painter(&image);
+    QPixmap pixmap(rect.size());
+    pixmap.fill(Qt::transparent);
+    QPainter painter(&pixmap);
     QStyleOptionViewItemV4 option = viewOptionsV4();
     option.state |= QStyle::State_Selected;
-    for (int j = 0; j < indexes.count(); ++j) {
+    for (int j = 0; j < paintedIndexes.count(); ++j) {
+        const QModelIndex &current = paintedIndexes.at(j);
         option.rect = QRect(rects.at(j).topLeft() - rect.topLeft(), rects.at(j).size());
-        delegateForIndex(indexes.at(j))->paint(&painter, option, indexes.at(j));
+        delegateForIndex(current)->paint(&painter, option, current);
     }
-    painter.end();
-    if (r) *r = rect;
-    return QPixmap::fromImage(image);
+    return pixmap;
 }
 
 void QAbstractItemViewPrivate::selectAll(QItemSelectionModel::SelectionFlags command)
diff --git a/src/gui/itemviews/qabstractitemview_p.h b/src/gui/itemviews/qabstractitemview_p.h
index 00647f6..7443d50 100644
--- a/src/gui/itemviews/qabstractitemview_p.h
+++ b/src/gui/itemviews/qabstractitemview_p.h
@@ -221,7 +221,7 @@ public:
     void clearOrRemove();
     void checkPersistentEditorFocus();
 
-    QPixmap renderToPixmap(const QModelIndexList &indexes, QRect *r = 0) const;
+    QPixmap renderToPixmap(const QModelIndexList &indexes, QRect *r) const;
 
     inline QPoint offset() const {
         const Q_Q(QAbstractItemView);
diff --git a/src/gui/itemviews/qlistview.cpp b/src/gui/itemviews/qlistview.cpp
index 4652b91..6ff516a 100644
--- a/src/gui/itemviews/qlistview.cpp
+++ b/src/gui/itemviews/qlistview.cpp
@@ -1633,14 +1633,16 @@ QRegion QListView::visualRegionForSelection(const QItemSelection &selection) con
 QModelIndexList QListView::selectedIndexes() const
 {
     Q_D(const QListView);
-    QModelIndexList viewSelected;
-    QModelIndexList modelSelected;
-    if (d->selectionModel)
-        modelSelected = d->selectionModel->selectedIndexes();
-    for (int i = 0; i < modelSelected.count(); ++i) {
-        QModelIndex index = modelSelected.at(i);
+    if (!d->selectionModel)
+        return QModelIndexList();
+
+    QModelIndexList viewSelected = d->selectionModel->selectedIndexes();
+    for (int i = 0; i < viewSelected.count(); ++i) {
+        const QModelIndex &index = viewSelected.at(i);
         if (!isIndexHidden(index) && index.parent() == d->root && index.column() == d->column)
-            viewSelected.append(index);
+            ++i;
+        else
+            viewSelected.removeAt(i);
     }
     return viewSelected;
 }
diff --git a/src/gui/itemviews/qtableview.cpp b/src/gui/itemviews/qtableview.cpp
index c676237..2009499 100644
--- a/src/gui/itemviews/qtableview.cpp
+++ b/src/gui/itemviews/qtableview.cpp
@@ -1528,6 +1528,8 @@ void QTableView::updateGeometries()
             ++columnsInViewport;
         }
     }
+    columnsInViewport = qMax(columnsInViewport, 1); //there must be always at least 1 column
+
     if (horizontalScrollMode() == QAbstractItemView::ScrollPerItem) {
         const int visibleColumns = columnCount - d->horizontalHeader->hiddenSectionCount();
         horizontalScrollBar()->setRange(0, visibleColumns - columnsInViewport);
@@ -1554,6 +1556,8 @@ void QTableView::updateGeometries()
             ++rowsInViewport;
         }
     }
+    rowsInViewport = qMax(rowsInViewport, 1); //there must be always at least 1 row
+
     if (verticalScrollMode() == QAbstractItemView::ScrollPerItem) {
         const int visibleRows = rowCount - d->verticalHeader->hiddenSectionCount();
         verticalScrollBar()->setRange(0, visibleRows - rowsInViewport);
@@ -2036,7 +2040,7 @@ void QTableView::scrollTo(const QModelIndex &index, ScrollHint hint)
         if (positionAtRight || hint == PositionAtCenter || positionAtLeft) {
             int hiddenSections = 0;
             if (d->horizontalHeader->sectionsHidden()) {
-                for (int s = horizontalIndex; s >= 0; --s) {
+                for (int s = horizontalIndex - 1; s >= 0; --s) {
                     int column = d->horizontalHeader->logicalIndex(s);
                     if (d->horizontalHeader->isSectionHidden(column))
                         ++hiddenSections;
@@ -2091,7 +2095,7 @@ void QTableView::scrollTo(const QModelIndex &index, ScrollHint hint)
         if (hint == PositionAtBottom || hint == PositionAtCenter || hint == PositionAtTop) {
             int hiddenSections = 0;
             if (d->verticalHeader->sectionsHidden()) {
-                for (int s = verticalIndex; s >= 0; --s) {
+                for (int s = verticalIndex - 1; s >= 0; --s) {
                     int row = d->verticalHeader->logicalIndex(s);
                     if (d->verticalHeader->isSectionHidden(row))
                         ++hiddenSections;
diff --git a/src/gui/kernel/qapplication_p.h b/src/gui/kernel/qapplication_p.h
index db77b07..90eaba0 100644
--- a/src/gui/kernel/qapplication_p.h
+++ b/src/gui/kernel/qapplication_p.h
@@ -158,17 +158,19 @@ inline QPointF QTabletDeviceData::scaleCoord(int coordX, int coordY,
                                             int outOriginY, int outExtentY) const
 {
     QPointF ret;
+
     if (sign(outExtentX) == sign(maxX))
-        ret.setX(((coordX - minX) * qAbs(outExtentX) / qAbs(qreal(maxX))) + outOriginX);
+        ret.setX(((coordX - minX) * qAbs(outExtentX) / qAbs(qreal(maxX - minX))) + outOriginX);
     else
-        ret.setX(((qAbs(maxX) - (coordX - minX)) * qAbs(outExtentX) / qAbs(qreal(maxX)))
+        ret.setX(((qAbs(maxX) - (coordX - minX)) * qAbs(outExtentX) / qAbs(qreal(maxX - minX)))
                  + outOriginX);
 
     if (sign(outExtentY) == sign(maxY))
-        ret.setY(((coordY - minY) * qAbs(outExtentY) / qAbs(qreal(maxY))) + outOriginY);
+        ret.setY(((coordY - minY) * qAbs(outExtentY) / qAbs(qreal(maxY - minY))) + outOriginY);
     else
-        ret.setY(((qAbs(maxY) - (coordY - minY)) * qAbs(outExtentY) / qAbs(qreal(maxY)))
+        ret.setY(((qAbs(maxY) - (coordY - minY)) * qAbs(outExtentY) / qAbs(qreal(maxY - minY)))
                  + outOriginY);
+
     return ret;
 }
 #endif
diff --git a/src/gui/kernel/qapplication_win.cpp b/src/gui/kernel/qapplication_win.cpp
index e0eda82..e0c62b7 100644
--- a/src/gui/kernel/qapplication_win.cpp
+++ b/src/gui/kernel/qapplication_win.cpp
@@ -2956,7 +2956,9 @@ bool QETWidget::translateMouseEvent(const MSG &msg)
     if (alienWidget && alienWidget->internalWinId())
         alienWidget = 0;
 
-    if (type == QEvent::MouseMove || type == QEvent::NonClientAreaMouseMove) {
+    if (type == QEvent::MouseMove || type == QEvent::NonClientAreaMouseMove
+            || type == QEvent::TabletMove) {
+
         if (!(state & Qt::MouseButtonMask))
             qt_button_down = 0;
 #ifndef QT_NO_CURSOR
@@ -3087,6 +3089,8 @@ bool QETWidget::translateMouseEvent(const MSG &msg)
                 popupButtonFocus = popupChild;
                 break;
             case QEvent::MouseButtonRelease:
+            case QEvent::TabletRelease:
+
                 releaseAfter = true;
                 break;
             default:
@@ -3324,17 +3328,19 @@ static void tabletInit(UINT wActiveCsr, HCTX hTab)
         tdd.minTanPressure = int(np.axMin);
         tdd.maxTanPressure = int(np.axMax);
 
-        ptrWTInfo(WTI_DEVICES + lc.lcDevice, DVC_X, &np);
-        tdd.minX = int(np.axMin);
-        tdd.maxX = int(np.axMax);
+        LOGCONTEXT lcMine;
+
+      	/* get default region */
+        ptrWTInfo(WTI_DEFCONTEXT, 0, &lcMine);
+
+        tdd.minX = 0;
+        tdd.maxX = int(lcMine.lcInExtX) - int(lcMine.lcInOrgX);
 
-        ptrWTInfo(WTI_DEVICES + lc.lcDevice, DVC_Y, &np);
-        tdd.minY = int(np.axMin);
-        tdd.maxY = int(np.axMax);
+        tdd.minY = 0;
+        tdd.maxY = int(lcMine.lcInExtY) - int(lcMine.lcInOrgY);
 
-        ptrWTInfo(WTI_DEVICES + lc.lcDevice, DVC_Z, &np);
-        tdd.minZ = int(np.axMin);
-        tdd.maxZ = int(np.axMax);
+        tdd.minZ = 0;
+        tdd.maxZ = int(lcMine.lcInExtZ) - int(lcMine.lcInOrgZ);
 
         int csr_type,
             csr_physid;
@@ -3444,13 +3450,34 @@ bool QETWidget::translateTabletEvent(const MSG &msg, PACKET *localPacketBuf,
         }
         QPoint globalPos(qRound(hiResGlobal.x()), qRound(hiResGlobal.y()));
 
+        if (t == QEvent::TabletPress)
+        {
+            qt_button_down = QApplication::widgetAt(globalPos);
+        }
+
         // make sure the tablet event get's sent to the proper widget...
-        QWidget *w = QApplication::widgetAt(globalPos);
+        QWidget *w = 0;
+
         if (qt_button_down)
             w = qt_button_down; // Pass it to the thing that's grabbed it.
+        else
+            w = QApplication::widgetAt(globalPos);
 
         if (!w)
             w = this;
+
+        if (t == QEvent::TabletRelease)
+        {
+            if (qt_win_ignoreNextMouseReleaseEvent) {
+                qt_win_ignoreNextMouseReleaseEvent = false;
+                if (qt_button_down && qt_button_down->internalWinId() == autoCaptureWnd) {
+                    releaseAutoCapture();
+                    qt_button_down = 0;
+                }
+            }
+
+        }
+
         QPoint localPos = w->mapFromGlobal(globalPos);
 #ifndef QT_NO_TABLETEVENT
         if (currentTabletPointer.currentDevice == QTabletEvent::Airbrush) {
diff --git a/src/gui/kernel/qmultitouch_mac.mm b/src/gui/kernel/qmultitouch_mac.mm
index 3fe85a9..3d2eae6 100644
--- a/src/gui/kernel/qmultitouch_mac.mm
+++ b/src/gui/kernel/qmultitouch_mac.mm
@@ -48,7 +48,7 @@ QT_BEGIN_NAMESPACE
 
 #ifdef QT_MAC_USE_COCOA
 
-QHash<int, QCocoaTouch*> QCocoaTouch::_currentTouches;
+QHash<qint64, QCocoaTouch*> QCocoaTouch::_currentTouches;
 QPointF QCocoaTouch::_screenReferencePos;
 QPointF QCocoaTouch::_trackpadReferencePos;
 int QCocoaTouch::_idAssignmentCount = 0;
@@ -62,7 +62,7 @@ QCocoaTouch::QCocoaTouch(NSTouch *nstouch)
 
     _touchPoint.setId(_idAssignmentCount++);
     _touchPoint.setPressure(1.0);
-    _identity = int([nstouch identity]);
+    _identity = qint64([nstouch identity]);
     _currentTouches.insert(_identity, this);
     updateTouchData(nstouch, NSTouchPhaseBegan);
 }
@@ -100,7 +100,7 @@ void QCocoaTouch::updateTouchData(NSTouch *nstouch, NSTouchPhase phase)
 
 QCocoaTouch *QCocoaTouch::findQCocoaTouch(NSTouch *nstouch)
 {
-    int identity = int([nstouch identity]);
+    qint64 identity = qint64([nstouch identity]);
     if (_currentTouches.contains(identity))
         return _currentTouches.value(identity);
     return 0;
diff --git a/src/gui/kernel/qmultitouch_mac_p.h b/src/gui/kernel/qmultitouch_mac_p.h
index 3fa8f6c..618e9ca 100644
--- a/src/gui/kernel/qmultitouch_mac_p.h
+++ b/src/gui/kernel/qmultitouch_mac_p.h
@@ -74,7 +74,7 @@ class QCocoaTouch
         static void setMouseInDraggingState(bool inDraggingState);
 
     private:
-        static QHash<int, QCocoaTouch*> _currentTouches;
+        static QHash<qint64, QCocoaTouch*> _currentTouches;
         static QPointF _screenReferencePos;
         static QPointF _trackpadReferencePos;
         static int _idAssignmentCount;
@@ -82,7 +82,7 @@ class QCocoaTouch
         static bool _updateInternalStateOnly;
 
         QTouchEvent::TouchPoint _touchPoint;
-        int _identity;
+        qint64 _identity;
 
         QCocoaTouch(NSTouch *nstouch);
         ~QCocoaTouch();
diff --git a/src/gui/widgets/qmainwindowlayout.cpp b/src/gui/widgets/qmainwindowlayout.cpp
index 541907e..3936a67 100644
--- a/src/gui/widgets/qmainwindowlayout.cpp
+++ b/src/gui/widgets/qmainwindowlayout.cpp
@@ -1629,9 +1629,6 @@ void QMainWindowLayout::animationFinished(QWidget *widget)
 
 #ifndef QT_NO_DOCKWIDGET
 #ifndef QT_NO_TABBAR
-        //it is important to set the current tab before applying the layout
-        //so that applyState will not try to counter the result of the animation
-        //by putting the item in negative space
         if (qobject_cast<QDockWidget*>(widget) != 0) {
             // info() might return null if the widget is destroyed while
             // animating but before the animationFinished signal is received.
@@ -1641,8 +1638,6 @@ void QMainWindowLayout::animationFinished(QWidget *widget)
 #endif
 #endif
 
-        applyState(layoutState, false);
-
         savedState.clear();
         currentGapPos.clear();
         pluggingWidget = 0;
diff --git a/src/gui/widgets/qspinbox.cpp b/src/gui/widgets/qspinbox.cpp
index e069a21..3933272 100644
--- a/src/gui/widgets/qspinbox.cpp
+++ b/src/gui/widgets/qspinbox.cpp
@@ -50,6 +50,7 @@
 #include <qdebug.h>
 
 #include <math.h>
+#include <float.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -823,8 +824,8 @@ void QDoubleSpinBox::setRange(double minimum, double maximum)
      Sets how many decimals the spinbox will use for displaying and
      interpreting doubles.
 
-     \warning The results might not be reliable with very high values
-     for \a decimals.
+     \warning The maximum value for \a decimals is DBL_MAX_10_EXP +
+     DBL_DIG (ie. 323) because of the limitations of the double type.
 
      Note: The maximum, minimum and value might change as a result of
      changing this property.
@@ -840,7 +841,7 @@ int QDoubleSpinBox::decimals() const
 void QDoubleSpinBox::setDecimals(int decimals)
 {
     Q_D(QDoubleSpinBox);
-    d->decimals = qMax(0, decimals);
+    d->decimals = qBound(0, decimals, DBL_MAX_10_EXP + DBL_DIG);
 
     setRange(minimum(), maximum()); // make sure values are rounded
     setValue(value());
diff --git a/tests/auto/auto.pro b/tests/auto/auto.pro
index 8252154..f6ff59d 100644
--- a/tests/auto/auto.pro
+++ b/tests/auto/auto.pro
@@ -152,6 +152,7 @@ SUBDIRS += _networkselftest \
 	   qgraphicspolygonitem \
 	   qgraphicsproxywidget \
            qgraphicsscene \
+           qgraphicssceneindex \
            qgraphicsview \
            qgraphicswidget \
 	   qgridlayout \
diff --git a/tests/auto/qfiledialog/tst_qfiledialog.cpp b/tests/auto/qfiledialog/tst_qfiledialog.cpp
index 8bb81e7..50cab0e 100644
--- a/tests/auto/qfiledialog/tst_qfiledialog.cpp
+++ b/tests/auto/qfiledialog/tst_qfiledialog.cpp
@@ -160,6 +160,7 @@ private slots:
     void task251321_sideBarHiddenEntries();
     void task251341_sideBarRemoveEntries();
     void task254490_selectFileMultipleTimes();
+    void task257579_sideBarWithNonCleanUrls();
 
 private:
     QByteArray userSettings;
@@ -2026,5 +2027,25 @@ void tst_QFiledialog::task254490_selectFileMultipleTimes()
     t->deleteLater();
 }
 
+void tst_QFiledialog::task257579_sideBarWithNonCleanUrls()
+{
+    QDir tempDir = QDir::temp();
+    QLatin1String dirname("autotest_task257579");
+    tempDir.rmdir(dirname); //makes sure it doesn't exist any more
+    QVERIFY(tempDir.mkdir(dirname));
+    QString url = QString::fromLatin1("%1/%2/..").arg(tempDir.absolutePath()).arg(dirname);
+    QNonNativeFileDialog fd;
+    fd.setSidebarUrls(QList<QUrl>() << QUrl::fromLocalFile(url));
+    QSidebar *sidebar = qFindChild<QSidebar*>(&fd, "sidebar");
+    QCOMPARE(sidebar->urls().count(), 1);
+    QVERIFY(sidebar->urls().first().toLocalFile() != url);
+    QCOMPARE(sidebar->urls().first().toLocalFile(), QDir::cleanPath(url));
+    QCOMPARE(sidebar->model()->index(0,0).data().toString(), tempDir.dirName());
+
+    //all tests are finished, we can remove the temporary dir
+    QVERIFY(tempDir.rmdir(dirname));
+}
+
+
 QTEST_MAIN(tst_QFiledialog)
 #include "tst_qfiledialog.moc"
diff --git a/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp b/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp
index 7552f18..4ca1b48 100644
--- a/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp
+++ b/tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp
@@ -231,6 +231,7 @@ private slots:
     void sorting_data();
     void sorting();
     void itemHasNoContents();
+    void hitTestUntransformableItem();
 
     // task specific tests below me
     void task141694_textItemEnsureVisible();
@@ -6580,6 +6581,7 @@ public:
 void tst_QGraphicsItem::update()
 {
     QGraphicsScene scene;
+    scene.setSceneRect(-100, -100, 200, 200);
     MyGraphicsView view(&scene);
 
     view.show();
@@ -6612,9 +6614,9 @@ void tst_QGraphicsItem::update()
     qApp->processEvents();
     QCOMPARE(item->repaints, 1);
     QCOMPARE(view.repaints, 1);
-    const QRect itemDeviceBoundingRect = item->deviceTransform(view.viewportTransform())
-                                         .mapRect(item->boundingRect()).toRect();
-    const QRegion expectedRegion = itemDeviceBoundingRect.adjusted(-2, -2, 2, 2);
+    QRect itemDeviceBoundingRect = item->deviceTransform(view.viewportTransform())
+                                                         .mapRect(item->boundingRect()).toRect();
+    QRegion expectedRegion = itemDeviceBoundingRect.adjusted(-2, -2, 2, 2);
     // The entire item's bounding rect (adjusted for antialiasing) should have been painted.
     QCOMPARE(view.paintedRegion, expectedRegion);
 
@@ -6625,6 +6627,90 @@ void tst_QGraphicsItem::update()
     qApp->processEvents();
     QCOMPARE(item->repaints, 0);
     QCOMPARE(view.repaints, 0);
+
+    // Make sure the area occupied by an item is repainted when hiding it.
+    view.reset();
+    item->repaints = 0;
+    item->update(); // Full update; all sub-sequent update requests are discarded.
+    item->hide(); // visible set to 0. ignoreVisible must be set to 1; the item won't be processed otherwise.
+    qApp->processEvents();
+    QCOMPARE(item->repaints, 0);
+    QCOMPARE(view.repaints, 1);
+    // The entire item's bounding rect (adjusted for antialiasing) should have been painted.
+    QCOMPARE(view.paintedRegion, expectedRegion);
+
+    // Make sure item is repainted when shown (after being hidden).
+    view.reset();
+    item->repaints = 0;
+    item->show();
+    qApp->processEvents();
+    QCOMPARE(item->repaints, 1);
+    QCOMPARE(view.repaints, 1);
+    // The entire item's bounding rect (adjusted for antialiasing) should have been painted.
+    QCOMPARE(view.paintedRegion, expectedRegion);
+
+    item->repaints = 0;
+    item->hide();
+    qApp->processEvents();
+    view.reset();
+    const QPointF originalPos = item->pos();
+    item->setPos(5000, 5000);
+    qApp->processEvents();
+    QCOMPARE(item->repaints, 0);
+    QCOMPARE(view.repaints, 0);
+    qApp->processEvents();
+
+    item->setPos(originalPos);
+    qApp->processEvents();
+    QCOMPARE(item->repaints, 0);
+    QCOMPARE(view.repaints, 0);
+    item->show();
+    qApp->processEvents();
+    QCOMPARE(item->repaints, 1);
+    QCOMPARE(view.repaints, 1);
+    // The entire item's bounding rect (adjusted for antialiasing) should have been painted.
+    QCOMPARE(view.paintedRegion, expectedRegion);
+
+    QGraphicsViewPrivate *viewPrivate = static_cast<QGraphicsViewPrivate *>(qt_widget_private(&view));
+    item->setPos(originalPos + QPoint(50, 50));
+    viewPrivate->updateAll();
+    QVERIFY(viewPrivate->fullUpdatePending);
+    QTest::qWait(50);
+    item->repaints = 0;
+    view.reset();
+    item->setPos(originalPos);
+    QTest::qWait(50);
+    qApp->processEvents();
+    QCOMPARE(item->repaints, 1);
+    QCOMPARE(view.repaints, 1);
+    QCOMPARE(view.paintedRegion, expectedRegion + expectedRegion.translated(50, 50));
+
+    // Make sure moving a parent item triggers an update on the children
+    // (even though the parent itself is outside the viewport).
+    QGraphicsRectItem *parent = new QGraphicsRectItem(0, 0, 10, 10);
+    parent->setPos(-400, 0);
+    item->setParentItem(parent);
+    item->setPos(400, 0);
+    scene.addItem(parent);
+    QTest::qWait(50);
+    itemDeviceBoundingRect = item->deviceTransform(view.viewportTransform())
+                                                   .mapRect(item->boundingRect()).toRect();
+    expectedRegion = itemDeviceBoundingRect.adjusted(-2, -2, 2, 2);
+    view.reset();
+    item->repaints = 0;
+    parent->translate(-400, 0);
+    qApp->processEvents();
+    QCOMPARE(item->repaints, 0);
+    QCOMPARE(view.repaints, 1);
+    QCOMPARE(view.paintedRegion, expectedRegion);
+    view.reset();
+    item->repaints = 0;
+    parent->translate(400, 0);
+    qApp->processEvents();
+    QCOMPARE(item->repaints, 1);
+    QCOMPARE(view.repaints, 1);
+    QCOMPARE(view.paintedRegion, expectedRegion);
+    QCOMPARE(view.paintedRegion, expectedRegion);
 }
 
 void tst_QGraphicsItem::setTransformProperties_data()
@@ -6837,9 +6923,11 @@ public:
             //Doesn't use the extended style option so the exposed rect is the boundingRect
             if (!(flags() & QGraphicsItem::ItemUsesExtendedStyleOption)) {
                 QCOMPARE(option->exposedRect, boundingRect());
+                QCOMPARE(option->matrix, QMatrix());
             } else {
                 QVERIFY(option->exposedRect != QRect());
                 QVERIFY(option->exposedRect != boundingRect());
+                QCOMPARE(option->matrix, sceneTransform().toAffine());
             }
         }
         QGraphicsRectItem::paint(painter, option, widget);
@@ -6861,6 +6949,8 @@ void tst_QGraphicsItem::itemUsesExtendedStyleOption()
     scene.addItem(rect);
     rect->setPos(200, 200);
     QGraphicsView view(&scene);
+    rect->startTrack = false;
+    view.show();
     QTest::qWait(500);
     rect->startTrack = true;
     rect->update(10, 10, 10, 10);
@@ -7069,5 +7159,55 @@ void tst_QGraphicsItem::itemHasNoContents()
     QCOMPARE(_paintedItems, QList<QGraphicsItem *>() << item2);
 }
 
+void tst_QGraphicsItem::hitTestUntransformableItem()
+{
+    QGraphicsScene scene;
+    scene.setSceneRect(-100, -100, 200, 200);
+
+    QGraphicsView view(&scene);
+    view.show();
+#ifdef Q_WS_X11
+    qt_x11_wait_for_window_manager(&view);
+#endif
+    QTest::qWait(100);
+
+    // Confuse the BSP with dummy items.
+    QGraphicsRectItem *dummy = new QGraphicsRectItem(0, 0, 20, 20);
+    dummy->setPos(-100, -100);
+    scene.addItem(dummy);
+    for (int i = 0; i < 100; ++i) {
+        QGraphicsItem *parent = dummy;
+        dummy = new QGraphicsRectItem(0, 0, 20, 20);
+        dummy->setPos(-100 + i, -100 + i);
+        dummy->setParentItem(parent);
+    }
+
+    QGraphicsRectItem *item1 = new QGraphicsRectItem(0, 0, 20, 20);
+    item1->setPos(-200, -200);
+
+    QGraphicsRectItem *item2 = new QGraphicsRectItem(0, 0, 20, 20);
+    item2->setFlag(QGraphicsItem::ItemIgnoresTransformations);
+    item2->setParentItem(item1);
+    item2->setPos(200, 200);
+
+    QGraphicsRectItem *item3 = new QGraphicsRectItem(0, 0, 20, 20);
+    item3->setParentItem(item2);
+    item3->setPos(80, 80);
+
+    scene.addItem(item1);
+    QTest::qWait(100);
+
+    QList<QGraphicsItem *> items = scene.items(QPointF(80, 80));
+    QCOMPARE(items.size(), 1);
+    QCOMPARE(items.at(0), static_cast<QGraphicsItem*>(item3));
+
+    scene.setItemIndexMethod(QGraphicsScene::NoIndex);
+    QTest::qWait(100);
+
+    items = scene.items(QPointF(80, 80));
+    QCOMPARE(items.size(), 1);
+    QCOMPARE(items.at(0), static_cast<QGraphicsItem*>(item3));
+}
+
 QTEST_MAIN(tst_QGraphicsItem)
 #include "tst_qgraphicsitem.moc"
diff --git a/tests/auto/qgraphicslayout/tst_qgraphicslayout.cpp b/tests/auto/qgraphicslayout/tst_qgraphicslayout.cpp
index 536c750..bca673f 100644
--- a/tests/auto/qgraphicslayout/tst_qgraphicslayout.cpp
+++ b/tests/auto/qgraphicslayout/tst_qgraphicslayout.cpp
@@ -687,7 +687,6 @@ void tst_QGraphicsLayout::ownership()
         delete top;
         //don't crash after that.
     }
-        
 }
 
 QTEST_MAIN(tst_QGraphicsLayout)
diff --git a/tests/auto/qgraphicsproxywidget/tst_qgraphicsproxywidget.cpp b/tests/auto/qgraphicsproxywidget/tst_qgraphicsproxywidget.cpp
index dbc4339..1d0663a 100644
--- a/tests/auto/qgraphicsproxywidget/tst_qgraphicsproxywidget.cpp
+++ b/tests/auto/qgraphicsproxywidget/tst_qgraphicsproxywidget.cpp
@@ -178,6 +178,7 @@ private slots:
     void windowFlags_data();
     void windowFlags();
     void comboboxWindowFlags();
+    void updateAndDelete();
     void inputMethod();
 };
 
@@ -3218,6 +3219,44 @@ void tst_QGraphicsProxyWidget::comboboxWindowFlags()
     QVERIFY((static_cast<QGraphicsWidget *>(popupProxy)->windowFlags() & Qt::Popup) == Qt::Popup);
 }
 
+void tst_QGraphicsProxyWidget::updateAndDelete()
+{
+    QGraphicsScene scene;
+    QGraphicsProxyWidget *proxy = scene.addWidget(new QPushButton("Hello World"));
+    View view(&scene);
+    view.show();
+#ifdef Q_WS_X11
+    qt_x11_wait_for_window_manager(&view);
+#endif
+    QTest::qWait(200);
+
+    const QRect itemDeviceBoundingRect = proxy->deviceTransform(view.viewportTransform())
+                                         .mapRect(proxy->boundingRect()).toRect();
+    const QRegion expectedRegion = itemDeviceBoundingRect.adjusted(-2, -2, 2, 2);
+
+    view.npaints = 0;
+    view.paintEventRegion = QRegion();
+
+    // Update and hide.
+    proxy->update();
+    proxy->hide();
+    QTest::qWait(50);
+    QCOMPARE(view.npaints, 1);
+    QCOMPARE(view.paintEventRegion, expectedRegion);
+
+    proxy->show();
+    QTest::qWait(50);
+    view.npaints = 0;
+    view.paintEventRegion = QRegion();
+
+    // Update and delete.
+    proxy->update();
+    delete proxy;
+    QTest::qWait(50);
+    QCOMPARE(view.npaints, 1);
+    QCOMPARE(view.paintEventRegion, expectedRegion);
+}
+
 class InputMethod_LineEdit : public QLineEdit
 {
     bool event(QEvent *e)
@@ -3252,7 +3291,7 @@ void tst_QGraphicsProxyWidget::inputMethod()
 
         if (i)
             lineEdit->setFocus();
-            
+
         lineEdit->inputMethodEvents = 0;
         QInputMethodEvent event;
         qApp->sendEvent(proxy, &event);
diff --git a/tests/auto/qgraphicsscene/tst_qgraphicsscene.cpp b/tests/auto/qgraphicsscene/tst_qgraphicsscene.cpp
index d325f0f..e9d6f1d 100644
--- a/tests/auto/qgraphicsscene/tst_qgraphicsscene.cpp
+++ b/tests/auto/qgraphicsscene/tst_qgraphicsscene.cpp
@@ -289,28 +289,46 @@ void tst_QGraphicsScene::construction()
 void tst_QGraphicsScene::sceneRect()
 {
     QGraphicsScene scene;
+    QSignalSpy sceneRectChanged(&scene, SIGNAL(sceneRectChanged(QRectF)));
     QCOMPARE(scene.sceneRect(), QRectF());
+    QCOMPARE(sceneRectChanged.count(), 0);
 
     QGraphicsItem *item = scene.addRect(QRectF(0, 0, 10, 10));
-    qApp->processEvents();
     item->setPos(-5, -5);
-    qApp->processEvents();
+    QCOMPARE(sceneRectChanged.count(), 0);
 
     QCOMPARE(scene.itemAt(0, 0), item);
     QCOMPARE(scene.itemAt(10, 10), (QGraphicsItem *)0);
+    QCOMPARE(sceneRectChanged.count(), 0);
+    QCOMPARE(scene.sceneRect(), QRectF(-5, -5, 10, 10));
+    QCOMPARE(sceneRectChanged.count(), 1);
+    QCOMPARE(sceneRectChanged.last().at(0).toRectF(), scene.sceneRect());
+
+    item->setPos(0, 0);
     QCOMPARE(scene.sceneRect(), QRectF(-5, -5, 15, 15));
+    QCOMPARE(sceneRectChanged.count(), 2);
+    QCOMPARE(sceneRectChanged.last().at(0).toRectF(), scene.sceneRect());
 
     scene.setSceneRect(-100, -100, 10, 10);
+    QCOMPARE(sceneRectChanged.count(), 3);
+    QCOMPARE(sceneRectChanged.last().at(0).toRectF(), scene.sceneRect());
 
     QCOMPARE(scene.itemAt(0, 0), item);
     QCOMPARE(scene.itemAt(10, 10), (QGraphicsItem *)0);
     QCOMPARE(scene.sceneRect(), QRectF(-100, -100, 10, 10));
+    item->setPos(10, 10);
+    QCOMPARE(scene.sceneRect(), QRectF(-100, -100, 10, 10));
+    QCOMPARE(sceneRectChanged.count(), 3);
+    QCOMPARE(sceneRectChanged.last().at(0).toRectF(), scene.sceneRect());
 
     scene.setSceneRect(QRectF());
 
-    QCOMPARE(scene.itemAt(0, 0), item);
-    QCOMPARE(scene.itemAt(10, 10), (QGraphicsItem *)0);
-    QCOMPARE(scene.sceneRect(), QRectF(-5, -5, 15, 15));
+    QCOMPARE(scene.itemAt(10, 10), item);
+    QCOMPARE(scene.itemAt(20, 20), (QGraphicsItem *)0);
+    QCOMPARE(sceneRectChanged.count(), 4);
+    QCOMPARE(scene.sceneRect(), QRectF(-5, -5, 25, 25));
+    QCOMPARE(sceneRectChanged.count(), 5);
+    QCOMPARE(sceneRectChanged.last().at(0).toRectF(), scene.sceneRect());
 }
 
 void tst_QGraphicsScene::itemIndexMethod()
@@ -399,8 +417,7 @@ void tst_QGraphicsScene::items()
             for (int x = minX; x < maxX; x += 100)
                 items << scene.addRect(QRectF(0, 0, 10, 10));
         }
-
-        QCOMPARE(scene.items(), items);
+        QCOMPARE(scene.items().size(), items.size());
         scene.itemAt(0, 0); // trigger indexing
 
         scene.removeItem(items.at(5));
@@ -415,6 +432,9 @@ void tst_QGraphicsScene::items()
         QGraphicsLineItem *l2 = scene.addLine(0, -5, 0, 5);
         QVERIFY(!l1->sceneBoundingRect().intersects(l2->sceneBoundingRect()));
         QVERIFY(!l2->sceneBoundingRect().intersects(l1->sceneBoundingRect()));
+        QList<QGraphicsItem *> items;
+        items<<l1<<l2;
+        QCOMPARE(scene.items().size(), items.size());
         QVERIFY(scene.items(-1, -1, 2, 2).contains(l1));
         QVERIFY(scene.items(-1, -1, 2, 2).contains(l2));
     }
@@ -2742,8 +2762,8 @@ void tst_QGraphicsScene::update()
     qRegisterMetaType<QList<QRectF> >("QList<QRectF>");
     QSignalSpy spy(&scene, SIGNAL(changed(QList<QRectF>)));
 
-    // When deleted, the item will lazy-remove itself
-    delete rect;
+    // We update the scene.
+    scene.update();
 
     // This function forces a purge, which will post an update signal
     scene.itemAt(0, 0);
diff --git a/tests/auto/qgraphicssceneindex/qgraphicssceneindex.pro b/tests/auto/qgraphicssceneindex/qgraphicssceneindex.pro
new file mode 100644
index 0000000..740a23e
--- /dev/null
+++ b/tests/auto/qgraphicssceneindex/qgraphicssceneindex.pro
@@ -0,0 +1,3 @@
+load(qttest_p4)
+SOURCES  += tst_qgraphicssceneindex.cpp
+
diff --git a/tests/auto/qgraphicssceneindex/tst_qgraphicssceneindex.cpp b/tests/auto/qgraphicssceneindex/tst_qgraphicssceneindex.cpp
new file mode 100644
index 0000000..3ce5b16
--- /dev/null
+++ b/tests/auto/qgraphicssceneindex/tst_qgraphicssceneindex.cpp
@@ -0,0 +1,271 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include <QtTest/QtTest>
+#include <QtGui/qgraphicsscene.h>
+#include <private/qgraphicsscenebsptreeindex_p.h>
+#include <private/qgraphicssceneindex_p.h>
+#include <private/qgraphicsscenelinearindex_p.h>
+
+//TESTED_CLASS=
+//TESTED_FILES=
+
+class tst_QGraphicsSceneIndex : public QObject
+{
+    Q_OBJECT
+public slots:
+    void initTestCase();
+
+private slots:
+    void customIndex_data();
+    void customIndex();
+    void scatteredItems_data();
+    void scatteredItems();
+    void overlappedItems_data();
+    void overlappedItems();
+    void movingItems_data();
+    void movingItems();
+    void connectedToSceneRectChanged();
+    void items();
+
+private:
+    void common_data();
+    QGraphicsSceneIndex *createIndex(const QString &name);
+};
+
+void tst_QGraphicsSceneIndex::initTestCase()
+{
+}
+
+void tst_QGraphicsSceneIndex::common_data()
+{
+    QTest::addColumn<QString>("indexMethod");
+
+    QTest::newRow("BSP") << QString("bsp");
+    QTest::newRow("Linear") << QString("linear");
+}
+
+QGraphicsSceneIndex *tst_QGraphicsSceneIndex::createIndex(const QString &indexMethod)
+{
+    QGraphicsSceneIndex *index = 0;
+    QGraphicsScene *scene = new QGraphicsScene();
+    if (indexMethod == "bsp")
+        index = new QGraphicsSceneBspTreeIndex(scene);
+
+    if (indexMethod == "linear")
+        index = new QGraphicsSceneLinearIndex(scene);
+
+    return index;
+}
+
+void tst_QGraphicsSceneIndex::customIndex_data()
+{
+    common_data();
+}
+
+void tst_QGraphicsSceneIndex::customIndex()
+{
+#if 0
+    QFETCH(QString, indexMethod);
+    QGraphicsSceneIndex *index = createIndex(indexMethod);
+
+    QGraphicsScene scene;
+    scene.setSceneIndex(index);
+
+    scene.addRect(0, 0, 30, 40);
+    QCOMPARE(scene.items(QRectF(0, 0, 10, 10)).count(), 1);
+#endif
+}
+
+void tst_QGraphicsSceneIndex::scatteredItems_data()
+{
+    common_data();
+}
+
+void tst_QGraphicsSceneIndex::scatteredItems()
+{
+    QFETCH(QString, indexMethod);
+
+    QGraphicsScene scene;
+#if 1
+    scene.setItemIndexMethod(indexMethod == "linear" ? QGraphicsScene::NoIndex : QGraphicsScene::BspTreeIndex);
+#else
+    QGraphicsSceneIndex *index = createIndex(indexMethod);
+    scene.setSceneIndex(index);
+#endif
+
+    for (int i = 0; i < 10; ++i)
+        scene.addRect(i*50, i*50, 40, 35);
+
+    QCOMPARE(scene.items(QPointF(5, 5)).count(), 1);
+    QCOMPARE(scene.items(QPointF(55, 55)).count(), 1);
+    QCOMPARE(scene.items(QPointF(-100, -100)).count(), 0);
+
+    QCOMPARE(scene.items(QRectF(0, 0, 10, 10)).count(), 1);
+    QCOMPARE(scene.items(QRectF(0, 0, 1000, 1000)).count(), 10);
+    QCOMPARE(scene.items(QRectF(-100, -1000, 0, 0)).count(), 0);
+}
+
+void tst_QGraphicsSceneIndex::overlappedItems_data()
+{
+    common_data();
+}
+
+void tst_QGraphicsSceneIndex::overlappedItems()
+{
+    QFETCH(QString, indexMethod);
+
+    QGraphicsScene scene;
+#if 1
+    scene.setItemIndexMethod(indexMethod == "linear" ? QGraphicsScene::NoIndex : QGraphicsScene::BspTreeIndex);
+#else
+    QGraphicsSceneIndex *index = createIndex(indexMethod);
+    scene.setSceneIndex(index);
+#endif
+
+    for (int i = 0; i < 10; ++i)
+        for (int j = 0; j < 10; ++j)
+            scene.addRect(i*50, j*50, 200, 200);
+
+    QCOMPARE(scene.items(QPointF(5, 5)).count(), 1);
+    QCOMPARE(scene.items(QPointF(55, 55)).count(), 4);
+    QCOMPARE(scene.items(QPointF(105, 105)).count(), 9);
+    QCOMPARE(scene.items(QPointF(-100, -100)).count(), 0);
+
+    QCOMPARE(scene.items(QRectF(0, 0, 1000, 1000)).count(), 100);
+    QCOMPARE(scene.items(QRectF(-100, -1000, 0, 0)).count(), 0);
+    QCOMPARE(scene.items(QRectF(0, 0, 200, 200)).count(), 16);
+    QCOMPARE(scene.items(QRectF(0, 0, 100, 100)).count(), 4);
+    QCOMPARE(scene.items(QRectF(0, 0, 1, 100)).count(), 2);
+    QCOMPARE(scene.items(QRectF(0, 0, 1, 1000)).count(), 10);
+}
+
+void tst_QGraphicsSceneIndex::movingItems_data()
+{
+    common_data();
+}
+
+void tst_QGraphicsSceneIndex::movingItems()
+{
+    QFETCH(QString, indexMethod);
+
+    QGraphicsScene scene;
+#if 1
+    scene.setItemIndexMethod(indexMethod == "linear" ? QGraphicsScene::NoIndex : QGraphicsScene::BspTreeIndex);
+#else
+    QGraphicsSceneIndex *index = createIndex(indexMethod);
+    scene.setSceneIndex(index);
+#endif
+
+    for (int i = 0; i < 10; ++i)
+        scene.addRect(i*50, i*50, 40, 35);
+
+    QGraphicsRectItem *box = scene.addRect(0, 0, 10, 10);
+    QCOMPARE(scene.items(QPointF(5, 5)).count(), 2);
+    QCOMPARE(scene.items(QPointF(-1, -1)).count(), 0);
+    QCOMPARE(scene.items(QRectF(0, 0, 5, 5)).count(), 2);
+
+    box->setPos(10, 10);
+    QCOMPARE(scene.items(QPointF(9, 9)).count(), 1);
+    QCOMPARE(scene.items(QPointF(15, 15)).count(), 2);
+    QCOMPARE(scene.items(QRectF(0, 0, 1, 1)).count(), 1);
+
+    box->setPos(-5, -5);
+    QCOMPARE(scene.items(QPointF(-1, -1)).count(), 1);
+    QCOMPARE(scene.items(QRectF(0, 0, 1, 1)).count(), 2);
+
+    QCOMPARE(scene.items(QRectF(0, 0, 1000, 1000)).count(), 11);
+}
+
+void tst_QGraphicsSceneIndex::connectedToSceneRectChanged()
+{
+
+    class MyScene : public QGraphicsScene
+    { public: using QGraphicsScene::receivers; };
+
+    MyScene scene; // Uses QGraphicsSceneBspTreeIndex by default.
+    QCOMPARE(scene.receivers(SIGNAL(sceneRectChanged(const QRectF&))), 1);
+
+    scene.setItemIndexMethod(QGraphicsScene::NoIndex); // QGraphicsSceneLinearIndex
+    QCOMPARE(scene.receivers(SIGNAL(sceneRectChanged(const QRectF&))), 1);
+}
+
+void tst_QGraphicsSceneIndex::items()
+{
+    QGraphicsScene scene;
+    QGraphicsItem *item1 = scene.addRect(0, 0, 10, 10);
+    QGraphicsItem *item2 = scene.addRect(10, 10, 10, 10);
+    QCOMPARE(scene.items().size(), 2);
+
+    // Move from unindexed items into bsp tree.
+    QTest::qWait(50);
+    QCOMPARE(scene.items().size(), 2);
+
+    // Add untransformable item.
+    QGraphicsItem *item3 = new QGraphicsRectItem(QRectF(20, 20, 10, 10));
+    item3->setFlag(QGraphicsItem::ItemIgnoresTransformations);
+    scene.addItem(item3);
+    QCOMPARE(scene.items().size(), 3);
+
+    // Move from unindexed items into untransformable items.
+    QTest::qWait(50);
+    QCOMPARE(scene.items().size(), 3);
+
+    // Move from untransformable items into unindexed items.
+    item3->setFlag(QGraphicsItem::ItemIgnoresTransformations, false);
+    QCOMPARE(scene.items().size(), 3);
+    QTest::qWait(50);
+    QCOMPARE(scene.items().size(), 3);
+
+    // Make all items untransformable.
+    item1->setFlag(QGraphicsItem::ItemIgnoresTransformations);
+    item2->setParentItem(item1);
+    item3->setParentItem(item2);
+    QCOMPARE(scene.items().size(), 3);
+
+    // Move from unindexed items into untransformable items.
+    QTest::qWait(50);
+    QCOMPARE(scene.items().size(), 3);
+}
+
+QTEST_MAIN(tst_QGraphicsSceneIndex)
+#include "tst_qgraphicssceneindex.moc"
diff --git a/tests/auto/qgraphicsview/tst_qgraphicsview.cpp b/tests/auto/qgraphicsview/tst_qgraphicsview.cpp
index 8b4ca4c..77ab977 100644
--- a/tests/auto/qgraphicsview/tst_qgraphicsview.cpp
+++ b/tests/auto/qgraphicsview/tst_qgraphicsview.cpp
@@ -64,6 +64,7 @@
 #include <QtGui/QStyle>
 #include <QtGui/QPushButton>
 #include <QtGui/QInputContext>
+#include <private/qgraphicsview_p.h>
 
 //TESTED_CLASS=
 //TESTED_FILES=
@@ -176,6 +177,7 @@ private slots:
     void transformationAnchor();
     void resizeAnchor();
     void viewportUpdateMode();
+    void viewportUpdateMode2();
     void acceptDrops();
     void optimizationFlags();
     void optimizationFlags_dontSavePainterState();
@@ -196,6 +198,8 @@ private slots:
     void mouseTracking2();
     void render();
     void exposeRegion();
+    void update_data();
+    void update();
     void inputMethodSensitivity();
     void inputContextReset();
 
@@ -374,6 +378,7 @@ void tst_QGraphicsView::interactive()
     QCOMPARE(item->events.size(), 0);
 
     QPoint itemPoint = view.mapFromScene(item->scenePos());
+
     QVERIFY(view.itemAt(itemPoint));
 
     for (int i = 0; i < 100; ++i) {
@@ -2109,12 +2114,12 @@ void tst_QGraphicsView::resizeAnchor()
             view.setResizeAnchor(QGraphicsView::AnchorViewCenter);
         }
         view.centerOn(0, 0);
-        QTest::qWait(100);
+        QTest::qWait(250);
 
         QPointF f = view.mapToScene(50, 50);
         QPointF center = view.mapToScene(view.viewport()->rect().center());
 
-        QTest::qWait(100);
+        QTest::qWait(250);
 
         for (int size = 200; size <= 400; size += 25) {
             view.resize(size, size);
@@ -2129,7 +2134,7 @@ void tst_QGraphicsView::resizeAnchor()
                 QVERIFY(qAbs(newCenter.x() - center.x()) < slack);
                 QVERIFY(qAbs(newCenter.y() - center.y()) < slack);
             }
-            QTest::qWait(100);
+            QTest::qWait(250);
         }
     }
 }
@@ -2231,6 +2236,52 @@ void tst_QGraphicsView::viewportUpdateMode()
     QCOMPARE(view.lastUpdateRegions.size(), 0);
 }
 
+void tst_QGraphicsView::viewportUpdateMode2()
+{
+    // Create a view with viewport rect equal to QRect(0, 0, 200, 200).
+    QGraphicsScene dummyScene;
+    CustomView view;
+    view.setViewportUpdateMode(QGraphicsView::BoundingRectViewportUpdate);
+    view.setScene(&dummyScene);
+    int left, top, right, bottom;
+    view.getContentsMargins(&left, &top, &right, &bottom);
+    view.resize(200 + left + right, 200 + top + bottom);
+    view.show();
+#ifdef Q_WS_X11
+    qt_x11_wait_for_window_manager(&view);
+#endif
+    QTest::qWait(300);
+    const QRect viewportRect = view.viewport()->rect();
+    QCOMPARE(viewportRect, QRect(0, 0, 200, 200));
+    QGraphicsViewPrivate *viewPrivate = static_cast<QGraphicsViewPrivate *>(qt_widget_private(&view));
+
+    QRect boundingRect;
+    const QRect rect1(0, 0, 10, 10);
+    QVERIFY(viewPrivate->updateRect(rect1));
+    QVERIFY(!viewPrivate->fullUpdatePending);
+    boundingRect |= rect1;
+    QCOMPARE(viewPrivate->dirtyBoundingRect, boundingRect);
+
+    const QRect rect2(50, 50, 10, 10);
+    QVERIFY(viewPrivate->updateRect(rect2));
+    QVERIFY(!viewPrivate->fullUpdatePending);
+    boundingRect |= rect2;
+    QCOMPARE(viewPrivate->dirtyBoundingRect, boundingRect);
+
+    const QRect rect3(190, 190, 10, 10);
+    QVERIFY(viewPrivate->updateRect(rect3));
+    QVERIFY(viewPrivate->fullUpdatePending);
+    boundingRect |= rect3;
+    QCOMPARE(viewPrivate->dirtyBoundingRect, boundingRect);
+
+    view.lastUpdateRegions.clear();
+    viewPrivate->processPendingUpdates();
+    QTest::qWait(50);
+    QCOMPARE(view.lastUpdateRegions.size(), 1);
+    // Note that we adjust by 2 for antialiasing.
+    QCOMPARE(view.lastUpdateRegions.at(0), QRegion(boundingRect.adjusted(-2, -2, 2, 2) & viewportRect));
+}
+
 void tst_QGraphicsView::acceptDrops()
 {
     QGraphicsView view;
@@ -2991,14 +3042,7 @@ void tst_QGraphicsView::embeddedViews()
     v2->QWidget::render(&actual);
     QTransform b = item->transform;
 
-#ifdef Q_WS_MAC
-    // We don't use shared painter on the Mac, so the
-    // transform should be exactly the same.
     QVERIFY(a == b);
-#else
-    QVERIFY(a != b);
-#endif
-
     delete v1;
 }
 
@@ -3095,7 +3139,7 @@ void tst_QGraphicsView::moveItemWhileScrolling()
 #ifdef Q_WS_X11
     qt_x11_wait_for_window_manager(&view);
 #endif
-    QTest::qWait(100);
+    QTest::qWait(200);
 
     view.lastPaintedRegion = QRegion();
     view.horizontalScrollBar()->setValue(view.horizontalScrollBar()->value() + 10);
@@ -3360,6 +3404,72 @@ void tst_QGraphicsView::exposeRegion()
     QCOMPARE(item->paints, 0);
 }
 
+void tst_QGraphicsView::update_data()
+{
+    // In view.viewport() coordinates. (viewport rect: QRect(0, 0, 200, 200))
+    QTest::addColumn<QRect>("updateRect");
+    QTest::newRow("empty") << QRect();
+    QTest::newRow("outside left") << QRect(-200, 0, 100, 100);
+    QTest::newRow("outside right") << QRect(400, 0 ,100, 100);
+    QTest::newRow("outside top") << QRect(0, -200, 100, 100);
+    QTest::newRow("outside bottom") << QRect(0, 400, 100, 100);
+    QTest::newRow("partially inside left") << QRect(-50, 0, 100, 100);
+    QTest::newRow("partially inside right") << QRect(-150, 0, 100, 100);
+    QTest::newRow("partially inside top") << QRect(0, -150, 100, 100);
+    QTest::newRow("partially inside bottom") << QRect(0, 150, 100, 100);
+    QTest::newRow("on topLeft edge") << QRect(-100, -100, 100, 100);
+    QTest::newRow("on topRight edge") << QRect(200, -100, 100, 100);
+    QTest::newRow("on bottomRight edge") << QRect(200, 200, 100, 100);
+    QTest::newRow("on bottomLeft edge") << QRect(-200, 200, 100, 100);
+    QTest::newRow("inside topLeft") << QRect(-99, -99, 100, 100);
+    QTest::newRow("inside topRight") << QRect(199, -99, 100, 100);
+    QTest::newRow("inside bottomRight") << QRect(199, 199, 100, 100);
+    QTest::newRow("inside bottomLeft") << QRect(-199, 199, 100, 100);
+    QTest::newRow("large1") << QRect(50, -100, 100, 400);
+    QTest::newRow("large2") << QRect(-100, 50, 400, 100);
+    QTest::newRow("large3") << QRect(-100, -100, 400, 400);
+    QTest::newRow("viewport rect") << QRect(0, 0, 200, 200);
+}
+
+void tst_QGraphicsView::update()
+{
+    QFETCH(QRect, updateRect);
+
+    // Create a view with viewport rect equal to QRect(0, 0, 200, 200).
+    QGraphicsScene dummyScene;
+    CustomView view;
+    view.setScene(&dummyScene);
+    int left, top, right, bottom;
+    view.getContentsMargins(&left, &top, &right, &bottom);
+    view.resize(200 + left + right, 200 + top + bottom);
+    view.show();
+#ifdef Q_WS_X11
+    qt_x11_wait_for_window_manager(&view);
+#endif
+    QTest::qWait(300);
+    const QRect viewportRect = view.viewport()->rect();
+    QCOMPARE(viewportRect, QRect(0, 0, 200, 200));
+
+    const bool intersects = updateRect.intersects(viewportRect);
+    QGraphicsViewPrivate *viewPrivate = static_cast<QGraphicsViewPrivate *>(qt_widget_private(&view));
+    QCOMPARE(viewPrivate->updateRect(updateRect), intersects);
+    QCOMPARE(viewPrivate->updateRegion(updateRect), intersects);
+
+    view.lastUpdateRegions.clear();
+    viewPrivate->processPendingUpdates();
+    QVERIFY(viewPrivate->dirtyRegion.isEmpty());
+    QVERIFY(viewPrivate->dirtyBoundingRect.isEmpty());
+    QTest::qWait(50);
+    if (!intersects) {
+        QVERIFY(view.lastUpdateRegions.isEmpty());
+    } else {
+        QCOMPARE(view.lastUpdateRegions.size(), 1);
+        // Note that we adjust by 2 for antialiasing.
+        QCOMPARE(view.lastUpdateRegions.at(0), QRegion(updateRect.adjusted(-2, -2, 2, 2) & viewportRect));
+    }
+    QVERIFY(!viewPrivate->fullUpdatePending);
+}
+
 void tst_QGraphicsView::inputMethodSensitivity()
 {
     QGraphicsScene scene;
diff --git a/tests/auto/qsqldatabase/tst_databases.h b/tests/auto/qsqldatabase/tst_databases.h
index 5b19023..9c8c313 100644
--- a/tests/auto/qsqldatabase/tst_databases.h
+++ b/tests/auto/qsqldatabase/tst_databases.h
@@ -105,7 +105,11 @@ inline static QString qTableName( const QString& prefix, QSqlDriver* driver = 0
 
 inline static bool testWhiteSpaceNames( const QString &name )
 {
-    return name != QLatin1String("QTDS7");
+/*    return name.startsWith( "QPSQL" )
+           || name.startsWith( "QODBC" )
+           || name.startsWith( "QSQLITE" )
+           || name.startsWith( "QMYSQL" );*/
+    return name != QLatin1String("QSQLITE2");
 }
 
 inline static QString toHex( const QString& binary )
@@ -246,10 +250,10 @@ public:
 
 //         addDb( "QODBC", "DRIVER={MySQL ODBC 3.51 Driver};SERVER=mysql5-nokia.trolltech.com.au;DATABASE=testdb", "testuser", "Ee4Gabf6_", "" );
 //         addDb( "QODBC", "DRIVER={MySQL ODBC 5.1 Driver};SERVER=mysql4-nokia.trolltech.com.au;DATABASE=testdb", "testuser", "Ee4Gabf6_", "" );
-//         addDb( "QODBC", "DRIVER={FreeTDS};SERVER=horsehead.nokia.troll.no;DATABASE=testdb;PORT=4101;UID=troll;PWD=trondk;TDS_Version=8.0", "troll", "trondk", "" );
-//         addDb( "QODBC", "DRIVER={FreeTDS};SERVER=silence.nokia.troll.no;DATABASE=testdb;PORT=2392;UID=troll;PWD=trond;TDS_Version=8.0", "troll", "trond", "" );
-//         addDb( "QODBC", "DRIVER={FreeTDS};SERVER=bq-winserv2003-x86-01.apac.nokia.com;DATABASE=testdb;PORT=1433;UID=testuser;PWD=Ee4Gabf6_;TDS_Version=8.0", "testuser", "Ee4Gabf6_", "" );
-//         addDb( "QODBC", "DRIVER={FreeTDS};SERVER=bq-winserv2008-x86-01.apac.nokia.com;DATABASE=testdb;PORT=1433;UID=testuser;PWD=Ee4Gabf6_;TDS_Version=8.0", "testuser", "Ee4Gabf6_", "" );
+//         addDb( "QODBC", "DRIVER={FreeTDS};SERVER=horsehead.nokia.troll.no;DATABASE=testdb;PORT=4101;UID=troll;PWD=trondk", "troll", "trondk", "" );
+//         addDb( "QODBC", "DRIVER={FreeTDS};SERVER=silence.nokia.troll.no;DATABASE=testdb;PORT=2392;UID=troll;PWD=trond", "troll", "trond", "" );
+//         addDb( "QODBC", "DRIVER={FreeTDS};SERVER=bq-winserv2003-x86-01.apac.nokia.com;DATABASE=testdb;PORT=1433;UID=testuser;PWD=Ee4Gabf6_;TDS_Version=8.0", "", "", "" );
+//         addDb( "QODBC", "DRIVER={FreeTDS};SERVER=bq-winserv2008-x86-01.apac.nokia.com;DATABASE=testdb;PORT=1433;UID=testuser;PWD=Ee4Gabf6_;TDS_Version=8.0", "", "", "" );
 //         addDb( "QTDS7", "testdb", "testuser", "Ee4Gabf6_", "bq-winserv2003" );
 //         addDb( "QTDS7", "testdb", "testuser", "Ee4Gabf6_", "bq-winserv2008" );
 //         addDb( "QODBC3", "DRIVER={SQL SERVER};SERVER=bq-winserv2003-x86-01.apac.nokia.com;DATABASE=testdb;PORT=1433", "testuser", "Ee4Gabf6_", "" );
diff --git a/tests/auto/qtableview/tst_qtableview.cpp b/tests/auto/qtableview/tst_qtableview.cpp
index ae023ba..6fa57f0 100644
--- a/tests/auto/qtableview/tst_qtableview.cpp
+++ b/tests/auto/qtableview/tst_qtableview.cpp
@@ -175,6 +175,8 @@ private slots:
     // task-specific tests:
     void task173773_updateVerticalHeader();
     void task227953_setRootIndex();
+    void task240266_veryBigColumn();
+    void task248688_autoScrollNavigation();
 
     void mouseWheel_data();
     void mouseWheel();
@@ -586,7 +588,7 @@ void tst_QTableView::keyboardNavigation()
     QModelIndex index = model.index(rowCount - 1, columnCount - 1);
     view.setCurrentIndex(index);
 
-    QApplication::instance()->processEvents();
+    QApplication::processEvents();
 
     int row = rowCount - 1;
     int column = columnCount - 1;
@@ -618,7 +620,7 @@ void tst_QTableView::keyboardNavigation()
         }
 
         QTest::keyClick(&view, key);
-        QApplication::instance()->processEvents();
+        QApplication::processEvents();
 
         QModelIndex index = model.index(row, column);
         QCOMPARE(view.currentIndex(), index);
@@ -3127,6 +3129,56 @@ void tst_QTableView::task227953_setRootIndex()
     QVERIFY(!tableView.verticalHeader()->isHidden());
 }
 
+void tst_QTableView::task240266_veryBigColumn()
+{
+    QTableView table;
+    table.setFixedSize(500, 300); //just to make sure we have the 2 first columns visible
+    QStandardItemModel model(1, 3);
+    table.setModel(&model);
+    table.setColumnWidth(0, 100); //normal column
+    table.setColumnWidth(1, 100); //normal column
+    table.setColumnWidth(2, 9000); //very big column
+    table.show();
+#ifdef Q_WS_X11
+    qt_x11_wait_for_window_manager(&view);
+#endif
+    QTest::qWait(100);
+
+    QScrollBar *scroll = table.horizontalScrollBar();
+    QCOMPARE(scroll->minimum(), 0);
+    QCOMPARE(scroll->maximum(), model.columnCount() - 1);
+    QCOMPARE(scroll->singleStep(), 1);
+    
+    //1 is not always a very correct value for pageStep. Ideally this should be dynamic.
+    //Maybe something for Qt 5 ;-)
+    QCOMPARE(scroll->pageStep(), 1);
+
+}
+
+void tst_QTableView::task248688_autoScrollNavigation()
+{
+    //we make sure that when navigating with the keyboard the view is correctly scrolled
+    //to the current item
+    QStandardItemModel model(16, 16);
+    QTableView view;
+    view.setModel(&model);
+
+	view.hideColumn(8);
+	view.hideRow(8);
+    view.show();
+    for (int r = 0; r < model.rowCount(); ++r) {
+        if (view.isRowHidden(r))
+            continue;
+        for (int c = 0; c < model.columnCount(); ++c) {
+            if (view.isColumnHidden(c))
+                continue;
+            QModelIndex index = model.index(r, c);
+            view.setCurrentIndex(index);
+            QVERIFY(view.viewport()->rect().contains(view.visualRect(index)));
+        }
+    }
+}
+
 
 void tst_QTableView::mouseWheel_data()
 {