Merge commit oslo-staging-2/4.6 into upstream/4.6

1 files changed, 23 insertions, 184 deletions

diff --git a/src/gui/graphicsview/qgraphicsitem.cpp b/src/gui/graphicsview/qgraphicsitem.cpp
index 94a37a0..bb45e7e 100644
--- a/src/gui/graphicsview/qgraphicsitem.cpp
+++ b/src/gui/graphicsview/qgraphicsitem.cpp
@@ -755,7 +755,6 @@ void QGraphicsItemPrivate::updateAncestorFlag(QGraphicsItem::GraphicsItemFlag ch
         case QGraphicsItem::ItemClipsChildrenToShape:
             flag = AncestorClipsChildren;
             enabled = flags & QGraphicsItem::ItemClipsChildrenToShape;
-            invalidateCachedClipPathRecursively(/*childrenOnly=*/true);
             break;
         case QGraphicsItem::ItemIgnoresTransformations:
             flag = AncestorIgnoresTransformations;
@@ -1104,9 +1103,7 @@ void QGraphicsItemPrivate::setParentItemHelper(QGraphicsItem *newParent)
         parent->itemChange(QGraphicsItem::ItemChildAddedChange, thisPointerVariant);
         if (scene) {
             if (!implicitUpdate)
-                scene->d_func()->markDirty(q_ptr, QRect(),
-                                           /*invalidateChildren=*/false,
-                                           /*maybeDirtyClipPath=*/true);
+                scene->d_func()->markDirty(q_ptr);
 
             // Re-enable scene pos notifications for new ancestors
             if (scenePosDescendants || (flags & QGraphicsItem::ItemSendsScenePositionChanges))
@@ -1147,11 +1144,8 @@ void QGraphicsItemPrivate::setParentItemHelper(QGraphicsItem *newParent)
                 setEnabledHelper(true, /* explicit = */ false);
 
             // If the item is being deleted, the whole scene will be updated.
-            if (scene) {
-                scene->d_func()->markDirty(q_ptr, QRect(),
-                                           /*invalidateChildren=*/false,
-                                           /*maybeDirtyClipPath=*/true);
-            }
+            if (scene)
+                scene->d_func()->markDirty(q_ptr);
         }
     }
 
@@ -1732,9 +1726,6 @@ 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.
@@ -1777,9 +1768,7 @@ void QGraphicsItem::setFlags(GraphicsItemFlags flags)
             else
                 d_ptr->scene->d_func()->unregisterScenePosItem(this);
         }
-        d_ptr->scene->d_func()->markDirty(this, QRectF(),
-                                          /*invalidateChildren=*/true,
-                                          /*maybeDirtyClipPath*/true);
+        d_ptr->scene->d_func()->markDirty(this, QRectF(), /*invalidateChildren=*/true);
     }
 
     // Notify change.
@@ -2127,12 +2116,8 @@ void QGraphicsItemPrivate::setVisibleHelper(bool newVisible, bool explicitly, bo
         QGraphicsItemCache *c = (QGraphicsItemCache *)qVariantValue<void *>(extra(ExtraCacheData));
         if (c)
             c->purge();
-        if (scene) {
-            scene->d_func()->markDirty(q_ptr, QRectF(),
-                                       /*invalidateChildren=*/false,
-                                       /*maybeDirtyClipPath=*/false,
-                                       /*force=*/true);
-        }
+        if (scene)
+            scene->d_func()->markDirty(q_ptr, QRectF(), /*invalidateChildren=*/false, /*force=*/true);
     }
 
     // Certain properties are dropped as an item becomes invisible.
@@ -2542,7 +2527,6 @@ void QGraphicsItem::setOpacity(qreal opacity)
 #endif //QT_NO_GRAPHICSEFFECT
         d_ptr->scene->d_func()->markDirty(this, QRectF(),
                                           /*invalidateChildren=*/true,
-                                          /*maybeDirtyClipPath=*/false,
                                           /*force=*/false,
                                           /*ignoreOpacity=*/true);
     }
@@ -2590,8 +2574,11 @@ void QGraphicsItem::setGraphicsEffect(QGraphicsEffect *effect)
         d_ptr->graphicsEffect = 0;
         if (oldEffectPrivate) {
             oldEffectPrivate->setGraphicsEffectSource(0); // deletes the current source.
-            if (d_ptr->scene) // Update the views directly.
-                d_ptr->scene->d_func()->markDirty(this, QRectF(), false, false, false, false, true);
+            if (d_ptr->scene) { // Update the views directly.
+                d_ptr->scene->d_func()->markDirty(this, QRectF(), /*invalidateChildren=*/false,
+                                                  /*force=*/false, /*ignoreOpacity=*/false,
+                                                  /*removeItemFromScene=*/true);
+            }
         }
     } else {
         // Set new effect.
@@ -3399,7 +3386,6 @@ void QGraphicsItemPrivate::setPosHelper(const QPointF &pos)
 {
     Q_Q(QGraphicsItem);
     inSetPosHelper = 1;
-    updateCachedClipPathFromSetPosHelper(pos);
     if (scene)
         q->prepareGeometryChange();
     QPointF oldPos = this->pos;
@@ -4535,22 +4521,12 @@ bool QGraphicsItem::isClipped() const
 QPainterPath QGraphicsItem::clipPath() const
 {
     Q_D(const QGraphicsItem);
-    if (!d->dirtyClipPath)
-        return d->emptyClipPath ? QPainterPath() : d->cachedClipPath;
-
-    if (!isClipped()) {
-        d_ptr->setCachedClipPath(QPainterPath());
-        return d->cachedClipPath;
-    }
+    if (!isClipped())
+        return QPainterPath();
 
     const QRectF thisBoundingRect(boundingRect());
-    if (thisBoundingRect.isEmpty()) {
-        if (d_ptr->flags & ItemClipsChildrenToShape)
-            d_ptr->setEmptyCachedClipPathRecursively();
-        else
-            d_ptr->setEmptyCachedClipPath();
+    if (thisBoundingRect.isEmpty())
         return QPainterPath();
-    }
 
     QPainterPath clip;
     // Start with the item's bounding rect.
@@ -4561,40 +4537,18 @@ QPainterPath QGraphicsItem::clipPath() const
         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) {
                 // 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());
-                }
-
-                if (clip.isEmpty()) {
-                    if (d_ptr->flags & ItemClipsChildrenToShape)
-                        d_ptr->setEmptyCachedClipPathRecursively();
-                    else
-                        d_ptr->setEmptyCachedClipPath();
+                clip = clip.intersected(parent->shape());
+                if (clip.isEmpty())
                     return clip;
-                }
                 lastParent = parent;
             }
 
-            if (!(parent->d_ptr->ancestorFlags & QGraphicsItemPrivate::AncestorClipsChildren)
-                || foundValidClipPath) {
+            if (!(parent->d_ptr->ancestorFlags & QGraphicsItemPrivate::AncestorClipsChildren))
                 break;
-            }
         }
 
         if (lastParent != this) {
@@ -4607,7 +4561,6 @@ QPainterPath QGraphicsItem::clipPath() const
     if (d->flags & ItemClipsToShape)
         clip = clip.intersected(shape());
 
-    d_ptr->setCachedClipPath(clip);
     return clip;
 }
 
@@ -5026,15 +4979,14 @@ 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, bool ignoreOpacity) const
+bool QGraphicsItemPrivate::discardUpdateRequest(bool ignoreVisibleBit, bool ignoreDirtyBit,
+                                                bool ignoreOpacity) 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 !scene
            || (!visible && !ignoreVisibleBit && !this->ignoreVisible)
            || (!ignoreDirtyBit && fullUpdatePending)
-           || (!ignoreClipping && (childrenClippedToShape() && isClippedAway()))
            || (!ignoreOpacity && !this->ignoreOpacity && childrenCombineOpacity() && isFullyTransparent());
 }
 
@@ -5169,109 +5121,6 @@ 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 (inDestructor || !(ancestorFlags & QGraphicsItemPrivate::AncestorClipsChildren))
-        return; // Not clipped by any ancestor.
-
-    // Find closest clip ancestor and transform.
-    Q_Q(QGraphicsItem);
-    // COMBINE
-    QTransform thisToParentTransform = QTransform::fromTranslate(newPos.x(), newPos.y());
-    if (transformData)
-        thisToParentTransform = transformData->computedFullTransform(&thisToParentTransform);
-    QGraphicsItem *clipParent = parent;
-    while (clipParent && !clipParent->d_ptr->inDestructor && !(clipParent->d_ptr->flags & QGraphicsItem::ItemClipsChildrenToShape)) {
-        thisToParentTransform *= clipParent->d_ptr->transformToParent();
-        clipParent = clipParent->d_ptr->parent;
-    }
-
-    // Ensure no parents are currently being deleted. This can only
-    // happen if the item is moved by a dying ancestor.
-    QGraphicsItem *p = clipParent;
-    while (p) {
-        if (p->d_ptr->inDestructor)
-            return;
-        p = p->d_ptr->parent;
-    }
-
-    // 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));
-    }
-}
-
 // Traverses all the ancestors up to the top-level and updates the pointer to
 // always point to the top-most item that has a dirty scene transform.
 // It then backtracks to the top-most dirty item and start calculating the
@@ -7288,9 +7137,7 @@ void QGraphicsItem::prepareGeometryChange()
 
         QGraphicsScenePrivate *scenePrivate = d_ptr->scene->d_func();
         scenePrivate->index->prepareBoundingRectChange(this);
-        scenePrivate->markDirty(this, QRectF(),
-                                /*invalidateChildren=*/true,
-                                /*maybeDirtyClipPath=*/!d_ptr->inSetPosHelper);
+        scenePrivate->markDirty(this, QRectF(), /*invalidateChildren=*/true);
 
         // For compatibility reasons, we have to update the item's old geometry
         // if someone is connected to the changed signal or the scene has no views.
@@ -7313,16 +7160,6 @@ void QGraphicsItem::prepareGeometryChange()
         // ### Only do this if the parent's effect applies to the entire subtree.
         parent->d_ptr->notifyBoundingRectChanged = 1;
     }
-
-    if (d_ptr->inSetPosHelper)
-        return;
-
-    if (d_ptr->flags & ItemClipsChildrenToShape
-        || d_ptr->ancestorFlags & QGraphicsItemPrivate::AncestorClipsChildren) {
-        d_ptr->invalidateCachedClipPathRecursively();
-    } else {
-        d_ptr->invalidateCachedClipPath();
-    }
 }
 
 /*!
@@ -9604,9 +9441,11 @@ void QGraphicsTextItem::setDefaultTextColor(const QColor &col)
 {
     QTextControl *c = dd->textControl();
     QPalette pal = c->palette();
+    QColor old = pal.color(QPalette::Text);
     pal.setColor(QPalette::Text, col);
     c->setPalette(pal);
-    update();
+    if (old != col)
+        update();
 }
 
 /*!