Changeset 769 for trunk/src/gui/graphicsview

Timestamp:

Aug 2, 2010, 9:27:30 PM (15 years ago)

Author:

Dmitry A. Kuminov

Message:

trunk: Merged in qt 4.6.3 sources from branches/vendor/nokia/qt.

Location:

trunk

Files:

• . (modified) (1 prop)
• src/gui/graphicsview/qgraphicsitem.cpp (modified) (23 diffs)
• src/gui/graphicsview/qgraphicsitem_p.h (modified) (2 diffs)
• src/gui/graphicsview/qgraphicsproxywidget.cpp (modified) (6 diffs)
• src/gui/graphicsview/qgraphicsproxywidget_p.h (modified) (2 diffs)
• src/gui/graphicsview/qgraphicsscene.cpp (modified) (15 diffs)
• src/gui/graphicsview/qgraphicsscene_p.h (modified) (1 diff)
• src/gui/graphicsview/qgraphicssceneevent.h (modified) (9 diffs)
• src/gui/graphicsview/qgraphicsview.cpp (modified) (5 diffs)
• src/gui/graphicsview/qgraphicsview_p.h (modified) (1 diff)
• src/gui/graphicsview/qgraphicswidget.cpp (modified) (8 diffs)
• src/gui/graphicsview/qgraphicswidget_p.cpp (modified) (1 diff)
• src/gui/graphicsview/qgraphicswidget_p.h (modified) (1 diff)

trunk/src/gui/graphicsview/qgraphicsitem.cpp

@@ -320 +320 @@
 
     \value ItemClipsToShape The item clips to its own shape. The item cannot
-    draw or receive mouse, tablet, drag and drop or hover events outside ts
+    draw or receive mouse, tablet, drag and drop or hover events outside its
     shape. It is disabled by default. This behavior is enforced by
     QGraphicsView::drawItems() or QGraphicsScene::drawItems(). This flag was
@@ -358 +358 @@
     this flag, the child will be stacked behind it. This flag is useful for
     drop shadow effects and for decoration objects that follow the parent
-    item's geometry without drawing on top of it.
+    item's geometry without drawing on top of it. This flag was introduced
+    in Qt 4.5.
 
     \value ItemUsesExtendedStyleOption The item makes use of either
-    \l{QStyleOptionGraphicsItem::}{exposedRect} or
-    \l{QStyleOptionGraphicsItem::}{matrix} in QStyleOptionGraphicsItem. By default,
-    the \l{QStyleOptionGraphicsItem::}{exposedRect} is initialized to the item's
-    boundingRect() and the \l{QStyleOptionGraphicsItem::}{matrix} is untransformed.
-    You can enable this flag for the style options to be set up with more
-    fine-grained values.
-    Note that QStyleOptionGraphicsItem::levelOfDetail is unaffected by this flag
+    \l{QStyleOptionGraphicsItem::} {exposedRect} or
+    \l{QStyleOptionGraphicsItem::} {matrix} in
+    QStyleOptionGraphicsItem. By default, the
+    \l{QStyleOptionGraphicsItem::} {exposedRect} is initialized to the
+    item's boundingRect() and the
+    \l{QStyleOptionGraphicsItem::}{matrix} is untransformed.  You can
+    enable this flag for the style options to be set up with more
+    fine-grained values.  Note that
+    QStyleOptionGraphicsItem::levelOfDetail is unaffected by this flag
     and always initialized to 1. Use
-    QStyleOptionGraphicsItem::levelOfDetailFromTransform() if you need a higher
-    value.
+    QStyleOptionGraphicsItem::levelOfDetailFromTransform() if you need
+    a higher value. This flag was introduced in Qt 4.6.
 
     \value ItemHasNoContents The item does not paint anything (i.e., calling
@@ -388 +391 @@
     This flag was introduced in Qt 4.6.
 
-    \value ItemNegativeZStacksBehindParent The item automatically stacks behind
-    it's parent if it's z-value is negative. This flag enables setZValue() to
-    toggle ItemStacksBehindParent.
+    \value ItemNegativeZStacksBehindParent The item automatically
+    stacks behind it's parent if it's z-value is negative. This flag
+    enables setZValue() to toggle ItemStacksBehindParent. This flag
+    was introduced in Qt 4.6.
 
     \value ItemIsPanel The item is a panel. A panel provides activation and
@@ -410 +414 @@
 /*!
     \enum QGraphicsItem::GraphicsItemChange
-
-        ItemVisibleHasChanged,
-        ItemEnabledHasChanged,
-        ItemSelectedHasChanged,
-        ItemParentHasChanged,
-        ItemSceneHasChanged
 
     This enum describes the state changes that are notified by
@@ -644 +642 @@
 
     The values are:
-    \value NonModal   The panel is not modal and does not block input to other panels.
-    \value PanelModal The panel is modal to a single item hierarchy and blocks input to its parent pane, all grandparent panels, and all siblings of its parent and grandparent panels.
-    \value SceneModal The window is modal to the entire scene and blocks input to all panels.
+
+    \value NonModal The panel is not modal and does not block input to
+    other panels. This is the default value for panels.
+
+    \value PanelModal The panel is modal to a single item hierarchy
+    and blocks input to its parent pane, all grandparent panels, and
+    all siblings of its parent and grandparent panels.
+
+    \value SceneModal The window is modal to the entire scene and
+    blocks input to all panels.
 
     \sa QGraphicsItem::setPanelModality(), QGraphicsItem::panelModality(), QGraphicsItem::ItemIsPanel
@@ -1126 +1131 @@
     }
 
+    // Resolve depth.
+    invalidateDepthRecursively();
+
     if ((parent = newParent)) {
         if (parent->d_func()->scene && parent->d_func()->scene != scene) {
@@ -1176 +1184 @@
     }
 
-    // Resolve depth.
-    invalidateDepthRecursively();
     dirtySceneTransform = 1;
 
@@ -1393 +1399 @@
     delete d_ptr->transformData;
 
-    qt_dataStore()->data.remove(this);
+    if (QGraphicsItemCustomDataStore *dataStore = qt_dataStore())
+        dataStore->data.remove(this);
 }
 
@@ -1571 +1578 @@
 
 /*!
-    Sets this item's parent item to \a parent. If this item already has a
-    parent, it is first removed from the previous parent. If \a parent is 0,
-    this item will become a top-level item.
-
-    Note that this implicitly adds this graphics item to the scene of
-    the parent. You should not \l{QGraphicsScene::addItem()}{add} the
-    item to the scene yourself.
-
-    Calling this function on an item that is an ancestor of \a parent have undefined behaviour.
-
-    \sa parentItem(), childItems()
+  Sets this item's parent item to \a newParent. If this item already
+  has a parent, it is first removed from the previous parent. If \a
+  newParent is 0, this item will become a top-level item.
+
+  Note that this implicitly adds this graphics item to the scene of
+  the parent. You should not \l{QGraphicsScene::addItem()}{add} the
+  item to the scene yourself.
+
+  Calling this function on an item that is an ancestor of \a newParent
+  have undefined behaviour.
+
+  \sa parentItem(), childItems()
 */
 void QGraphicsItem::setParentItem(QGraphicsItem *newParent)
@@ -1876 +1884 @@
     bool noVisualChange = (mode == NoCache && lastMode == NoCache)
                           || (mode == NoCache && lastMode == DeviceCoordinateCache)
-                          || (mode == DeviceCoordinateCache && lastMode == NoCache);
+                          || (mode == DeviceCoordinateCache && lastMode == NoCache)
+                          || (mode == DeviceCoordinateCache && lastMode == DeviceCoordinateCache);
     if (mode == NoCache) {
         d_ptr->removeExtraItemCache();
@@ -2170 +2179 @@
         if (c)
             c->purge();
-        if (scene)
+        if (scene) {
+#ifndef QT_NO_GRAPHICSEFFECT
+            invalidateParentGraphicsEffectsRecursively();
+#endif //QT_NO_GRAPHICSEFFECT
             scene->d_func()->markDirty(q_ptr, QRectF(), /*invalidateChildren=*/false, /*force=*/true);
+        }
     }
 
     // Certain properties are dropped as an item becomes invisible.
+    bool hasFocus = q_ptr->hasFocus();
     if (!newVisible) {
         if (scene) {
@@ -2184 +2198 @@
                 scene->d_func()->leaveModal(q_ptr);
         }
-        if (q_ptr->hasFocus() && scene) {
+        if (hasFocus && scene) {
             // Hiding the closest non-panel ancestor of the focus item
             QGraphicsItem *focusItem = scene->focusItem();
@@ -2197 +2211 @@
             }
             if (clear)
-                q_ptr->clearFocus();
+                clearFocusHelper(/* giveFocusToParent = */ false);
         }
         if (q_ptr->isSelected())
@@ -2235 +2249 @@
 
     // Enable subfocus
-    if (scene && newVisible) {
-        QGraphicsItem *p = parent;
-        bool done = false;
-        while (p) {
-            if (p->flags() & QGraphicsItem::ItemIsFocusScope) {
-                QGraphicsItem *fsi = p->d_ptr->focusScopeItem;
-                if (q_ptr == fsi || q_ptr->isAncestorOf(fsi)) {
-                    done = true;
-                    while (fsi->d_ptr->focusScopeItem && fsi->d_ptr->focusScopeItem->isVisible())
-                        fsi = fsi->d_ptr->focusScopeItem;
-                    scene->setFocusItem(fsi);
+    if (scene) {
+        if (newVisible) {
+            // Item is shown
+            QGraphicsItem *p = parent;
+            bool done = false;
+            while (p) {
+                if (p->flags() & QGraphicsItem::ItemIsFocusScope) {
+                    QGraphicsItem *fsi = p->d_ptr->focusScopeItem;
+                    if (q_ptr == fsi || q_ptr->isAncestorOf(fsi)) {
+                        done = true;
+                        while (fsi->d_ptr->focusScopeItem && fsi->d_ptr->focusScopeItem->isVisible())
+                            fsi = fsi->d_ptr->focusScopeItem;
+                        fsi->d_ptr->setFocusHelper(Qt::OtherFocusReason, /* climb = */ true,
+                                                   /* focusFromShow = */ true);
+                    }
+                    break;
                 }
-                break;
+                p = p->d_ptr->parent;
             }
-            p = p->d_ptr->parent;
-        }
-        if (!done) {
-            QGraphicsItem *fi = subFocusItem;
-            if (fi && fi != scene->focusItem()) {
-                scene->setFocusItem(fi);
+            if (!done) {
+                QGraphicsItem *fi = subFocusItem;
+                if (fi && fi != scene->focusItem()) {
+                    scene->setFocusItem(fi);
+                }
+            }
+        } else {
+            // Item is hidden
+            if (hasFocus) {
+                QGraphicsItem *p = parent;
+                while (p) {
+                    if (p->flags() & QGraphicsItem::ItemIsFocusScope) {
+                        if (p->d_ptr->visible) {
+                            p->d_ptr->setFocusHelper(Qt::OtherFocusReason, /* climb = */ true,
+                                                     /* focusFromShow = */ true);
+                        }
+                        break;
+                    }
+                    p = p->d_ptr->parent;
+                }
             }
         }
@@ -3105 +3138 @@
 void QGraphicsItem::setFocus(Qt::FocusReason focusReason)
 {
-    d_ptr->setFocusHelper(focusReason, /* climb = */ true);
+    d_ptr->setFocusHelper(focusReason, /* climb = */ true, /* focusFromShow = */ false);
 }
 
@@ -3111 +3144 @@
     \internal
 */
-void QGraphicsItemPrivate::setFocusHelper(Qt::FocusReason focusReason, bool climb)
+void QGraphicsItemPrivate::setFocusHelper(Qt::FocusReason focusReason, bool climb, bool focusFromShow)
 {
     // Disabled / unfocusable items cannot accept focus.
@@ -3131 +3164 @@
         if (p->flags() & QGraphicsItem::ItemIsFocusScope) {
             p->d_ptr->focusScopeItem = q_ptr;
-            if (!p->focusItem()) {
+            if (!p->focusItem() && !focusFromShow) {
                 // If you call setFocus on a child of a focus scope that
                 // doesn't currently have a focus item, then stop.
@@ -3172 +3205 @@
 void QGraphicsItem::clearFocus()
 {
-    // Pass focus to the closest parent focus scope.
-    if (!d_ptr->inDestructor) {
-        QGraphicsItem *p = d_ptr->parent;
-        while (p) {
-            if (p->flags() & ItemIsFocusScope) {
-                p->d_ptr->setFocusHelper(Qt::OtherFocusReason, /* climb = */ false);
-                return;
+    d_ptr->clearFocusHelper(/* giveFocusToParent = */ true);
+}
+
+/*!
+    \internal
+*/
+void QGraphicsItemPrivate::clearFocusHelper(bool giveFocusToParent)
+{
+    if (giveFocusToParent) {
+        // Pass focus to the closest parent focus scope
+        if (!inDestructor) {
+            QGraphicsItem *p = parent;
+            while (p) {
+                if (p->flags() & QGraphicsItem::ItemIsFocusScope) {
+                    p->d_ptr->setFocusHelper(Qt::OtherFocusReason, /* climb = */ false,
+                                             /* focusFromShow = */ false);
+                    return;
+                }
+                p = p->d_ptr->parent;
             }
-            p = p->d_ptr->parent;
         }
     }
 
     // Invisible items with focus must explicitly clear subfocus.
-    d_ptr->clearSubFocus(this);
-
-    if (hasFocus()) {
+    clearSubFocus(q_ptr);
+
+    if (q_ptr->hasFocus()) {
         // If this item has the scene's input focus, clear it.
-        d_ptr->scene->setFocusItem(0);
+        scene->setFocusItem(0);
     }
 }
@@ -3535 +3579 @@
     if (!(d_ptr->flags & ItemSendsGeometryChanges)) {
         d_ptr->setPosHelper(pos);
+        if (d_ptr->isWidget)
+            static_cast<QGraphicsWidget *>(this)->d_func()->setGeometryFromSetPos();
         return;
     }
@@ -7257 +7303 @@
         QGraphicsScenePrivate *scenePrivate = d_ptr->scene->d_func();
         scenePrivate->index->prepareBoundingRectChange(this);
-        scenePrivate->markDirty(this, QRectF(), /*invalidateChildren=*/true);
+        scenePrivate->markDirty(this, QRectF(), /*invalidateChildren=*/true, /*force=*/false,
+                                /*ignoreOpacity=*/ false, /*removingItemFromScene=*/ false,
+                                /*updateBoundingRect=*/true);
 
         // For compatibility reasons, we have to update the item's old geometry
@@ -10802 +10850 @@
 }
 
+// sourceRect must be in the given coordinate system
 QRect QGraphicsItemEffectSourcePrivate::paddedEffectRect(Qt::CoordinateSystem system, QGraphicsEffect::PixmapPadMode mode, const QRectF &sourceRect, bool *unpadded) const
 {
@@ -10811 +10860 @@
     if (mode == QGraphicsEffect::PadToEffectiveBoundingRect) {
         if (info) {
-            effectRectF = item->graphicsEffect()->boundingRectFor(boundingRect(Qt::DeviceCoordinates));
+            QRectF deviceRect = system == Qt::DeviceCoordinates ? sourceRect : info->painter->worldTransform().mapRect(sourceRect);
+            effectRectF = item->graphicsEffect()->boundingRectFor(deviceRect);
             if (unpadded)
                 *unpadded = (effectRectF.size() == sourceRect.size());
@@ -10860 +10910 @@
     }
 
-    if (deviceCoordinates) {
-        // Clip to viewport rect.
-        int left, top, right, bottom;
-        effectRect.getCoords(&left, &top, &right, &bottom);
-        if (left < 0) {
-            if (offset)
-                offset->rx() += -left;
-            effectRect.setX(0);
-        }
-        if (top < 0) {
-            if (offset)
-                offset->ry() += -top;
-            effectRect.setY(0);
-        }
-        // NB! We use +-1 for historical reasons (see QRect documentation).
-        QPaintDevice *device = info->painter->device();
-        const int deviceWidth = device->width();
-        const int deviceHeight = device->height();
-        if (right + 1 > deviceWidth)
-            effectRect.setRight(deviceWidth - 1);
-        if (bottom + 1 > deviceHeight)
-            effectRect.setBottom(deviceHeight -1);
-
-    }
     if (effectRect.isEmpty())
         return QPixmap();

trunk/src/gui/graphicsview/qgraphicsitem_p.h

@@ -415 +415 @@
     inline void markParentDirty(bool updateBoundingRect = false);
 
-    void setFocusHelper(Qt::FocusReason focusReason, bool climb);
+    void setFocusHelper(Qt::FocusReason focusReason, bool climb, bool focusFromShow);
+    void clearFocusHelper(bool giveFocusToParent);
     void setSubFocus(QGraphicsItem *rootItem = 0);
     void clearSubFocus(QGraphicsItem *rootItem = 0);
@@ -769 +770 @@
 {
     QGraphicsItemPrivate *parentp = this;
+#ifndef QT_NO_GRAPHICSEFFECT
+    if (updateBoundingRect && parentp->graphicsEffect && !parentp->inSetPosHelper) {
+        parentp->notifyInvalidated = 1;
+        static_cast<QGraphicsItemEffectSourcePrivate *>(parentp->graphicsEffect->d_func()
+                                                        ->source->d_func())->invalidateCache();
+    }
+#endif
     while (parentp->parent) {
         parentp = parentp->parent->d_ptr.data();

trunk/src/gui/graphicsview/qgraphicsproxywidget.cpp

@@ -190 +190 @@
 
 extern bool qt_sendSpontaneousEvent(QObject *, QEvent *);
-extern bool qt_tab_all_widgets;
+Q_GUI_EXPORT extern bool qt_tab_all_widgets;
 
 /*!
@@ -898 +898 @@
         break;
     }
+#ifndef QT_NO_TOOLTIP
+    case QEvent::GraphicsSceneHelp: {
+        // Propagate the help event (for tooltip) to the widget under mouse
+        if (d->lastWidgetUnderMouse) {
+            QGraphicsSceneHelpEvent *he = static_cast<QGraphicsSceneHelpEvent *>(event);
+            QPoint pos = d->mapToReceiver(mapFromScene(he->scenePos()), d->lastWidgetUnderMouse).toPoint();
+            QHelpEvent e(QEvent::ToolTip, pos, he->screenPos());
+            QApplication::sendEvent(d->lastWidgetUnderMouse, &e);
+            event->setAccepted(e.isAccepted());
+            return e.isAccepted();
+        }
+        break;
+    }
+    case QEvent::ToolTipChange: {
+        // Propagate tooltip change to the widget
+        if (!d->tooltipChangeMode) {
+            d->tooltipChangeMode = QGraphicsProxyWidgetPrivate::ProxyToWidgetMode;
+            d->widget->setToolTip(toolTip());
+            d->tooltipChangeMode = QGraphicsProxyWidgetPrivate::NoMode;
+        }
+        break;
+    }
+#endif
     default:
         break;
@@ -953 +976 @@
             }
             break;
+        case QEvent::ToolTipChange:
+            // Propagate tooltip change to the proxy.
+            if (!d->tooltipChangeMode) {
+                d->tooltipChangeMode = QGraphicsProxyWidgetPrivate::WidgetToProxyMode;
+                setToolTip(d->widget->toolTip());
+                d->tooltipChangeMode = QGraphicsProxyWidgetPrivate::NoMode;
+            }
+            break;
         default:
             break;
@@ -1316 +1347 @@
     }
 
+    d->proxyIsGivingFocus = true;
+
     switch (event->reason()) {
     case Qt::TabFocusReason: {
@@ -1329 +1362 @@
         if (d->widget && d->widget->focusWidget()) {
             d->widget->focusWidget()->setFocus(event->reason());
-            return;
-        }
-        break;
-    }
+        }
+        break;
+    }
+
+    d->proxyIsGivingFocus = false;
 }
 
@@ -1433 +1467 @@
 
     // Filter out repaints on the window frame.
-    const QRect exposedWidgetRect = (option->exposedRect & rect()).toRect();
+    const QRect exposedWidgetRect = (option->exposedRect & rect()).toAlignedRect();
     if (exposedWidgetRect.isEmpty())
         return;

trunk/src/gui/graphicsview/qgraphicsproxywidget_p.h

@@ -73 +73 @@
           styleChangeMode(NoMode),
           paletteChangeMode(NoMode),
+          tooltipChangeMode(NoMode),
           focusFromWidgetToProxy(0)
     { }
@@ -118 +119 @@
     quint32 styleChangeMode : 2;
     quint32 paletteChangeMode : 2;
+    quint32 tooltipChangeMode : 2;
     quint32 focusFromWidgetToProxy : 1;
+    quint32 proxyIsGivingFocus : 1;
 };
 

trunk/src/gui/graphicsview/qgraphicsscene.cpp

@@ -694 +694 @@
     if (!selectionChanging && selectedItems.size() != oldSelectedItemsSize)
         emit q->selectionChanged();
+
+    QHash<QGesture *, QGraphicsObject *>::iterator it;
+    for (it = gestureTargets.begin(); it != gestureTargets.end();) {
+        if (it.value() == item)
+            it = gestureTargets.erase(it);
+        else
+            ++it;
+    }
 }
 
@@ -802 +810 @@
             if (item) {
                 for (int i = 0; i < views.size(); ++i)
-                    views.at(i)->inputContext()->reset();
+                    if (views.at(i)->inputContext())
+                        views.at(i)->inputContext()->reset();
             }
         }
@@ -808 +817 @@
     }
 
+    if (item)
+        focusItem = item;
+    updateInputMethodSensitivityInViews();
     if (item) {
-        focusItem = item;
         QFocusEvent event(QEvent::FocusIn, focusReason);
         sendEvent(item, &event);
     }
-
-    updateInputMethodSensitivityInViews();
 }
 
@@ -3772 +3781 @@
     for (int i = 0; i < itemsAtPos.size(); ++i) {
         QGraphicsItem *tmp = itemsAtPos.at(i);
+        if (tmp->d_func()->isProxyWidget()) {
+            // if the item is a proxy widget, the event is forwarded to it
+            sendEvent(tmp, helpEvent);
+            if (helpEvent->isAccepted())
+                return;
+        }
         if (!tmp->toolTip().isEmpty()) {
             toolTipItem = tmp;
@@ -4285 +4300 @@
         // Blit the subpixmap into the main pixmap.
         pixmapPainter.begin(pix);
+        pixmapPainter.setCompositionMode(QPainter::CompositionMode_Source);
         pixmapPainter.setClipRegion(pixmapExposed);
         pixmapPainter.drawPixmap(br.topLeft(), subPix);
@@ -4450 +4466 @@
 
         // Create or reuse offscreen pixmap, possibly scroll/blit from the old one.
+        // If the world transform is rotated we always recreate the cache to avoid
+        // wrong blending.
         bool pixModified = false;
         QGraphicsItemCache::DeviceData *deviceData = &itemCache->deviceData[widget];
@@ -4457 +4475 @@
             diff *= painter->worldTransform();
         deviceData->lastTransform = painter->worldTransform();
-        if (!invertable || diff.type() > QTransform::TxTranslate) {
+        if (!invertable
+            || diff.type() > QTransform::TxTranslate
+            || painter->worldTransform().type() > QTransform::TxScale) {
             pixModified = true;
             itemCache->allExposed = true;
@@ -4679 +4699 @@
             item->d_ptr->paintedViewBoundingRects.insert(widget, viewBoundingRect);
         viewBoundingRect.adjust(-1, -1, 1, 1);
-        drawItem = exposedRegion ? exposedRegion->intersects(viewBoundingRect) : !viewBoundingRect.isEmpty();
+        drawItem = exposedRegion ? exposedRegion->intersects(viewBoundingRect)
+                                 : !viewBoundingRect.normalized().isEmpty();
         if (!drawItem) {
             if (!itemHasChildren)
@@ -4713 +4734 @@
             && 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;
-                }
+                QRectF sourceRect = sourced->boundingRect(Qt::DeviceCoordinates);
+                QRect effectRect = sourced->paddedEffectRect(Qt::DeviceCoordinates, sourced->currentCachedMode(), sourceRect);
+
+                sourced->setCachedOffset(effectRect.topLeft());
+            } else {
+                sourced->invalidateCache(QGraphicsEffectSourcePrivate::TransformChanged);
             }
 
             sourced->lastEffectTransform = painter->worldTransform();
-
-            if (!unclipped)
-                sourced->invalidateCache(QGraphicsEffectSourcePrivate::TransformChanged);
         }
 
@@ -4849 +4857 @@
 
 void QGraphicsScenePrivate::markDirty(QGraphicsItem *item, const QRectF &rect, bool invalidateChildren,
-                                      bool force, bool ignoreOpacity, bool removingItemFromScene)
+                                      bool force, bool ignoreOpacity, bool removingItemFromScene,
+                                      bool updateBoundingRect)
 {
     Q_ASSERT(item);
@@ -4920 +4929 @@
         item->d_ptr->ignoreOpacity = 1;
 
-    item->d_ptr->markParentDirty();
+    if (!updateBoundingRect)
+        item->d_ptr->markParentDirty();
 }
 
@@ -5131 +5141 @@
 
 /*!
+    \obsolete
+
     Paints the given \a items using the provided \a painter, after the
     background has been drawn, and before the foreground has been
@@ -5153 +5165 @@
     \snippet doc/src/snippets/graphicssceneadditemsnippet.cpp 0
 
-    \obsolete Since Qt 4.6, this function is not called anymore unless
+    Since Qt 4.6, this function is not called anymore unless
     the QGraphicsView::IndirectPainting flag is given as an Optimization
     flag.
@@ -5709 +5721 @@
             bool res = sendTouchBeginEvent(item, &touchEvent)
                        && touchEvent.isAccepted();
-            if (!res)
+            if (!res) {
+                // forget about these touch points, we didn't handle them
+                for (int i = 0; i < touchEvent.touchPoints().count(); ++i) {
+                    const QTouchEvent::TouchPoint &touchPoint = touchEvent.touchPoints().at(i);
+                    itemForTouchPointId.remove(touchPoint.id());
+                    sceneCurrentTouchPoints.remove(touchPoint.id());
+                }
                 ignoreSceneTouchEvent = false;
+            }
             break;
         }
@@ -5901 +5920 @@
             QList<QGraphicsObject *> result;
             for (int j = 0; j < items.size(); ++j) {
-                QGraphicsObject *item = items.at(j)->toGraphicsObject();
-                if (!item)
-                    continue;
-                QGraphicsItemPrivate *d = item->QGraphicsItem::d_func();
-                if (d->gestureContext.contains(gestureType)) {
-                    result.append(item);
+                QGraphicsItem *item = items.at(j);
+
+                // Check if the item is blocked by a modal panel and use it as
+                // a target instead of this item.
+                (void) item->isBlockedByModalPanel(&item);
+
+                if (QGraphicsObject *itemobj = item->toGraphicsObject()) {
+                    QGraphicsItemPrivate *d = item->d_func();
+                    if (d->gestureContext.contains(gestureType)) {
+                        result.append(itemobj);
+                    }
                 }
+                // Don't propagate through panels.
+                if (item->isPanel())
+                    break;
             }
             DEBUG() << "QGraphicsScenePrivate::getGestureTargets:"

trunk/src/gui/graphicsview/qgraphicsscene_p.h

@@ -223 +223 @@
 
     void markDirty(QGraphicsItem *item, const QRectF &rect = QRectF(), bool invalidateChildren = false,
-                   bool force = false, bool ignoreOpacity = false, bool removingItemFromScene = false);
+                   bool force = false, bool ignoreOpacity = false, bool removingItemFromScene = false,
+                   bool updateBoundingRect = false);
     void processDirtyItemsRecursive(QGraphicsItem *item, bool dirtyAncestorContainsChildren = false,
                                     qreal parentOpacity = qreal(1.0));

trunk/src/gui/graphicsview/qgraphicssceneevent.h

@@ -78 +78 @@
     QScopedPointer<QGraphicsSceneEventPrivate> d_ptr;
     Q_DECLARE_PRIVATE(QGraphicsSceneEvent)
+private:
+    Q_DISABLE_COPY(QGraphicsSceneEvent)
 };
 
@@ -125 +127 @@
 private:
     Q_DECLARE_PRIVATE(QGraphicsSceneMouseEvent)
+    Q_DISABLE_COPY(QGraphicsSceneMouseEvent)
 };
 
@@ -157 +160 @@
 private:
     Q_DECLARE_PRIVATE(QGraphicsSceneWheelEvent)
+    Q_DISABLE_COPY(QGraphicsSceneWheelEvent)
 };
 
@@ -185 +189 @@
 private:
     Q_DECLARE_PRIVATE(QGraphicsSceneContextMenuEvent)
+    Q_DISABLE_COPY(QGraphicsSceneContextMenuEvent)
 };
 
@@ -217 +222 @@
 private:
     Q_DECLARE_PRIVATE(QGraphicsSceneHoverEvent)
+    Q_DISABLE_COPY(QGraphicsSceneHoverEvent)
 };
 
@@ -234 +240 @@
 private:
     Q_DECLARE_PRIVATE(QGraphicsSceneHelpEvent)
+    Q_DISABLE_COPY(QGraphicsSceneHelpEvent)
 };
 
@@ -276 +283 @@
 private:
     Q_DECLARE_PRIVATE(QGraphicsSceneDragDropEvent)
+    Q_DISABLE_COPY(QGraphicsSceneDragDropEvent)
 };
 
@@ -282 +290 @@
 {
     Q_DECLARE_PRIVATE(QGraphicsSceneResizeEvent)
+    Q_DISABLE_COPY(QGraphicsSceneResizeEvent)
 public:
     QGraphicsSceneResizeEvent();
@@ -297 +306 @@
 {
     Q_DECLARE_PRIVATE(QGraphicsSceneMoveEvent)
+    Q_DISABLE_COPY(QGraphicsSceneMoveEvent)
 public:
     QGraphicsSceneMoveEvent();

trunk/src/gui/graphicsview/qgraphicsview.cpp

@@ -3361 +3361 @@
             if (viewTransformed)
                 backgroundPainter.setTransform(viewTransform);
-#ifdef Q_WS_X11
-#undef X11
-            if (backgroundPainter.paintEngine()->type() != QPaintEngine::X11)
-#define X11 qt_x11Data
-#endif
-                backgroundPainter.setCompositionMode(QPainter::CompositionMode_Source);
             QRectF backgroundExposedSceneRect = mapToScene(d->backgroundPixmapExposed.boundingRect()).boundingRect();
             drawBackground(&backgroundPainter, backgroundExposedSceneRect);
@@ -3401 +3395 @@
             painter.setWorldTransform(viewTransform);
     } else {
+        // Make sure we don't have unpolished items before we draw
+        if (!d->scene->d_func()->unpolishedItems.isEmpty())
+            d->scene->d_func()->_q_polishItems();
+        // We reset updateAll here (after we've issued polish events)
+        // so that we can discard update requests coming from polishEvent().
+        d->scene->d_func()->updateAll = false;
+
         // Find all exposed items
         bool allItems = false;
@@ -3409 +3410 @@
             QGraphicsItem **itemArray = &itemList[0]; // Relies on QList internals, but is perfectly valid.
             QStyleOptionGraphicsItem *styleOptionArray = d->allocStyleOptionsArray(numItems);
+            QTransform transform(Qt::Uninitialized);
             for (int i = 0; i < numItems; ++i) {
-                itemArray[i]->d_ptr->initStyleOption(&styleOptionArray[i], viewTransform,
-                                                     d->exposedRegion, allItems);
+                QGraphicsItem *item = itemArray[i];
+                QGraphicsItemPrivate *itemd = item->d_ptr.data();
+                itemd->initStyleOption(&styleOptionArray[i], viewTransform, d->exposedRegion, allItems);
+                // Cache the item's area in view coordinates.
+                // Note that we have to do this here in case the base class implementation
+                // (QGraphicsScene::drawItems) is not called. If it is, we'll do this
+                // operation twice, but that's the price one has to pay for using indirect
+                // painting :-/.
+                const QRectF brect = adjustedItemEffectiveBoundingRect(item);
+                if (!itemd->itemIsUntransformable()) {
+                    transform = item->sceneTransform();
+                    if (viewTransformed)
+                        transform *= viewTransform;
+                } else {
+                    transform = item->deviceTransform(viewTransform);
+                }
+                itemd->paintedViewBoundingRects.insert(d->viewport, transform.mapRect(brect).toRect());
             }
             // Draw the items.
@@ -3610 +3627 @@
 
 /*!
+    \obsolete 
+
     Draws the items \a items in the scene using \a painter, after the
     background and before the foreground are drawn. \a numItems is the number
@@ -3618 +3637 @@
     The default implementation calls the scene's drawItems() function.
 
-    \obsolete Since Qt 4.6, this function is not called anymore unless
+    Since Qt 4.6, this function is not called anymore unless
     the QGraphicsView::IndirectPainting flag is given as an Optimization
     flag.

trunk/src/gui/graphicsview/qgraphicsview_p.h

@@ -184 +184 @@
             QCoreApplication::sendPostedEvents(viewport->window(), QEvent::UpdateRequest);
 #else
-        QCoreApplication::processEvents(QEventLoop::AllEvents | QEventLoop::ExcludeSocketNotifiers
-                                        | QEventLoop::ExcludeUserInputEvents);
+        // At this point either HIViewSetNeedsDisplay (Carbon) or setNeedsDisplay: YES (Cocoa)
+        // is called, which means there's a pending update request. We want to dispatch it
+        // now because otherwise graphics view updates would require two
+        // round-trips in the event loop before the item is painted.
+        extern void qt_mac_dispatchPendingUpdateRequests(QWidget *);
+        qt_mac_dispatchPendingUpdateRequests(viewport->window());
 #endif
     }

trunk/src/gui/graphicsview/qgraphicswidget.cpp

@@ -335 +335 @@
     a move event and a resize event. Also, if the widget has a layout
     assigned, the layout will activate.
-    
+
     \sa geometry(), resize()
 */
@@ -563 +563 @@
 {
     Q_D(QGraphicsWidget);
-    if ((d->windowFlags & Qt::Window) && (d->windowFlags & Qt::WindowType_Mask) != Qt::Popup && 
+    if ((d->windowFlags & Qt::Window) && (d->windowFlags & Qt::WindowType_Mask) != Qt::Popup &&
          (d->windowFlags & Qt::WindowType_Mask) != Qt::ToolTip && !(d->windowFlags & Qt::FramelessWindowHint)) {
         QStyleOptionTitleBar bar;
@@ -1045 +1045 @@
         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 ;
-        }
+        d->setGeometryFromSetPos();
         break;
     case ItemParentChange: {
@@ -1068 +1062 @@
         break;
     }
-    case ItemCursorChange: {
+    case ItemCursorHasChanged: {
         // Deliver CursorChange.
         QEvent event(QEvent::CursorChange);
@@ -1074 +1068 @@
         break;
     }
-    case ItemToolTipChange: {
+    case ItemToolTipHasChanged: {
         // Deliver ToolTipChange.
         QEvent event(QEvent::ToolTipChange);
@@ -1140 +1134 @@
     Returns true if \a event has been recognized and processed; otherwise,
     returns false.
-    
+
     \sa event()
 */
@@ -1197 +1191 @@
     if (!r.contains(pos))
         return Qt::NoSection;
-    
+
     const qreal left = r.left();
     const qreal top = r.top();
@@ -2323 +2317 @@
 
 QT_END_NAMESPACE
-        
+
 #endif //QT_NO_GRAPHICSVIEW

trunk/src/gui/graphicsview/qgraphicswidget_p.cpp

@@ -826 +826 @@
 }
 
+void QGraphicsWidgetPrivate::setGeometryFromSetPos()
+{
+    if (inSetGeometry)
+        return;
+    Q_Q(QGraphicsWidget);
+    inSetPos = 1;
+    // Ensure setGeometry is called (avoid recursion when setPos is
+    // called from within setGeometry).
+    q->setGeometry(QRectF(pos, q->size()));
+    inSetPos = 0 ;
+}
+
 QT_END_NAMESPACE
 

trunk/src/gui/graphicsview/qgraphicswidget_p.h

@@ -130 +130 @@
     void windowFrameHoverLeaveEvent(QGraphicsSceneHoverEvent *event);
     bool hasDecoration() const;
+
+    void setGeometryFromSetPos();
 
     // State