QGraphicsSceneIndexPrivate Class Reference

#include <qgraphicssceneindex_p.h>

Inheritance diagram for QGraphicsSceneIndexPrivate:

Public Functions
void	init ()
void	items_helper (const QRectF &rect, QGraphicsSceneIndexIntersector *intersector, QList< QGraphicsItem *> *items, const QTransform &viewTransform, Qt::ItemSelectionMode mode, Qt::SortOrder order) const
	QGraphicsSceneIndexPrivate (QGraphicsScene *scene)
	Constructs a private scene index. More...
void	recursive_items_helper (QGraphicsItem *item, QRectF exposeRect, QGraphicsSceneIndexIntersector *intersector, QList< QGraphicsItem *> *items, const QTransform &viewTransform, Qt::ItemSelectionMode mode, qreal parentOpacity=1.0) const
	This function returns the items in ascending order. More...
	~QGraphicsSceneIndexPrivate ()
	Destructor of private scene index. More...
Public Functions inherited from QObjectPrivate
void	_q_reregisterTimers (void *pointer)
void	addConnection (int signal, Connection *c)
void	cleanConnectionLists ()
void	connectNotify (const char *signal)
void	deleteChildren ()
void	disconnectNotify (const char *signal)
bool	isSender (const QObject *receiver, const char *signal) const
bool	isSignalConnected (uint signalIdx) const
	Returns true if the signal with index signal_index from object sender is connected. More...
void	moveToThread_helper ()
	QObjectPrivate (int version=QObjectPrivateVersion)
QObjectList	receiverList (const char *signal) const
QObjectList	senderList () const
void	setParent_helper (QObject *)
void	setThreadData_helper (QThreadData *currentData, QThreadData *targetData)
int	signalIndex (const char *signalName) const
	Returns the signal index used in the internal connectionLists vector. More...
virtual	~QObjectPrivate ()
Public Functions inherited from QObjectData
virtual	~QObjectData ()=0

Static Public Functions
static bool	itemCollidesWithPath (const QGraphicsItem *item, const QPainterPath &path, Qt::ItemSelectionMode mode)
	Checks if item collides with the path and mode, but also checks that if it doesn't collide, maybe its frame rect will. More...
Static Public Functions inherited from QObjectPrivate
static void	clearGuards (QObject *)
static QObjectPrivate *	get (QObject *o)
static void	resetCurrentSender (QObject *receiver, Sender *currentSender, Sender *previousSender)
static Sender *	setCurrentSender (QObject *receiver, Sender *sender)
static void	signalSignature (const QMetaMethod &signal, QVarLengthArray< char > *result)

Public Variables
QGraphicsSceneIndexPathIntersector *	pathIntersector
QGraphicsSceneIndexPointIntersector *	pointIntersector
QGraphicsSceneIndexRectIntersector *	rectIntersector
QGraphicsScene *	scene
Public Variables inherited from QObjectPrivate
union {
QObject *   currentChildBeingDeleted
QAbstractDeclarativeData *   declarativeData
};
quint32	connectedSignals [2]
QObjectConnectionListVector *	connectionLists
Sender *	currentSender
QList< QPointer< QObject > >	eventFilters
ExtraData *	extraData
QString	objectName
Connection *	senders
QAtomicPointer< QtSharedPointer::ExternalRefCountData >	sharedRefcount
QThreadData *	threadData
void *	unused
Public Variables inherited from QObjectData
uint	blockSig: 1
QObjectList	children
uint	hasGuards: 1
uint	inEventHandler: 1
uint	inThreadChangeEvent: 1
uint	isWidget: 1
QMetaObject *	metaObject
uint	ownObjectName: 1
QObject *	parent
uint	pendTimer: 1
int	postedEvents
QObject *	q_ptr
uint	receiveChildEvents: 1
uint	sendChildEvents: 1
uint	unused: 22
uint	wasDeleted: 1

Additional Inherited Members
Public Types inherited from QObjectPrivate
typedef void(*	StaticMetaCallFunction) (QObject *, QMetaObject::Call, int, void **)

Detailed Description

Definition at line 128 of file qgraphicssceneindex_p.h.

Constructors and Destructors

QGraphicsSceneIndexPrivate()

QGraphicsSceneIndexPrivate::QGraphicsSceneIndexPrivate

(

QGraphicsScene *

scene

)

Constructs a private scene index.

Definition at line 223 of file qgraphicssceneindex.cpp.

                                                                            : scene(scene)
{
    pointIntersector = new QGraphicsSceneIndexPointIntersector;
    rectIntersector = new QGraphicsSceneIndexRectIntersector;
    pathIntersector =  new QGraphicsSceneIndexPathIntersector;
}

~QGraphicsSceneIndexPrivate()

QGraphicsSceneIndexPrivate::~QGraphicsSceneIndexPrivate

(

)

Destructor of private scene index.

Definition at line 233 of file qgraphicssceneindex.cpp.

{
    delete pointIntersector;
    delete rectIntersector;
    delete pathIntersector;
}

Functions

init()

void QGraphicsSceneIndexPrivate::init

(

)

Definition at line 361 of file qgraphicssceneindex.cpp.

{
    if (!scene)
        return;

    QObject::connect(scene, SIGNAL(sceneRectChanged(QRectF)),
                     q_func(), SLOT(updateSceneRect(QRectF)));
}

itemCollidesWithPath()

bool QGraphicsSceneIndexPrivate::itemCollidesWithPath ( const QGraphicsItem *  item, const QPainterPath &  path, Qt::ItemSelectionMode  mode  )

static

Checks if item collides with the path and mode, but also checks that if it doesn't collide, maybe its frame rect will.

Warning

This function is not part of the public interface.

Definition at line 249 of file qgraphicssceneindex.cpp.

Referenced by QGraphicsSceneIndexRectIntersector::intersect(), QGraphicsSceneIndexPointIntersector::intersect(), and QGraphicsSceneIndexPathIntersector::intersect().

{
    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;
}

items_helper()

void QGraphicsSceneIndexPrivate::items_helper ( const QRectF &  rect, QGraphicsSceneIndexIntersector *  intersector, QList< QGraphicsItem *> *  items, const QTransform &  viewTransform, Qt::ItemSelectionMode  mode, Qt::SortOrder  order  ) const

inline

Definition at line 152 of file qgraphicssceneindex_p.h.

{
    Q_Q(const QGraphicsSceneIndex);
    const QList<QGraphicsItem *> tli = q->estimateTopLevelItems(rect, Qt::AscendingOrder);
    for (int i = 0; i < tli.size(); ++i)
        recursive_items_helper(tli.at(i), rect, intersector, items, viewTransform, mode);
    if (order == Qt::DescendingOrder) {
        const int n = items->size();
        for (int i = 0; i < n / 2; ++i)
            items->swap(i, n - i - 1);
    }
}

recursive_items_helper()

void QGraphicsSceneIndexPrivate::recursive_items_helper	(	QGraphicsItem *	item,
		QRectF	exposeRect,
		QGraphicsSceneIndexIntersector *	intersector,
		QList< QGraphicsItem *> *	items,
		const QTransform &	viewTransform,
		Qt::ItemSelectionMode	mode,
		qreal	parentOpacity = 1.0
	)		const

This function returns the items in ascending order.

Warning

This function is not part of the public interface.

Definition at line 279 of file qgraphicssceneindex.cpp.

{
    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);
        }
    }
}

Properties

pathIntersector

QGraphicsSceneIndexPathIntersector* QGraphicsSceneIndexPrivate::pathIntersector

Definition at line 149 of file qgraphicssceneindex_p.h.

Referenced by QGraphicsSceneIndexPrivate(), and ~QGraphicsSceneIndexPrivate().

pointIntersector

QGraphicsSceneIndexPointIntersector* QGraphicsSceneIndexPrivate::pointIntersector

Definition at line 147 of file qgraphicssceneindex_p.h.

Referenced by QGraphicsSceneIndexPrivate(), and ~QGraphicsSceneIndexPrivate().

rectIntersector

QGraphicsSceneIndexRectIntersector* QGraphicsSceneIndexPrivate::rectIntersector

Definition at line 148 of file qgraphicssceneindex_p.h.

Referenced by QGraphicsSceneIndexPrivate(), and ~QGraphicsSceneIndexPrivate().

scene

QGraphicsScene* QGraphicsSceneIndexPrivate::scene

Definition at line 146 of file qgraphicssceneindex_p.h.

Referenced by init().

---

The documentation for this class was generated from the following files:

• /src/gui/graphicsview/qgraphicssceneindex_p.h
• /src/gui/graphicsview/qgraphicssceneindex.cpp