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

Conflicts:
	src/corelib/kernel/kernel.pri
	src/corelib/kernel/qvariant_p.h
	src/corelib/tools/tools.pri
	src/gui/graphicsview/qgraphicsitem.cpp
	src/gui/graphicsview/qgraphicsitem.h
	src/gui/graphicsview/qgraphicswidget.h
	src/gui/gui.pro

16 files changed, 1419 insertions, 1015 deletions

diff --git a/src/gui/graphicsview/qgraphicsitem.cpp b/src/gui/graphicsview/qgraphicsitem.cpp
index 5ff2acf..b7e88f4 100644
--- a/src/gui/graphicsview/qgraphicsitem.cpp
+++ b/src/gui/graphicsview/qgraphicsitem.cpp
@@ -130,12 +130,18 @@
 
     \img graphicsview-parentchild.png
 
+    \section Transformation
+
     QGraphicsItem supports affine transformations in addition to its base
     position, pos(). To change the item's transformation, you can either pass
-    a transformation matrix to setTransform(), or call one of the convenience
-    functions rotate(), scale(), translate(), or shear(). Item transformations
-    accumulate from parent to child, so if both a parent and child item are
-    rotated 90 degrees, the child's total transformation will be 180 degrees.
+    a transformation matrix to setTransform(), or set the different transformation
+    properties (transformOrigin, x/y/zRotation, x/yScale, horizontal/verticalShear).
+    Note that setting the transformation matrix conflicts with using the properties.
+    Setting the properties will overwrite the transformation set with setTransform,
+    and using setTransform will reset the properties.
+
+    Item transformations accumulate from parent to child, so if both a parent and child
+    item are rotated 90 degrees, the child's total transformation will be 180 degrees.
     Similarly, if the item's parent is scaled to 2x its original size, its
     children will also be twice as large. An item's transformation does not
     affect its own local geometry; all geometry functions (e.g., contains(),
@@ -146,6 +152,22 @@
     and scenePos(), which returns its position in scene coordinates. To reset
     an item's matrix, call resetTransform().
 
+    The order you set the transformation properties does not affect the resulting transformation
+    The resulting transformation is always computed in the following order
+
+    \code
+    [Origin] [RotateX] [RotateY] [RotateZ] [Shear] [Scale] [-Origin]
+    \endcode
+
+    So the transformation is equivalent to the following code
+
+    \code
+    QTransform().translate(xOrigin, yOrigin).rotate(xRotation, Qt::XAxis).rotate(yRotation, Qt::YAxis).rotate(zRotation, Qt::ZAxis)
+                .shear(horizontalShear, verticalShear).scale(xScale, yScale).translate(-xOrigin, -yOrigin);
+    \endcode
+
+    \section Painting
+
     The paint() function is called by QGraphicsView to paint the item's
     contents. The item has no background or default fill of its own; whatever
     is behind the item will shine through all areas that are not explicitly
@@ -161,6 +183,8 @@
     high z-values. Stacking order applies to sibling items; parents are always
     drawn before their children.
 
+    \section Events
+
     QGraphicsItem receives events from QGraphicsScene through the virtual
     function sceneEvent(). This function distributes the most common events
     to a set of convenience event handlers:
@@ -186,6 +210,8 @@
     by the virtual function sceneEventFilter(). You can remove item
     event filters by calling removeSceneEventFilter().
 
+    \section Custom Data
+
     Sometimes it's useful to register custom data with an item, be it a custom
     item, or a standard item. You can call setData() on any item to store data
     in it using a key-value pair (the key being an integer, and the value is a
@@ -274,6 +300,15 @@
     this flag, the child will be stacked behind it. This flag is useful for
     drop shadow effects and for decoration objects that follow the parent
     item's geometry without drawing on top of it.
+
+    \value ItemUsesExtendedStyleOption The item makes use of either
+    QStyleOptionGraphicsItem::exposedRect or QStyleOptionGraphicsItem::matrix.
+    By default, the exposedRect is initialized to the item's boundingRect and
+    the matrix is untransformed. Enable this flag for more fine-grained values.
+    Note that QStyleOptionGraphicsItem::levelOfDetail is unaffected by this flag
+    and is always initialized to 1.
+    Use QStyleOptionGraphicsItem::levelOfDetailFromTransform for a more
+    fine-grained value.
 */
 
 /*!
@@ -329,16 +364,17 @@
 
     \value ItemTransformChange The item's transformation matrix changes. This
     notification is only sent when the item's local transformation matrix
-    changes (i.e., as a result of calling setTransform(), or one of the
-    convenience transformation functions, such as rotate()). The value
+    changes (i.e., as a result of calling setTransform(). The value
     argument is the new matrix (i.e., a QTransform); to get the old matrix,
-    call transform(). Do not call setTransform() or any of the transformation
-    convenience functions in itemChange() as this notification is delivered;
+    call transform(). Do not call setTransform() or set any of the transformation
+    properties in itemChange() as this notification is delivered;
     instead, you can return the new matrix from itemChange().
+    This notification is not sent if you change the transformation properties.
 
     \value ItemTransformHasChanged The item's transformation matrix has
-    changed.  This notification is only sent after the item's local
-    trasformation matrix has changed. The value argument is the new matrix
+    changed either because setTransform is called, or one of the transformation
+    properties is changed. This notification is only sent after the item's local
+    transformation matrix has changed. The value argument is the new matrix
     (same as transform()), and QGraphicsItem ignores the return value for this
     notification (i.e., a read-only notification).
 
@@ -522,6 +558,11 @@
 #include <private/qtextdocumentlayout_p.h>
 #include <private/qtextengine_p.h>
 
+#ifdef Q_WS_X11
+#include <private/qt_x11_p.h>
+#include <private/qpixmap_x11_p.h>
+#endif
+
 #include <math.h>
 
 QT_BEGIN_NAMESPACE
@@ -559,29 +600,6 @@ Q_GLOBAL_STATIC(QGraphicsItemCustomDataStore, qt_dataStore)
 /*!
     \internal
 
-    Removes the first instance of \a child from \a children. This is a
-    heuristic approach that assumes that it's common to remove items from the
-    start or end of the list.
-*/
-static void qt_graphicsitem_removeChild(QGraphicsItem *child, QList<QGraphicsItem *> *children)
-{
-    const int n = children->size();
-    for (int i = 0; i < (n + 1) / 2; ++i) {
-        if (children->at(i) == child) {
-            children->removeAt(i);
-            return;
-        }
-        int j = n - i - 1;
-        if (children->at(j) == child) {
-            children->removeAt(j);
-            return;
-        }
-    }
-}
-
-/*!
-    \internal
-
     Returns a QPainterPath of \a path when stroked with the \a pen.
     Ignoring dash pattern.
 */
@@ -781,11 +799,213 @@ QVariant QGraphicsItemPrivate::inputMethodQueryHelper(Qt::InputMethodQuery query
 /*!
     \internal
 
+    If \a deleting is true, then this item is being deleted, and \a parent is
+    null. Make sure not to trigger any pure virtual function calls (e.g.,
+    prepareGeometryChange).
+*/
+void QGraphicsItemPrivate::setParentItemHelper(QGraphicsItem *newParent, bool deleting)
+{
+    Q_Q(QGraphicsItem);
+    if (newParent == q) {
+        qWarning("QGraphicsItem::setParentItem: cannot assign %p as a parent of itself", this);
+        return;
+    }
+    if (newParent == parent)
+        return;
+
+    const QVariant newParentVariant(q->itemChange(QGraphicsItem::ItemParentChange,
+                                                  qVariantFromValue<QGraphicsItem *>(newParent)));
+    newParent = qVariantValue<QGraphicsItem *>(newParentVariant);
+    if (newParent == parent)
+        return;
+
+    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
+        // chain from our parents before it's reparented.
+        if (QGraphicsWidget *focusChild = w->focusWidget())
+            focusChild->clearFocus();
+    }
+
+    // We anticipate geometry changes. If the item is deleted, it will be
+    // removed from the index at a later stage, and the whole scene will be
+    // updated.
+    if (!deleting)
+        q_ptr->prepareGeometryChange();
+
+    const QVariant thisPointerVariant(qVariantFromValue<QGraphicsItem *>(q));
+    if (parent) {
+        // Remove from current parent
+        parent->d_ptr->removeChild(q);
+        parent->itemChange(QGraphicsItem::ItemChildRemovedChange, thisPointerVariant);
+    }
+
+    // Update toplevelitem list. If this item is being deleted, its parent
+    // will be 0 but we don't want to register/unregister it in the TLI list.
+    if (scene && !deleting) {
+        if (parent && !newParent) {
+            scene->d_func()->registerTopLevelItem(q);
+        } else if (!parent && newParent) {
+            scene->d_func()->unregisterTopLevelItem(q);
+        }
+    }
+
+    if ((parent = newParent)) {
+        bool implicitUpdate = false;
+        if (parent->d_func()->scene && parent->d_func()->scene != scene) {
+            // Move this item to its new parent's scene
+            parent->d_func()->scene->addItem(q);
+            implicitUpdate = true;
+        } else if (!parent->d_func()->scene && scene) {
+            // Remove this item from its former scene
+            scene->removeItem(q);
+        }
+
+        parent->d_ptr->addChild(q);
+        parent->itemChange(QGraphicsItem::ItemChildAddedChange, thisPointerVariant);
+        if (!implicitUpdate)
+            updateHelper(QRectF(), false, true);
+
+        // Inherit ancestor flags from the new parent.
+        updateAncestorFlag(QGraphicsItem::GraphicsItemFlag(-1));
+        updateAncestorFlag(QGraphicsItem::ItemClipsChildrenToShape);
+        updateAncestorFlag(QGraphicsItem::ItemIgnoresTransformations);
+
+        // Update item visible / enabled.
+        if (parent->isVisible() != visible) {
+            if (!parent->isVisible() || !explicitlyHidden)
+                setVisibleHelper(parent->isVisible(), /* explicit = */ false, /* update = */ !implicitUpdate);
+        }
+        if (parent->isEnabled() != enabled) {
+            if (!parent->isEnabled() || !explicitlyDisabled)
+                setEnabledHelper(parent->isEnabled(), /* explicit = */ false, /* update = */ !implicitUpdate);
+        }
+
+    } else {
+        // Inherit ancestor flags from the new parent.
+        updateAncestorFlag(QGraphicsItem::GraphicsItemFlag(-1));
+        updateAncestorFlag(QGraphicsItem::ItemClipsChildrenToShape);
+        updateAncestorFlag(QGraphicsItem::ItemIgnoresTransformations);
+
+        if (!deleting) {
+            // Update item visible / enabled.
+            if (!visible && !explicitlyHidden)
+                setVisibleHelper(true, /* explicit = */ false);
+            if (!enabled && !explicitlyDisabled)
+                setEnabledHelper(true, /* explicit = */ false);
+
+            // If the item is being deleted, the whole scene will be updated.
+            updateHelper(QRectF(), false, true);
+        }
+    }
+
+    if (scene) {
+        // Invalidate any sort caching; arrival of a new item means we need to
+        // resort.
+        scene->d_func()->invalidateSortCache();
+    }
+
+    // Resolve opacity.
+    updateEffectiveOpacity();
+
+    // Resolve depth.
+    resolveDepth(parent ? parent->d_ptr->depth : -1);
+
+    // Invalidate transform cache.
+    invalidateSceneTransformCache();
+
+    // Deliver post-change notification
+    q->itemChange(QGraphicsItem::ItemParentHasChanged, newParentVariant);
+}
+
+/*!
+    \internal
+
+    Returns the bounding rect of this item's children (excluding itself).
+*/
+void QGraphicsItemPrivate::childrenBoundingRectHelper(QTransform *x, QRectF *rect)
+{
+    for (int i = 0; i < children.size(); ++i) {
+        QGraphicsItem *child = children.at(i);
+        QGraphicsItemPrivate *childd = child->d_ptr;
+        bool hasX = childd->hasTransform;
+        bool hasPos = !childd->pos.isNull();
+        if (hasPos || hasX) {
+            QTransform matrix;
+            if (hasX)
+                matrix = child->transform();
+            if (hasPos) {
+                const QPointF &p = childd->pos;
+                matrix *= QTransform::fromTranslate(p.x(), p.y());
+            }
+            matrix *= *x;
+            *rect |= matrix.mapRect(child->boundingRect());
+            if (!childd->children.isEmpty())
+                childd->childrenBoundingRectHelper(&matrix, rect);
+        } else {
+            *rect |= x->mapRect(child->boundingRect());
+            if (!childd->children.isEmpty())
+                childd->childrenBoundingRectHelper(x, rect);
+        }
+    }
+}
+
+void QGraphicsItemPrivate::initStyleOption(QStyleOptionGraphicsItem *option, const QTransform &worldTransform,
+                                           const QRegion &exposedRegion, bool allItems) const
+{
+    Q_ASSERT(option);
+    Q_Q(const QGraphicsItem);
+
+    // Initialize standard QStyleOption values.
+    const QRectF brect = q->boundingRect();
+    option->state = QStyle::State_None;
+    option->rect = brect.toRect();
+    option->levelOfDetail = 1;
+    option->exposedRect = brect;
+    if (selected)
+        option->state |= QStyle::State_Selected;
+    if (enabled)
+        option->state |= QStyle::State_Enabled;
+    if (q->hasFocus())
+        option->state |= QStyle::State_HasFocus;
+    if (scene) {
+        if (scene->d_func()->hoverItems.contains(q_ptr))
+            option->state |= QStyle::State_MouseOver;
+        if (q == scene->mouseGrabberItem())
+            option->state |= QStyle::State_Sunken;
+    }
+
+    if (!(flags & QGraphicsItem::ItemUsesExtendedStyleOption))
+        return;
+
+    // Initialize QStyleOptionGraphicsItem specific values (matrix, exposedRect).
+
+    const QTransform itemToViewportTransform = q->deviceTransform(worldTransform);
+    option->matrix = itemToViewportTransform.toAffine(); //### discards perspective
+
+    if (!allItems) {
+        // Determine the item's exposed area
+        option->exposedRect = QRectF();
+        const QTransform reverseMap = itemToViewportTransform.inverted();
+        const QVector<QRect> exposedRects(exposedRegion.rects());
+        for (int i = 0; i < exposedRects.size(); ++i) {
+            option->exposedRect |= reverseMap.mapRect(exposedRects.at(i));
+            if (option->exposedRect.contains(brect))
+                break;
+        }
+        option->exposedRect &= brect;
+    }
+}
+
+/*!
+    \internal
+
     Empty all cached pixmaps from the pixmap cache.
 */
 void QGraphicsItemCache::purge()
 {
     QPixmapCache::remove(key);
+    key = QPixmapCache::Key();
     QMutableMapIterator<QPaintDevice *, DeviceData> it(deviceData);
     while (it.hasNext()) {
         DeviceData &data = it.next().value();
@@ -853,32 +1073,20 @@ QGraphicsItem::QGraphicsItem(QGraphicsItemPrivate &dd, QGraphicsItem *parent,
 */
 QGraphicsItem::~QGraphicsItem()
 {
+    if (d_ptr->scene && !d_ptr->parent)
+        d_ptr->scene->d_func()->unregisterTopLevelItem(this);
+
     clearFocus();
-    d_ptr->removeExtraItemCache();
 
-    QVariant variant;
-    foreach (QGraphicsItem *child, d_ptr->children) {
-        if (QGraphicsItem *parent = child->parentItem()) {
-            qVariantSetValue<QGraphicsItem *>(variant, child);
-            parent->itemChange(ItemChildRemovedChange, variant);
-        }
-        delete child;
-    }
-    d_ptr->children.clear();
+    d_ptr->removeExtraItemCache();
+    QList<QGraphicsItem *> oldChildren = d_ptr->children;
+    qDeleteAll(oldChildren);
+    Q_ASSERT(d_ptr->children.isEmpty());
 
-    if (QGraphicsItem *parent = parentItem()) {
-        qVariantSetValue<QGraphicsItem *>(variant, this);
-        parent->itemChange(ItemChildRemovedChange, variant);
-        qt_graphicsitem_removeChild(this, &parent->d_func()->children);
-    }
+    d_ptr->setParentItemHelper(0, /* deleting = */ true);
     if (d_ptr->scene)
         d_ptr->scene->d_func()->_q_removeItemLater(this);
-    
-    if (d_ptr->hasTransform) {
-        delete static_cast<QGraphicsItemPrivate::TransformData *>(
-                            qVariantValue<void *>(d_ptr->extra(QGraphicsItemPrivate::ExtraTransform)));
-    }
-        
+
     delete d_ptr;
 
     qt_dataStore()->data.remove(this);
@@ -1020,98 +1228,7 @@ QGraphicsWidget *QGraphicsItem::window() const
 */
 void QGraphicsItem::setParentItem(QGraphicsItem *parent)
 {
-    if (parent == this) {
-        qWarning("QGraphicsItem::setParentItem: cannot assign %p as a parent of itself", this);
-        return;
-    }
-    if (parent == d_ptr->parent)
-        return;
-    const QVariant newParentVariant(itemChange(ItemParentChange, qVariantFromValue<QGraphicsItem *>(parent)));
-    parent = qVariantValue<QGraphicsItem *>(newParentVariant);
-    if (parent == d_ptr->parent)
-        return;
-
-    if (QGraphicsWidget *w = d_ptr->isWidget ? static_cast<QGraphicsWidget *>(this) : parentWidget()) {
-        // Update the child focus chain; when reparenting a widget that has a
-        // focus child, ensure that that focus child clears its focus child
-        // chain from our parents before it's reparented.
-        if (QGraphicsWidget *focusChild = w->focusWidget())
-            focusChild->clearFocus();
-    }
-
-    // We anticipate geometry changes
-    prepareGeometryChange();
-
-    const QVariant thisPointerVariant(qVariantFromValue<QGraphicsItem *>(this));
-    if (d_ptr->parent) {
-        // Remove from current parent
-        qt_graphicsitem_removeChild(this, &d_ptr->parent->d_func()->children);
-        d_ptr->parent->itemChange(ItemChildRemovedChange, thisPointerVariant);
-    }
-
-    if ((d_ptr->parent = parent)) {
-        bool implicitUpdate = false;
-        if (parent->d_func()->scene && parent->d_func()->scene != d_ptr->scene) {
-            // Move this item to its new parent's scene
-            parent->d_func()->scene->addItem(this);
-            implicitUpdate = true;
-        } else if (!parent->d_func()->scene && d_ptr->scene) {
-            // Remove this item from its former scene
-            d_ptr->scene->removeItem(this);
-        }
-
-        d_ptr->parent->d_func()->children << this;
-        d_ptr->parent->itemChange(ItemChildAddedChange, thisPointerVariant);
-        if (!implicitUpdate)
-            d_ptr->updateHelper(QRectF(), false, true);
-
-        // Inherit ancestor flags from the new parent.
-        d_ptr->updateAncestorFlag(QGraphicsItem::GraphicsItemFlag(-1));
-        d_ptr->updateAncestorFlag(ItemClipsChildrenToShape);
-        d_ptr->updateAncestorFlag(ItemIgnoresTransformations);
-
-        // Update item visible / enabled.
-        if (d_ptr->parent->isVisible() != d_ptr->visible) {
-            if (!d_ptr->parent->isVisible() || !d_ptr->explicitlyHidden)
-                d_ptr->setVisibleHelper(d_ptr->parent->isVisible(), /* explicit = */ false, /* update = */ !implicitUpdate);
-        }
-        if (d_ptr->parent->isEnabled() != d_ptr->enabled) {
-            if (!d_ptr->parent->isEnabled() || !d_ptr->explicitlyDisabled)
-                d_ptr->setEnabledHelper(d_ptr->parent->isEnabled(), /* explicit = */ false, /* update = */ !implicitUpdate);
-        }
-
-    } else {
-        // Inherit ancestor flags from the new parent.
-        d_ptr->updateAncestorFlag(QGraphicsItem::GraphicsItemFlag(-1));
-        d_ptr->updateAncestorFlag(ItemClipsChildrenToShape);
-        d_ptr->updateAncestorFlag(ItemIgnoresTransformations);
-
-        // Update item visible / enabled.
-        if (!d_ptr->visible && !d_ptr->explicitlyHidden)
-            d_ptr->setVisibleHelper(true, /* explicit = */ false);
-        if (!d_ptr->enabled && !d_ptr->explicitlyDisabled)
-            d_ptr->setEnabledHelper(true, /* explicit = */ false);
-
-        d_ptr->updateHelper(QRectF(), false, true);
-    }
-
-    if (d_ptr->scene) {
-        // Invalidate any sort caching; arrival of a new item means we need to
-        // resort.
-        d_ptr->scene->d_func()->invalidateSortCache();
-    }
-
-    // Resolve opacity.
-    d_ptr->updateEffectiveOpacity();
-
-    // Resolve depth.
-    d_ptr->resolveDepth(parent ? parent->d_ptr->depth : -1);
-
-    // Invalidate transform cache.
-    d_ptr->invalidateSceneTransformCache();
-
-    // Deliver post-change notification
-    itemChange(QGraphicsItem::ItemParentHasChanged, newParentVariant);
+    d_ptr->setParentItemHelper(parent, /* deleting = */ false);
 }
 
 /*!
@@ -1337,12 +1454,6 @@ void QGraphicsItem::setCacheMode(CacheMode mode, const QSize &logicalCacheSize)
         cache->purge();
 
         if (mode == ItemCoordinateCache) {
-            if (cache->key.isEmpty()) {
-                // Generate new simple pixmap cache key.
-                QString tmp;
-                tmp.sprintf("qgv-%p", this);
-                cache->key = tmp;
-            }
             if (lastMode == mode && cache->fixedSize == logicalCacheSize)
                 noVisualChange = true;
             cache->fixedSize = logicalCacheSize;
@@ -1420,7 +1531,9 @@ void QGraphicsItem::setCursor(const QCursor &cursor)
     d_ptr->setExtra(QGraphicsItemPrivate::ExtraCursor, qVariantValue<QCursor>(cursorVariant));
     d_ptr->hasCursor = 1;
     if (d_ptr->scene) {
+        d_ptr->scene->d_func()->allItemsUseDefaultCursor = false;
         foreach (QGraphicsView *view, d_ptr->scene->views()) {
+            view->viewport()->setMouseTracking(true);
             // Note: Some of this logic is duplicated in QGraphicsView's mouse events.
             if (view->underMouse()) {
                 foreach (QGraphicsItem *itemUnderCursor, view->items(view->mapFromGlobal(QCursor::pos()))) {
@@ -1903,11 +2016,11 @@ void QGraphicsItem::setOpacity(qreal opacity)
     newOpacity = qBound<qreal>(0.0, newOpacity, 1.0);
 
     // No change? Done.
-    if (qFuzzyCompare(newOpacity, this->opacity()))
+    if (qFuzzyIsNull(newOpacity - this->opacity()))
         return;
 
     // Assign local opacity.
-    if (qFuzzyCompare(newOpacity, qreal(1.0))) {
+    if (qFuzzyIsNull(newOpacity - 1)) {
         // Opaque, unset opacity.
         d_ptr->hasOpacity = 0;
         d_ptr->unsetExtra(QGraphicsItemPrivate::ExtraOpacity);
@@ -2052,7 +2165,13 @@ bool QGraphicsItem::acceptsHoverEvents() const
 */
 void QGraphicsItem::setAcceptHoverEvents(bool enabled)
 {
+    if (d_ptr->acceptsHover == quint32(enabled))
+        return;
     d_ptr->acceptsHover = quint32(enabled);
+    if (d_ptr->acceptsHover && d_ptr->scene && d_ptr->scene->d_func()->allItemsIgnoreHoverEvents) {
+        d_ptr->scene->d_func()->allItemsIgnoreHoverEvents = false;
+        d_ptr->scene->d_func()->enableMouseTrackingOnViews();
+    }
 }
 
 /*!
@@ -2062,7 +2181,7 @@ void QGraphicsItem::setAcceptHoverEvents(bool enabled)
 */
 void QGraphicsItem::setAcceptsHoverEvents(bool enabled)
 {
-    d_ptr->acceptsHover = quint32(enabled);
+    setAcceptHoverEvents(enabled);
 }
 
 /*!
@@ -2467,8 +2586,13 @@ QMatrix QGraphicsItem::matrix() const
 /*!
     \since 4.3
 
-    Returns this item's transformation matrix. If no matrix has been set, the
-    identity matrix is returned.
+    Returns this item's transformation matrix.
+
+    Either the one set by setTransform, or the resulting transformation from
+    all the transfmation properties
+
+    If no matrix or transformation property has been set, the
+    identity matrix is returned. 
 
     \sa setTransform(), sceneTransform()
 */
@@ -2476,24 +2600,304 @@ QTransform QGraphicsItem::transform() const
 {
     if (!d_ptr->hasTransform)
         return QTransform();
-    QGraphicsItemPrivate::TransformData *transformData = static_cast<QGraphicsItemPrivate::TransformData *>(
-                            qVariantValue<void *>(d_ptr->extra(QGraphicsItemPrivate::ExtraTransform)));
-    Q_ASSERT(transformData);
-    if (transformData->dirty) {
-        QGraphicsItem *that = const_cast<QGraphicsItem *>(this);
-        QTransform newTransform;
-        QPointF center = transformData->transformCenter;
-        newTransform.translate(center.x(), center.y());
-        newTransform.rotate(transformData->rotationZ, Qt::ZAxis);
-        newTransform.rotate(transformData->rotationY, Qt::YAxis);
-        newTransform.rotate(transformData->rotationX, Qt::XAxis);
-        newTransform.scale(transformData->scaleX, transformData->scaleY);
-        newTransform *= transformData->baseTransform;
-        newTransform.translate(-center.x(), -center.y());
-        transformData->transform = newTransform;
-        transformData->dirty = false;
-    }
-    return transformData->transform;
+    if (d_ptr->hasDecomposedTransform && d_ptr->dirtyTransform) {
+        QGraphicsItemPrivate::DecomposedTransform *decomposed = d_ptr->decomposedTransform();
+        QTransform x;
+        decomposed->generateTransform(&x);
+        QVariant v(x);
+        d_ptr->setExtra(QGraphicsItemPrivate::ExtraTransform, v);
+        d_ptr->dirtyTransform = 0;
+        d_ptr->dirtyTransformComponents = 1;
+        const_cast<QGraphicsItem *>(this)->itemChange(ItemTransformHasChanged, v);
+        return x;
+    }
+    return qVariantValue<QTransform>(d_ptr->extra(QGraphicsItemPrivate::ExtraTransform));
+}
+
+/*!
+    \property QGraphicsItem::xRotation
+
+    \since 4.6
+
+    This property holds the rotation angle in degrees around the X axis
+
+    The default is 0
+
+    \warning setting this property is conflicting with calling setTransform.
+    If a transform has been set, this function return the default value.
+
+    \sa {Transformations}
+*/
+qreal QGraphicsItem::xRotation() const
+{
+    return d_ptr->decomposedTransform()->xRotation;
+}
+
+void QGraphicsItem::setXRotation(qreal angle)
+{
+    if (!d_ptr->dirtyTransform) {
+        d_ptr->fullUpdateHelper(true);
+        prepareGeometryChange();
+    }
+    QGraphicsItemPrivate::DecomposedTransform *decomposed = d_ptr->decomposedTransform();
+    decomposed->xRotation = angle;
+    if (!d_ptr->dirtyTransform)
+        d_ptr->invalidateSceneTransformCache();
+    d_ptr->dirtyTransform = 1;
+    d_ptr->hasTransform = 1;
+}
+
+/*!
+    \property QGraphicsItem::yRotation
+
+    \since 4.6
+
+    This property holds the rotation angle in degrees around the Y axis
+
+    The default is 0
+
+    \warning setting this property is conflicting with calling setTransform.
+    If a transform has been set, this function return the default value.
+
+    \sa {Transformations}
+*/
+qreal QGraphicsItem::yRotation() const
+{
+    return d_ptr->decomposedTransform()->yRotation;
+}
+
+void QGraphicsItem::setYRotation(qreal angle)
+{
+    if (!d_ptr->dirtyTransform) {
+        d_ptr->fullUpdateHelper(true);
+        prepareGeometryChange();
+    }
+    QGraphicsItemPrivate::DecomposedTransform *decomposed = d_ptr->decomposedTransform();
+    decomposed->yRotation = angle;
+    if (!d_ptr->dirtyTransform)
+        d_ptr->invalidateSceneTransformCache();
+    d_ptr->dirtyTransform = 1;
+    d_ptr->hasTransform = 1;
+}
+
+/*!
+    \property QGraphicsItem::zRotation
+
+    \since 4.6
+
+    This property holds the rotation angle in degrees around the Z axis
+
+    The default is 0
+
+    \warning setting this property is conflicting with calling setTransform.
+    If a transform has been set, this function return the default value.
+
+    \sa {Transformations}
+*/
+qreal QGraphicsItem::zRotation() const
+{
+    return d_ptr->decomposedTransform()->zRotation;
+}
+
+void QGraphicsItem::setZRotation(qreal angle)
+{
+    if (!d_ptr->dirtyTransform) {
+        d_ptr->fullUpdateHelper(true);
+        prepareGeometryChange();
+    }
+    QGraphicsItemPrivate::DecomposedTransform *decomposed = d_ptr->decomposedTransform();
+    decomposed->zRotation = angle;
+    if (!d_ptr->dirtyTransform)
+        d_ptr->invalidateSceneTransformCache();
+    d_ptr->dirtyTransform = 1;
+    d_ptr->hasTransform = 1;
+}
+
+void QGraphicsItem::setRotation(qreal x, qreal y, qreal z)
+{
+    setXRotation(x);
+    setYRotation(y);
+    setZRotation(z);
+}
+
+/*!
+    \property QGraphicsItem::xScale
+
+    \since 4.6
+
+    This property holds the scale factor on the X axis.
+
+    The default is 1
+
+    \warning setting this property is conflicting with calling setTransform.
+    If a transform has been set, this function return the default value.
+
+    \sa {Transformations}
+*/
+qreal QGraphicsItem::xScale() const
+{
+    return d_ptr->decomposedTransform()->xScale;
+}
+
+void QGraphicsItem::setXScale(qreal factor)
+{
+    if (!d_ptr->dirtyTransform) {
+        d_ptr->fullUpdateHelper(true);
+        prepareGeometryChange();
+    }
+    QGraphicsItemPrivate::DecomposedTransform *decomposed = d_ptr->decomposedTransform();
+    decomposed->xScale = factor;
+    if (!d_ptr->dirtyTransform)
+        d_ptr->invalidateSceneTransformCache();
+    d_ptr->dirtyTransform = 1;
+    d_ptr->hasTransform = 1;
+}
+
+/*!
+    \property QGraphicsItem::yScale
+
+    \since 4.6
+
+    This property holds the scale factor on the Y axis.
+
+    The default is 1
+
+    \warning setting this property is conflicting with calling setTransform.
+    If a transform has been set, this function return the default value.
+
+    \sa {Transformations}
+*/
+qreal QGraphicsItem::yScale() const
+{
+    return d_ptr->decomposedTransform()->yScale;
+}
+
+void QGraphicsItem::setYScale(qreal factor)
+{
+    if (!d_ptr->dirtyTransform) {
+        d_ptr->fullUpdateHelper(true);
+        prepareGeometryChange();
+    }
+    QGraphicsItemPrivate::DecomposedTransform *decomposed = d_ptr->decomposedTransform();
+    decomposed->yScale = factor;
+    if (!d_ptr->dirtyTransform)
+        d_ptr->invalidateSceneTransformCache();
+    d_ptr->dirtyTransform = 1;
+    d_ptr->hasTransform = 1;
+}
+
+void QGraphicsItem::setScale(qreal sx, qreal sy)
+{
+    setXScale(sx);
+    setYScale(sy);
+}
+
+/*!
+    \property QGraphicsItem::horizontalShear
+
+    \since 4.6
+
+    This property holds the horizontal shear.
+
+    The default is 0.
+
+    \warning setting this property is conflicting with calling setTransform.
+    If a transform has been set, this function return the default value.
+
+    \sa {Transformations}
+*/
+qreal QGraphicsItem::horizontalShear() const
+{
+    return d_ptr->decomposedTransform()->horizontalShear;
+}
+
+void QGraphicsItem::setHorizontalShear(qreal shear)
+{
+    if (!d_ptr->dirtyTransform) {
+        d_ptr->fullUpdateHelper(true);
+        prepareGeometryChange();
+    }
+    QGraphicsItemPrivate::DecomposedTransform *decomposed = d_ptr->decomposedTransform();
+    decomposed->horizontalShear = shear;
+    if (!d_ptr->dirtyTransform)
+        d_ptr->invalidateSceneTransformCache();
+    d_ptr->dirtyTransform = 1;
+    d_ptr->hasTransform = 1;
+}
+
+/*!
+    \property QGraphicsItem::verticalShear
+
+    \since 4.6
+
+    This property holds the vertical shear.
+
+    The default is 0.
+
+    \warning setting this property is conflicting with calling setTransform.
+    If a transform has been set, this function return the default value.
+
+    \sa {Transformations}
+*/
+qreal QGraphicsItem::verticalShear() const
+{
+    return d_ptr->decomposedTransform()->verticalShear;
+}
+
+void QGraphicsItem::setVerticalShear(qreal shear)
+{
+    if (!d_ptr->dirtyTransform) {
+        d_ptr->fullUpdateHelper(true);
+        prepareGeometryChange();
+    }
+    QGraphicsItemPrivate::DecomposedTransform *decomposed = d_ptr->decomposedTransform();
+    decomposed->verticalShear = shear;
+    if (!d_ptr->dirtyTransform)
+        d_ptr->invalidateSceneTransformCache();
+    d_ptr->dirtyTransform = 1;
+    d_ptr->hasTransform = 1;
+}
+
+void QGraphicsItem::setShear(qreal sh, qreal sv)
+{
+    setHorizontalShear(sh);
+    setVerticalShear(sv);
+}
+
+/*!
+    \property QGraphicsItem::transformOrigin
+
+    \since 4.6
+
+    This property holds the transformation origin for the transformation properties.
+    This does not apply to the transformation set by setTransform.
+
+    The default is QPointF(0,0).
+
+    \warning setting this property is conflicting with calling setTransform.
+    If a transform has been set, this function return the default value.
+
+    \sa {Transformations}
+*/
+QPointF QGraphicsItem::transformOrigin() const
+{
+    const QGraphicsItemPrivate::DecomposedTransform *decomposed = d_ptr->decomposedTransform();
+    return QPointF(decomposed->xOrigin, decomposed->yOrigin);
+}
+
+void QGraphicsItem::setTransformOrigin(const QPointF &origin)
+{
+    if (!d_ptr->dirtyTransform) {
+        d_ptr->fullUpdateHelper(true);
+        prepareGeometryChange();
+    }
+    QGraphicsItemPrivate::DecomposedTransform *decomposed = d_ptr->decomposedTransform();
+    decomposed->xOrigin = origin.x();
+    decomposed->yOrigin = origin.y();
+    if (!d_ptr->dirtyTransform)
+        d_ptr->invalidateSceneTransformCache();
+    d_ptr->dirtyTransform = 1;
+    d_ptr->hasTransform = 1;
 }
 
 /*!
@@ -2594,6 +2998,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;
+
     // Find the topmost item that ignores view transformations.
     const QGraphicsItem *untransformedAncestor = this;
     QList<const QGraphicsItem *> parents;
@@ -2767,21 +3175,11 @@ QTransform QGraphicsItem::itemTransform(const QGraphicsItem *other, bool *ok) co
 
     Use setTransform() instead.
 
-    \sa transform(), rotate(), scale(), shear(), translate(), {The Graphics View Coordinate System}
+    \sa transform(), {The Graphics View Coordinate System}
 */
 void QGraphicsItem::setMatrix(const QMatrix &matrix, bool combine)
 {
-    QGraphicsItemPrivate::TransformData *transformData = static_cast<QGraphicsItemPrivate::TransformData *>(
-                            qVariantValue<void *>(d_ptr->extra(QGraphicsItemPrivate::ExtraTransform)));
-    if (!transformData) {
-        if (matrix.isIdentity())
-            return;
-        transformData = new QGraphicsItemPrivate::TransformData;
-        d_ptr->setExtra(QGraphicsItemPrivate::ExtraTransform, qVariantFromValue<void *>(transformData));
-    }
-    
-    QTransform oldTransform = transformData->baseTransform;
-
+    QTransform oldTransform = this->transform();
     QTransform newTransform;
     if (!combine)
         newTransform = QTransform(matrix);
@@ -2790,7 +3188,7 @@ void QGraphicsItem::setMatrix(const QMatrix &matrix, bool combine)
     if (oldTransform == newTransform)
         return;
 
-    // Notify the item that the transformation matrix is changing.
+    // Notify the item that the matrix is changing.
     QVariant newTransformVariant(itemChange(ItemMatrixChange,
                                             qVariantFromValue<QMatrix>(newTransform.toAffine())));
     newTransform = QTransform(qVariantValue<QMatrix>(newTransformVariant));
@@ -2800,10 +3198,11 @@ void QGraphicsItem::setMatrix(const QMatrix &matrix, bool combine)
     // Update and set the new transformation.
     d_ptr->fullUpdateHelper(true, true);
     prepareGeometryChange();
-    transformData->baseTransform = newTransform;
-    transformData->dirty = true;
-    d_ptr->hasTransform = true;
+    d_ptr->hasTransform = !newTransform.isIdentity();
+    d_ptr->setExtra(QGraphicsItemPrivate::ExtraTransform, newTransform);
     d_ptr->invalidateSceneTransformCache();
+    if (d_ptr->hasDecomposedTransform)
+        d_ptr->dirtyTransform = 1;
 
     // Send post-notification.
     // NB! We have to change the value from QMatrix to QTransform.
@@ -2826,21 +3225,14 @@ void QGraphicsItem::setMatrix(const QMatrix &matrix, bool combine)
     to map an item coordiate to a scene coordinate, or mapFromScene() to map
     from scene coordinates to item coordinates.
 
-    \sa transform(), rotate(), scale(), shear(), translate(), {The Graphics View Coordinate System}
+    \warning using this function conflicts with using the transformation properties.
+    If you set a transformation, getting the properties will return default values.
+
+    \sa transform(), setRotation(), setScale(), setShear(), setTransformOrigin() {The Graphics View Coordinate System}
 */
 void QGraphicsItem::setTransform(const QTransform &matrix, bool combine)
 {
-    QGraphicsItemPrivate::TransformData *transformData = static_cast<QGraphicsItemPrivate::TransformData *>(
-                            qVariantValue<void *>(d_ptr->extra(QGraphicsItemPrivate::ExtraTransform)));
-    if (!transformData) {
-        if (matrix.isIdentity())
-            return;
-        transformData = new QGraphicsItemPrivate::TransformData;
-        d_ptr->setExtra(QGraphicsItemPrivate::ExtraTransform, qVariantFromValue<void *>(transformData));
-    }
-    
-    QTransform oldTransform = transformData->baseTransform;
-
+    QTransform oldTransform = this->transform();
     QTransform newTransform;
     if (!combine)
         newTransform = matrix;
@@ -2859,11 +3251,11 @@ void QGraphicsItem::setTransform(const QTransform &matrix, bool combine)
     // Update and set the new transformation.
     d_ptr->fullUpdateHelper(true, true);
     prepareGeometryChange();
-    transformData->baseTransform = newTransform;
-    transformData->dirty = true;
-    d_ptr->hasTransform = true;
-    transform(); // ### update transform, bad!
+    d_ptr->hasTransform = !newTransform.isIdentity();
+    d_ptr->setExtra(QGraphicsItemPrivate::ExtraTransform, newTransform);
     d_ptr->invalidateSceneTransformCache();
+    if (d_ptr->hasDecomposedTransform)
+        d_ptr->dirtyTransform = 1;
 
     // Send post-notification.
     itemChange(ItemTransformHasChanged, newTransformVariant);
@@ -2882,8 +3274,9 @@ void QGraphicsItem::resetMatrix()
 /*!
     \since 4.3
 
-    Resets this item's transformation matrix to the identity matrix. This is
-    equivalent to calling \c setTransform(QTransform()).
+    Resets this item's transformation matrix to the identity matrix or
+    all the transformation properties to their default values.
+    This is equivalent to calling \c setTransform(QTransform()).
 
     \sa setTransform(), transform()
 */
@@ -2893,6 +3286,9 @@ void QGraphicsItem::resetTransform()
 }
 
 /*!
+    \obsolete
+    Use setZRotation() instead
+
     Rotates the current item transformation \a angle degrees clockwise around
     its origin. To translate around an arbitrary point (x, y), you need to
     combine translation and rotation with setTransform().
@@ -2901,6 +3297,9 @@ void QGraphicsItem::resetTransform()
 
     \snippet doc/src/snippets/code/src_gui_graphicsview_qgraphicsitem.cpp 6
 
+    \warning using this function conflicts with using the transformation properties.
+    Getting those properties after using this function will return default values.
+
     \sa setTransform(), transform(), scale(), shear(), translate()
 */
 void QGraphicsItem::rotate(qreal angle)
@@ -2909,6 +3308,9 @@ void QGraphicsItem::rotate(qreal angle)
 }
 
 /*!
+    \obsolete
+    Use setScale() instead
+
     Scales the current item transformation by (\a sx, \a sy) around its
     origin. To scale from an arbitrary point (x, y), you need to combine
     translation and scaling with setTransform().
@@ -2917,7 +3319,10 @@ void QGraphicsItem::rotate(qreal angle)
 
     \snippet doc/src/snippets/code/src_gui_graphicsview_qgraphicsitem.cpp 7
 
-    \sa setTransform(), transform(), rotate(), shear(), translate()
+    \warning using this function conflicts with using the transformation properties.
+    Getting those properties after using this function will return default values.
+
+    \sa setTransform(), transform()
 */
 void QGraphicsItem::scale(qreal sx, qreal sy)
 {
@@ -2925,9 +3330,15 @@ void QGraphicsItem::scale(qreal sx, qreal sy)
 }
 
 /*!
+    \obsolete
+    Use setShear instead.
+
     Shears the current item transformation by (\a sh, \a sv).
 
-    \sa setTransform(), transform(), rotate(), scale(), translate()
+    \warning using this function conflicts with using the transformation properties.
+    Getting those properties after using this function will return default values.
+
+    \sa setTransform(), transform()
 */
 void QGraphicsItem::shear(qreal sh, qreal sv)
 {
@@ -2935,210 +3346,25 @@ void QGraphicsItem::shear(qreal sh, qreal sv)
 }
 
 /*!
+    \obsolete
+    Use setPos() or setTransformOrigin() instead.
+
     Translates the current item transformation by (\a dx, \a dy).
 
     If all you want is to move an item, you should call moveBy() or
     setPos() instead; this function changes the item's translation,
     which is conceptually separate from its position.
 
-    \sa setTransform(), transform(), rotate(), scale(), shear()
+    \warning using this function conflicts with using the transformation properties.
+    Getting those properties after using this function will return default values.
+
+    \sa setTransform(), transform()
 */
 void QGraphicsItem::translate(qreal dx, qreal dy)
 {
     setTransform(QTransform::fromTranslate(dx, dy), true);
 }
 
-QPointF QGraphicsItem::transformOrigin() const
-{
-    QGraphicsItemPrivate::TransformData *transformData = static_cast<QGraphicsItemPrivate::TransformData *>(
-                            qVariantValue<void *>(d_ptr->extra(QGraphicsItemPrivate::ExtraTransform)));
-    if (!transformData)
-        return QPointF();
- 
-    return transformData->transformCenter;
-}
-
-/*!
-    Set a center for all transformation
-*/
-void QGraphicsItem::setTransformOrigin(const QPointF &center)
-{
-    QGraphicsItemPrivate::TransformData *transformData = static_cast<QGraphicsItemPrivate::TransformData *>(
-                            qVariantValue<void *>(d_ptr->extra(QGraphicsItemPrivate::ExtraTransform)));
-    if (!transformData) {
-        if (center.isNull())
-            return;
-        transformData = new QGraphicsItemPrivate::TransformData;
-        d_ptr->setExtra(QGraphicsItemPrivate::ExtraTransform, qVariantFromValue<void *>(transformData));
-    }
-    if (transformData->transformCenter == center)
-        return;
-   
-    d_ptr->fullUpdateHelper(true);
-    prepareGeometryChange();
-    
-    transformData->transformCenter = center;
-
-    transformData->dirty = true;
-    d_ptr->hasTransform = true;
-    d_ptr->fullUpdateHelper();
-
-}
-
-qreal QGraphicsItem::xScale() const
-{
-    QGraphicsItemPrivate::TransformData *transformData = static_cast<QGraphicsItemPrivate::TransformData *>(
-                            qVariantValue<void *>(d_ptr->extra(QGraphicsItemPrivate::ExtraTransform)));
-    if (!transformData)
-        return 1;
-    
-    return transformData->scaleX; 
-}
-
-void QGraphicsItem::setXScale(qreal factor)
-{
-    QGraphicsItemPrivate::TransformData *transformData = static_cast<QGraphicsItemPrivate::TransformData *>(
-                            qVariantValue<void *>(d_ptr->extra(QGraphicsItemPrivate::ExtraTransform)));
-    if (!transformData) {
-        if (factor == 1)
-            return;
-        transformData = new QGraphicsItemPrivate::TransformData;
-        d_ptr->setExtra(QGraphicsItemPrivate::ExtraTransform, qVariantFromValue<void *>(transformData));
-    }
-    if (transformData->scaleX == factor)
-        return;  
-    
-    d_ptr->fullUpdateHelper(true);
-    prepareGeometryChange();
-    
-    transformData->scaleX = factor;
-    transformData->dirty = true;
-    d_ptr->hasTransform = true;
-    d_ptr->invalidateSceneTransformCache();
-}
-
-qreal QGraphicsItem::yScale() const
-{
-    QGraphicsItemPrivate::TransformData *transformData = static_cast<QGraphicsItemPrivate::TransformData *>(
-                            qVariantValue<void *>(d_ptr->extra(QGraphicsItemPrivate::ExtraTransform)));
-    if (!transformData)
-        return 1;
-    
-    return transformData->scaleY; 
-}
-
-void QGraphicsItem::setYScale(qreal factor)
-{
-    QGraphicsItemPrivate::TransformData *transformData = static_cast<QGraphicsItemPrivate::TransformData *>(
-                            qVariantValue<void *>(d_ptr->extra(QGraphicsItemPrivate::ExtraTransform)));
-    if (!transformData) {
-        if (factor == 1)
-            return;
-        transformData = new QGraphicsItemPrivate::TransformData;
-        d_ptr->setExtra(QGraphicsItemPrivate::ExtraTransform, qVariantFromValue<void *>(transformData));
-    }
-    if (transformData->scaleY == factor)
-        return;  
-    
-    d_ptr->fullUpdateHelper(true);
-    prepareGeometryChange();
-    
-    transformData->scaleY = factor;
-    transformData->dirty = true;
-    d_ptr->hasTransform = true;
-    d_ptr->invalidateSceneTransformCache();
-}
-
-qreal QGraphicsItem::xRotation() const
-{
-    QGraphicsItemPrivate::TransformData *transformData = static_cast<QGraphicsItemPrivate::TransformData *>(
-                            qVariantValue<void *>(d_ptr->extra(QGraphicsItemPrivate::ExtraTransform)));
-    if (!transformData)
-        return 0;
-    return transformData->rotationX;
-}
-
-void QGraphicsItem::setXRotation(qreal angle)
-{
-    QGraphicsItemPrivate::TransformData *transformData = static_cast<QGraphicsItemPrivate::TransformData *>(
-                            qVariantValue<void *>(d_ptr->extra(QGraphicsItemPrivate::ExtraTransform)));
-    if (!transformData) {
-        if (qFuzzyCompare(angle + 1, 1))
-            return;
-        transformData = new QGraphicsItemPrivate::TransformData;
-        d_ptr->setExtra(QGraphicsItemPrivate::ExtraTransform, qVariantFromValue<void *>(transformData));
-    }
-    
-    d_ptr->fullUpdateHelper(true);
-    prepareGeometryChange();
-
-    transformData->rotationX = angle;
-    
-    transformData->dirty = true;
-    d_ptr->hasTransform = true;
-    d_ptr->invalidateSceneTransformCache();
-}
-
-qreal QGraphicsItem::yRotation() const
-{
-    QGraphicsItemPrivate::TransformData *transformData = static_cast<QGraphicsItemPrivate::TransformData *>(
-                            qVariantValue<void *>(d_ptr->extra(QGraphicsItemPrivate::ExtraTransform)));
-    if (!transformData)
-        return 0;
-    return transformData->rotationY;
-}
-
-void QGraphicsItem::setYRotation(qreal angle)
-{
-    QGraphicsItemPrivate::TransformData *transformData = static_cast<QGraphicsItemPrivate::TransformData *>(
-                            qVariantValue<void *>(d_ptr->extra(QGraphicsItemPrivate::ExtraTransform)));
-    if (!transformData) {
-        if (qFuzzyCompare(angle + 1, 1))
-            return;
-        transformData = new QGraphicsItemPrivate::TransformData;
-        d_ptr->setExtra(QGraphicsItemPrivate::ExtraTransform, qVariantFromValue<void *>(transformData));
-    }
-    
-    d_ptr->fullUpdateHelper(true);
-    prepareGeometryChange();
-
-    transformData->rotationY = angle;
-    
-    transformData->dirty = true;
-    d_ptr->hasTransform = true;
-    d_ptr->invalidateSceneTransformCache();
-}
-
-qreal QGraphicsItem::zRotation() const
-{
-    QGraphicsItemPrivate::TransformData *transformData = static_cast<QGraphicsItemPrivate::TransformData *>(
-                            qVariantValue<void *>(d_ptr->extra(QGraphicsItemPrivate::ExtraTransform)));
-    if (!transformData)
-        return 0;
-    return transformData->rotationZ;
-}
-
-void QGraphicsItem::setZRotation(qreal angle)
-{
-    QGraphicsItemPrivate::TransformData *transformData = static_cast<QGraphicsItemPrivate::TransformData *>(
-                            qVariantValue<void *>(d_ptr->extra(QGraphicsItemPrivate::ExtraTransform)));
-    if (!transformData) {
-        if (qFuzzyCompare(angle + 1, 1))
-            return;
-        transformData = new QGraphicsItemPrivate::TransformData;
-        d_ptr->setExtra(QGraphicsItemPrivate::ExtraTransform, qVariantFromValue<void *>(transformData));
-    }
-    
-    d_ptr->fullUpdateHelper(true);
-    prepareGeometryChange();
-
-    transformData->rotationZ = angle;
-    
-    transformData->dirty = true;
-    d_ptr->hasTransform = true;
-    d_ptr->invalidateSceneTransformCache();
-}
-
 /*!
     This virtual function is called twice for all items by the
     QGraphicsScene::advance() slot. In the first phase, all items are called
@@ -3177,11 +3403,11 @@ qreal QGraphicsItem::zValue() const
 /*!
     Sets the Z-value, or the elevation, of the item, to \a z. The elevation
     decides the stacking order of sibling (neighboring) items. An item of high
-    Z-value will be drawn on top of an item with a lower Z-value if they
-    share the same parent item. In addition, children of an item will always be drawn
-    on top of the parent, regardless of the child's Z-value. Sibling items
-    that share the same Z-value will be drawn in an undefined order, although
-    the order will stay the same for as long as the items live.
+    Z-value will be drawn on top of an item with a lower Z-value if they share
+    the same parent item. In addition, children of an item will always be
+    drawn on top of the parent, regardless of the child's Z-value. Sibling
+    items that share the same Z-value will be drawn in order of insertion; the
+    last inserted child is stacked above previous children.
 
     \img graphicsview-zorder.png
 
@@ -3209,7 +3435,7 @@ void QGraphicsItem::setZValue(qreal z)
     qreal newZ = qreal(newZVariant.toDouble());
     if (newZ == d_ptr->z)
         return;
-    d_ptr->z = z;
+    d_ptr->z = newZ;
     d_ptr->fullUpdateHelper();
 
     if (d_ptr->scene) {
@@ -3241,13 +3467,8 @@ void QGraphicsItem::setZValue(qreal z)
 QRectF QGraphicsItem::childrenBoundingRect() const
 {
     QRectF childRect;
-    foreach (QGraphicsItem *child, children()) {
-        QPointF childPos = child->pos();
-        QTransform matrix = child->transform();
-        if (!childPos.isNull())
-            matrix *= QTransform::fromTranslate(childPos.x(), childPos.y());
-        childRect |= matrix.mapRect(child->boundingRect() | child->childrenBoundingRect());
-    }
+    QTransform x;
+    d_ptr->childrenBoundingRectHelper(&x, &childRect);
     return childRect;
 }
 
@@ -3261,7 +3482,7 @@ QRectF QGraphicsItem::childrenBoundingRect() const
 
     Although the item's shape can be arbitrary, the bounding rect is
     always rectangular, and it is unaffected by the items'
-    transformation (scale(), rotate(), etc.).
+    transformation.
 
     If you want to change the item's bounding rectangle, you must first call
     prepareGeometryChange(). This notifies the scene of the imminent change,
@@ -3862,7 +4083,7 @@ void QGraphicsItem::setBoundingRegionGranularity(qreal granularity)
 
     All painting is done in local coordinates.
 
-    \sa setCacheMode(), QPen::width(), {Item Coordinates}
+    \sa setCacheMode(), QPen::width(), {Item Coordinates}, ItemUsesExtendedStyleOption
 */
 
 /*!
@@ -3953,7 +4174,7 @@ void QGraphicsItemPrivate::fullUpdateHelper(bool childrenOnly, bool maybeDirtyCl
     dirtyChildren = 1;
 }
 
-static inline bool qt_allChildrenCombineOpacity(QGraphicsItem *parent)
+static inline bool allChildrenCombineOpacityHelper(QGraphicsItem *parent)
 {
     Q_ASSERT(parent);
     if (parent->flags() & QGraphicsItem::ItemDoesntPropagateOpacityToChildren)
@@ -3972,11 +4193,11 @@ void QGraphicsItemPrivate::updateEffectiveOpacity()
     Q_Q(QGraphicsItem);
     if (parent) {
         resolveEffectiveOpacity(parent->effectiveOpacity());
-        parent->d_ptr->allChildrenCombineOpacity = qt_allChildrenCombineOpacity(parent);
+        parent->d_ptr->allChildrenCombineOpacity = allChildrenCombineOpacityHelper(parent);
     } else {
         resolveEffectiveOpacity(1.0);
     }
-    allChildrenCombineOpacity = qt_allChildrenCombineOpacity(q);
+    allChildrenCombineOpacity = allChildrenCombineOpacityHelper(q);
 }
 
 /*!
@@ -4003,7 +4224,7 @@ void QGraphicsItemPrivate::resolveEffectiveOpacity(qreal parentEffectiveOpacity)
     }
 
     // Set this item's resolved opacity.
-    if (qFuzzyCompare(myEffectiveOpacity, qreal(1.0))) {
+    if (qFuzzyIsNull(myEffectiveOpacity - 1)) {
         // Opaque, unset effective opacity.
         hasEffectiveOpacity = 0;
         unsetExtra(ExtraEffectiveOpacity);
@@ -4042,6 +4263,41 @@ void QGraphicsItemPrivate::invalidateSceneTransformCache()
         children.at(i)->d_ptr->invalidateSceneTransformCache();
 }
 
+/*!
+    \internal
+*/
+void QGraphicsItemPrivate::addChild(QGraphicsItem *child)
+{
+    child->d_ptr->siblingIndex = children.size();
+    children.append(child);
+}
+
+/*!
+    \internal
+*/
+void QGraphicsItemPrivate::removeChild(QGraphicsItem *child)
+{
+    int idx = child->d_ptr->siblingIndex;
+    int size = children.size();
+    for (int i = idx; i < size - 1; ++i) {
+        QGraphicsItem *p = children[i + 1];
+        children[i] = p;
+        p->d_ptr->siblingIndex = i;
+    }
+    children.removeLast();
+}
+
+/*!
+    \internal
+*/
+QGraphicsItemCache *QGraphicsItemPrivate::maybeExtraItemCache() const
+{
+    return (QGraphicsItemCache *)qVariantValue<void *>(extra(ExtraCacheData));
+}
+
+/*!
+    \internal
+*/
 QGraphicsItemCache *QGraphicsItemPrivate::extraItemCache() const
 {
     QGraphicsItemCache *c = (QGraphicsItemCache *)qVariantValue<void *>(extra(ExtraCacheData));
@@ -4053,6 +4309,9 @@ QGraphicsItemCache *QGraphicsItemPrivate::extraItemCache() const
     return c;
 }
 
+/*!
+    \internal
+*/
 void QGraphicsItemPrivate::removeExtraItemCache()
 {
     QGraphicsItemCache *c = (QGraphicsItemCache *)qVariantValue<void *>(extra(ExtraCacheData));
@@ -4208,11 +4467,13 @@ void QGraphicsItem::update(const QRectF &rect)
         }
 
         // Invalidate cache.
-        if (rect.isNull()) {
-            cache->allExposed = true;
-            cache->exposed.clear();
-        } else {
-            cache->exposed.append(rect);
+        if (!cache->allExposed) {
+            if (rect.isNull()) {
+                cache->allExposed = true;
+                cache->exposed.clear();
+            } else {
+                cache->exposed.append(rect);
+            }
         }
         // Only invalidate cache; item is already dirty.
         if (d_ptr->dirty)
@@ -4227,6 +4488,45 @@ void QGraphicsItem::update(const QRectF &rect)
     d_ptr->scene->itemUpdated(this, rect);
 }
 
+/*!
+    \internal
+
+    Scrolls \a rect in \a pix by \a dx, \a dy.
+
+    ### This can be done much more efficiently by using XCopyArea on X11 with
+    the same dst and src, and through moving pixels in the raster engine. It
+    can probably also be done much better on the other paint engines.
+*/
+void _q_scrollPixmap(QPixmap *pix, const QRect &rect, int dx, int dy)
+{
+#if 0
+    QPainter painter(pix);
+    painter.setClipRect(rect);
+    painter.drawPixmap(rect.translated(dx, dy), *pix, rect);
+    painter.end();
+#elif defined Q_WS_X11
+    GC gc = XCreateGC(X11->display, pix->handle(), 0, 0);
+
+    XRectangle xrect;
+    xrect.x = rect.x();
+    xrect.y = rect.y();
+    xrect.width = rect.width();
+    xrect.height = rect.height();
+    XSetClipRectangles(X11->display, gc, 0, 0, &xrect, 1, YXBanded);
+
+    XCopyArea(X11->display, pix->handle(), pix->handle(), gc,
+              rect.x(), rect.y(), rect.width(), rect.height(),
+              rect.x()+dx, rect.y()+dy);
+    XFreeGC(X11->display, gc);
+#else
+    QPixmap newPix = *pix;
+    QPainter painter(&newPix);
+    painter.setClipRect(rect);
+    painter.drawPixmap(rect.translated(dx, dy), *pix, rect);
+    painter.end();
+    *pix = newPix;
+#endif
+}
 
 /*!
     \since 4.4
@@ -4255,11 +4555,45 @@ void QGraphicsItem::scroll(qreal dx, qreal dy, const QRectF &rect)
     if (!d->scene)
         return;
     if (d->cacheMode != NoCache) {
-        // ### This is very slow, and can be done much better. If the cache is
-        // local and matches the below criteria for rotation and scaling, we
-        // can easily scroll. And if the cache is in device coordinates, we
-        // can scroll both the viewport and the cache.
-        update(rect);
+        QGraphicsItemCache *c;
+        bool scrollCache = qFuzzyIsNull(dx - int(dx)) && qFuzzyIsNull(dy - int(dy))
+                           && (c = (QGraphicsItemCache *)qVariantValue<void *>(d_ptr->extra(QGraphicsItemPrivate::ExtraCacheData)))
+                           && (d->cacheMode == ItemCoordinateCache && !c->fixedSize.isValid());
+        if (scrollCache) {
+            QPixmap pix;
+            if (QPixmapCache::find(c->key, &pix)) {
+                // Adjust with 2 pixel margin. Notice the loss of precision
+                // when converting to QRect.
+                int adjust = 2;
+                QRectF br = boundingRect().adjusted(-adjust, -adjust, adjust, adjust);
+                QRect irect = rect.toRect().translated(-br.x(), -br.y());
+
+                _q_scrollPixmap(&pix, irect, dx, dy);
+
+                QPixmapCache::replace(c->key, pix);
+
+                // Translate the existing expose.
+                foreach (QRectF exposedRect, c->exposed)
+                    c->exposed += exposedRect.translated(dx, dy) & rect;
+
+                // Calculate exposure.
+                QRegion exposed;
+                QRect r = rect.toRect();
+                exposed += r;
+                exposed -= r.translated(dx, dy);
+                foreach (QRect rect, exposed.rects())
+                    update(rect);
+                d_ptr->updateHelper();
+            } else {
+                update(rect);
+            }
+        } else {
+            // ### This is very slow, and can be done much better. If the cache is
+            // local and matches the below criteria for rotation and scaling, we
+            // can easily scroll. And if the cache is in device coordinates, we
+            // can scroll both the viewport and the cache.
+            update(rect);
+        }
         return;
     }
 
@@ -4416,7 +4750,9 @@ QPointF QGraphicsItem::mapToItem(const QGraphicsItem *item, const QPointF &point
 */
 QPointF QGraphicsItem::mapToParent(const QPointF &point) const
 {
-    return d_ptr->pos + (d_ptr->hasTransform ? transform().map(point) : point);
+    if (!d_ptr->hasTransform)
+        return point + d_ptr->pos;
+    return transform().map(point) + d_ptr->pos;
 }
 
 /*!
@@ -4481,9 +4817,9 @@ QPolygonF QGraphicsItem::mapToItem(const QGraphicsItem *item, const QRectF &rect
 */
 QPolygonF QGraphicsItem::mapToParent(const QRectF &rect) const
 {
-    QPolygonF p = !d_ptr->hasTransform ? rect : transform().map(rect);
-    p.translate(d_ptr->pos);
-    return p;
+    if (!d_ptr->hasTransform)
+        return rect.translated(d_ptr->pos);
+    return transform().map(rect).translated(d_ptr->pos);
 }
 
 /*!
@@ -4682,9 +5018,9 @@ QPolygonF QGraphicsItem::mapToItem(const QGraphicsItem *item, const QPolygonF &p
 */
 QPolygonF QGraphicsItem::mapToParent(const QPolygonF &polygon) const
 {
-    QPolygonF p = !d_ptr->hasTransform ? polygon : transform().map(polygon);
-    p.translate(d_ptr->pos);
-    return p;
+    if (!d_ptr->hasTransform)
+        return polygon.translated(d_ptr->pos);
+    return transform().map(polygon).translated(d_ptr->pos);
 }
 
 /*!
@@ -4726,10 +5062,9 @@ QPainterPath QGraphicsItem::mapToItem(const QGraphicsItem *item, const QPainterP
 */
 QPainterPath QGraphicsItem::mapToParent(const QPainterPath &path) const
 {
-    QTransform x = QTransform::fromTranslate(d_ptr->pos.x(), d_ptr->pos.y());
-    if (d_ptr->hasTransform)
-        x = transform() * x;
-    return x.map(path);
+    if (!d_ptr->hasTransform)
+        return path.translated(d_ptr->pos);
+    return transform().map(path).translated(d_ptr->pos);
 }
 
 /*!
@@ -4944,9 +5279,9 @@ QPainterPath QGraphicsItem::mapFromItem(const QGraphicsItem *item, const QPainte
 */
 QPainterPath QGraphicsItem::mapFromParent(const QPainterPath &path) const
 {
-    if (d_ptr->parent)
-        return d_ptr->parent->itemTransform(this).map(path);
-    return mapFromScene(path);
+    QPainterPath p(path);
+    p.translate(-d_ptr->pos);
+    return d_ptr->hasTransform ? transform().inverted().map(p) : p;
 }
 
 /*!
@@ -5985,7 +6320,7 @@ static void qt_graphicsItem_highlightSelected(
     QGraphicsItem *item, QPainter *painter, const QStyleOptionGraphicsItem *option)
 {
     const QRectF murect = painter->transform().mapRect(QRectF(0, 0, 1, 1));
-    if (qFuzzyCompare(qMax(murect.width(), murect.height()) + 1, 1))
+    if (qFuzzyIsNull(qMax(murect.width(), murect.height())))
         return;
 
     const QRectF mbrect = painter->transform().mapRect(item->boundingRect());
@@ -7712,9 +8047,7 @@ void QGraphicsPixmapItem::paint(QPainter *painter, const QStyleOptionGraphicsIte
     painter->setRenderHint(QPainter::SmoothPixmapTransform,
                            (d->transformationMode == Qt::SmoothTransformation));
 
-    QRectF exposed = option->exposedRect.adjusted(-1, -1, 1, 1);
-    exposed &= QRectF(d->offset.x(), d->offset.y(), d->pixmap.width(), d->pixmap.height());
-    painter->drawPixmap(exposed, d->pixmap, exposed.translated(-d->offset));
+    painter->drawPixmap(d->offset, d->pixmap);
 
     if (option->state & QStyle::State_Selected)
         qt_graphicsItem_highlightSelected(this, painter, option);
@@ -7880,6 +8213,7 @@ QGraphicsTextItem::QGraphicsTextItem(const QString &text, QGraphicsItem *parent
         setPlainText(text);
     setAcceptDrops(true);
     setAcceptHoverEvents(true);
+    setFlags(ItemUsesExtendedStyleOption);
 }
 
 /*!
@@ -7899,6 +8233,7 @@ QGraphicsTextItem::QGraphicsTextItem(QGraphicsItem *parent
     dd->qq = this;
     setAcceptDrops(true);
     setAcceptHoverEvents(true);
+    setFlag(ItemUsesExtendedStyleOption);
 }
 
 /*!
@@ -8169,19 +8504,19 @@ bool QGraphicsTextItem::sceneEvent(QEvent *event)
 void QGraphicsTextItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
 {
     if ((QGraphicsItem::d_ptr->flags & (ItemIsSelectable | ItemIsMovable))
-	&& (event->buttons() & Qt::LeftButton) && dd->_q_mouseOnEdge(event)) {
-	// User left-pressed on edge of selectable/movable item, use
-	// base impl.
-	dd->useDefaultImpl = true;
+        && (event->buttons() & Qt::LeftButton) && dd->_q_mouseOnEdge(event)) {
+        // User left-pressed on edge of selectable/movable item, use
+        // base impl.
+        dd->useDefaultImpl = true;
     } else if (event->buttons() == event->button()
-	       && dd->control->textInteractionFlags() == Qt::NoTextInteraction) {
-	// User pressed first button on non-interactive item.
-	dd->useDefaultImpl = true;
+               && dd->control->textInteractionFlags() == Qt::NoTextInteraction) {
+        // User pressed first button on non-interactive item.
+        dd->useDefaultImpl = true;
     }
     if (dd->useDefaultImpl) {
         QGraphicsItem::mousePressEvent(event);
-	if (!event->isAccepted())
-	    dd->useDefaultImpl = false;
+        if (!event->isAccepted())
+            dd->useDefaultImpl = false;
         return;
     }
     dd->sendControlEvent(event);
@@ -8206,14 +8541,14 @@ void QGraphicsTextItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
 {
     if (dd->useDefaultImpl) {
         QGraphicsItem::mouseReleaseEvent(event);
-	if (dd->control->textInteractionFlags() == Qt::NoTextInteraction
-	    && !event->buttons()) {
-	    // User released last button on non-interactive item.
+        if (dd->control->textInteractionFlags() == Qt::NoTextInteraction
+            && !event->buttons()) {
+            // User released last button on non-interactive item.
             dd->useDefaultImpl = false;
-	} else  if ((event->buttons() & Qt::LeftButton) == 0) {
-	    // User released the left button on an interactive item.
+        } else  if ((event->buttons() & Qt::LeftButton) == 0) {
+            // User released the left button on an interactive item.
             dd->useDefaultImpl = false;
-	}
+        }
         return;
     }
     dd->sendControlEvent(event);
@@ -9244,6 +9579,9 @@ QDebug operator<<(QDebug debug, QGraphicsItem::GraphicsItemFlag flag)
     case QGraphicsItem::ItemStacksBehindParent:
         str = "ItemStacksBehindParent";
         break;
+    case QGraphicsItem::ItemUsesExtendedStyleOption:
+        str = "ItemUsesExtendedStyleOption";
+        break;
     }
     debug << str;
     return debug;
diff --git a/src/gui/graphicsview/qgraphicsitem.h b/src/gui/graphicsview/qgraphicsitem.h
index 1fce3db..f6ee197 100644
--- a/src/gui/graphicsview/qgraphicsitem.h
+++ b/src/gui/graphicsview/qgraphicsitem.h
@@ -94,7 +94,9 @@ public:
         ItemIgnoresTransformations = 0x20,
         ItemIgnoresParentOpacity = 0x40,
         ItemDoesntPropagateOpacityToChildren = 0x80,
-        ItemStacksBehindParent = 0x100
+        ItemStacksBehindParent = 0x100,
+        ItemUsesExtendedStyleOption = 0x200
+        // NB! Don't forget to increase the d_ptr->flags bit field by 1 when adding a new flag.
     };
     Q_DECLARE_FLAGS(GraphicsItemFlags, GraphicsItemFlag)
 
@@ -240,25 +242,39 @@ public:
     void setTransform(const QTransform &matrix, bool combine = false);
     void resetTransform();
 
-    // ### obsolete?
-    void rotate(qreal angle);
-    void scale(qreal sx, qreal sy);
-    void shear(qreal sh, qreal sv);
-    void translate(qreal dx, qreal dy);
+    void rotate(qreal angle);           // ### obsolete
+    void scale(qreal sx, qreal sy);     // ### obsolete
+    void shear(qreal sh, qreal sv);     // ### obsolete
+    void translate(qreal dx, qreal dy); // ### obsolete
 
-    // ### experimental
-    QPointF transformOrigin() const;
-    void setTransformOrigin(const QPointF &center);
-    qreal xScale() const;
-    void setXScale(qreal factor);
-    qreal yScale() const;
-    void setYScale(qreal factor);
     qreal xRotation() const;
     void setXRotation(qreal angle);
+
     qreal yRotation() const;
     void setYRotation(qreal angle);
+
     qreal zRotation() const;
     void setZRotation(qreal angle);
+    void setRotation(qreal x, qreal y, qreal z);
+
+    qreal xScale() const;
+    void setXScale(qreal factor);
+
+    qreal yScale() const;
+    void setYScale(qreal factor);
+    void setScale(qreal sx, qreal sy);
+
+    qreal horizontalShear() const;
+    void setHorizontalShear(qreal shear);
+
+    qreal verticalShear() const;
+    void setVerticalShear(qreal shear);
+    void setShear(qreal sh, qreal sv);
+
+    QPointF transformOrigin() const;
+    void setTransformOrigin(const QPointF &origin);
+    inline void setTransformOrigin(qreal x, qreal y)
+    { setTransformOrigin(QPointF(x,y)); }
 
     virtual void advance(int phase);
 
@@ -1029,4 +1045,3 @@ QT_END_NAMESPACE
 QT_END_HEADER
 
 #endif // QGRAPHICSITEM_H
-
diff --git a/src/gui/graphicsview/qgraphicsitem_p.h b/src/gui/graphicsview/qgraphicsitem_p.h
index e8ab63d..1070e5f 100644
--- a/src/gui/graphicsview/qgraphicsitem_p.h
+++ b/src/gui/graphicsview/qgraphicsitem_p.h
@@ -54,6 +54,9 @@
 //
 
 #include "qgraphicsitem.h"
+#include "qpixmapcache.h"
+
+#include <QtCore/qpoint.h>
 
 #if !defined(QT_NO_GRAPHICSVIEW) || (QT_EDITION & QT_MODULE_GRAPHICSVIEW) != QT_MODULE_GRAPHICSVIEW
 
@@ -69,13 +72,14 @@ public:
     // ItemCoordinateCache only
     QRect boundingRect;
     QSize fixedSize;
-    QString key;
+    QPixmapCache::Key key;
 
     // DeviceCoordinateCache only
     struct DeviceData {
+        DeviceData() {}
         QTransform lastTransform;
         QPoint cacheIndent;
-        QString key;
+        QPixmapCache::Key key;
     };
     QMap<QPaintDevice *, DeviceData> deviceData;
 
@@ -108,7 +112,8 @@ public:
         ExtraMaxDeviceCoordCacheSize,
         ExtraBoundingRegionGranularity,
         ExtraOpacity,
-        ExtraEffectiveOpacity
+        ExtraEffectiveOpacity,
+        ExtraDecomposedTransform
     };
 
     enum AncestorFlag {
@@ -122,6 +127,7 @@ public:
         : z(0),
         scene(0),
         parent(0),
+        siblingIndex(-1),
         index(-1),
         depth(0),
         acceptedMouseButtons(0x1f),
@@ -140,7 +146,6 @@ public:
         ancestorFlags(0),
         cacheMode(0),
         hasBoundingRegionGranularity(0),
-        flags(0),
         hasOpacity(0),
         hasEffectiveOpacity(0),
         isWidget(0),
@@ -150,7 +155,11 @@ public:
         dirtyClipPath(1),
         emptyClipPath(0),
         inSetPosHelper(0),
+        flags(0),
         allChildrenCombineOpacity(1),
+        hasDecomposedTransform(0),
+        dirtyTransform(0),
+        dirtyTransformComponents(0),
         globalStackingOrder(-1),
         sceneTransformIndex(-1),
         q_ptr(0)
@@ -182,6 +191,12 @@ public:
     void resolveEffectiveOpacity(qreal effectiveParentOpacity);
     void resolveDepth(int parentDepth);
     void invalidateSceneTransformCache();
+    void addChild(QGraphicsItem *child);
+    void removeChild(QGraphicsItem *child);
+    void setParentItemHelper(QGraphicsItem *parent, bool deleting);
+    void childrenBoundingRectHelper(QTransform *x, QRectF *rect);
+    void initStyleOption(QStyleOptionGraphicsItem *option, const QTransform &worldTransform,
+                         const QRegion &exposedRegion, bool allItems = false) const;
 
     virtual void resolveFont(uint inheritedMask)
     {
@@ -248,6 +263,7 @@ public:
     
     QList<ExtraStruct> extras;
 
+    QGraphicsItemCache *maybeExtraItemCache() const;
     QGraphicsItemCache *extraItemCache() const;
     void removeExtraItemCache();
 
@@ -273,7 +289,7 @@ public:
     void updateCachedClipPathFromSetPosHelper(const QPointF &newPos);
 
     inline bool isFullyTransparent() const
-    { return hasEffectiveOpacity && qFuzzyCompare(q_func()->effectiveOpacity() + 1, qreal(1.0)); }
+    { return hasEffectiveOpacity && qFuzzyIsNull(q_func()->effectiveOpacity()); }
 
     inline bool childrenCombineOpacity() const
     { return allChildrenCombineOpacity || children.isEmpty(); }
@@ -297,10 +313,11 @@ public:
     QGraphicsScene *scene;
     QGraphicsItem *parent;
     QList<QGraphicsItem *> children;
+    int siblingIndex;
     int index;
     int depth;
 
-    // Packed 32 bytes
+    // Packed 32 bits
     quint32 acceptedMouseButtons : 5;
     quint32 visible : 1;
     quint32 explicitlyHidden : 1;
@@ -317,9 +334,6 @@ public:
     quint32 ancestorFlags : 3;
     quint32 cacheMode : 2;
     quint32 hasBoundingRegionGranularity : 1;
-    quint32 flags : 9;
-
-    // New 32 bytes
     quint32 hasOpacity : 1;
     quint32 hasEffectiveOpacity : 1;
     quint32 isWidget : 1;
@@ -329,15 +343,88 @@ public:
     quint32 dirtyClipPath : 1;
     quint32 emptyClipPath : 1;
     quint32 inSetPosHelper : 1;
+
+    // New 32 bits
+    quint32 flags : 10;
     quint32 allChildrenCombineOpacity : 1;
+    quint32 hasDecomposedTransform : 1;
+    quint32 dirtyTransform : 1;
+    quint32 dirtyTransformComponents : 1;
+    quint32 padding : 18; // feel free to use
 
     // Optional stacking order
     int globalStackingOrder;
     int sceneTransformIndex;
 
+    struct DecomposedTransform;    
+    DecomposedTransform *decomposedTransform() const
+    {
+        QGraphicsItemPrivate *that = const_cast<QGraphicsItemPrivate *>(this);
+        DecomposedTransform *decomposed;
+        if (hasDecomposedTransform) {
+            decomposed = qVariantValue<DecomposedTransform *>(extra(ExtraDecomposedTransform));
+        } else {
+            decomposed = new DecomposedTransform;
+            that->setExtra(ExtraDecomposedTransform, qVariantFromValue<DecomposedTransform *>(decomposed));
+            that->hasDecomposedTransform = 1;
+            if (!dirtyTransformComponents)
+                decomposed->reset();
+        }
+        if (dirtyTransformComponents) {
+            decomposed->initFrom(q_ptr->transform());
+            that->dirtyTransformComponents = 0;
+        }
+        return decomposed;
+    }
+
+    struct DecomposedTransform {
+        qreal xScale;
+        qreal yScale;
+        qreal xRotation;
+        qreal yRotation;
+        qreal zRotation;
+        qreal horizontalShear;
+        qreal verticalShear;
+        qreal xOrigin;
+        qreal yOrigin;
+
+        inline void reset()
+        {
+            xScale = 1.0;
+            yScale = 1.0;
+            xRotation = 0.0;
+            yRotation = 0.0;
+            zRotation = 0.0;
+            horizontalShear = 0.0;
+            verticalShear = 0.0;
+            xOrigin = 0.0;
+            yOrigin = 0.0;
+        }
+
+        inline void initFrom(const QTransform &x)
+        {
+            reset();
+            // ### decompose transform
+            Q_UNUSED(x);
+        }
+
+        inline void generateTransform(QTransform *x) const
+        {
+            x->translate(xOrigin, yOrigin);
+            x->rotate(xRotation, Qt::XAxis);
+            x->rotate(yRotation, Qt::YAxis);
+            x->rotate(zRotation, Qt::ZAxis);
+            x->shear(horizontalShear, verticalShear);
+            x->scale(xScale, yScale);
+            x->translate(-xOrigin, -yOrigin);
+        }
+    };
+
     QGraphicsItem *q_ptr;
 };
 
+Q_DECLARE_METATYPE(QGraphicsItemPrivate::DecomposedTransform *)
+
 QT_END_NAMESPACE
 
 #endif // QT_NO_GRAPHICSVIEW
diff --git a/src/gui/graphicsview/qgraphicslayoutitem.cpp b/src/gui/graphicsview/qgraphicslayoutitem.cpp
index eaa97ff..b58eb53 100644
--- a/src/gui/graphicsview/qgraphicslayoutitem.cpp
+++ b/src/gui/graphicsview/qgraphicslayoutitem.cpp
@@ -108,13 +108,22 @@ static void normalizeHints(qreal &minimum, qreal &preferred, qreal &maximum, qre
     \internal
 */
 QGraphicsLayoutItemPrivate::QGraphicsLayoutItemPrivate(QGraphicsLayoutItem *par, bool layout)
-    : parent(par), isLayout(layout), ownedByLayout(false), graphicsItem(0)
+    : parent(par), userSizeHints(0), isLayout(layout), ownedByLayout(false), graphicsItem(0)
 {
 }
 
 /*!
     \internal
 */
+QGraphicsLayoutItemPrivate::~QGraphicsLayoutItemPrivate()
+{
+    // Remove any lazily allocated data
+    delete[] userSizeHints;
+}
+
+/*!
+    \internal
+*/
 void QGraphicsLayoutItemPrivate::init()
 {
     sizeHintCacheDirty = true;
@@ -132,7 +141,8 @@ QSizeF *QGraphicsLayoutItemPrivate::effectiveSizeHints(const QSizeF &constraint)
 
     for (int i = 0; i < Qt::NSizeHints; ++i) {
         cachedSizeHints[i] = constraint;
-        combineSize(cachedSizeHints[i], userSizeHints[i]);
+        if (userSizeHints)
+            combineSize(cachedSizeHints[i], userSizeHints[i]);
     }
 
     QSizeF &minS = cachedSizeHints[Qt::MinimumSize];
@@ -198,6 +208,58 @@ QGraphicsItem *QGraphicsLayoutItemPrivate::parentItem() const
 }
 
 /*!
+    \internal
+
+     Ensures that userSizeHints is allocated.
+     This function must be called before any dereferencing.
+*/
+void QGraphicsLayoutItemPrivate::ensureUserSizeHints()
+{
+    if (!userSizeHints)
+        userSizeHints = new QSizeF[Qt::NSizeHints];
+}
+
+/*!
+    \internal
+
+    Sets the user size hint \a which to \a size. Use an invalid size to unset the size hint.
+ */
+void QGraphicsLayoutItemPrivate::setSize(Qt::SizeHint which, const QSizeF &size)
+{
+    Q_Q(QGraphicsLayoutItem);
+
+    if (userSizeHints) {
+        if (size == userSizeHints[which])
+            return;
+    } else if (!size.isValid()) {
+        return;
+    }
+
+    ensureUserSizeHints();
+    userSizeHints[which] = size;
+    q->updateGeometry();
+}
+
+/*!
+    \internal
+
+    Sets the width of the user size hint \a which to \a width.
+ */
+void QGraphicsLayoutItemPrivate::setSizeComponent(
+    Qt::SizeHint which, SizeComponent component, qreal value)
+{
+    Q_Q(QGraphicsLayoutItem);
+    ensureUserSizeHints();
+    qreal &userValue = (component == Width)
+        ? userSizeHints[which].rwidth()
+        : userSizeHints[which].rheight();
+    if (value == userValue)
+        return;
+    userValue = value;
+    q->updateGeometry();
+}
+
+/*!
     \class QGraphicsLayoutItem
     \brief The QGraphicsLayoutItem class can be inherited to allow your custom
     items to be managed by layouts.
@@ -255,7 +317,7 @@ QGraphicsItem *QGraphicsLayoutItemPrivate::parentItem() const
     passing a QGraphicsLayoutItem pointer to QGraphicsLayoutItem's
     protected constructor, or by calling setParentLayoutItem(). The
     parentLayoutItem() function returns a pointer to the item's layoutItem
-    parent. If the item's parent is 0 or if the the parent does not inherit
+    parent. If the item's parent is 0 or if the parent does not inherit
     from QGraphicsItem, the parentLayoutItem() function then returns 0.
     isLayout() returns true if the QGraphicsLayoutItem subclass is itself a
     layout, or false otherwise.
@@ -381,12 +443,7 @@ QSizePolicy QGraphicsLayoutItem::sizePolicy() const
 */
 void QGraphicsLayoutItem::setMinimumSize(const QSizeF &size)
 {
-    Q_D(QGraphicsLayoutItem);
-    if (size == d->userSizeHints[Qt::MinimumSize])
-        return;
-
-    d->userSizeHints[Qt::MinimumSize] = size;
-    updateGeometry();
+    d_ptr->setSize(Qt::MinimumSize, size);
 }
 
 /*!
@@ -416,12 +473,7 @@ QSizeF QGraphicsLayoutItem::minimumSize() const
 */
 void QGraphicsLayoutItem::setMinimumWidth(qreal width)
 {
-    Q_D(QGraphicsLayoutItem);
-    qreal &userSizeHint = d->userSizeHints[Qt::MinimumSize].rwidth();
-    if (width == userSizeHint)
-        return;
-    userSizeHint = width;
-    updateGeometry();
+    d_ptr->setSizeComponent(Qt::MinimumSize, d_ptr->Width, width);
 }
 
 /*!
@@ -431,12 +483,7 @@ void QGraphicsLayoutItem::setMinimumWidth(qreal width)
 */
 void QGraphicsLayoutItem::setMinimumHeight(qreal height)
 {
-    Q_D(QGraphicsLayoutItem);
-    qreal &userSizeHint = d->userSizeHints[Qt::MinimumSize].rheight();
-    if (height == userSizeHint)
-        return;
-    userSizeHint = height;
-    updateGeometry();
+    d_ptr->setSizeComponent(Qt::MinimumSize, d_ptr->Height, height);
 }
 
 
@@ -450,12 +497,7 @@ void QGraphicsLayoutItem::setMinimumHeight(qreal height)
 */
 void QGraphicsLayoutItem::setPreferredSize(const QSizeF &size)
 {
-    Q_D(QGraphicsLayoutItem);
-    if (size == d->userSizeHints[Qt::PreferredSize])
-        return;
-
-    d->userSizeHints[Qt::PreferredSize] = size;
-    updateGeometry();
+    d_ptr->setSize(Qt::PreferredSize, size);
 }
 
 /*!
@@ -485,12 +527,7 @@ QSizeF QGraphicsLayoutItem::preferredSize() const
 */
 void QGraphicsLayoutItem::setPreferredHeight(qreal height)
 {
-    Q_D(QGraphicsLayoutItem);
-    qreal &userSizeHint = d->userSizeHints[Qt::PreferredSize].rheight();
-    if (height == userSizeHint)
-        return;
-    userSizeHint = height;
-    updateGeometry();
+    d_ptr->setSizeComponent(Qt::PreferredSize, d_ptr->Height, height);
 }
 
 /*!
@@ -500,12 +537,7 @@ void QGraphicsLayoutItem::setPreferredHeight(qreal height)
 */
 void QGraphicsLayoutItem::setPreferredWidth(qreal width)
 {
-    Q_D(QGraphicsLayoutItem);
-    qreal &userSizeHint = d->userSizeHints[Qt::PreferredSize].rwidth();
-    if (width == userSizeHint)
-        return;
-    userSizeHint = width;
-    updateGeometry();
+    d_ptr->setSizeComponent(Qt::PreferredSize, d_ptr->Width, width);
 }
 
 /*!
@@ -519,12 +551,7 @@ void QGraphicsLayoutItem::setPreferredWidth(qreal width)
 */
 void QGraphicsLayoutItem::setMaximumSize(const QSizeF &size)
 {
-    Q_D(QGraphicsLayoutItem);
-    if (size == d->userSizeHints[Qt::MaximumSize])
-        return;
-
-    d->userSizeHints[Qt::MaximumSize] = size;
-    updateGeometry();
+    d_ptr->setSize(Qt::MaximumSize, size);
 }
 
 /*!
@@ -554,12 +581,7 @@ QSizeF QGraphicsLayoutItem::maximumSize() const
 */
 void QGraphicsLayoutItem::setMaximumWidth(qreal width)
 {
-    Q_D(QGraphicsLayoutItem);
-    qreal &userSizeHint = d->userSizeHints[Qt::MaximumSize].rwidth();
-    if (width == userSizeHint)
-        return;
-    userSizeHint = width;
-    updateGeometry();
+    d_ptr->setSizeComponent(Qt::MaximumSize, d_ptr->Width, width);
 }
 
 /*!
@@ -569,12 +591,7 @@ void QGraphicsLayoutItem::setMaximumWidth(qreal width)
 */
 void QGraphicsLayoutItem::setMaximumHeight(qreal height)
 {
-    Q_D(QGraphicsLayoutItem);
-    qreal &userSizeHint = d->userSizeHints[Qt::MaximumSize].rheight();
-    if (height == userSizeHint)
-        return;
-    userSizeHint = height;
-    updateGeometry();
+    d_ptr->setSizeComponent(Qt::MaximumSize, d_ptr->Height, height);
 }
 
 /*!
@@ -732,6 +749,11 @@ QRectF QGraphicsLayoutItem::contentsRect() const
 */
 QSizeF QGraphicsLayoutItem::effectiveSizeHint(Qt::SizeHint which, const QSizeF &constraint) const
 {
+    Q_D(const QGraphicsLayoutItem);
+
+    if (!d->userSizeHints && constraint.isValid())
+        return constraint;
+
     // ### should respect size policy???
     return d_ptr->effectiveSizeHints(constraint)[which];
 }
diff --git a/src/gui/graphicsview/qgraphicslayoutitem_p.h b/src/gui/graphicsview/qgraphicslayoutitem_p.h
index fab0f39..dc044e6 100644
--- a/src/gui/graphicsview/qgraphicslayoutitem_p.h
+++ b/src/gui/graphicsview/qgraphicslayoutitem_p.h
@@ -63,16 +63,20 @@ class Q_AUTOTEST_EXPORT QGraphicsLayoutItemPrivate
 {
     Q_DECLARE_PUBLIC(QGraphicsLayoutItem)
 public:
-    virtual ~QGraphicsLayoutItemPrivate() {}
+    virtual ~QGraphicsLayoutItemPrivate();
     QGraphicsLayoutItemPrivate(QGraphicsLayoutItem *parent, bool isLayout);
     void init();
     QSizeF *effectiveSizeHints(const QSizeF &constraint) const;
     QGraphicsItem *parentItem() const;
+    void ensureUserSizeHints();
+    void setSize(Qt::SizeHint which, const QSizeF &size);
+    enum SizeComponent { Width, Height };
+    void setSizeComponent(Qt::SizeHint which, SizeComponent component, qreal value);
 
     QSizePolicy sizePolicy;
     QGraphicsLayoutItem *parent;
 
-    QSizeF userSizeHints[Qt::NSizeHints];
+    QSizeF *userSizeHints;
     mutable QSizeF cachedSizeHints[Qt::NSizeHints];
     mutable QSizeF cachedConstraint;
 
diff --git a/src/gui/graphicsview/qgraphicsproxywidget.cpp b/src/gui/graphicsview/qgraphicsproxywidget.cpp
index 973254f..a5b11ff 100644
--- a/src/gui/graphicsview/qgraphicsproxywidget.cpp
+++ b/src/gui/graphicsview/qgraphicsproxywidget.cpp
@@ -460,7 +460,7 @@ void QGraphicsProxyWidgetPrivate::embedSubWindow(QWidget *subWin)
 {
     QWExtra *extra;
     if (!((extra = subWin->d_func()->extra) && extra->proxyWidget)) {
-        QGraphicsProxyWidget *subProxy = new QGraphicsProxyWidget(q_func());
+        QGraphicsProxyWidget *subProxy = new QGraphicsProxyWidget(q_func(), subWin->windowFlags());
         subProxy->d_func()->setWidget_helper(subWin, false);
     }
 }
@@ -544,6 +544,9 @@ QGraphicsProxyWidget::~QGraphicsProxyWidget()
     hidden or disabled after embedding is complete. The class documentation
     has a full overview over the shared state.
 
+    QGraphicsProxyWidget's window flags determine whether the widget, after
+    embedding, will be given window decorations or not.
+
     After this function returns, QGraphicsProxyWidget will keep its state
     synchronized with that of \a widget whenever possible.
 
@@ -661,10 +664,6 @@ void QGraphicsProxyWidgetPrivate::setWidget_helper(QWidget *newWidget, bool auto
     if (newWidget->testAttribute(Qt::WA_SetCursor))
         q->setCursor(widget->cursor());
 #endif
-    Qt::WFlags flags = newWidget->windowFlags();
-    if (newWidget->windowType() == Qt::Window)
-        flags &= ~Qt::Window;
-    q->setWindowFlags(flags);
     q->setEnabled(newWidget->isEnabled());
     q->setVisible(newWidget->isVisible());
     q->setLayoutDirection(newWidget->layoutDirection());
diff --git a/src/gui/graphicsview/qgraphicsscene.cpp b/src/gui/graphicsview/qgraphicsscene.cpp
index 13f70e5..1fbda85 100644
--- a/src/gui/graphicsview/qgraphicsscene.cpp
+++ b/src/gui/graphicsview/qgraphicsscene.cpp
@@ -351,6 +351,8 @@ QGraphicsScenePrivate::QGraphicsScenePrivate()
       dragDropItem(0),
       enterWidget(0),
       lastDropAction(Qt::IgnoreAction),
+      allItemsIgnoreHoverEvents(true),
+      allItemsUseDefaultCursor(true),
       painterStateProtection(true),
       sortCacheEnabled(false),
       updatingSortCache(false),
@@ -622,6 +624,30 @@ void QGraphicsScenePrivate::_q_emitUpdated()
 
 /*!
     \internal
+*/
+void QGraphicsScenePrivate::registerTopLevelItem(QGraphicsItem *item)
+{
+    item->d_ptr->siblingIndex = topLevelItems.size();
+    topLevelItems.append(item);
+}
+
+/*!
+    \internal
+*/
+void QGraphicsScenePrivate::unregisterTopLevelItem(QGraphicsItem *item)
+{
+    int idx = item->d_ptr->siblingIndex;
+    int size = topLevelItems.size();
+    for (int i = idx; i < size - 1; ++i) {
+        QGraphicsItem *p = topLevelItems[i + 1];
+        topLevelItems[i] = p;
+        p->d_ptr->siblingIndex = i;
+    }
+    topLevelItems.removeLast();
+}
+
+/*!
+    \internal
 
     Updates all items in the pending update list. At this point, the list is
     unlikely to contain partially constructed items.
@@ -756,10 +782,6 @@ void QGraphicsScenePrivate::_q_removeItemLater(QGraphicsItem *item)
         freeSceneTransformSlots.append(transformIndex);
     }
 
-    // Remove all children recursively.
-    foreach (QGraphicsItem *child, item->children())
-        _q_removeItemLater(child);
-
     // Reset the mouse grabber
     if (mouseGrabberItems.contains(item))
         ungrabMouse(item, /* item is dying */ true);
@@ -880,11 +902,18 @@ void QGraphicsScenePrivate::grabMouse(QGraphicsItem *item, bool implicit)
 {
     // Append to list of mouse grabber items, and send a mouse grab event.
     if (mouseGrabberItems.contains(item)) {
-        if (mouseGrabberItems.last() == item)
-            qWarning("QGraphicsItem::grabMouse: already a mouse grabber");
-        else
+        if (mouseGrabberItems.last() == item) {
+            Q_ASSERT(!implicit);
+            if (!lastMouseGrabberItemHasImplicitMouseGrab) {
+                qWarning("QGraphicsItem::grabMouse: already a mouse grabber");
+            } else {
+                // Upgrade to an explicit mouse grab
+                lastMouseGrabberItemHasImplicitMouseGrab = false;
+            }
+        } else {
             qWarning("QGraphicsItem::grabMouse: already blocked by mouse grabber: %p",
                      mouseGrabberItems.last());
+        }
         return;
     }
 
@@ -1036,6 +1065,12 @@ void QGraphicsScenePrivate::clearKeyboardGrabber()
         ungrabKeyboard(keyboardGrabberItems.first());
 }
 
+void QGraphicsScenePrivate::enableMouseTrackingOnViews()
+{
+    foreach (QGraphicsView *view, views)
+        view->viewport()->setMouseTracking(true);
+}
+
 /*!
     Returns all items for the screen position in \a event.
 */
@@ -1294,7 +1329,8 @@ void QGraphicsScenePrivate::mousePressEventHandler(QGraphicsSceneMouseEvent *mou
         // check if the item we are sending to are disabled (before we send the event)
         bool disabled = !item->isEnabled();
         bool isWindow = item->isWindow();
-        if (mouseEvent->type() == QEvent::GraphicsSceneMouseDoubleClick && item != lastMouseGrabberItem) {
+        if (mouseEvent->type() == QEvent::GraphicsSceneMouseDoubleClick
+            && item != lastMouseGrabberItem && lastMouseGrabberItem) {
             // If this item is different from the item that received the last
             // mouse event, and mouseEvent is a doubleclick event, then the
             // event is converted to a press. Known limitation:
@@ -1831,7 +1867,7 @@ inline bool qt_closestLeaf(const QGraphicsItem *item1, const QGraphicsItem *item
     if (f1 != f2) return f2;
     qreal z1 = d1->z;
     qreal z2 = d2->z;
-    return z1 != z2 ? z1 > z2 : item1 > item2;
+    return z1 != z2 ? z1 > z2 : d1->siblingIndex > d2->siblingIndex;
 }
 
 /*!
@@ -2211,8 +2247,6 @@ void QGraphicsScene::setSceneRect(const QRectF &rect)
 void QGraphicsScene::render(QPainter *painter, const QRectF &target, const QRectF &source,
                             Qt::AspectRatioMode aspectRatioMode)
 {
-    Q_D(QGraphicsScene);
-
     // Default source rect = scene rect
     QRectF sourceRect = source;
     if (sourceRect.isNull())
@@ -2269,41 +2303,8 @@ void QGraphicsScene::render(QPainter *painter, const QRectF &target, const QRect
 
     // Generate the style options
     QStyleOptionGraphicsItem *styleOptionArray = new QStyleOptionGraphicsItem[numItems];
-    for (int i = 0; i < numItems; ++i) {
-        QGraphicsItem *item = itemArray[i];
-
-        QStyleOptionGraphicsItem option;
-        option.state = QStyle::State_None;
-        option.rect = item->boundingRect().toRect();
-        if (item->isSelected())
-            option.state |= QStyle::State_Selected;
-        if (item->isEnabled())
-            option.state |= QStyle::State_Enabled;
-        if (item->hasFocus())
-            option.state |= QStyle::State_HasFocus;
-        if (d->hoverItems.contains(item))
-            option.state |= QStyle::State_MouseOver;
-        if (item == mouseGrabberItem())
-            option.state |= QStyle::State_Sunken;
-
-        // Calculate a simple level-of-detail metric.
-        // ### almost identical code in QGraphicsView::paintEvent()
-        //     and QGraphicsView::render() - consider refactoring
-        QTransform itemToDeviceTransform;
-        if (item->d_ptr->itemIsUntransformable()) {
-            itemToDeviceTransform = item->deviceTransform(painterTransform);
-        } else {
-            itemToDeviceTransform = item->sceneTransform() * painterTransform;
-        }
-
-        option.levelOfDetail = qSqrt(itemToDeviceTransform.map(v1).length() * itemToDeviceTransform.map(v2).length());
-        option.matrix = itemToDeviceTransform.toAffine(); //### discards perspective
-
-        option.exposedRect = item->boundingRect();
-        option.exposedRect &= itemToDeviceTransform.inverted().mapRect(targetRect);
-
-        styleOptionArray[i] = option;
-    }
+    for (int i = 0; i < numItems; ++i)
+        itemArray[i]->d_ptr->initStyleOption(&styleOptionArray[i], painterTransform, targetRect.toRect());
 
     // Render the scene.
     drawBackground(painter, sourceRect);
@@ -2747,12 +2748,13 @@ void QGraphicsScene::clear()
     }
     d->unindexedItems.clear();
     qDeleteAll(unindexedParents);
-
     d->indexedItems.clear();
     d->freeItemIndexes.clear();
     d->lastItemCount = 0;
     d->bspTree.clear();
     d->largestUntransformableItem = QRectF();
+    d->allItemsIgnoreHoverEvents = true;
+    d->allItemsUseDefaultCursor = true;
 }
 
 /*!
@@ -2856,7 +2858,6 @@ void QGraphicsScene::addItem(QGraphicsItem *item)
         qWarning("QGraphicsScene::addItem: item has already been added to this scene");
         return;
     }
-
     // Remove this item from its existing scene
     if (QGraphicsScene *oldScene = item->scene())
         oldScene->removeItem(item);
@@ -2897,6 +2898,10 @@ void QGraphicsScene::addItem(QGraphicsItem *item)
     item->d_func()->index = -1;
     d->startIndexTimer();
 
+    // 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();
@@ -2914,6 +2919,17 @@ void QGraphicsScene::addItem(QGraphicsItem *item)
     ++d->selectionChanging;
     int oldSelectedItemSize = d->selectedItems.size();
 
+    // Enable mouse tracking if the item accepts hover events or has a cursor set.
+    if (d->allItemsIgnoreHoverEvents && d->itemAcceptsHoverEvents_helper(item)) {
+        d->allItemsIgnoreHoverEvents = false;
+        d->enableMouseTrackingOnViews();
+    }
+    if (d->allItemsUseDefaultCursor && item->hasCursor()) {
+        d->allItemsUseDefaultCursor = false;
+        if (d->allItemsIgnoreHoverEvents) // already enabled otherwise
+            d->enableMouseTrackingOnViews();
+    }
+
     // Update selection lists
     if (item->isSelected())
         d->selectedItems << item;
@@ -3249,13 +3265,15 @@ void QGraphicsScene::removeItem(QGraphicsItem *item)
     // Set the item's scene ptr to 0.
     item->d_func()->scene = 0;
 
-    // Detach the item from its parent.
+    // Remove from parent, or unregister from toplevels.
     if (QGraphicsItem *parentItem = item->parentItem()) {
         if (parentItem->scene()) {
             Q_ASSERT_X(parentItem->scene() == this, "QGraphicsScene::removeItem",
                        "Parent item's scene is different from this item's scene");
             item->setParentItem(0);
         }
+    } else {
+        d->unregisterTopLevelItem(item);
     }
 
     // Remove from our item lists.
@@ -4214,6 +4232,9 @@ bool QGraphicsScenePrivate::itemAcceptsHoverEvents_helper(const QGraphicsItem *i
 */
 bool QGraphicsScenePrivate::dispatchHoverEvent(QGraphicsSceneHoverEvent *hoverEvent)
 {
+    if (allItemsIgnoreHoverEvents)
+        return false;
+
     // Find the first item that accepts hover events, reusing earlier
     // calculated data is possible.
     if (cachedItemsUnderMouse.isEmpty()) {
@@ -4613,7 +4634,7 @@ static void _q_paintItem(QGraphicsItem *item, QPainter *painter,
                                 ? proxy->widget()->windowOpacity() : 1.0;
     const qreal oldPainterOpacity = painter->opacity();
 
-    if (qFuzzyCompare(windowOpacity + 1, qreal(1.0)))
+    if (qFuzzyIsNull(windowOpacity))
         return;
     // Set new painter opacity.
     if (windowOpacity < 1.0)
@@ -4722,8 +4743,9 @@ void QGraphicsScenePrivate::drawItemHelper(QGraphicsItem *item, QPainter *painte
         return;
 
     // Fetch the off-screen transparent buffer and exposed area info.
-    QString pixmapKey;
+    QPixmapCache::Key pixmapKey;
     QPixmap pix;
+    bool pixmapFound;
     QGraphicsItemCache *itemCache = itemd->extraItemCache();
     if (cacheMode == QGraphicsItem::ItemCoordinateCache) {
         if (itemCache->boundingRect != brect.toRect()) {
@@ -4733,17 +4755,14 @@ void QGraphicsScenePrivate::drawItemHelper(QGraphicsItem *item, QPainter *painte
         }
         pixmapKey = itemCache->key;
     } else {
-        if ((pixmapKey = itemCache->deviceData.value(widget).key).isEmpty()) {
-            pixmapKey.sprintf("qgv-%p-%p", item, widget);
-            QGraphicsItemCache::DeviceData data;
-            data.key = pixmapKey;
-            itemCache->deviceData.insert(widget, data);
-        }
+        pixmapKey = itemCache->deviceData.value(widget).key;
     }
 
     // Find pixmap in cache.
     if (!itemCache->allExposed)
-        QPixmapCache::find(pixmapKey, pix);
+       pixmapFound = QPixmapCache::find(pixmapKey, &pix);
+    else
+       pixmapFound = false;
 
     // Render using item coordinate cache mode.
     if (cacheMode == QGraphicsItem::ItemCoordinateCache) {
@@ -4796,8 +4815,12 @@ void QGraphicsScenePrivate::drawItemHelper(QGraphicsItem *item, QPainter *painte
             _q_paintIntoCache(&pix, item, pixmapExposed, itemToPixmap, painter->renderHints(),
                               &cacheOption, painterStateProtection);
 
-            // Reinsert this pixmap into the cache.
-            QPixmapCache::insert(pixmapKey, pix);
+            if (!pixmapFound) {
+                // insert this pixmap into the cache.
+                itemCache->key = QPixmapCache::insert(pix);
+            } else {
+                QPixmapCache::replace(pixmapKey, pix);
+            }
 
             // Reset expose data.
             itemCache->allExposed = false;
@@ -4964,8 +4987,13 @@ void QGraphicsScenePrivate::drawItemHelper(QGraphicsItem *item, QPainter *painte
         }
 
         if (pixModified) {
-            // Reinsert this pixmap into the cache
-            QPixmapCache::insert(pixmapKey, pix);
+            if (!pixmapFound) {
+                // Insert this pixmap into the cache.
+                deviceData->key = QPixmapCache::insert(pix);
+            } else {
+                //otherwise we replace the pixmap in the cache
+                QPixmapCache::replace(pixmapKey, pix);
+            }
         }
 
         // Redraw the exposed area using an untransformed painter. This
@@ -5078,11 +5106,7 @@ void QGraphicsScene::drawItems(QPainter *painter,
                 // optimization, but it's hit very rarely.
                 for (int i = clippers.size() - 1; i >= 0; --i) {
                     QGraphicsItem *clipper = clippers[i];
-                    if (clipper->d_ptr->itemIsUntransformable()) {
-                        painter->setWorldTransform(clipper->deviceTransform(viewTransform), false);
-                    } else {
-                        painter->setWorldTransform(clipper->sceneTransform() * viewTransform, false);
-                    }
+                    painter->setWorldTransform(clipper->deviceTransform(viewTransform), false);
 
                     childClippers.append(clipper);
                     painter->save();
@@ -5093,12 +5117,8 @@ void QGraphicsScene::drawItems(QPainter *painter,
         }
 
         // Set up the painter transform
-        if (item->d_ptr->itemIsUntransformable()) {
-            painter->setWorldTransform(item->deviceTransform(viewTransform), false);
-        } else {
-            painter->setWorldTransform(item->sceneTransform() * viewTransform, false);
-        }
-       
+        painter->setWorldTransform(item->deviceTransform(viewTransform), false);
+
         // Save painter
         bool saveState = (d->painterStateProtection || (item->flags() & QGraphicsItem::ItemClipsToShape));
         if (saveState)
@@ -5255,7 +5275,7 @@ void QGraphicsScene::itemUpdated(QGraphicsItem *item, const QRectF &rect)
     // Deliver the actual update.
     if (!d->updateAll) {
         if (d->views.isEmpty() || ((d->connectedSignals & d->changedSignalMask) && !item->d_ptr->itemIsUntransformable()
-                                   && qFuzzyCompare(item->boundingRegionGranularity(), qreal(0.0)))) {
+                                   && 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.
diff --git a/src/gui/graphicsview/qgraphicsscene_p.h b/src/gui/graphicsview/qgraphicsscene_p.h
index befbbd8..9ace725 100644
--- a/src/gui/graphicsview/qgraphicsscene_p.h
+++ b/src/gui/graphicsview/qgraphicsscene_p.h
@@ -113,7 +113,10 @@ public:
     QList<QGraphicsItem *> dirtyItems;
     QList<QGraphicsItem *> pendingUpdateItems;
     QList<QGraphicsItem *> unpolishedItems;
+    QList<QGraphicsItem *> topLevelItems;
     QMap<QGraphicsItem *, QPointF> movingItemsInitialPositions;
+    void registerTopLevelItem(QGraphicsItem *item);
+    void unregisterTopLevelItem(QGraphicsItem *item);
     void _q_updateLater();
     void _q_polishItems();
 
@@ -165,6 +168,9 @@ public:
     Qt::DropAction lastDropAction;
     QList<QGraphicsItem *> cachedItemsUnderMouse;
     QList<QGraphicsItem *> hoverItems;
+    bool allItemsIgnoreHoverEvents;
+    bool allItemsUseDefaultCursor;
+    void enableMouseTrackingOnViews();
     QMap<Qt::MouseButton, QPointF> mouseGrabberButtonDownPos;
     QMap<Qt::MouseButton, QPointF> mouseGrabberButtonDownScenePos;
     QMap<Qt::MouseButton, QPoint> mouseGrabberButtonDownScreenPos;
diff --git a/src/gui/graphicsview/qgraphicssceneevent.cpp b/src/gui/graphicsview/qgraphicssceneevent.cpp
index b819c2c..0ffd2b1 100644
--- a/src/gui/graphicsview/qgraphicssceneevent.cpp
+++ b/src/gui/graphicsview/qgraphicssceneevent.cpp
@@ -844,7 +844,7 @@ QGraphicsSceneContextMenuEvent::~QGraphicsSceneContextMenuEvent()
 
 /*!
     Returns the position of the mouse cursor in item coordinates at the moment
-    the the context menu was requested.
+    the context menu was requested.
 
     \sa scenePos(), screenPos()
 */
@@ -992,7 +992,7 @@ QGraphicsSceneHoverEvent::~QGraphicsSceneHoverEvent()
 
 /*!
     Returns the position of the mouse cursor in item coordinates at the moment
-    the the hover event was sent.
+    the hover event was sent.
 
     \sa scenePos(), screenPos()
 */
@@ -1017,7 +1017,7 @@ void QGraphicsSceneHoverEvent::setPos(const QPointF &pos)
 
 /*!
     Returns the position of the mouse cursor in scene coordinates at the
-    moment the the hover event was sent.
+    moment the hover event was sent.
 
     \sa pos(), screenPos()
 */
@@ -1042,7 +1042,7 @@ void QGraphicsSceneHoverEvent::setScenePos(const QPointF &pos)
 
 /*!
     Returns the position of the mouse cursor in screen coordinates at the
-    moment the the hover event was sent.
+    moment the hover event was sent.
 
     \sa pos(), scenePos()
 */
@@ -1138,7 +1138,7 @@ void QGraphicsSceneHoverEvent::setLastScreenPos(const QPoint &pos)
 /*!
     \since 4.4
 
-    Returns the keyboard modifiers at the moment the the hover event was sent.
+    Returns the keyboard modifiers at the moment the hover event was sent.
 */
 Qt::KeyboardModifiers QGraphicsSceneHoverEvent::modifiers() const
 {
@@ -1184,7 +1184,7 @@ QGraphicsSceneHelpEvent::~QGraphicsSceneHelpEvent()
 
 /*!
     Returns the position of the mouse cursor in scene coordinates at the
-    moment the the help event was sent.
+    moment the help event was sent.
 
     \sa screenPos()
 */
@@ -1209,7 +1209,7 @@ void QGraphicsSceneHelpEvent::setScenePos(const QPointF &pos)
 
 /*!
     Returns the position of the mouse cursor in screen coordinates at the
-    moment the the help event was sent.
+    moment the help event was sent.
 
   \sa scenePos()
 */
diff --git a/src/gui/graphicsview/qgraphicsview.cpp b/src/gui/graphicsview/qgraphicsview.cpp
index 05e4907..396618c 100644
--- a/src/gui/graphicsview/qgraphicsview.cpp
+++ b/src/gui/graphicsview/qgraphicsview.cpp
@@ -614,6 +614,16 @@ void QGraphicsViewPrivate::mouseMoveEventHandler(QMouseEvent *event)
     }
 
 #ifndef QT_NO_CURSOR
+    // If all the items ignore hover events, we don't look-up any items
+    // in QGraphicsScenePrivate::dispatchHoverEvent, hence the
+    // cachedItemsUnderMouse list will be empty. We therefore do the look-up
+    // for cursor items here if not all items use the default cursor.
+    if (scene->d_func()->allItemsIgnoreHoverEvents && !scene->d_func()->allItemsUseDefaultCursor
+        && scene->d_func()->cachedItemsUnderMouse.isEmpty()) {
+        scene->d_func()->cachedItemsUnderMouse = scene->d_func()->itemsAtPosition(mouseEvent.screenPos(),
+                                                                                  mouseEvent.scenePos(),
+                                                                                  mouseEvent.widget());
+    }
     // Find the topmost item under the mouse with a cursor.
     foreach (QGraphicsItem *item, scene->d_func()->cachedItemsUnderMouse) {
         if (item->hasCursor()) {
@@ -1061,7 +1071,7 @@ QList<QGraphicsItem *> QGraphicsViewPrivate::findItems(const QRegion &exposedReg
 
     // Step 1) If all items are contained within the expose region, then
     // return a list of all visible items.
-    const QRectF exposedRegionSceneBounds = q->mapToScene(exposedRegion.boundingRect().adjusted(-1, -1, 2, 2))
+    const QRectF exposedRegionSceneBounds = q->mapToScene(exposedRegion.boundingRect().adjusted(-1, -1, 1, 1))
                                             .boundingRect();
     if (exposedRegionSceneBounds.contains(scene->d_func()->growingItemsBoundingRect)) {
         Q_ASSERT(allItems);
@@ -1117,73 +1127,6 @@ QList<QGraphicsItem *> QGraphicsViewPrivate::findItems(const QRegion &exposedReg
     return itemsInArea(exposedPath, Qt::IntersectsItemBoundingRect, Qt::DescendingOrder);
 }
 
-void QGraphicsViewPrivate::generateStyleOptions(const QList<QGraphicsItem *> &itemList,
-                                                QGraphicsItem **itemArray,
-                                                QStyleOptionGraphicsItem *styleOptionArray,
-                                                const QTransform &worldTransform,
-                                                bool allItems,
-                                                const QRegion &exposedRegion) const
-{
-    // Two unit vectors.
-    QLineF v1(0, 0, 1, 0);
-    QLineF v2(0, 0, 0, 1);
-    QTransform itemToViewportTransform;
-    QRectF brect;
-    QTransform reverseMap;
-
-    for (int i = 0; i < itemList.size(); ++i) {
-        QGraphicsItem *item = itemArray[i] = itemList[i];
-
-        QStyleOptionGraphicsItem &option = styleOptionArray[i];
-        brect = item->boundingRect();
-        option.state = QStyle::State_None;
-        option.rect = brect.toRect();
-        option.exposedRect = QRectF();
-        if (item->d_ptr->selected)
-            option.state |= QStyle::State_Selected;
-        if (item->d_ptr->enabled)
-            option.state |= QStyle::State_Enabled;
-        if (item->hasFocus())
-            option.state |= QStyle::State_HasFocus;
-        if (scene->d_func()->hoverItems.contains(item))
-            option.state |= QStyle::State_MouseOver;
-        if (item == scene->mouseGrabberItem())
-            option.state |= QStyle::State_Sunken;
-
-        // Calculate a simple level-of-detail metric.
-        // ### almost identical code in QGraphicsScene::render()
-        //     and QGraphicsView::render() - consider refactoring
-        if (item->d_ptr->itemIsUntransformable()) {
-            itemToViewportTransform = item->deviceTransform(worldTransform);
-        } else {
-            itemToViewportTransform = item->sceneTransform() * worldTransform;
-        }
-
-        if (itemToViewportTransform.type() <= QTransform::TxTranslate) {
-            // Translation and rotation only? The LOD is 1.
-            option.levelOfDetail = 1;
-        } else {
-            // LOD is the transformed area of a 1x1 rectangle.
-            option.levelOfDetail = qSqrt(itemToViewportTransform.map(v1).length() * itemToViewportTransform.map(v2).length());
-        }
-        option.matrix = itemToViewportTransform.toAffine(); //### discards perspective
-
-        if (!allItems) {
-            // Determine the item's exposed area
-            reverseMap = itemToViewportTransform.inverted();
-            foreach (const QRect &rect, exposedRegion.rects()) {
-                option.exposedRect |= reverseMap.mapRect(QRectF(rect.adjusted(-1, -1, 1, 1)));
-                if (option.exposedRect.contains(brect))
-                    break;
-            }
-            option.exposedRect &= brect;
-        } else {
-            // The whole item is exposed
-            option.exposedRect = brect;
-        }
-    }
-}
-
 /*!
     Constructs a QGraphicsView. \a parent is passed to QWidget's constructor.
 */
@@ -1681,6 +1624,7 @@ void QGraphicsView::setScene(QGraphicsScene *scene)
         disconnect(d->scene, SIGNAL(sceneRectChanged(QRectF)),
                    this, SLOT(updateSceneRect(QRectF)));
         d->scene->d_func()->views.removeAll(this);
+        d->connectedToScene = false;
     }
 
     // Assign the new scene and update the contents (scrollbars, etc.)).
@@ -1692,6 +1636,12 @@ void QGraphicsView::setScene(QGraphicsScene *scene)
         d->recalculateContentSize();
         d->lastCenterPoint = sceneRect().center();
         d->keepLastCenterPoint = true;
+        // We are only interested in mouse tracking if items accept
+        // hover events or use non-default cursors.
+        if (!d->scene->d_func()->allItemsIgnoreHoverEvents
+            || !d->scene->d_func()->allItemsUseDefaultCursor) {
+            d->viewport->setMouseTracking(true);
+        }
     } else {
         d->recalculateContentSize();
     }
@@ -2133,45 +2083,10 @@ void QGraphicsView::render(QPainter *painter, const QRectF &target, const QRect
                      .scale(xratio, yratio)
                      .translate(-sourceRect.left(), -sourceRect.top());
 
-    // Two unit vectors.
-    QLineF v1(0, 0, 1, 0);
-    QLineF v2(0, 0, 0, 1);
-
     // Generate the style options
     QStyleOptionGraphicsItem *styleOptionArray = d->allocStyleOptionsArray(numItems);
-    QStyleOptionGraphicsItem* option = styleOptionArray;
-    for (int i = 0; i < numItems; ++i, ++option) {
-        QGraphicsItem *item = itemArray[i];
-
-        option->state = QStyle::State_None;
-        option->rect = item->boundingRect().toRect();
-        if (item->isSelected())
-            option->state |= QStyle::State_Selected;
-        if (item->isEnabled())
-            option->state |= QStyle::State_Enabled;
-        if (item->hasFocus())
-            option->state |= QStyle::State_HasFocus;
-        if (d->scene->d_func()->hoverItems.contains(item))
-            option->state |= QStyle::State_MouseOver;
-        if (item == d->scene->mouseGrabberItem())
-            option->state |= QStyle::State_Sunken;
-
-        // Calculate a simple level-of-detail metric.
-        // ### almost identical code in QGraphicsScene::render()
-        //     and QGraphicsView::paintEvent() - consider refactoring
-        QTransform itemToViewportTransform;
-        if (item->d_ptr->itemIsUntransformable()) {
-            itemToViewportTransform = item->deviceTransform(painterMatrix);
-        } else {
-            itemToViewportTransform = item->sceneTransform() * painterMatrix;
-        }
-
-        option->levelOfDetail = qSqrt(itemToViewportTransform.map(v1).length() * itemToViewportTransform.map(v2).length());
-        option->matrix = itemToViewportTransform.toAffine();
-
-        option->exposedRect = item->boundingRect();
-        option->exposedRect &= itemToViewportTransform.inverted().mapRect(targetRect);
-    }
+    for (int i = 0; i < numItems; ++i)
+        itemArray[i]->d_ptr->initStyleOption(&styleOptionArray[i], painterMatrix, targetRect.toRect());
 
     painter->save();
 
@@ -2297,7 +2212,7 @@ QList<QGraphicsItem *> QGraphicsView::items(const QPoint &pos) const
             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(), 2, 2));
+        return d->scene->items(mapToScene(pos.x(), pos.y(), 1, 1));
     }
 
     QPainterPath path;
@@ -2459,10 +2374,11 @@ QPolygonF QGraphicsView::mapToScene(const QRect &rect) const
         return QPolygonF();
 
     QPointF scrollOffset(d->horizontalScroll(), d->verticalScroll());
-    QPointF tl = scrollOffset + rect.topLeft();
-    QPointF tr = scrollOffset + rect.topRight();
-    QPointF br = scrollOffset + rect.bottomRight();
-    QPointF bl = scrollOffset + rect.bottomLeft();
+    QRect r = rect.adjusted(0, 0, 1, 1);
+    QPointF tl = scrollOffset + r.topLeft();
+    QPointF tr = scrollOffset + r.topRight();
+    QPointF br = scrollOffset + r.bottomRight();
+    QPointF bl = scrollOffset + r.bottomLeft();
 
     QPolygonF poly;
     poly.resize(4);
@@ -2792,9 +2708,7 @@ void QGraphicsView::setupViewport(QWidget *widget)
 
     const bool isGLWidget = widget->inherits("QGLWidget");
 
-    d->accelerateScrolling = !(isGLWidget
-                               || widget->testAttribute(Qt::WA_MSWindowsUseDirect3D)
-                               || qApp->testAttribute(Qt::AA_MSWindowsUseDirect3DByDefault));
+    d->accelerateScrolling = !(isGLWidget);
 
     widget->setFocusPolicy(Qt::StrongFocus);
 
@@ -2803,7 +2717,12 @@ void QGraphicsView::setupViewport(QWidget *widget)
         widget->setAutoFillBackground(true);
     }
 
-    widget->setMouseTracking(true);
+    // We are only interested in mouse tracking if items
+    // accept hover events or use non-default cursors.
+    if (d->scene && (!d->scene->d_func()->allItemsIgnoreHoverEvents
+                     || !d->scene->d_func()->allItemsUseDefaultCursor)) {
+        widget->setMouseTracking(true);
+    }
     widget->setAcceptDrops(acceptDrops());
 }
 
@@ -3450,7 +3369,7 @@ void QGraphicsView::paintEvent(QPaintEvent *event)
         exposedRegion = viewport()->rect();
     else if (d->viewportUpdateMode == BoundingRectViewportUpdate)
         exposedRegion = event->rect();
-    QRectF exposedSceneRect = mapToScene(exposedRegion.boundingRect().adjusted(0, 0, 1, 1)).boundingRect();
+    QRectF exposedSceneRect = mapToScene(exposedRegion.boundingRect()).boundingRect();
 
     // Set up the painter
     QPainter painter(viewport());
@@ -3504,6 +3423,7 @@ void QGraphicsView::paintEvent(QPaintEvent *event)
             QPainter backgroundPainter(&d->backgroundPixmap);
             backgroundPainter.setClipRegion(d->backgroundPixmapExposed, Qt::ReplaceClip);
             backgroundPainter.setTransform(viewportTransform());
+            backgroundPainter.setCompositionMode(QPainter::CompositionMode_Source);
             drawBackground(&backgroundPainter, exposedSceneRect);
             d->backgroundPixmapExposed = QRegion();
         }
@@ -3525,15 +3445,17 @@ void QGraphicsView::paintEvent(QPaintEvent *event)
     int backgroundTime = stopWatch.elapsed() - exposedTime;
 #endif
 
-    // Generate the style options
-    QGraphicsItem **itemArray = new QGraphicsItem *[itemList.size()];
-    QStyleOptionGraphicsItem *styleOptionArray = d->allocStyleOptionsArray(itemList.size());
-
-    d->generateStyleOptions(itemList, itemArray, styleOptionArray, viewTransform,
-                            allItems, exposedRegion);
-
-    // Items
-    drawItems(&painter, itemList.size(), itemArray, styleOptionArray);
+    if (!itemList.isEmpty()) {
+        // Generate the style options.
+        const int numItems = itemList.size();
+        QGraphicsItem **itemArray = &itemList[0]; // Relies on QList internals, but is perfectly valid.
+        QStyleOptionGraphicsItem *styleOptionArray = d->allocStyleOptionsArray(numItems);
+        for (int i = 0; i < numItems; ++i)
+            itemArray[i]->d_ptr->initStyleOption(&styleOptionArray[i], viewTransform, exposedRegion, allItems);
+        // Draw the items.
+        drawItems(&painter, numItems, itemArray, styleOptionArray);
+        d->freeStyleOptionsArray(styleOptionArray);
+    }
 
 #ifdef QGRAPHICSVIEW_DEBUG
     int itemsTime = stopWatch.elapsed() - exposedTime - backgroundTime;
@@ -3542,9 +3464,6 @@ void QGraphicsView::paintEvent(QPaintEvent *event)
     // Foreground
     drawForeground(&painter, exposedSceneRect);
 
-    delete [] itemArray;
-    d->freeStyleOptionsArray(styleOptionArray);
-
 #ifdef QGRAPHICSVIEW_DEBUG
     int foregroundTime = stopWatch.elapsed() - exposedTime - backgroundTime - itemsTime;
 #endif
@@ -3656,31 +3575,14 @@ void QGraphicsView::scrollContentsBy(int dx, int dy)
         && X11->use_xrender
 #endif
         ) {
-        // Invalidate the background pixmap
-        d->backgroundPixmapExposed.translate(dx, 0);
-        if (dx > 0) {
-            d->backgroundPixmapExposed += QRect(0, 0, dx, viewport()->height());
-        } else if (dx < 0) {
-            d->backgroundPixmapExposed += QRect(viewport()->width() + dx, 0,
-                                                -dx, viewport()->height());
-        }
-        d->backgroundPixmapExposed.translate(0, dy);
-        if (dy > 0) {
-            d->backgroundPixmapExposed += QRect(0, 0, viewport()->width(), dy);
-        } else if (dy < 0) {
-            d->backgroundPixmapExposed += QRect(0, viewport()->height() + dy,
-                                                viewport()->width(), -dy);
-        }
-
         // Scroll the background pixmap
-        if (!d->backgroundPixmap.isNull()) {
-            QPixmap tmp = d->backgroundPixmap.copy();
-            QBrush bgBrush = viewport()->palette().brush(viewport()->backgroundRole());
-            if (!bgBrush.isOpaque())
-                d->backgroundPixmap.fill(Qt::transparent);
-            QPainter painter(&d->backgroundPixmap);
-            painter.drawPixmap(dx, dy, tmp);
-        }
+        QRegion exposed;
+        if (!d->backgroundPixmap.isNull())
+            d->backgroundPixmap.scroll(dx, dy, d->backgroundPixmap.rect(), &exposed);
+
+        // Invalidate the background pixmap
+        d->backgroundPixmapExposed.translate(dx, dy);
+        d->backgroundPixmapExposed += exposed;
     }
 
     // Always replay on scroll.
diff --git a/src/gui/graphicsview/qgraphicsview_p.h b/src/gui/graphicsview/qgraphicsview_p.h
index a76279e..c18f85d 100644
--- a/src/gui/graphicsview/qgraphicsview_p.h
+++ b/src/gui/graphicsview/qgraphicsview_p.h
@@ -63,7 +63,7 @@
 
 QT_BEGIN_NAMESPACE
 
-class Q_GUI_EXPORT QGraphicsViewPrivate : public QAbstractScrollAreaPrivate
+class QGraphicsViewPrivate : public QAbstractScrollAreaPrivate
 {
     Q_DECLARE_PUBLIC(QGraphicsView)
 public:
@@ -174,13 +174,6 @@ public:
     bool updateSceneSlotReimplementedChecked;
 
     QList<QGraphicsItem *> findItems(const QRegion &exposedRegion, bool *allItems) const;
-
-    void generateStyleOptions(const QList<QGraphicsItem *> &itemList,
-			      QGraphicsItem **itemArray,
-			      QStyleOptionGraphicsItem *styleOptionArray,
-			      const QTransform &worldTransform,
-			      bool allItems,
-			      const QRegion &exposedRegion) const;
 };
 
 QT_END_NAMESPACE
diff --git a/src/gui/graphicsview/qgraphicswidget.cpp b/src/gui/graphicsview/qgraphicswidget.cpp
index 7f02fb9..702e0b6 100644
--- a/src/gui/graphicsview/qgraphicswidget.cpp
+++ b/src/gui/graphicsview/qgraphicswidget.cpp
@@ -459,17 +459,19 @@ void QGraphicsWidget::setContentsMargins(qreal left, qreal top, qreal right, qre
 {
     Q_D(QGraphicsWidget);
 
-    if (left == d->leftMargin
-        && top == d->topMargin
-        && right == d->rightMargin
-        && bottom == d->bottomMargin) {
+    if (!d->margins && left == 0 && top == 0 && right == 0 && bottom == 0)
+        return;
+    d->ensureMargins();
+    if (left == d->margins[d->Left]
+        && top == d->margins[d->Top]
+        && right == d->margins[d->Right]
+        && bottom == d->margins[d->Bottom])
         return;
-    }
 
-    d->leftMargin = left;
-    d->topMargin = top;
-    d->rightMargin = right;
-    d->bottomMargin = bottom;
+    d->margins[d->Left] = left;
+    d->margins[d->Top] = top;
+    d->margins[d->Right] = right;
+    d->margins[d->Bottom] = bottom;
 
     if (QGraphicsLayout *l = d->layout)
         l->invalidate();
@@ -490,14 +492,16 @@ void QGraphicsWidget::setContentsMargins(qreal left, qreal top, qreal right, qre
 void QGraphicsWidget::getContentsMargins(qreal *left, qreal *top, qreal *right, qreal *bottom) const
 {
     Q_D(const QGraphicsWidget);
+    if (left || top || right || bottom)
+        d->ensureMargins();
     if (left)
-        *left = d->leftMargin;
+        *left = d->margins[d->Left];
     if (top)
-        *top = d->topMargin;
+        *top = d->margins[d->Top];
     if (right)
-        *right = d->rightMargin;
+        *right = d->margins[d->Right];
     if (bottom)
-        *bottom = d->bottomMargin;
+        *bottom = d->margins[d->Bottom];
 }
 
 /*!
@@ -513,16 +517,23 @@ void QGraphicsWidget::getContentsMargins(qreal *left, qreal *top, qreal *right,
 void QGraphicsWidget::setWindowFrameMargins(qreal left, qreal top, qreal right, qreal bottom)
 {
     Q_D(QGraphicsWidget);
-    bool unchanged = left == d->leftWindowFrameMargin && top == d->topWindowFrameMargin
-                     && right == d->rightWindowFrameMargin && bottom == d->bottomWindowFrameMargin;
+
+    if (!d->windowFrameMargins && left == 0 && top == 0 && right == 0 && bottom == 0)
+        return;
+    d->ensureWindowFrameMargins();
+    bool unchanged =
+        d->windowFrameMargins[d->Left] == left
+        && d->windowFrameMargins[d->Top] == top
+        && d->windowFrameMargins[d->Right] == right
+        && d->windowFrameMargins[d->Bottom] == bottom;
     if (d->setWindowFrameMargins && unchanged)
         return;
     if (!unchanged)
         prepareGeometryChange();
-    d->leftWindowFrameMargin = left;
-    d->topWindowFrameMargin = top;
-    d->rightWindowFrameMargin = right;
-    d->bottomWindowFrameMargin = bottom;
+    d->windowFrameMargins[d->Left] = left;
+    d->windowFrameMargins[d->Top] = top;
+    d->windowFrameMargins[d->Right] = right;
+    d->windowFrameMargins[d->Bottom] = bottom;
     d->setWindowFrameMargins = true;
 }
 
@@ -536,14 +547,16 @@ void QGraphicsWidget::setWindowFrameMargins(qreal left, qreal top, qreal right,
 void QGraphicsWidget::getWindowFrameMargins(qreal *left, qreal *top, qreal *right, qreal *bottom) const
 {
     Q_D(const QGraphicsWidget);
+    if (left || top || right || bottom)
+        d->ensureWindowFrameMargins();
     if (left)
-        *left = d->leftWindowFrameMargin;
+        *left = d->windowFrameMargins[d->Left];
     if (top)
-        *top = d->topWindowFrameMargin;
+        *top = d->windowFrameMargins[d->Top];
     if (right)
-        *right = d->rightWindowFrameMargin;
+        *right = d->windowFrameMargins[d->Right];
     if (bottom)
-        *bottom = d->bottomWindowFrameMargin;
+        *bottom = d->windowFrameMargins[d->Bottom];
 }
 
 /*!
@@ -577,8 +590,10 @@ void QGraphicsWidget::unsetWindowFrameMargins()
 QRectF QGraphicsWidget::windowFrameGeometry() const
 {
     Q_D(const QGraphicsWidget);
-    return geometry().adjusted(-d->leftWindowFrameMargin, -d->topWindowFrameMargin,
-                               d->rightWindowFrameMargin, d->bottomWindowFrameMargin);
+    return d->windowFrameMargins
+        ? geometry().adjusted(-d->windowFrameMargins[d->Left], -d->windowFrameMargins[d->Top],
+                              d->windowFrameMargins[d->Right], d->windowFrameMargins[d->Bottom])
+        : geometry();
 }
 
 /*!
@@ -589,8 +604,10 @@ QRectF QGraphicsWidget::windowFrameGeometry() const
 QRectF QGraphicsWidget::windowFrameRect() const
 {
     Q_D(const QGraphicsWidget);
-    return rect().adjusted(-d->leftWindowFrameMargin, -d->topWindowFrameMargin,
-                           d->rightWindowFrameMargin, d->bottomWindowFrameMargin);
+    return d->windowFrameMargins
+        ? rect().adjusted(-d->windowFrameMargins[d->Left], -d->windowFrameMargins[d->Top],
+                          d->windowFrameMargins[d->Right], d->windowFrameMargins[d->Bottom])
+        : rect();
 }
 
 /*!
@@ -699,7 +716,10 @@ QSizeF QGraphicsWidget::sizeHint(Qt::SizeHint which, const QSizeF &constraint) c
     QSizeF sh;
     if (d->layout) {
         sh = d->layout->effectiveSizeHint(which, constraint);
-        sh += QSizeF(d->leftMargin + d->rightMargin, d->topMargin + d->bottomMargin);
+        if (d->margins) {
+            sh += QSizeF(d->margins[d->Left] + d->margins[d->Right],
+                         d->margins[d->Top] + d->margins[d->Bottom]);
+        }
     } else {
         switch (which) {
             case Qt::MinimumSize:
@@ -1039,10 +1059,6 @@ QVariant QGraphicsWidget::itemChange(GraphicsItemChange change, const QVariant &
         break;
     }
     case ItemParentHasChanged: {
-        // reset window type on parent change in order to automagically remove decorations etc.
-        Qt::WindowFlags wflags = d->windowFlags & ~Qt::WindowType_Mask;
-        d->adjustWindowFlags(&wflags);
-        setWindowFlags(wflags);
         // Deliver ParentChange.
         QEvent event(QEvent::ParentChange);
         QApplication::sendEvent(this, &event);
@@ -1131,7 +1147,8 @@ bool QGraphicsWidget::windowFrameEvent(QEvent *event)
         d->windowFrameMousePressEvent(static_cast<QGraphicsSceneMouseEvent *>(event));
         break;
     case QEvent::GraphicsSceneMouseMove:
-        if (d->grabbedSection != Qt::NoSection) {
+        d->ensureWindowData();
+        if (d->windowData->grabbedSection != Qt::NoSection) {
             d->windowFrameMouseMoveEvent(static_cast<QGraphicsSceneMouseEvent *>(event));
             event->accept();
         }
@@ -1186,7 +1203,8 @@ Qt::WindowFrameSection QGraphicsWidget::windowFrameSectionAt(const QPointF &pos)
 
     const qreal cornerMargin = 20;
     //### Not sure of this one, it should be the same value for all edges.
-    const qreal windowFrameWidth = d->leftWindowFrameMargin;
+    const qreal windowFrameWidth = d->windowFrameMargins
+        ? d->windowFrameMargins[d->Left] : 0;
 
     Qt::WindowFrameSection s = Qt::NoSection;
     if (x <= left + cornerMargin) {
@@ -1212,7 +1230,8 @@ Qt::WindowFrameSection QGraphicsWidget::windowFrameSectionAt(const QPointF &pos)
     }
     if (s == Qt::NoSection) {
         QRectF r1 = r;
-        r1.setHeight(d->topWindowFrameMargin);
+        r1.setHeight(d->windowFrameMargins
+                     ? d->windowFrameMargins[d->Top] : 0);
         if (r1.contains(pos))
             s = Qt::TitleBarArea;
     }
@@ -1320,7 +1339,8 @@ bool QGraphicsWidget::event(QEvent *event)
     case QEvent::GraphicsSceneMouseMove:
     case QEvent::GraphicsSceneMouseRelease:
     case QEvent::GraphicsSceneMouseDoubleClick:
-        if (d->hasDecoration() && d->grabbedSection != Qt::NoSection)
+        d->ensureWindowData();
+        if (d->hasDecoration() && d->windowData->grabbedSection != Qt::NoSection)
             return windowFrameEvent(event);
         break;
     case QEvent::GraphicsSceneHoverEnter:
@@ -1623,6 +1643,7 @@ void QGraphicsWidget::setWindowFlags(Qt::WindowFlags wFlags)
         return;
     bool wasPopup = (d->windowFlags & Qt::WindowType_Mask) == Qt::Popup;
 
+    d->adjustWindowFlags(&wFlags);
     d->windowFlags = wFlags;
     if (!d->setWindowFrameMargins)
         unsetWindowFrameMargins();
@@ -1635,6 +1656,11 @@ void QGraphicsWidget::setWindowFlags(Qt::WindowFlags wFlags)
         else
             d->scene->d_func()->addPopup(this);
     }
+
+    if (d->scene && d->scene->d_func()->allItemsIgnoreHoverEvents && d->hasDecoration()) {
+        d->scene->d_func()->allItemsIgnoreHoverEvents = false;
+        d->scene->d_func()->enableMouseTrackingOnViews();
+    }
 }
 
 /*!
@@ -1667,12 +1693,13 @@ bool QGraphicsWidget::isActiveWindow() const
 void QGraphicsWidget::setWindowTitle(const QString &title)
 {
     Q_D(QGraphicsWidget);
-    d->windowTitle = title;
+    d->ensureWindowData();
+    d->windowData->windowTitle = title;
 }
 QString QGraphicsWidget::windowTitle() const
 {
     Q_D(const QGraphicsWidget);
-    return d->windowTitle;
+    return d->windowData ? d->windowData->windowTitle : QString();
 }
 
 /*!
@@ -2108,11 +2135,12 @@ void QGraphicsWidget::paintWindowFrame(QPainter *painter, const QStyleOptionGrap
     QStyleOptionTitleBar bar;
     bar.QStyleOption::operator=(*option);
     d->initStyleOptionTitleBar(&bar);   // this clear flags in bar.state
-    if (d->buttonMouseOver)
+    d->ensureWindowData();
+    if (d->windowData->buttonMouseOver)
         bar.state |= QStyle::State_MouseOver;
     else
         bar.state &= ~QStyle::State_MouseOver;
-    if (d->buttonSunken)
+    if (d->windowData->buttonSunken)
         bar.state |= QStyle::State_Sunken;
     else
         bar.state &= ~QStyle::State_Sunken;
diff --git a/src/gui/graphicsview/qgraphicswidget.h b/src/gui/graphicsview/qgraphicswidget.h
index 65fd219..a5c9068 100644
--- a/src/gui/graphicsview/qgraphicswidget.h
+++ b/src/gui/graphicsview/qgraphicswidget.h
@@ -81,12 +81,14 @@ class Q_GUI_EXPORT QGraphicsWidget : public QObject, public QGraphicsItem, publi
     Q_PROPERTY(qreal opacity READ opacity WRITE setOpacity)
     Q_PROPERTY(QPointF pos READ pos WRITE setPos)
     Q_PROPERTY(QRectF geometry READ geometry WRITE setGeometry)
-    Q_PROPERTY(qreal xScale READ xScale WRITE setXScale)
-    Q_PROPERTY(qreal yScale READ yScale WRITE setYScale)
-    Q_PROPERTY(qreal zRotation READ zRotation WRITE setZRotation)
+    Q_PROPERTY(QPointF transformOrigin READ transformOrigin WRITE setTransformOrigin)
     Q_PROPERTY(qreal xRotation READ xRotation WRITE setXRotation)
     Q_PROPERTY(qreal yRotation READ yRotation WRITE setYRotation)
-
+    Q_PROPERTY(qreal zRotation READ zRotation WRITE setZRotation)
+    Q_PROPERTY(qreal xScale READ xScale WRITE setXScale)
+    Q_PROPERTY(qreal yScale READ yScale WRITE setYScale)
+    Q_PROPERTY(qreal horizontalShear READ horizontalShear WRITE setHorizontalShear)
+    Q_PROPERTY(qreal verticalShear READ verticalShear WRITE setVerticalShear)
 public:
     QGraphicsWidget(QGraphicsItem *parent = 0, Qt::WindowFlags wFlags = 0);
     ~QGraphicsWidget();
diff --git a/src/gui/graphicsview/qgraphicswidget_p.cpp b/src/gui/graphicsview/qgraphicswidget_p.cpp
index 789f8da..a435758 100644
--- a/src/gui/graphicsview/qgraphicswidget_p.cpp
+++ b/src/gui/graphicsview/qgraphicswidget_p.cpp
@@ -66,16 +66,17 @@ void QGraphicsWidgetPrivate::init(QGraphicsItem *parentItem, Qt::WindowFlags wFl
     isWidget = 1; // QGraphicsItem::isWidget() returns true.
     focusNext = focusPrev = q;
     focusPolicy = Qt::NoFocus;
+
+    adjustWindowFlags(&wFlags);
+    windowFlags = wFlags;
+
     q->setParentItem(parentItem);
     q->setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred, QSizePolicy::DefaultType));
     q->setGraphicsItem(q);
 
     resolveLayoutDirection();
-
-    if (!parentItem)
-        adjustWindowFlags(&wFlags);
-    windowFlags = wFlags;
     q->unsetWindowFrameMargins();
+    q->setFlag(QGraphicsItem::ItemUsesExtendedStyleOption);
 }
 qreal QGraphicsWidgetPrivate::titleBarHeight(const QStyleOptionTitleBar &options) const
 {
@@ -89,56 +90,57 @@ qreal QGraphicsWidgetPrivate::titleBarHeight(const QStyleOptionTitleBar &options
     return (qreal)height;
 }
 
-void QGraphicsWidgetPrivate::getLayoutItemMargins(qreal *left, qreal *top, qreal *right, qreal *bottom) const
+/*!
+    \internal
+*/
+QGraphicsWidgetPrivate::~QGraphicsWidgetPrivate()
 {
-    if (left)
-        *left = leftLayoutItemMargin;
-    if (top)
-        *top = topLayoutItemMargin;
-    if (right)
-        *right = rightLayoutItemMargin;
-    if (bottom)
-        *bottom = bottomLayoutItemMargin;
+    // Remove any lazily allocated data
+    delete[] margins;
+    delete[] windowFrameMargins;
+    delete windowData;
 }
 
-void QGraphicsWidgetPrivate::setLayoutItemMargins(qreal left, qreal top, qreal right, qreal bottom)
-{
-    if (leftLayoutItemMargin == left
-        && topLayoutItemMargin == top
-        && rightLayoutItemMargin == right
-        && bottomLayoutItemMargin == bottom)
-        return;
+/*!
+    \internal
 
-    Q_Q(QGraphicsWidget);
-    leftLayoutItemMargin = left;
-    topLayoutItemMargin = top;
-    rightLayoutItemMargin = right;
-    bottomLayoutItemMargin = bottom;
-    q->updateGeometry();
+     Ensures that margins is allocated.
+     This function must be called before any dereferencing.
+*/
+void QGraphicsWidgetPrivate::ensureMargins() const
+{
+    if (!margins) {
+        margins = new qreal[4];
+        for (int i = 0; i < 4; ++i)
+            margins[i] = 0;
+    }
 }
 
-void QGraphicsWidgetPrivate::setLayoutItemMargins(QStyle::SubElement element, const QStyleOption *opt)
+/*!
+    \internal
+
+     Ensures that windowFrameMargins is allocated.
+     This function must be called before any dereferencing.
+*/
+void QGraphicsWidgetPrivate::ensureWindowFrameMargins() const
 {
-    Q_Q(QGraphicsWidget);
-    QStyleOption myOpt;
-    if (!opt) {
-        q->initStyleOption(&myOpt);
-        myOpt.rect.setRect(0, 0, 32768, 32768);     // arbitrary
-        opt = &myOpt;
+    if (!windowFrameMargins) {
+        windowFrameMargins = new qreal[4];
+        for (int i = 0; i < 4; ++i)
+            windowFrameMargins[i] = 0;
     }
+}
 
-    QRect liRect = q->style()->subElementRect(element, opt, /* q */ 0);
-    if (liRect.isValid()) {
-        leftLayoutItemMargin = (opt->rect.left() - liRect.left());
-        topLayoutItemMargin = (opt->rect.top() - liRect.top());
-        rightLayoutItemMargin = (liRect.right() - opt->rect.right());
-        bottomLayoutItemMargin = (liRect.bottom() - opt->rect.bottom());
-    } else {
-        leftLayoutItemMargin = 0;
-        topLayoutItemMargin = 0;
-        rightLayoutItemMargin = 0;
-        bottomLayoutItemMargin = 0;
-    }
+/*!
+    \internal
+
+     Ensures that windowData is allocated.
+     This function must be called before any dereferencing.
+*/
+void QGraphicsWidgetPrivate::ensureWindowData()
+{
+    if (!windowData)
+        windowData = new WindowData;
 }
 
 void QGraphicsWidgetPrivate::setPalette_helper(const QPalette &palette)
@@ -297,11 +299,12 @@ QFont QGraphicsWidgetPrivate::naturalWidgetFont() const
 void QGraphicsWidgetPrivate::initStyleOptionTitleBar(QStyleOptionTitleBar *option)
 {
     Q_Q(QGraphicsWidget);
+    ensureWindowData();
     q->initStyleOption(option);
     option->rect.setHeight(titleBarHeight(*option));
     option->titleBarFlags = windowFlags;
     option->subControls = QStyle::SC_TitleBarCloseButton | QStyle::SC_TitleBarLabel | QStyle::SC_TitleBarSysMenu;
-    option->activeSubControls = hoveredSubControl;
+    option->activeSubControls = windowData->hoveredSubControl;
     bool isActive = q->isActiveWindow();
     if (isActive) {
         option->state |= QStyle::State_Active;
@@ -313,7 +316,8 @@ void QGraphicsWidgetPrivate::initStyleOptionTitleBar(QStyleOptionTitleBar *optio
     }
     QFont windowTitleFont = QApplication::font("QWorkspaceTitleBar");
     QRect textRect = q->style()->subControlRect(QStyle::CC_TitleBar, option, QStyle::SC_TitleBarLabel, 0);
-    option->text = QFontMetrics(windowTitleFont).elidedText(windowTitle, Qt::ElideRight, textRect.width());
+    option->text = QFontMetrics(windowTitleFont).elidedText(
+        windowData->windowTitle, Qt::ElideRight, textRect.width());
 }
 
 void QGraphicsWidgetPrivate::adjustWindowFlags(Qt::WindowFlags *flags)
@@ -341,9 +345,10 @@ void QGraphicsWidgetPrivate::adjustWindowFlags(Qt::WindowFlags *flags)
 void QGraphicsWidgetPrivate::windowFrameMouseReleaseEvent(QGraphicsSceneMouseEvent *event)
 {
     Q_Q(QGraphicsWidget);
-    if (grabbedSection != Qt::NoSection) {
-        if (grabbedSection == Qt::TitleBarArea) {
-            buttonSunken = false;
+    ensureWindowData();
+    if (windowData->grabbedSection != Qt::NoSection) {
+        if (windowData->grabbedSection == Qt::TitleBarArea) {
+            windowData->buttonSunken = false;
             QStyleOptionTitleBar bar;
             initStyleOptionTitleBar(&bar);
             // make sure that the coordinates (rect and pos) we send to the style are positive.
@@ -351,8 +356,10 @@ void QGraphicsWidgetPrivate::windowFrameMouseReleaseEvent(QGraphicsSceneMouseEve
             bar.rect.moveTo(0,0);
             bar.rect.setHeight(q->style()->pixelMetric(QStyle::PM_TitleBarHeight, &bar));
             QPointF pos = event->pos();
-            pos.rx() += leftWindowFrameMargin;
-            pos.ry() += topWindowFrameMargin;
+            if (windowFrameMargins) {
+                pos.rx() += windowFrameMargins[Left];
+                pos.ry() += windowFrameMargins[Top];
+            }
             bar.subControls = QStyle::SC_TitleBarCloseButton;
             if (q->style()->subControlRect(QStyle::CC_TitleBar, &bar,
                                            QStyle::SC_TitleBarCloseButton,
@@ -361,7 +368,7 @@ void QGraphicsWidgetPrivate::windowFrameMouseReleaseEvent(QGraphicsSceneMouseEve
             }
         }
         if (!(static_cast<QGraphicsSceneMouseEvent *>(event)->buttons()))
-            grabbedSection = Qt::NoSection;
+            windowData->grabbedSection = Qt::NoSection;
         event->accept();
     }
 }
@@ -372,35 +379,16 @@ void QGraphicsWidgetPrivate::windowFrameMousePressEvent(QGraphicsSceneMouseEvent
     if (event->button() != Qt::LeftButton)
         return;
 
-    startGeometry = q->geometry();
-    grabbedSection = q->windowFrameSectionAt(event->pos());
-    switch (grabbedSection) {
-    case Qt::LeftSection:
-    case Qt::TopLeftSection:
-        mouseDelta = event->pos() - q->rect().topLeft();
-        break;
-    case Qt::TopSection:
-    case Qt::TopRightSection:
-        mouseDelta = event->pos() - q->rect().topRight();
-        break;
-    case Qt::RightSection:
-    case Qt::BottomRightSection:
-        mouseDelta = event->pos() - q->rect().bottomRight();
-        break;
-    case Qt::BottomSection:
-    case Qt::BottomLeftSection:
-        mouseDelta = event->pos() - q->rect().bottomLeft();
-        break;
-    case Qt::TitleBarArea:
-        if (hoveredSubControl == QStyle::SC_TitleBarCloseButton) {
-            buttonSunken = true;
-            q->update();
-        }
-        break;
-    case Qt::NoSection:
-        break;
+    ensureWindowData();
+    windowData->startGeometry = q->geometry();
+    windowData->grabbedSection = q->windowFrameSectionAt(event->pos());
+    ensureWindowData();
+    if (windowData->grabbedSection == Qt::TitleBarArea
+        && windowData->hoveredSubControl == QStyle::SC_TitleBarCloseButton) {
+        windowData->buttonSunken = true;
+        q->update();
     }
-    event->setAccepted(grabbedSection != Qt::NoSection);
+    event->setAccepted(windowData->grabbedSection != Qt::NoSection);
 }
 
 static void _q_boundGeometryToSizeConstraints(const QRectF &startGeometry,
@@ -455,7 +443,8 @@ static void _q_boundGeometryToSizeConstraints(const QRectF &startGeometry,
 void QGraphicsWidgetPrivate::windowFrameMouseMoveEvent(QGraphicsSceneMouseEvent *event)
 {
     Q_Q(QGraphicsWidget);
-    if (!(event->buttons() & Qt::LeftButton) || hoveredSubControl != QStyle::SC_TitleBarLabel)
+    ensureWindowData();
+    if (!(event->buttons() & Qt::LeftButton) || windowData->hoveredSubControl != QStyle::SC_TitleBarLabel)
         return;
 
     QLineF delta(q->mapFromScene(event->buttonDownScenePos(Qt::LeftButton)), event->pos());
@@ -464,49 +453,56 @@ void QGraphicsWidgetPrivate::windowFrameMouseMoveEvent(QGraphicsSceneMouseEvent
     QLineF parentYDelta(q->mapToParent(QPointF(0, delta.p1().y())), q->mapToParent(QPointF(0, delta.p2().y())));
 
     QRectF newGeometry;
-    switch (grabbedSection) {
+    switch (windowData->grabbedSection) {
     case Qt::LeftSection:
-        newGeometry = QRectF(startGeometry.topLeft() + QPointF(parentXDelta.dx(), parentXDelta.dy()),
-                             startGeometry.size() - QSizeF(delta.dx(), delta.dy()));
+        newGeometry = QRectF(windowData->startGeometry.topLeft()
+                             + QPointF(parentXDelta.dx(), parentXDelta.dy()),
+                             windowData->startGeometry.size() - QSizeF(delta.dx(), delta.dy()));
         break;
     case Qt::TopLeftSection:
-        newGeometry = QRectF(startGeometry.topLeft() + QPointF(parentDelta.dx(), parentDelta.dy()),
-                             startGeometry.size() - QSizeF(delta.dx(), delta.dy()));
+        newGeometry = QRectF(windowData->startGeometry.topLeft()
+                             + QPointF(parentDelta.dx(), parentDelta.dy()),
+                             windowData->startGeometry.size() - QSizeF(delta.dx(), delta.dy()));
         break;
     case Qt::TopSection:
-        newGeometry = QRectF(startGeometry.topLeft() + QPointF(parentYDelta.dx(), parentYDelta.dy()),
-                             startGeometry.size() - QSizeF(0, delta.dy()));
+        newGeometry = QRectF(windowData->startGeometry.topLeft()
+                             + QPointF(parentYDelta.dx(), parentYDelta.dy()),
+                             windowData->startGeometry.size() - QSizeF(0, delta.dy()));
         break;
     case Qt::TopRightSection:
-        newGeometry = QRectF(startGeometry.topLeft() + QPointF(parentYDelta.dx(), parentYDelta.dy()),
-                             startGeometry.size() - QSizeF(-delta.dx(), delta.dy()));
+        newGeometry = QRectF(windowData->startGeometry.topLeft()
+                             + QPointF(parentYDelta.dx(), parentYDelta.dy()),
+                             windowData->startGeometry.size() - QSizeF(-delta.dx(), delta.dy()));
         break;
     case Qt::RightSection:
-        newGeometry = QRectF(startGeometry.topLeft(),
-                             startGeometry.size() + QSizeF(delta.dx(), 0));
+        newGeometry = QRectF(windowData->startGeometry.topLeft(),
+                             windowData->startGeometry.size() + QSizeF(delta.dx(), 0));
         break;
     case Qt::BottomRightSection:
-        newGeometry = QRectF(startGeometry.topLeft(),
-                             startGeometry.size() + QSizeF(delta.dx(), delta.dy()));
+        newGeometry = QRectF(windowData->startGeometry.topLeft(),
+                             windowData->startGeometry.size() + QSizeF(delta.dx(), delta.dy()));
         break;
     case Qt::BottomSection:
-        newGeometry = QRectF(startGeometry.topLeft(),
-                             startGeometry.size() + QSizeF(0, delta.dy()));
+        newGeometry = QRectF(windowData->startGeometry.topLeft(),
+                             windowData->startGeometry.size() + QSizeF(0, delta.dy()));
         break;
     case Qt::BottomLeftSection:
-        newGeometry = QRectF(startGeometry.topLeft() + QPointF(parentXDelta.dx(), parentXDelta.dy()),
-                             startGeometry.size() - QSizeF(delta.dx(), -delta.dy()));
+        newGeometry = QRectF(windowData->startGeometry.topLeft()
+                             + QPointF(parentXDelta.dx(), parentXDelta.dy()),
+                             windowData->startGeometry.size() - QSizeF(delta.dx(), -delta.dy()));
         break;
     case Qt::TitleBarArea:
-        newGeometry = QRectF(startGeometry.topLeft() + QPointF(parentDelta.dx(), parentDelta.dy()),
-                             startGeometry.size());
+        newGeometry = QRectF(windowData->startGeometry.topLeft()
+                             + QPointF(parentDelta.dx(), parentDelta.dy()),
+                             windowData->startGeometry.size());
         break;
     case Qt::NoSection:
         break;
     }
 
-    if (grabbedSection != Qt::NoSection) {
-        _q_boundGeometryToSizeConstraints(startGeometry, &newGeometry, grabbedSection,
+    if (windowData->grabbedSection != Qt::NoSection) {
+        _q_boundGeometryToSizeConstraints(windowData->startGeometry, &newGeometry,
+                                          windowData->grabbedSection,
                                           q->effectiveSizeHint(Qt::MinimumSize),
                                           q->effectiveSizeHint(Qt::MaximumSize));
         q->setGeometry(newGeometry);
@@ -519,21 +515,25 @@ void QGraphicsWidgetPrivate::windowFrameHoverMoveEvent(QGraphicsSceneHoverEvent
     if (!hasDecoration())
         return;
 
+    ensureWindowData();
+
     if (q->rect().contains(event->pos())) {
-        if (buttonMouseOver || hoveredSubControl != QStyle::SC_None)
+        if (windowData->buttonMouseOver || windowData->hoveredSubControl != QStyle::SC_None)
             windowFrameHoverLeaveEvent(event);
         return;
     }
 
-    bool wasMouseOver = buttonMouseOver;
-    QRect oldButtonRect = buttonRect;
-    buttonRect = QRect();
-    buttonMouseOver = false;
+    bool wasMouseOver = windowData->buttonMouseOver;
+    QRect oldButtonRect = windowData->buttonRect;
+    windowData->buttonRect = QRect();
+    windowData->buttonMouseOver = false;
     QPointF pos = event->pos();
     QStyleOptionTitleBar bar;
     // make sure that the coordinates (rect and pos) we send to the style are positive.
-    pos.rx() += leftWindowFrameMargin;
-    pos.ry() += topWindowFrameMargin;
+    if (windowFrameMargins) {
+        pos.rx() += windowFrameMargins[Left];
+        pos.ry() += windowFrameMargins[Top];
+    }
     initStyleOptionTitleBar(&bar);
     bar.rect = q->windowFrameRect().toRect();
     bar.rect.moveTo(0,0);
@@ -559,14 +559,17 @@ void QGraphicsWidgetPrivate::windowFrameHoverMoveEvent(QGraphicsSceneHoverEvent
             cursorShape = Qt::SizeVerCursor;
             break;
         case Qt::TitleBarArea:
-            buttonRect = q->style()->subControlRect(QStyle::CC_TitleBar, &bar, QStyle::SC_TitleBarCloseButton, 0);
+            windowData->buttonRect = q->style()->subControlRect(
+                QStyle::CC_TitleBar, &bar, QStyle::SC_TitleBarCloseButton, 0);
 #ifdef Q_WS_MAC
             // On mac we should hover if we are in the 'area' of the buttons
-            buttonRect |= q->style()->subControlRect(QStyle::CC_TitleBar, &bar, QStyle::SC_TitleBarMinButton, 0);
-            buttonRect |= q->style()->subControlRect(QStyle::CC_TitleBar, &bar, QStyle::SC_TitleBarMaxButton, 0);
+            windowData->buttonRect |= q->style()->subControlRect(
+                QStyle::CC_TitleBar, &bar, QStyle::SC_TitleBarMinButton, 0);
+            windowData->buttonRect |= q->style()->subControlRect(
+                QStyle::CC_TitleBar, &bar, QStyle::SC_TitleBarMaxButton, 0);
 #endif
-            if (buttonRect.contains(pos.toPoint()))
-                buttonMouseOver = true;
+            if (windowData->buttonRect.contains(pos.toPoint()))
+                windowData->buttonMouseOver = true;
             event->ignore();
             break;
         default:
@@ -578,15 +581,15 @@ void QGraphicsWidgetPrivate::windowFrameHoverMoveEvent(QGraphicsSceneHoverEvent
         q->setCursor(cursorShape);
 #endif
     // update buttons if we hover over them
-    hoveredSubControl = q->style()->hitTestComplexControl(QStyle::CC_TitleBar, &bar, pos.toPoint(), 0);
-    if (hoveredSubControl != QStyle::SC_TitleBarCloseButton)
-        hoveredSubControl = QStyle::SC_TitleBarLabel;
+    windowData->hoveredSubControl = q->style()->hitTestComplexControl(QStyle::CC_TitleBar, &bar, pos.toPoint(), 0);
+    if (windowData->hoveredSubControl != QStyle::SC_TitleBarCloseButton)
+        windowData->hoveredSubControl = QStyle::SC_TitleBarLabel;
 
-    if (buttonMouseOver != wasMouseOver) {
+    if (windowData->buttonMouseOver != wasMouseOver) {
         if (!oldButtonRect.isNull())
             q->update(QRectF(oldButtonRect).translated(q->windowFrameRect().topLeft()));
-        if (!buttonRect.isNull())
-            q->update(QRectF(buttonRect).translated(q->windowFrameRect().topLeft()));
+        if (!windowData->buttonRect.isNull())
+            q->update(QRectF(windowData->buttonRect).translated(q->windowFrameRect().topLeft()));
     }
 }
 
@@ -600,16 +603,19 @@ void QGraphicsWidgetPrivate::windowFrameHoverLeaveEvent(QGraphicsSceneHoverEvent
         q->unsetCursor();
 #endif
 
+        ensureWindowData();
+
         bool needsUpdate = false;
-        if (hoveredSubControl == QStyle::SC_TitleBarCloseButton || buttonMouseOver)
+        if (windowData->hoveredSubControl == QStyle::SC_TitleBarCloseButton
+            || windowData->buttonMouseOver)
             needsUpdate = true;
 
         // update the hover state (of buttons etc...)
-        hoveredSubControl = QStyle::SC_None;
-        buttonMouseOver = false;
-        buttonRect = QRect();
+        windowData->hoveredSubControl = QStyle::SC_None;
+        windowData->buttonMouseOver = false;
+        windowData->buttonRect = QRect();
         if (needsUpdate)
-            q->update(buttonRect);
+            q->update(windowData->buttonRect);
     }
 }
 
diff --git a/src/gui/graphicsview/qgraphicswidget_p.h b/src/gui/graphicsview/qgraphicswidget_p.h
index 53eaa31..f4cdeca 100644
--- a/src/gui/graphicsview/qgraphicswidget_p.h
+++ b/src/gui/graphicsview/qgraphicswidget_p.h
@@ -68,19 +68,12 @@ class QStyleOptionTitleBar;
 
 #if !defined(QT_NO_GRAPHICSVIEW) || (QT_EDITION & QT_MODULE_GRAPHICSVIEW) != QT_MODULE_GRAPHICSVIEW
 
-class Q_GUI_EXPORT QGraphicsWidgetPrivate : public QGraphicsItemPrivate
+class QGraphicsWidgetPrivate : public QGraphicsItemPrivate
 {
     Q_DECLARE_PUBLIC(QGraphicsWidget)
 public:
     QGraphicsWidgetPrivate()
-        : leftMargin(0),
-          topMargin(0),
-          rightMargin(0),
-          bottomMargin(0),
-          leftLayoutItemMargin(0),
-          topLayoutItemMargin(0),
-          rightLayoutItemMargin(0),
-          bottomLayoutItemMargin(0),
+        : margins(0),
           layout(0),
           inheritedPaletteResolveMask(0),
           inheritedFontResolveMask(0),
@@ -92,40 +85,23 @@ public:
           focusPrev(0),
           focusChild(0),
           windowFlags(0),
-          hoveredSubControl(QStyle::SC_None),
-          grabbedSection(Qt::NoSection),
-          buttonMouseOver(false),
-          buttonSunken(false),
+          windowData(0),
           setWindowFrameMargins(false),
-          leftWindowFrameMargin(0),
-          topWindowFrameMargin(0),
-          rightWindowFrameMargin(0),
-          bottomWindowFrameMargin(0)
+          windowFrameMargins(0)
     { }
+    virtual ~QGraphicsWidgetPrivate();
 
     void init(QGraphicsItem *parentItem, Qt::WindowFlags wFlags);
     qreal titleBarHeight(const QStyleOptionTitleBar &options) const;
 
     // Margins
-    qreal leftMargin;
-    qreal topMargin;
-    qreal rightMargin;
-    qreal bottomMargin;
-    QRectF contentsRect;
-
-    // Layout item margins
-    void getLayoutItemMargins(qreal *left, qreal *top, qreal *right, qreal *bottom) const;
-    void setLayoutItemMargins(qreal left, qreal top, qreal right, qreal bottom);
-    void setLayoutItemMargins(QStyle::SubElement element, const QStyleOption *opt = 0);
+    enum {Left, Top, Right, Bottom};
+    mutable qreal *margins;
+    void ensureMargins() const;
 
     void fixFocusChainBeforeReparenting(QGraphicsWidget *newParent, QGraphicsScene *newScene = 0);
     void setLayout_helper(QGraphicsLayout *l);
 
-    qreal leftLayoutItemMargin;
-    qreal topLayoutItemMargin;
-    qreal rightLayoutItemMargin;
-    qreal bottomLayoutItemMargin;
-
     // Layouts
     QGraphicsLayout *layout;
     void setLayoutDirection_helper(Qt::LayoutDirection direction);
@@ -208,20 +184,26 @@ public:
 
     // Windows
     Qt::WindowFlags windowFlags;
-    QString windowTitle;
-    QStyle::SubControl hoveredSubControl;
-    Qt::WindowFrameSection grabbedSection;
-    uint buttonMouseOver : 1;
-    uint buttonSunken : 1;
-    QPointF mouseDelta; // to compensate for small error when interactively resizing
-    QRectF startGeometry;
-    QRect buttonRect;
+    struct WindowData {
+        QString windowTitle;
+        QStyle::SubControl hoveredSubControl;
+        Qt::WindowFrameSection grabbedSection;
+        uint buttonMouseOver : 1;
+        uint buttonSunken : 1;
+        QRectF startGeometry;
+        QRect buttonRect;
+        WindowData()
+            : hoveredSubControl(QStyle::SC_None)
+            , grabbedSection(Qt::NoSection)
+            , buttonMouseOver(false)
+            , buttonSunken(false)
+        {}
+    } *windowData;
+    void ensureWindowData();
 
     bool setWindowFrameMargins;
-    qreal leftWindowFrameMargin;
-    qreal topWindowFrameMargin;
-    qreal rightWindowFrameMargin;
-    qreal bottomWindowFrameMargin;
+    mutable qreal *windowFrameMargins;
+    void ensureWindowFrameMargins() const;
 
 #ifndef QT_NO_ACTION
     QList<QAction *> actions;
diff --git a/src/gui/graphicsview/qgridlayoutengine.cpp b/src/gui/graphicsview/qgridlayoutengine.cpp
index dc5ca21..c150b0e 100644
--- a/src/gui/graphicsview/qgridlayoutengine.cpp
+++ b/src/gui/graphicsview/qgridlayoutengine.cpp
@@ -275,7 +275,7 @@ void QGridLayoutRowData::calculateGeometries(int start, int end, qreal targetSiz
                         if (hasIgnoreFlag) {
                             factors[i] = (stretch < 0) ? 1.0 : 0.0;
                         } else {
-                            factors[i] = (stretch < 0) ? sizes[i] : 0.0;                        
+                            factors[i] = (stretch < 0) ? sizes[i] : 0.0;
                         }
                     } else if (stretch == sumStretches) {
                         factors[i] = 1.0;
@@ -615,7 +615,7 @@ QRectF QGridLayoutItem::geometryWithin(qreal x, qreal y, qreal width, qreal heig
         QSizeF size = effectiveMaxSize().boundedTo(QSizeF(cellWidth, cellHeight));
         width = size.width();
         height = size.height();
-        
+
         Qt::Alignment align = q_engine->effectiveAlignment(this);
         switch (align & Qt::AlignHorizontal_Mask) {
         case Qt::AlignHCenter:
@@ -717,7 +717,7 @@ void QGridLayoutItem::dump(int indent) const
 void QGridLayoutRowInfo::insertOrRemoveRows(int row, int delta)
 {
     count += delta;
-    
+
     insertOrRemoveItems(stretches, row, delta);
     insertOrRemoveItems(spacings, row, delta);
     insertOrRemoveItems(alignments, row, delta);
@@ -1076,7 +1076,7 @@ QSizeF QGridLayoutEngine::sizeHint(const QLayoutStyleInfo &styleInfo, Qt::SizeHi
         break;
     }
     return QSizeF();
-} 
+}
 
 QSizePolicy::ControlTypes QGridLayoutEngine::controlTypes(LayoutSide side) const
 {
@@ -1150,16 +1150,16 @@ void QGridLayoutEngine::dump(int indent) const
     q_rowData.dump(indent + 2);
 
     qDebug("%*s Geometries output", indent, "");
+    QVector<qreal> *cellPos = &q_yy;
     for (int pass = 0; pass < 2; ++pass) {
-        QVector<qreal> &cellPos = q_yy;
         QString message;
-        for (i = 0; i < cellPos.count(); ++i) {
+        for (i = 0; i < cellPos->count(); ++i) {
             message += QLatin1String((message.isEmpty() ? "[" : ", "));
-            message += QString::number(cellPos.at(i));
+            message += QString::number(cellPos->at(i));
         }
         message += QLatin1String("]");
         qDebug("%*s %s %s", indent, "", (pass == 0 ? "rows:" : "columns:"), qPrintable(message));
-        cellPos = q_xx;
+        cellPos = &q_xx;
     }
 }
 #endif
@@ -1538,5 +1538,5 @@ void QGridLayoutEngine::ensureGeometries(const QLayoutStyleInfo &styleInfo,
 }
 
 QT_END_NAMESPACE
-        
+
 #endif //QT_NO_GRAPHICSVIEW