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

equal deleted inserted replaced

-:dee5afe5301f
+:3f74d0d4af4c
 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"
 }
 p = p->d_ptr->parent;
 }
 }
+// Resolve depth.
+invalidateDepthRecursively();
 if ((parent = newParent)) {
 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);
 } else if (!parent->d_func()->scene && scene) {
 if (!enabled && !explicitlyDisabled)
 setEnabledHelper(true, /* explicit = */ false);
 }
 }
-// Resolve depth.
-invalidateDepthRecursively();
 dirtySceneTransform = 1;
 // Restore the sub focus chain.
 if (subFocusItem) {
 subFocusItem->d_ptr->setSubFocus(newParent);
 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.
 {
 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);
 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();
 }
 \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
 // 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
 */
 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);
 }
 }
+// sourceRect must be in the given coordinate system
 QRect QGraphicsItemEffectSourcePrivate::paddedEffectRect(Qt::CoordinateSystem system, QGraphicsEffect::PixmapPadMode mode, const QRectF &sourceRect, bool *unpadded) const
 {
 QRectF effectRectF;
 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);
+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 {
 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);

branch	RCL_3
changeset 8	3f74d0d4af4c
parent 5	d3bac044e0f0
child 14	c0432d11811c