Merge commit 'origin/4.5'

Conflicts: src/gui/graphicsview/qgraphicsitem.cpp src/gui/graphicsview/qgraphicsitem_p.h src/gui/graphicsview/qgraphicsscene.cpp src/gui/painting/qtransform.cpp
author: Bjoern Erik Nilsen <bjorn.nilsen@nokia.com> 2009-04-07 10:59:16 (GMT)
committer: Bjoern Erik Nilsen <bjorn.nilsen@nokia.com> 2009-04-07 10:59:16 (GMT)
commit: 6e13559503040963c28dd8f5b6881e3a2b9d5596 (patch)
tree: 3e030548ffb1667d5fa8cd2020fd7b28749d0411 /src/gui
parent: 939623b2bc8e441618ee1a1886cc656880bee62b (diff)
parent: d8f76432c3937690c37972136c02a5a264bc941f (diff)
download: Qt-6e13559503040963c28dd8f5b6881e3a2b9d5596.zip
Qt-6e13559503040963c28dd8f5b6881e3a2b9d5596.tar.gz
Qt-6e13559503040963c28dd8f5b6881e3a2b9d5596.tar.bz2
24 files changed, 1038 insertions, 497 deletions
diff --git a/src/gui/dialogs/qfilesystemmodel.cpp b/src/gui/dialogs/qfilesystemmodel.cpp
index c7b3137..012d3a1 100644
--- a/src/gui/dialogs/qfilesystemmodel.cpp
+++ b/src/gui/dialogs/qfilesystemmodel.cpp
@@ -1430,7 +1430,10 @@ void QFileSystemModel::setFilter(QDir::Filters filters)
 }
 
 /*!
-    Returns the filter specification for the directory model.
+    Returns the filter specified for the directory model.
+
+    If a filter has not been set, the default filter is QDir::AllEntries |
+    QDir::NoDotAndDotDot | QDir::AllDirs.
 
     \sa QDir::Filters
 */
diff --git a/src/gui/graphicsview/qgraphicsitem.cpp b/src/gui/graphicsview/qgraphicsitem.cpp
index c5f5889..0f39263 100644
--- a/src/gui/graphicsview/qgraphicsitem.cpp
+++ b/src/gui/graphicsview/qgraphicsitem.cpp
@@ -533,25 +533,22 @@ QT_BEGIN_NAMESPACE
 
 // QRectF::intersects() returns false always if either the source or target
 // rectangle's width or height are 0. This works around that problem.
-static QRectF _q_adjustedRect(const QRectF &rect)
-{
-    static const qreal p = (qreal)0.00001;
-    QRectF r = rect;
-    if (!r.width())
-        r.adjust(-p, 0, p, 0);
-    if (!r.height())
-        r.adjust(0, -p, 0, p);
-    return r;
+static inline void _q_adjustRect(QRectF *rect)
+{
+    Q_ASSERT(rect);
+    if (!rect->width())
+        rect->adjust(-0.00001, 0, 0.00001, 0);
+    if (!rect->height())
+        rect->adjust(0, -0.00001, 0, 0.00001);
 }
 
-static QRect _q_adjustedRect(const QRect &rect)
+static inline void _q_adjustRect(QRect *rect)
 {
-    QRect r = rect;
-    if (!r.width())
-        r.adjust(0, 0, 1, 0);
-    if (!r.height())
-        r.adjust(0, 0, 0, 1);
-    return r;
+    Q_ASSERT(rect);
+    if (!rect->width())
+        rect->adjust(0, 0, 1, 0);
+    if (!rect->height())
+        rect->adjust(0, 0, 0, 1);
 }
 
 /*
@@ -613,6 +610,7 @@ void QGraphicsItemPrivate::updateAncestorFlag(QGraphicsItem::GraphicsItemFlag ch
         case QGraphicsItem::ItemClipsChildrenToShape:
             flag = AncestorClipsChildren;
             enabled = flags & QGraphicsItem::ItemClipsChildrenToShape;
+            invalidateCachedClipPathRecursively(/*childrenOnly=*/true);
             break;
         case QGraphicsItem::ItemIgnoresTransformations:
             flag = AncestorIgnoresTransformations;
@@ -779,9 +777,9 @@ void QGraphicsItemPrivate::setParentItemHelper(QGraphicsItem *newParent, bool de
     if (newParent == parent)
         return;
 
-    QVariant variant;
-    qVariantSetValue<QGraphicsItem *>(variant, newParent);
-    newParent = qVariantValue<QGraphicsItem *>(q->itemChange(QGraphicsItem::ItemParentChange, variant));
+    const QVariant newParentVariant(q->itemChange(QGraphicsItem::ItemParentChange,
+                                                  qVariantFromValue<QGraphicsItem *>(newParent)));
+    newParent = qVariantValue<QGraphicsItem *>(newParentVariant);
     if (newParent == parent)
         return;
 
@@ -799,11 +797,11 @@ void QGraphicsItemPrivate::setParentItemHelper(QGraphicsItem *newParent, bool de
     if (!deleting)
         q_ptr->prepareGeometryChange();
 
+    const QVariant thisPointerVariant(qVariantFromValue<QGraphicsItem *>(q));
     if (parent) {
         // Remove from current parent
         parent->d_ptr->removeChild(q);
-        qVariantSetValue<QGraphicsItem *>(variant, q);
-        parent->itemChange(QGraphicsItem::ItemChildRemovedChange, variant);
+        parent->itemChange(QGraphicsItem::ItemChildRemovedChange, thisPointerVariant);
     }
 
     // Update toplevelitem list. If this item is being deleted, its parent
@@ -828,10 +826,9 @@ void QGraphicsItemPrivate::setParentItemHelper(QGraphicsItem *newParent, bool de
         }
 
         parent->d_ptr->addChild(q);
-        qVariantSetValue<QGraphicsItem *>(variant, q);
-        parent->itemChange(QGraphicsItem::ItemChildAddedChange, variant);
+        parent->itemChange(QGraphicsItem::ItemChildAddedChange, thisPointerVariant);
         if (!implicitUpdate)
-            updateHelper();
+            updateHelper(QRectF(), false, true);
 
         // Inherit ancestor flags from the new parent.
         updateAncestorFlag(QGraphicsItem::GraphicsItemFlag(-1));
@@ -862,7 +859,7 @@ void QGraphicsItemPrivate::setParentItemHelper(QGraphicsItem *newParent, bool de
                 setEnabledHelper(true, /* explicit = */ false);
 
             // If the item is being deleted, the whole scene will be updated.
-            updateHelper();
+            updateHelper(QRectF(), false, true);
         }
     }
 
@@ -873,10 +870,7 @@ void QGraphicsItemPrivate::setParentItemHelper(QGraphicsItem *newParent, bool de
     }
 
     // Resolve opacity.
-    if (parent)
-        resolveEffectiveOpacity(parent->effectiveOpacity());
-    else
-        resolveEffectiveOpacity(1.0);
+    updateEffectiveOpacity();
 
     // Resolve depth.
     resolveDepth(parent ? parent->d_ptr->depth : -1);
@@ -885,7 +879,7 @@ void QGraphicsItemPrivate::setParentItemHelper(QGraphicsItem *newParent, bool de
     invalidateSceneTransformCache();
 
     // Deliver post-change notification
-    q->itemChange(QGraphicsItem::ItemParentHasChanged, qVariantFromValue<QGraphicsItem *>(parent));
+    q->itemChange(QGraphicsItem::ItemParentHasChanged, newParentVariant);
 }
 
 /*!
@@ -1240,7 +1234,7 @@ void QGraphicsItem::setFlags(GraphicsItemFlags flags)
     int geomChangeFlagsMask = (ItemClipsChildrenToShape | ItemClipsToShape | ItemIgnoresTransformations);
     bool fullUpdate = (flags & geomChangeFlagsMask) != (d_ptr->flags & geomChangeFlagsMask);
     if (fullUpdate)
-        d_ptr->fullUpdateHelper();
+        d_ptr->fullUpdateHelper(false, true);
 
     // Keep the old flags to compare the diff.
     GraphicsItemFlags oldFlags = this->flags();
@@ -1250,12 +1244,8 @@ void QGraphicsItem::setFlags(GraphicsItemFlags flags)
 
     // Reresolve effective opacity if the opacity flags change.
     static const quint32 opacityFlagsMask = ItemIgnoresParentOpacity | ItemDoesntPropagateOpacityToChildren;
-    if ((flags & opacityFlagsMask) != (oldFlags & opacityFlagsMask)) {
-        if (QGraphicsItem *p = d_ptr->parent)
-            d_ptr->resolveEffectiveOpacity(p->effectiveOpacity());
-        else
-            d_ptr->resolveEffectiveOpacity(1.0);
-    }
+    if ((flags & opacityFlagsMask) != (oldFlags & opacityFlagsMask))
+        d_ptr->updateEffectiveOpacity();
 
     if (!(d_ptr->flags & ItemIsFocusable) && hasFocus()) {
         // Clear focus on the item if it has focus when the focusable flag
@@ -1275,6 +1265,9 @@ void QGraphicsItem::setFlags(GraphicsItemFlags flags)
         d_ptr->updateAncestorFlag(ItemClipsChildrenToShape);
     }
 
+    if ((flags & ItemClipsToShape) != (oldFlags & ItemClipsToShape))
+        d_ptr->invalidateCachedClipPath();
+
     if ((flags & ItemIgnoresTransformations) != (oldFlags & ItemIgnoresTransformations)) {
         // Item children clipping changes. Propagate the ancestor flag to
         // all children.
@@ -1282,7 +1275,7 @@ void QGraphicsItem::setFlags(GraphicsItemFlags flags)
     }
 
     // ### Why updateHelper?
-    d_ptr->updateHelper();
+    d_ptr->updateHelper(QRectF(), false, true);
 
     // Notify change.
     itemChange(ItemFlagsHaveChanged, quint32(flags));
@@ -1380,9 +1373,9 @@ QString QGraphicsItem::toolTip() const
 */
 void QGraphicsItem::setToolTip(const QString &toolTip)
 {
-    QString newCursor = itemChange(ItemToolTipChange, toolTip).toString();
-    d_ptr->setExtra(QGraphicsItemPrivate::ExtraToolTip, toolTip);
-    itemChange(ItemToolTipHasChanged, toolTip);
+    const QVariant toolTipVariant(itemChange(ItemToolTipChange, toolTip));
+    d_ptr->setExtra(QGraphicsItemPrivate::ExtraToolTip, toolTipVariant.toString());
+    itemChange(ItemToolTipHasChanged, toolTipVariant);
 }
 #endif // QT_NO_TOOLTIP
 
@@ -1424,9 +1417,8 @@ QCursor QGraphicsItem::cursor() const
 */
 void QGraphicsItem::setCursor(const QCursor &cursor)
 {
-    QCursor newCursor = qVariantValue<QCursor>(itemChange(ItemCursorChange,
-                                                          qVariantFromValue<QCursor>(cursor)));
-    d_ptr->setExtra(QGraphicsItemPrivate::ExtraCursor, newCursor);
+    const QVariant cursorVariant(itemChange(ItemCursorChange, qVariantFromValue<QCursor>(cursor)));
+    d_ptr->setExtra(QGraphicsItemPrivate::ExtraCursor, qVariantValue<QCursor>(cursorVariant));
     d_ptr->hasCursor = 1;
     if (d_ptr->scene) {
         foreach (QGraphicsView *view, d_ptr->scene->views()) {
@@ -1443,7 +1435,7 @@ void QGraphicsItem::setCursor(const QCursor &cursor)
             }
         }
     }
-    itemChange(ItemCursorHasChanged, qVariantFromValue<QCursor>(newCursor));
+    itemChange(ItemCursorHasChanged, cursorVariant);
 }
 
 /*!
@@ -1537,7 +1529,9 @@ void QGraphicsItemPrivate::setVisibleHelper(bool newVisible, bool explicitly, bo
         return;
 
     // Modify the property.
-    newVisible = q_ptr->itemChange(QGraphicsItem::ItemVisibleChange, quint32(newVisible)).toBool();
+    const QVariant newVisibleVariant(q_ptr->itemChange(QGraphicsItem::ItemVisibleChange,
+                                                       quint32(newVisible)));
+    newVisible = newVisibleVariant.toBool();
     if (visible == quint32(newVisible))
         return;
     visible = newVisible;
@@ -1584,9 +1578,10 @@ void QGraphicsItemPrivate::setVisibleHelper(bool newVisible, bool explicitly, bo
     }
 
     // Update children with explicitly = false.
+    const bool updateChildren = update && !(flags & QGraphicsItem::ItemClipsChildrenToShape);
     foreach (QGraphicsItem *child, children) {
         if (!newVisible || !child->d_ptr->explicitlyHidden)
-            child->d_ptr->setVisibleHelper(newVisible, false);
+            child->d_ptr->setVisibleHelper(newVisible, false, updateChildren);
     }
 
     // Enable subfocus
@@ -1598,7 +1593,7 @@ void QGraphicsItemPrivate::setVisibleHelper(bool newVisible, bool explicitly, bo
     }
 
     // Deliver post-change notification.
-    q_ptr->itemChange(QGraphicsItem::ItemVisibleHasChanged, quint32(visible));
+    q_ptr->itemChange(QGraphicsItem::ItemVisibleHasChanged, newVisibleVariant);
 }
 
 /*!
@@ -1704,7 +1699,9 @@ void QGraphicsItemPrivate::setEnabledHelper(bool newEnabled, bool explicitly, bo
     }
 
     // Modify the property.
-    enabled = q_ptr->itemChange(QGraphicsItem::ItemEnabledChange, quint32(newEnabled)).toBool();
+    const QVariant newEnabledVariant(q_ptr->itemChange(QGraphicsItem::ItemEnabledChange,
+                                                       quint32(newEnabled)));
+    enabled = newEnabledVariant.toBool();
 
     // Schedule redraw.
     if (update)
@@ -1716,7 +1713,7 @@ void QGraphicsItemPrivate::setEnabledHelper(bool newEnabled, bool explicitly, bo
     }
 
     // Deliver post-change notification.
-    q_ptr->itemChange(QGraphicsItem::ItemEnabledHasChanged, quint32(enabled));
+    q_ptr->itemChange(QGraphicsItem::ItemEnabledHasChanged, newEnabledVariant);
 }
 
 /*!
@@ -1803,7 +1800,8 @@ void QGraphicsItem::setSelected(bool selected)
         selected = false;
     if (d_ptr->selected == selected)
         return;
-    bool newSelected = itemChange(ItemSelectedChange, quint32(selected)).toBool();
+    const QVariant newSelectedVariant(itemChange(ItemSelectedChange, quint32(selected)));
+    bool newSelected = newSelectedVariant.toBool();
     if (d_ptr->selected == newSelected)
         return;
     d_ptr->selected = newSelected;
@@ -1823,7 +1821,7 @@ void QGraphicsItem::setSelected(bool selected)
     }
 
     // Deliver post-change notification.
-    itemChange(QGraphicsItem::ItemSelectedHasChanged, quint32(d_ptr->selected));
+    itemChange(QGraphicsItem::ItemSelectedHasChanged, newSelectedVariant);
 }
 
 /*!
@@ -1867,6 +1865,9 @@ qreal QGraphicsItem::opacity() const
 */
 qreal QGraphicsItem::effectiveOpacity() const
 {
+    if (!d_ptr->hasEffectiveOpacity)
+        return qreal(1.0);
+
     QVariant effectiveOpacity = d_ptr->extra(QGraphicsItemPrivate::ExtraEffectiveOpacity);
     return effectiveOpacity.isNull() ? qreal(1.0) : qreal(effectiveOpacity.toDouble());
 }
@@ -1896,7 +1897,8 @@ qreal QGraphicsItem::effectiveOpacity() const
 void QGraphicsItem::setOpacity(qreal opacity)
 {
     // Notify change.
-    qreal newOpacity = itemChange(ItemOpacityChange, double(opacity)).toDouble();
+    const QVariant newOpacityVariant(itemChange(ItemOpacityChange, double(opacity)));
+    qreal newOpacity = newOpacityVariant.toDouble();
 
     // Normalize.
     newOpacity = qBound<qreal>(0.0, newOpacity, 1.0);
@@ -2354,19 +2356,22 @@ QPointF QGraphicsItem::scenePos() const
     the item is also updated; otherwise it is not updated before and after the
     change.
 */
-void QGraphicsItemPrivate::setPosHelper(const QPointF &pos, bool update)
+void QGraphicsItemPrivate::setPosHelper(const QPointF &pos)
 {
     Q_Q(QGraphicsItem);
     if (this->pos == pos)
         return;
 
     // Notify the item that the position is changing.
-    QPointF newPos = q->itemChange(QGraphicsItem::ItemPositionChange, pos).toPointF();
+    const QVariant newPosVariant(q->itemChange(QGraphicsItem::ItemPositionChange, pos));
+    QPointF newPos = newPosVariant.toPointF();
     if (newPos == this->pos)
         return;
 
     // Update and repositition.
-    if (scene && update) {
+    inSetPosHelper = 1;
+    updateCachedClipPathFromSetPosHelper(newPos);
+    if (scene) {
         fullUpdateHelper(true);
         q->prepareGeometryChange();
     }
@@ -2374,7 +2379,8 @@ void QGraphicsItemPrivate::setPosHelper(const QPointF &pos, bool update)
     invalidateSceneTransformCache();
 
     // Send post-notification.
-    q->itemChange(QGraphicsItem::ItemPositionHasChanged, newPos);
+    q->itemChange(QGraphicsItem::ItemPositionHasChanged, newPosVariant);
+    inSetPosHelper = 0;
 }
 
 /*!
@@ -2389,7 +2395,7 @@ void QGraphicsItemPrivate::setPosHelper(const QPointF &pos, bool update)
 */
 void QGraphicsItem::setPos(const QPointF &pos)
 {
-    d_ptr->setPosHelper(pos, /* update = */ true);
+    d_ptr->setPosHelper(pos);
 }
 
 /*!
@@ -2516,10 +2522,10 @@ QTransform QGraphicsItem::sceneTransform() const
     QTransform m;
     if (d_ptr->hasTransform) {
         m = transform();
-        m *= QTransform::fromTranslate(d_ptr->pos.x(), d_ptr->pos.y());
-    } else {
-        // ### ? QTransform::fromTranslate(d_ptr->pos.x(), d_ptr->pos.y())
-        m.translate(d_ptr->pos.x(), d_ptr->pos.y());
+        if (!d_ptr->pos.isNull())
+            m *= QTransform::fromTranslate(d_ptr->pos.x(), d_ptr->pos.y());
+    } else if (!d_ptr->pos.isNull()) {
+        m = QTransform::fromTranslate(d_ptr->pos.x(), d_ptr->pos.y());
     }
 
     // Combine with parent and add to cache.
@@ -2644,6 +2650,8 @@ QTransform QGraphicsItem::itemTransform(const QGraphicsItem *other, bool *ok) co
         if (ok)
             *ok = true;
         const QPointF &itemPos = d_ptr->pos;
+        if (itemPos.isNull())
+            return d_ptr->hasTransform ? transform() : QTransform();
         if (d_ptr->hasTransform)
             return transform() * QTransform::fromTranslate(itemPos.x(), itemPos.y());
         return QTransform::fromTranslate(itemPos.x(), itemPos.y());
@@ -2654,7 +2662,8 @@ QTransform QGraphicsItem::itemTransform(const QGraphicsItem *other, bool *ok) co
         const QPointF &otherPos = other->d_ptr->pos;
         if (other->d_ptr->hasTransform) {
             QTransform otherToParent = other->transform();
-            otherToParent *= QTransform::fromTranslate(otherPos.x(), otherPos.y());
+            if (!otherPos.isNull())
+                otherToParent *= QTransform::fromTranslate(otherPos.x(), otherPos.y());
             return otherToParent.inverted(ok);
         } else {
             if (ok)
@@ -2679,11 +2688,11 @@ QTransform QGraphicsItem::itemTransform(const QGraphicsItem *other, bool *ok) co
 
         QTransform itemToParent = QTransform::fromTranslate(itemPos.x(), itemPos.y());
         if (hasTr)
-            itemToParent = transform() * itemToParent;
+            itemToParent = itemPos.isNull() ? transform() : transform() * itemToParent;
 
         QTransform otherToParent = QTransform::fromTranslate(otherPos.x(), otherPos.y());
         if (otherHasTr)
-            otherToParent = other->transform() * otherToParent;
+            otherToParent = otherPos.isNull() ? other->transform() : other->transform() * otherToParent;
 
         return itemToParent * otherToParent.inverted(ok);
     }
@@ -2723,7 +2732,8 @@ QTransform QGraphicsItem::itemTransform(const QGraphicsItem *other, bool *ok) co
         const QGraphicsItemPrivate *pd = p->d_ptr;
         if (pd->hasTransform)
             x *= p->transform();
-        x *= QTransform::fromTranslate(pd->pos.x(), pd->pos.y());
+        if (!pd->pos.isNull())
+            x *= QTransform::fromTranslate(pd->pos.x(), pd->pos.y());
     } while ((p = p->d_ptr->parent) && p != root);
     if (parentOfOther)
         return x.inverted(ok);
@@ -2755,21 +2765,23 @@ void QGraphicsItem::setMatrix(const QMatrix &matrix, bool combine)
         return;
 
     // Notify the item that the matrix is changing.
-    QVariant variant;
-    qVariantSetValue<QMatrix>(variant, newTransform.toAffine());
-    newTransform = QTransform(qVariantValue<QMatrix>(itemChange(ItemMatrixChange, variant)));
+    QVariant newTransformVariant(itemChange(ItemMatrixChange,
+                                            qVariantFromValue<QMatrix>(newTransform.toAffine())));
+    newTransform = QTransform(qVariantValue<QMatrix>(newTransformVariant));
     if (oldTransform == newTransform)
         return;
 
     // Update and set the new transformation.
-    d_ptr->fullUpdateHelper(true);
+    d_ptr->fullUpdateHelper(true, true);
     prepareGeometryChange();
     d_ptr->hasTransform = !newTransform.isIdentity();
     d_ptr->setExtra(QGraphicsItemPrivate::ExtraTransform, newTransform);
     d_ptr->invalidateSceneTransformCache();
 
     // Send post-notification.
-    itemChange(ItemTransformHasChanged, newTransform);
+    // NB! We have to change the value from QMatrix to QTransform.
+    qVariantSetValue<QTransform>(newTransformVariant, newTransform);
+    itemChange(ItemTransformHasChanged, newTransformVariant);
 }
 
 /*!
@@ -2801,21 +2813,21 @@ void QGraphicsItem::setTransform(const QTransform &matrix, bool combine)
         return;
 
     // Notify the item that the transformation matrix is changing.
-    QVariant variant;
-    qVariantSetValue<QTransform>(variant, newTransform);
-    newTransform = qVariantValue<QTransform>(itemChange(ItemTransformChange, variant));
+    const QVariant newTransformVariant(itemChange(ItemTransformChange,
+                                                  qVariantFromValue<QTransform>(newTransform)));
+    newTransform = qVariantValue<QTransform>(newTransformVariant);
     if (oldTransform == newTransform)
         return;
 
     // Update and set the new transformation.
-    d_ptr->fullUpdateHelper(true);
+    d_ptr->fullUpdateHelper(true, true);
     prepareGeometryChange();
     d_ptr->hasTransform = !newTransform.isIdentity();
     d_ptr->setExtra(QGraphicsItemPrivate::ExtraTransform, newTransform);
     d_ptr->invalidateSceneTransformCache();
 
     // Send post-notification.
-    itemChange(ItemTransformHasChanged, newTransform);
+    itemChange(ItemTransformHasChanged, newTransformVariant);
 }
 
 /*!
@@ -2963,7 +2975,8 @@ qreal QGraphicsItem::zValue() const
 */
 void QGraphicsItem::setZValue(qreal z)
 {
-    qreal newZ = qreal(itemChange(ItemZValueChange, double(z)).toDouble());
+    const QVariant newZVariant(itemChange(ItemZValueChange, double(z)));
+    qreal newZ = qreal(newZVariant.toDouble());
     if (newZ == d_ptr->z)
         return;
     d_ptr->z = newZ;
@@ -2975,7 +2988,7 @@ void QGraphicsItem::setZValue(qreal z)
         d_ptr->scene->d_func()->invalidateSortCache();
     }
 
-    itemChange(ItemZValueHasChanged, double(newZ));
+    itemChange(ItemZValueHasChanged, newZVariant);
 }
 
 /*!
@@ -3000,7 +3013,9 @@ QRectF QGraphicsItem::childrenBoundingRect() const
     QRectF childRect;
     foreach (QGraphicsItem *child, children()) {
         QPointF childPos = child->pos();
-        QTransform matrix = child->transform() * QTransform::fromTranslate(childPos.x(), childPos.y());
+        QTransform matrix = child->transform();
+        if (!childPos.isNull())
+            matrix *= QTransform::fromTranslate(childPos.x(), childPos.y());
         childRect |= matrix.mapRect(child->boundingRect() | child->childrenBoundingRect());
     }
     return childRect;
@@ -3132,57 +3147,79 @@ bool QGraphicsItem::isClipped() const
 QPainterPath QGraphicsItem::clipPath() const
 {
     Q_D(const QGraphicsItem);
-    QPainterPath clip;
-    if (!isClipped())
-        return clip;
+    if (!d->dirtyClipPath)
+        return d->emptyClipPath ? QPainterPath() : d->cachedClipPath;
 
+    if (!isClipped()) {
+        d_ptr->setCachedClipPath(QPainterPath());
+        return d->cachedClipPath;
+    }
+
+    const QRectF thisBoundingRect(boundingRect());
+    if (thisBoundingRect.isEmpty()) {
+        if (d_ptr->flags & ItemClipsChildrenToShape)
+            d_ptr->setEmptyCachedClipPathRecursively();
+        else
+            d_ptr->setEmptyCachedClipPath();
+        return QPainterPath();
+    }
+
+    QPainterPath clip;
     // Start with the item's bounding rect.
-    clip.addRect(boundingRect());
+    clip.addRect(thisBoundingRect);
 
-    bool clipAway = false;
     if (d->ancestorFlags & QGraphicsItemPrivate::AncestorClipsChildren) {
-        // Make list of parents up to the farthest ancestor that clips its
-        // children to its shape.
-        QVarLengthArray<const QGraphicsItem *, 32> clippingAncestors;
-        const QGraphicsItem *parent = parentItem();
-        const QGraphicsItem *clipOwner = 0;
-        do {
+        const QGraphicsItem *parent = this;
+        const QGraphicsItem *lastParent = this;
+
+        // Intersect any in-between clips starting at the top and moving downwards.
+        bool foundValidClipPath = false;
+        while ((parent = parent->d_ptr->parent)) {
             if (parent->d_ptr->flags & ItemClipsChildrenToShape) {
-                clippingAncestors.append(parent);
-                clipOwner = parent;
-            }
-        } while ((parent->d_ptr->ancestorFlags & QGraphicsItemPrivate::AncestorClipsChildren) && (parent = parent->parentItem()));
+                // Map clip to the current parent and intersect with its shape/clipPath
+                clip = lastParent->itemTransform(parent).map(clip);
+                if ((foundValidClipPath = !parent->d_ptr->dirtyClipPath && parent->isClipped())) {
+                    if (parent->d_ptr->emptyClipPath) {
+                        if (d_ptr->flags & ItemClipsChildrenToShape)
+                            d_ptr->setEmptyCachedClipPathRecursively();
+                        else
+                            d_ptr->setEmptyCachedClipPath();
+                        return QPainterPath();
+                    }
+                    clip = clip.intersected(parent->d_ptr->cachedClipPath);
+                    if (!(parent->d_ptr->flags & ItemClipsToShape))
+                        clip = clip.intersected(parent->shape());
+                } else {
+                    clip = clip.intersected(parent->shape());
+                }
 
-        // Start with the topmost clip.
-        QPainterPath parentClip = clipOwner->shape();
+                if (clip.isEmpty()) {
+                    if (d_ptr->flags & ItemClipsChildrenToShape)
+                        d_ptr->setEmptyCachedClipPathRecursively();
+                    else
+                        d_ptr->setEmptyCachedClipPath();
+                    return clip;
+                }
+                lastParent = parent;
+            }
 
-        // Intersect any in-between clips starting at the bottom and moving
-        // upwards.
-        for (int i = clippingAncestors.size() - 2; i >= 0; --i) {
-            const QGraphicsItem *item = clippingAncestors[i];
-            // ### what if itemtransform fails
-            if (clipOwner)
-                parentClip = clipOwner->itemTransform(item).map(parentClip);
-            parentClip = parentClip.intersected(item->shape());
-            if (parentClip.isEmpty()) {
-                clip = parentClip;
-                clipAway = true;
+            if (!(parent->d_ptr->ancestorFlags & QGraphicsItemPrivate::AncestorClipsChildren)
+                || foundValidClipPath) {
                 break;
             }
-            clipOwner = item;
         }
 
-        if (!clipAway) {
+        if (lastParent != this) {
+            // Map clip back to the item's transform.
             // ### what if itemtransform fails
-            clip = clip.intersected(clipOwner->itemTransform(this).map(parentClip));
-            if (clip.isEmpty())
-                clipAway = true;
+            clip = lastParent->itemTransform(this).map(clip);
         }
     }
 
-    if (!clipAway && d->flags & ItemClipsToShape)
+    if (d->flags & ItemClipsToShape)
         clip = clip.intersected(shape());
 
+    d_ptr->setCachedClipPath(clip);
     return clip;
 }
 
@@ -3271,8 +3308,10 @@ bool QGraphicsItem::collidesWithPath(const QPainterPath &path, Qt::ItemSelection
         return false;
     }
 
-    QRectF rectA = _q_adjustedRect(boundingRect());
-    QRectF rectB = _q_adjustedRect(path.controlPointRect());
+    QRectF rectA(boundingRect());
+    _q_adjustRect(&rectA);
+    QRectF rectB(path.controlPointRect());
+    _q_adjustRect(&rectB);
     if (!rectA.intersects(rectB)) {
         // This we can determine efficiently. If the two rects neither
         // intersect nor contain eachother, then the two items do not collide.
@@ -3281,12 +3320,11 @@ bool QGraphicsItem::collidesWithPath(const QPainterPath &path, Qt::ItemSelection
 
     // For further testing, we need this item's shape or bounding rect.
     QPainterPath thisShape;
-    if (mode == Qt::IntersectsItemShape || mode == Qt::ContainsItemShape) {
+    if (mode == Qt::IntersectsItemShape || mode == Qt::ContainsItemShape)
         thisShape = (isClipped() && !d_ptr->localCollisionHack) ? clipPath() : shape();
-    } else {
-        thisShape.addPolygon(_q_adjustedRect(boundingRect()));
-        thisShape.closeSubpath();
-    }
+    else
+        thisShape.addRect(rectA);
+
     if (thisShape == QPainterPath()) {
         // Empty shape? No collision.
         return false;
@@ -3456,7 +3494,8 @@ QRegion QGraphicsItem::boundingRegion(const QTransform &itemToDeviceTransform) c
     // into the bitmap, converts the result to a QRegion and scales the region
     // back to device space with inverse granularity.
     qreal granularity = boundingRegionGranularity();
-    QRect deviceRect = _q_adjustedRect(itemToDeviceTransform.mapRect(boundingRect()).toRect());
+    QRect deviceRect = itemToDeviceTransform.mapRect(boundingRect()).toRect();
+    _q_adjustRect(&deviceRect);
     if (granularity == 0.0)
         return QRegion(deviceRect);
 
@@ -3586,6 +3625,24 @@ void QGraphicsItem::setBoundingRegionGranularity(qreal granularity)
 
 /*!
     \internal
+    Returns true if we can discard an update request; otherwise false.
+*/
+bool QGraphicsItemPrivate::discardUpdateRequest(bool ignoreClipping,
+                                                bool ignoreVisibleBit,
+                                                bool ignoreDirtyBit) const
+{
+    // No scene, or if the scene is updating everything, means we have nothing
+    // to do. The only exception is if the scene tracks the growing scene rect.
+    return (!visible && !ignoreVisibleBit)
+           || (dirty && !ignoreDirtyBit)
+           || !scene
+           || (scene->d_func()->updateAll && scene->d_func()->hasSceneRect)
+           || (!ignoreClipping && (childrenClippedToShape() && isClippedAway()))
+           || (childrenCombineOpacity() && isFullyTransparent());
+}
+
+/*!
+    \internal
 
     Asks the scene to mark this item's scene rect as dirty, requesting a
     redraw.  This does not invalidate any cache.
@@ -3594,31 +3651,16 @@ void QGraphicsItem::setBoundingRegionGranularity(qreal granularity)
     only case where the item's background should be marked as dirty even when
     the item isn't visible.
 */
-void QGraphicsItemPrivate::updateHelper(const QRectF &rect, bool force, bool updateCache)
+void QGraphicsItemPrivate::updateHelper(const QRectF &rect, bool force, bool maybeDirtyClipPath)
 {
     // No scene, or if the scene is updating everything, means we have nothing
     // to do. The only exception is if the scene tracks the growing scene rect.
-    QGraphicsItemCache *cache = maybeExtraItemCache();
-    if (dirty && (!updateCache || !cache || cache->allExposed))
-        return;
-
-    if (!scene || (scene && scene->d_func()->updateAll && scene->d_func()->hasSceneRect))
+    if (discardUpdateRequest(/*ignoreClipping=*/maybeDirtyClipPath, /*ignoreVisibleBit=*/force))
         return;
 
-    if (updateCache && QGraphicsItem::CacheMode(cacheMode) != QGraphicsItem::NoCache) {
-        if (rect.isNull()) {
-            cache->allExposed = true;
-            cache->exposed.clear();
-        } else {
-            cache->exposed.append(rect);
-        }
-    }
-
-    if (!dirty && scene && (visible || force)) {
-        if (rect.isNull())
-            dirty = 1;
-        scene->itemUpdated(q_ptr, rect);
-    }
+    if (rect.isNull())
+        dirty = 1;
+    scene->itemUpdated(q_ptr, rect);
 }
 
 /*!
@@ -3626,21 +3668,25 @@ void QGraphicsItemPrivate::updateHelper(const QRectF &rect, bool force, bool upd
 
     Propagates updates to \a item and all its children.
 */
-void QGraphicsItemPrivate::fullUpdateHelper(bool childrenOnly)
+void QGraphicsItemPrivate::fullUpdateHelper(bool childrenOnly, bool maybeDirtyClipPath)
 {
-    // No scene, or if the scene is updating everything, means we have nothing
-    // to do. The only exception is if the scene tracks the growing scene rect.
-    if (!scene || (scene && scene->d_func()->updateAll && scene->d_func()->hasSceneRect))
-        return;
-    if (!childrenOnly && !dirty)
-        updateHelper();
-    if (children.isEmpty() || dirtyChildren)
+    if (discardUpdateRequest(/*ignoreClipping=*/maybeDirtyClipPath,
+                             /*ignoreVisibleBit=*/false,
+                             /*ignoreDirtyBit=*/true)) {
         return;
-    if (flags & QGraphicsItem::ItemClipsChildrenToShape) {
-        // ### mark all children dirty?
+    }
+
+    if (!childrenOnly && !dirty) {
+        // Effectively the same as updateHelper(QRectF(), false, maybeDirtyClipPath).
+        dirty = 1;
+        scene->itemUpdated(q_ptr, QRectF());
+    }
+
+    if (dirtyChildren || childrenClippedToShape()) {
         // Unnecessary to update children as well.
         return;
     }
+
     if (ancestorFlags & AncestorClipsChildren) {
         Q_Q(QGraphicsItem);
         // Check if we can avoid updating all children.
@@ -3663,10 +3709,36 @@ void QGraphicsItemPrivate::fullUpdateHelper(bool childrenOnly)
         }
     }
     foreach (QGraphicsItem *child, children)
-        child->d_ptr->fullUpdateHelper();
+        child->d_ptr->fullUpdateHelper(false, maybeDirtyClipPath);
     dirtyChildren = 1;
 }
 
+static inline bool allChildrenCombineOpacity(QGraphicsItem *parent)
+{
+    Q_ASSERT(parent);
+    if (parent->flags() & QGraphicsItem::ItemDoesntPropagateOpacityToChildren)
+        return false;
+
+    const QList<QGraphicsItem *> children(parent->childItems());
+    for (int i = 0; i < children.size(); ++i) {
+        if (children.at(i)->flags() & QGraphicsItem::ItemIgnoresParentOpacity)
+            return false;
+    }
+    return true;
+}
+
+void QGraphicsItemPrivate::updateEffectiveOpacity()
+{
+    Q_Q(QGraphicsItem);
+    if (parent) {
+        resolveEffectiveOpacity(parent->effectiveOpacity());
+        parent->d_ptr->allChildrenCombineOpacity = ::allChildrenCombineOpacity(parent);
+    } else {
+        resolveEffectiveOpacity(1.0);
+    }
+    allChildrenCombineOpacity = ::allChildrenCombineOpacity(q);
+}
+
 /*!
     \internal
 
@@ -3691,7 +3763,14 @@ void QGraphicsItemPrivate::resolveEffectiveOpacity(qreal parentEffectiveOpacity)
     }
 
     // Set this item's resolved opacity.
-    setExtra(ExtraEffectiveOpacity, myEffectiveOpacity);
+    if (qFuzzyCompare(myEffectiveOpacity, qreal(1.0))) {
+        // Opaque, unset effective opacity.
+        hasEffectiveOpacity = 0;
+        unsetExtra(ExtraEffectiveOpacity);
+    } else {
+        hasEffectiveOpacity = 1;
+        setExtra(ExtraEffectiveOpacity, myEffectiveOpacity);
+    }
 
     // Resolve children always.
     for (int i = 0; i < children.size(); ++i)
@@ -3782,6 +3861,109 @@ void QGraphicsItemPrivate::removeExtraItemCache()
     unsetExtra(ExtraCacheData);
 }
 
+void QGraphicsItemPrivate::setEmptyCachedClipPathRecursively(const QRectF &emptyIfOutsideThisRect)
+{
+    setEmptyCachedClipPath();
+
+    const bool checkRect = !emptyIfOutsideThisRect.isNull()
+                           && !(flags & QGraphicsItem::ItemClipsChildrenToShape);
+    for (int i = 0; i < children.size(); ++i) {
+        if (!checkRect) {
+            children.at(i)->d_ptr->setEmptyCachedClipPathRecursively();
+            continue;
+        }
+
+        QGraphicsItem *child = children.at(i);
+        const QRectF rect = child->mapRectFromParent(emptyIfOutsideThisRect);
+        if (rect.intersects(child->boundingRect()))
+            child->d_ptr->invalidateCachedClipPathRecursively(false, rect);
+        else
+            child->d_ptr->setEmptyCachedClipPathRecursively(rect);
+    }
+}
+
+void QGraphicsItemPrivate::invalidateCachedClipPathRecursively(bool childrenOnly, const QRectF &emptyIfOutsideThisRect)
+{
+    if (!childrenOnly)
+        invalidateCachedClipPath();
+
+    const bool checkRect = !emptyIfOutsideThisRect.isNull();
+    for (int i = 0; i < children.size(); ++i) {
+        if (!checkRect) {
+            children.at(i)->d_ptr->invalidateCachedClipPathRecursively(false);
+            continue;
+        }
+
+        QGraphicsItem *child = children.at(i);
+        const QRectF rect = child->mapRectFromParent(emptyIfOutsideThisRect);
+        if (rect.intersects(child->boundingRect()))
+            child->d_ptr->invalidateCachedClipPathRecursively(false, rect);
+        else
+            child->d_ptr->setEmptyCachedClipPathRecursively(rect);
+    }
+}
+
+void QGraphicsItemPrivate::updateCachedClipPathFromSetPosHelper(const QPointF &newPos)
+{
+    Q_ASSERT(inSetPosHelper);
+
+    if (!(ancestorFlags & QGraphicsItemPrivate::AncestorClipsChildren))
+        return; // Not clipped by any ancestor.
+
+    // Find closest clip ancestor and transform.
+    Q_Q(QGraphicsItem);
+    QTransform thisToParentTransform = hasTransform
+                                       ? q->transform() * QTransform::fromTranslate(newPos.x(), newPos.y())
+                                       : QTransform::fromTranslate(newPos.x(), newPos.y());
+    QGraphicsItem *clipParent = parent;
+    while (clipParent && !(clipParent->d_ptr->flags & QGraphicsItem::ItemClipsChildrenToShape)) {
+        if (clipParent->d_ptr->hasTransform)
+            thisToParentTransform *= clipParent->transform();
+        if (!clipParent->d_ptr->pos.isNull()) {
+            thisToParentTransform *= QTransform::fromTranslate(clipParent->d_ptr->pos.x(),
+                                                               clipParent->d_ptr->pos.y());
+        }
+        clipParent = clipParent->d_ptr->parent;
+    }
+
+    // thisToParentTransform is now the same as q->itemTransform(clipParent), except
+    // that the new position (which is not yet set on the item) is taken into account.
+    Q_ASSERT(clipParent);
+    Q_ASSERT(clipParent->d_ptr->flags & QGraphicsItem::ItemClipsChildrenToShape);
+
+    // From here everything is calculated in clip parent's coordinates.
+    const QRectF parentBoundingRect(clipParent->boundingRect());
+    const QRectF thisBoundingRect(thisToParentTransform.mapRect(q->boundingRect()));
+
+    if (!parentBoundingRect.intersects(thisBoundingRect)) {
+        // Item is moved outside the clip parent's bounding rect,
+        // i.e. it is fully clipped and the clip path is empty.
+        if (flags & QGraphicsItem::ItemClipsChildrenToShape)
+            setEmptyCachedClipPathRecursively();
+        else
+            setEmptyCachedClipPathRecursively(thisToParentTransform.inverted().mapRect(parentBoundingRect));
+        return;
+    }
+
+    const QPainterPath parentClip(clipParent->isClipped() ? clipParent->clipPath() : clipParent->shape());
+    if (parentClip.contains(thisBoundingRect))
+        return; // Item is inside the clip parent's shape. No update required.
+
+    const QRectF parentClipRect(parentClip.controlPointRect());
+    if (!parentClipRect.intersects(thisBoundingRect)) {
+        // Item is moved outside the clip parent's shape,
+        // i.e. it is fully clipped and the clip path is empty.
+        if (flags & QGraphicsItem::ItemClipsChildrenToShape)
+            setEmptyCachedClipPathRecursively();
+        else
+            setEmptyCachedClipPathRecursively(thisToParentTransform.inverted().mapRect(parentClipRect));
+    } else {
+        // Item is partially inside the clip parent's shape,
+        // i.e. the cached clip path must be invalidated.
+        invalidateCachedClipPathRecursively(false, thisToParentTransform.inverted().mapRect(parentClipRect));
+    }
+}
+
 /*!
     \internal
 
@@ -3812,7 +3994,25 @@ bool QGraphicsItemPrivate::isProxyWidget() const
 */
 void QGraphicsItem::update(const QRectF &rect)
 {
-    d_ptr->updateHelper(rect, /* force = */ false, /* updateCache = */ true);
+    if ((rect.isEmpty() && !rect.isNull()) || d_ptr->discardUpdateRequest())
+        return;
+
+    if (CacheMode(d_ptr->cacheMode) != NoCache) {
+        QGraphicsItemCache *cache = d_ptr->maybeExtraItemCache();
+        if (!cache || cache->allExposed)
+            return;
+        if (rect.isNull()) {
+            cache->allExposed = true;
+            cache->exposed.clear();
+        } else {
+            cache->exposed.append(rect);
+        }
+    }
+
+    // Effectively the same as updateHelper(rect);
+    if (rect.isNull())
+        d_ptr->dirty = 1;
+    d_ptr->scene->itemUpdated(this, rect);
 }
 
 /*!
@@ -5616,12 +5816,20 @@ void QGraphicsItem::removeFromIndex()
 */
 void QGraphicsItem::prepareGeometryChange()
 {
-    if (d_ptr->scene) {
-        d_ptr->updateHelper();
+    if (!d_ptr->scene)
+        return;
 
-        QGraphicsScenePrivate *scenePrivate = d_ptr->scene->d_func();
-        scenePrivate->removeFromIndex(this);
-    }
+    d_ptr->updateHelper(QRectF(), false, /*maybeDirtyClipPath=*/!d_ptr->inSetPosHelper);
+    QGraphicsScenePrivate *scenePrivate = d_ptr->scene->d_func();
+    scenePrivate->removeFromIndex(this);
+
+    if (d_ptr->inSetPosHelper)
+        return;
+
+    if (d_ptr->flags & ItemClipsChildrenToShape)
+        d_ptr->invalidateCachedClipPathRecursively();
+    else
+        d_ptr->invalidateCachedClipPath();
 }
 
 /*!
@@ -8659,13 +8867,17 @@ void QGraphicsItemGroup::addToGroup(QGraphicsItem *item)
     QTransform oldSceneMatrix = item->sceneTransform();
     item->setPos(mapFromItem(item, 0, 0));
     item->setParentItem(this);
-    item->setTransform(oldSceneMatrix
-                       * sceneTransform().inverted()
-                       * QTransform::fromTranslate(-item->x(), -item->y()));
+    QTransform newItemTransform(oldSceneMatrix);
+    newItemTransform *= sceneTransform().inverted();
+    if (!item->pos().isNull())
+        newItemTransform *= QTransform::fromTranslate(-item->x(), -item->y());
+    item->setTransform(newItemTransform);
     item->d_func()->setIsMemberOfGroup(true);
     prepareGeometryChange();
-    d->itemsBoundingRect |= (item->transform() * QTransform::fromTranslate(item->x(), item->y()))
-                            .mapRect(item->boundingRect() | item->childrenBoundingRect());
+    QTransform itemTransform(item->transform());
+    if (!item->pos().isNull())
+        itemTransform *= QTransform::fromTranslate(item->x(), item->y());
+    d->itemsBoundingRect |= itemTransform.mapRect(item->boundingRect() | item->childrenBoundingRect());
     update();
 }
 
diff --git a/src/gui/graphicsview/qgraphicsitem_p.h b/src/gui/graphicsview/qgraphicsitem_p.h
index af0b077..f738cf1 100644
--- a/src/gui/graphicsview/qgraphicsitem_p.h
+++ b/src/gui/graphicsview/qgraphicsitem_p.h
@@ -134,10 +134,15 @@ public:
         hasBoundingRegionGranularity(0),
         flags(0),
         hasOpacity(0),
+        hasEffectiveOpacity(0),
         isWidget(0),
         dirty(0),
         dirtyChildren(0),
         localCollisionHack(0),
+        dirtyClipPath(1),
+        emptyClipPath(0),
+        inSetPosHelper(0),
+        allChildrenCombineOpacity(1),
         globalStackingOrder(-1),
         sceneTransformIndex(-1),
         q_ptr(0)
@@ -158,11 +163,15 @@ public:
     virtual QVariant inputMethodQueryHelper(Qt::InputMethodQuery query) const;
     static bool movableAncestorIsSelected(const QGraphicsItem *item);
 
-    void setPosHelper(const QPointF &pos, bool update);
+    void setPosHelper(const QPointF &pos);
     void setVisibleHelper(bool newVisible, bool explicitly, bool update = true);
     void setEnabledHelper(bool newEnabled, bool explicitly, bool update = true);
-    void updateHelper(const QRectF &rect = QRectF(), bool force = false, bool updateCache = false);
-    void fullUpdateHelper(bool childrenOnly = false);
+    bool discardUpdateRequest(bool ignoreClipping = false,
+                              bool ignoreVisibleBit = false,
+                              bool ignoreDirtyBit = false) const;
+    void updateHelper(const QRectF &rect = QRectF(), bool force = false, bool maybeDirtyClipPath = false);
+    void fullUpdateHelper(bool childrenOnly = false, bool maybeDirtyClipPath = false);
+    void updateEffectiveOpacity();
     void resolveEffectiveOpacity(qreal effectiveParentOpacity);
     void resolveDepth(int parentDepth);
     void invalidateSceneTransformCache();
@@ -238,6 +247,47 @@ public:
     QGraphicsItemCache *extraItemCache() const;
     void removeExtraItemCache();
 
+    inline void setCachedClipPath(const QPainterPath &path)
+    {
+        cachedClipPath = path;
+        dirtyClipPath = 0;
+        emptyClipPath = 0;
+    }
+
+    inline void setEmptyCachedClipPath()
+    {
+        emptyClipPath = 1;
+        dirtyClipPath = 0;
+    }
+
+    void setEmptyCachedClipPathRecursively(const QRectF &emptyIfOutsideThisRect = QRectF());
+
+    inline void invalidateCachedClipPath()
+    { /*static int count = 0 ;qWarning("%i", ++count);*/ dirtyClipPath = 1; emptyClipPath = 0; }
+
+    void invalidateCachedClipPathRecursively(bool childrenOnly = false, const QRectF &emptyIfOutsideThisRect = QRectF());
+    void updateCachedClipPathFromSetPosHelper(const QPointF &newPos);
+
+    inline bool isFullyTransparent() const
+    { return hasEffectiveOpacity && qFuzzyCompare(q_func()->effectiveOpacity() + 1, qreal(1.0)); }
+
+    inline bool childrenCombineOpacity() const
+    { return allChildrenCombineOpacity || children.isEmpty(); }
+
+    inline bool isClippedAway() const
+    { return !dirtyClipPath && q_func()->isClipped() && (emptyClipPath || cachedClipPath.isEmpty()); }
+
+    inline bool childrenClippedToShape() const
+    { return (flags & QGraphicsItem::ItemClipsChildrenToShape) || children.isEmpty(); }
+
+    inline bool isInvisible() const
+    {
+        return !visible
+               || (childrenClippedToShape() && isClippedAway())
+               || (childrenCombineOpacity() && isFullyTransparent());
+    }
+
+    QPainterPath cachedClipPath;
     QPointF pos;
     qreal z;
     QGraphicsScene *scene;
@@ -268,10 +318,15 @@ public:
 
     // New 32 bytes
     quint32 hasOpacity : 1;
+    quint32 hasEffectiveOpacity : 1;
     quint32 isWidget : 1;
     quint32 dirty : 1;    
     quint32 dirtyChildren : 1;    
     quint32 localCollisionHack : 1;
+    quint32 dirtyClipPath : 1;
+    quint32 emptyClipPath : 1;
+    quint32 inSetPosHelper : 1;
+    quint32 allChildrenCombineOpacity : 1;
 
     // Optional stacking order
     int globalStackingOrder;
diff --git a/src/gui/graphicsview/qgraphicsproxywidget.cpp b/src/gui/graphicsview/qgraphicsproxywidget.cpp
index 1d2721b..e660879 100644
--- a/src/gui/graphicsview/qgraphicsproxywidget.cpp
+++ b/src/gui/graphicsview/qgraphicsproxywidget.cpp
@@ -177,6 +177,10 @@ QT_BEGIN_NAMESPACE
     while the widget is embedded. In this state, the widget may differ slightly
     in behavior from when it is not embedded.
 
+    \warning This class is provided for convenience when bridging
+    QWidgets and QGraphicsItems, it should not be used for
+    high-performance scenarios.
+
     \sa QGraphicsScene::addWidget(), QGraphicsWidget
 */
 
@@ -1033,7 +1037,7 @@ void QGraphicsProxyWidget::dragMoveEvent(QGraphicsSceneDragDropEvent *event)
         if (receiver != d->dragDropWidget) {
             // Try to enter before we leave
             QDragEnterEvent dragEnter(receiverPos, event->possibleActions(), event->mimeData(), event->buttons(), event->modifiers());
-            dragEnter.setDropAction(event->proposedAction());            
+            dragEnter.setDropAction(event->proposedAction());
             QApplication::sendEvent(receiver, &dragEnter);
             event->setAccepted(dragEnter.isAccepted());
             event->setDropAction(dragEnter.dropAction());
@@ -1431,7 +1435,7 @@ int QGraphicsProxyWidget::type() const
 
   Creates a proxy widget for the given \a child of the widget
   contained in this proxy.
-  
+
   This function makes it possible to aquire proxies for
   non top-level widgets. For instance, you can embed a dialog,
   and then transform only one of its widgets.
diff --git a/src/gui/graphicsview/qgraphicsscene.cpp b/src/gui/graphicsview/qgraphicsscene.cpp
index a9578f2..7948caf 100644
--- a/src/gui/graphicsview/qgraphicsscene.cpp
+++ b/src/gui/graphicsview/qgraphicsscene.cpp
@@ -292,15 +292,21 @@ static inline bool QRectF_intersects(const QRectF &s, const QRectF &r)
 
 // QRectF::intersects() returns false always if either the source or target
 // rectangle's width or height are 0. This works around that problem.
-static QRectF _q_adjustedRect(const QRectF &rect)
+static inline void _q_adjustRect(QRectF *rect)
 {
-    static const qreal p = (qreal)0.00001;
-    QRectF r = rect;
-    if (!r.width())
-        r.adjust(-p, 0, p, 0);
-    if (!r.height())
-        r.adjust(0, -p, 0, p);
-    return r;
+    Q_ASSERT(rect);
+    if (!rect->width())
+        rect->adjust(-0.00001, 0, 0.00001, 0);
+    if (!rect->height())
+        rect->adjust(0, -0.00001, 0, 0.00001);
+}
+
+static inline QRectF adjustedItemBoundingRect(const QGraphicsItem *item)
+{
+    Q_ASSERT(item);
+    QRectF boundingRect(item->boundingRect());
+    _q_adjustRect(&boundingRect);
+    return boundingRect;
 }
 
 static void _q_hoverFromMouseEvent(QGraphicsSceneHoverEvent *hover, const QGraphicsSceneMouseEvent *mouseEvent)
@@ -656,10 +662,11 @@ void QGraphicsScenePrivate::_q_updateLater()
 */
 void QGraphicsScenePrivate::_q_polishItems()
 {
+    const QVariant booleanTrueVariant(true);
     foreach (QGraphicsItem *item, unpolishedItems) {
         if (!item->d_ptr->explicitlyHidden) {
-            item->itemChange(QGraphicsItem::ItemVisibleChange, true);
-            item->itemChange(QGraphicsItem::ItemVisibleHasChanged, true);
+            item->itemChange(QGraphicsItem::ItemVisibleChange, booleanTrueVariant);
+            item->itemChange(QGraphicsItem::ItemVisibleHasChanged, booleanTrueVariant);
         }
         if (item->isWidget()) {
             QEvent event(QEvent::Polish);
@@ -1371,6 +1378,48 @@ QGraphicsWidget *QGraphicsScenePrivate::windowForItem(const QGraphicsItem *item)
     return 0;
 }
 
+
+QList<QGraphicsItem *> QGraphicsScenePrivate::items_helper(const QPointF &pos) const
+{
+    QList<QGraphicsItem *> items;
+
+    // The index returns a rough estimate of what items are inside the rect.
+    // Refine it by iterating through all returned items.
+    QRectF adjustedRect = QRectF(pos, QSize(1,1));
+    foreach (QGraphicsItem *item, estimateItemsInRect(adjustedRect)) {
+        // Find the item's scene transform in a clever way.
+        QTransform x = item->sceneTransform();
+        bool keep = false;
+
+        // ### _q_adjustedRect is only needed because QRectF::intersects,
+        // QRectF::contains and QTransform::map() and friends don't work with
+        // flat rectangles.
+        const QRectF br(adjustedItemBoundingRect(item));
+            // Rect intersects/contains item's shape
+        if (QRectF_intersects(adjustedRect, x.mapRect(br))) {
+            bool ok;
+            QTransform xinv = x.inverted(&ok);
+            if (ok) {
+                if (item->contains(xinv.map(pos))) {
+                    items << item;
+                    keep = true;
+                }
+            }
+        }
+
+        if (keep && (item->flags() & QGraphicsItem::ItemClipsChildrenToShape)) {
+            // Recurse into children that clip children.
+            bool ok;
+            QTransform xinv = x.inverted(&ok);
+            if (ok)
+                childItems_helper(&items, item, xinv.map(pos));
+        }
+    }
+
+    sortItems(&items, Qt::AscendingOrder, sortCacheEnabled);
+    return items;
+}
+
 QList<QGraphicsItem *> QGraphicsScenePrivate::items_helper(const QRectF &rect,
                                                            Qt::ItemSelectionMode mode,
                                                            Qt::SortOrder order) const
@@ -1381,7 +1430,8 @@ QList<QGraphicsItem *> QGraphicsScenePrivate::items_helper(const QRectF &rect,
 
     // The index returns a rough estimate of what items are inside the rect.
     // Refine it by iterating through all returned items.
-    QRectF adjustedRect = _q_adjustedRect(rect);
+    QRectF adjustedRect(rect);
+    _q_adjustRect(&adjustedRect);
     foreach (QGraphicsItem *item, estimateItemsInRect(adjustedRect)) {
         // Find the item's scene transform in a clever way.
         QTransform x = item->sceneTransform();
@@ -1390,7 +1440,7 @@ QList<QGraphicsItem *> QGraphicsScenePrivate::items_helper(const QRectF &rect,
         // ### _q_adjustedRect is only needed because QRectF::intersects,
         // QRectF::contains and QTransform::map() and friends don't work with
         // flat rectangles.
-        QRectF br = _q_adjustedRect(item->boundingRect());
+        const QRectF br(adjustedItemBoundingRect(item));
         if (mode >= Qt::ContainsItemBoundingRect) {
             // Rect intersects/contains item's bounding rect
             QRectF mbr = x.mapRect(br);
@@ -1405,7 +1455,7 @@ QList<QGraphicsItem *> QGraphicsScenePrivate::items_helper(const QRectF &rect,
                 bool ok;
                 QTransform xinv = x.inverted(&ok);
                 if (ok) {
-                    if (path == QPainterPath())
+                    if (path.isEmpty())
                         path.addRect(rect);
                     if (itemCollidesWithPath(item, xinv.map(path), mode)) {
                         items << item;
@@ -1442,7 +1492,8 @@ QList<QGraphicsItem *> QGraphicsScenePrivate::items_helper(const QPolygonF &poly
 {
     QList<QGraphicsItem *> items;
 
-    QRectF polyRect = _q_adjustedRect(polygon.boundingRect());
+    QRectF polyRect(polygon.boundingRect());
+     _q_adjustRect(&polyRect);
     QPainterPath path;
 
     // The index returns a rough estimate of what items are inside the rect.
@@ -1455,7 +1506,7 @@ QList<QGraphicsItem *> QGraphicsScenePrivate::items_helper(const QPolygonF &poly
         // ### _q_adjustedRect is only needed because QRectF::intersects,
         // QRectF::contains and QTransform::map() and friends don't work with
         // flat rectangles.
-        QRectF br = _q_adjustedRect(item->boundingRect());
+        const QRectF br(adjustedItemBoundingRect(item));
         if (mode >= Qt::ContainsItemBoundingRect) {
             // Polygon contains/intersects item's bounding rect
             if (path == QPainterPath())
@@ -1500,21 +1551,47 @@ QList<QGraphicsItem *> QGraphicsScenePrivate::items_helper(const QPainterPath &p
                                                            Qt::SortOrder order) const
 {
     QList<QGraphicsItem *> items;
+    QRectF pathRect(path.controlPointRect());
+    _q_adjustRect(&pathRect);
+
     // The index returns a rough estimate of what items are inside the rect.
     // Refine it by iterating through all returned items.
-    foreach (QGraphicsItem *item, estimateItemsInRect(_q_adjustedRect(path.controlPointRect()))) {
+    foreach (QGraphicsItem *item, estimateItemsInRect(pathRect)) {
         // Find the item's scene transform in a clever way.
         QTransform x = item->sceneTransform();
-        bool ok;
-        QTransform xinv = x.inverted(&ok);
-        if (ok) {
-            QPainterPath mappedPath = xinv.map(path);
-            if (itemCollidesWithPath(item, mappedPath, mode)) {
+        bool keep = false;
+
+        // ### _q_adjustedRect is only needed because QRectF::intersects,
+        // QRectF::contains and QTransform::map() and friends don't work with
+        // flat rectangles.
+        const QRectF br(adjustedItemBoundingRect(item));
+        if (mode >= Qt::ContainsItemBoundingRect) {
+            // Path contains/intersects item's bounding rect
+            if ((mode == Qt::IntersectsItemBoundingRect && path.intersects(x.mapRect(br)))
+                || (mode == Qt::ContainsItemBoundingRect && path.contains(x.mapRect(br)))) {
                 items << item;
-                if (item->flags() & QGraphicsItem::ItemClipsChildrenToShape)
-                    childItems_helper(&items, item, mappedPath, mode);
+                keep = true;
+            }
+        } else {
+            // Path contains/intersects item's shape
+            if (QRectF_intersects(pathRect, x.mapRect(br))) {
+                bool ok;
+                QTransform xinv = x.inverted(&ok);
+                if (ok) {
+                    if (itemCollidesWithPath(item, xinv.map(path), mode)) {
+                        items << item;
+                        keep = true;
+                    }
+                }
             }
         }
+
+        if (keep && (item->flags() & QGraphicsItem::ItemClipsChildrenToShape)) {
+            bool ok;
+            QTransform xinv = x.inverted(&ok);
+            if (ok)
+                childItems_helper(&items, item, xinv.map(path), mode);
+        }
     }
 
     if (order != Qt::SortOrder(-1))
@@ -1524,13 +1601,13 @@ QList<QGraphicsItem *> QGraphicsScenePrivate::items_helper(const QPainterPath &p
 
 void QGraphicsScenePrivate::childItems_helper(QList<QGraphicsItem *> *items,
                                               const QGraphicsItem *parent,
-                                              const QRectF &rect,
-                                              Qt::ItemSelectionMode mode) const
+                                              const QPointF &pos) const
 {
-    QPainterPath path;
     bool parentClip = (parent->flags() & QGraphicsItem::ItemClipsChildrenToShape);
-    QRectF r = !parentClip ? _q_adjustedRect(rect) : _q_adjustedRect(rect).intersected(_q_adjustedRect(parent->boundingRect()));
-    if (r.isEmpty())
+    if (parentClip && parent->d_ptr->isClippedAway())
+        return;
+    // ### is this needed?
+    if (parentClip && !parent->boundingRect().contains(pos))
         return;
 
     QList<QGraphicsItem *> &children = parent->d_ptr->children;
@@ -1540,31 +1617,73 @@ void QGraphicsScenePrivate::childItems_helper(QList<QGraphicsItem *> *items,
             continue;
 
         // Skip invisible items and all their children.
-        if (!item->d_ptr->visible || qFuzzyCompare(item->effectiveOpacity(), qreal(0.0)))
+        if (item->d_ptr->isInvisible())
             continue;
 
-        // ### _q_adjustedRect is only needed because QRectF::intersects,
-        // QRectF::contains and QTransform::map() and friends don't work with
-        // flat rectangles.
-        QRectF br = _q_adjustedRect(item->boundingRect());
-        QRectF mbr = item->mapRectToParent(br);
         bool keep = false;
-        if (mode >= Qt::ContainsItemBoundingRect) {
-            // Rect intersects/contains item's bounding rect
-            if ((mode == Qt::IntersectsItemBoundingRect && QRectF_intersects(rect, mbr))
-                || (mode == Qt::ContainsItemBoundingRect && rect != mbr && rect.contains(br))) {
+        if (!item->d_ptr->isClippedAway()) {
+            if (item->contains(item->mapFromParent(pos))) {
                 items->append(item);
                 keep = true;
             }
-        } else {
-            // Rect intersects/contains item's shape
-            if (QRectF_intersects(rect, mbr)) {
-                if (path == QPainterPath())
-                    path.addRect(rect);
-                if (itemCollidesWithPath(item, item->mapFromParent(path), mode)) {
+        }
+
+        if ((keep || !(item->flags() & QGraphicsItem::ItemClipsChildrenToShape)) && !item->d_ptr->children.isEmpty())
+            // Recurse into children.
+            childItems_helper(items, item, item->mapFromParent(pos));
+    }
+}
+
+
+void QGraphicsScenePrivate::childItems_helper(QList<QGraphicsItem *> *items,
+                                              const QGraphicsItem *parent,
+                                              const QRectF &rect,
+                                              Qt::ItemSelectionMode mode) const
+{
+    bool parentClip = (parent->flags() & QGraphicsItem::ItemClipsChildrenToShape);
+    if (parentClip && parent->d_ptr->isClippedAway())
+        return;
+    QRectF adjustedRect(rect);
+    _q_adjustRect(&adjustedRect);
+    QRectF r = !parentClip ? adjustedRect : adjustedRect.intersected(adjustedItemBoundingRect(parent));
+    if (r.isEmpty())
+        return;
+
+    QPainterPath path;
+    QList<QGraphicsItem *> &children = parent->d_ptr->children;
+    for (int i = 0; i < children.size(); ++i) {
+        QGraphicsItem *item = children.at(i);
+        if (item->d_ptr->hasTransform && !item->transform().isInvertible())
+            continue;
+
+        // Skip invisible items and all their children.
+        if (item->d_ptr->isInvisible())
+            continue;
+
+        bool keep = false;
+        if (!item->d_ptr->isClippedAway()) {
+            // ### _q_adjustedRect is only needed because QRectF::intersects,
+            // QRectF::contains and QTransform::map() and friends don't work with
+            // flat rectangles.
+            const QRectF br(adjustedItemBoundingRect(item));
+            QRectF mbr = item->mapRectToParent(br);
+            if (mode >= Qt::ContainsItemBoundingRect) {
+                // Rect intersects/contains item's bounding rect
+                if ((mode == Qt::IntersectsItemBoundingRect && QRectF_intersects(rect, mbr))
+                    || (mode == Qt::ContainsItemBoundingRect && rect != mbr && rect.contains(br))) {
                     items->append(item);
                     keep = true;
                 }
+            } else {
+                // Rect intersects/contains item's shape
+                if (QRectF_intersects(rect, mbr)) {
+                    if (path == QPainterPath())
+                        path.addRect(rect);
+                    if (itemCollidesWithPath(item, item->mapFromParent(path), mode)) {
+                        items->append(item);
+                        keep = true;
+                    }
+                }
             }
         }
 
@@ -1581,18 +1700,22 @@ void QGraphicsScenePrivate::childItems_helper(QList<QGraphicsItem *> *items,
     }
 }
 
+
 void QGraphicsScenePrivate::childItems_helper(QList<QGraphicsItem *> *items,
                                               const QGraphicsItem *parent,
                                               const QPolygonF &polygon,
                                               Qt::ItemSelectionMode mode) const
 {
-    QPainterPath path;
     bool parentClip = (parent->flags() & QGraphicsItem::ItemClipsChildrenToShape);
-    QRectF polyRect = _q_adjustedRect(polygon.boundingRect());
-    QRectF r = !parentClip ? polyRect : polyRect.intersected(_q_adjustedRect(parent->boundingRect()));
+    if (parentClip && parent->d_ptr->isClippedAway())
+        return;
+    QRectF polyRect(polygon.boundingRect());
+    _q_adjustRect(&polyRect);
+    QRectF r = !parentClip ? polyRect : polyRect.intersected(adjustedItemBoundingRect(parent));
     if (r.isEmpty())
         return;
 
+    QPainterPath path;
     QList<QGraphicsItem *> &children = parent->d_ptr->children;
     for (int i = 0; i < children.size(); ++i) {
         QGraphicsItem *item = children.at(i);
@@ -1600,32 +1723,34 @@ void QGraphicsScenePrivate::childItems_helper(QList<QGraphicsItem *> *items,
             continue;
 
         // Skip invisible items.
-        if (!item->d_ptr->visible || qFuzzyCompare(item->effectiveOpacity() + 1, qreal(1.0)))
+        if (item->d_ptr->isInvisible())
             continue;
 
-        // ### _q_adjustedRect is only needed because QRectF::intersects,
-        // QRectF::contains and QTransform::map() and friends don't work with
-        // flat rectangles.
-        QRectF br = _q_adjustedRect(item->boundingRect());
         bool keep = false;
-        if (mode >= Qt::ContainsItemBoundingRect) {
-            // Polygon contains/intersects item's bounding rect
-            if (path == QPainterPath())
-                path.addPolygon(polygon);
-            if ((mode == Qt::IntersectsItemBoundingRect && path.intersects(item->mapRectToParent(br)))
-                || (mode == Qt::ContainsItemBoundingRect && path.contains(item->mapRectToParent(br)))) {
-                items->append(item);
-                keep = true;
-            }
-        } else {
-            // Polygon contains/intersects item's shape
-            if (QRectF_intersects(polyRect, item->mapRectToParent(br))) {
+        if (!item->d_ptr->isClippedAway()) {
+            // ### _q_adjustedRect is only needed because QRectF::intersects,
+            // QRectF::contains and QTransform::map() and friends don't work with
+            // flat rectangles.
+            const QRectF br(adjustedItemBoundingRect(item));
+            if (mode >= Qt::ContainsItemBoundingRect) {
+                // Polygon contains/intersects item's bounding rect
                 if (path == QPainterPath())
                     path.addPolygon(polygon);
-                if (itemCollidesWithPath(item, item->mapFromParent(path), mode)) {
+                if ((mode == Qt::IntersectsItemBoundingRect && path.intersects(item->mapRectToParent(br)))
+                    || (mode == Qt::ContainsItemBoundingRect && path.contains(item->mapRectToParent(br)))) {
                     items->append(item);
                     keep = true;
                 }
+            } else {
+                // Polygon contains/intersects item's shape
+                if (QRectF_intersects(polyRect, item->mapRectToParent(br))) {
+                    if (path == QPainterPath())
+                        path.addPolygon(polygon);
+                    if (itemCollidesWithPath(item, item->mapFromParent(path), mode)) {
+                        items->append(item);
+                        keep = true;
+                    }
+                }
             }
         }
 
@@ -1642,30 +1767,52 @@ void QGraphicsScenePrivate::childItems_helper(QList<QGraphicsItem *> *items,
                                               Qt::ItemSelectionMode mode) const
 {
     bool parentClip = (parent->flags() & QGraphicsItem::ItemClipsChildrenToShape);
-    QPainterPath intersectedPath = !parentClip ? path : path.intersected(parent->shape());
-    if (intersectedPath.isEmpty())
+    if (parentClip && parent->d_ptr->isClippedAway())
+        return;
+    QRectF pathRect(path.boundingRect());
+    _q_adjustRect(&pathRect);
+    QRectF r = !parentClip ? pathRect : pathRect.intersected(adjustedItemBoundingRect(parent));
+    if (r.isEmpty())
         return;
 
     QList<QGraphicsItem *> &children = parent->d_ptr->children;
     for (int i = 0; i < children.size(); ++i) {
         QGraphicsItem *item = children.at(i);
+        if (item->d_ptr->hasTransform && !item->transform().isInvertible())
+            continue;
 
         // Skip invisible items.
-        if (!item->d_ptr->visible || qFuzzyCompare(item->effectiveOpacity(), qreal(0.0)))
+        if (item->d_ptr->isInvisible())
             continue;
 
-        QTransform x = item->sceneTransform();
-
-        bool ok;
-        QTransform xinv = x.inverted(&ok);
-        if (ok) {
-            QPainterPath mappedPath = xinv.map(path);
-            if (itemCollidesWithPath(item, mappedPath, mode)) {
-                items->append(item);
-                if (!item->d_ptr->children.isEmpty())
-                    childItems_helper(items, item, mappedPath, mode);
+        bool keep = false;
+        if (!item->d_ptr->isClippedAway()) {
+            // ### _q_adjustedRect is only needed because QRectF::intersects,
+            // QRectF::contains and QTransform::map() and friends don't work with
+            // flat rectangles.
+            const QRectF br(adjustedItemBoundingRect(item));
+            if (mode >= Qt::ContainsItemBoundingRect) {
+                // Polygon contains/intersects item's bounding rect
+                if ((mode == Qt::IntersectsItemBoundingRect && path.intersects(item->mapRectToParent(br)))
+                    || (mode == Qt::ContainsItemBoundingRect && path.contains(item->mapRectToParent(br)))) {
+                    items->append(item);
+                    keep = true;
+                }
+            } else {
+                // Path contains/intersects item's shape
+                if (QRectF_intersects(pathRect, item->mapRectToParent(br))) {
+                    if (itemCollidesWithPath(item, item->mapFromParent(path), mode)) {
+                        items->append(item);
+                        keep = true;
+                    }
+                }
             }
         }
+
+        if ((keep || !(item->flags() & QGraphicsItem::ItemClipsChildrenToShape)) && !item->d_ptr->children.isEmpty()) {
+            // Recurse into children that clip children.
+            childItems_helper(items, item, item->mapFromParent(path), mode);
+        }
     }
 }
 
@@ -2339,17 +2486,8 @@ QList<QGraphicsItem *> QGraphicsScene::items() const
 */
 QList<QGraphicsItem *> QGraphicsScene::items(const QPointF &pos) const
 {
-    QList<QGraphicsItem *> itemsAtPoint;
-
-    // Find all items within a 1x1 rect area starting at pos. This can be
-    // inefficient for scenes that use small coordinates (like unity
-    // coordinates), or for detailed graphs. ### The index should support
-    // fetching items at a pos to avoid this limitation.
-    foreach (QGraphicsItem *item, items(QRectF(pos, QSizeF(1, 1)), Qt::IntersectsItemBoundingRect)) {
-        if (item->contains(item->mapFromScene(pos)))
-            itemsAtPoint << item;
-    }
-    return itemsAtPoint;
+    Q_D(const QGraphicsScene);
+    return d->items_helper(pos);
 }
 
 
@@ -2734,8 +2872,9 @@ void QGraphicsScene::addItem(QGraphicsItem *item)
 
     // Notify the item that its scene is changing, and allow the item to
     // react.
-    QGraphicsScene *targetScene = qVariantValue<QGraphicsScene *>(item->itemChange(QGraphicsItem::ItemSceneChange,
-                                                                                   qVariantFromValue<QGraphicsScene *>(this)));
+    const QVariant newSceneVariant(item->itemChange(QGraphicsItem::ItemSceneChange,
+                                                    qVariantFromValue<QGraphicsScene *>(this)));
+    QGraphicsScene *targetScene = qVariantValue<QGraphicsScene *>(newSceneVariant);
     if (targetScene != this) {
         if (targetScene && item->scene() != targetScene)
             targetScene->addItem(item);
@@ -2833,7 +2972,7 @@ void QGraphicsScene::addItem(QGraphicsItem *item)
         emit selectionChanged();
 
     // Deliver post-change notification
-    item->itemChange(QGraphicsItem::ItemSceneHasChanged, qVariantFromValue<QGraphicsScene *>(this));
+    item->itemChange(QGraphicsItem::ItemSceneHasChanged, newSceneVariant);
 }
 
 /*!
@@ -3097,8 +3236,9 @@ void QGraphicsScene::removeItem(QGraphicsItem *item)
 
     // Notify the item that it's scene is changing to 0, allowing the item to
     // react.
-    QGraphicsScene *targetScene = qVariantValue<QGraphicsScene *>(item->itemChange(QGraphicsItem::ItemSceneChange,
-                                                                                   qVariantFromValue<QGraphicsScene *>(0)));
+    const QVariant newSceneVariant(item->itemChange(QGraphicsItem::ItemSceneChange,
+                                                    qVariantFromValue<QGraphicsScene *>(0)));
+    QGraphicsScene *targetScene = qVariantValue<QGraphicsScene *>(newSceneVariant);
     if (targetScene != 0 && targetScene != this) {
         targetScene->addItem(item);
         return;
@@ -3198,7 +3338,7 @@ void QGraphicsScene::removeItem(QGraphicsItem *item)
         emit selectionChanged();
 
     // Deliver post-change notification
-    item->itemChange(QGraphicsItem::ItemSceneHasChanged, qVariantFromValue<QGraphicsScene *>(0));
+    item->itemChange(QGraphicsItem::ItemSceneHasChanged, newSceneVariant);
 }
 
 /*!
@@ -3472,7 +3612,7 @@ QVariant QGraphicsScene::inputMethodQuery(Qt::InputMethodQuery query) const
 void QGraphicsScene::update(const QRectF &rect)
 {
     Q_D(QGraphicsScene);
-    if (d->updateAll)
+    if (d->updateAll || (rect.isEmpty() && !rect.isNull()))
         return;
 
     // Check if anyone's connected; if not, we can send updates directly to
@@ -4581,7 +4721,9 @@ void QGraphicsScenePrivate::drawItemHelper(QGraphicsItem *item, QPainter *painte
 
     // Item's (local) bounding rect
     QRectF brect = item->boundingRect();
-    if (_q_adjustedRect(brect).isEmpty())
+    QRectF adjustedBrect(brect);
+    _q_adjustRect(&adjustedBrect);
+    if (adjustedBrect.isEmpty())
         return;
 
     // Fetch the off-screen transparent buffer and exposed area info.
@@ -4753,11 +4895,9 @@ void QGraphicsScenePrivate::drawItemHelper(QGraphicsItem *item, QPainter *painte
             if (newCacheIndent != deviceData->cacheIndent || deviceRect.size() != pix.size()) {
                 QPoint diff = newCacheIndent - deviceData->cacheIndent;
                 QPixmap newPix(deviceRect.size());
-                // ### Investigate removing this fill (test with Plasma and
-                // graphicssystem raster).
-                newPix.fill(Qt::transparent);
                 if (!pix.isNull()) {
                     QPainter newPixPainter(&newPix);
+                    newPixPainter.setCompositionMode(QPainter::CompositionMode_Source);
                     newPixPainter.drawPixmap(-diff, pix);
                     newPixPainter.end();
                 }
@@ -4789,8 +4929,9 @@ void QGraphicsScenePrivate::drawItemHelper(QGraphicsItem *item, QPainter *painte
         if (itemCache->allExposed || !itemCache->exposed.isEmpty() || !scrollExposure.isEmpty()) {
             // Construct an item-to-pixmap transform.
             QPointF p = deviceRect.topLeft();
-            QTransform itemToPixmap = QTransform::fromTranslate(-p.x(), -p.y());
-            itemToPixmap = painter->worldTransform() * itemToPixmap;
+            QTransform itemToPixmap = painter->worldTransform();
+            if (!p.isNull())
+                itemToPixmap *= QTransform::fromTranslate(-p.x(), -p.y());
 
             // Map the item's logical expose to pixmap coordinates.
             QRegion pixmapExposed = scrollExposure;
@@ -5124,9 +5265,12 @@ void QGraphicsScene::itemUpdated(QGraphicsItem *item, const QRectF &rect)
             update(item->sceneBoundingRect());
         } else {
             // ### Remove _q_adjustedRects().
-            QRectF boundingRect = _q_adjustedRect(item->boundingRect());
-            if (!rect.isNull())
-                boundingRect &= _q_adjustedRect(rect);
+            QRectF boundingRect(adjustedItemBoundingRect(item));
+            if (!rect.isNull()) {
+                QRectF adjustedRect(rect);
+                _q_adjustRect(&adjustedRect);
+                boundingRect &= adjustedRect;
+            }
 
             // Update each view directly.
             for (int i = 0; i < d->views.size(); ++i)
@@ -5138,6 +5282,9 @@ void QGraphicsScene::itemUpdated(QGraphicsItem *item, const QRectF &rect)
         d->resetDirtyItemsLater();
     }
 
+    if (!item->isVisible())
+        return; // Hiding an item won't effect the largestUntransformableItem/sceneRect.
+
     // Update d->largestUntransformableItem by mapping this item's bounding
     // rect back to the topmost untransformable item's untransformed
     // coordinate system (which sort of equals the 1:1 coordinate system of an
@@ -5153,7 +5300,9 @@ void QGraphicsScene::itemUpdated(QGraphicsItem *item, const QRectF &rect)
     // defined scene rect.
     if (!d->hasSceneRect) {
         QRectF oldGrowingItemsBoundingRect = d->growingItemsBoundingRect;
-        d->growingItemsBoundingRect |= _q_adjustedRect(item->sceneBoundingRect());
+        QRectF adjustedItemSceneBoundingRect(item->sceneBoundingRect());
+        _q_adjustRect(&adjustedItemSceneBoundingRect);
+        d->growingItemsBoundingRect |= adjustedItemSceneBoundingRect;
         if (d->growingItemsBoundingRect != oldGrowingItemsBoundingRect)
             emit sceneRectChanged(d->growingItemsBoundingRect);
     }
diff --git a/src/gui/graphicsview/qgraphicsscene_p.h b/src/gui/graphicsview/qgraphicsscene_p.h
index 7f441da..8af8b28 100644
--- a/src/gui/graphicsview/qgraphicsscene_p.h
+++ b/src/gui/graphicsview/qgraphicsscene_p.h
@@ -200,6 +200,7 @@ public:
     void mousePressEventHandler(QGraphicsSceneMouseEvent *mouseEvent);
     QGraphicsWidget *windowForItem(const QGraphicsItem *item) const;
 
+    QList<QGraphicsItem *> items_helper(const QPointF &pos) const;
     QList<QGraphicsItem *> items_helper(const QRectF &rect,
                                         Qt::ItemSelectionMode mode,
                                         Qt::SortOrder order) const;
@@ -211,6 +212,9 @@ public:
                                         Qt::SortOrder order) const;
     void childItems_helper(QList<QGraphicsItem *> *items,
                            const QGraphicsItem *parent,
+                           const QPointF &pos) const;
+    void childItems_helper(QList<QGraphicsItem *> *items,
+                           const QGraphicsItem *parent,
                            const QRectF &rect,
                            Qt::ItemSelectionMode mode) const;
     void childItems_helper(QList<QGraphicsItem *> *items,
diff --git a/src/gui/graphicsview/qgraphicsview.cpp b/src/gui/graphicsview/qgraphicsview.cpp
index a661441..b41dc66 100644
--- a/src/gui/graphicsview/qgraphicsview.cpp
+++ b/src/gui/graphicsview/qgraphicsview.cpp
@@ -790,6 +790,19 @@ QRegion QGraphicsViewPrivate::mapToViewRegion(const QGraphicsItem *item, const Q
     return item->boundingRegion(itv) & itv.mapRect(rect).toAlignedRect();
 }
 
+// QRectF::intersects() returns false always if either the source or target
+// rectangle's width or height are 0. This works around that problem.
+static inline QRectF adjustedItemBoundingRect(const QGraphicsItem *item)
+{
+    Q_ASSERT(item);
+    QRectF boundingRect(item->boundingRect());
+    if (!boundingRect.width())
+        boundingRect.adjust(-0.00001, 0, 0.00001, 0);
+    if (!boundingRect.height())
+        boundingRect.adjust(0, -0.00001, 0, 0.00001);
+    return boundingRect;
+}
+
 /*!
     \internal
 */
@@ -801,38 +814,37 @@ void QGraphicsViewPrivate::itemUpdated(QGraphicsItem *item, const QRectF &rect)
         updateLater();
 
     QRectF updateRect = rect;
-    if (item->isClipped()) {
+    if ((item->d_ptr->flags & QGraphicsItem::ItemClipsChildrenToShape) || item->d_ptr->children.isEmpty()) {
+        updateRect &= adjustedItemBoundingRect(item);
+        if (updateRect.isEmpty())
+            return;
+    }
+
+    QGraphicsItem *clipItem = item;
+    if (item->d_ptr->ancestorFlags & QGraphicsItemPrivate::AncestorClipsChildren) {
         // Minimize unnecessary redraw.
-        QGraphicsItem *p = item;
-        while ((p = p->d_ptr->parent)) {
-            if (p->flags() & QGraphicsItem::ItemClipsChildrenToShape) {
-                updateRect &= p->itemTransform(item).mapRect(p->boundingRect());
-                if (updateRect.isNull())
+        QGraphicsItem *parent = item;
+        while ((parent = parent->d_ptr->parent)) {
+            if (parent->d_ptr->flags & QGraphicsItem::ItemClipsChildrenToShape) {
+                // Map update rect to the current parent and itersect with its bounding rect.
+                updateRect = clipItem->itemTransform(parent).mapRect(updateRect)
+                             & adjustedItemBoundingRect(parent);
+                if (updateRect.isEmpty())
                     return;
+                clipItem = parent;
             }
 
-            if (!(p->d_ptr->ancestorFlags & QGraphicsItemPrivate::AncestorClipsChildren))
+            if (!(parent->d_ptr->ancestorFlags & QGraphicsItemPrivate::AncestorClipsChildren))
                 break;
         }
-
-        if (updateRect.isNull())
-            return;
     }
 
-    // Map the rect to view coordinates.
-    QRect vr = viewport->rect();
-
-    if (!item->d_ptr->hasBoundingRegionGranularity) {
-        QRect r = mapToViewRect(item, updateRect) & vr;
-        if (r.isNull())
-            return;
-        this->updateRect(r);
-    } else {
-        QRegion r = mapToViewRegion(item, updateRect) & vr;
-        if (r.isEmpty())
-            return;
-        updateRegion(r);
-    }
+    // Map update rect from clipItem coordinates to view coordinates.
+    Q_ASSERT(clipItem);
+    if (!item->d_ptr->hasBoundingRegionGranularity)
+        this->updateRect(mapToViewRect(clipItem, updateRect) & viewport->rect());
+    else
+        updateRegion(mapToViewRegion(clipItem, updateRect) & viewport->rect());
 }
 
 void QGraphicsViewPrivate::updateLater()
@@ -855,16 +867,19 @@ void QGraphicsViewPrivate::_q_updateLaterSlot()
     const QList<QGraphicsItem *> &dirtyItems = scene->d_func()->dirtyItems;
     for (int i = 0; i < dirtyItems.size(); ++i) {
         const QGraphicsItem *item = dirtyItems.at(i);
+        if (item->d_ptr->discardUpdateRequest(/*ignoreClipping=*/false,
+                                              /*ignoreVisibleBit=*/false,
+                                              /*ignoreDirtyBit=*/true)) {
+            continue;
+        }
         QTransform x = item->sceneTransform() * viewTransform;
-        QRect viewRect = x.mapRect(item->boundingRect()).toAlignedRect() & vr;
-        if (!viewRect.isNull())
-            updateRect(viewRect);
+        updateRect(x.mapRect(item->boundingRect()).toAlignedRect() & vr);
     }
 
     dirtyRectCount += dirtyRects.size();
 
     bool noUpdate = !fullUpdatePending && viewportUpdateMode == QGraphicsView::FullViewportUpdate;
-    if ((dirtyRectCount > 0 || !dirtyBoundingRect.isNull()) && !fullUpdatePending && !noUpdate) {
+    if ((dirtyRectCount > 0 || !dirtyBoundingRect.isEmpty()) && !fullUpdatePending && !noUpdate) {
         if (viewportUpdateMode == QGraphicsView::BoundingRectViewportUpdate
             || (viewportUpdateMode == QGraphicsView::SmartViewportUpdate
                 && dirtyRectCount >= QGRAPHICSVIEW_REGION_RECT_THRESHOLD)) {
@@ -921,6 +936,9 @@ void QGraphicsViewPrivate::updateAll()
 
 void QGraphicsViewPrivate::updateRegion(const QRegion &r)
 {
+    if (r.isEmpty())
+        return;
+
     Q_Q(QGraphicsView);
 
     // Rect intersects viewport - update everything?
@@ -969,6 +987,9 @@ void QGraphicsViewPrivate::updateRegion(const QRegion &r)
 
 void QGraphicsViewPrivate::updateRect(const QRect &r)
 {
+    if (r.isEmpty())
+        return;
+
     Q_Q(QGraphicsView);
 
     // Rect intersects viewport - update everything?
@@ -1025,103 +1046,71 @@ void QGraphicsViewPrivate::freeStyleOptionsArray(QStyleOptionGraphicsItem *array
 
 extern QPainterPath qt_regionToPath(const QRegion &region);
 
-QList<QGraphicsItem *> QGraphicsViewPrivate::findItems(const QRegion &exposedRegion,
-                                                       const QTransform &worldTransform,
-                                                       bool *allItems) const
+/*!
+    ### Adjustments in findItems: mapToScene(QRect) forces us to adjust the
+    input rectangle by (0, 0, 1, 1), because it uses QRect::bottomRight()
+    (etc) when mapping the rectangle to a polygon (which is _wrong_). In
+    addition, as QGraphicsItem::boundingRect() is defined in logical space,
+    but the default pen for QPainter is cosmetic with a width of 0, QPainter
+    is at risk of painting 1 pixel outside the bounding rect. Therefore we
+    must search for items with an adjustment of (-1, -1, 1, 1).
+*/
+QList<QGraphicsItem *> QGraphicsViewPrivate::findItems(const QRegion &exposedRegion, bool *allItems) const
 {
     Q_Q(const QGraphicsView);
-    QList<QGraphicsItem *> itemList;
-    QSet<QGraphicsItem *> tmp;
-    bool simpleTransform = worldTransform.type() <= QTransform::TxScale;
-
-    QPainterPath path = qt_regionToPath(exposedRegion);
-    *allItems = path.contains(q->mapFromScene(scene->d_func()->growingItemsBoundingRect).boundingRect());
-    QList<QRectF> exposedRects;
-    QList<QPolygonF> exposedPolys;
-
-    // Transform the exposed viewport rects to scene rects or polygons
-    foreach (const QRect &rect, exposedRegion.rects()) {
-        QPolygonF exposedPoly = q->mapToScene(rect.adjusted(-1, -1, 1, 1));
-        QRectF exposedRect = exposedPoly.boundingRect();
-        if (!simpleTransform)
-            exposedPolys << exposedPoly;
-        exposedRects << exposedRect;
-    }
-
-    // Find which items need to be drawn.
-    if (*allItems) {
+
+    // 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))
+                                            .boundingRect();
+    if (exposedRegionSceneBounds.contains(scene->d_func()->growingItemsBoundingRect)) {
+        Q_ASSERT(allItems);
+        *allItems = true;
+
         // All items are guaranteed within the exposed region, don't bother using the index.
-        foreach (QGraphicsItem *item, scene->items()) {
+        QList<QGraphicsItem *> itemList(scene->items());
+        int i = 0;
+        while (i < itemList.size()) {
             // But we only want to include items that are visible
-            if (item->isVisible())
-                itemList << item;
-        }
-    } else if (simpleTransform) {
-        // Simple rect lookups will do.
-        if (exposedRects.size() > 1) {
-            foreach (const QRectF &rect, exposedRects) {
-                foreach (QGraphicsItem *item, scene->d_func()->items_helper(rect, Qt::IntersectsItemBoundingRect, Qt::SortOrder(-1) /* don't sort */)) {
-                    if (!tmp.contains(item)) {
-                        tmp << item;
-                        itemList << item;
-                    }
-                }
-            }
-        } else {
-            itemList += scene->d_func()->items_helper(exposedRects[0], Qt::IntersectsItemBoundingRect, Qt::SortOrder(-1) /* don't sort */);
-        }
-    } else {
-        // Polygon lookup is necessary.
-        if (exposedRects.size() > 1) {
-            foreach (const QPolygonF &poly, exposedPolys) {
-                foreach (QGraphicsItem *item, scene->d_func()->items_helper(poly, Qt::IntersectsItemBoundingRect, Qt::SortOrder(-1) /* don't sort */)) {
-                    if (!tmp.contains(item)) {
-                        tmp << item;
-                        itemList << item;
-                    }
-                }
-            }
-        } else {
-            itemList += scene->d_func()->items_helper(exposedPolys[0], Qt::IntersectsItemBoundingRect, Qt::SortOrder(-1) /* don't sort */);
+            if (!itemList.at(i)->isVisible())
+                itemList.removeAt(i);
+            else
+                ++i;
         }
+
+        // Sort the items.
+        QGraphicsScenePrivate::sortItems(&itemList, Qt::DescendingOrder, scene->d_func()->sortCacheEnabled);
+        return itemList;
     }
 
-    // Check for items that ignore inherited transformations, and add them if
-    // necessary.
-    QRectF untr = scene->d_func()->largestUntransformableItem;
-    if (!*allItems && !untr.isNull()) {
-        // Map the largest untransformable item subtree boundingrect from view
-        // to scene coordinates, and use this to expand all exposed rects in
-        // search for untransformable items.
-        QRectF ltri = matrix.inverted().mapRect(untr);
-        ltri.adjust(-untr.width(), -untr.height(), untr.width(), untr.height());
-
-        foreach (const QRect &rect, exposedRegion.rects()) {
-            QRectF exposed = q->mapToScene(rect.adjusted(-1, -1, 1, 1)).boundingRect();
-            exposed.adjust(-ltri.width(), -ltri.height(), ltri.width(), ltri.height());
-
-            foreach (QGraphicsItem *item, scene->d_func()->estimateItemsInRect(exposed)) {
-                if (item->d_ptr->itemIsUntransformable()) {
-                    if (!tmp.contains(item)) {
-                        QPainterPath rectPath;
-                        rectPath.addRect(rect);
-                        QPainterPath path = item->deviceTransform(q->viewportTransform()).inverted().map(rectPath);
-                        if (item->collidesWithPath(path, Qt::IntersectsItemBoundingRect)) {
-                            itemList << item;
-                            tmp << item;
-                        }
-                    }
-                }
-            }
-        }
+    // Step 2) If the expose region is a simple rect and the view is only
+    // translated or scaled, search for items using
+    // QGraphicsScene::items(QRectF).
+    bool simpleRectLookup =  (scene->d_func()->largestUntransformableItem.isNull()
+                              && exposedRegion.numRects() == 1 && matrix.type() <= QTransform::TxScale);
+    if (simpleRectLookup) {
+        return scene->d_func()->items_helper(exposedRegionSceneBounds,
+                                             Qt::IntersectsItemBoundingRect,
+                                             Qt::DescendingOrder);
     }
-    tmp.clear();
 
-    // Sort the items.
-    QGraphicsScenePrivate::sortItems(&itemList, Qt::DescendingOrder,
-                                     scene->d_func()->sortCacheEnabled);
+    // If the region is complex or the view has a complex transform, adjust
+    // the expose region, convert it to a path, and then search for items
+    // using QGraphicsScene::items(QPainterPath);
+    QRegion adjustedRegion;
+    foreach (const QRect &r, exposedRegion.rects())
+        adjustedRegion += r.adjusted(-1, -1, 1, 1);
+
+    const QPainterPath exposedPath(qt_regionToPath(adjustedRegion));
+    if (scene->d_func()->largestUntransformableItem.isNull()) {
+        const QPainterPath exposedScenePath(q->mapToScene(exposedPath));
+        return scene->d_func()->items_helper(exposedScenePath,
+                                             Qt::IntersectsItemBoundingRect,
+                                             Qt::DescendingOrder);
+    }
 
-    return itemList;
+    // NB! Path must be in viewport coordinates.
+    return itemsInArea(exposedPath, Qt::IntersectsItemBoundingRect, Qt::DescendingOrder);
 }
 
 void QGraphicsViewPrivate::generateStyleOptions(const QList<QGraphicsItem *> &itemList,
@@ -2224,7 +2213,8 @@ QList<QGraphicsItem *> QGraphicsView::items() const
     certainly room for improvement.
 */
 QList<QGraphicsItem *> QGraphicsViewPrivate::itemsInArea(const QPainterPath &path,
-                                                         Qt::ItemSelectionMode mode) const
+                                                         Qt::ItemSelectionMode mode,
+                                                         Qt::SortOrder order) const
 {
     Q_Q(const QGraphicsView);
 
@@ -2274,8 +2264,8 @@ QList<QGraphicsItem *> QGraphicsViewPrivate::itemsInArea(const QPainterPath &pat
     }
 
     // ### Insertion sort would be faster.
-    QGraphicsScenePrivate::sortItems(&result, Qt::AscendingOrder,
-                                     scene->d_func()->sortCacheEnabled);
+    if (order != Qt::SortOrder(-1))
+        QGraphicsScenePrivate::sortItems(&result, order, scene->d_func()->sortCacheEnabled);
     return result;
 }
 
@@ -3280,7 +3270,7 @@ void QGraphicsView::mouseMoveEvent(QMouseEvent *event)
             }
 
             // Update old rubberband
-            if (d->viewportUpdateMode != QGraphicsView::NoViewportUpdate && !d->rubberBandRect.isNull()) {
+            if (d->viewportUpdateMode != QGraphicsView::NoViewportUpdate && !d->rubberBandRect.isEmpty()) {
                 if (d->viewportUpdateMode != FullViewportUpdate)
                     viewport()->update(d->rubberBandRegion(viewport(), d->rubberBandRect));
                 else
@@ -3462,7 +3452,7 @@ void QGraphicsView::paintEvent(QPaintEvent *event)
     QPainter painter(viewport());
     QTransform original = painter.worldTransform();
 #ifndef QT_NO_RUBBERBAND
-    if (d->rubberBanding && !d->rubberBandRect.isNull())
+    if (d->rubberBanding && !d->rubberBandRect.isEmpty())
         painter.save();
 #endif
     // Set up render hints
@@ -3481,7 +3471,7 @@ void QGraphicsView::paintEvent(QPaintEvent *event)
 
     // Find all exposed items
     bool allItems = false;
-    QList<QGraphicsItem *> itemList = d->findItems(exposedRegion, viewTransform, &allItems);
+    QList<QGraphicsItem *> itemList = d->findItems(exposedRegion, &allItems);
 
 #ifdef QGRAPHICSVIEW_DEBUG
     int exposedTime = stopWatch.elapsed();
@@ -3558,7 +3548,7 @@ void QGraphicsView::paintEvent(QPaintEvent *event)
 
 #ifndef QT_NO_RUBBERBAND
     // Rubberband
-    if (d->rubberBanding && !d->rubberBandRect.isNull()) {
+    if (d->rubberBanding && !d->rubberBandRect.isEmpty()) {
         painter.restore();
         QStyleOptionRubberBand option;
         option.initFrom(viewport());
@@ -3642,7 +3632,7 @@ void QGraphicsView::scrollContentsBy(int dx, int dy)
 
 #ifndef QT_NO_RUBBERBAND
     // Update old rubberband
-    if (d->viewportUpdateMode != QGraphicsView::NoViewportUpdate && !d->rubberBandRect.isNull()) {
+    if (d->viewportUpdateMode != QGraphicsView::NoViewportUpdate && !d->rubberBandRect.isEmpty()) {
         if (d->viewportUpdateMode != FullViewportUpdate)
             viewport()->update(d->rubberBandRegion(viewport(), d->rubberBandRect));
         else
diff --git a/src/gui/graphicsview/qgraphicsview_p.h b/src/gui/graphicsview/qgraphicsview_p.h
index 2109673..a76279e 100644
--- a/src/gui/graphicsview/qgraphicsview_p.h
+++ b/src/gui/graphicsview/qgraphicsview_p.h
@@ -85,7 +85,8 @@ public:
     qint64 verticalScroll() const;
 
     QList<QGraphicsItem *> itemsInArea(const QPainterPath &path,
-                                       Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const;
+                                       Qt::ItemSelectionMode mode = Qt::IntersectsItemShape,
+                                       Qt::SortOrder = Qt::AscendingOrder) const;
 
     QPointF mousePressItemPoint;
     QPointF mousePressScenePoint;
@@ -172,9 +173,7 @@ public:
     void updateRegion(const QRegion &region);
     bool updateSceneSlotReimplementedChecked;
 
-    QList<QGraphicsItem *> findItems(const QRegion &exposedRegion,
-				     const QTransform &worldTransform,
-                                     bool *allItems) const;
+    QList<QGraphicsItem *> findItems(const QRegion &exposedRegion, bool *allItems) const;
 
     void generateStyleOptions(const QList<QGraphicsItem *> &itemList,
 			      QGraphicsItem **itemArray,
diff --git a/src/gui/graphicsview/qgraphicswidget.cpp b/src/gui/graphicsview/qgraphicswidget.cpp
index 64ec0e7..7f02fb9 100644
--- a/src/gui/graphicsview/qgraphicswidget.cpp
+++ b/src/gui/graphicsview/qgraphicswidget.cpp
@@ -366,32 +366,33 @@ void QGraphicsWidget::resize(const QSizeF &size)
 void QGraphicsWidget::setGeometry(const QRectF &rect)
 {
     QGraphicsWidgetPrivate *wd = QGraphicsWidget::d_func();
-    const QGraphicsLayoutItemPrivate *d = QGraphicsLayoutItem::d_ptr;
-    setAttribute(Qt::WA_Resized);
-    QRectF newGeom = rect;
-    newGeom.setSize(rect.size().expandedTo(effectiveSizeHint(Qt::MinimumSize))
-                               .boundedTo(effectiveSizeHint(Qt::MaximumSize)));
-    if (newGeom == d->geom)
-        return;
-
-    // Update and prepare to change the geometry (remove from index).
-    if (wd->scene) {
-        if (rect.topLeft() != d->geom.topLeft())
-            wd->fullUpdateHelper(true);
-        else
-            update();
-    }
-    prepareGeometryChange();
-
-    // setPos triggers ItemPositionChange, which can adjust position
+    QGraphicsLayoutItemPrivate *d = QGraphicsLayoutItem::d_ptr;
+    QRectF newGeom;
     QPointF oldPos = d->geom.topLeft();
-    wd->inSetGeometry = 1;
-    wd->setPosHelper(newGeom.topLeft(), /* update = */ false);
-    wd->inSetGeometry = 0;
-    newGeom.moveTopLeft(pos());
-
-    if (newGeom == d->geom)
-        return;
+    if (!wd->inSetPos) {
+        setAttribute(Qt::WA_Resized);
+        newGeom = rect;
+        newGeom.setSize(rect.size().expandedTo(effectiveSizeHint(Qt::MinimumSize))
+                                   .boundedTo(effectiveSizeHint(Qt::MaximumSize)));
+        if (newGeom == d->geom)
+            return;
+
+        // setPos triggers ItemPositionChange, which can adjust position
+        wd->inSetGeometry = 1;
+        wd->setPosHelper(newGeom.topLeft());
+        wd->inSetGeometry = 0;
+        newGeom.moveTopLeft(pos());
+
+        if (newGeom == d->geom)
+           return;
+
+         // Update and prepare to change the geometry (remove from index) if the size has changed.
+        if (wd->scene) {
+            if (rect.topLeft() == d->geom.topLeft()) {
+                prepareGeometryChange();
+            }
+        }
+    }
 
     // Update the layout item geometry
     bool moved = oldPos != pos();
@@ -401,6 +402,11 @@ void QGraphicsWidget::setGeometry(const QRectF &rect)
         event.setOldPos(oldPos);
         event.setNewPos(pos());
         QApplication::sendEvent(this, &event);
+        if (wd->inSetPos) {
+            //set the new pos
+            d->geom.moveTopLeft(pos());
+            return;
+        }
     }
     QSizeF oldSize = size();
     QGraphicsLayoutItem::setGeometry(newGeom);
@@ -1016,9 +1022,11 @@ QVariant QGraphicsWidget::itemChange(GraphicsItemChange change, const QVariant &
         break;
     case ItemPositionHasChanged:
         if (!d->inSetGeometry) {
+            d->inSetPos = 1;
             // Ensure setGeometry is called (avoid recursion when setPos is
             // called from within setGeometry).
             setGeometry(QRectF(pos(), size()));
+            d->inSetPos = 0 ;
         }
         break;
     case ItemParentChange: {
diff --git a/src/gui/graphicsview/qgraphicswidget_p.h b/src/gui/graphicsview/qgraphicswidget_p.h
index 455a129..53eaa31 100644
--- a/src/gui/graphicsview/qgraphicswidget_p.h
+++ b/src/gui/graphicsview/qgraphicswidget_p.h
@@ -86,6 +86,7 @@ public:
           inheritedFontResolveMask(0),
           inSetGeometry(0),
           polished(0),
+          inSetPos(0),
           focusPolicy(Qt::NoFocus),
           focusNext(0),
           focusPrev(0),
@@ -195,6 +196,7 @@ public:
     quint32 attributes : 10;
     quint32 inSetGeometry : 1;
     quint32 polished: 1;
+    quint32 inSetPos : 1;
 
     // Focus
     Qt::FocusPolicy focusPolicy;
diff --git a/src/gui/image/qimage.cpp b/src/gui/image/qimage.cpp
index dc236e4..c7a20db 100644
--- a/src/gui/image/qimage.cpp
+++ b/src/gui/image/qimage.cpp
@@ -3607,6 +3607,9 @@ int QImage::pixelIndex(int x, int y) const
 
     If the \a position is not valid, the results are undefined.
 
+    \warning This function is expensive when used for massive pixel
+    manipulations.
+
     \sa setPixel(), valid(), {QImage#Pixel Manipulation}{Pixel
     Manipulation}
 */
@@ -5581,6 +5584,8 @@ bool QImage::isDetached() const
 
     Use one of the composition mods in QPainter::CompositionMode instead.
 
+    \warning This function is expensive.
+
     \sa alphaChannel(), {QImage#Image Transformations}{Image
     Transformations}, {QImage#Image Formats}{Image Formats}
 */
@@ -5663,6 +5668,11 @@ void QImage::setAlphaChannel(const QImage &alphaChannel)
     \l{QPixmap::}{alphaChannel()}, which works in the same way as
     this function on QPixmaps.
 
+    Most usecases for this function can be replaced with QPainter and
+    using composition modes.
+
+    \warning This is an expensive function.
+
     \sa setAlphaChannel(), hasAlphaChannel(),
     {QPixmap#Pixmap Information}{Pixmap},
     {QImage#Image Transformations}{Image Transformations}
diff --git a/src/gui/image/qpixmap.cpp b/src/gui/image/qpixmap.cpp
index e563fc9..3b82da8 100644
--- a/src/gui/image/qpixmap.cpp
+++ b/src/gui/image/qpixmap.cpp
@@ -724,7 +724,7 @@ void QPixmap::resize_helper(const QSize &s)
     pixels black. The effect of this function is undefined when the pixmap is
     being painted on.
 
-    This is potentially an expensive operation.
+    \warning This is potentially an expensive operation.
 
     \sa mask(), {QPixmap#Pixmap Transformations}{Pixmap Transformations},
     QBitmap
@@ -1430,6 +1430,12 @@ void QPixmap::deref()
     If the given \a size is empty, this function returns a null
     pixmap.
 
+
+    In some cases it can be more beneficial to draw the pixmap to a
+    painter with a scale set rather than scaling the pixmap. This is
+    the case when the painter is for instance based on OpenGL or when
+    the scale factor changes rapidly.
+
     \sa isNull(), {QPixmap#Pixmap Transformations}{Pixmap
     Transformations}
 
@@ -1801,6 +1807,10 @@ int QPixmap::metric(PaintDeviceMetric metric) const
     The effect of this function is undefined when the pixmap is being
     painted on.
 
+    \warning This is potentially an expensive operation. Most usecases
+    for this function are covered by QPainter and compositionModes
+    which will normally execute faster.
+
     \sa alphaChannel(), {QPixmap#Pixmap Transformations}{Pixmap
     Transformations}
  */
@@ -1843,6 +1853,9 @@ void QPixmap::setAlphaChannel(const QPixmap &alphaChannel)
 
     \image alphachannelimage.png The pixmap and channelImage QPixmaps
 
+    \warning This is an expensive operation. The alpha channel of the
+    pixmap is extracted dynamically from the pixeldata.
+
     \sa setAlphaChannel(), {QPixmap#Pixmap Information}{Pixmap
     Information}
 */
@@ -1864,7 +1877,8 @@ QPaintEngine *QPixmap::paintEngine() const
 
     Extracts a bitmap mask from the pixmap's alphachannel.
 
-    This is potentially an expensive operation.
+    \warning This is potentially an expensive operation. The mask of
+    the pixmap is extracted dynamically from the pixeldata.
 
     \sa setMask(), {QPixmap#Pixmap Information}{Pixmap Information}
 */
diff --git a/src/gui/kernel/qapplication_x11.cpp b/src/gui/kernel/qapplication_x11.cpp
index 10fb886..b1270bc 100644
--- a/src/gui/kernel/qapplication_x11.cpp
+++ b/src/gui/kernel/qapplication_x11.cpp
@@ -1362,8 +1362,10 @@ static void qt_set_x11_resources(const char* font = 0, const char* fg = 0,
             pal.setColor(QPalette::Disabled, QPalette::Highlight, Qt::darkBlue);
         }
 
-        QApplicationPrivate::setSystemPalette(pal);
-
+        // QGtkStyle sets it's own system palette
+        if (!(QApplicationPrivate::app_style && QApplicationPrivate::app_style->inherits("QGtkStyle"))) {
+            QApplicationPrivate::setSystemPalette(pal);
+        }
         QColor::setAllowX11ColorNames(allowX11ColorNames);
     }
 
diff --git a/src/gui/kernel/qt_mac_p.h b/src/gui/kernel/qt_mac_p.h
index 3aec23f..e65492d 100644
--- a/src/gui/kernel/qt_mac_p.h
+++ b/src/gui/kernel/qt_mac_p.h
@@ -233,6 +233,7 @@ extern QPaintDevice *qt_mac_safe_pdev; //qapplication_mac.cpp
 
 extern OSWindowRef qt_mac_window_for(const QWidget*); //qwidget_mac.mm
 extern OSViewRef qt_mac_nativeview_for(const QWidget *); //qwidget_mac.mm
+extern QPoint qt_mac_nativeMapFromParent(const QWidget *child, const QPoint &pt); //qwidget_mac.mm
 
 #ifdef check
 # undef check
diff --git a/src/gui/kernel/qwidget.cpp b/src/gui/kernel/qwidget.cpp
index 8ce0231..20b79ce 100644
--- a/src/gui/kernel/qwidget.cpp
+++ b/src/gui/kernel/qwidget.cpp
@@ -66,6 +66,7 @@
 #ifdef Q_WS_MAC
 # include "qt_mac_p.h"
 # include "qt_cocoa_helpers_mac_p.h"
+# include "qmainwindow.h"
 #endif
 #if defined(Q_WS_QWS)
 # include "qwsdisplay_qws.h"
@@ -8979,17 +8980,36 @@ QWidget *QWidget::childAt(const QPoint &p) const
 QWidget *QWidgetPrivate::childAt_helper(const QPoint &p, bool ignoreChildrenInDestructor) const
 {
     Q_Q(const QWidget);
-    if (!q->rect().contains(p))
+#ifdef Q_WS_MAC
+    bool includeFrame = q->isWindow() && qobject_cast<const QMainWindow *>(q)
+                        && static_cast<const QMainWindow *>(q)->unifiedTitleAndToolBarOnMac();
+#endif
+
+    if (
+#ifdef Q_WS_MAC
+            !includeFrame &&
+#endif
+            !q->rect().contains(p))
         return 0;
+
     for (int i = children.size(); i > 0 ;) {
         --i;
         QWidget *w = qobject_cast<QWidget *>(children.at(i));
-        if (w && !w->isWindow() && !w->isHidden() && w->geometry().contains(p)) {
+        if (w && !w->isWindow() && !w->isHidden()
+                && (w->geometry().contains(p)
+#ifdef Q_WS_MAC
+                    || (includeFrame && w->geometry().contains(qt_mac_nativeMapFromParent(w, p)))
+#endif
+               )) {
             if (ignoreChildrenInDestructor && w->data->in_destructor)
                 continue;
             if (w->testAttribute(Qt::WA_TransparentForMouseEvents))
                 continue;
             QPoint childPoint = w->mapFromParent(p);
+#ifdef Q_WS_MAC
+            if (includeFrame && !w->geometry().contains(p))
+                childPoint = qt_mac_nativeMapFromParent(w, p);
+#endif
             if (QWidget *t = w->d_func()->childAt_helper(childPoint, ignoreChildrenInDestructor))
                 return t;
             // if WMouseNoMask is set the widget mask is ignored, if
@@ -9430,11 +9450,13 @@ void QWidget::repaint(const QRect &rect)
     if (!isVisible() || !updatesEnabled() || rect.isEmpty())
         return;
 
-    QTLWExtra *tlwExtra = !d->paintOnScreen() ? window()->d_func()->maybeTopData() : 0;
-    if (tlwExtra && !tlwExtra->inTopLevelResize && tlwExtra->backingStore) {
-        tlwExtra->inRepaint = true;
-        tlwExtra->backingStore->markDirty(rect, this, true);
-        tlwExtra->inRepaint = false;
+    if (hasBackingStoreSupport()) {
+        QTLWExtra *tlwExtra = window()->d_func()->maybeTopData();
+        if (tlwExtra && !tlwExtra->inTopLevelResize && tlwExtra->backingStore) {
+            tlwExtra->inRepaint = true;
+            tlwExtra->backingStore->markDirty(rect, this, true);
+            tlwExtra->inRepaint = false;
+        }
     } else {
         d->repaint_sys(rect);
     }
@@ -9457,11 +9479,13 @@ void QWidget::repaint(const QRegion &rgn)
     if (!isVisible() || !updatesEnabled() || rgn.isEmpty())
         return;
 
-    QTLWExtra *tlwExtra = !d->paintOnScreen() ? window()->d_func()->maybeTopData() : 0;
-    if (tlwExtra && !tlwExtra->inTopLevelResize && tlwExtra->backingStore) {
-        tlwExtra->inRepaint = true;
-        tlwExtra->backingStore->markDirty(rgn, this, true);
-        tlwExtra->inRepaint = false;
+    if (hasBackingStoreSupport()) {
+        QTLWExtra *tlwExtra = window()->d_func()->maybeTopData();
+        if (tlwExtra && !tlwExtra->inTopLevelResize && tlwExtra->backingStore) {
+            tlwExtra->inRepaint = true;
+            tlwExtra->backingStore->markDirty(rgn, this, true);
+            tlwExtra->inRepaint = false;
+        }
     } else {
         d->repaint_sys(rgn);
     }
diff --git a/src/gui/kernel/qwidget_mac.mm b/src/gui/kernel/qwidget_mac.mm
index a3c026b..9eac321 100644
--- a/src/gui/kernel/qwidget_mac.mm
+++ b/src/gui/kernel/qwidget_mac.mm
@@ -3268,6 +3268,20 @@ void QWidgetPrivate::show_sys()
     qt_event_request_window_change(q);
 }
 
+
+QPoint qt_mac_nativeMapFromParent(const QWidget *child, const QPoint &pt)
+{
+#ifndef QT_MAC_USE_COCOA
+    CGPoint nativePoint = CGPointMake(pt.x(), pt.y());
+    HIViewConvertPoint(&nativePoint, qt_mac_nativeview_for(child->parentWidget()),
+                       qt_mac_nativeview_for(child));
+#else
+    NSPoint nativePoint = [qt_mac_nativeview_for(child) convertPoint:NSMakePoint(pt.x(), pt.y()) fromView:qt_mac_nativeview_for(child->parentWidget())];
+#endif
+    return QPoint(nativePoint.x, nativePoint.y);
+}
+
+
 void QWidgetPrivate::hide_sys()
 {
     Q_Q(QWidget);
diff --git a/src/gui/painting/qpaintengine_raster.cpp b/src/gui/painting/qpaintengine_raster.cpp
index 6dd5682..addd63d 100644
--- a/src/gui/painting/qpaintengine_raster.cpp
+++ b/src/gui/painting/qpaintengine_raster.cpp
@@ -2355,11 +2355,6 @@ void QRasterPaintEngine::strokePolygonCosmetic(const QPoint *points, int pointCo
     }
 }
 
-#define IMAGE_FROM_PIXMAP(pixmap) \
-    pixmap.data->classId() == QPixmapData::RasterClass        \
-        ? ((QRasterPixmapData *) pixmap.data)->image          \
-        : pixmap.toImage()
-
 /*!
     \internal
 */
@@ -2368,16 +2363,33 @@ void QRasterPaintEngine::drawPixmap(const QPointF &pos, const QPixmap &pixmap)
 #ifdef QT_DEBUG_DRAW
     qDebug() << " - QRasterPaintEngine::drawPixmap(), pos=" << pos << " pixmap=" << pixmap.size() << "depth=" << pixmap.depth();
 #endif
-    if (pixmap.depth() == 1) {
-        Q_D(QRasterPaintEngine);
-        QRasterPaintEngineState *s = state();
-        if (s->matrix.type() <= QTransform::TxTranslate) {
-            drawBitmap(pos + QPointF(s->matrix.dx(), s->matrix.dy()), pixmap, &s->penData);
+
+    if (pixmap.data->classId() == QPixmapData::RasterClass) {
+        const QImage &image = ((QRasterPixmapData *) pixmap.data)->image;
+        if (image.depth() == 1) {
+            Q_D(QRasterPaintEngine);
+            QRasterPaintEngineState *s = state();
+            if (s->matrix.type() <= QTransform::TxTranslate) {
+                drawBitmap(pos + QPointF(s->matrix.dx(), s->matrix.dy()), image, &s->penData);
+            } else {
+                drawImage(pos, d->rasterBuffer->colorizeBitmap(image, s->pen.color()));
+            }
         } else {
-            drawImage(pos, d->rasterBuffer->colorizeBitmap(IMAGE_FROM_PIXMAP(pixmap), s->pen.color()));
+            QRasterPaintEngine::drawImage(pos, image);
         }
     } else {
-        QRasterPaintEngine::drawImage(pos, IMAGE_FROM_PIXMAP(pixmap));
+        const QImage image = pixmap.toImage();
+        if (pixmap.depth() == 1) {
+            Q_D(QRasterPaintEngine);
+            QRasterPaintEngineState *s = state();
+            if (s->matrix.type() <= QTransform::TxTranslate) {
+                drawBitmap(pos + QPointF(s->matrix.dx(), s->matrix.dy()), image, &s->penData);
+            } else {
+                drawImage(pos, d->rasterBuffer->colorizeBitmap(image, s->pen.color()));
+            }
+        } else {
+            QRasterPaintEngine::drawImage(pos, image);
+        }
     }
 }
 
@@ -2390,22 +2402,40 @@ void QRasterPaintEngine::drawPixmap(const QRectF &r, const QPixmap &pixmap, cons
     qDebug() << " - QRasterPaintEngine::drawPixmap(), r=" << r << " sr=" << sr << " pixmap=" << pixmap.size() << "depth=" << pixmap.depth();
 #endif
 
-    Q_D(QRasterPaintEngine);
-    QRasterPaintEngineState *s = state();
-
-    if (pixmap.depth() == 1) {
-        if (s->matrix.type() <= QTransform::TxTranslate
-            && r.size() == sr.size()
-            && r.size() == pixmap.size()) {
-            ensurePen();
-            drawBitmap(r.topLeft() + QPointF(s->matrix.dx(), s->matrix.dy()), pixmap, &s->penData);
-            return;
+    if (pixmap.data->classId() == QPixmapData::RasterClass) {
+        const QImage &image = ((QRasterPixmapData *) pixmap.data)->image;
+        if (image.depth() == 1) {
+            Q_D(QRasterPaintEngine);
+            QRasterPaintEngineState *s = state();
+            if (s->matrix.type() <= QTransform::TxTranslate
+                && r.size() == sr.size()
+                && r.size() == pixmap.size()) {
+                ensurePen();
+                drawBitmap(r.topLeft() + QPointF(s->matrix.dx(), s->matrix.dy()), image, &s->penData);
+                return;
+            } else {
+                drawImage(r, d->rasterBuffer->colorizeBitmap(image, s->pen.color()), sr);
+            }
         } else {
-            drawImage(r, d->rasterBuffer->colorizeBitmap(IMAGE_FROM_PIXMAP(pixmap),
-                                                         s->pen.color()), sr);
+            drawImage(r, image, sr);
         }
     } else {
-        drawImage(r, IMAGE_FROM_PIXMAP(pixmap), sr);
+        const QImage image = pixmap.toImage();
+        if (image.depth() == 1) {
+            Q_D(QRasterPaintEngine);
+            QRasterPaintEngineState *s = state();
+            if (s->matrix.type() <= QTransform::TxTranslate
+                && r.size() == sr.size()
+                && r.size() == pixmap.size()) {
+                ensurePen();
+                drawBitmap(r.topLeft() + QPointF(s->matrix.dx(), s->matrix.dy()), image, &s->penData);
+                return;
+            } else {
+                drawImage(r, d->rasterBuffer->colorizeBitmap(image, s->pen.color()), sr);
+            }
+        } else {
+            drawImage(r, image, sr);
+        }
     }
 }
 
@@ -2614,10 +2644,15 @@ void QRasterPaintEngine::drawTiledPixmap(const QRectF &r, const QPixmap &pixmap,
     QRasterPaintEngineState *s = state();
 
     QImage image;
-    if (pixmap.depth() == 1)
-        image = d->rasterBuffer->colorizeBitmap(IMAGE_FROM_PIXMAP(pixmap), s->pen.color());
-    else
-        image = IMAGE_FROM_PIXMAP(pixmap);
+
+    if (pixmap.data->classId() == QPixmapData::RasterClass) {
+        image = ((QRasterPixmapData *) pixmap.data)->image;
+    } else {
+        image = pixmap.toImage();
+    }
+
+    if (image.depth() == 1)
+        image = d->rasterBuffer->colorizeBitmap(image, s->pen.color());
 
     if (s->matrix.type() > QTransform::TxTranslate) {
         QTransform copy = s->matrix;
@@ -3650,14 +3685,13 @@ void QRasterPaintEngine::drawBufferSpan(const uint *buffer, int bufsize,
 }
 #endif // Q_WS_QWS
 
-void QRasterPaintEngine::drawBitmap(const QPointF &pos, const QPixmap &pm, QSpanData *fg)
+void QRasterPaintEngine::drawBitmap(const QPointF &pos, const QImage &image, QSpanData *fg)
 {
     Q_ASSERT(fg);
     if (!fg->blend)
         return;
     Q_D(QRasterPaintEngine);
 
-    const QImage image = IMAGE_FROM_PIXMAP(pm);
     Q_ASSERT(image.depth() == 1);
 
     const int spanCount = 256;
@@ -3665,8 +3699,8 @@ void QRasterPaintEngine::drawBitmap(const QPointF &pos, const QPixmap &pm, QSpan
     int n = 0;
 
     // Boundaries
-    int w = pm.width();
-    int h = pm.height();
+    int w = image.width();
+    int h = image.height();
     int ymax = qMin(qRound(pos.y() + h), d->rasterBuffer->height());
     int ymin = qMax(qRound(pos.y()), 0);
     int xmax = qMin(qRound(pos.x() + w), d->rasterBuffer->width());
diff --git a/src/gui/painting/qpaintengine_raster_p.h b/src/gui/painting/qpaintengine_raster_p.h
index 0f8060a..26a2b3f 100644
--- a/src/gui/painting/qpaintengine_raster_p.h
+++ b/src/gui/painting/qpaintengine_raster_p.h
@@ -256,7 +256,7 @@ private:
     void init();
 
     void fillRect(const QRectF &rect, QSpanData *data);
-    void drawBitmap(const QPointF &pos, const QPixmap &image, QSpanData *fill);
+    void drawBitmap(const QPointF &pos, const QImage &image, QSpanData *fill);
 
     void drawCachedGlyphs(const QPointF &p, const QTextItemInt &ti);
 
diff --git a/src/gui/painting/qpainter.cpp b/src/gui/painting/qpainter.cpp
index fe6cc69..2beb8c2 100644
--- a/src/gui/painting/qpainter.cpp
+++ b/src/gui/painting/qpainter.cpp
@@ -2371,6 +2371,11 @@ void QPainter::setClipping(bool enable)
     Returns the currently set clip region. Note that the clip region
     is given in logical coordinates.
 
+    \warning QPainter does not store the combined clip explicitly as
+    this is handled by the underlying QPaintEngine, so the path is
+    recreated on demand and transformed to the current logical
+    coordinate system. This is potentially an expensive operation.
+
     \sa setClipRegion(), clipPath(), setClipping()
 */
 
@@ -2486,6 +2491,11 @@ extern QPainterPath qt_regionToPath(const QRegion &region);
     Returns the currently clip as a path. Note that the clip path is
     given in logical coordinates.
 
+    \warning QPainter does not store the combined clip explicitly as
+    this is handled by the underlying QPaintEngine, so the path is
+    recreated on demand and transformed to the current logical
+    coordinate system. This is potentially an expensive operation.
+
     \sa setClipPath(), clipRegion(), setClipping()
 */
 QPainterPath QPainter::clipPath() const
@@ -5155,9 +5165,6 @@ void QPainter::drawPixmap(const QPointF &p, const QPixmap &pm)
 
     Q_D(QPainter);
 
-    if (!d->engine || pm.isNull())
-        return;
-
 #ifndef QT_NO_DEBUG
     qt_painter_thread_test(d->device->devType(), "drawPixmap()");
 #endif
@@ -5167,12 +5174,18 @@ void QPainter::drawPixmap(const QPointF &p, const QPixmap &pm)
         return;
     }
 
+    if (!d->engine)
+        return;
+
     qreal x = p.x();
     qreal y = p.y();
 
     int w = pm.width();
     int h = pm.height();
 
+    if (w <= 0)
+        return;
+
     // Emulate opaque background for bitmaps
     if (d->state->bgMode == Qt::OpaqueMode && pm.isQBitmap()) {
         fillRect(QRectF(x, y, w, h), d->state->bgBrush.color());
diff --git a/src/gui/painting/qpainterpath.cpp b/src/gui/painting/qpainterpath.cpp
index b5e092c..6ae908c 100644
--- a/src/gui/painting/qpainterpath.cpp
+++ b/src/gui/painting/qpainterpath.cpp
@@ -1725,7 +1725,7 @@ static void qt_painterpath_isect_curve(const QBezier &bezier, const QPointF &pt,
 */
 bool QPainterPath::contains(const QPointF &pt) const
 {
-    if (isEmpty())
+    if (isEmpty() || !controlPointRect().contains(pt))
         return false;
 
     QPainterPathData *d = d_func();
diff --git a/src/gui/styles/gtksymbols.cpp b/src/gui/styles/gtksymbols.cpp
index 8123d32..f7af8f8 100644
--- a/src/gui/styles/gtksymbols.cpp
+++ b/src/gui/styles/gtksymbols.cpp
@@ -504,13 +504,6 @@ static QPalette gtkWidgetPalette(const QString &gtkWidgetName)
     pal.setBrush(QPalette::Disabled, QPalette::WindowText, disabledTextColor);
     pal.setBrush(QPalette::All, QPalette::ButtonText, textColor);
     pal.setBrush(QPalette::Disabled, QPalette::ButtonText, disabledTextColor);
-    if (gtkWidgetName == QLS("GtkMenu")) {
-        // This really applies to the combo box rendering since
-        // QComboBox copies the palette from a QMenu
-        GdkColor gdkBg = gtkWidget->style->bg[GTK_STATE_NORMAL];
-        QColor bgColor(gdkBg.red>>8, gdkBg.green>>8, gdkBg.blue>>8);
-        pal.setBrush(QPalette::Base, bgColor);
-    }
     return pal;
 }
 
@@ -528,6 +521,7 @@ void QGtk::applyCustomPaletteHash()
     GdkColor gdkBg = QGtk::gtkWidget(QLS("GtkMenu"))->style->bg[GTK_STATE_NORMAL];
     QColor bgColor(gdkBg.red>>8, gdkBg.green>>8, gdkBg.blue>>8);
     menuPal.setBrush(QPalette::Base, bgColor);
+    menuPal.setBrush(QPalette::Window, bgColor);
     qApp->setPalette(menuPal, "QMenu");
 
     QPalette toolbarPal = gtkWidgetPalette(QLS("GtkToolbar"));
diff --git a/src/gui/styles/qgtkstyle.cpp b/src/gui/styles/qgtkstyle.cpp
index 6354ce7..b569b5c 100644
--- a/src/gui/styles/qgtkstyle.cpp
+++ b/src/gui/styles/qgtkstyle.cpp
@@ -2634,7 +2634,7 @@ void QGtkStyle::drawControl(ControlElement element,
             QColor disabledTextColor = QColor(gdkDText.red>>8, gdkDText.green>>8, gdkDText.blue>>8);
             if (resolve_mask & (1 << QPalette::ButtonText)) {
                 textColor = option->palette.buttonText().color();
-                disabledTextColor = option->palette.brush(QPalette::Disabled, QPalette::ButtonText);;
+                disabledTextColor = option->palette.brush(QPalette::Disabled, QPalette::ButtonText).color();
             }
 
             QColor highlightedTextColor = QColor(gdkHText.red>>8, gdkHText.green>>8, gdkHText.blue>>8);
diff --git a/src/gui/styles/qwindowsvistastyle.cpp b/src/gui/styles/qwindowsvistastyle.cpp
index 4c3060d..b14b8b3 100644
--- a/src/gui/styles/qwindowsvistastyle.cpp
+++ b/src/gui/styles/qwindowsvistastyle.cpp
@@ -801,12 +801,20 @@ void QWindowsVistaStyle::drawPrimitive(PrimitiveElement element, const QStyleOpt
                         if (vopt->viewItemPosition == QStyleOptionViewItemV4::OnlyOne
                             || vopt->viewItemPosition == QStyleOptionViewItemV4::Invalid)
                             painter->drawPixmap(pixmapRect.topLeft(), pixmap);
-                        else if (reverse ? rightSection : leftSection)
-                            painter->drawPixmap(pixmapRect, pixmap, srcRect.adjusted(0, 0, -frame, 0));
-                        else if (reverse ? leftSection : rightSection)
-                            painter->drawPixmap(pixmapRect, pixmap,
-                                                srcRect.adjusted(frame, 0, 0, 0));
-                        else if (vopt->viewItemPosition == QStyleOptionViewItemV4::Middle)
+                        else if (reverse ? rightSection : leftSection){
+                            painter->drawPixmap(QRect(pixmapRect.topLeft(), 
+                                                QSize(frame, pixmapRect.height())), pixmap, 
+                                                QRect(QPoint(0, 0), QSize(frame, pixmapRect.height())));
+                            painter->drawPixmap(pixmapRect.adjusted(frame, 0, 0, 0), 
+                                                pixmap, srcRect.adjusted(frame, 0, -frame, 0));
+                        } else if (reverse ? leftSection : rightSection) {
+                            painter->drawPixmap(QRect(pixmapRect.topRight() - QPoint(frame - 1, 0), 
+                                                QSize(frame, pixmapRect.height())), pixmap, 
+                                                QRect(QPoint(pixmapRect.width() - frame, 0), 
+                                                QSize(frame, pixmapRect.height())));
+                            painter->drawPixmap(pixmapRect.adjusted(0, 0, -frame, 0), 
+                                                pixmap, srcRect.adjusted(frame, 0, -frame, 0));
+                        } else if (vopt->viewItemPosition == QStyleOptionViewItemV4::Middle)
                             painter->drawPixmap(pixmapRect, pixmap,
                                                 srcRect.adjusted(frame, 0, -frame, 0));
                     } else {
diff --git a/src/gui/widgets/qdialogbuttonbox.cpp b/src/gui/widgets/qdialogbuttonbox.cpp
index 246da95..4a95292 100644
--- a/src/gui/widgets/qdialogbuttonbox.cpp
+++ b/src/gui/widgets/qdialogbuttonbox.cpp
@@ -752,7 +752,8 @@ QDialogButtonBox::~QDialogButtonBox()
     \value KdeLayout Use a policy appropriate for applications on KDE.
     \value GnomeLayout Use a policy appropriate for applications on GNOME.
 
-    The button layout is specified by the \l{style()}{current style}.
+    The button layout is specified by the \l{style()}{current style}. However,
+    on the X11 platform, it may be influenced by the desktop environment.
 */
 
 /*!
author	Bjoern Erik Nilsen <bjorn.nilsen@nokia.com>	2009-04-07 10:59:16 (GMT)
committer	Bjoern Erik Nilsen <bjorn.nilsen@nokia.com>	2009-04-07 10:59:16 (GMT)
commit	6e13559503040963c28dd8f5b6881e3a2b9d5596 (patch)
tree	3e030548ffb1667d5fa8cd2020fd7b28749d0411 /src/gui
parent	939623b2bc8e441618ee1a1886cc656880bee62b (diff)
parent	d8f76432c3937690c37972136c02a5a264bc941f (diff)
download	Qt-6e13559503040963c28dd8f5b6881e3a2b9d5596.zip Qt-6e13559503040963c28dd8f5b6881e3a2b9d5596.tar.gz Qt-6e13559503040963c28dd8f5b6881e3a2b9d5596.tar.bz2