FCL/sf/mw/qt: comparison src/gui/graphicsview/qgraphicsitem.cpp

equal deleted inserted replaced

-:41300fa6a67c
+:f7bc934e204c
 /****************************************************************************
 **
-** 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)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
 **
 \sa QGraphicsScene, QGraphicsView, {The Graphics View Framework}
 */
 /*!
+\variable QGraphicsItem::Type
+The type value returned by the virtual type() function in standard
+graphics item classes in Qt. All such standard graphics item
+classes in Qt are associated with a unique value for Type,
+e.g. the value returned by QGraphicsPathItem::type() is 2.
+\snippet doc/src/snippets/code/src_gui_graphicsview_qgraphicsitem.cpp 18
+*/
+/*!
 \variable QGraphicsItem::UserType
 The lowest permitted type value for custom items (subclasses
 of QGraphicsItem or any of the standard items). This value is
 used in conjunction with a reimplementation of QGraphicsItem::type()
 and declaring a Type enum value. Example:
 \snippet doc/src/snippets/code/src_gui_graphicsview_qgraphicsitem.cpp 1
+\note UserType = 65536
 */
 /*!
 \enum QGraphicsItem::GraphicsItemFlag
 an input item). Enabling this flag will allow the item to accept focus,
 which again allows the delivery of key events to
 QGraphicsItem::keyPressEvent() and QGraphicsItem::keyReleaseEvent().
 \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
 introduced in Qt 4.3.
 \value ItemClipsChildrenToShape The item clips the painting of all its
 \value ItemStacksBehindParent The item is stacked behind its parent. By
 default, child items are stacked on top of the parent item. But setting
 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::} {exposedRect} or
-\l{QStyleOptionGraphicsItem::}{matrix} in QStyleOptionGraphicsItem. By default,
+\l{QStyleOptionGraphicsItem::} {matrix} in
-the \l{QStyleOptionGraphicsItem::}{exposedRect} is initialized to the item's
+QStyleOptionGraphicsItem. By default, the
-boundingRect() and the \l{QStyleOptionGraphicsItem::}{matrix} is untransformed.
+\l{QStyleOptionGraphicsItem::} {exposedRect} is initialized to the
-You can enable this flag for the style options to be set up with more
+item's boundingRect() and the
-fine-grained values.
+\l{QStyleOptionGraphicsItem::}{matrix} is untransformed.  You can
-Note that QStyleOptionGraphicsItem::levelOfDetail is unaffected by this flag
+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
+QStyleOptionGraphicsItem::levelOfDetailFromTransform() if you need
-value.
+a higher value. This flag was introduced in Qt 4.6.
 \value ItemHasNoContents The item does not paint anything (i.e., calling
 paint() on the item has no effect). You should set this flag on items that
 do not need to be painted to ensure that Graphics View avoids unnecessary
 painting preparations. This flag was introduced in Qt 4.6.
 \value ItemAcceptsInputMethod The item supports input methods typically
 used for Asian languages.
 This flag was introduced in Qt 4.6.
-\value ItemNegativeZStacksBehindParent The item automatically stacks behind
+\value ItemNegativeZStacksBehindParent The item automatically
-it's parent if it's z-value is negative. This flag enables setZValue() to
+stacks behind it's parent if it's z-value is negative. This flag
-toggle ItemStacksBehindParent.
+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
 contained focus handling. Only one panel can be active at a time (see
 QGraphicsItem::isActive()). When no panel is active, QGraphicsScene
 activates all non-panel items. Window items (i.e.,
 introduced in Qt 4.6.
 */
 /*!
 \enum QGraphicsItem::GraphicsItemChange
-ItemVisibleHasChanged,
-ItemEnabledHasChanged,
-ItemSelectedHasChanged,
-ItemParentHasChanged,
-ItemSceneHasChanged
 This enum describes the state changes that are notified by
 QGraphicsItem::itemChange(). The notifications are sent as the state
 changes, and in some cases, adjustments can be made (see the documentation
 for each change for details).
 This enum specifies the behavior of a modal panel. A modal panel
 is one that blocks input to other panels. Note that items that
 are children of a modal panel are not blocked.
 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 NonModal The panel is not modal and does not block input to
-\value SceneModal The window is modal to the entire scene and blocks input to all panels.
+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
 */
 #include "qgraphicsitem.h"
 || (int(childFlag) == -1 && handlesChildEvents)
 || (int(childFlag) == -2 && filtersDescendantEvents))
 return;
 }
-foreach (QGraphicsItem *child, children)
+for (int i = 0; i < children.size(); ++i)
-child->d_ptr->updateAncestorFlag(childFlag, flag, enabled, false);
+children.at(i)->d_ptr->updateAncestorFlag(childFlag, flag, enabled, false);
+}
+void QGraphicsItemPrivate::updateAncestorFlags()
+{
+int flags = 0;
+if (parent) {
+// Inherit the parent's ancestor flags.
+QGraphicsItemPrivate *pd = parent->d_ptr.data();
+flags = pd->ancestorFlags;
+// Add in flags from the parent.
+if (pd->filtersDescendantEvents)
+flags |= AncestorFiltersChildEvents;
+if (pd->handlesChildEvents)
+flags |= AncestorHandlesChildEvents;
+if (pd->flags & QGraphicsItem::ItemClipsChildrenToShape)
+flags |= AncestorClipsChildren;
+if (pd->flags & QGraphicsItem::ItemIgnoresTransformations)
+flags |= AncestorIgnoresTransformations;
+}
+if (ancestorFlags == flags)
+return; // No change; stop propagation.
+ancestorFlags = flags;
+// Propagate to children recursively.
+for (int i = 0; i < children.size(); ++i)
+children.at(i)->d_ptr->updateAncestorFlags();
 }
 /*!
 \internal
 Make sure not to trigger any pure virtual function calls (e.g.,
 prepareGeometryChange) if the item is in its destructor, i.e.
 inDestructor is 1.
 */
-void QGraphicsItemPrivate::setParentItemHelper(QGraphicsItem *newParent)
+void QGraphicsItemPrivate::setParentItemHelper(QGraphicsItem *newParent, const QVariant *newParentVariant,
+const QVariant *thisPointerVariant)
 {
 Q_Q(QGraphicsItem);
-if (newParent == q) {
-qWarning("QGraphicsItem::setParentItem: cannot assign %p as a parent of itself", this);
-return;
-}
 if (newParent == parent)
 return;
-const QVariant newParentVariant(q->itemChange(QGraphicsItem::ItemParentChange,
-qVariantFromValue<QGraphicsItem *>(newParent)));
-newParent = qVariantValue<QGraphicsItem *>(newParentVariant);
-if (newParent == parent)
-return;
 if (scene) {
 // Deliver the change to the index
-scene->d_func()->index->itemChange(q, QGraphicsItem::ItemParentChange, newParentVariant);
+if (scene->d_func()->indexMethod != QGraphicsScene::NoIndex)
+scene->d_func()->index->itemChange(q, QGraphicsItem::ItemParentChange, newParent);
 // Disable scene pos notifications for old ancestors
 if (scenePosDescendants || (flags & QGraphicsItem::ItemSendsScenePositionChanges))
 scene->d_func()->setScenePosItemEnabled(q, false);
 }
 // removed from the index at a later stage, and the whole scene will be
 // updated.
 if (!inDestructor)
 q_ptr->prepareGeometryChange();
-const QVariant thisPointerVariant(qVariantFromValue<QGraphicsItem *>(q));
 if (parent) {
 // Remove from current parent
 parent->d_ptr->removeChild(q);
-parent->itemChange(QGraphicsItem::ItemChildRemovedChange, thisPointerVariant);
+if (thisPointerVariant)
+parent->itemChange(QGraphicsItem::ItemChildRemovedChange, *thisPointerVariant);
 }
 // Update toplevelitem list. If this item is being deleted, its parent
 // will be 0 but we don't want to register/unregister it in the TLI list.
 if (scene && !inDestructor) {
 // Ensure any last parent focus scope does not point to this item or any of
 // its descendents.
 QGraphicsItem *p = parent;
 QGraphicsItem *parentFocusScopeItem = 0;
 while (p) {
-if (p->flags() & QGraphicsItem::ItemIsFocusScope) {
+if (p->d_ptr->flags & QGraphicsItem::ItemIsFocusScope) {
 // If this item's focus scope's focus scope item points
 // to this item or a descendent, then clear it.
 QGraphicsItem *fsi = p->d_ptr->focusScopeItem;
 if (q_ptr == fsi || q_ptr->isAncestorOf(fsi)) {
 parentFocusScopeItem = fsi;
 break;
 }
 p = p->d_ptr->parent;
 }
+// Update graphics effect optimization flag
+if (newParent && (graphicsEffect || mayHaveChildWithGraphicsEffect))
+newParent->d_ptr->updateChildWithGraphicsEffectFlagRecursively();
 // Update focus scope item ptr in new scope.
 QGraphicsItem *newFocusScopeItem = subFocusItem ? subFocusItem : parentFocusScopeItem;
 if (newFocusScopeItem && newParent) {
 if (subFocusItem) {
 // Find the subFocusItem's topmost focus scope.
 QGraphicsItem *ancestorScope = 0;
 QGraphicsItem *p = subFocusItem->d_ptr->parent;
 while (p) {
-if (p->flags() & QGraphicsItem::ItemIsFocusScope)
+if (p->d_ptr->flags & QGraphicsItem::ItemIsFocusScope)
 ancestorScope = p;
-if (p->isPanel())
+if (p->d_ptr->flags & QGraphicsItem::ItemIsPanel)
 break;
-p = p->parentItem();
+p = p->d_ptr->parent;
 }
 if (ancestorScope)
 newFocusScopeItem = ancestorScope;
 }
 QGraphicsItem *p = newParent;
 while (p) {
-if (p->flags() & QGraphicsItem::ItemIsFocusScope) {
+if (p->d_ptr->flags & QGraphicsItem::ItemIsFocusScope) {
 p->d_ptr->focusScopeItem = newFocusScopeItem;
 // Ensure the new item is no longer the subFocusItem. The
 // only way to set focus on a child of a focus scope is
 // by setting focus on the scope itself.
 if (subFocusItem && !p->focusItem())
 }
 p = p->d_ptr->parent;
 }
 }
+// Resolve depth.
+invalidateDepthRecursively();
 if ((parent = newParent)) {
-bool implicitUpdate = false;
 if (parent->d_func()->scene && parent->d_func()->scene != scene) {
 // Move this item to its new parent's scene
 parent->d_func()->scene->addItem(q);
-implicitUpdate = true;
 } else if (!parent->d_func()->scene && scene) {
 // Remove this item from its former scene
 scene->removeItem(q);
 }
 parent->d_ptr->addChild(q);
-parent->itemChange(QGraphicsItem::ItemChildAddedChange, thisPointerVariant);
+if (thisPointerVariant)
+parent->itemChange(QGraphicsItem::ItemChildAddedChange, *thisPointerVariant);
 if (scene) {
-if (!implicitUpdate)
-scene->d_func()->markDirty(q_ptr);
 // Re-enable scene pos notifications for new ancestors
 if (scenePosDescendants || (flags & QGraphicsItem::ItemSendsScenePositionChanges))
 scene->d_func()->setScenePosItemEnabled(q, true);
 }
+// Propagate dirty flags to the new parent
+markParentDirty(/*updateBoundingRect=*/true);
 // Inherit ancestor flags from the new parent.
-updateAncestorFlag(QGraphicsItem::GraphicsItemFlag(-2));
+updateAncestorFlags();
-updateAncestorFlag(QGraphicsItem::GraphicsItemFlag(-1));
-updateAncestorFlag(QGraphicsItem::ItemClipsChildrenToShape);
-updateAncestorFlag(QGraphicsItem::ItemIgnoresTransformations);
 // Update item visible / enabled.
-if (parent->isVisible() != visible) {
+if (parent->d_ptr->visible != visible) {
-if (!parent->isVisible() || !explicitlyHidden)
+if (!parent->d_ptr->visible || !explicitlyHidden)
-setVisibleHelper(parent->isVisible(), /* explicit = */ false, /* update = */ !implicitUpdate);
+setVisibleHelper(parent->d_ptr->visible, /* explicit = */ false, /* update = */ false);
 }
 if (parent->isEnabled() != enabled) {
-if (!parent->isEnabled() || !explicitlyDisabled)
+if (!parent->d_ptr->enabled || !explicitlyDisabled)
-setEnabledHelper(parent->isEnabled(), /* explicit = */ false, /* update = */ !implicitUpdate);
+setEnabledHelper(parent->d_ptr->enabled, /* explicit = */ false, /* update = */ false);
 }
 // Auto-activate if visible and the parent is active.
-if (q->isVisible() && parent->isActive())
+if (visible && parent->isActive())
 q->setActive(true);
 } else {
 // Inherit ancestor flags from the new parent.
-updateAncestorFlag(QGraphicsItem::GraphicsItemFlag(-2));
+updateAncestorFlags();
-updateAncestorFlag(QGraphicsItem::GraphicsItemFlag(-1));
-updateAncestorFlag(QGraphicsItem::ItemClipsChildrenToShape);
-updateAncestorFlag(QGraphicsItem::ItemIgnoresTransformations);
 if (!inDestructor) {
 // Update item visible / enabled.
 if (!visible && !explicitlyHidden)
 setVisibleHelper(true, /* explicit = */ false);
 if (!enabled && !explicitlyDisabled)
 setEnabledHelper(true, /* explicit = */ false);
-// If the item is being deleted, the whole scene will be updated.
-if (scene)
-scene->d_func()->markDirty(q_ptr);
 }
 }
-// Resolve depth.
-invalidateDepthRecursively();
 dirtySceneTransform = 1;
 // Restore the sub focus chain.
 if (subFocusItem) {
 subFocusItem->d_ptr->setSubFocus(newParent);
 if (parent && parent->isActive())
 subFocusItem->setFocus();
 }
 // Deliver post-change notification
-q->itemChange(QGraphicsItem::ItemParentHasChanged, newParentVariant);
+if (newParentVariant)
+q->itemChange(QGraphicsItem::ItemParentHasChanged, *newParentVariant);
 if (isObject)
 emit static_cast<QGraphicsObject *>(q)->parentChanged();
 }
 if (d_ptr->scene) {
 d_ptr->scene->d_func()->removeItemHelper(this);
 } else {
 d_ptr->resetFocusProxy();
-d_ptr->setParentItemHelper(0);
+setParentItem(0);
 }
 #ifndef QT_NO_GRAPHICSEFFECT
 delete d_ptr->graphicsEffect;
 #endif //QT_NO_GRAPHICSEFFECT
 delete t;
 }
 }
 delete d_ptr->transformData;
-qt_dataStore()->data.remove(this);
+if (QGraphicsItemCustomDataStore *dataStore = qt_dataStore())
+dataStore->data.remove(this);
 }
 /*!
 Returns the current scene for the item, or 0 if the item is not stored in
 a scene.
 {
 return d_ptr->isObject ? static_cast<const QGraphicsObject *>(this) : 0;
 }
 /*!
-Sets this item's parent item to \a parent. If this item already has a
+Sets this item's parent item to \a newParent. If this item already
-parent, it is first removed from the previous parent. If \a parent is 0,
+has a parent, it is first removed from the previous parent. If \a
-this item will become a top-level item.
+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 parent have undefined behaviour.
+Calling this function on an item that is an ancestor of \a newParent
+have undefined behaviour.
-\sa parentItem(), childItems()
-*/
+\sa parentItem(), childItems()
-void QGraphicsItem::setParentItem(QGraphicsItem *parent)
+*/
-{
+void QGraphicsItem::setParentItem(QGraphicsItem *newParent)
-d_ptr->setParentItemHelper(parent);
+{
+if (newParent == this) {
+qWarning("QGraphicsItem::setParentItem: cannot assign %p as a parent of itself", this);
+return;
+}
+if (newParent == d_ptr->parent)
+return;
+const QVariant newParentVariant(itemChange(QGraphicsItem::ItemParentChange,
+qVariantFromValue<QGraphicsItem *>(newParent)));
+newParent = qVariantValue<QGraphicsItem *>(newParentVariant);
+if (newParent == d_ptr->parent)
+return;
+const QVariant thisPointerVariant(qVariantFromValue<QGraphicsItem *>(this));
+d_ptr->setParentItemHelper(newParent, &newParentVariant, &thisPointerVariant);
 }
 /*!
 \obsolete
 \sa QGraphicsWidget::windowFlags()
 */
 bool QGraphicsItem::isWindow() const
 {
-return isWidget() && (static_cast<const QGraphicsWidget *>(this)->windowType() & Qt::Window);
+return d_ptr->isWidget && (static_cast<const QGraphicsWidget *>(this)->windowType() & Qt::Window);
 }
 /*!
 \since 4.6
 Returns true if the item is a panel; otherwise returns false.
 \sa flags(), setFlags()
 */
 void QGraphicsItem::setFlag(GraphicsItemFlag flag, bool enabled)
 {
 if (enabled)
-setFlags(flags() | flag);
+setFlags(GraphicsItemFlags(d_ptr->flags) | flag);
 else
-setFlags(flags() & ~flag);
+setFlags(GraphicsItemFlags(d_ptr->flags) & ~flag);
 }
 /*!
 \internal
 if (quint32(d_ptr->flags) == quint32(flags))
 return;
 flags = GraphicsItemFlags(itemChange(ItemFlagsChange, quint32(flags)).toUInt());
 if (quint32(d_ptr->flags) == quint32(flags))
 return;
-if (d_ptr->scene)
+if (d_ptr->scene && d_ptr->scene->d_func()->indexMethod != QGraphicsScene::NoIndex)
-d_ptr->scene->d_func()->index->itemChange(this, ItemFlagsChange, quint32(flags));
+d_ptr->scene->d_func()->index->itemChange(this, ItemFlagsChange, &flags);
 // Flags that alter the geometry of the item (or its children).
 const quint32 geomChangeFlagsMask = (ItemClipsChildrenToShape | ItemClipsToShape | ItemIgnoresTransformations | ItemIsSelectable);
 bool fullUpdate = (quint32(flags) & geomChangeFlagsMask) != (d_ptr->flags & geomChangeFlagsMask);
 if (fullUpdate)
 d_ptr->paintedViewBoundingRectsNeedRepaint = 1;
 // Keep the old flags to compare the diff.
-GraphicsItemFlags oldFlags = this->flags();
+GraphicsItemFlags oldFlags = GraphicsItemFlags(d_ptr->flags);
 // Update flags.
 d_ptr->flags = flags;
 if (!(d_ptr->flags & ItemIsFocusable) && hasFocus()) {
 // Item children clipping changes. Propagate the ancestor flag to
 // all children.
 d_ptr->updateAncestorFlag(ItemIgnoresTransformations);
 }
+if ((flags & ItemNegativeZStacksBehindParent) != (oldFlags & ItemNegativeZStacksBehindParent)) {
+// NB! We change the flags directly here, so we must also update d_ptr->flags.
+// Note that this has do be done before the ItemStacksBehindParent check
+// below; otherwise we will loose the change.
+// Update stack-behind.
+if (d_ptr->z < qreal(0.0))
+flags |= ItemStacksBehindParent;
+else
+flags &= ~ItemStacksBehindParent;
+d_ptr->flags = flags;
+}
 if ((flags & ItemStacksBehindParent) != (oldFlags & ItemStacksBehindParent)) {
+// NB! This check has to come after the ItemNegativeZStacksBehindParent
+// check above. Be careful.
 // Ensure child item sorting is up to date when toggling this flag.
 if (d_ptr->parent)
 d_ptr->parent->d_ptr->needSortChildren = 1;
 else if (d_ptr->scene)
 d_ptr->scene->d_func()->needSortTopLevelItems = 1;
 // Update input method sensitivity in any views.
 if (d_ptr->scene)
 d_ptr->scene->d_func()->updateInputMethodSensitivityInViews();
 }
-if ((flags & ItemNegativeZStacksBehindParent) != (oldFlags & ItemNegativeZStacksBehindParent)) {
-// Update stack-behind.
-setFlag(ItemStacksBehindParent, d_ptr->z < qreal(0.0));
-}
 if ((d_ptr->panelModality != NonModal)
 && d_ptr->scene
 && (flags & ItemIsPanel) != (oldFlags & ItemIsPanel)) {
 // update the panel's modal state
 {
 CacheMode lastMode = CacheMode(d_ptr->cacheMode);
 d_ptr->cacheMode = mode;
 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();
 } else {
 QGraphicsItemCache *cache = d_ptr->extraItemCache();
 // Schedule redrawing
 if (update) {
 QGraphicsItemCache *c = (QGraphicsItemCache *)qVariantValue<void *>(extra(ExtraCacheData));
 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) {
 if (scene->d_func()->mouseGrabberItems.contains(q))
 q->ungrabMouse();
 if (scene->d_func()->keyboardGrabberItems.contains(q))
 q->ungrabKeyboard();
 if (q->isPanel() && panelModality != QGraphicsItem::NonModal)
 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();
 bool clear = true;
 if (isWidget && !focusItem->isPanel()) {
 do {
 break;
 }
 } while ((focusItem = focusItem->parentWidget()) && !focusItem->isPanel());
 }
 if (clear)
-q_ptr->clearFocus();
+clearFocusHelper(/* giveFocusToParent = */ false);
 }
 if (q_ptr->isSelected())
 q_ptr->setSelected(false);
 } else {
 geometryChanged = 1;
 scene->setActivePanel(parent);
 }
 }
 // Enable subfocus
-if (scene && newVisible) {
+if (scene) {
-QGraphicsItem *p = parent;
+if (newVisible) {
-bool done = false;
+// Item is shown
-while (p) {
+QGraphicsItem *p = parent;
-if (p->flags() & QGraphicsItem::ItemIsFocusScope) {
+bool done = false;
-QGraphicsItem *fsi = p->d_ptr->focusScopeItem;
+while (p) {
-if (q_ptr == fsi || q_ptr->isAncestorOf(fsi)) {
+if (p->flags() & QGraphicsItem::ItemIsFocusScope) {
-done = true;
+QGraphicsItem *fsi = p->d_ptr->focusScopeItem;
-while (fsi->d_ptr->focusScopeItem && fsi->d_ptr->focusScopeItem->isVisible())
+if (q_ptr == fsi || q_ptr->isAncestorOf(fsi)) {
-fsi = fsi->d_ptr->focusScopeItem;
+done = true;
-scene->setFocusItem(fsi);
+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 (!done) {
+if (fi && fi != scene->focusItem()) {
-QGraphicsItem *fi = subFocusItem;
+scene->setFocusItem(fi);
-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;
+}
 }
 }
 }
 // Deliver post-change notification.
 // No change? Done.
 if (newOpacity == d_ptr->opacity)
 return;
+bool wasFullyTransparent = d_ptr->isOpacityNull();
 d_ptr->opacity = newOpacity;
 // Notify change.
 itemChange(ItemOpacityHasChanged, newOpacityVariant);
 // Update.
 if (d_ptr->scene) {
 #ifndef QT_NO_GRAPHICSEFFECT
-d_ptr->invalidateGraphicsEffectsRecursively();
+d_ptr->invalidateParentGraphicsEffectsRecursively();
+if (!(d_ptr->flags & ItemDoesntPropagateOpacityToChildren))
+d_ptr->invalidateChildGraphicsEffectsRecursively(QGraphicsItemPrivate::OpacityChanged);
 #endif //QT_NO_GRAPHICSEFFECT
 d_ptr->scene->d_func()->markDirty(this, QRectF(),
 /*invalidateChildren=*/true,
 /*force=*/false,
-/*ignoreOpacity=*/true);
+/*ignoreOpacity=*/d_ptr->isOpacityNull());
+if (wasFullyTransparent)
+d_ptr->paintedViewBoundingRectsNeedRepaint = 1;
 }
 if (d_ptr->isObject)
 emit static_cast<QGraphicsObject *>(this)->opacityChanged();
 }
 return;
 if (d_ptr->graphicsEffect) {
 delete d_ptr->graphicsEffect;
 d_ptr->graphicsEffect = 0;
+} else if (d_ptr->parent) {
+d_ptr->parent->d_ptr->updateChildWithGraphicsEffectFlagRecursively();
 }
 if (effect) {
 // Set new effect.
 QGraphicsEffectSourcePrivate *sourced = new QGraphicsItemEffectSourcePrivate(this);
 effect->d_func()->setGraphicsEffectSource(source);
 prepareGeometryChange();
 }
 }
 #endif //QT_NO_GRAPHICSEFFECT
+void QGraphicsItemPrivate::updateChildWithGraphicsEffectFlagRecursively()
+{
+#ifndef QT_NO_GRAPHICSEFFECT
+QGraphicsItemPrivate *itemPrivate = this;
+do {
+// parent chain already notified?
+if (itemPrivate->mayHaveChildWithGraphicsEffect)
+return;
+itemPrivate->mayHaveChildWithGraphicsEffect = 1;
+} while ((itemPrivate = itemPrivate->parent ? itemPrivate->parent->d_ptr.data() : 0));
+#endif
+}
 /*!
 \internal
 \since 4.6
 Returns the effective bounding rect of the given item space rect.
 \sa focusItem(), setFocus(), QGraphicsScene::setFocusItem(), isActive()
 */
 bool QGraphicsItem::hasFocus() const
 {
+if (!d_ptr->scene || !d_ptr->scene->isActive())
+return false;
 if (d_ptr->focusProxy)
 return d_ptr->focusProxy->hasFocus();
-return isActive() && (d_ptr->scene && d_ptr->scene->focusItem() == this);
+if (d_ptr->scene->d_func()->focusItem != this)
+return false;
+return panel() == d_ptr->scene->d_func()->activePanel;
 }
 /*!
 Gives keyboard input focus to this item. The \a focusReason argument will
 be passed into any \l{QFocusEvent}{focus event} generated by this function;
 \sa clearFocus(), hasFocus(), focusItem(), focusProxy()
 */
 void QGraphicsItem::setFocus(Qt::FocusReason focusReason)
 {
-d_ptr->setFocusHelper(focusReason, /* climb = */ true);
+d_ptr->setFocusHelper(focusReason, /* climb = */ true, /* focusFromShow = */ false);
 }
 /*!
 \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.
 if (!q_ptr->isEnabled() || !(flags & QGraphicsItem::ItemIsFocusable))
 return;
 // Update focus scope item ptr.
 QGraphicsItem *p = parent;
 while (p) {
 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.
 return;
 }
 break;
 \sa setFocus(), hasFocus(), QGraphicsWidget::focusPolicy
 */
 void QGraphicsItem::clearFocus()
 {
-// Pass focus to the closest parent focus scope.
+d_ptr->clearFocusHelper(/* giveFocusToParent = */ true);
-if (!d_ptr->inDestructor) {
+}
-QGraphicsItem *p = d_ptr->parent;
-while (p) {
+/*!
-if (p->flags() & ItemIsFocusScope) {
+\internal
-p->d_ptr->setFocusHelper(Qt::OtherFocusReason, /* climb = */ false);
+*/
-return;
+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);
+clearSubFocus(q_ptr);
-if (hasFocus()) {
+if (q_ptr->hasFocus()) {
 // If this item has the scene's input focus, clear it.
-d_ptr->scene->setFocusItem(0);
+scene->setFocusItem(0);
 }
 }
 /*!
 \since 4.6
 const QVariant newZVariant(itemChange(ItemZValueChange, z));
 qreal newZ = newZVariant.toReal();
 if (newZ == d_ptr->z)
 return;
-if (d_ptr->scene) {
+if (d_ptr->scene && d_ptr->scene->d_func()->indexMethod != QGraphicsScene::NoIndex) {
 // Z Value has changed, we have to notify the index.
-d_ptr->scene->d_func()->index->itemChange(this, ItemZValueChange, newZVariant);
+d_ptr->scene->d_func()->index->itemChange(this, ItemZValueChange, &newZ);
 }
 d_ptr->z = newZ;
 if (d_ptr->parent)
 d_ptr->parent->d_ptr->needSortChildren = 1;
 /*!
 \internal
 */
 #ifndef QT_NO_GRAPHICSEFFECT
-void QGraphicsItemPrivate::invalidateGraphicsEffectsRecursively()
+void QGraphicsItemPrivate::invalidateParentGraphicsEffectsRecursively()
 {
 QGraphicsItemPrivate *itemPrivate = this;
 do {
 if (itemPrivate->graphicsEffect) {
 itemPrivate->notifyInvalidated = 1;
 if (!itemPrivate->updateDueToGraphicsEffect)
 static_cast<QGraphicsItemEffectSourcePrivate *>(itemPrivate->graphicsEffect->d_func()->source->d_func())->invalidateCache();
 }
 } while ((itemPrivate = itemPrivate->parent ? itemPrivate->parent->d_ptr.data() : 0));
+}
+void QGraphicsItemPrivate::invalidateChildGraphicsEffectsRecursively(QGraphicsItemPrivate::InvalidateReason reason)
+{
+if (!mayHaveChildWithGraphicsEffect)
+return;
+for (int i = 0; i < children.size(); ++i) {
+QGraphicsItemPrivate *childPrivate = children.at(i)->d_ptr.data();
+if (reason == OpacityChanged && (childPrivate->flags & QGraphicsItem::ItemIgnoresParentOpacity))
+continue;
+if (childPrivate->graphicsEffect) {
+childPrivate->notifyInvalidated = 1;
+static_cast<QGraphicsItemEffectSourcePrivate *>(childPrivate->graphicsEffect->d_func()->source->d_func())->invalidateCache();
+}
+childPrivate->invalidateChildGraphicsEffectsRecursively(reason);
+}
 }
 #endif //QT_NO_GRAPHICSEFFECT
 /*!
 \internal
 // number is equal to the size of the children list.
 ensureSequentialSiblingIndex();
 needSortChildren = 1; // ### maybe 0
 child->d_ptr->siblingIndex = children.size();
 children.append(child);
+if (isObject)
+emit static_cast<QGraphicsObject *>(q_ptr)->childrenChanged();
 }
 /*!
 \internal
 children.removeOne(child);
 // NB! Do not use children.removeAt(child->d_ptr->siblingIndex) because
 // the child is not guaranteed to be at the index after the list is sorted.
 // (see ensureSortedChildren()).
 child->d_ptr->siblingIndex = -1;
+if (isObject)
+emit static_cast<QGraphicsObject *>(q_ptr)->childrenChanged();
 }
 /*!
 \internal
 */
 if (rect.isEmpty() && !rect.isNull())
 return;
 // Make sure we notify effects about invalidated source.
 #ifndef QT_NO_GRAPHICSEFFECT
-d_ptr->invalidateGraphicsEffectsRecursively();
+d_ptr->invalidateParentGraphicsEffectsRecursively();
 #endif //QT_NO_GRAPHICSEFFECT
 if (CacheMode(d_ptr->cacheMode) != NoCache) {
 // Invalidate cache.
 QGraphicsItemCache *cache = d_ptr->extraItemCache();
 d_ptr->paintedViewBoundingRectsNeedRepaint = 1;
 d_ptr->notifyBoundingRectChanged = !d_ptr->inSetPosHelper;
 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
 // if someone is connected to the changed signal or the scene has no views.
 // Note that this has to be done *after* markDirty to ensure that
 // _q_processDirtyItems is called before _q_emitUpdated.
 d_ptr->scene->update(d_ptr->sceneTransform.mapRect(boundingRect()));
 }
 }
 }
-QGraphicsItem *parent = this;
+d_ptr->markParentDirty(/*updateBoundingRect=*/true);
-while ((parent = parent->d_ptr->parent)) {
-QGraphicsItemPrivate *parentp = parent->d_ptr.data();
-parentp->dirtyChildrenBoundingRect = 1;
-// ### Only do this if the parent's effect applies to the entire subtree.
-parentp->notifyBoundingRectChanged = 1;
-#ifndef QT_NO_GRAPHICSEFFECT
-if (parentp->scene && parentp->graphicsEffect) {
-parentp->notifyInvalidated = 1;
-static_cast<QGraphicsItemEffectSourcePrivate *>(parentp->graphicsEffect->d_func()->source->d_func())->invalidateCache();
-}
-#endif
-}
 }
 /*!
 \internal
 QGestureManager *manager = QGestureManager::instance();
 manager->cleanupCachedGestures(this, gesture);
 }
 }
+void QGraphicsItemPrivate::append(QDeclarativeListProperty<QGraphicsObject> *list, QGraphicsObject *item)
+{
+QGraphicsItemPrivate::get(item)->setParentItemHelper(static_cast<QGraphicsObject *>(list->object), /*newParentVariant=*/0, /*thisPointerVariant=*/0);
+}
+/*!
+Returns a list of this item's children.
+The items are sorted by stacking order. This takes into account both the
+items' insertion order and their Z-values.
+*/
+QDeclarativeListProperty<QGraphicsObject> QGraphicsItemPrivate::childrenList()
+{
+Q_Q(QGraphicsItem);
+if (isObject) {
+QGraphicsObject *that = static_cast<QGraphicsObject *>(q);
+return QDeclarativeListProperty<QGraphicsObject>(that, &children, QGraphicsItemPrivate::append);
+} else {
+//QGraphicsItem is not supported for this property
+return QDeclarativeListProperty<QGraphicsObject>();
+}
+}
+/*!
+\internal
+Returns the width of the item
+Reimplemented by QGraphicsWidget
+*/
+qreal QGraphicsItemPrivate::width() const
+{
+return 0;
+}
+/*!
+\internal
+Set the width of the item
+Reimplemented by QGraphicsWidget
+*/
+void QGraphicsItemPrivate::setWidth(qreal w)
+{
+Q_UNUSED(w);
+}
+/*!
+\internal
+Reset the width of the item
+Reimplemented by QGraphicsWidget
+*/
+void QGraphicsItemPrivate::resetWidth()
+{
+}
+/*!
+\internal
+Returns the height of the item
+Reimplemented by QGraphicsWidget
+*/
+qreal QGraphicsItemPrivate::height() const
+{
+return 0;
+}
+/*!
+\internal
+Set the height of the item
+Reimplemented by QGraphicsWidget
+*/
+void QGraphicsItemPrivate::setHeight(qreal h)
+{
+Q_UNUSED(h);
+}
+/*!
+\internal
+Reset the height of the item
+Reimplemented by QGraphicsWidget
+*/
+void QGraphicsItemPrivate::resetHeight()
+{
+}
 /*!
 \property QGraphicsObject::parent
 \brief the parent of the item
 \note The item's parent is set independently of the parent object returned
 origin for scale and rotation.
 \sa scale, rotation, QGraphicsItem::transformOriginPoint()
 */
+/*!
+\fn void QGraphicsObject::widthChanged()
+\internal
+*/
+/*!
+\fn void QGraphicsObject::heightChanged()
+\internal
+*/
+/*!
+\fn QGraphicsObject::childrenChanged()
+This signal gets emitted whenever the children list changes
+\internal
+*/
 /*!
 \class QAbstractGraphicsShapeItem
 \brief The QAbstractGraphicsShapeItem class provides a common base for
 all path items.
 info->widget, info->opacity, &effectTransform, info->wasDirtySceneTransform,
 info->drawItem);
 }
 }
-QPixmap QGraphicsItemEffectSourcePrivate::pixmap(Qt::CoordinateSystem system, QPoint *offset,
+// sourceRect must be in the given coordinate system
-QGraphicsEffect::PixmapPadMode mode) const
+QRect QGraphicsItemEffectSourcePrivate::paddedEffectRect(Qt::CoordinateSystem system, QGraphicsEffect::PixmapPadMode mode, const QRectF &sourceRect, bool *unpadded) const
 {
-const bool deviceCoordinates = (system == Qt::DeviceCoordinates);
-if (!info && deviceCoordinates) {
-// Device coordinates without info not yet supported.
-qWarning("QGraphicsEffectSource::pixmap: Not yet implemented, lacking device context");
-return QPixmap();
-}
-if (!item->d_ptr->scene)
-return QPixmap();
-QGraphicsScenePrivate *scened = item->d_ptr->scene->d_func();
-const QRectF sourceRect = boundingRect(system);
 QRectF effectRectF;
-bool unpadded = false;
+if (unpadded)
+*unpadded = false;
 if (mode == QGraphicsEffect::PadToEffectiveBoundingRect) {
 if (info) {
-effectRectF = item->graphicsEffect()->boundingRectFor(boundingRect(Qt::DeviceCoordinates));
+QRectF deviceRect = system == Qt::DeviceCoordinates ? sourceRect : info->painter->worldTransform().mapRect(sourceRect);
-unpadded = (effectRectF.size() == sourceRect.size());
+effectRectF = item->graphicsEffect()->boundingRectFor(deviceRect);
+if (unpadded)
+*unpadded = (effectRectF.size() == sourceRect.size());
 if (info && system == Qt::LogicalCoordinates)
 effectRectF = info->painter->worldTransform().inverted().mapRect(effectRectF);
 } else {
 // no choice but to send a logical coordinate bounding rect to boundingRectFor
 effectRectF = item->graphicsEffect()->boundingRectFor(sourceRect);
 } else if (mode == QGraphicsEffect::PadToTransparentBorder) {
 // adjust by 1.5 to account for cosmetic pens
 effectRectF = sourceRect.adjusted(-1.5, -1.5, 1.5, 1.5);
 } else {
 effectRectF = sourceRect;
-unpadded = true;
+if (unpadded)
-}
+*unpadded = true;
+}
-QRect effectRect = effectRectF.toAlignedRect();
+return effectRectF.toAlignedRect();
+}
+QPixmap QGraphicsItemEffectSourcePrivate::pixmap(Qt::CoordinateSystem system, QPoint *offset,
+QGraphicsEffect::PixmapPadMode mode) const
+{
+const bool deviceCoordinates = (system == Qt::DeviceCoordinates);
+if (!info && deviceCoordinates) {
+// Device coordinates without info not yet supported.
+qWarning("QGraphicsEffectSource::pixmap: Not yet implemented, lacking device context");
+return QPixmap();
+}
+if (!item->d_ptr->scene)
+return QPixmap();
+QGraphicsScenePrivate *scened = item->d_ptr->scene->d_func();
+bool unpadded;
+const QRectF sourceRect = boundingRect(system);
+QRect effectRect = paddedEffectRect(system, mode, sourceRect, &unpadded);
 if (offset)
 *offset = effectRect.topLeft();
 bool untransformed = !deviceCoordinates
 if (offset)
 *offset = boundingRect(system).topLeft().toPoint();
 return static_cast<QGraphicsPixmapItem *>(item)->pixmap();
 }
-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();
 QPixmap pixmap(effectRect.size());
 pixmap.fill(Qt::transparent);

changeset 7	f7bc934e204c
parent 3	41300fa6a67c