Changeset 651 for trunk/src/gui/graphicsview/qgraphicsscene.cpp

Timestamp:

Mar 8, 2010, 12:52:58 PM (15 years ago)

Author:

Dmitry A. Kuminov

Message:

trunk: Merged in qt 4.6.2 sources.

Location:

trunk

Files:

• . (modified) (1 prop)
• src/gui/graphicsview/qgraphicsscene.cpp (modified) (25 diffs)

trunk/src/gui/graphicsview/qgraphicsscene.cpp

@@ -1 +1 @@
 /****************************************************************************
 **
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
@@ -252 +252 @@
 #include <private/qgraphicseffect_p.h>
 #include <private/qgesturemanager_p.h>
+#include <private/qpathclipper_p.h>
 
 // #define GESTURE_DEBUG
@@ -293 +294 @@
       selectionChanging(0),
       needSortTopLevelItems(true),
-      unpolishedItemsModified(true),
       holesInTopLevelSiblingIndex(false),
       topLevelSequentialOrdering(true),
@@ -374 +374 @@
         }
     } else {
-        updateAll = false;
+        if (views.isEmpty()) {
+            updateAll = false;
+            return;
+        }
         for (int i = 0; i < views.size(); ++i)
             views.at(i)->d_func()->processPendingUpdates();
@@ -430 +433 @@
 void QGraphicsScenePrivate::_q_polishItems()
 {
-    QSet<QGraphicsItem *>::Iterator it = unpolishedItems.begin();
+    if (unpolishedItems.isEmpty())
+        return;
+
     const QVariant booleanTrueVariant(true);
-    while (!unpolishedItems.isEmpty()) {
-        QGraphicsItem *item = *it;
-        it = unpolishedItems.erase(it);
-        unpolishedItemsModified = false;
-        if (!item->d_ptr->explicitlyHidden) {
+    QGraphicsItem *item = 0;
+    QGraphicsItemPrivate *itemd = 0;
+    const int oldUnpolishedCount = unpolishedItems.count();
+
+    for (int i = 0; i < oldUnpolishedCount; ++i) {
+        item = unpolishedItems.at(i);
+        if (!item)
+            continue;
+        itemd = item->d_ptr.data();
+        itemd->pendingPolish = false;
+        if (!itemd->explicitlyHidden) {
             item->itemChange(QGraphicsItem::ItemVisibleChange, booleanTrueVariant);
             item->itemChange(QGraphicsItem::ItemVisibleHasChanged, booleanTrueVariant);
         }
-        if (item->isWidget()) {
+        if (itemd->isWidget) {
             QEvent event(QEvent::Polish);
             QApplication::sendEvent((QGraphicsWidget *)item, &event);
         }
-        if (unpolishedItemsModified)
-            it = unpolishedItems.begin();
+    }
+
+    if (unpolishedItems.count() == oldUnpolishedCount) {
+        // No new items were added to the vector.
+        unpolishedItems.clear();
+    } else {
+        // New items were appended; keep them and remove the old ones.
+        unpolishedItems.remove(0, oldUnpolishedCount);
+        unpolishedItems.squeeze();
+        QMetaObject::invokeMethod(q_ptr, "_q_polishItems", Qt::QueuedConnection);
     }
 }
@@ -600 +619 @@
             Q_ASSERT_X(parentItem->scene() == q, "QGraphicsScene::removeItem",
                        "Parent item's scene is different from this item's scene");
-            item->d_ptr->setParentItemHelper(0);
+            item->setParentItem(0);
         }
     } else {
@@ -639 +658 @@
     hoverItems.removeAll(item);
     cachedItemsUnderMouse.removeAll(item);
-    unpolishedItems.remove(item);
-    unpolishedItemsModified = true;
+    if (item->d_ptr->pendingPolish) {
+        const int unpolishedIndex = unpolishedItems.indexOf(item);
+        if (unpolishedIndex != -1)
+            unpolishedItems[unpolishedIndex] = 0;
+        item->d_ptr->pendingPolish = false;
+    }
     resetDirtyItem(item);
 
@@ -1937 +1960 @@
 
     This convenience function is equivalent to calling items(QRectF(\a x, \a y, \a w, \a h), \a mode).
-    
+
     This function is deprecated and returns incorrect results if the scene
     contains items that ignore transformations. Use the overload that takes
@@ -2483 +2506 @@
         return;
     }
-    if (item->scene() == this) {
+    if (item->d_ptr->scene == this) {
         qWarning("QGraphicsScene::addItem: item has already been added to this scene");
         return;
     }
     // Remove this item from its existing scene
-    if (QGraphicsScene *oldScene = item->scene())
+    if (QGraphicsScene *oldScene = item->d_ptr->scene)
         oldScene->removeItem(item);
 
@@ -2497 +2520 @@
     QGraphicsScene *targetScene = qVariantValue<QGraphicsScene *>(newSceneVariant);
     if (targetScene != this) {
-        if (targetScene && item->scene() != targetScene)
+        if (targetScene && item->d_ptr->scene != targetScene)
             targetScene->addItem(item);
         return;
     }
 
+    if (d->unpolishedItems.isEmpty())
+        QMetaObject::invokeMethod(this, "_q_polishItems", Qt::QueuedConnection);
+    d->unpolishedItems.append(item);
+    item->d_ptr->pendingPolish = true;
+
     // Detach this item from its parent if the parent's scene is different
     // from this scene.
-    if (QGraphicsItem *itemParent = item->parentItem()) {
-        if (itemParent->scene() != this)
+    if (QGraphicsItem *itemParent = item->d_ptr->parent) {
+        if (itemParent->d_ptr->scene != this)
             item->setParentItem(0);
     }
@@ -2535 +2563 @@
     }
 #ifndef QT_NO_CURSOR
-    if (d->allItemsUseDefaultCursor && item->hasCursor()) {
+    if (d->allItemsUseDefaultCursor && item->d_ptr->hasCursor) {
         d->allItemsUseDefaultCursor = false;
         if (d->allItemsIgnoreHoverEvents) // already enabled otherwise
@@ -2543 +2571 @@
 
     // Enable touch events if the item accepts touch events.
-    if (d->allItemsIgnoreTouchEvents && item->acceptTouchEvents()) {
+    if (d->allItemsIgnoreTouchEvents && item->d_ptr->acceptTouchEvents) {
         d->allItemsIgnoreTouchEvents = false;
         d->enableTouchEventsOnViews();
@@ -2576 +2604 @@
 
     // Add all children recursively
-    foreach (QGraphicsItem *child, item->children())
-        addItem(child);
+    item->d_ptr->ensureSortedChildren();
+    for (int i = 0; i < item->d_ptr->children.size(); ++i)
+        addItem(item->d_ptr->children.at(i));
 
     // Resolve font and palette.
@@ -2583 +2612 @@
     item->d_ptr->resolvePalette(d->palette.resolve());
 
-    if (d->unpolishedItems.isEmpty())
-        QMetaObject::invokeMethod(this, "_q_polishItems", Qt::QueuedConnection);
-    d->unpolishedItems.insert(item);
-    d->unpolishedItemsModified = true;
 
     // Reenable selectionChanged() for individual items
@@ -2620 +2645 @@
     }
 
-    if (item->flags() & QGraphicsItem::ItemSendsScenePositionChanges)
+    if (item->d_ptr->flags & QGraphicsItem::ItemSendsScenePositionChanges)
         d->registerScenePosItem(item);
 
@@ -3767 +3792 @@
 bool QGraphicsScenePrivate::itemAcceptsHoverEvents_helper(const QGraphicsItem *item) const
 {
-    return (!item->isBlockedByModalPanel() &&
-            (item->acceptHoverEvents()
-             || (item->isWidget()
-                 && static_cast<const QGraphicsWidget *>(item)->d_func()->hasDecoration())));
+    return (item->d_ptr->acceptsHover
+            || (item->d_ptr->isWidget
+                && static_cast<const QGraphicsWidget *>(item)->d_func()->hasDecoration()))
+           && !item->isBlockedByModalPanel();
 }
 
@@ -4583 +4608 @@
         _q_polishItems();
 
+    updateAll = false;
     QRectF exposedSceneRect;
     if (exposedRegion && indexMethod != QGraphicsScene::NoIndex) {
@@ -4610 +4636 @@
 
     const qreal opacity = item->d_ptr->combineOpacityFromParent(parentOpacity);
-    const bool itemIsFullyTransparent = (opacity < 0.0001);
+    const bool itemIsFullyTransparent = QGraphicsItemPrivate::isOpacityNull(opacity);
     if (itemIsFullyTransparent && (!itemHasChildren || item->d_ptr->childrenCombineOpacity()))
         return;
@@ -4687 +4713 @@
             && sourced->lastEffectTransform != painter->worldTransform())
         {
+            bool unclipped = false;
+            if (sourced->lastEffectTransform.type() <= QTransform::TxTranslate
+                && painter->worldTransform().type() <= QTransform::TxTranslate)
+            {
+                QRectF itemRect = item->boundingRect();
+                if (!item->d_ptr->children.isEmpty())
+                    itemRect |= item->childrenBoundingRect();
+
+                QRectF oldSourceRect = sourced->lastEffectTransform.mapRect(itemRect);
+                QRectF newSourceRect = painter->worldTransform().mapRect(itemRect);
+
+                QRect oldEffectRect = sourced->paddedEffectRect(sourced->currentCachedSystem(), sourced->currentCachedMode(), oldSourceRect);
+                QRect newEffectRect = sourced->paddedEffectRect(sourced->currentCachedSystem(), sourced->currentCachedMode(), newSourceRect);
+
+                QRect deviceRect(0, 0, painter->device()->width(), painter->device()->height());
+                if (deviceRect.contains(oldEffectRect) && deviceRect.contains(newEffectRect)) {
+                    sourced->setCachedOffset(newEffectRect.topLeft());
+                    unclipped = true;
+                }
+            }
+
             sourced->lastEffectTransform = painter->worldTransform();
-            sourced->invalidateCache(QGraphicsEffectSourcePrivate::TransformChanged);
+
+            if (!unclipped)
+                sourced->invalidateCache(QGraphicsEffectSourcePrivate::TransformChanged);
         }
 
@@ -4707 +4756 @@
                                  bool wasDirtyParentSceneTransform, bool drawItem)
 {
-    const bool itemIsFullyTransparent = (opacity < 0.0001);
+    const bool itemIsFullyTransparent = QGraphicsItemPrivate::isOpacityNull(opacity);
     const bool itemClipsChildrenToShape = (item->d_ptr->flags & QGraphicsItem::ItemClipsChildrenToShape);
     const bool itemHasChildren = !item->d_ptr->children.isEmpty();
@@ -4722 +4771 @@
             else
                 painter->setWorldTransform(*transformPtr);
-            painter->setClipPath(item->shape(), Qt::IntersectClip);
+            QRectF clipRect;
+            const QPainterPath clipPath(item->shape());
+            if (QPathClipper::pathToRect(clipPath, &clipRect))
+                painter->setClipRect(clipRect, Qt::IntersectClip);
+            else
+                painter->setClipPath(clipPath, Qt::IntersectClip);
         }
 
@@ -4758 +4812 @@
         }
 
-        if (itemClipsToShape)
-            painter->setClipPath(item->shape(), Qt::IntersectClip);
+        if (itemClipsToShape) {
+            QRectF clipRect;
+            const QPainterPath clipPath(item->shape());
+            if (QPathClipper::pathToRect(clipPath, &clipRect))
+                painter->setClipRect(clipRect, Qt::IntersectClip);
+            else
+                painter->setClipPath(clipPath, Qt::IntersectClip);
+        }
         painter->setOpacity(opacity);
 
@@ -4860 +4920 @@
         item->d_ptr->ignoreOpacity = 1;
 
-    QGraphicsItem *p = item->d_ptr->parent;
-    while (p) {
-        p->d_ptr->dirtyChildren = 1;
-#ifndef QT_NO_GRAPHICSEFFECT
-        if (p->d_ptr->graphicsEffect && p->d_ptr->graphicsEffect->isEnabled()) {
-            p->d_ptr->dirty = 1;
-            p->d_ptr->fullUpdatePending = 1;
-        }
-#endif //QT_NO_GRAPHICSEFFECT
-        p = p->d_ptr->parent;
-    }
+    item->d_ptr->markParentDirty();
 }
 
@@ -4945 +4995 @@
 
     const qreal opacity = item->d_ptr->combineOpacityFromParent(parentOpacity);
-    const bool itemIsFullyTransparent = !item->d_ptr->ignoreOpacity && opacity < 0.0001;
+    const bool itemIsFullyTransparent = !item->d_ptr->ignoreOpacity
+                                        && QGraphicsItemPrivate::isOpacityNull(opacity);
     if (itemIsFullyTransparent && (!itemHasChildren || item->d_ptr->childrenCombineOpacity())) {
         resetDirtyItem(item, /*recursive=*/itemHasChildren);
@@ -5118 +5169 @@
         d->_q_polishItems();
 
+    d->updateAll = false;
     QTransform viewTransform = painter->worldTransform();
     Q_UNUSED(options);