#include <qgraphicsscene_p.h>

Inheritance diagram for QGraphicsScenePrivate:

Public Functions
void	_q_emitUpdated ()

void	_q_polishItems ()

void	_q_processDirtyItems ()

void	_q_updateLater ()

void	_q_updateScenePosDescendants ()

void	addPopup (QGraphicsWidget *widget)

void	addView (QGraphicsView *view)

void	cancelGesturesForChildren (QGesture *original)

void	clearKeyboardGrabber ()

void	clearMouseGrabber ()

void	cloneDragDropEvent (QGraphicsSceneDragDropEvent dest, QGraphicsSceneDragDropEvent source)

bool	dispatchHoverEvent (QGraphicsSceneHoverEvent *hoverEvent)
	This event handler, for event hoverEvent, can be reimplemented in a subclass to receive hover enter events. More...

void	draw (QGraphicsItem , QPainter , const QTransform const, const QTransform const, QRegion , QWidget , qreal, const QTransform *const, bool, bool)

void	drawItemHelper (QGraphicsItem item, QPainter painter, const QStyleOptionGraphicsItem option, QWidget widget, bool painterStateProtection)
	Draws items directly, or using cache. More...

void	drawItems (QPainter painter, const QTransform const viewTransform, QRegion exposedRegion, QWidget widget)

void	drawSubtreeRecursive (QGraphicsItem item, QPainter painter, const QTransform const, QRegion exposedRegion, QWidget widget, qreal parentOpacity=qreal(1.0), const QTransform const effectTransform=0)

void	enableMouseTrackingOnViews ()

void	enableTouchEventsOnViews ()

void	ensureSequentialTopLevelSiblingIndexes ()
	Ensures that the list of toplevels is sorted by insertion order, and that the siblingIndexes are packed (no gaps), and start at 0. More...

void	ensureSortedTopLevelItems ()

void	enterModal (QGraphicsItem *item, QGraphicsItem::PanelModality panelModality=QGraphicsItem::NonModal)

bool	filterDescendantEvent (QGraphicsItem item, QEvent event)

bool	filterEvent (QGraphicsItem item, QEvent event)

int	findClosestTouchPointId (const QPointF &scenePos)

void	gestureEventHandler (QGestureEvent *event)

void	gestureTargetsAtHotSpots (const QSet< QGesture > &gestures, Qt::GestureFlag flag, QHash< QGraphicsObject , QSet< QGesture > > targets, QSet< QGraphicsObject > itemsSet=0, QSet< QGesture > normal=0, QSet< QGesture > conflicts=0)

void	grabGesture (QGraphicsItem *, Qt::GestureType gesture)

void	grabKeyboard (QGraphicsItem *item)

void	grabMouse (QGraphicsItem *item, bool implicit=false)

void	init ()

void	installSceneEventFilter (QGraphicsItem watched, QGraphicsItem filter)

bool	itemAcceptsHoverEvents_helper (const QGraphicsItem *item) const

QList< QGraphicsItem * >	itemsAtPosition (const QPoint &screenPos, const QPointF &scenePos, QWidget *widget) const
	Returns all items for the screen position in event. More...

void	leaveModal (QGraphicsItem *item)

void	leaveScene (QWidget *viewport)
	Handles all actions necessary to clean up the scene when the mouse leaves the view. More...

void	markDirty (QGraphicsItem *item, const QRectF &rect=QRectF(), bool invalidateChildren=false, bool force=false, bool ignoreOpacity=false, bool removingItemFromScene=false, bool updateBoundingRect=false)

void	mousePressEventHandler (QGraphicsSceneMouseEvent *mouseEvent)

void	processDirtyItemsRecursive (QGraphicsItem *item, bool dirtyAncestorContainsChildren=false, qreal parentOpacity=qreal(1.0))

	QGraphicsScenePrivate ()

void	registerScenePosItem (QGraphicsItem *item)

void	registerTopLevelItem (QGraphicsItem *item)

void	removeItemHelper (QGraphicsItem *item)
	Schedules an item for removal. More...

void	removePopup (QGraphicsWidget *widget, bool itemIsDying=false)
	Remove widget from the popup list. More...

void	removeSceneEventFilter (QGraphicsItem watched, QGraphicsItem filter)

void	removeView (QGraphicsView *view)

void	resetDirtyItem (QGraphicsItem *item, bool recursive=false)

void	resolveFont ()
	Resolve the scene's font against the application font, and propagate the changes too all items in the scene. More...

void	resolvePalette ()
	Resolve the scene's palette against the application palette, and propagate the changes too all items in the scene. More...

void	sendDragDropEvent (QGraphicsItem item, QGraphicsSceneDragDropEvent dragDropEvent)

bool	sendEvent (QGraphicsItem item, QEvent event)
	This is the final dispatch point for any events from the scene to the item. More...

void	sendHoverEvent (QEvent::Type type, QGraphicsItem item, QGraphicsSceneHoverEvent hoverEvent)

void	sendMouseEvent (QGraphicsSceneMouseEvent *mouseEvent)

bool	sendTouchBeginEvent (QGraphicsItem item, QTouchEvent touchEvent)

void	setActivePanelHelper (QGraphicsItem *item, bool duringActivationEvent)

void	setFocusItemHelper (QGraphicsItem *item, Qt::FocusReason focusReason)

void	setFont_helper (const QFont &font)
	Set the font and propagate the changes if the font is different from the current font. More...

void	setPalette_helper (const QPalette &palette)
	Set the palette and propagate the changes if the palette is different from the current palette. More...

void	setScenePosItemEnabled (QGraphicsItem *item, bool enabled)

void	storeMouseButtonsForMouseGrabber (QGraphicsSceneMouseEvent *event)

void	touchEventHandler (QTouchEvent *touchEvent)

void	ungrabGesture (QGraphicsItem *, Qt::GestureType gesture)

void	ungrabKeyboard (QGraphicsItem *item, bool itemIsDying=false)

void	ungrabMouse (QGraphicsItem *item, bool itemIsDying=false)

void	unregisterScenePosItem (QGraphicsItem *item)

void	unregisterTopLevelItem (QGraphicsItem *item)

void	updateFont (const QFont &font)
	Update the font, and whether or not it has changed, reresolve all fonts in the scene. More...

void	updateInputMethodSensitivityInViews ()

void	updatePalette (const QPalette &palette)
	Update the palette, and whether or not it has changed, reresolve all palettes in the scene. More...

QGraphicsWidget *	windowForItem (const QGraphicsItem *item) const

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 QGraphicsScenePrivate *	get (QGraphicsScene *q)

static void	updateTouchPointsForItem (QGraphicsItem item, QTouchEvent touchEvent)

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
int	activationRefCount

QGraphicsItem *	activePanel

quint32	allItemsIgnoreHoverEvents: 1

quint32	allItemsIgnoreTouchEvents: 1

quint32	allItemsUseDefaultCursor: 1

QBrush	backgroundBrush

QHash< QGraphicsObject , QSet< QGesture > >	cachedAlreadyDeliveredGestures

QHash< QGraphicsObject , QSet< QGesture > >	cachedItemGestures

QList< QGraphicsItem * >	cachedItemsUnderMouse

QList< QGraphicsObject * >	cachedTargetItems

quint32	calledEmitUpdated: 1

int	changedSignalIndex

int	childExplicitActivation

quint32	dirtyGrowingItemsBoundingRect: 1

QGraphicsItem *	dragDropItem

QGraphicsWidget *	enterWidget

QGraphicsItem *	focusItem

QFont	font

QBrush	foregroundBrush

QHash< QGesture , QGraphicsObject >	gestureTargets

QHash< Qt::GestureType, int >	grabbedGestures

QRectF	growingItemsBoundingRect

quint32	hasFocus: 1

quint32	hasSceneRect: 1

quint32	holesInTopLevelSiblingIndex: 1

QList< QGraphicsItem * >	hoverItems

QGraphicsSceneIndex *	index

QGraphicsScene::ItemIndexMethod	indexMethod

QMap< int, QGraphicsItem * >	itemForTouchPointId

QList< QGraphicsItem * >	keyboardGrabberItems

QGraphicsItem *	lastActivePanel

Qt::DropAction	lastDropAction

QGraphicsItem *	lastFocusItem

int	lastItemCount

QGraphicsItem *	lastMouseGrabberItem

quint32	lastMouseGrabberItemHasImplicitMouseGrab: 1

QPointF	lastSceneMousePos

QList< QGraphicsItem * >	modalPanels

QMap< Qt::MouseButton, QPointF >	mouseGrabberButtonDownPos

QMap< Qt::MouseButton, QPointF >	mouseGrabberButtonDownScenePos

QMap< Qt::MouseButton, QPoint >	mouseGrabberButtonDownScreenPos

QList< QGraphicsItem * >	mouseGrabberItems

QMap< QGraphicsItem *, QPointF >	movingItemsInitialPositions

quint32	needSortTopLevelItems: 1

quint32	padding: 15

quint32	painterStateProtection: 1

QPalette	palette

QGraphicsItem *	passiveFocusItem

int	polishItemsIndex

QList< QGraphicsWidget * >	popupWidgets

quint32	processDirtyItemsEmitted: 1

int	processDirtyItemsIndex

quint32	rectAdjust

QMap< int, QTouchEvent::TouchPoint >	sceneCurrentTouchPoints

QMultiMap< QGraphicsItem , QGraphicsItem >	sceneEventFilters

quint32	scenePosDescendantsUpdatePending: 1

QSet< QGraphicsItem * >	scenePosItems

QRectF	sceneRect

QSet< QGraphicsItem * >	selectedItems

QPainterPath	selectionArea

int	selectionChanging

quint32	sortCacheEnabled: 1

quint32	stickyFocus: 1

QStyle *	style

QStyleOptionGraphicsItem	styleOptionTmp

QGraphicsWidget *	tabFocusFirst

QList< QGraphicsItem * >	topLevelItems

quint32	topLevelSequentialOrdering: 1

QVector< QGraphicsItem * >	unpolishedItems

quint32	updateAll: 1

QList< QRectF >	updatedRects

QList< QGraphicsView * >	views

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 81 of file qgraphicsscene_p.h.

Constructors and Destructors

◆ QGraphicsScenePrivate()

QGraphicsScenePrivate::QGraphicsScenePrivate ( )

Warning: This function is not part of the public interface.

Definition at line 296 of file qgraphicsscene.cpp.

     : indexMethod(QGraphicsScene::BspTreeIndex),
       index(0),
       lastItemCount(0),
       hasSceneRect(false),
       dirtyGrowingItemsBoundingRect(true),
       updateAll(false),
       calledEmitUpdated(false),
       processDirtyItemsEmitted(false),
       needSortTopLevelItems(true),
       holesInTopLevelSiblingIndex(false),
       topLevelSequentialOrdering(true),
       scenePosDescendantsUpdatePending(false),
       stickyFocus(false),
       hasFocus(false),
       lastMouseGrabberItemHasImplicitMouseGrab(false),
       allItemsIgnoreHoverEvents(true),
       allItemsUseDefaultCursor(true),
       painterStateProtection(true),
       sortCacheEnabled(false),
       allItemsIgnoreTouchEvents(true),
       selectionChanging(0),
       rectAdjust(2),
       focusItem(0),
       lastFocusItem(0),
       passiveFocusItem(0),
       tabFocusFirst(0),
       activePanel(0),
       lastActivePanel(0),
       activationRefCount(0),
       childExplicitActivation(0),
       lastMouseGrabberItem(0),
       dragDropItem(0),
       enterWidget(0),
       lastDropAction(Qt::IgnoreAction),
       style(0)
 {
 }

Functions

◆ _q_emitUpdated()

void QGraphicsScenePrivate::_q_emitUpdated ( )

Definition at line 361 of file qgraphicsscene.cpp.

Referenced by _q_processDirtyItems().

 {
     Q_Q(QGraphicsScene);
     calledEmitUpdated = false;
 
     if (dirtyGrowingItemsBoundingRect) {
         if (!hasSceneRect) {
             const QRectF oldGrowingItemsBoundingRect = growingItemsBoundingRect;
             growingItemsBoundingRect |= q->itemsBoundingRect();
             if (oldGrowingItemsBoundingRect != growingItemsBoundingRect)
                 emit q->sceneRectChanged(growingItemsBoundingRect);
         }
         dirtyGrowingItemsBoundingRect = false;
     }
 
     // Ensure all views are connected if anything is connected. This disables
     // the optimization that items send updates directly to the views, but it
     // needs to happen in order to keep compatibility with the behavior from
     // Qt 4.4 and backward.
     if (isSignalConnected(changedSignalIndex)) {
         for (int i = 0; i < views.size(); ++i) {
             QGraphicsView *view = views.at(i);
             if (!view->d_func()->connectedToScene) {
                 view->d_func()->connectedToScene = true;
                 q->connect(q, SIGNAL(changed(QList<QRectF>)),
                            views.at(i), SLOT(updateScene(QList<QRectF>)));
             }
         }
     } else {
         if (views.isEmpty()) {
             updateAll = false;
             return;
         }
         for (int i = 0; i < views.size(); ++i)
             views.at(i)->d_func()->processPendingUpdates();
         // It's important that we update all views before we dispatch, hence two for-loops.
         for (int i = 0; i < views.size(); ++i)
             views.at(i)->d_func()->dispatchPendingUpdateRequests();
         return;
     }
 
     // Notify the changes to anybody interested.
     QList<QRectF> oldUpdatedRects;
     oldUpdatedRects = updateAll ? (QList<QRectF>() << q->sceneRect()) : updatedRects;
     updateAll = false;
     updatedRects.clear();
     emit q->changed(oldUpdatedRects);
 }

◆ _q_polishItems()

void QGraphicsScenePrivate::_q_polishItems ( )

Warning: This function is not part of the public interface.

Definition at line 447 of file qgraphicsscene.cpp.

 {
     if (unpolishedItems.isEmpty())
         return;
 
     const QVariant booleanTrueVariant(true);
     QGraphicsItem *item = 0;
     QGraphicsItemPrivate *itemd = 0;
     const int oldUnpolishedCount = unpolishedItems.count();
 
     for (int i = 0; i < oldUnpolishedCount; ++i) {
         item = unpolishedItems.at(i);
         if (!item)
             continue;
         itemd = item->d_ptr.data();
         itemd->pendingPolish = false;
         if (!itemd->explicitlyHidden) {
             item->itemChange(QGraphicsItem::ItemVisibleChange, booleanTrueVariant);
             item->itemChange(QGraphicsItem::ItemVisibleHasChanged, booleanTrueVariant);
         }
         if (itemd->isWidget) {
             QEvent event(QEvent::Polish);
             QApplication::sendEvent((QGraphicsWidget *)item, &event);
         }
     }
 
     if (unpolishedItems.count() == oldUnpolishedCount) {
         // No new items were added to the vector.
         unpolishedItems.clear();
     } else {
         // New items were appended; keep them and remove the old ones.
         unpolishedItems.remove(0, oldUnpolishedCount);
         unpolishedItems.squeeze();
         QMetaObject::invokeMethod(q_ptr, "_q_polishItems", Qt::QueuedConnection);
     }
 }

◆ _q_processDirtyItems()

void QGraphicsScenePrivate::_q_processDirtyItems ( )

Definition at line 484 of file qgraphicsscene.cpp.

 {
     processDirtyItemsEmitted = false;
 
     if (updateAll) {
         Q_ASSERT(calledEmitUpdated);
         // No need for further processing (except resetting the dirty states).
         // The growingItemsBoundingRect is updated in _q_emitUpdated.
         for (int i = 0; i < topLevelItems.size(); ++i)
             resetDirtyItem(topLevelItems.at(i), /*recursive=*/true);
         return;
     }
 
     const bool wasPendingSceneUpdate = calledEmitUpdated;
     const QRectF oldGrowingItemsBoundingRect = growingItemsBoundingRect;
 
     // Process items recursively.
     for (int i = 0; i < topLevelItems.size(); ++i)
         processDirtyItemsRecursive(topLevelItems.at(i));
 
     dirtyGrowingItemsBoundingRect = false;
     if (!hasSceneRect && oldGrowingItemsBoundingRect != growingItemsBoundingRect)
         emit q_func()->sceneRectChanged(growingItemsBoundingRect);
 
     if (wasPendingSceneUpdate)
         return;
 
     for (int i = 0; i < views.size(); ++i)
         views.at(i)->d_func()->processPendingUpdates();
 
     if (calledEmitUpdated) {
         // We did a compatibility QGraphicsScene::update in processDirtyItemsRecursive
         // and we cannot wait for the control to reach the eventloop before the
         // changed signal is emitted, so we emit it now.
         _q_emitUpdated();
     }
 
     // Immediately dispatch all pending update requests on the views.
     for (int i = 0; i < views.size(); ++i)
         views.at(i)->d_func()->dispatchPendingUpdateRequests();
 }

◆ _q_updateLater()

void QGraphicsScenePrivate::_q_updateLater ( )

◆ _q_updateScenePosDescendants()

void QGraphicsScenePrivate::_q_updateScenePosDescendants ( )

Warning: This function is not part of the public interface.

Definition at line 563 of file qgraphicsscene.cpp.

 {
     foreach (QGraphicsItem *item, scenePosItems) {
         QGraphicsItem *p = item->d_ptr->parent;
         while (p) {
             p->d_ptr->scenePosDescendants = 1;
             p = p->d_ptr->parent;
         }
     }
     scenePosDescendantsUpdatePending = false;
 }

◆ addPopup()

void QGraphicsScenePrivate::addPopup ( QGraphicsWidget * widget )

Warning: This function is not part of the public interface.

Definition at line 872 of file qgraphicsscene.cpp.

 {
     Q_ASSERT(widget);
     Q_ASSERT(!popupWidgets.contains(widget));
     popupWidgets << widget;
     if (QGraphicsWidget *focusWidget = widget->focusWidget()) {
         focusWidget->setFocus(Qt::PopupFocusReason);
     } else {
         grabKeyboard((QGraphicsItem *)widget);
         if (focusItem && popupWidgets.size() == 1) {
             QFocusEvent event(QEvent::FocusOut, Qt::PopupFocusReason);
             sendEvent(focusItem, &event);
         }
     }
     grabMouse((QGraphicsItem *)widget);
 }

◆ addView()

void QGraphicsScenePrivate::addView ( QGraphicsView * view )

Definition at line 5938 of file qgraphicsscene.cpp.

 {
     views << view;
 #ifndef QT_NO_GESTURES
     foreach (Qt::GestureType gesture, grabbedGestures.keys())
         view->viewport()->grabGesture(gesture);
 #endif
 }

◆ cancelGesturesForChildren()

void QGraphicsScenePrivate::cancelGesturesForChildren ( QGesture * original )

Definition at line 6570 of file qgraphicsscene.cpp.

 {
     Q_ASSERT(original);
     QGraphicsItem *originalItem = gestureTargets.value(original);
     if (originalItem == 0) // we only act on accepted gestures, which implies it has a target.
         return;
 
     // iterate over all active gestures and for each find the owner
     // if the owner is part of our sub-hierarchy, cancel it.
 
     QSet<QGesture *> canceledGestures;
     QHash<QGesture *, QGraphicsObject *>::Iterator iter = gestureTargets.begin();
     while (iter != gestureTargets.end()) {
         QGraphicsObject *item = iter.value();
         // note that we don't touch the gestures for our originalItem
         if (item != originalItem && originalItem->isAncestorOf(item)) {
             G_DEBUG() << "  found a gesture to cancel" << iter.key();
             iter.key()->d_func()->state = Qt::GestureCanceled;
             canceledGestures << iter.key();
         }
         ++iter;
     }
 
     // sort them per target item by cherry picking from almostCanceledGestures and delivering
     QSet<QGesture *> almostCanceledGestures = canceledGestures;
     QSet<QGesture *>::Iterator setIter;
     while (!almostCanceledGestures.isEmpty()) {
         QGraphicsObject *target = 0;
         QSet<QGesture*> gestures;
         setIter = almostCanceledGestures.begin();
         // sort per target item
         while (setIter != almostCanceledGestures.end()) {
             QGraphicsObject *item = gestureTargets.value(*setIter);
             if (target == 0)
                 target = item;
             if (target == item) {
                 gestures << *setIter;
                 setIter = almostCanceledGestures.erase(setIter);
             } else {
                 ++setIter;
             }
         }
         Q_ASSERT(target);
 
         QList<QGesture *> list = gestures.toList();
         QGestureEvent ev(list);
         sendEvent(target, &ev);
 
         foreach (QGesture *g, list) {
             if (ev.isAccepted() || ev.isAccepted(g))
                 gestures.remove(g);
         }
 
         foreach (QGesture *g, gestures) {
             if (!g->hasHotSpot())
                 continue;
 
             QList<QGraphicsItem *> items = itemsAtPosition(QPoint(), g->d_func()->sceneHotSpot, 0);
             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(g->gestureType())) {
                     QList<QGesture *> list;
                     list << g;
                     QGestureEvent ev(list);
                     sendEvent(item, &ev);
                     if (ev.isAccepted() || ev.isAccepted(g))
                         break; // successfully delivered
                 }
             }
         }
     }
 
     QGestureManager *gestureManager = QApplicationPrivate::instance()->gestureManager;
     Q_ASSERT(gestureManager); // it would be very odd if we got called without a manager.
     for (setIter = canceledGestures.begin(); setIter != canceledGestures.end(); ++setIter) {
         gestureManager->recycle(*setIter);
         gestureTargets.remove(*setIter);
     }
 }

◆ clearKeyboardGrabber()

void QGraphicsScenePrivate::clearKeyboardGrabber ( )

Warning: This function is not part of the public interface.

Definition at line 1086 of file qgraphicsscene.cpp.

 {
     if (!keyboardGrabberItems.isEmpty())
         ungrabKeyboard(keyboardGrabberItems.first());
 }

◆ clearMouseGrabber()

void QGraphicsScenePrivate::clearMouseGrabber ( )

Warning: This function is not part of the public interface.

Definition at line 1015 of file qgraphicsscene.cpp.

Referenced by sendMouseEvent().

 {
     if (!mouseGrabberItems.isEmpty())
         mouseGrabberItems.first()->ungrabMouse();
     lastMouseGrabberItem = 0;
 }

◆ cloneDragDropEvent()

void QGraphicsScenePrivate::cloneDragDropEvent	(	QGraphicsSceneDragDropEvent *	dest,
		QGraphicsSceneDragDropEvent *	source
	)

Warning: This function is not part of the public interface.

Definition at line 1244 of file qgraphicsscene.cpp.

 {
     dest->setWidget(source->widget());
     dest->setPos(source->pos());
     dest->setScenePos(source->scenePos());
     dest->setScreenPos(source->screenPos());
     dest->setButtons(source->buttons());
     dest->setModifiers(source->modifiers());
     dest->setPossibleActions(source->possibleActions());
     dest->setProposedAction(source->proposedAction());
     dest->setDropAction(source->dropAction());
     dest->setSource(source->source());
     dest->setMimeData(source->mimeData());
 }

◆ dispatchHoverEvent()

bool QGraphicsScenePrivate::dispatchHoverEvent ( QGraphicsSceneHoverEvent * hoverEvent )

This event handler, for event hoverEvent, can be reimplemented in a subclass to receive hover enter events.

The default implementation forwards the event to the topmost item that accepts hover events at the scene position from the event.

See also: QGraphicsItem::hoverEvent(), QGraphicsItem::setAcceptHoverEvents()

Definition at line 3999 of file qgraphicsscene.cpp.

 {
     if (allItemsIgnoreHoverEvents)
         return false;
 
     // Find the first item that accepts hover events, reusing earlier
     // calculated data is possible.
     if (cachedItemsUnderMouse.isEmpty()) {
         cachedItemsUnderMouse = itemsAtPosition(hoverEvent->screenPos(),
                                                 hoverEvent->scenePos(),
                                                 hoverEvent->widget());
     }
 
     QGraphicsItem *item = 0;
     for (int i = 0; i < cachedItemsUnderMouse.size(); ++i) {
         QGraphicsItem *tmp = cachedItemsUnderMouse.at(i);
         if (itemAcceptsHoverEvents_helper(tmp)) {
             item = tmp;
             break;
         }
     }
 
     // Find the common ancestor item for the new topmost hoverItem and the
     // last item in the hoverItem list.
     QGraphicsItem *commonAncestorItem = (item && !hoverItems.isEmpty()) ? item->commonAncestorItem(hoverItems.last()) : 0;
     while (commonAncestorItem && !itemAcceptsHoverEvents_helper(commonAncestorItem))
         commonAncestorItem = commonAncestorItem->parentItem();
     if (commonAncestorItem && commonAncestorItem->panel() != item->panel()) {
         // The common ancestor isn't in the same panel as the two hovered
         // items.
         commonAncestorItem = 0;
     }
 
     // Check if the common ancestor item is known.
     int index = commonAncestorItem ? hoverItems.indexOf(commonAncestorItem) : -1;
     // Send hover leaves to any existing hovered children of the common
     // ancestor item.
     for (int i = hoverItems.size() - 1; i > index; --i) {
         QGraphicsItem *lastItem = hoverItems.takeLast();
         if (itemAcceptsHoverEvents_helper(lastItem))
             sendHoverEvent(QEvent::GraphicsSceneHoverLeave, lastItem, hoverEvent);
     }
 
     // Item is a child of a known item. Generate enter events for the
     // missing links.
     QList<QGraphicsItem *> parents;
     QGraphicsItem *parent = item;
     while (parent && parent != commonAncestorItem) {
         parents.prepend(parent);
         if (parent->isPanel()) {
             // Stop at the panel - we don't deliver beyond this point.
             break;
         }
         parent = parent->parentItem();
     }
     for (int i = 0; i < parents.size(); ++i) {
         parent = parents.at(i);
         hoverItems << parent;
         if (itemAcceptsHoverEvents_helper(parent))
             sendHoverEvent(QEvent::GraphicsSceneHoverEnter, parent, hoverEvent);
     }
 
     // Generate a move event for the item itself
     if (item
         && !hoverItems.isEmpty()
         && item == hoverItems.last()) {
         sendHoverEvent(QEvent::GraphicsSceneHoverMove, item, hoverEvent);
         return true;
     }
     return false;
 }

◆ draw()

void QGraphicsScenePrivate::draw	(	QGraphicsItem *	item,
		QPainter *	painter,
		const QTransform * const	viewTransform,
		const QTransform * const	transformPtr,
		QRegion *	exposedRegion,
		QWidget *	widget,
		qreal	opacity,
		const QTransform * const	effectTransform,
		bool	wasDirtyParentSceneTransform,
		bool	drawItem
	)

Definition at line 5007 of file qgraphicsscene.cpp.

Referenced by QGraphicsItemEffectSourcePrivate::draw(), and QGraphicsItemEffectSourcePrivate::pixmap().

 {
     const bool itemIsFullyTransparent = QGraphicsItemPrivate::isOpacityNull(opacity);
     const bool itemClipsChildrenToShape = (item->d_ptr->flags & QGraphicsItem::ItemClipsChildrenToShape);
     const bool itemHasChildren = !item->d_ptr->children.isEmpty();
     bool setChildClip = itemClipsChildrenToShape;
     bool itemHasChildrenStackedBehind = false;
 
     int i = 0;
     if (itemHasChildren) {
         if (itemClipsChildrenToShape)
             setWorldTransform(painter, transformPtr, effectTransform);
 
         item->d_ptr->ensureSortedChildren();
         // Items with the 'ItemStacksBehindParent' flag are put in front of the list
         // so all we have to do is to check the first item.
         itemHasChildrenStackedBehind = (item->d_ptr->children.at(0)->d_ptr->flags
                                         & QGraphicsItem::ItemStacksBehindParent);
 
         if (itemHasChildrenStackedBehind) {
             if (itemClipsChildrenToShape) {
                 setClip(painter, item);
                 setChildClip = false;
             }
 
             // Draw 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;
                 drawSubtreeRecursive(child, painter, viewTransform, exposedRegion, widget, opacity, effectTransform);
             }
         }
     }
 
     // Draw item
     if (drawItem) {
         Q_ASSERT(!itemIsFullyTransparent);
         Q_ASSERT(!(item->d_ptr->flags & QGraphicsItem::ItemHasNoContents));
         Q_ASSERT(transformPtr);
         item->d_ptr->initStyleOption(&styleOptionTmp, *transformPtr, exposedRegion
                                      ? *exposedRegion : QRegion(), exposedRegion == 0);
 
         const bool itemClipsToShape = item->d_ptr->flags & QGraphicsItem::ItemClipsToShape;
         bool restorePainterClip = false;
 
         if (!itemHasChildren || !itemClipsChildrenToShape) {
             // Item does not have children or clip children to shape.
             setWorldTransform(painter, transformPtr, effectTransform);
             if ((restorePainterClip = itemClipsToShape))
                 setClip(painter, item);
         } else if (itemHasChildrenStackedBehind){
             // Item clips children to shape and has children stacked behind, which means
             // the painter is already clipped to the item's shape.
             if (itemClipsToShape) {
                 // The clip is already correct. Ensure correct world transform.
                 setWorldTransform(painter, transformPtr, effectTransform);
             } else {
                 // Remove clip (this also ensures correct world transform).
                 painter->restore();
                 setChildClip = true;
             }
         } else if (itemClipsToShape) {
             // Item clips children and itself to shape. It does not have hildren stacked
             // behind, which means the clip has not yet been set. We set it now and re-use it
             // for the children.
             setClip(painter, item);
             setChildClip = false;
         }
 
         if (painterStateProtection && !restorePainterClip)
             painter->save();
 
         painter->setOpacity(opacity);
         if (!item->d_ptr->cacheMode && !item->d_ptr->isWidget)
             item->paint(painter, &styleOptionTmp, widget);
         else
             drawItemHelper(item, painter, &styleOptionTmp, widget, painterStateProtection);
 
         if (painterStateProtection || restorePainterClip)
             painter->restore();
 
         static int drawRect = qgetenv("QT_DRAW_SCENE_ITEM_RECTS").toInt();
         if (drawRect) {
             QPen oldPen = painter->pen();
             QBrush oldBrush = painter->brush();
             quintptr ptr = reinterpret_cast<quintptr>(item);
             const QColor color = QColor::fromHsv(ptr % 255, 255, 255);
             painter->setPen(color);
             painter->setBrush(Qt::NoBrush);
             painter->drawRect(adjustedItemBoundingRect(item));
             painter->setPen(oldPen);
             painter->setBrush(oldBrush);
         }
     }
 
     // Draw children in front
     if (itemHasChildren) {
         if (setChildClip)
             setClip(painter, item);
 
         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;
             drawSubtreeRecursive(child, painter, viewTransform, exposedRegion, widget, opacity, effectTransform);
         }
 
         // Restore child clip
         if (itemClipsChildrenToShape)
             painter->restore();
     }
 }

◆ drawItemHelper()

void QGraphicsScenePrivate::drawItemHelper	(	QGraphicsItem *	item,
		QPainter *	painter,
		const QStyleOptionGraphicsItem *	option,
		QWidget *	widget,
		bool	painterStateProtection
	)

Draws items directly, or using cache.

Warning: This function is not part of the public interface.

Definition at line 4543 of file qgraphicsscene.cpp.

 {
     QGraphicsItemPrivate *itemd = item->d_ptr.data();
     QGraphicsItem::CacheMode cacheMode = QGraphicsItem::CacheMode(itemd->cacheMode);
 
     // Render directly, using no cache.
     if (cacheMode == QGraphicsItem::NoCache
 #ifdef Q_WS_X11
         || !X11->use_xrender
 #endif
         ) {
         _q_paintItem(static_cast<QGraphicsWidget *>(item), painter, option, widget, true, painterStateProtection);
         return;
     }
 
     const qreal oldPainterOpacity = painter->opacity();
     qreal newPainterOpacity = oldPainterOpacity;
     QGraphicsProxyWidget *proxy = item->isWidget() ? qobject_cast<QGraphicsProxyWidget *>(static_cast<QGraphicsWidget *>(item)) : 0;
     if (proxy && proxy->widget()) {
         const qreal windowOpacity = proxy->widget()->windowOpacity();
         if (windowOpacity < 1.0)
             newPainterOpacity *= windowOpacity;
     }
 
     // Item's (local) bounding rect
     QRectF brect = item->boundingRect();
     QRectF adjustedBrect(brect);
     _q_adjustRect(&adjustedBrect);
     if (adjustedBrect.isEmpty())
         return;
 
     // Fetch the off-screen transparent buffer and exposed area info.
     QPixmapCache::Key pixmapKey;
     QPixmap pix;
     bool pixmapFound;
     QGraphicsItemCache *itemCache = itemd->extraItemCache();
     if (cacheMode == QGraphicsItem::ItemCoordinateCache) {
         pixmapKey = itemCache->key;
     } else {
         pixmapKey = itemCache->deviceData.value(widget).key;
     }
 
     // Find pixmap in cache.
     pixmapFound = QPixmapCache::find(pixmapKey, &pix);
 
     // Render using item coordinate cache mode.
     if (cacheMode == QGraphicsItem::ItemCoordinateCache) {
         QSize pixmapSize;
         bool fixedCacheSize = false;
         QRect br = brect.toAlignedRect();
         if ((fixedCacheSize = itemCache->fixedSize.isValid())) {
             pixmapSize = itemCache->fixedSize;
         } else {
             pixmapSize = br.size();
         }
 
         // Create or recreate the pixmap.
         int adjust = itemCache->fixedSize.isValid() ? 0 : 2;
         QSize adjustSize(adjust*2, adjust*2);
         br.adjust(-adjust, -adjust, adjust, adjust);
         if (pix.isNull() || (!fixedCacheSize && (pixmapSize + adjustSize) != pix.size())) {
             pix = QPixmap(pixmapSize + adjustSize);
             itemCache->boundingRect = br;
             itemCache->exposed.clear();
             itemCache->allExposed = true;
         } else if (itemCache->boundingRect != br) {
             itemCache->boundingRect = br;
             itemCache->exposed.clear();
             itemCache->allExposed = true;
         }
 
         // Redraw any newly exposed areas.
         if (itemCache->allExposed || !itemCache->exposed.isEmpty()) {
 
             //We know that we will modify the pixmap, removing it from the cache
             //will detach the one we have and avoid a deep copy
             if (pixmapFound)
                 QPixmapCache::remove(pixmapKey);
 
             // Fit the item's bounding rect into the pixmap's coordinates.
             QTransform itemToPixmap;
             if (fixedCacheSize) {
                 const QPointF scale(pixmapSize.width() / brect.width(), pixmapSize.height() / brect.height());
                 itemToPixmap.scale(scale.x(), scale.y());
             }
             itemToPixmap.translate(-br.x(), -br.y());
 
             // Generate the item's exposedRect and map its list of expose
             // rects to device coordinates.
             styleOptionTmp = *option;
             QRegion pixmapExposed;
             QRectF exposedRect;
             if (!itemCache->allExposed) {
                 for (int i = 0; i < itemCache->exposed.size(); ++i) {
                     QRectF r = itemCache->exposed.at(i);
                     exposedRect |= r;
                     pixmapExposed += itemToPixmap.mapRect(r).toAlignedRect();
                 }
             } else {
                 exposedRect = brect;
             }
             styleOptionTmp.exposedRect = exposedRect;
 
             // Render.
             _q_paintIntoCache(&pix, item, pixmapExposed, itemToPixmap, painter->renderHints(),
                               &styleOptionTmp, painterStateProtection);
 
             // insert this pixmap into the cache.
             itemCache->key = QPixmapCache::insert(pix);
 
             // Reset expose data.
             itemCache->allExposed = false;
             itemCache->exposed.clear();
         }
 
         // Redraw the exposed area using the transformed painter. Depending on
         // the hardware, this may be a server-side operation, or an expensive
         // qpixmap-image-transform-pixmap roundtrip.
         if (newPainterOpacity != oldPainterOpacity) {
             painter->setOpacity(newPainterOpacity);
             painter->drawPixmap(br.topLeft(), pix);
             painter->setOpacity(oldPainterOpacity);
         } else {
             painter->drawPixmap(br.topLeft(), pix);
         }
         return;
     }
 
     // Render using device coordinate cache mode.
     if (cacheMode == QGraphicsItem::DeviceCoordinateCache) {
         // Find the item's bounds in device coordinates.
         QRectF deviceBounds = painter->worldTransform().mapRect(brect);
         QRect deviceRect = deviceBounds.toRect().adjusted(-1, -1, 1, 1);
         if (deviceRect.isEmpty())
             return;
         QRect viewRect = widget ? widget->rect() : QRect();
         if (widget && !viewRect.intersects(deviceRect))
             return;
 
         // Resort to direct rendering if the device rect exceeds the
         // (optional) maximum bounds. (QGraphicsSvgItem uses this).
         QSize maximumCacheSize =
             itemd->extra(QGraphicsItemPrivate::ExtraMaxDeviceCoordCacheSize).toSize();
         if (!maximumCacheSize.isEmpty()
             && (deviceRect.width() > maximumCacheSize.width()
                 || deviceRect.height() > maximumCacheSize.height())) {
             _q_paintItem(static_cast<QGraphicsWidget *>(item), painter, option, widget,
                          oldPainterOpacity != newPainterOpacity, painterStateProtection);
             return;
         }
 
         // 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];
         bool invertable = true;
         QTransform diff = deviceData->lastTransform.inverted(&invertable);
         if (invertable)
             diff *= painter->worldTransform();
         deviceData->lastTransform = painter->worldTransform();
         bool allowPartialCacheExposure = false;
         bool simpleTransform = invertable && diff.type() <= QTransform::TxTranslate
                                && transformIsSimple(painter->worldTransform());
         if (!simpleTransform) {
             pixModified = true;
             itemCache->allExposed = true;
             itemCache->exposed.clear();
             deviceData->cacheIndent = QPoint();
             pix = QPixmap();
         } else if (!viewRect.isNull()) {
             allowPartialCacheExposure = deviceData->cacheIndent != QPoint();
         }
 
         // Allow partial cache exposure if the device rect isn't fully contained and
         // deviceRect is 20% taller or wider than the viewRect.
         if (!allowPartialCacheExposure && !viewRect.isNull() && !viewRect.contains(deviceRect)) {
             allowPartialCacheExposure = (viewRect.width() * 1.2 < deviceRect.width())
                                          || (viewRect.height() * 1.2 < deviceRect.height());
         }
 
         QRegion scrollExposure;
         if (allowPartialCacheExposure) {
             // Part of pixmap is drawn. Either device contains viewrect (big
             // item covers whole screen) or parts of device are outside the
             // viewport. In either case the device rect must be the intersect
             // between the two.
             int dx = deviceRect.left() < viewRect.left() ? viewRect.left() - deviceRect.left() : 0;
             int dy = deviceRect.top() < viewRect.top() ? viewRect.top() - deviceRect.top() : 0;
             QPoint newCacheIndent(dx, dy);
             deviceRect &= viewRect;
 
             if (pix.isNull()) {
                 deviceData->cacheIndent = QPoint();
                 itemCache->allExposed = true;
                 itemCache->exposed.clear();
                 pixModified = true;
             }
 
             // Copy / "scroll" the old pixmap onto the new ole and calculate
             // scrolled exposure.
             if (newCacheIndent != deviceData->cacheIndent || deviceRect.size() != pix.size()) {
                 QPoint diff = newCacheIndent - deviceData->cacheIndent;
                 QPixmap newPix(deviceRect.size());
                 // ### Investigate removing this fill (test with Plasma and
                 // graphicssystem raster).
                 newPix.fill(Qt::transparent);
                 if (!pix.isNull()) {
                     QPainter newPixPainter(&newPix);
                     newPixPainter.drawPixmap(-diff, pix);
                     newPixPainter.end();
                 }
                 QRegion exposed;
                 exposed += newPix.rect();
                 if (!pix.isNull())
                     exposed -= QRect(-diff, pix.size());
                 scrollExposure = exposed;
 
                 pix = newPix;
                 pixModified = true;
             }
             deviceData->cacheIndent = newCacheIndent;
         } else {
             // Full pixmap is drawn.
             deviceData->cacheIndent = QPoint();
 
             // Auto-adjust the pixmap size.
             if (deviceRect.size() != pix.size()) {
                 // exposed needs to cover the whole pixmap
                 pix = QPixmap(deviceRect.size());
                 pixModified = true;
                 itemCache->allExposed = true;
                 itemCache->exposed.clear();
             }
         }
 
         // Check for newly invalidated areas.
         if (itemCache->allExposed || !itemCache->exposed.isEmpty() || !scrollExposure.isEmpty()) {
             //We know that we will modify the pixmap, removing it from the cache
             //will detach the one we have and avoid a deep copy
             if (pixmapFound)
                 QPixmapCache::remove(pixmapKey);
 
             // Construct an item-to-pixmap transform.
             QPointF p = deviceRect.topLeft();
             QTransform itemToPixmap = painter->worldTransform();
             if (!p.isNull())
                 itemToPixmap *= QTransform::fromTranslate(-p.x(), -p.y());
 
             // Map the item's logical expose to pixmap coordinates.
             QRegion pixmapExposed = scrollExposure;
             if (!itemCache->allExposed) {
                 const QVector<QRectF> &exposed = itemCache->exposed;
                 for (int i = 0; i < exposed.size(); ++i)
                     pixmapExposed += itemToPixmap.mapRect(exposed.at(i)).toRect().adjusted(-1, -1, 1, 1);
             }
 
             // Calculate the style option's exposedRect.
             QRectF br;
             if (itemCache->allExposed) {
                 br = item->boundingRect();
             } else {
                 const QVector<QRectF> &exposed = itemCache->exposed;
                 for (int i = 0; i < exposed.size(); ++i)
                     br |= exposed.at(i);
                 QTransform pixmapToItem = itemToPixmap.inverted();
                 foreach (QRect r, scrollExposure.rects())
                     br |= pixmapToItem.mapRect(r);
             }
             styleOptionTmp = *option;
             styleOptionTmp.exposedRect = br.adjusted(-1, -1, 1, 1);
 
             // Render the exposed areas.
             _q_paintIntoCache(&pix, item, pixmapExposed, itemToPixmap, painter->renderHints(),
                               &styleOptionTmp, painterStateProtection);
 
             // Reset expose data.
             pixModified = true;
             itemCache->allExposed = false;
             itemCache->exposed.clear();
         }
 
         if (pixModified) {
             // Insert this pixmap into the cache.
             deviceData->key = QPixmapCache::insert(pix);
         }
 
         // Redraw the exposed area using an untransformed painter. This
         // effectively becomes a bitblit that does not transform the cache.
         QTransform restoreTransform = painter->worldTransform();
         painter->setWorldTransform(QTransform());
         if (newPainterOpacity != oldPainterOpacity) {
             painter->setOpacity(newPainterOpacity);
             painter->drawPixmap(deviceRect.topLeft(), pix);
             painter->setOpacity(oldPainterOpacity);
         } else {
             painter->drawPixmap(deviceRect.topLeft(), pix);
         }
         painter->setWorldTransform(restoreTransform);
         return;
     }
 }

◆ drawItems()

void QGraphicsScenePrivate::drawItems	(	QPainter *	painter,
		const QTransform *const	viewTransform,
		QRegion *	exposedRegion,
		QWidget *	widget
	)

Definition at line 4848 of file qgraphicsscene.cpp.

 {
     // Make sure we don't have unpolished items before we draw.
     if (!unpolishedItems.isEmpty())
         _q_polishItems();
 
     updateAll = false;
     QRectF exposedSceneRect;
     if (exposedRegion && indexMethod != QGraphicsScene::NoIndex) {
         exposedSceneRect = exposedRegion->boundingRect().adjusted(-1, -1, 1, 1);
         if (viewTransform)
             exposedSceneRect = viewTransform->inverted().mapRect(exposedSceneRect);
     }
     const QList<QGraphicsItem *> tli = index->estimateTopLevelItems(exposedSceneRect, Qt::AscendingOrder);
     for (int i = 0; i < tli.size(); ++i)
         drawSubtreeRecursive(tli.at(i), painter, viewTransform, exposedRegion, widget);
 }

◆ drawSubtreeRecursive()

void QGraphicsScenePrivate::drawSubtreeRecursive	(	QGraphicsItem *	item,
		QPainter *	painter,
		const QTransform * const	viewTransform,
		QRegion *	exposedRegion,
		QWidget *	widget,
		qreal	parentOpacity = `qreal(1.0)`,
		const QTransform *const	effectTransform = `0`
	)

Definition at line 4867 of file qgraphicsscene.cpp.

 {
     Q_ASSERT(item);
 
     if (!item->d_ptr->visible)
         return;
 
     const bool itemHasContents = !(item->d_ptr->flags & QGraphicsItem::ItemHasNoContents);
     const bool itemHasChildren = !item->d_ptr->children.isEmpty();
     if (!itemHasContents && !itemHasChildren)
         return; // Item has neither contents nor children!(?)
 
     const qreal opacity = item->d_ptr->combineOpacityFromParent(parentOpacity);
     const bool itemIsFullyTransparent = QGraphicsItemPrivate::isOpacityNull(opacity);
     if (itemIsFullyTransparent && (!itemHasChildren || item->d_ptr->childrenCombineOpacity()))
         return;
 
     QTransform transform(Qt::Uninitialized);
     QTransform *transformPtr = 0;
     bool translateOnlyTransform = false;
 #define ENSURE_TRANSFORM_PTR \
     if (!transformPtr) { \
         Q_ASSERT(!itemIsUntransformable); \
         if (viewTransform) { \
             transform = item->d_ptr->sceneTransform; \
             transform *= *viewTransform; \
             transformPtr = &transform; \
         } else { \
             transformPtr = &item->d_ptr->sceneTransform; \
             translateOnlyTransform = item->d_ptr->sceneTransformTranslateOnly; \
         } \
     }
 
     // Update the item's scene transform if the item is transformable;
     // otherwise calculate the full transform,
     bool wasDirtyParentSceneTransform = false;
     const bool itemIsUntransformable = item->d_ptr->itemIsUntransformable();
     if (itemIsUntransformable) {
         transform = item->deviceTransform(viewTransform ? *viewTransform : QTransform());
         transformPtr = &transform;
     } else if (item->d_ptr->dirtySceneTransform) {
         item->d_ptr->updateSceneTransformFromParent();
         Q_ASSERT(!item->d_ptr->dirtySceneTransform);
         wasDirtyParentSceneTransform = true;
     }
 
     const bool itemClipsChildrenToShape = (item->d_ptr->flags & QGraphicsItem::ItemClipsChildrenToShape);
     bool drawItem = itemHasContents && !itemIsFullyTransparent;
     if (drawItem) {
         const QRectF brect = adjustedItemEffectiveBoundingRect(item);
         ENSURE_TRANSFORM_PTR
         QRect viewBoundingRect = translateOnlyTransform ? brect.translated(transformPtr->dx(), transformPtr->dy()).toAlignedRect()
                                                         : transformPtr->mapRect(brect).toAlignedRect();
         viewBoundingRect.adjust(-int(rectAdjust), -int(rectAdjust), rectAdjust, rectAdjust);
         if (widget)
             item->d_ptr->paintedViewBoundingRects.insert(widget, viewBoundingRect);
         drawItem = exposedRegion ? exposedRegion->intersects(viewBoundingRect)
                                  : !viewBoundingRect.normalized().isEmpty();
         if (!drawItem) {
             if (!itemHasChildren)
                 return;
             if (itemClipsChildrenToShape) {
                 if (wasDirtyParentSceneTransform)
                     item->d_ptr->invalidateChildrenSceneTransform();
                 return;
             }
         }
     } // else we know for sure this item has children we must process.
 
     if (itemHasChildren && itemClipsChildrenToShape)
         ENSURE_TRANSFORM_PTR;
 
 #ifndef QT_NO_GRAPHICSEFFECT
     if (item->d_ptr->graphicsEffect && item->d_ptr->graphicsEffect->isEnabled()) {
         ENSURE_TRANSFORM_PTR;
         QGraphicsItemPaintInfo info(viewTransform, transformPtr, effectTransform, exposedRegion, widget, &styleOptionTmp,
                                     painter, opacity, wasDirtyParentSceneTransform, itemHasContents && !itemIsFullyTransparent);
         QGraphicsEffectSource *source = item->d_ptr->graphicsEffect->d_func()->source;
         QGraphicsItemEffectSourcePrivate *sourced = static_cast<QGraphicsItemEffectSourcePrivate *>
                                                     (source->d_func());
         sourced->info = &info;
         const QTransform restoreTransform = painter->worldTransform();
         if (effectTransform)
             painter->setWorldTransform(*transformPtr * *effectTransform);
         else
             painter->setWorldTransform(*transformPtr);
         painter->setOpacity(opacity);
 
         if (sourced->currentCachedSystem() != Qt::LogicalCoordinates
             && sourced->lastEffectTransform != painter->worldTransform())
         {
             if (sourced->lastEffectTransform.type() <= QTransform::TxTranslate
                 && painter->worldTransform().type() <= QTransform::TxTranslate)
             {
                 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();
         }
 
         item->d_ptr->graphicsEffect->draw(painter);
         painter->setWorldTransform(restoreTransform);
         sourced->info = 0;
     } else
 #endif //QT_NO_GRAPHICSEFFECT
     {
         draw(item, painter, viewTransform, transformPtr, exposedRegion, widget, opacity,
              effectTransform, wasDirtyParentSceneTransform, drawItem);
     }
 }

◆ enableMouseTrackingOnViews()

void QGraphicsScenePrivate::enableMouseTrackingOnViews ( )

Definition at line 1092 of file qgraphicsscene.cpp.

 {
     foreach (QGraphicsView *view, views)
         view->viewport()->setMouseTracking(true);
 }

◆ enableTouchEventsOnViews()

void QGraphicsScenePrivate::enableTouchEventsOnViews ( )

Definition at line 6176 of file qgraphicsscene.cpp.

 {
     foreach (QGraphicsView *view, views)
         view->viewport()->setAttribute(Qt::WA_AcceptTouchEvents, true);
 }

◆ ensureSequentialTopLevelSiblingIndexes()

void QGraphicsScenePrivate::ensureSequentialTopLevelSiblingIndexes ( )

Ensures that the list of toplevels is sorted by insertion order, and that the siblingIndexes are packed (no gaps), and start at 0.

Warning: This function is not part of the public interface.

This function is almost identical to

QGraphicsItemPrivate::ensureSequentialSiblingIndex().

Definition at line 1490 of file qgraphicsscene.cpp.

 {
     if (!topLevelSequentialOrdering) {
         qSort(topLevelItems.begin(), topLevelItems.end(), QGraphicsItemPrivate::insertionOrder);
         topLevelSequentialOrdering = true;
         needSortTopLevelItems = 1;
     }
     if (holesInTopLevelSiblingIndex) {
         holesInTopLevelSiblingIndex = 0;
         for (int i = 0; i < topLevelItems.size(); ++i)
             topLevelItems[i]->d_ptr->siblingIndex = i;
     }
 }

◆ ensureSortedTopLevelItems()

void QGraphicsScenePrivate::ensureSortedTopLevelItems ( )

inline

Definition at line 271 of file qgraphicsscene_p.h.

Referenced by QGraphicsSceneIndex::estimateTopLevelItems().

     {
         if (needSortTopLevelItems) {
             qSort(topLevelItems.begin(), topLevelItems.end(), qt_notclosestLeaf);
             topLevelSequentialOrdering = false;
             needSortTopLevelItems = false;
         }
     }

◆ enterModal()

void QGraphicsScenePrivate::enterModal	(	QGraphicsItem *	item,
		QGraphicsItem::PanelModality	panelModality = `QGraphicsItem::NonModal`
	)

Definition at line 6188 of file qgraphicsscene.cpp.

 {
     Q_Q(QGraphicsScene);
     Q_ASSERT(panel && panel->isPanel());
 
     QGraphicsItem::PanelModality panelModality = panel->d_ptr->panelModality;
     if (previousModality != QGraphicsItem::NonModal) {
         // the panel is changing from one modality type to another... temporarily set it back so
         // that blockedPanels is populated correctly
         panel->d_ptr->panelModality = previousModality;
     }
 
     QSet<QGraphicsItem *> blockedPanels;
     QList<QGraphicsItem *> items = q->items(); // ### store panels separately
     for (int i = 0; i < items.count(); ++i) {
         QGraphicsItem *item = items.at(i);
         if (item->isPanel() && item->isBlockedByModalPanel())
             blockedPanels.insert(item);
     }
     // blockedPanels contains all currently blocked panels
 
     if (previousModality != QGraphicsItem::NonModal) {
         // reset the modality to the proper value, since we changed it above
         panel->d_ptr->panelModality = panelModality;
         // remove this panel so that it will be reinserted at the front of the stack
         modalPanels.removeAll(panel);
     }
 
     modalPanels.prepend(panel);
 
     if (!hoverItems.isEmpty()) {
         // send GraphicsSceneHoverLeave events to newly blocked hoverItems
         QGraphicsSceneHoverEvent hoverEvent;
         hoverEvent.setScenePos(lastSceneMousePos);
         dispatchHoverEvent(&hoverEvent);
     }
 
     if (!mouseGrabberItems.isEmpty() && lastMouseGrabberItemHasImplicitMouseGrab) {
         QGraphicsItem *item = mouseGrabberItems.last();
         if (item->isBlockedByModalPanel())
             ungrabMouse(item, /*itemIsDying =*/ false);
     }
 
     QEvent windowBlockedEvent(QEvent::WindowBlocked);
     QEvent windowUnblockedEvent(QEvent::WindowUnblocked);
     for (int i = 0; i < items.count(); ++i) {
         QGraphicsItem *item = items.at(i);
         if (item->isPanel()) {
             if (!blockedPanels.contains(item) && item->isBlockedByModalPanel()) {
                 // send QEvent::WindowBlocked to newly blocked panels
                 sendEvent(item, &windowBlockedEvent);
             } else if (blockedPanels.contains(item) && !item->isBlockedByModalPanel()) {
                 // send QEvent::WindowUnblocked to unblocked panels when downgrading
                 // a panel from SceneModal to PanelModal
                 sendEvent(item, &windowUnblockedEvent);
             }
         }
     }
 }

◆ filterDescendantEvent()

bool QGraphicsScenePrivate::filterDescendantEvent	(	QGraphicsItem *	item,
		QEvent *	event
	)

Warning: This function is not part of the public interface.

Definition at line 1168 of file qgraphicsscene.cpp.

Referenced by sendEvent().

 {
     if (item && (item->d_ptr->ancestorFlags & QGraphicsItemPrivate::AncestorFiltersChildEvents)) {
         QGraphicsItem *parent = item->parentItem();
         while (parent) {
             if (parent->d_ptr->filtersDescendantEvents && parent->sceneEventFilter(item, event))
                 return true;
             if (!(parent->d_ptr->ancestorFlags & QGraphicsItemPrivate::AncestorFiltersChildEvents))
                 return false;
             parent = parent->parentItem();
         }
     }
     return false;
 }

◆ filterEvent()

bool QGraphicsScenePrivate::filterEvent	(	QGraphicsItem *	item,
		QEvent *	event
	)

Warning: This function is not part of the public interface.

Definition at line 1186 of file qgraphicsscene.cpp.

Referenced by sendEvent().

 {
     if (item && !sceneEventFilters.contains(item))
         return false;
 
     QMultiMap<QGraphicsItem *, QGraphicsItem *>::Iterator it = sceneEventFilters.lowerBound(item);
     QMultiMap<QGraphicsItem *, QGraphicsItem *>::Iterator end = sceneEventFilters.upperBound(item);
     while (it != end) {
         // ### The filterer and filteree might both be deleted.
         if (it.value()->sceneEventFilter(it.key(), event))
             return true;
         ++it;
     }
     return false;
 }

◆ findClosestTouchPointId()

int QGraphicsScenePrivate::findClosestTouchPointId ( const QPointF & scenePos )

Definition at line 5964 of file qgraphicsscene.cpp.

 {
     int closestTouchPointId = -1;
     qreal closestDistance = qreal(0.);
     foreach (const QTouchEvent::TouchPoint &touchPoint, sceneCurrentTouchPoints) {
         qreal distance = QLineF(scenePos, touchPoint.scenePos()).length();
         if (closestTouchPointId == -1|| distance < closestDistance) {
             closestTouchPointId = touchPoint.id();
             closestDistance = distance;
         }
     }
     return closestTouchPointId;
 }

◆ gestureEventHandler()

void QGraphicsScenePrivate::gestureEventHandler ( QGestureEvent * event )

Definition at line 6324 of file qgraphicsscene.cpp.

 {
     QWidget *viewport = event->widget();
     if (!viewport)
         return;
     QGraphicsView *graphicsView = qobject_cast<QGraphicsView *>(viewport->parent());
     if (!graphicsView)
         return;
 
     QList<QGesture *> allGestures = event->gestures();
     G_DEBUG() << "QGraphicsScenePrivate::gestureEventHandler:"
             << "Gestures:" <<  allGestures;
 
     QSet<QGesture *> startedGestures;
     QPoint delta = viewport->mapFromGlobal(QPoint());
     QTransform toScene = QTransform::fromTranslate(delta.x(), delta.y())
                          * graphicsView->viewportTransform().inverted();
     foreach (QGesture *gesture, allGestures) {
         // cache scene coordinates of the hot spot
         if (gesture->hasHotSpot()) {
             gesture->d_func()->sceneHotSpot = toScene.map(gesture->hotSpot());
         } else {
             gesture->d_func()->sceneHotSpot = QPointF();
         }
 
         QGraphicsObject *target = gestureTargets.value(gesture, 0);
         if (!target) {
             // when we are not in started mode but don't have a target
             // then the only one interested in gesture is the view/scene
             if (gesture->state() == Qt::GestureStarted)
                 startedGestures.insert(gesture);
         }
     }
 
     if (!startedGestures.isEmpty()) {
         QSet<QGesture *> normalGestures; // that have just one target
         QSet<QGesture *> conflictedGestures; // that have multiple possible targets
         gestureTargetsAtHotSpots(startedGestures, Qt::GestureFlag(0), &cachedItemGestures, 0,
                                  &normalGestures, &conflictedGestures);
         cachedTargetItems = cachedItemGestures.keys();
         qSort(cachedTargetItems.begin(), cachedTargetItems.end(), qt_closestItemFirst);
         G_DEBUG() << "QGraphicsScenePrivate::gestureEventHandler:"
                 << "Normal gestures:" << normalGestures
                 << "Conflicting gestures:" << conflictedGestures;
 
         // deliver conflicted gestures as override events AND remember
         // initial gesture targets
         if (!conflictedGestures.isEmpty()) {
             for (int i = 0; i < cachedTargetItems.size(); ++i) {
                 QWeakPointer<QGraphicsObject> item = cachedTargetItems.at(i);
 
                 // get gestures to deliver to the current item
                 QSet<QGesture *> gestures = conflictedGestures & cachedItemGestures.value(item.data());
                 if (gestures.isEmpty())
                     continue;
 
                 G_DEBUG() << "QGraphicsScenePrivate::gestureEventHandler:"
                         << "delivering override to"
                         << item.data() << gestures;
                 // send gesture override
                 QGestureEvent ev(gestures.toList());
                 ev.t = QEvent::GestureOverride;
                 ev.setWidget(event->widget());
                 // mark event and individual gestures as ignored
                 ev.ignore();
                 foreach(QGesture *g, gestures)
                     ev.setAccepted(g, false);
                 sendEvent(item.data(), &ev);
                 // mark all accepted gestures to deliver them as normal gesture events
                 foreach (QGesture *g, gestures) {
                     if (ev.isAccepted() || ev.isAccepted(g)) {
                         conflictedGestures.remove(g);
                         // mark the item as a gesture target
                         if (item) {
                             gestureTargets.insert(g, item.data());
                             QHash<QGraphicsObject *, QSet<QGesture *> >::iterator it, e;
                             it = cachedItemGestures.begin();
                             e = cachedItemGestures.end();
                             for(; it != e; ++it)
                                 it.value().remove(g);
                             cachedItemGestures[item.data()].insert(g);
                         }
                         G_DEBUG() << "QGraphicsScenePrivate::gestureEventHandler:"
                                 << "override was accepted:"
                                 << g << item.data();
                     }
                     // remember the first item that received the override event
                     // as it most likely become a target if no one else accepts
                     // the override event
                     if (!gestureTargets.contains(g) && item)
                         gestureTargets.insert(g, item.data());
 
                 }
                 if (conflictedGestures.isEmpty())
                     break;
             }
         }
         // remember the initial target item for each gesture that was not in
         // the conflicted state.
         if (!normalGestures.isEmpty()) {
             for (int i = 0; i < cachedTargetItems.size() && !normalGestures.isEmpty(); ++i) {
                 QGraphicsObject *item = cachedTargetItems.at(i);
 
                 // get gestures to deliver to the current item
                 foreach (QGesture *g, cachedItemGestures.value(item)) {
                     if (!gestureTargets.contains(g)) {
                         gestureTargets.insert(g, item);
                         normalGestures.remove(g);
                     }
                 }
             }
         }
     }
 
 
     // deliver all gesture events
     QSet<QGesture *> undeliveredGestures;
     QSet<QGesture *> parentPropagatedGestures;
     foreach (QGesture *gesture, allGestures) {
         if (QGraphicsObject *target = gestureTargets.value(gesture, 0)) {
             cachedItemGestures[target].insert(gesture);
             cachedTargetItems.append(target);
             undeliveredGestures.insert(gesture);
             QGraphicsItemPrivate *d = target->QGraphicsItem::d_func();
             const Qt::GestureFlags flags = d->gestureContext.value(gesture->gestureType());
             if (flags & Qt::IgnoredGesturesPropagateToParent)
                 parentPropagatedGestures.insert(gesture);
         } else {
             G_DEBUG() << "QGraphicsScenePrivate::gestureEventHandler:"
                     << "no target for" << gesture << "at"
                     << gesture->hotSpot() << gesture->d_func()->sceneHotSpot;
         }
     }
     qSort(cachedTargetItems.begin(), cachedTargetItems.end(), qt_closestItemFirst);
     for (int i = 0; i < cachedTargetItems.size(); ++i) {
         QWeakPointer<QGraphicsObject> receiver = cachedTargetItems.at(i);
         QSet<QGesture *> gestures =
                 undeliveredGestures & cachedItemGestures.value(receiver.data());
         gestures -= cachedAlreadyDeliveredGestures.value(receiver.data());
 
         if (gestures.isEmpty())
             continue;
 
         cachedAlreadyDeliveredGestures[receiver.data()] += gestures;
         const bool isPanel = receiver.data()->isPanel();
 
         G_DEBUG() << "QGraphicsScenePrivate::gestureEventHandler:"
                 << "delivering to"
                 << receiver.data() << gestures;
         QGestureEvent ev(gestures.toList());
         ev.setWidget(event->widget());
         sendEvent(receiver.data(), &ev);
         QSet<QGesture *> ignoredGestures;
         foreach (QGesture *g, gestures) {
             if (!ev.isAccepted() && !ev.isAccepted(g)) {
                 // if the gesture was ignored by its target, we will update the
                 // targetItems list with a possible target items (items that
                 // want to receive partial gestures).
                 // ### wont' work if the target was destroyed in the event
                 //     we will just stop delivering it.
                 if (receiver && receiver.data() == gestureTargets.value(g, 0))
                     ignoredGestures.insert(g);
             } else {
                 if (receiver && g->state() == Qt::GestureStarted) {
                     // someone accepted the propagated initial GestureStarted
                     // event, let it be the new target for all following events.
                     gestureTargets[g] = receiver.data();
                 }
                 undeliveredGestures.remove(g);
             }
         }
         if (undeliveredGestures.isEmpty())
             break;
 
         // ignoredGestures list is only filled when delivering to the gesture
         // target item, so it is safe to assume item == target.
         if (!ignoredGestures.isEmpty() && !isPanel) {
             // look for new potential targets for gestures that were ignored
             // and should be propagated.
 
             QSet<QGraphicsObject *> targetsSet = cachedTargetItems.toSet();
 
             if (receiver) {
                 // first if the gesture should be propagated to parents only
                 for (QSet<QGesture *>::iterator it = ignoredGestures.begin();
                      it != ignoredGestures.end();) {
                     if (parentPropagatedGestures.contains(*it)) {
                         QGesture *gesture = *it;
                         const Qt::GestureType gestureType = gesture->gestureType();
                         QGraphicsItem *item = receiver.data();
                         while (item) {
                             if (QGraphicsObject *obj = item->toGraphicsObject()) {
                                 if (item->d_func()->gestureContext.contains(gestureType)) {
                                     targetsSet.insert(obj);
                                     cachedItemGestures[obj].insert(gesture);
                                 }
                             }
                             if (item->isPanel())
                                 break;
                             item = item->parentItem();
                         }
 
                         it = ignoredGestures.erase(it);
                         continue;
                     }
                     ++it;
                 }
             }
 
             gestureTargetsAtHotSpots(ignoredGestures, Qt::ReceivePartialGestures,
                                      &cachedItemGestures, &targetsSet, 0, 0);
 
             cachedTargetItems = targetsSet.toList();
             qSort(cachedTargetItems.begin(), cachedTargetItems.end(), qt_closestItemFirst);
             G_DEBUG() << "QGraphicsScenePrivate::gestureEventHandler:"
                     << "new targets:" << cachedTargetItems;
             i = -1; // start delivery again
             continue;
         }
     }
 
     foreach (QGesture *g, startedGestures) {
         if (g->gestureCancelPolicy() == QGesture::CancelAllInContext) {
             G_DEBUG() << "lets try to cancel some";
             // find gestures in context in Qt::GestureStarted or Qt::GestureUpdated state and cancel them
             cancelGesturesForChildren(g);
         }
     }
 
     // forget about targets for gestures that have ended
     foreach (QGesture *g, allGestures) {
         switch (g->state()) {
         case Qt::GestureFinished:
         case Qt::GestureCanceled:
             gestureTargets.remove(g);
             break;
         default:
             break;
         }
     }
 
     cachedTargetItems.clear();
     cachedItemGestures.clear();
     cachedAlreadyDeliveredGestures.clear();
 }

◆ gestureTargetsAtHotSpots()

void QGraphicsScenePrivate::gestureTargetsAtHotSpots	(	const QSet< QGesture *> &	gestures,
		Qt::GestureFlag	flag,
		QHash< QGraphicsObject , QSet< QGesture > > *	targets,
		QSet< QGraphicsObject >	itemsSet = `0`,
		QSet< QGesture >	normal = `0`,
		QSet< QGesture >	conflicts = `0`
	)

Definition at line 6277 of file qgraphicsscene.cpp.

 {
     QSet<QGesture *> normalGestures; // that are not in conflicted state.
     foreach (QGesture *gesture, gestures) {
         if (!gesture->hasHotSpot())
             continue;
         const Qt::GestureType gestureType = gesture->gestureType();
         QList<QGraphicsItem *> items = itemsAtPosition(QPoint(), gesture->d_func()->sceneHotSpot, 0);
         for (int j = 0; j < items.size(); ++j) {
             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->QGraphicsItem::d_func();
                 QMap<Qt::GestureType, Qt::GestureFlags>::const_iterator it =
                         d->gestureContext.find(gestureType);
                 if (it != d->gestureContext.end() && (!flag || (it.value() & flag))) {
                     if (normalGestures.contains(gesture)) {
                         normalGestures.remove(gesture);
                         if (conflicts)
                             conflicts->insert(gesture);
                     } else {
                         normalGestures.insert(gesture);
                     }
                     if (targets)
                         (*targets)[itemobj].insert(gesture);
                     if (itemsSet)
                         (*itemsSet).insert(itemobj);
                 }
             }
             // Don't propagate through panels.
             if (item->isPanel())
                 break;
         }
     }
     if (normal)
         *normal = normalGestures;
 }

◆ get()

QGraphicsScenePrivate * QGraphicsScenePrivate::get ( QGraphicsScene * q )

static

Warning: This function is not part of the public interface.

Definition at line 356 of file qgraphicsscene.cpp.

 {
     return q->d_func();
 }

◆ grabGesture()

void QGraphicsScenePrivate::grabGesture	(	QGraphicsItem *	,
		Qt::GestureType	gesture
	)

Definition at line 6653 of file qgraphicsscene.cpp.

 {
     (void)QGestureManager::instance(); // create a gesture manager
     if (!grabbedGestures[gesture]++) {
         foreach (QGraphicsView *view, views)
             view->viewport()->grabGesture(gesture);
     }
 }

◆ grabKeyboard()

void QGraphicsScenePrivate::grabKeyboard ( QGraphicsItem * item )

Warning: This function is not part of the public interface.

Definition at line 1025 of file qgraphicsscene.cpp.

Referenced by addPopup().

 {
     if (keyboardGrabberItems.contains(item)) {
         if (keyboardGrabberItems.last() == item)
             qWarning("QGraphicsItem::grabKeyboard: already a keyboard grabber");
         else
             qWarning("QGraphicsItem::grabKeyboard: already blocked by keyboard grabber: %p",
                      keyboardGrabberItems.last());
         return;
     }
 
     // Send ungrab event to the last grabber.
     if (!keyboardGrabberItems.isEmpty()) {
         // Just send ungrab event to current grabber.
         QEvent ungrabEvent(QEvent::UngrabKeyboard);
         sendEvent(keyboardGrabberItems.last(), &ungrabEvent);
     }
 
     keyboardGrabberItems << item;
 
     // Send grab event to current grabber.
     QEvent grabEvent(QEvent::GrabKeyboard);
     sendEvent(item, &grabEvent);
 }

◆ grabMouse()

void QGraphicsScenePrivate::grabMouse	(	QGraphicsItem *	item,
		bool	implicit = `false`
	)

Warning: This function is not part of the public interface.

Definition at line 925 of file qgraphicsscene.cpp.

Referenced by addPopup().

 {
     // Append to list of mouse grabber items, and send a mouse grab event.
     if (mouseGrabberItems.contains(item)) {
         if (mouseGrabberItems.last() == item) {
             Q_ASSERT(!implicit);
             if (!lastMouseGrabberItemHasImplicitMouseGrab) {
                 qWarning("QGraphicsItem::grabMouse: already a mouse grabber");
             } else {
                 // Upgrade to an explicit mouse grab
                 lastMouseGrabberItemHasImplicitMouseGrab = false;
             }
         } else {
             qWarning("QGraphicsItem::grabMouse: already blocked by mouse grabber: %p",
                      mouseGrabberItems.last());
         }
         return;
     }
 
     // Send ungrab event to the last grabber.
     if (!mouseGrabberItems.isEmpty()) {
         QGraphicsItem *last = mouseGrabberItems.last();
         if (lastMouseGrabberItemHasImplicitMouseGrab) {
             // Implicit mouse grab is immediately lost.
             last->ungrabMouse();
         } else {
             // Just send ungrab event to current grabber.
             QEvent ungrabEvent(QEvent::UngrabMouse);
             sendEvent(last, &ungrabEvent);
         }
     }
 
     mouseGrabberItems << item;
     lastMouseGrabberItemHasImplicitMouseGrab = implicit;
 
     // Send grab event to current grabber.
     QEvent grabEvent(QEvent::GrabMouse);
     sendEvent(item, &grabEvent);
 }

◆ init()

void QGraphicsScenePrivate::init ( )

Warning: This function is not part of the public interface.

Definition at line 338 of file qgraphicsscene.cpp.

 {
     Q_Q(QGraphicsScene);
 
     index = new QGraphicsSceneBspTreeIndex(q);
 
     // Keep this index so we can check for connected slots later on.
     changedSignalIndex = signalIndex("changed(QList<QRectF>)");
     processDirtyItemsIndex = q->metaObject()->indexOfSlot("_q_processDirtyItems()");
     polishItemsIndex = q->metaObject()->indexOfSlot("_q_polishItems()");
 
     qApp->d_func()->scene_list.append(q);
     q->update();
 }

◆ installSceneEventFilter()

void QGraphicsScenePrivate::installSceneEventFilter	(	QGraphicsItem *	watched,
		QGraphicsItem *	filter
	)

Warning: This function is not part of the public interface.

Definition at line 1142 of file qgraphicsscene.cpp.

 {
     sceneEventFilters.insert(watched, filter);
 }

◆ itemAcceptsHoverEvents_helper()

bool QGraphicsScenePrivate::itemAcceptsHoverEvents_helper ( const QGraphicsItem * item ) const

Definition at line 3983 of file qgraphicsscene.cpp.

 {
     return (item->d_ptr->acceptsHover
             || (item->d_ptr->isWidget
                 && static_cast<const QGraphicsWidget *>(item)->d_func()->hasDecoration()))
            && !item->isBlockedByModalPanel();
 }

◆ itemsAtPosition()

QList< QGraphicsItem * > QGraphicsScenePrivate::itemsAtPosition	(	const QPoint &	screenPos,
		const QPointF &	scenePos,
		QWidget *	widget
	)		const

Returns all items for the screen position in event.

Definition at line 1101 of file qgraphicsscene.cpp.

Referenced by mousePressEventHandler().

 {
     Q_Q(const QGraphicsScene);
     QGraphicsView *view = widget ? qobject_cast<QGraphicsView *>(widget->parentWidget()) : 0;
     if (!view)
         return q->items(scenePos, Qt::IntersectsItemShape, Qt::DescendingOrder, QTransform());
 
     const QRectF pointRect(QPointF(widget->mapFromGlobal(screenPos)), QSizeF(1, 1));
     if (!view->isTransformed())
         return q->items(pointRect, Qt::IntersectsItemShape, Qt::DescendingOrder);
 
     const QTransform viewTransform = view->viewportTransform();
     if (viewTransform.type() <= QTransform::TxScale) {
         return q->items(viewTransform.inverted().mapRect(pointRect), Qt::IntersectsItemShape,
                         Qt::DescendingOrder, viewTransform);
     }
     return q->items(viewTransform.inverted().map(pointRect), Qt::IntersectsItemShape,
                     Qt::DescendingOrder, viewTransform);
 }

◆ leaveModal()

void QGraphicsScenePrivate::leaveModal ( QGraphicsItem * item )

Definition at line 6248 of file qgraphicsscene.cpp.

Referenced by removeItemHelper().

 {
     Q_Q(QGraphicsScene);
     Q_ASSERT(panel && panel->isPanel());
 
     QSet<QGraphicsItem *> blockedPanels;
     QList<QGraphicsItem *> items = q->items(); // ### same as above
     for (int i = 0; i < items.count(); ++i) {
         QGraphicsItem *item = items.at(i);
         if (item->isPanel() && item->isBlockedByModalPanel())
             blockedPanels.insert(item);
     }
 
     modalPanels.removeAll(panel);
 
     QEvent e(QEvent::WindowUnblocked);
     for (int i = 0; i < items.count(); ++i) {
         QGraphicsItem *item = items.at(i);
         if (item->isPanel() && blockedPanels.contains(item) && !item->isBlockedByModalPanel())
             sendEvent(item, &e);
     }
 
     // send GraphicsSceneHoverEnter events to newly unblocked items
     QGraphicsSceneHoverEvent hoverEvent;
     hoverEvent.setScenePos(lastSceneMousePos);
     dispatchHoverEvent(&hoverEvent);
 }

◆ leaveScene()

void QGraphicsScenePrivate::leaveScene ( QWidget * viewport )

Handles all actions necessary to clean up the scene when the mouse leaves the view.

Warning: This function is not part of the public interface.

Definition at line 4080 of file qgraphicsscene.cpp.

 {
 #ifndef QT_NO_TOOLTIP
     QToolTip::hideText();
 #endif
     QGraphicsView *view = qobject_cast<QGraphicsView *>(viewport->parent());
     // Send HoverLeave events to all existing hover items, topmost first.
     QGraphicsSceneHoverEvent hoverEvent;
     hoverEvent.setWidget(viewport);
 
     if (view) {
         QPoint cursorPos = QCursor::pos();
         hoverEvent.setScenePos(view->mapToScene(viewport->mapFromGlobal(cursorPos)));
         hoverEvent.setLastScenePos(hoverEvent.scenePos());
         hoverEvent.setScreenPos(cursorPos);
         hoverEvent.setLastScreenPos(hoverEvent.screenPos());
     }
 
     while (!hoverItems.isEmpty()) {
         QGraphicsItem *lastItem = hoverItems.takeLast();
         if (itemAcceptsHoverEvents_helper(lastItem))
             sendHoverEvent(QEvent::GraphicsSceneHoverLeave, lastItem, &hoverEvent);
     }
 }

◆ markDirty()

void QGraphicsScenePrivate::markDirty	(	QGraphicsItem *	item,
		const QRectF &	rect = `QRectF()`,
		bool	invalidateChildren = `false`,
		bool	force = `false`,
		bool	ignoreOpacity = `false`,
		bool	removingItemFromScene = `false`,
		bool	updateBoundingRect = `false`
	)

Definition at line 5130 of file qgraphicsscene.cpp.

Referenced by QGraphicsItem::prepareGeometryChange(), and removeItemHelper().

 {
     Q_ASSERT(item);
     if (updateAll)
         return;
 
     if (removingItemFromScene && !ignoreOpacity && !item->d_ptr->ignoreOpacity) {
         // If any of the item's ancestors ignore opacity, it means that the opacity
         // was set to 0 (and the update request has not yet been processed). That
         // also means that we have to ignore the opacity for the item itself; otherwise
         // things like: parent->setOpacity(0); scene->removeItem(child) won't work.
         // Note that we only do this when removing items from the scene. In all other
         // cases the ignoreOpacity bit propagates properly in processDirtyItems, but
         // since the item is removed immediately it won't be processed there.
         QGraphicsItem *p = item->d_ptr->parent;
         while (p) {
             if (p->d_ptr->ignoreOpacity) {
                 item->d_ptr->ignoreOpacity = true;
                 break;
             }
             p = p->d_ptr->parent;
         }
     }
 
     if (item->d_ptr->discardUpdateRequest(/*ignoreVisibleBit=*/force,
                                           /*ignoreDirtyBit=*/removingItemFromScene || invalidateChildren,
                                           /*ignoreOpacity=*/ignoreOpacity)) {
         if (item->d_ptr->dirty) {
             // The item is already marked as dirty and will be processed later. However,
             // we have to make sure ignoreVisible and ignoreOpacity are set properly;
             // otherwise things like: item->update(); item->hide() (force is now true)
             // won't work as expected.
             if (force)
                 item->d_ptr->ignoreVisible = 1;
             if (ignoreOpacity)
                 item->d_ptr->ignoreOpacity = 1;
         }
         return;
     }
 
     const bool fullItemUpdate = rect.isNull();
     if (!fullItemUpdate && rect.isEmpty())
         return;
 
     if (!processDirtyItemsEmitted) {
         QMetaMethod method = q_ptr->metaObject()->method(processDirtyItemsIndex);
         method.invoke(q_ptr, Qt::QueuedConnection);
 //        QMetaObject::invokeMethod(q_ptr, "_q_processDirtyItems", Qt::QueuedConnection);
         processDirtyItemsEmitted = true;
     }
 
     if (removingItemFromScene) {
         // Note that this function can be called from the item's destructor, so
         // do NOT call any virtual functions on it within this block.
         if (isSignalConnected(changedSignalIndex) || views.isEmpty()) {
             // This block of code is kept for compatibility. Since 4.5, by default
             // QGraphicsView does not connect the signal and we use the below
             // method of delivering updates.
             q_func()->update();
             return;
         }
 
         for (int i = 0; i < views.size(); ++i) {
             QGraphicsViewPrivate *viewPrivate = views.at(i)->d_func();
             QRect rect = item->d_ptr->paintedViewBoundingRects.value(viewPrivate->viewport);
             rect.translate(viewPrivate->dirtyScrollOffset);
             viewPrivate->updateRect(rect);
         }
         return;
     }
 
     bool hasNoContents = item->d_ptr->flags & QGraphicsItem::ItemHasNoContents;
     if (!hasNoContents) {
         item->d_ptr->dirty = 1;
         if (fullItemUpdate)
             item->d_ptr->fullUpdatePending = 1;
         else if (!item->d_ptr->fullUpdatePending)
             item->d_ptr->needsRepaint |= rect;
     } else if (item->d_ptr->graphicsEffect) {
         invalidateChildren = true;
     }
 
     if (invalidateChildren) {
         item->d_ptr->allChildrenDirty = 1;
         item->d_ptr->dirtyChildren = 1;
     }
 
     if (force)
         item->d_ptr->ignoreVisible = 1;
     if (ignoreOpacity)
         item->d_ptr->ignoreOpacity = 1;
 
     if (!updateBoundingRect)
         item->d_ptr->markParentDirty();
 }

◆ mousePressEventHandler()

void QGraphicsScenePrivate::mousePressEventHandler ( QGraphicsSceneMouseEvent * mouseEvent )

Warning: This function is not part of the public interface.

Definition at line 1318 of file qgraphicsscene.cpp.

 {
     Q_Q(QGraphicsScene);
 
     // Ignore by default, unless we find a mouse grabber that accepts it.
     mouseEvent->ignore();
 
     // Deliver to any existing mouse grabber.
     if (!mouseGrabberItems.isEmpty()) {
         if (mouseGrabberItems.last()->isBlockedByModalPanel())
             return;
         // The event is ignored by default, but we disregard the event's
         // accepted state after delivery; the mouse is grabbed, after all.
         sendMouseEvent(mouseEvent);
         return;
     }
 
     // Start by determining the number of items at the current position.
     // Reuse value from earlier calculations if possible.
     if (cachedItemsUnderMouse.isEmpty()) {
         cachedItemsUnderMouse = itemsAtPosition(mouseEvent->screenPos(),
                                                 mouseEvent->scenePos(),
                                                 mouseEvent->widget());
     }
 
     // Update window activation.
     QGraphicsItem *topItem = cachedItemsUnderMouse.value(0);
     QGraphicsWidget *newActiveWindow = topItem ? topItem->window() : 0;
     if (newActiveWindow && newActiveWindow->isBlockedByModalPanel(&topItem)) {
         // pass activation to the blocking modal window
         newActiveWindow = topItem ? topItem->window() : 0;
     }
 
     if (newActiveWindow != q->activeWindow())
         q->setActiveWindow(newActiveWindow);
 
     // Set focus on the topmost enabled item that can take focus.
     bool setFocus = false;
 
     foreach (QGraphicsItem *item, cachedItemsUnderMouse) {
         if (item->isBlockedByModalPanel()
             || (item->d_ptr->flags & QGraphicsItem::ItemStopsFocusHandling)) {
             // Make sure we don't clear focus.
             setFocus = true;
             break;
         }
         if (item->isEnabled() && ((item->flags() & QGraphicsItem::ItemIsFocusable))) {
             if (!item->isWidget() || ((QGraphicsWidget *)item)->focusPolicy() & Qt::ClickFocus) {
                 setFocus = true;
                 if (item != q->focusItem() && item->d_ptr->mouseSetsFocus)
                     q->setFocusItem(item, Qt::MouseFocusReason);
                 break;
             }
         }
         if (item->isPanel())
             break;
         if (item->d_ptr->flags & QGraphicsItem::ItemStopsClickFocusPropagation)
             break;
     }
 
     // Check for scene modality.
     bool sceneModality = false;
     for (int i = 0; i < modalPanels.size(); ++i) {
         if (modalPanels.at(i)->panelModality() == QGraphicsItem::SceneModal) {
             sceneModality = true;
             break;
         }
     }
 
     // If nobody could take focus, clear it.
     if (!stickyFocus && !setFocus && !sceneModality)
         q->setFocusItem(0, Qt::MouseFocusReason);
 
     // Any item will do.
     if (sceneModality && cachedItemsUnderMouse.isEmpty())
         cachedItemsUnderMouse << modalPanels.first();
 
     // Find a mouse grabber by sending mouse press events to all mouse grabber
     // candidates one at a time, until the event is accepted. It's accepted by
     // default, so the receiver has to explicitly ignore it for it to pass
     // through.
     foreach (QGraphicsItem *item, cachedItemsUnderMouse) {
         if (!(item->acceptedMouseButtons() & mouseEvent->button())) {
             // Skip items that don't accept the event's mouse button.
             continue;
         }
 
         // Check if this item is blocked by a modal panel and deliver the mouse event to the
         // blocking panel instead of this item if blocked.
         (void) item->isBlockedByModalPanel(&item);
 
         grabMouse(item, /* implicit = */ true);
         mouseEvent->accept();
 
         // check if the item we are sending to are disabled (before we send the event)
         bool disabled = !item->isEnabled();
         bool isPanel = item->isPanel();
         if (mouseEvent->type() == QEvent::GraphicsSceneMouseDoubleClick
             && item != lastMouseGrabberItem && lastMouseGrabberItem) {
             // If this item is different from the item that received the last
             // mouse event, and mouseEvent is a doubleclick event, then the
             // event is converted to a press. Known limitation:
             // Triple-clicking will not generate a doubleclick, though.
             QGraphicsSceneMouseEvent mousePress(QEvent::GraphicsSceneMousePress);
             mousePress.spont = mouseEvent->spont;
             mousePress.accept();
             mousePress.setButton(mouseEvent->button());
             mousePress.setButtons(mouseEvent->buttons());
             mousePress.setScreenPos(mouseEvent->screenPos());
             mousePress.setScenePos(mouseEvent->scenePos());
             mousePress.setModifiers(mouseEvent->modifiers());
             mousePress.setWidget(mouseEvent->widget());
             mousePress.setButtonDownPos(mouseEvent->button(),
                                         mouseEvent->buttonDownPos(mouseEvent->button()));
             mousePress.setButtonDownScenePos(mouseEvent->button(),
                                              mouseEvent->buttonDownScenePos(mouseEvent->button()));
             mousePress.setButtonDownScreenPos(mouseEvent->button(),
                                               mouseEvent->buttonDownScreenPos(mouseEvent->button()));
             sendMouseEvent(&mousePress);
             mouseEvent->setAccepted(mousePress.isAccepted());
         } else {
             sendMouseEvent(mouseEvent);
         }
 
         bool dontSendUngrabEvents = mouseGrabberItems.isEmpty() || mouseGrabberItems.last() != item;
         if (disabled) {
             ungrabMouse(item, /* itemIsDying = */ dontSendUngrabEvents);
             break;
         }
         if (mouseEvent->isAccepted()) {
             if (!mouseGrabberItems.isEmpty())
                 storeMouseButtonsForMouseGrabber(mouseEvent);
             lastMouseGrabberItem = item;
             return;
         }
         ungrabMouse(item, /* itemIsDying = */ dontSendUngrabEvents);
 
         // Don't propagate through panels.
         if (isPanel)
             break;
     }
 
     // Is the event still ignored? Then the mouse press goes to the scene.
     // Reset the mouse grabber, clear the selection, clear focus, and leave
     // the event ignored so that it can propagate through the originating
     // view.
     if (!mouseEvent->isAccepted()) {
         clearMouseGrabber();
 
         QGraphicsView *view = mouseEvent->widget() ? qobject_cast<QGraphicsView *>(mouseEvent->widget()->parentWidget()) : 0;
         bool dontClearSelection = view && view->dragMode() == QGraphicsView::ScrollHandDrag;
         if (!dontClearSelection) {
             // Clear the selection if the originating view isn't in scroll
             // hand drag mode. The view will clear the selection if no drag
             // happened.
             q->clearSelection();
         }
     }
 }

◆ processDirtyItemsRecursive()

void QGraphicsScenePrivate::processDirtyItemsRecursive	(	QGraphicsItem *	item,
		bool	dirtyAncestorContainsChildren = `false`,
		qreal	parentOpacity = `qreal(1.0)`
	)

Definition at line 5265 of file qgraphicsscene.cpp.

Referenced by _q_processDirtyItems().

 {
     Q_Q(QGraphicsScene);
     Q_ASSERT(item);
     Q_ASSERT(!updateAll);
 
     if (!item->d_ptr->dirty && !item->d_ptr->dirtyChildren) {
         resetDirtyItem(item);
         return;
     }
 
     const bool itemIsHidden = !item->d_ptr->ignoreVisible && !item->d_ptr->visible;
     if (itemIsHidden) {
         resetDirtyItem(item, /*recursive=*/true);
         return;
     }
 
     bool itemHasContents = !(item->d_ptr->flags & QGraphicsItem::ItemHasNoContents);
     const bool itemHasChildren = !item->d_ptr->children.isEmpty();
     if (!itemHasContents) {
         if (!itemHasChildren) {
             resetDirtyItem(item);
             return; // Item has neither contents nor children!(?)
         }
         if (item->d_ptr->graphicsEffect)
             itemHasContents = true;
     }
 
     const qreal opacity = item->d_ptr->combineOpacityFromParent(parentOpacity);
     const bool itemIsFullyTransparent = !item->d_ptr->ignoreOpacity
                                         && QGraphicsItemPrivate::isOpacityNull(opacity);
     if (itemIsFullyTransparent && (!itemHasChildren || item->d_ptr->childrenCombineOpacity())) {
         resetDirtyItem(item, /*recursive=*/itemHasChildren);
         return;
     }
 
     bool wasDirtyParentSceneTransform = item->d_ptr->dirtySceneTransform;
     const bool itemIsUntransformable = item->d_ptr->itemIsUntransformable();
     if (wasDirtyParentSceneTransform && !itemIsUntransformable) {
         item->d_ptr->updateSceneTransformFromParent();
         Q_ASSERT(!item->d_ptr->dirtySceneTransform);
     }
 
     const bool wasDirtyParentViewBoundingRects = item->d_ptr->paintedViewBoundingRectsNeedRepaint;
     if (itemIsFullyTransparent || !itemHasContents || dirtyAncestorContainsChildren) {
         // Make sure we don't process invisible items or items with no content.
         item->d_ptr->dirty = 0;
         item->d_ptr->fullUpdatePending = 0;
         // Might have a dirty view bounding rect otherwise.
         if (itemIsFullyTransparent || !itemHasContents)
             item->d_ptr->paintedViewBoundingRectsNeedRepaint = 0;
     }
 
     if (!hasSceneRect && item->d_ptr->geometryChanged && item->d_ptr->visible) {
         // Update growingItemsBoundingRect.
         if (item->d_ptr->sceneTransformTranslateOnly) {
             growingItemsBoundingRect |= item->boundingRect().translated(item->d_ptr->sceneTransform.dx(),
                                                                         item->d_ptr->sceneTransform.dy());
         } else {
             growingItemsBoundingRect |= item->d_ptr->sceneTransform.mapRect(item->boundingRect());
         }
     }
 
     // Process item.
     if (item->d_ptr->dirty || item->d_ptr->paintedViewBoundingRectsNeedRepaint) {
         const bool useCompatUpdate = views.isEmpty() || isSignalConnected(changedSignalIndex);
         const QRectF itemBoundingRect = adjustedItemEffectiveBoundingRect(item);
 
         if (useCompatUpdate && !itemIsUntransformable && qFuzzyIsNull(item->boundingRegionGranularity())) {
             // This block of code is kept for compatibility. Since 4.5, by default
             // QGraphicsView does not connect the signal and we use the below
             // method of delivering updates.
             if (item->d_ptr->sceneTransformTranslateOnly) {
                 q->update(itemBoundingRect.translated(item->d_ptr->sceneTransform.dx(),
                                                       item->d_ptr->sceneTransform.dy()));
             } else {
                 QRectF rect = item->d_ptr->sceneTransform.mapRect(itemBoundingRect);
                 if (!rect.isEmpty())
                     q->update(rect);
             }
         } else {
             QRectF dirtyRect;
             bool uninitializedDirtyRect = true;
 
             for (int j = 0; j < views.size(); ++j) {
                 QGraphicsView *view = views.at(j);
                 QGraphicsViewPrivate *viewPrivate = view->d_func();
                 QRect &paintedViewBoundingRect = item->d_ptr->paintedViewBoundingRects[viewPrivate->viewport];
                 if (viewPrivate->fullUpdatePending
                     || viewPrivate->viewportUpdateMode == QGraphicsView::NoViewportUpdate) {
                     // Okay, if we have a full update pending or no viewport update, this item's
                     // paintedViewBoundingRect  will be updated correctly in the next paintEvent if
                     // it is inside the viewport, but for now we can pretend that it is outside.
                     paintedViewBoundingRect = QRect(-1, -1, -1, -1);
                     continue;
                 }
 
                 if (item->d_ptr->paintedViewBoundingRectsNeedRepaint) {
                     paintedViewBoundingRect.translate(viewPrivate->dirtyScrollOffset);
                     if (!viewPrivate->updateRect(paintedViewBoundingRect))
                         paintedViewBoundingRect = QRect(-1, -1, -1, -1); // Outside viewport.
                 }
 
                 if (!item->d_ptr->dirty)
                     continue;
 
                 if (!item->d_ptr->paintedViewBoundingRectsNeedRepaint
                     && paintedViewBoundingRect.x() == -1 && paintedViewBoundingRect.y() == -1
                     && paintedViewBoundingRect.width() == -1 && paintedViewBoundingRect.height() == -1) {
                     continue; // Outside viewport.
                 }
 
                 if (uninitializedDirtyRect) {
                     dirtyRect = itemBoundingRect;
                     if (!item->d_ptr->fullUpdatePending) {
                         _q_adjustRect(&item->d_ptr->needsRepaint);
                         dirtyRect &= item->d_ptr->needsRepaint;
                     }
                     uninitializedDirtyRect = false;
                 }
 
                 if (dirtyRect.isEmpty())
                     continue; // Discard updates outside the bounding rect.
 
                 if (!updateHelper(viewPrivate, item->d_ptr.data(), dirtyRect, itemIsUntransformable)
                     && item->d_ptr->paintedViewBoundingRectsNeedRepaint) {
                     paintedViewBoundingRect = QRect(-1, -1, -1, -1); // Outside viewport.
                 }
             }
         }
     }
 
     // Process children.
     if (itemHasChildren && item->d_ptr->dirtyChildren) {
         const bool itemClipsChildrenToShape = item->d_ptr->flags & QGraphicsItem::ItemClipsChildrenToShape;
         // Items with no content are threated as 'dummy' items which means they are never drawn and
         // 'processed', so the painted view bounding rect is never up-to-date. This means that whenever
         // such an item changes geometry, its children have to take care of the update regardless
         // of whether the item clips children to shape or not.
         const bool bypassUpdateClip = !itemHasContents && wasDirtyParentViewBoundingRects;
         if (itemClipsChildrenToShape && !bypassUpdateClip) {
             // Make sure child updates are clipped to the item's bounding rect.
             for (int i = 0; i < views.size(); ++i)
                 views.at(i)->d_func()->setUpdateClip(item);
         }
         if (!dirtyAncestorContainsChildren) {
             dirtyAncestorContainsChildren = item->d_ptr->fullUpdatePending
                                             && itemClipsChildrenToShape;
         }
         const bool allChildrenDirty = item->d_ptr->allChildrenDirty;
         const bool parentIgnoresVisible = item->d_ptr->ignoreVisible;
         const bool parentIgnoresOpacity = item->d_ptr->ignoreOpacity;
         for (int 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 (wasDirtyParentViewBoundingRects)
                 child->d_ptr->paintedViewBoundingRectsNeedRepaint = 1;
             if (parentIgnoresVisible)
                 child->d_ptr->ignoreVisible = 1;
             if (parentIgnoresOpacity)
                 child->d_ptr->ignoreOpacity = 1;
             if (allChildrenDirty) {
                 child->d_ptr->dirty = 1;
                 child->d_ptr->fullUpdatePending = 1;
                 child->d_ptr->dirtyChildren = 1;
                 child->d_ptr->allChildrenDirty = 1;
             }
             processDirtyItemsRecursive(child, dirtyAncestorContainsChildren, opacity);
         }
 
         if (itemClipsChildrenToShape) {
             // Reset updateClip.
             for (int i = 0; i < views.size(); ++i)
                 views.at(i)->d_func()->setUpdateClip(0);
         }
     } else if (wasDirtyParentSceneTransform) {
         item->d_ptr->invalidateChildrenSceneTransform();
     }
 
     resetDirtyItem(item);
 }

◆ registerScenePosItem()

void QGraphicsScenePrivate::registerScenePosItem ( QGraphicsItem * item )

Warning: This function is not part of the public interface.

Definition at line 545 of file qgraphicsscene.cpp.

 {
     scenePosItems.insert(item);
     setScenePosItemEnabled(item, true);
 }

◆ registerTopLevelItem()

void QGraphicsScenePrivate::registerTopLevelItem ( QGraphicsItem * item )

Warning: This function is not part of the public interface.

This function is almost identical to QGraphicsItemPrivate::addChild().

Definition at line 415 of file qgraphicsscene.cpp.

 {
     item->d_ptr->ensureSequentialSiblingIndex();
     needSortTopLevelItems = true; // ### maybe false
     item->d_ptr->siblingIndex = topLevelItems.size();
     topLevelItems.append(item);
 }

◆ removeItemHelper()

void QGraphicsScenePrivate::removeItemHelper ( QGraphicsItem * item )

Schedules an item for removal.

Warning: This function is not part of the public interface.

This function leaves some stale indexes around in the BSP tree if called from the item's destructor; these will be cleaned up the next time someone triggers purgeRemovedItems().

Note: This function might get called from QGraphicsItem's destructor. item is being destroyed, so we cannot call any pure virtual functions on it (such as boundingRect()). Also, it is unnecessary to update the item's own state in any way.

Definition at line 590 of file qgraphicsscene.cpp.

 {
     Q_Q(QGraphicsScene);
 
     // Clear focus on the item to remove any reference in the focusWidget chain.
     item->clearFocus();
 
     markDirty(item, QRectF(), /*invalidateChildren=*/false, /*force=*/false,
               /*ignoreOpacity=*/false, /*removingItemFromScene=*/true);
 
     if (item->d_ptr->inDestructor) {
         // The item is actually in its destructor, we call the special method in the index.
         index->deleteItem(item);
     } else {
         // Can potentially call item->boundingRect() (virtual function), that's why
         // we only can call this function if the item is not in its destructor.
         index->removeItem(item);
     }
 
     item->d_ptr->clearSubFocus();
 
     if (item->flags() & QGraphicsItem::ItemSendsScenePositionChanges)
         unregisterScenePosItem(item);
 
     QGraphicsScene *oldScene = item->d_func()->scene;
     item->d_func()->scene = 0;
 
     //We need to remove all children first because they might use their parent
     //attributes (e.g. sceneTransform).
     if (!item->d_ptr->inDestructor) {
         // Remove all children recursively
         for (int i = 0; i < item->d_ptr->children.size(); ++i)
             q->removeItem(item->d_ptr->children.at(i));
     }
 
     if (!item->d_ptr->inDestructor && item == tabFocusFirst) {
         QGraphicsWidget *widget = static_cast<QGraphicsWidget *>(item);
         widget->d_func()->fixFocusChainBeforeReparenting(0, oldScene, 0);
     }
 
     // Unregister focus proxy.
     item->d_ptr->resetFocusProxy();
 
     // Remove from parent, or unregister from toplevels.
     if (QGraphicsItem *parentItem = item->parentItem()) {
         if (parentItem->scene()) {
             Q_ASSERT_X(parentItem->scene() == q, "QGraphicsScene::removeItem",
                        "Parent item's scene is different from this item's scene");
             item->setParentItem(0);
         }
     } else {
         unregisterTopLevelItem(item);
     }
 
     // Reset the mouse grabber and focus item data.
     if (item == focusItem)
         focusItem = 0;
     if (item == lastFocusItem)
         lastFocusItem = 0;
     if (item == passiveFocusItem)
         passiveFocusItem = 0;
     if (item == activePanel) {
         // ### deactivate...
         activePanel = 0;
     }
     if (item == lastActivePanel)
         lastActivePanel = 0;
 
     // Cancel active touches
     {
         QMap<int, QGraphicsItem *>::iterator it = itemForTouchPointId.begin();
         while (it != itemForTouchPointId.end()) {
             if (it.value() == item) {
                 sceneCurrentTouchPoints.remove(it.key());
                 it = itemForTouchPointId.erase(it);
             } else {
                 ++it;
             }
         }
     }
 
     // Disable selectionChanged() for individual items
     ++selectionChanging;
     int oldSelectedItemsSize = selectedItems.size();
 
     // Update selected & hovered item bookkeeping
     selectedItems.remove(item);
     hoverItems.removeAll(item);
     cachedItemsUnderMouse.removeAll(item);
     if (item->d_ptr->pendingPolish) {
         const int unpolishedIndex = unpolishedItems.indexOf(item);
         if (unpolishedIndex != -1)
             unpolishedItems[unpolishedIndex] = 0;
         item->d_ptr->pendingPolish = false;
     }
     resetDirtyItem(item);
 
     //We remove all references of item from the sceneEventFilter arrays
     QMultiMap<QGraphicsItem*, QGraphicsItem*>::iterator iterator = sceneEventFilters.begin();
     while (iterator != sceneEventFilters.end()) {
         if (iterator.value() == item || iterator.key() == item)
             iterator = sceneEventFilters.erase(iterator);
         else
             ++iterator;
     }
 
     if (item->isPanel() && item->isVisible() && item->panelModality() != QGraphicsItem::NonModal)
         leaveModal(item);
 
     // Reset the mouse grabber and focus item data.
     if (mouseGrabberItems.contains(item))
         ungrabMouse(item, /* item is dying */ item->d_ptr->inDestructor);
 
     // Reset the keyboard grabber
     if (keyboardGrabberItems.contains(item))
         ungrabKeyboard(item, /* item is dying */ item->d_ptr->inDestructor);
 
     // Reset the last mouse grabber item
     if (item == lastMouseGrabberItem)
         lastMouseGrabberItem = 0;
 
     // Reset the current drop item
     if (item == dragDropItem)
         dragDropItem = 0;
 
     // Reenable selectionChanged() for individual items
     --selectionChanging;
     if (!selectionChanging && selectedItems.size() != oldSelectedItemsSize)
         emit q->selectionChanged();
 
 #ifndef QT_NO_GESTURES
     QHash<QGesture *, QGraphicsObject *>::iterator it;
     for (it = gestureTargets.begin(); it != gestureTargets.end();) {
         if (it.value() == item)
             it = gestureTargets.erase(it);
         else
             ++it;
     }
 
     QGraphicsObject *dummy = static_cast<QGraphicsObject *>(item);
     cachedTargetItems.removeOne(dummy);
     cachedItemGestures.remove(dummy);
     cachedAlreadyDeliveredGestures.remove(dummy);
 
     foreach (Qt::GestureType gesture, item->d_ptr->gestureContext.keys())
         ungrabGesture(item, gesture);
 #endif // QT_NO_GESTURES
 }

◆ removePopup()

void QGraphicsScenePrivate::removePopup	(	QGraphicsWidget *	widget,
		bool	itemIsDying = `false`
	)

Remove widget from the popup list.

Warning: This function is not part of the public interface.

Important notes:

widget is guaranteed to be in the list of popups, but it might not be the last entry; you can hide any item in the pop list before the others, and this must cause all later mouse grabbers to lose the grab.

Definition at line 901 of file qgraphicsscene.cpp.

Referenced by ungrabMouse().

 {
     Q_ASSERT(widget);
     int index = popupWidgets.indexOf(widget);
     Q_ASSERT(index != -1);
 
     for (int i = popupWidgets.size() - 1; i >= index; --i) {
         QGraphicsWidget *widget = popupWidgets.takeLast();
         ungrabMouse(widget, itemIsDying);
         if (focusItem && popupWidgets.isEmpty()) {
             QFocusEvent event(QEvent::FocusIn, Qt::PopupFocusReason);
             sendEvent(focusItem, &event);
         } else if (keyboardGrabberItems.contains(static_cast<QGraphicsItem *>(widget))) {
             ungrabKeyboard(static_cast<QGraphicsItem *>(widget), itemIsDying);
         }
         if (!itemIsDying && widget->isVisible()) {
             widget->QGraphicsItem::d_ptr->setVisibleHelper(false, /* explicit = */ false);
         }
     }
 }

◆ removeSceneEventFilter()

void QGraphicsScenePrivate::removeSceneEventFilter	(	QGraphicsItem *	watched,
		QGraphicsItem *	filter
	)

Warning: This function is not part of the public interface.

Definition at line 1150 of file qgraphicsscene.cpp.

 {
     if (!sceneEventFilters.contains(watched))
         return;
 
     QMultiMap<QGraphicsItem *, QGraphicsItem *>::Iterator it = sceneEventFilters.lowerBound(watched);
     QMultiMap<QGraphicsItem *, QGraphicsItem *>::Iterator end = sceneEventFilters.upperBound(watched);
     do {
         if (it.value() == filter)
             it = sceneEventFilters.erase(it);
         else
             ++it;
     } while (it != end);
 }

◆ removeView()

void QGraphicsScenePrivate::removeView ( QGraphicsView * view )

Definition at line 5947 of file qgraphicsscene.cpp.

 {
     views.removeAll(view);
 }

◆ resetDirtyItem()

void QGraphicsScenePrivate::resetDirtyItem	(	QGraphicsItem *	item,
		bool	recursive = `false`
	)

inline

Definition at line 236 of file qgraphicsscene_p.h.

Referenced by _q_processDirtyItems(), and removeItemHelper().

     {
         Q_ASSERT(item);
         item->d_ptr->dirty = 0;
         item->d_ptr->paintedViewBoundingRectsNeedRepaint = 0;
         item->d_ptr->geometryChanged = 0;
         if (!item->d_ptr->dirtyChildren)
             recursive = false;
         item->d_ptr->dirtyChildren = 0;
         item->d_ptr->needsRepaint = QRectF();
         item->d_ptr->allChildrenDirty = 0;
         item->d_ptr->fullUpdatePending = 0;
         item->d_ptr->ignoreVisible = 0;
         item->d_ptr->ignoreOpacity = 0;
 #ifndef QT_NO_GRAPHICSEFFECT
         QGraphicsEffect::ChangeFlags flags;
         if (item->d_ptr->notifyBoundingRectChanged) {
             flags |= QGraphicsEffect::SourceBoundingRectChanged;
             item->d_ptr->notifyBoundingRectChanged = 0;
         }
         if (item->d_ptr->notifyInvalidated) {
             flags |= QGraphicsEffect::SourceInvalidated;
             item->d_ptr->notifyInvalidated = 0;
         }
 #endif //QT_NO_GRAPHICSEFFECT
         if (recursive) {
             for (int i = 0; i < item->d_ptr->children.size(); ++i)
                 resetDirtyItem(item->d_ptr->children.at(i), recursive);
         }
 #ifndef QT_NO_GRAPHICSEFFECT
         if (flags && item->d_ptr->graphicsEffect)
             item->d_ptr->graphicsEffect->sourceChanged(flags);
 #endif //QT_NO_GRAPHICSEFFECT
     }

◆ resolveFont()

void QGraphicsScenePrivate::resolveFont ( )

Resolve the scene's font against the application font, and propagate the changes too all items in the scene.

Warning: This function is not part of the public interface.

Definition at line 1529 of file qgraphicsscene.cpp.

 {
     QFont naturalFont = QApplication::font();
     naturalFont.resolve(0);
     QFont resolvedFont = font.resolve(naturalFont);
     updateFont(resolvedFont);
 }

◆ resolvePalette()

void QGraphicsScenePrivate::resolvePalette ( )

Resolve the scene's palette against the application palette, and propagate the changes too all items in the scene.

Warning: This function is not part of the public interface.

Definition at line 1594 of file qgraphicsscene.cpp.

 {
     QPalette naturalPalette = QApplication::palette();
     naturalPalette.resolve(0);
     QPalette resolvedPalette = palette.resolve(naturalPalette);
     updatePalette(resolvedPalette);
 }

◆ sendDragDropEvent()

void QGraphicsScenePrivate::sendDragDropEvent	(	QGraphicsItem *	item,
		QGraphicsSceneDragDropEvent *	dragDropEvent
	)

Warning: This function is not part of the public interface.

Definition at line 1263 of file qgraphicsscene.cpp.

 {
     dragDropEvent->setPos(item->d_ptr->genericMapFromScene(dragDropEvent->scenePos(), dragDropEvent->widget()));
     sendEvent(item, dragDropEvent);
 }

◆ sendEvent()

bool QGraphicsScenePrivate::sendEvent	(	QGraphicsItem *	item,
		QEvent *	event
	)

This is the final dispatch point for any events from the scene to the item.

Warning: This function is not part of the public interface.

It filters the event first - if the filter returns true, the event is considered to have been eaten by the filter, and is therefore stopped (the default filter returns false). Then/otherwise, if the item is enabled, the event is sent; otherwise it is stopped.

Definition at line 1214 of file qgraphicsscene.cpp.

Referenced by addPopup(), grabKeyboard(), grabMouse(), removePopup(), sendDragDropEvent(), sendHoverEvent(), sendMouseEvent(), setFocusItemHelper(), ungrabKeyboard(), and ungrabMouse().

 {
     if (QGraphicsObject *object = item->toGraphicsObject()) {
 #ifndef QT_NO_GESTURES
         QGestureManager *gestureManager = QApplicationPrivate::instance()->gestureManager;
         if (gestureManager) {
             if (gestureManager->filterEvent(object, event))
                 return true;
         }
 #endif // QT_NO_GESTURES
     }
 
     if (filterEvent(item, event))
         return false;
     if (filterDescendantEvent(item, event))
         return false;
     if (!item || !item->isEnabled())
         return false;
     if (QGraphicsObject *o = item->toGraphicsObject()) {
         bool spont = event->spontaneous();
         if (spont ? qt_sendSpontaneousEvent(o, event) : QApplication::sendEvent(o, event))
             return true;
         event->spont = spont;
     }
     return item->sceneEvent(event);
 }

◆ sendHoverEvent()

void QGraphicsScenePrivate::sendHoverEvent	(	QEvent::Type	type,
		QGraphicsItem *	item,
		QGraphicsSceneHoverEvent *	hoverEvent
	)

Warning: This function is not part of the public interface.

Definition at line 1273 of file qgraphicsscene.cpp.

 {
     QGraphicsSceneHoverEvent event(type);
     event.setWidget(hoverEvent->widget());
     event.setPos(item->d_ptr->genericMapFromScene(hoverEvent->scenePos(), hoverEvent->widget()));
     event.setScenePos(hoverEvent->scenePos());
     event.setScreenPos(hoverEvent->screenPos());
     event.setLastPos(item->d_ptr->genericMapFromScene(hoverEvent->lastScenePos(), hoverEvent->widget()));
     event.setLastScenePos(hoverEvent->lastScenePos());
     event.setLastScreenPos(hoverEvent->lastScreenPos());
     event.setModifiers(hoverEvent->modifiers());
     sendEvent(item, &event);
 }

◆ sendMouseEvent()

void QGraphicsScenePrivate::sendMouseEvent ( QGraphicsSceneMouseEvent * mouseEvent )

Warning: This function is not part of the public interface.

Definition at line 1291 of file qgraphicsscene.cpp.

Referenced by mousePressEventHandler().

 {
     if (mouseEvent->button() == 0 && mouseEvent->buttons() == 0 && lastMouseGrabberItemHasImplicitMouseGrab) {
         // ### This is a temporary fix for until we get proper mouse
         // grab events.
         clearMouseGrabber();
         return;
     }
 
     QGraphicsItem *item = mouseGrabberItems.last();
     if (item->isBlockedByModalPanel())
         return;
 
     for (int i = 0x1; i <= 0x10; i <<= 1) {
         Qt::MouseButton button = Qt::MouseButton(i);
         mouseEvent->setButtonDownPos(button, mouseGrabberButtonDownPos.value(button, item->d_ptr->genericMapFromScene(mouseEvent->scenePos(), mouseEvent->widget())));
         mouseEvent->setButtonDownScenePos(button, mouseGrabberButtonDownScenePos.value(button, mouseEvent->scenePos()));
         mouseEvent->setButtonDownScreenPos(button, mouseGrabberButtonDownScreenPos.value(button, mouseEvent->screenPos()));
     }
     mouseEvent->setPos(item->d_ptr->genericMapFromScene(mouseEvent->scenePos(), mouseEvent->widget()));
     mouseEvent->setLastPos(item->d_ptr->genericMapFromScene(mouseEvent->lastScenePos(), mouseEvent->widget()));
     sendEvent(item, mouseEvent);
 }

◆ sendTouchBeginEvent()

bool QGraphicsScenePrivate::sendTouchBeginEvent	(	QGraphicsItem *	item,
		QTouchEvent *	touchEvent
	)

Definition at line 6106 of file qgraphicsscene.cpp.

 {
     Q_Q(QGraphicsScene);
 
     if (cachedItemsUnderMouse.isEmpty() || cachedItemsUnderMouse.first() != origin) {
         const QTouchEvent::TouchPoint &firstTouchPoint = touchEvent->touchPoints().first();
         cachedItemsUnderMouse = itemsAtPosition(firstTouchPoint.screenPos().toPoint(),
                                                 firstTouchPoint.scenePos(),
                                                 touchEvent->widget());
     }
 
     // Set focus on the topmost enabled item that can take focus.
     bool setFocus = false;
 
     foreach (QGraphicsItem *item, cachedItemsUnderMouse) {
         if (item->isEnabled() && ((item->flags() & QGraphicsItem::ItemIsFocusable) && item->d_ptr->mouseSetsFocus)) {
             if (!item->isWidget() || ((QGraphicsWidget *)item)->focusPolicy() & Qt::ClickFocus) {
                 setFocus = true;
                 if (item != q->focusItem())
                     q->setFocusItem(item, Qt::MouseFocusReason);
                 break;
             }
         }
         if (item->isPanel())
             break;
         if (item->d_ptr->flags & QGraphicsItem::ItemStopsClickFocusPropagation)
             break;
         if (item->d_ptr->flags & QGraphicsItem::ItemStopsFocusHandling) {
             // Make sure we don't clear focus.
             setFocus = true;
             break;
         }
     }
 
     // If nobody could take focus, clear it.
     if (!stickyFocus && !setFocus)
         q->setFocusItem(0, Qt::MouseFocusReason);
 
     bool res = false;
     bool eventAccepted = touchEvent->isAccepted();
     foreach (QGraphicsItem *item, cachedItemsUnderMouse) {
         // first, try to deliver the touch event
         updateTouchPointsForItem(item, touchEvent);
         bool acceptTouchEvents = item->acceptTouchEvents();
         touchEvent->setAccepted(acceptTouchEvents);
         res = acceptTouchEvents && sendEvent(item, touchEvent);
         eventAccepted = touchEvent->isAccepted();
         if (itemForTouchPointId.value(touchEvent->touchPoints().first().id()) == 0) {
             // item was deleted
             item = 0;
         } else {
             item->d_ptr->acceptedTouchBeginEvent = (res && eventAccepted);
         }
         touchEvent->spont = false;
         if (res && eventAccepted) {
             // the first item to accept the TouchBegin gets an implicit grab.
             for (int i = 0; i < touchEvent->touchPoints().count(); ++i) {
                 const QTouchEvent::TouchPoint &touchPoint = touchEvent->touchPoints().at(i);
                 itemForTouchPointId[touchPoint.id()] = item; // can be zero
             }
             break;
         }
         if (item && item->isPanel())
             break;
     }
 
     touchEvent->setAccepted(eventAccepted);
     return res;
 }

◆ setActivePanelHelper()

void QGraphicsScenePrivate::setActivePanelHelper	(	QGraphicsItem *	item,
		bool	duringActivationEvent
	)

Warning: This function is not part of the public interface.

Definition at line 742 of file qgraphicsscene.cpp.

 {
     Q_Q(QGraphicsScene);
     if (item && item->scene() != q) {
         qWarning("QGraphicsScene::setActivePanel: item %p must be part of this scene",
                  item);
         return;
     }
 
     // Ensure the scene has focus when we change panel activation.
     q->setFocus(Qt::ActiveWindowFocusReason);
 
     // Find the item's panel.
     QGraphicsItem *panel = item ? item->panel() : 0;
     lastActivePanel = panel ? activePanel : 0;
     if (panel == activePanel || (!q->isActive() && !duringActivationEvent))
         return;
 
     // Deactivate the last active panel.
     if (activePanel) {
         if (QGraphicsItem *fi = activePanel->focusItem()) {
             // Remove focus from the current focus item.
             if (fi == q->focusItem())
                 q->setFocusItem(0, Qt::ActiveWindowFocusReason);
         }
 
         QEvent event(QEvent::WindowDeactivate);
         q->sendEvent(activePanel, &event);
     } else if (panel && !duringActivationEvent) {
         // Deactivate the scene if changing activation to a panel.
         QEvent event(QEvent::WindowDeactivate);
         foreach (QGraphicsItem *item, q->items()) {
             if (item->isVisible() && !item->isPanel() && !item->parentItem())
                 q->sendEvent(item, &event);
         }
     }
 
     // Update activate state.
     activePanel = panel;
     QEvent event(QEvent::ActivationChange);
     QApplication::sendEvent(q, &event);
 
     // Activate
     if (panel) {
         QEvent event(QEvent::WindowActivate);
         q->sendEvent(panel, &event);
 
         // Set focus on the panel's focus item.
         if (QGraphicsItem *focusItem = panel->focusItem())
             focusItem->setFocus(Qt::ActiveWindowFocusReason);
     } else if (q->isActive()) {
         // Activate the scene
         QEvent event(QEvent::WindowActivate);
         foreach (QGraphicsItem *item, q->items()) {
             if (item->isVisible() && !item->isPanel() && !item->parentItem())
                 q->sendEvent(item, &event);
         }
     }
 }

◆ setFocusItemHelper()

void QGraphicsScenePrivate::setFocusItemHelper	(	QGraphicsItem *	item,
		Qt::FocusReason	focusReason
	)

Warning: This function is not part of the public interface.

Definition at line 805 of file qgraphicsscene.cpp.

 {
     Q_Q(QGraphicsScene);
     if (item == focusItem)
         return;
 
     // Clear focus if asked to set focus on something that can't
     // accept input focus.
     if (item && (!(item->flags() & QGraphicsItem::ItemIsFocusable)
                  || !item->isVisible() || !item->isEnabled())) {
         item = 0;
     }
 
     // Set focus on the scene if an item requests focus.
     if (item) {
         q->setFocus(focusReason);
         if (item == focusItem)
             return;
     }
 
     if (focusItem) {
         lastFocusItem = focusItem;
 
 #ifndef QT_NO_IM
         if (lastFocusItem
             && (lastFocusItem->flags() & QGraphicsItem::ItemAcceptsInputMethod)) {
             // Close any external input method panel. This happens
             // automatically by removing WA_InputMethodEnabled on
             // the views, but if we are changing focus, we have to
             // do it ourselves.
             for (int i = 0; i < views.size(); ++i)
                 if (views.at(i)->inputContext())
                     views.at(i)->inputContext()->reset();
         }
 
         focusItem = 0;
         QFocusEvent event(QEvent::FocusOut, focusReason);
         sendEvent(lastFocusItem, &event);
 #endif //QT_NO_IM
     }
 
     // This handles the case that the item has been removed from the
     // scene in response to the FocusOut event.
     if (item && item->scene() != q)
         item = 0;
 
     if (item)
         focusItem = item;
     updateInputMethodSensitivityInViews();
 
 #ifndef QT_NO_ACCESSIBILITY
     if (focusItem) {
         if (QGraphicsObject *focusObj = focusItem->toGraphicsObject()) {
             QAccessible::updateAccessibility(focusObj, 0, QAccessible::Focus);
         }
     }
 #endif
     if (item) {
         QFocusEvent event(QEvent::FocusIn, focusReason);
         sendEvent(item, &event);
     }
 }

◆ setFont_helper()

void QGraphicsScenePrivate::setFont_helper ( const QFont & font )

Set the font and propagate the changes if the font is different from the current font.

Warning: This function is not part of the public interface.

Definition at line 1513 of file qgraphicsscene.cpp.

 {
     if (this->font == font && this->font.resolve() == font.resolve())
         return;
     updateFont(font);
 }

◆ setPalette_helper()

void QGraphicsScenePrivate::setPalette_helper ( const QPalette & palette )

Set the palette and propagate the changes if the palette is different from the current palette.

Warning: This function is not part of the public interface.

Definition at line 1578 of file qgraphicsscene.cpp.

 {
     if (this->palette == palette && this->palette.resolve() == palette.resolve())
         return;
     updatePalette(palette);
 }

◆ setScenePosItemEnabled()

void QGraphicsScenePrivate::setScenePosItemEnabled	(	QGraphicsItem *	item,
		bool	enabled
	)

Warning: This function is not part of the public interface.

Definition at line 529 of file qgraphicsscene.cpp.

Referenced by registerScenePosItem(), and unregisterScenePosItem().

 {
     QGraphicsItem *p = item->d_ptr->parent;
     while (p) {
         p->d_ptr->scenePosDescendants = enabled;
         p = p->d_ptr->parent;
     }
     if (!enabled && !scenePosDescendantsUpdatePending) {
         scenePosDescendantsUpdatePending = true;
         QMetaObject::invokeMethod(q_func(), "_q_updateScenePosDescendants", Qt::QueuedConnection);
     }
 }

◆ storeMouseButtonsForMouseGrabber()

void QGraphicsScenePrivate::storeMouseButtonsForMouseGrabber ( QGraphicsSceneMouseEvent * event )

Warning: This function is not part of the public interface.

Definition at line 1126 of file qgraphicsscene.cpp.

 {
     for (int i = 0x1; i <= 0x10; i <<= 1) {
         if (event->buttons() & i) {
             mouseGrabberButtonDownPos.insert(Qt::MouseButton(i),
                                              mouseGrabberItems.last()->d_ptr->genericMapFromScene(event->scenePos(),
                                                                                                   event->widget()));
             mouseGrabberButtonDownScenePos.insert(Qt::MouseButton(i), event->scenePos());
             mouseGrabberButtonDownScreenPos.insert(Qt::MouseButton(i), event->screenPos());
         }
     }
 }

◆ touchEventHandler()

void QGraphicsScenePrivate::touchEventHandler ( QTouchEvent * touchEvent )

Definition at line 5978 of file qgraphicsscene.cpp.

 {
     typedef QPair<Qt::TouchPointStates, QList<QTouchEvent::TouchPoint> > StatesAndTouchPoints;
     QHash<QGraphicsItem *, StatesAndTouchPoints> itemsNeedingEvents;
 
     for (int i = 0; i < sceneTouchEvent->touchPoints().count(); ++i) {
         const QTouchEvent::TouchPoint &touchPoint = sceneTouchEvent->touchPoints().at(i);
 
         // update state
         QGraphicsItem *item = 0;
         if (touchPoint.state() == Qt::TouchPointPressed) {
             if (sceneTouchEvent->deviceType() == QTouchEvent::TouchPad) {
                 // on touch-pad devices, send all touch points to the same item
                 item = itemForTouchPointId.isEmpty()
                        ? 0
                        : itemForTouchPointId.constBegin().value();
             }
 
             if (!item) {
                 // determine which item this touch point will go to
                 cachedItemsUnderMouse = itemsAtPosition(touchPoint.screenPos().toPoint(),
                                                         touchPoint.scenePos(),
                                                         sceneTouchEvent->widget());
                 item = cachedItemsUnderMouse.isEmpty() ? 0 : cachedItemsUnderMouse.first();
             }
 
             if (sceneTouchEvent->deviceType() == QTouchEvent::TouchScreen) {
                 // on touch-screens, combine this touch point with the closest one we find
                 int closestTouchPointId = findClosestTouchPointId(touchPoint.scenePos());
                 QGraphicsItem *closestItem = itemForTouchPointId.value(closestTouchPointId);
                 if (!item || (closestItem && cachedItemsUnderMouse.contains(closestItem)))
                     item = closestItem;
             }
             if (!item)
                 continue;
 
             itemForTouchPointId.insert(touchPoint.id(), item);
             sceneCurrentTouchPoints.insert(touchPoint.id(), touchPoint);
         } else if (touchPoint.state() == Qt::TouchPointReleased) {
             item = itemForTouchPointId.take(touchPoint.id());
             if (!item)
                 continue;
 
             sceneCurrentTouchPoints.remove(touchPoint.id());
         } else {
             item = itemForTouchPointId.value(touchPoint.id());
             if (!item)
                 continue;
             Q_ASSERT(sceneCurrentTouchPoints.contains(touchPoint.id()));
             sceneCurrentTouchPoints[touchPoint.id()] = touchPoint;
         }
 
         StatesAndTouchPoints &statesAndTouchPoints = itemsNeedingEvents[item];
         statesAndTouchPoints.first |= touchPoint.state();
         statesAndTouchPoints.second.append(touchPoint);
     }
 
     if (itemsNeedingEvents.isEmpty()) {
         sceneTouchEvent->accept();
         return;
     }
 
     bool ignoreSceneTouchEvent = true;
     QHash<QGraphicsItem *, StatesAndTouchPoints>::ConstIterator it = itemsNeedingEvents.constBegin();
     const QHash<QGraphicsItem *, StatesAndTouchPoints>::ConstIterator end = itemsNeedingEvents.constEnd();
     for (; it != end; ++it) {
         QGraphicsItem *item = it.key();
 
         (void) item->isBlockedByModalPanel(&item);
 
         // determine event type from the state mask
         QEvent::Type eventType;
         switch (it.value().first) {
         case Qt::TouchPointPressed:
             // all touch points have pressed state
             eventType = QEvent::TouchBegin;
             break;
         case Qt::TouchPointReleased:
             // all touch points have released state
             eventType = QEvent::TouchEnd;
             break;
         case Qt::TouchPointStationary:
             // don't send the event if nothing changed
             continue;
         default:
             // all other combinations
             eventType = QEvent::TouchUpdate;
             break;
         }
 
         QTouchEvent touchEvent(eventType);
         touchEvent.setWidget(sceneTouchEvent->widget());
         touchEvent.setDeviceType(sceneTouchEvent->deviceType());
         touchEvent.setModifiers(sceneTouchEvent->modifiers());
         touchEvent.setTouchPointStates(it.value().first);
         touchEvent.setTouchPoints(it.value().second);
 
         switch (touchEvent.type()) {
         case QEvent::TouchBegin:
         {
             // if the TouchBegin handler recurses, we assume that means the event
             // has been implicitly accepted and continue to send touch events
             item->d_ptr->acceptedTouchBeginEvent = true;
             bool res = sendTouchBeginEvent(item, &touchEvent)
                        && touchEvent.isAccepted();
             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;
         }
         default:
             if (item->d_ptr->acceptedTouchBeginEvent) {
                 updateTouchPointsForItem(item, &touchEvent);
                 (void) sendEvent(item, &touchEvent);
                 ignoreSceneTouchEvent = false;
             }
             break;
         }
     }
     sceneTouchEvent->setAccepted(ignoreSceneTouchEvent);
 }

◆ ungrabGesture()

void QGraphicsScenePrivate::ungrabGesture	(	QGraphicsItem *	item,
		Qt::GestureType	gesture
	)

Definition at line 6662 of file qgraphicsscene.cpp.

Referenced by removeItemHelper().

 {
     // we know this can only be an object
     Q_ASSERT(item->d_ptr->isObject);
     QGraphicsObject *obj = static_cast<QGraphicsObject *>(item);
     QGestureManager::instance()->cleanupCachedGestures(obj, gesture);
     if (!--grabbedGestures[gesture]) {
         foreach (QGraphicsView *view, views)
             view->viewport()->ungrabGesture(gesture);
     }
 }

◆ ungrabKeyboard()

void QGraphicsScenePrivate::ungrabKeyboard	(	QGraphicsItem *	item,
		bool	itemIsDying = `false`
	)

Warning: This function is not part of the public interface.

Definition at line 1053 of file qgraphicsscene.cpp.

Referenced by clearKeyboardGrabber(), removeItemHelper(), and removePopup().

 {
     int index = keyboardGrabberItems.lastIndexOf(item);
     if (index == -1) {
         qWarning("QGraphicsItem::ungrabKeyboard: not a keyboard grabber");
         return;
     }
     if (item != keyboardGrabberItems.last()) {
         // Recursively ungrab the topmost keyboard grabber until we reach this
         // item to ensure state consistency.
         ungrabKeyboard(keyboardGrabberItems.at(index + 1), itemIsDying);
     }
 
     // Send notification about keyboard ungrab.
     if (!itemIsDying) {
         QEvent event(QEvent::UngrabKeyboard);
         sendEvent(item, &event);
     }
 
     // Remove the item from the list of grabbers.
     keyboardGrabberItems.takeLast();
 
     // Send notification about mouse regrab.
     if (!itemIsDying && !keyboardGrabberItems.isEmpty()) {
         QGraphicsItem *last = keyboardGrabberItems.last();
         QEvent event(QEvent::GrabKeyboard);
         sendEvent(last, &event);
     }
 }

◆ ungrabMouse()

void QGraphicsScenePrivate::ungrabMouse	(	QGraphicsItem *	item,
		bool	itemIsDying = `false`
	)

Warning: This function is not part of the public interface.

Definition at line 968 of file qgraphicsscene.cpp.

Referenced by removeItemHelper(), and removePopup().

 {
     int index = mouseGrabberItems.indexOf(item);
     if (index == -1) {
         qWarning("QGraphicsItem::ungrabMouse: not a mouse grabber");
         return;
     }
 
     if (item != mouseGrabberItems.last()) {
         // Recursively ungrab the next mouse grabber until we reach this item
         // to ensure state consistency.
         ungrabMouse(mouseGrabberItems.at(index + 1), itemIsDying);
     }
     if (!popupWidgets.isEmpty() && item == popupWidgets.last()) {
         // If the item is a popup, go via removePopup to ensure state
         // consistency and that it gets hidden correctly - beware that
         // removePopup() reenters this function to continue removing the grab.
         removePopup((QGraphicsWidget *)item, itemIsDying);
         return;
     }
 
     // Send notification about mouse ungrab.
     if (!itemIsDying) {
         QEvent event(QEvent::UngrabMouse);
         sendEvent(item, &event);
     }
 
     // Remove the item from the list of grabbers. Whenever this happens, we
     // reset the implicitGrab (there can be only ever be one implicit grabber
     // in a scene, and it is always the latest grabber; if the implicit grab
     // is lost, it is not automatically regained.
     mouseGrabberItems.takeLast();
     lastMouseGrabberItemHasImplicitMouseGrab = false;
 
     // Send notification about mouse regrab. ### It's unfortunate that all the
     // items get a GrabMouse event, but this is a rare case with a simple
     // implementation and it does ensure a consistent state.
     if (!itemIsDying && !mouseGrabberItems.isEmpty()) {
         QGraphicsItem *last = mouseGrabberItems.last();
         QEvent event(QEvent::GrabMouse);
         sendEvent(last, &event);
     }
 }

◆ unregisterScenePosItem()

void QGraphicsScenePrivate::unregisterScenePosItem ( QGraphicsItem * item )

Warning: This function is not part of the public interface.

Definition at line 554 of file qgraphicsscene.cpp.

Referenced by removeItemHelper().

 {
     scenePosItems.remove(item);
     setScenePosItemEnabled(item, false);
 }

◆ unregisterTopLevelItem()

void QGraphicsScenePrivate::unregisterTopLevelItem ( QGraphicsItem * item )

Warning: This function is not part of the public interface.

This function is almost identical to QGraphicsItemPrivate::removeChild().

Definition at line 428 of file qgraphicsscene.cpp.

Referenced by removeItemHelper().

 {
     if (!holesInTopLevelSiblingIndex)
         holesInTopLevelSiblingIndex = item->d_ptr->siblingIndex != topLevelItems.size() - 1;
     if (topLevelSequentialOrdering && !holesInTopLevelSiblingIndex)
         topLevelItems.removeAt(item->d_ptr->siblingIndex);
     else
         topLevelItems.removeOne(item);
     // NB! Do not use topLevelItems.removeAt(item->d_ptr->siblingIndex) because
     // the item is not guaranteed to be at the index after the list is sorted
     // (see ensureSortedTopLevelItems()).
     item->d_ptr->siblingIndex = -1;
     if (topLevelSequentialOrdering)
         topLevelSequentialOrdering = !holesInTopLevelSiblingIndex;
 }

◆ updateFont()

void QGraphicsScenePrivate::updateFont ( const QFont & font )

Update the font, and whether or not it has changed, reresolve all fonts in the scene.

Warning: This function is not part of the public interface.

Definition at line 1546 of file qgraphicsscene.cpp.

Referenced by resolveFont(), and setFont_helper().

 {
     Q_Q(QGraphicsScene);
 
     // Update local font setting.
     this->font = font;
 
     // Resolve the fonts of all top-level widget items, or widget items
     // whose parent is not a widget.
     foreach (QGraphicsItem *item, q->items()) {
         if (!item->parentItem()) {
             // Resolvefont for an item is a noop operation, but
             // every item can be a widget, or can have a widget
             // childre.
             item->d_ptr->resolveFont(font.resolve());
         }
     }
 
     // Send the scene a FontChange event.
     QEvent event(QEvent::FontChange);
     QApplication::sendEvent(q, &event);
 }

◆ updateInputMethodSensitivityInViews()

void QGraphicsScenePrivate::updateInputMethodSensitivityInViews ( )

Definition at line 6182 of file qgraphicsscene.cpp.

Referenced by setFocusItemHelper().

 {
     for (int i = 0; i < views.size(); ++i)
         views.at(i)->d_func()->updateInputMethodSensitivity();
 }

◆ updatePalette()

void QGraphicsScenePrivate::updatePalette ( const QPalette & palette )

Update the palette, and whether or not it has changed, reresolve all palettes in the scene.

Warning: This function is not part of the public interface.

Definition at line 1611 of file qgraphicsscene.cpp.

Referenced by resolvePalette(), and setPalette_helper().

 {
     Q_Q(QGraphicsScene);
 
     // Update local palette setting.
     this->palette = palette;
 
     // Resolve the palettes of all top-level widget items, or widget items
     // whose parent is not a widget.
     foreach (QGraphicsItem *item, q->items()) {
         if (!item->parentItem()) {
             // Resolvefont for an item is a noop operation, but
             // every item can be a widget, or can have a widget
             // childre.
             item->d_ptr->resolvePalette(palette.resolve());
         }
     }
 
     // Send the scene a PaletteChange event.
     QEvent event(QEvent::PaletteChange);
     QApplication::sendEvent(q, &event);
 }

◆ updateTouchPointsForItem()

void QGraphicsScenePrivate::updateTouchPointsForItem	(	QGraphicsItem *	item,
		QTouchEvent *	touchEvent
	)

static

Definition at line 5952 of file qgraphicsscene.cpp.

 {
     QList<QTouchEvent::TouchPoint> touchPoints = touchEvent->touchPoints();
     for (int i = 0; i < touchPoints.count(); ++i) {
         QTouchEvent::TouchPoint &touchPoint = touchPoints[i];
         touchPoint.setRect(item->mapFromScene(touchPoint.sceneRect()).boundingRect());
         touchPoint.setStartPos(item->d_ptr->genericMapFromScene(touchPoint.startScenePos(), touchEvent->widget()));
         touchPoint.setLastPos(item->d_ptr->genericMapFromScene(touchPoint.lastScenePos(), touchEvent->widget()));
     }
     touchEvent->setTouchPoints(touchPoints);
 }

◆ windowForItem()

QGraphicsWidget* QGraphicsScenePrivate::windowForItem ( const QGraphicsItem * item ) const

Properties

◆ activationRefCount

int QGraphicsScenePrivate::activationRefCount

Definition at line 157 of file qgraphicsscene_p.h.

◆ activePanel

QGraphicsItem* QGraphicsScenePrivate::activePanel

Definition at line 155 of file qgraphicsscene_p.h.

Referenced by removeItemHelper(), and setActivePanelHelper().

◆ allItemsIgnoreHoverEvents

quint32 QGraphicsScenePrivate::allItemsIgnoreHoverEvents

Definition at line 113 of file qgraphicsscene_p.h.

◆ allItemsIgnoreTouchEvents

quint32 QGraphicsScenePrivate::allItemsIgnoreTouchEvents

Definition at line 117 of file qgraphicsscene_p.h.

◆ allItemsUseDefaultCursor

quint32 QGraphicsScenePrivate::allItemsUseDefaultCursor

Definition at line 114 of file qgraphicsscene_p.h.

◆ backgroundBrush

QBrush QGraphicsScenePrivate::backgroundBrush

Definition at line 147 of file qgraphicsscene_p.h.

◆ cachedAlreadyDeliveredGestures

QHash<QGraphicsObject *, QSet<QGesture *> > QGraphicsScenePrivate::cachedAlreadyDeliveredGestures

Definition at line 305 of file qgraphicsscene_p.h.

Referenced by removeItemHelper().

◆ cachedItemGestures

QHash<QGraphicsObject *, QSet<QGesture *> > QGraphicsScenePrivate::cachedItemGestures

Definition at line 304 of file qgraphicsscene_p.h.

Referenced by removeItemHelper().

◆ cachedItemsUnderMouse

QList<QGraphicsItem *> QGraphicsScenePrivate::cachedItemsUnderMouse

Definition at line 180 of file qgraphicsscene_p.h.

Referenced by mousePressEventHandler(), and removeItemHelper().

◆ cachedTargetItems

QList<QGraphicsObject *> QGraphicsScenePrivate::cachedTargetItems

Definition at line 302 of file qgraphicsscene_p.h.

Referenced by removeItemHelper().

◆ calledEmitUpdated

quint32 QGraphicsScenePrivate::calledEmitUpdated

Definition at line 104 of file qgraphicsscene_p.h.

Referenced by _q_emitUpdated(), and _q_processDirtyItems().

◆ changedSignalIndex

int QGraphicsScenePrivate::changedSignalIndex

Definition at line 90 of file qgraphicsscene_p.h.

Referenced by _q_emitUpdated(), init(), and QGraphicsItem::prepareGeometryChange().

◆ childExplicitActivation

int QGraphicsScenePrivate::childExplicitActivation

Definition at line 158 of file qgraphicsscene_p.h.

◆ dirtyGrowingItemsBoundingRect

quint32 QGraphicsScenePrivate::dirtyGrowingItemsBoundingRect

Definition at line 102 of file qgraphicsscene_p.h.

Referenced by _q_emitUpdated(), _q_processDirtyItems(), and QGraphicsScene::~QGraphicsScene().

◆ dragDropItem

QGraphicsItem* QGraphicsScenePrivate::dragDropItem

Definition at line 177 of file qgraphicsscene_p.h.

Referenced by removeItemHelper().

◆ enterWidget

QGraphicsWidget* QGraphicsScenePrivate::enterWidget

Definition at line 178 of file qgraphicsscene_p.h.

◆ focusItem

QGraphicsItem* QGraphicsScenePrivate::focusItem

Definition at line 151 of file qgraphicsscene_p.h.

Referenced by addPopup(), removeItemHelper(), removePopup(), setActivePanelHelper(), and setFocusItemHelper().

◆ font

QFont QGraphicsScenePrivate::font

Definition at line 283 of file qgraphicsscene_p.h.

Referenced by resolveFont(), and updateFont().

◆ foregroundBrush

QBrush QGraphicsScenePrivate::foregroundBrush

Definition at line 148 of file qgraphicsscene_p.h.

◆ gestureTargets

QHash<QGesture *, QGraphicsObject *> QGraphicsScenePrivate::gestureTargets

Definition at line 306 of file qgraphicsscene_p.h.

Referenced by removeItemHelper().

◆ grabbedGestures

QHash<Qt::GestureType, int> QGraphicsScenePrivate::grabbedGestures

Definition at line 307 of file qgraphicsscene_p.h.

◆ growingItemsBoundingRect

QRectF QGraphicsScenePrivate::growingItemsBoundingRect

Definition at line 120 of file qgraphicsscene_p.h.

Referenced by _q_emitUpdated(), _q_processDirtyItems(), and QGraphicsScene::~QGraphicsScene().

◆ hasFocus

quint32 QGraphicsScenePrivate::hasFocus

Definition at line 111 of file qgraphicsscene_p.h.

◆ hasSceneRect

quint32 QGraphicsScenePrivate::hasSceneRect

Definition at line 101 of file qgraphicsscene_p.h.

Referenced by _q_emitUpdated(), and _q_processDirtyItems().

◆ holesInTopLevelSiblingIndex

quint32 QGraphicsScenePrivate::holesInTopLevelSiblingIndex

Definition at line 107 of file qgraphicsscene_p.h.

Referenced by ensureSequentialTopLevelSiblingIndexes(), and unregisterTopLevelItem().

◆ hoverItems

QList<QGraphicsItem *> QGraphicsScenePrivate::hoverItems

Definition at line 181 of file qgraphicsscene_p.h.

Referenced by removeItemHelper().

◆ index

QGraphicsSceneIndex* QGraphicsScenePrivate::index

Definition at line 95 of file qgraphicsscene_p.h.

Referenced by init(), QGraphicsItem::prepareGeometryChange(), removeItemHelper(), removePopup(), ungrabKeyboard(), and ungrabMouse().

◆ indexMethod

QGraphicsScene::ItemIndexMethod QGraphicsScenePrivate::indexMethod

Definition at line 94 of file qgraphicsscene_p.h.

◆ itemForTouchPointId

QMap<int, QGraphicsItem *> QGraphicsScenePrivate::itemForTouchPointId

Definition at line 295 of file qgraphicsscene_p.h.

Referenced by removeItemHelper().

◆ keyboardGrabberItems

QList<QGraphicsItem *> QGraphicsScenePrivate::keyboardGrabberItems

Definition at line 172 of file qgraphicsscene_p.h.

Referenced by clearKeyboardGrabber(), grabKeyboard(), removeItemHelper(), removePopup(), and ungrabKeyboard().

◆ lastActivePanel

QGraphicsItem* QGraphicsScenePrivate::lastActivePanel

Definition at line 156 of file qgraphicsscene_p.h.

Referenced by removeItemHelper(), and setActivePanelHelper().

◆ lastDropAction

Qt::DropAction QGraphicsScenePrivate::lastDropAction

Definition at line 179 of file qgraphicsscene_p.h.

◆ lastFocusItem

QGraphicsItem* QGraphicsScenePrivate::lastFocusItem

Definition at line 152 of file qgraphicsscene_p.h.

Referenced by removeItemHelper(), and setFocusItemHelper().

◆ lastItemCount

int QGraphicsScenePrivate::lastItemCount

Definition at line 97 of file qgraphicsscene_p.h.

◆ lastMouseGrabberItem

QGraphicsItem* QGraphicsScenePrivate::lastMouseGrabberItem

Definition at line 166 of file qgraphicsscene_p.h.

Referenced by clearMouseGrabber(), and removeItemHelper().

◆ lastMouseGrabberItemHasImplicitMouseGrab

quint32 QGraphicsScenePrivate::lastMouseGrabberItemHasImplicitMouseGrab

Definition at line 112 of file qgraphicsscene_p.h.

Referenced by grabMouse(), sendMouseEvent(), and ungrabMouse().

◆ lastSceneMousePos

QPointF QGraphicsScenePrivate::lastSceneMousePos

Definition at line 182 of file qgraphicsscene_p.h.

◆ modalPanels

QList<QGraphicsItem *> QGraphicsScenePrivate::modalPanels

Definition at line 322 of file qgraphicsscene_p.h.

Referenced by QGraphicsItem::isBlockedByModalPanel(), and mousePressEventHandler().

◆ mouseGrabberButtonDownPos

QMap<Qt::MouseButton, QPointF> QGraphicsScenePrivate::mouseGrabberButtonDownPos

Definition at line 184 of file qgraphicsscene_p.h.

Referenced by sendMouseEvent(), and storeMouseButtonsForMouseGrabber().

◆ mouseGrabberButtonDownScenePos

QMap<Qt::MouseButton, QPointF> QGraphicsScenePrivate::mouseGrabberButtonDownScenePos

Definition at line 185 of file qgraphicsscene_p.h.

Referenced by sendMouseEvent(), and storeMouseButtonsForMouseGrabber().

◆ mouseGrabberButtonDownScreenPos

QMap<Qt::MouseButton, QPoint> QGraphicsScenePrivate::mouseGrabberButtonDownScreenPos

Definition at line 186 of file qgraphicsscene_p.h.

Referenced by sendMouseEvent(), and storeMouseButtonsForMouseGrabber().

◆ mouseGrabberItems

QList<QGraphicsItem *> QGraphicsScenePrivate::mouseGrabberItems

Definition at line 167 of file qgraphicsscene_p.h.

Referenced by clearMouseGrabber(), grabMouse(), mousePressEventHandler(), removeItemHelper(), sendMouseEvent(), storeMouseButtonsForMouseGrabber(), and ungrabMouse().

◆ movingItemsInitialPositions

QMap<QGraphicsItem *, QPointF> QGraphicsScenePrivate::movingItemsInitialPositions

Definition at line 131 of file qgraphicsscene_p.h.

◆ needSortTopLevelItems

quint32 QGraphicsScenePrivate::needSortTopLevelItems

Definition at line 106 of file qgraphicsscene_p.h.

Referenced by ensureSequentialTopLevelSiblingIndexes(), and registerTopLevelItem().

◆ padding

quint32 QGraphicsScenePrivate::padding

Definition at line 118 of file qgraphicsscene_p.h.

◆ painterStateProtection

quint32 QGraphicsScenePrivate::painterStateProtection

Definition at line 115 of file qgraphicsscene_p.h.

◆ palette

QPalette QGraphicsScenePrivate::palette

Definition at line 287 of file qgraphicsscene_p.h.

Referenced by resolvePalette(), and updatePalette().

◆ passiveFocusItem

QGraphicsItem* QGraphicsScenePrivate::passiveFocusItem

Definition at line 153 of file qgraphicsscene_p.h.

Referenced by removeItemHelper().

◆ polishItemsIndex

int QGraphicsScenePrivate::polishItemsIndex

Definition at line 92 of file qgraphicsscene_p.h.

Referenced by init().

◆ popupWidgets

QList<QGraphicsWidget *> QGraphicsScenePrivate::popupWidgets

Definition at line 162 of file qgraphicsscene_p.h.

Referenced by addPopup(), QGraphicsItem::isBlockedByModalPanel(), removePopup(), and ungrabMouse().

◆ processDirtyItemsEmitted

quint32 QGraphicsScenePrivate::processDirtyItemsEmitted

Definition at line 105 of file qgraphicsscene_p.h.

Referenced by _q_processDirtyItems().

◆ processDirtyItemsIndex

int QGraphicsScenePrivate::processDirtyItemsIndex

Definition at line 91 of file qgraphicsscene_p.h.

Referenced by init().

◆ rectAdjust

quint32 QGraphicsScenePrivate::rectAdjust

Definition at line 150 of file qgraphicsscene_p.h.

◆ sceneCurrentTouchPoints

QMap<int, QTouchEvent::TouchPoint> QGraphicsScenePrivate::sceneCurrentTouchPoints

Definition at line 294 of file qgraphicsscene_p.h.

Referenced by removeItemHelper().

◆ sceneEventFilters

QMultiMap<QGraphicsItem *, QGraphicsItem *> QGraphicsScenePrivate::sceneEventFilters

Definition at line 196 of file qgraphicsscene_p.h.

Referenced by filterEvent(), installSceneEventFilter(), removeItemHelper(), and removeSceneEventFilter().

◆ scenePosDescendantsUpdatePending

quint32 QGraphicsScenePrivate::scenePosDescendantsUpdatePending

Definition at line 109 of file qgraphicsscene_p.h.

Referenced by _q_updateScenePosDescendants(), and setScenePosItemEnabled().

◆ scenePosItems

QSet<QGraphicsItem *> QGraphicsScenePrivate::scenePosItems

Definition at line 139 of file qgraphicsscene_p.h.

Referenced by _q_updateScenePosDescendants(), registerScenePosItem(), and unregisterScenePosItem().

◆ sceneRect

QRectF QGraphicsScenePrivate::sceneRect

Definition at line 99 of file qgraphicsscene_p.h.

◆ selectedItems

QSet<QGraphicsItem *> QGraphicsScenePrivate::selectedItems

Definition at line 127 of file qgraphicsscene_p.h.

Referenced by removeItemHelper(), and QGraphicsItem::setSelected().

◆ selectionArea

QPainterPath QGraphicsScenePrivate::selectionArea

Definition at line 125 of file qgraphicsscene_p.h.

◆ selectionChanging

int QGraphicsScenePrivate::selectionChanging

Definition at line 126 of file qgraphicsscene_p.h.

Referenced by removeItemHelper(), and QGraphicsItem::setSelected().

◆ sortCacheEnabled

quint32 QGraphicsScenePrivate::sortCacheEnabled

Definition at line 116 of file qgraphicsscene_p.h.

◆ stickyFocus

quint32 QGraphicsScenePrivate::stickyFocus

Definition at line 110 of file qgraphicsscene_p.h.

Referenced by mousePressEventHandler().

◆ style

QStyle* QGraphicsScenePrivate::style

Definition at line 282 of file qgraphicsscene_p.h.

◆ styleOptionTmp

QStyleOptionGraphicsItem QGraphicsScenePrivate::styleOptionTmp

Definition at line 292 of file qgraphicsscene_p.h.

◆ tabFocusFirst

QGraphicsWidget* QGraphicsScenePrivate::tabFocusFirst

Definition at line 154 of file qgraphicsscene_p.h.

Referenced by removeItemHelper(), QGraphicsWidget::setTabOrder(), and QGraphicsWidget::~QGraphicsWidget().

◆ topLevelItems

QList<QGraphicsItem *> QGraphicsScenePrivate::topLevelItems

Definition at line 129 of file qgraphicsscene_p.h.

Referenced by _q_processDirtyItems(), ensureSequentialTopLevelSiblingIndexes(), QGraphicsSceneIndex::estimateTopLevelItems(), registerTopLevelItem(), and unregisterTopLevelItem().

◆ topLevelSequentialOrdering

quint32 QGraphicsScenePrivate::topLevelSequentialOrdering

Definition at line 108 of file qgraphicsscene_p.h.

Referenced by ensureSequentialTopLevelSiblingIndexes(), and unregisterTopLevelItem().

◆ unpolishedItems

QVector<QGraphicsItem *> QGraphicsScenePrivate::unpolishedItems

Definition at line 128 of file qgraphicsscene_p.h.

Referenced by _q_polishItems(), and removeItemHelper().

◆ updateAll

quint32 QGraphicsScenePrivate::updateAll

Definition at line 103 of file qgraphicsscene_p.h.

Referenced by _q_emitUpdated(), and _q_processDirtyItems().

◆ updatedRects

QList<QRectF> QGraphicsScenePrivate::updatedRects

Definition at line 123 of file qgraphicsscene_p.h.

Referenced by _q_emitUpdated().

◆ views

QList<QGraphicsView *> QGraphicsScenePrivate::views

Definition at line 192 of file qgraphicsscene_p.h.

Referenced by _q_emitUpdated(), _q_processDirtyItems(), enableMouseTrackingOnViews(), QGraphicsItem::prepareGeometryChange(), and setFocusItemHelper().

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

/src/gui/graphicsview/qgraphicsscene_p.h
/src/gui/graphicsview/qgraphicsscene.cpp

Public Functions

Static Public Functions

Public Variables

Additional Inherited Members

Detailed Description

Constructors and Destructors

◆ QGraphicsScenePrivate()

Functions

◆ _q_emitUpdated()

◆ _q_polishItems()

◆ _q_processDirtyItems()

◆ _q_updateLater()

◆ _q_updateScenePosDescendants()

◆ addPopup()

◆ addView()

◆ cancelGesturesForChildren()

◆ clearKeyboardGrabber()

◆ clearMouseGrabber()

◆ cloneDragDropEvent()

◆ dispatchHoverEvent()

◆ draw()

◆ drawItemHelper()

◆ drawItems()

◆ drawSubtreeRecursive()

◆ enableMouseTrackingOnViews()

◆ enableTouchEventsOnViews()

◆ ensureSequentialTopLevelSiblingIndexes()

This function is almost identical to

◆ ensureSortedTopLevelItems()

◆ enterModal()

◆ filterDescendantEvent()

◆ filterEvent()

◆ findClosestTouchPointId()

◆ gestureEventHandler()

◆ gestureTargetsAtHotSpots()

◆ get()

◆ grabGesture()

◆ grabKeyboard()

◆ grabMouse()

◆ init()

◆ installSceneEventFilter()

◆ itemAcceptsHoverEvents_helper()

◆ itemsAtPosition()

◆ leaveModal()

◆ leaveScene()

◆ markDirty()

◆ mousePressEventHandler()

◆ processDirtyItemsRecursive()

◆ registerScenePosItem()

◆ registerTopLevelItem()

This function is almost identical to QGraphicsItemPrivate::addChild().

◆ removeItemHelper()

◆ removePopup()

◆ removeSceneEventFilter()

◆ removeView()

◆ resetDirtyItem()

◆ resolveFont()

◆ resolvePalette()

◆ sendDragDropEvent()

◆ sendEvent()

◆ sendHoverEvent()

◆ sendMouseEvent()

◆ sendTouchBeginEvent()

◆ setActivePanelHelper()

◆ setFocusItemHelper()

◆ setFont_helper()

◆ setPalette_helper()

◆ setScenePosItemEnabled()

◆ storeMouseButtonsForMouseGrabber()

◆ touchEventHandler()

◆ ungrabGesture()

◆ ungrabKeyboard()

◆ ungrabMouse()

◆ unregisterScenePosItem()

◆ unregisterTopLevelItem()

This function is almost identical to QGraphicsItemPrivate::removeChild().

◆ updateFont()

◆ updateInputMethodSensitivityInViews()

◆ updatePalette()

◆ updateTouchPointsForItem()