| /**************************************************************************** |
| ** |
| ** Copyright (C) 2011 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. |
| ** |
| ** $QT_BEGIN_LICENSE:LGPL$ |
| ** GNU Lesser General Public License Usage |
| ** This file may be used under the terms of the GNU Lesser General Public |
| ** License version 2.1 as published by the Free Software Foundation and |
| ** appearing in the file LICENSE.LGPL included in the packaging of this |
| ** file. Please review the following information to ensure the GNU Lesser |
| ** General Public License version 2.1 requirements will be met: |
| ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. |
| ** |
| ** In addition, as a special exception, Nokia gives you certain additional |
| ** rights. These rights are described in the Nokia Qt LGPL Exception |
| ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. |
| ** |
| ** GNU General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU General |
| ** Public License version 3.0 as published by the Free Software Foundation |
| ** and appearing in the file LICENSE.GPL included in the packaging of this |
| ** file. Please review the following information to ensure the GNU General |
| ** Public License version 3.0 requirements will be met: |
| ** http://www.gnu.org/copyleft/gpl.html. |
| ** |
| ** Other Usage |
| ** Alternatively, this file may be used in accordance with the terms and |
| ** conditions contained in a signed written agreement between you and Nokia. |
| ** |
| ** |
| ** |
| ** |
| ** |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| /*! |
| \class QGraphicsSceneIndex |
| \brief The QGraphicsSceneIndex class provides a base class to implement |
| a custom indexing algorithm for discovering items in QGraphicsScene. |
| \since 4.6 |
| \ingroup graphicsview-api |
| |
| \internal |
| |
| The QGraphicsSceneIndex class provides a base class to implement |
| a custom indexing algorithm for discovering items in QGraphicsScene. You |
| need to subclass it and reimplement addItem, removeItem, estimateItems |
| and items in order to have an functional indexing. |
| |
| \sa QGraphicsScene, QGraphicsView |
| */ |
| |
| #include "qdebug.h" |
| #include "qgraphicsscene.h" |
| #include "qgraphicsitem_p.h" |
| #include "qgraphicsscene_p.h" |
| #include "qgraphicswidget.h" |
| #include "qgraphicssceneindex_p.h" |
| #include "qgraphicsscenebsptreeindex_p.h" |
| |
| #ifndef QT_NO_GRAPHICSVIEW |
| |
| QT_BEGIN_NAMESPACE |
| |
| class QGraphicsSceneIndexRectIntersector : public QGraphicsSceneIndexIntersector |
| { |
| public: |
| bool intersect(const QGraphicsItem *item, const QRectF &exposeRect, Qt::ItemSelectionMode mode, |
| const QTransform &deviceTransform) const |
| { |
| QRectF brect = item->boundingRect(); |
| _q_adjustRect(&brect); |
| |
| // ### Add test for this (without making things slower?) |
| Q_UNUSED(exposeRect); |
| |
| bool keep = true; |
| const QGraphicsItemPrivate *itemd = QGraphicsItemPrivate::get(item); |
| if (itemd->itemIsUntransformable()) { |
| // Untransformable items; map the scene rect to item coordinates. |
| const QTransform transform = item->deviceTransform(deviceTransform); |
| QRectF itemRect = (deviceTransform * transform.inverted()).mapRect(sceneRect); |
| if (mode == Qt::ContainsItemShape || mode == Qt::ContainsItemBoundingRect) |
| keep = itemRect.contains(brect) && itemRect != brect; |
| else |
| keep = itemRect.intersects(brect); |
| if (keep && (mode == Qt::ContainsItemShape || mode == Qt::IntersectsItemShape)) { |
| QPainterPath itemPath; |
| itemPath.addRect(itemRect); |
| keep = QGraphicsSceneIndexPrivate::itemCollidesWithPath(item, itemPath, mode); |
| } |
| } else { |
| Q_ASSERT(!itemd->dirtySceneTransform); |
| const QRectF itemSceneBoundingRect = itemd->sceneTransformTranslateOnly |
| ? brect.translated(itemd->sceneTransform.dx(), |
| itemd->sceneTransform.dy()) |
| : itemd->sceneTransform.mapRect(brect); |
| if (mode == Qt::ContainsItemShape || mode == Qt::ContainsItemBoundingRect) |
| keep = sceneRect != brect && sceneRect.contains(itemSceneBoundingRect); |
| else |
| keep = sceneRect.intersects(itemSceneBoundingRect); |
| if (keep && (mode == Qt::ContainsItemShape || mode == Qt::IntersectsItemShape)) { |
| QPainterPath rectPath; |
| rectPath.addRect(sceneRect); |
| if (itemd->sceneTransformTranslateOnly) |
| rectPath.translate(-itemd->sceneTransform.dx(), -itemd->sceneTransform.dy()); |
| else |
| rectPath = itemd->sceneTransform.inverted().map(rectPath); |
| keep = QGraphicsSceneIndexPrivate::itemCollidesWithPath(item, rectPath, mode); |
| } |
| } |
| return keep; |
| } |
| |
| QRectF sceneRect; |
| }; |
| |
| class QGraphicsSceneIndexPointIntersector : public QGraphicsSceneIndexIntersector |
| { |
| public: |
| bool intersect(const QGraphicsItem *item, const QRectF &exposeRect, Qt::ItemSelectionMode mode, |
| const QTransform &deviceTransform) const |
| { |
| QRectF brect = item->boundingRect(); |
| _q_adjustRect(&brect); |
| |
| // ### Add test for this (without making things slower?) |
| Q_UNUSED(exposeRect); |
| |
| bool keep = false; |
| const QGraphicsItemPrivate *itemd = QGraphicsItemPrivate::get(item); |
| if (itemd->itemIsUntransformable()) { |
| // Untransformable items; map the scene point to item coordinates. |
| const QTransform transform = item->deviceTransform(deviceTransform); |
| QPointF itemPoint = (deviceTransform * transform.inverted()).map(scenePoint); |
| keep = brect.contains(itemPoint); |
| if (keep && (mode == Qt::ContainsItemShape || mode == Qt::IntersectsItemShape)) { |
| QPainterPath pointPath; |
| pointPath.addRect(QRectF(itemPoint, QSizeF(1, 1))); |
| keep = QGraphicsSceneIndexPrivate::itemCollidesWithPath(item, pointPath, mode); |
| } |
| } else { |
| Q_ASSERT(!itemd->dirtySceneTransform); |
| QRectF sceneBoundingRect = itemd->sceneTransformTranslateOnly |
| ? brect.translated(itemd->sceneTransform.dx(), |
| itemd->sceneTransform.dy()) |
| : itemd->sceneTransform.mapRect(brect); |
| keep = sceneBoundingRect.intersects(QRectF(scenePoint, QSizeF(1, 1))); |
| if (keep) { |
| QPointF p = itemd->sceneTransformTranslateOnly |
| ? QPointF(scenePoint.x() - itemd->sceneTransform.dx(), |
| scenePoint.y() - itemd->sceneTransform.dy()) |
| : itemd->sceneTransform.inverted().map(scenePoint); |
| keep = item->contains(p); |
| } |
| } |
| |
| return keep; |
| } |
| |
| QPointF scenePoint; |
| }; |
| |
| class QGraphicsSceneIndexPathIntersector : public QGraphicsSceneIndexIntersector |
| { |
| public: |
| bool intersect(const QGraphicsItem *item, const QRectF &exposeRect, Qt::ItemSelectionMode mode, |
| const QTransform &deviceTransform) const |
| { |
| QRectF brect = item->boundingRect(); |
| _q_adjustRect(&brect); |
| |
| // ### Add test for this (without making things slower?) |
| Q_UNUSED(exposeRect); |
| |
| bool keep = true; |
| const QGraphicsItemPrivate *itemd = QGraphicsItemPrivate::get(item); |
| if (itemd->itemIsUntransformable()) { |
| // Untransformable items; map the scene rect to item coordinates. |
| const QTransform transform = item->deviceTransform(deviceTransform); |
| QPainterPath itemPath = (deviceTransform * transform.inverted()).map(scenePath); |
| if (mode == Qt::ContainsItemShape || mode == Qt::ContainsItemBoundingRect) |
| keep = itemPath.contains(brect); |
| else |
| keep = itemPath.intersects(brect); |
| if (keep && (mode == Qt::ContainsItemShape || mode == Qt::IntersectsItemShape)) |
| keep = QGraphicsSceneIndexPrivate::itemCollidesWithPath(item, itemPath, mode); |
| } else { |
| Q_ASSERT(!itemd->dirtySceneTransform); |
| const QRectF itemSceneBoundingRect = itemd->sceneTransformTranslateOnly |
| ? brect.translated(itemd->sceneTransform.dx(), |
| itemd->sceneTransform.dy()) |
| : itemd->sceneTransform.mapRect(brect); |
| if (mode == Qt::ContainsItemShape || mode == Qt::ContainsItemBoundingRect) |
| keep = scenePath.contains(itemSceneBoundingRect); |
| else |
| keep = scenePath.intersects(itemSceneBoundingRect); |
| if (keep && (mode == Qt::ContainsItemShape || mode == Qt::IntersectsItemShape)) { |
| QPainterPath itemPath = itemd->sceneTransformTranslateOnly |
| ? scenePath.translated(-itemd->sceneTransform.dx(), |
| -itemd->sceneTransform.dy()) |
| : itemd->sceneTransform.inverted().map(scenePath); |
| keep = QGraphicsSceneIndexPrivate::itemCollidesWithPath(item, itemPath, mode); |
| } |
| } |
| return keep; |
| } |
| |
| QPainterPath scenePath; |
| }; |
| |
| /*! |
| Constructs a private scene index. |
| */ |
| QGraphicsSceneIndexPrivate::QGraphicsSceneIndexPrivate(QGraphicsScene *scene) : scene(scene) |
| { |
| pointIntersector = new QGraphicsSceneIndexPointIntersector; |
| rectIntersector = new QGraphicsSceneIndexRectIntersector; |
| pathIntersector = new QGraphicsSceneIndexPathIntersector; |
| } |
| |
| /*! |
| Destructor of private scene index. |
| */ |
| QGraphicsSceneIndexPrivate::~QGraphicsSceneIndexPrivate() |
| { |
| delete pointIntersector; |
| delete rectIntersector; |
| delete pathIntersector; |
| } |
| |
| /*! |
| \internal |
| |
| Checks if item collides with the path and mode, but also checks that if it |
| doesn't collide, maybe its frame rect will. |
| */ |
| bool QGraphicsSceneIndexPrivate::itemCollidesWithPath(const QGraphicsItem *item, |
| const QPainterPath &path, |
| Qt::ItemSelectionMode mode) |
| { |
| if (item->collidesWithPath(path, mode)) |
| return true; |
| if (item->isWidget()) { |
| // Check if this is a window, and if its frame rect collides. |
| const QGraphicsWidget *widget = static_cast<const QGraphicsWidget *>(item); |
| if (widget->isWindow()) { |
| QRectF frameRect = widget->windowFrameRect(); |
| QPainterPath framePath; |
| framePath.addRect(frameRect); |
| bool intersects = path.intersects(frameRect); |
| if (mode == Qt::IntersectsItemShape || mode == Qt::IntersectsItemBoundingRect) |
| return intersects || path.contains(frameRect.topLeft()) |
| || framePath.contains(path.elementAt(0)); |
| return !intersects && path.contains(frameRect.topLeft()); |
| } |
| } |
| return false; |
| } |
| |
| /*! |
| \internal |
| This function returns the items in ascending order. |
| */ |
| void QGraphicsSceneIndexPrivate::recursive_items_helper(QGraphicsItem *item, QRectF exposeRect, |
| QGraphicsSceneIndexIntersector *intersector, |
| QList<QGraphicsItem *> *items, |
| const QTransform &viewTransform, |
| Qt::ItemSelectionMode mode, |
| qreal parentOpacity) const |
| { |
| Q_ASSERT(item); |
| if (!item->d_ptr->visible) |
| return; |
| |
| const qreal opacity = item->d_ptr->combineOpacityFromParent(parentOpacity); |
| const bool itemIsFullyTransparent = QGraphicsItemPrivate::isOpacityNull(opacity); |
| const bool itemHasChildren = !item->d_ptr->children.isEmpty(); |
| if (itemIsFullyTransparent && (!itemHasChildren || item->d_ptr->childrenCombineOpacity())) |
| return; |
| |
| // Update the item's scene transform if dirty. |
| const bool itemIsUntransformable = item->d_ptr->itemIsUntransformable(); |
| const bool wasDirtyParentSceneTransform = item->d_ptr->dirtySceneTransform && !itemIsUntransformable; |
| if (wasDirtyParentSceneTransform) { |
| item->d_ptr->updateSceneTransformFromParent(); |
| Q_ASSERT(!item->d_ptr->dirtySceneTransform); |
| } |
| |
| const bool itemClipsChildrenToShape = (item->d_ptr->flags & QGraphicsItem::ItemClipsChildrenToShape); |
| bool processItem = !itemIsFullyTransparent; |
| if (processItem) { |
| processItem = intersector->intersect(item, exposeRect, mode, viewTransform); |
| if (!processItem && (!itemHasChildren || itemClipsChildrenToShape)) { |
| if (wasDirtyParentSceneTransform) |
| item->d_ptr->invalidateChildrenSceneTransform(); |
| return; |
| } |
| } // else we know for sure this item has children we must process. |
| |
| int i = 0; |
| if (itemHasChildren) { |
| // Sort children. |
| item->d_ptr->ensureSortedChildren(); |
| |
| // Clip to shape. |
| if (itemClipsChildrenToShape && !itemIsUntransformable) { |
| QPainterPath mappedShape = item->d_ptr->sceneTransformTranslateOnly |
| ? item->shape().translated(item->d_ptr->sceneTransform.dx(), |
| item->d_ptr->sceneTransform.dy()) |
| : item->d_ptr->sceneTransform.map(item->shape()); |
| exposeRect &= mappedShape.controlPointRect(); |
| } |
| |
| // Process children behind |
| for (i = 0; i < item->d_ptr->children.size(); ++i) { |
| QGraphicsItem *child = item->d_ptr->children.at(i); |
| if (wasDirtyParentSceneTransform) |
| child->d_ptr->dirtySceneTransform = 1; |
| if (!(child->d_ptr->flags & QGraphicsItem::ItemStacksBehindParent)) |
| break; |
| if (itemIsFullyTransparent && !(child->d_ptr->flags & QGraphicsItem::ItemIgnoresParentOpacity)) |
| continue; |
| recursive_items_helper(child, exposeRect, intersector, items, viewTransform, |
| mode, opacity); |
| } |
| } |
| |
| // Process item |
| if (processItem) |
| items->append(item); |
| |
| // Process children in front |
| if (itemHasChildren) { |
| for (; i < item->d_ptr->children.size(); ++i) { |
| QGraphicsItem *child = item->d_ptr->children.at(i); |
| if (wasDirtyParentSceneTransform) |
| child->d_ptr->dirtySceneTransform = 1; |
| if (itemIsFullyTransparent && !(child->d_ptr->flags & QGraphicsItem::ItemIgnoresParentOpacity)) |
| continue; |
| recursive_items_helper(child, exposeRect, intersector, items, viewTransform, |
| mode, opacity); |
| } |
| } |
| } |
| |
| void QGraphicsSceneIndexPrivate::init() |
| { |
| if (!scene) |
| return; |
| |
| QObject::connect(scene, SIGNAL(sceneRectChanged(QRectF)), |
| q_func(), SLOT(updateSceneRect(QRectF))); |
| } |
| |
| /*! |
| Constructs an abstract scene index for a given \a scene. |
| */ |
| QGraphicsSceneIndex::QGraphicsSceneIndex(QGraphicsScene *scene) |
| : QObject(*new QGraphicsSceneIndexPrivate(scene), scene) |
| { |
| d_func()->init(); |
| } |
| |
| /*! |
| \internal |
| */ |
| QGraphicsSceneIndex::QGraphicsSceneIndex(QGraphicsSceneIndexPrivate &dd, QGraphicsScene *scene) |
| : QObject(dd, scene) |
| { |
| d_func()->init(); |
| } |
| |
| /*! |
| Destroys the scene index. |
| */ |
| QGraphicsSceneIndex::~QGraphicsSceneIndex() |
| { |
| |
| } |
| |
| /*! |
| Returns the scene of this index. |
| */ |
| QGraphicsScene* QGraphicsSceneIndex::scene() const |
| { |
| Q_D(const QGraphicsSceneIndex); |
| return d->scene; |
| } |
| |
| /*! |
| \fn QList<QGraphicsItem *> QGraphicsSceneIndex::items(const QPointF &pos, |
| Qt::ItemSelectionMode mode, Qt::SortOrder order, const QTransform |
| &deviceTransform) const |
| |
| Returns all visible items that, depending on \a mode, are at the specified |
| \a pos and return a list sorted using \a order. |
| |
| The default value for \a mode is Qt::IntersectsItemShape; all items whose |
| exact shape intersects with \a pos are returned. |
| |
| \a deviceTransform is the transformation apply to the view. |
| |
| This method use the estimation of the index (estimateItems) and refine the |
| list to get an exact result. If you want to implement your own refinement |
| algorithm you can reimplement this method. |
| |
| \sa estimateItems() |
| |
| */ |
| QList<QGraphicsItem *> QGraphicsSceneIndex::items(const QPointF &pos, Qt::ItemSelectionMode mode, |
| Qt::SortOrder order, const QTransform &deviceTransform) const |
| { |
| |
| Q_D(const QGraphicsSceneIndex); |
| QList<QGraphicsItem *> itemList; |
| d->pointIntersector->scenePoint = pos; |
| d->items_helper(QRectF(pos, QSizeF(1, 1)), d->pointIntersector, &itemList, deviceTransform, mode, order); |
| return itemList; |
| } |
| |
| /*! |
| \fn QList<QGraphicsItem *> QGraphicsSceneIndex::items(const QRectF &rect, |
| Qt::ItemSelectionMode mode, Qt::SortOrder order, const QTransform |
| &deviceTransform) const |
| |
| \overload |
| |
| Returns all visible items that, depending on \a mode, are either inside or |
| intersect with the specified \a rect and return a list sorted using \a order. |
| |
| The default value for \a mode is Qt::IntersectsItemShape; all items whose |
| exact shape intersects with or is contained by \a rect are returned. |
| |
| \a deviceTransform is the transformation apply to the view. |
| |
| This method use the estimation of the index (estimateItems) and refine |
| the list to get an exact result. If you want to implement your own |
| refinement algorithm you can reimplement this method. |
| |
| \sa estimateItems() |
| |
| */ |
| QList<QGraphicsItem *> QGraphicsSceneIndex::items(const QRectF &rect, Qt::ItemSelectionMode mode, |
| Qt::SortOrder order, const QTransform &deviceTransform) const |
| { |
| Q_D(const QGraphicsSceneIndex); |
| QRectF exposeRect = rect; |
| _q_adjustRect(&exposeRect); |
| QList<QGraphicsItem *> itemList; |
| d->rectIntersector->sceneRect = rect; |
| d->items_helper(exposeRect, d->rectIntersector, &itemList, deviceTransform, mode, order); |
| return itemList; |
| } |
| |
| /*! |
| \fn QList<QGraphicsItem *> QGraphicsSceneIndex::items(const QPolygonF |
| &polygon, Qt::ItemSelectionMode mode, Qt::SortOrder order, const |
| QTransform &deviceTransform) const |
| |
| \overload |
| |
| Returns all visible items that, depending on \a mode, are either inside or |
| intersect with the specified \a polygon and return a list sorted using \a order. |
| |
| The default value for \a mode is Qt::IntersectsItemShape; all items whose |
| exact shape intersects with or is contained by \a polygon are returned. |
| |
| \a deviceTransform is the transformation apply to the view. |
| |
| This method use the estimation of the index (estimateItems) and refine |
| the list to get an exact result. If you want to implement your own |
| refinement algorithm you can reimplement this method. |
| |
| \sa estimateItems() |
| |
| */ |
| QList<QGraphicsItem *> QGraphicsSceneIndex::items(const QPolygonF &polygon, Qt::ItemSelectionMode mode, |
| Qt::SortOrder order, const QTransform &deviceTransform) const |
| { |
| Q_D(const QGraphicsSceneIndex); |
| QList<QGraphicsItem *> itemList; |
| QRectF exposeRect = polygon.boundingRect(); |
| _q_adjustRect(&exposeRect); |
| QPainterPath path; |
| path.addPolygon(polygon); |
| d->pathIntersector->scenePath = path; |
| d->items_helper(exposeRect, d->pathIntersector, &itemList, deviceTransform, mode, order); |
| return itemList; |
| } |
| |
| /*! |
| \fn QList<QGraphicsItem *> QGraphicsSceneIndex::items(const QPainterPath |
| &path, Qt::ItemSelectionMode mode, Qt::SortOrder order, const QTransform |
| &deviceTransform) const |
| |
| \overload |
| |
| Returns all visible items that, depending on \a mode, are either inside or |
| intersect with the specified \a path and return a list sorted using \a order. |
| |
| The default value for \a mode is Qt::IntersectsItemShape; all items whose |
| exact shape intersects with or is contained by \a path are returned. |
| |
| \a deviceTransform is the transformation apply to the view. |
| |
| This method use the estimation of the index (estimateItems) and refine |
| the list to get an exact result. If you want to implement your own |
| refinement algorithm you can reimplement this method. |
| |
| \sa estimateItems() |
| |
| */ |
| QList<QGraphicsItem *> QGraphicsSceneIndex::items(const QPainterPath &path, Qt::ItemSelectionMode mode, |
| Qt::SortOrder order, const QTransform &deviceTransform) const |
| { |
| Q_D(const QGraphicsSceneIndex); |
| QList<QGraphicsItem *> itemList; |
| QRectF exposeRect = path.controlPointRect(); |
| _q_adjustRect(&exposeRect); |
| d->pathIntersector->scenePath = path; |
| d->items_helper(exposeRect, d->pathIntersector, &itemList, deviceTransform, mode, order); |
| return itemList; |
| } |
| |
| /*! |
| This virtual function return an estimation of items at position \a point. |
| This method return a list sorted using \a order. |
| */ |
| QList<QGraphicsItem *> QGraphicsSceneIndex::estimateItems(const QPointF &point, Qt::SortOrder order) const |
| { |
| return estimateItems(QRectF(point, QSize(1, 1)), order); |
| } |
| |
| QList<QGraphicsItem *> QGraphicsSceneIndex::estimateTopLevelItems(const QRectF &rect, Qt::SortOrder order) const |
| { |
| Q_D(const QGraphicsSceneIndex); |
| Q_UNUSED(rect); |
| QGraphicsScenePrivate *scened = d->scene->d_func(); |
| scened->ensureSortedTopLevelItems(); |
| if (order == Qt::DescendingOrder) { |
| QList<QGraphicsItem *> sorted; |
| for (int i = scened->topLevelItems.size() - 1; i >= 0; --i) |
| sorted << scened->topLevelItems.at(i); |
| return sorted; |
| } |
| return scened->topLevelItems; |
| } |
| |
| /*! |
| \fn QList<QGraphicsItem *> QGraphicsSceneIndex::items(Qt::SortOrder order = Qt::DescendingOrder) const |
| |
| This pure virtual function all items in the index and sort them using |
| \a order. |
| */ |
| |
| |
| /*! |
| Notifies the index that the scene's scene rect has changed. \a rect |
| is thew new scene rect. |
| |
| \sa QGraphicsScene::sceneRect() |
| */ |
| void QGraphicsSceneIndex::updateSceneRect(const QRectF &rect) |
| { |
| Q_UNUSED(rect); |
| } |
| |
| /*! |
| This virtual function removes all items in the scene index. |
| */ |
| void QGraphicsSceneIndex::clear() |
| { |
| const QList<QGraphicsItem *> allItems = items(); |
| for (int i = 0 ; i < allItems.size(); ++i) |
| removeItem(allItems.at(i)); |
| } |
| |
| /*! |
| \fn virtual void QGraphicsSceneIndex::addItem(QGraphicsItem *item) = 0 |
| |
| This pure virtual function inserts an \a item to the scene index. |
| |
| \sa removeItem(), deleteItem() |
| */ |
| |
| /*! |
| \fn virtual void QGraphicsSceneIndex::removeItem(QGraphicsItem *item) = 0 |
| |
| This pure virtual function removes an \a item to the scene index. |
| |
| \sa addItem(), deleteItem() |
| */ |
| |
| /*! |
| This method is called when an \a item has been deleted. |
| The default implementation call removeItem. Be carefull, |
| if your implementation of removeItem use pure virtual method |
| of QGraphicsItem like boundingRect(), then you should reimplement |
| this method. |
| |
| \sa addItem(), removeItem() |
| */ |
| void QGraphicsSceneIndex::deleteItem(QGraphicsItem *item) |
| { |
| removeItem(item); |
| } |
| |
| /*! |
| This virtual function is called by QGraphicsItem to notify the index |
| that some part of the \a item 's state changes. By reimplementing this |
| function, your can react to a change, and in some cases, (depending on \a |
| change,) adjustments in the index can be made. |
| |
| \a change is the parameter of the item that is changing. \a value is the |
| value that changed; the type of the value depends on \a change. |
| |
| The default implementation does nothing. |
| |
| \sa QGraphicsItem::GraphicsItemChange |
| */ |
| void QGraphicsSceneIndex::itemChange(const QGraphicsItem *item, QGraphicsItem::GraphicsItemChange change, const void *const value) |
| { |
| Q_UNUSED(item); |
| Q_UNUSED(change); |
| Q_UNUSED(value); |
| } |
| |
| /*! |
| Notify the index for a geometry change of an \a item. |
| |
| \sa QGraphicsItem::prepareGeometryChange() |
| */ |
| void QGraphicsSceneIndex::prepareBoundingRectChange(const QGraphicsItem *item) |
| { |
| Q_UNUSED(item); |
| } |
| |
| QT_END_NAMESPACE |
| |
| #include "moc_qgraphicssceneindex_p.cpp" |
| |
| #endif // QT_NO_GRAPHICSVIEW |
