QGraphicsScene Class Reference

The QGraphicsScene class provides a surface for managing a large number of 2D graphical items. More...

#include <qgraphicsscene.h>

Inheritance diagram for QGraphicsScene:

Public Types
enum	ItemIndexMethod { BspTreeIndex, NoIndex = -1 }
	This enum describes the indexing algorithms QGraphicsScene provides for managing positional information about items on the scene. More...
enum	SceneLayer { ItemLayer = 0x1, BackgroundLayer = 0x2, ForegroundLayer = 0x4, AllLayers = 0xffff }
	This enum describes the rendering layers in a QGraphicsScene. More...

Public Slots
void	advance ()
	This slot advances the scene by one step, by calling QGraphicsItem::advance() for all items on the scene. More...
void	clear ()
	Removes and deletes all items from the scene, but otherwise leaves the state of the scene unchanged. More...
void	clearSelection ()
	Clears the current selection. More...
void	invalidate (const QRectF &rect=QRectF(), SceneLayers layers=AllLayers)
	Invalidates and schedules a redraw of the layers in rect on the scene. More...
void	update (const QRectF &rect=QRectF())
	Schedules a redraw of the area rect on the scene. More...
Public Slots inherited from QObject
void	deleteLater ()
	Schedules this object for deletion. More...

Signals
void	changed (const QList< QRectF > &region)
	This signal is emitted by QGraphicsScene when control reaches the event loop, if the scene content changes. More...
void	sceneRectChanged (const QRectF &rect)
	This signal is emitted by QGraphicsScene whenever the scene rect changes. More...
void	selectionChanged ()
	This signal is emitted by QGraphicsScene whenever the selection changes. More...
Signals inherited from QObject
void	destroyed (QObject *=0)
	This signal is emitted immediately before the object obj is destroyed, and can not be blocked. More...

Public Functions
QGraphicsItem *	activePanel () const
	Returns the current active panel, or 0 if no panel is currently active. More...
QGraphicsWidget *	activeWindow () const
	Returns the current active window, or 0 if no window is currently active. More...
QGraphicsEllipseItem *	addEllipse (const QRectF &rect, const QPen &pen=QPen(), const QBrush &brush=QBrush())
	Creates and adds an ellipse item to the scene, and returns the item pointer. More...
QGraphicsEllipseItem *	addEllipse (qreal x, qreal y, qreal w, qreal h, const QPen &pen=QPen(), const QBrush &brush=QBrush())
void	addItem (QGraphicsItem *item)
	Adds or moves the item and all its childen to this scene. More...
QGraphicsLineItem *	addLine (const QLineF &line, const QPen &pen=QPen())
	Creates and adds a line item to the scene, and returns the item pointer. More...
QGraphicsLineItem *	addLine (qreal x1, qreal y1, qreal x2, qreal y2, const QPen &pen=QPen())
QGraphicsPathItem *	addPath (const QPainterPath &path, const QPen &pen=QPen(), const QBrush &brush=QBrush())
	Creates and adds a path item to the scene, and returns the item pointer. More...
QGraphicsPixmapItem *	addPixmap (const QPixmap &pixmap)
	Creates and adds a pixmap item to the scene, and returns the item pointer. More...
QGraphicsPolygonItem *	addPolygon (const QPolygonF &polygon, const QPen &pen=QPen(), const QBrush &brush=QBrush())
	Creates and adds a polygon item to the scene, and returns the item pointer. More...
QGraphicsRectItem *	addRect (const QRectF &rect, const QPen &pen=QPen(), const QBrush &brush=QBrush())
	Creates and adds a rectangle item to the scene, and returns the item pointer. More...
QGraphicsRectItem *	addRect (qreal x, qreal y, qreal w, qreal h, const QPen &pen=QPen(), const QBrush &brush=QBrush())
QGraphicsSimpleTextItem *	addSimpleText (const QString &text, const QFont &font=QFont())
	Creates and adds a QGraphicsSimpleTextItem to the scene, and returns the item pointer. More...
QGraphicsTextItem *	addText (const QString &text, const QFont &font=QFont())
	Creates and adds a text item to the scene, and returns the item pointer. More...
QGraphicsProxyWidget *	addWidget (QWidget *widget, Qt::WindowFlags wFlags=0)
	Creates a new QGraphicsProxyWidget for widget, adds it to the scene, and returns a pointer to the proxy. More...
QBrush	backgroundBrush () const
int	bspTreeDepth () const
void	clearFocus ()
	Clears focus from the scene. More...
QList< QGraphicsItem * >	collidingItems (const QGraphicsItem *item, Qt::ItemSelectionMode mode=Qt::IntersectsItemShape) const
	Returns a list of all items that collide with item. More...
QGraphicsItemGroup *	createItemGroup (const QList< QGraphicsItem *> &items)
	Groups all items in items into a new QGraphicsItemGroup, and returns a pointer to the group. More...
void	destroyItemGroup (QGraphicsItemGroup *group)
	Reparents all items in group to group's parent item, then removes group from the scene, and finally deletes it. More...
QGraphicsItem *	focusItem () const
	When the scene is active, this functions returns the scene's current focus item, or 0 if no item currently has focus. More...
QFont	font () const
QBrush	foregroundBrush () const
bool	hasFocus () const
	Returns true if the scene has focus; otherwise returns false. More...
qreal	height () const
	This convenience function is equivalent to calling sceneRect(). More...
virtual QVariant	inputMethodQuery (Qt::InputMethodQuery query) const
	This method is used by input methods to query a set of properties of the scene to be able to support complex input method operations as support for surrounding text and reconversions. More...
void	invalidate (qreal x, qreal y, qreal w, qreal h, SceneLayers layers=AllLayers)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
bool	isActive () const
	Returns true if the scene is active (e. More...
bool	isSortCacheEnabled () const
QGraphicsItem *	itemAt (const QPointF &pos) const
	Returns the topmost visible item at the specified position, or 0 if there are no items at this position. More...
QGraphicsItem *	itemAt (const QPointF &pos, const QTransform &deviceTransform) const
	Returns the topmost visible item at the specified position, or 0 if there are no items at this position. More...
QGraphicsItem *	itemAt (qreal x, qreal y) const
	Returns the topmost item at the position specified by (x, y), or 0 if there are no items at this position. More...
QGraphicsItem *	itemAt (qreal x, qreal y, const QTransform &deviceTransform) const
	Returns the topmost item at the position specified by (x, y), or 0 if there are no items at this position. More...
ItemIndexMethod	itemIndexMethod () const
QList< QGraphicsItem * >	items () const
	Returns a list of all items in the scene in descending stacking order. More...
QList< QGraphicsItem * >	items (Qt::SortOrder order) const
	Returns an ordered list of all items on the scene. More...
QList< QGraphicsItem * >	items (const QPointF &pos, Qt::ItemSelectionMode mode, Qt::SortOrder order, const QTransform &deviceTransform=QTransform()) const
	Returns all visible items that, depending on mode, are at the specified pos in a list sorted using order. More...
QList< QGraphicsItem * >	items (const QRectF &rect, Qt::ItemSelectionMode mode, Qt::SortOrder order, const QTransform &deviceTransform=QTransform()) const
	Returns all visible items that, depending on mode, are either inside or intersect with the specified rect and return a list sorted using order. More...
QList< QGraphicsItem * >	items (const QPolygonF &polygon, Qt::ItemSelectionMode mode, Qt::SortOrder order, const QTransform &deviceTransform=QTransform()) const
	Returns all visible items that, depending on mode, are either inside or intersect with the specified polygon and return a list sorted using order. More...
QList< QGraphicsItem * >	items (const QPainterPath &path, Qt::ItemSelectionMode mode, Qt::SortOrder order, const QTransform &deviceTransform=QTransform()) const
	Returns all visible items that, depending on mode, are either inside or intersect with the specified path and return a list sorted using order. More...
QList< QGraphicsItem * >	items (const QPointF &pos) const
	Returns all visible items at position pos in the scene. More...
QList< QGraphicsItem * >	items (const QRectF &rect, Qt::ItemSelectionMode mode=Qt::IntersectsItemShape) const
	Returns all visible items that, depending on mode, are either inside or intersect with the specified rectangle. More...
QList< QGraphicsItem * >	items (const QPolygonF &polygon, Qt::ItemSelectionMode mode=Qt::IntersectsItemShape) const
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
QList< QGraphicsItem * >	items (const QPainterPath &path, Qt::ItemSelectionMode mode=Qt::IntersectsItemShape) const
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
QList< QGraphicsItem * >	items (qreal x, qreal y, qreal w, qreal h, Qt::ItemSelectionMode mode=Qt::IntersectsItemShape) const
QList< QGraphicsItem * >	items (qreal x, qreal y, qreal w, qreal h, Qt::ItemSelectionMode mode, Qt::SortOrder order, const QTransform &deviceTransform=QTransform()) const
	Returns all visible items that, depending on mode, are either inside or intersect with the rectangle defined by x, y,. More...
QRectF	itemsBoundingRect () const
	Calculates and returns the bounding rect of all items on the scene. More...
QGraphicsItem *	mouseGrabberItem () const
	Returns the current mouse grabber item, or 0 if no item is currently grabbing the mouse. More...
QPalette	palette () const
	QGraphicsScene (QObject *parent=0)
	Constructs a QGraphicsScene object. More...
	QGraphicsScene (const QRectF &sceneRect, QObject *parent=0)
	Constructs a QGraphicsScene object, using sceneRect for its scene rectangle. More...
	QGraphicsScene (qreal x, qreal y, qreal width, qreal height, QObject *parent=0)
	Constructs a QGraphicsScene object, using the rectangle specified by (x, y), and the given width and height for its scene rectangle. More...
void	removeItem (QGraphicsItem *item)
	Removes the item item and all its children from the scene. More...
void	render (QPainter *painter, const QRectF &target=QRectF(), const QRectF &source=QRectF(), Qt::AspectRatioMode aspectRatioMode=Qt::KeepAspectRatio)
	Renders the source rect from scene into target, using painter. More...
QRectF	sceneRect () const
QList< QGraphicsItem * >	selectedItems () const
	Returns a list of all currently selected items. More...
QPainterPath	selectionArea () const
	Returns the selection area that was previously set with setSelectionArea(), or an empty QPainterPath if no selection area has been set. More...
bool	sendEvent (QGraphicsItem *item, QEvent *event)
	Sends event event to item item through possible event filters. More...
void	setActivePanel (QGraphicsItem *item)
	Activates item, which must be an item in this scene. More...
void	setActiveWindow (QGraphicsWidget *widget)
	Activates widget, which must be a widget in this scene. More...
void	setBackgroundBrush (const QBrush &brush)
void	setBspTreeDepth (int depth)
void	setFocus (Qt::FocusReason focusReason=Qt::OtherFocusReason)
	Sets focus on the scene by sending a QFocusEvent to the scene, passing focusReason as the reason. More...
void	setFocusItem (QGraphicsItem *item, Qt::FocusReason focusReason=Qt::OtherFocusReason)
	Sets the scene's focus item to item, with the focus reason focusReason, after removing focus from any previous item that may have had focus. More...
void	setFont (const QFont &font)
void	setForegroundBrush (const QBrush &brush)
void	setItemIndexMethod (ItemIndexMethod method)
void	setPalette (const QPalette &palette)
void	setSceneRect (const QRectF &rect)
void	setSceneRect (qreal x, qreal y, qreal w, qreal h)
void	setSelectionArea (const QPainterPath &path)
	Sets the selection area to path. More...
void	setSelectionArea (const QPainterPath &path, const QTransform &deviceTransform)
	Sets the selection area to path. More...
void	setSelectionArea (const QPainterPath &path, Qt::ItemSelectionMode mode)
	Sets the selection area to path using mode to determine if items are included in the selection area. More...
void	setSelectionArea (const QPainterPath &path, Qt::ItemSelectionMode mode, const QTransform &deviceTransform)
	Sets the selection area to path using mode to determine if items are included in the selection area. More...
void	setSortCacheEnabled (bool enabled)
void	setStickyFocus (bool enabled)
void	setStyle (QStyle *style)
	Sets or replaces the style of the scene to style, and reparents the style to this scene. More...
bool	stickyFocus () const
QStyle *	style () const
	Returns the scene's style, or the same as QApplication::style() if the scene has not been explicitly assigned a style. More...
void	update (qreal x, qreal y, qreal w, qreal h)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
QList< QGraphicsView * >	views () const
	Returns a list of all the views that display this scene. More...
qreal	width () const
	This convenience function is equivalent to calling sceneRect(). More...
virtual	~QGraphicsScene ()
	Removes and deletes all items from the scene object before destroying the scene object. More...
Public Functions inherited from QObject
bool	blockSignals (bool b)
	If block is true, signals emitted by this object are blocked (i.e., emitting a signal will not invoke anything connected to it). More...
const QObjectList &	children () const
	Returns a list of child objects. More...
bool	connect (const QObject *sender, const char *signal, const char *member, Qt::ConnectionType type=Qt::AutoConnection) const
bool	disconnect (const char *signal=0, const QObject *receiver=0, const char *member=0)
bool	disconnect (const QObject *receiver, const char *member=0)
void	dumpObjectInfo ()
	Dumps information about signal connections, etc. More...
void	dumpObjectTree ()
	Dumps a tree of children to the debug output. More...
QList< QByteArray >	dynamicPropertyNames () const
	Returns the names of all properties that were dynamically added to the object using setProperty(). More...
template<typename T >
T	findChild (const QString &aName=QString()) const
	Returns the child of this object that can be cast into type T and that is called name, or 0 if there is no such object. More...
template<typename T >
QList< T >	findChildren (const QString &aName=QString()) const
	Returns all children of this object with the given name that can be cast to type T, or an empty list if there are no such objects. More...
template<typename T >
QList< T >	findChildren (const QRegExp &re) const
bool	inherits (const char *classname) const
	Returns true if this object is an instance of a class that inherits className or a QObject subclass that inherits className; otherwise returns false. More...
void	installEventFilter (QObject *)
	Installs an event filter filterObj on this object. More...
bool	isWidgetType () const
	Returns true if the object is a widget; otherwise returns false. More...
void	killTimer (int id)
	Kills the timer with timer identifier, id. More...
virtual const QMetaObject *	metaObject () const
	Returns a pointer to the meta-object of this object. More...
void	moveToThread (QThread *thread)
	Changes the thread affinity for this object and its children. More...
QString	objectName () const
QObject *	parent () const
	Returns a pointer to the parent object. More...
QVariant	property (const char *name) const
	Returns the value of the object's name property. More...
Q_INVOKABLE	QObject (QObject *parent=0)
	Constructs an object with parent object parent. More...
void	removeEventFilter (QObject *)
	Removes an event filter object obj from this object. More...
void	setObjectName (const QString &name)
void	setParent (QObject *)
	Makes the object a child of parent. More...
bool	setProperty (const char *name, const QVariant &value)
	Sets the value of the object's name property to value. More...
void	setUserData (uint id, QObjectUserData *data)
bool	signalsBlocked () const
	Returns true if signals are blocked; otherwise returns false. More...
int	startTimer (int interval)
	Starts a timer and returns a timer identifier, or returns zero if it could not start a timer. More...
QThread *	thread () const
	Returns the thread in which the object lives. More...
QObjectUserData *	userData (uint id) const
virtual	~QObject ()
	Destroys the object, deleting all its child objects. More...

Protected Slots
bool	focusNextPrevChild (bool next)
	Finds a new widget to give the keyboard focus to, as appropriate for Tab and Shift+Tab, and returns true if it can find a new widget, or false if it cannot. More...

Protected Functions
virtual void	contextMenuEvent (QGraphicsSceneContextMenuEvent *event)
	This event handler, for event contextMenuEvent, can be reimplemented in a subclass to receive context menu events. More...
virtual void	dragEnterEvent (QGraphicsSceneDragDropEvent *event)
	This event handler, for event event, can be reimplemented in a subclass to receive drag enter events for the scene. More...
virtual void	dragLeaveEvent (QGraphicsSceneDragDropEvent *event)
	This event handler, for event event, can be reimplemented in a subclass to receive drag leave events for the scene. More...
virtual void	dragMoveEvent (QGraphicsSceneDragDropEvent *event)
	This event handler, for event event, can be reimplemented in a subclass to receive drag move events for the scene. More...
virtual void	drawBackground (QPainter *painter, const QRectF &rect)
	Draws the background of the scene using painter, before any items and the foreground are drawn. More...
virtual void	drawForeground (QPainter *painter, const QRectF &rect)
	Draws the foreground of the scene using painter, after the background and all items have been drawn. More...
virtual void	drawItems (QPainter *painter, int numItems, QGraphicsItem *items[], const QStyleOptionGraphicsItem options[], QWidget *widget=0)
	Paints the given items using the provided painter, after the background has been drawn, and before the foreground has been drawn. More...
virtual void	dropEvent (QGraphicsSceneDragDropEvent *event)
	This event handler, for event event, can be reimplemented in a subclass to receive drop events for the scene. More...
bool	event (QEvent *event)
	Processes the event event, and dispatches it to the respective event handlers. More...
bool	eventFilter (QObject *watched, QEvent *event)
	QGraphicsScene filters QApplication's events to detect palette and font changes. More...
virtual void	focusInEvent (QFocusEvent *event)
	This event handler, for event focusEvent, can be reimplemented in a subclass to receive focus in events. More...
virtual void	focusOutEvent (QFocusEvent *event)
	This event handler, for event focusEvent, can be reimplemented in a subclass to receive focus out events. More...
virtual void	helpEvent (QGraphicsSceneHelpEvent *event)
	This event handler, for event helpEvent, can be reimplemented in a subclass to receive help events. More...
virtual void	inputMethodEvent (QInputMethodEvent *event)
	This event handler, for event event, can be reimplemented in a subclass to receive input method events for the scene. More...
virtual void	keyPressEvent (QKeyEvent *event)
	This event handler, for event keyEvent, can be reimplemented in a subclass to receive keypress events. More...
virtual void	keyReleaseEvent (QKeyEvent *event)
	This event handler, for event keyEvent, can be reimplemented in a subclass to receive key release events. More...
virtual void	mouseDoubleClickEvent (QGraphicsSceneMouseEvent *event)
	This event handler, for event mouseEvent, can be reimplemented in a subclass to receive mouse doubleclick events for the scene. More...
virtual void	mouseMoveEvent (QGraphicsSceneMouseEvent *event)
	This event handler, for event mouseEvent, can be reimplemented in a subclass to receive mouse move events for the scene. More...
virtual void	mousePressEvent (QGraphicsSceneMouseEvent *event)
	This event handler, for event mouseEvent, can be reimplemented in a subclass to receive mouse press events for the scene. More...
virtual void	mouseReleaseEvent (QGraphicsSceneMouseEvent *event)
	This event handler, for event mouseEvent, can be reimplemented in a subclass to receive mouse release events for the scene. More...
virtual void	wheelEvent (QGraphicsSceneWheelEvent *event)
	This event handler, for event wheelEvent, can be reimplemented in a subclass to receive mouse wheel events for the scene. More...
Protected Functions inherited from QObject
virtual void	childEvent (QChildEvent *)
	This event handler can be reimplemented in a subclass to receive child events. More...
virtual void	connectNotify (const char *signal)
	This virtual function is called when something has been connected to signal in this object. More...
virtual void	customEvent (QEvent *)
	This event handler can be reimplemented in a subclass to receive custom events. More...
virtual void	disconnectNotify (const char *signal)
	This virtual function is called when something has been disconnected from signal in this object. More...
	QObject (QObjectPrivate &dd, QObject *parent=0)
int	receivers (const char *signal) const
	Returns the number of receivers connected to the signal. More...
QObject *	sender () const
	Returns a pointer to the object that sent the signal, if called in a slot activated by a signal; otherwise it returns 0. More...
int	senderSignalIndex () const
virtual void	timerEvent (QTimerEvent *)
	This event handler can be reimplemented in a subclass to receive timer events for the object. More...

Properties
QBrush	backgroundBrush
	the background brush of the scene. More...
int	bspTreeDepth
	the depth of QGraphicsScene's BSP index tree More...
QFont	font
	the scene's default font More...
QBrush	foregroundBrush
	the foreground brush of the scene. More...
ItemIndexMethod	itemIndexMethod
	the item indexing method. More...
QPalette	palette
	the scene's default palette More...
QRectF	sceneRect
	the scene rectangle; the bounding rectangle of the scene More...
bool	sortCacheEnabled
	whether sort caching is enabled More...
bool	stickyFocus
	whether clicking into the scene background will clear focus More...

Friends
class	QGesture
class	QGraphicsEffect
class	QGraphicsItem
class	QGraphicsItemEffectSourcePrivate
class	QGraphicsItemPrivate
class	QGraphicsObject
class	QGraphicsSceneBspTreeIndex
class	QGraphicsSceneBspTreeIndexPrivate
class	QGraphicsSceneIndex
class	QGraphicsSceneIndexPrivate
class	QGraphicsView
class	QGraphicsViewPrivate
class	QGraphicsWidget
class	QGraphicsWidgetPrivate

Additional Inherited Members
Static Public Functions inherited from QObject
static bool	connect (const QObject *sender, const char *signal, const QObject *receiver, const char *member, Qt::ConnectionType=Qt::AutoConnection)
	Creates a connection of the given type from the signal in the sender object to the method in the receiver object. More...
static bool	connect (const QObject *sender, const QMetaMethod &signal, const QObject *receiver, const QMetaMethod &method, Qt::ConnectionType type=Qt::AutoConnection)
static bool	disconnect (const QObject *sender, const char *signal, const QObject *receiver, const char *member)
	Disconnects signal in object sender from method in object receiver. More...
static bool	disconnect (const QObject *sender, const QMetaMethod &signal, const QObject *receiver, const QMetaMethod &member)
static uint	registerUserData ()
static QString	tr (const char *sourceText, const char *comment=0, int n=-1)
static QString	trUtf8 (const char *sourceText, const char *comment=0, int n=-1)
Static Public Variables inherited from QObject
static const QMetaObject	staticMetaObject
	This variable stores the meta-object for the class. More...
Protected Variables inherited from QObject
QScopedPointer< QObjectData >	d_ptr
Static Protected Variables inherited from QObject
static const QMetaObject	staticQtMetaObject
Related Functions inherited from QObject
T	qFindChildqFindChildren (const QObject *obj, const QString &name)()
QList< T >	qFindChildrenqFindChildren (const QObject *obj, const QString &name)()
QList< T >	qFindChildrenqFindChildren (const QObject *obj, const QRegExp &regExp)()
T *	qobject_cast (QObject *object)
	QObjectList
void *	qt_find_obj_child (QObject *parent, const char *type, const QString &name)
	Returns a pointer to the object named name that inherits type and with a given parent. More...

Detailed Description

The QGraphicsScene class provides a surface for managing a large number of 2D graphical items.

Since

4.2

The class serves as a container for QGraphicsItems. It is used together with QGraphicsView for visualizing graphical items, such as lines, rectangles, text, or even custom items, on a 2D surface. QGraphicsScene is part of the Graphics View Framework.

QGraphicsScene also provides functionality that lets you efficiently determine both the location of items, and for determining what items are visible within an arbitrary area on the scene. With the QGraphicsView widget, you can either visualize the whole scene, or zoom in and view only parts of the scene.

Example:

QGraphicsScene scene;
scene.addText("Hello, world!");

QGraphicsView view(&scene);
view.show();

Note that QGraphicsScene has no visual appearance of its own; it only manages the items. You need to create a QGraphicsView widget to visualize the scene.

To add items to a scene, you start off by constructing a QGraphicsScene object. Then, you have two options: either add your existing QGraphicsItem objects by calling addItem(), or you can call one of the convenience functions addEllipse(), addLine(), addPath(), addPixmap(), addPolygon(), addRect(), or addText(), which all return a pointer to the newly added item. The dimensions of the items added with these functions are relative to the item's coordinate system, and the items position is initialized to (0, 0) in the scene.

You can then visualize the scene using QGraphicsView. When the scene changes, (e.g., when an item moves or is transformed) QGraphicsScene emits the changed() signal. To remove an item, call removeItem().

QGraphicsScene uses an indexing algorithm to manage the location of items efficiently. By default, a BSP (Binary Space Partitioning) tree is used; an algorithm suitable for large scenes where most items remain static (i.e., do not move around). You can choose to disable this index by calling setItemIndexMethod(). For more information about the available indexing algorithms, see the itemIndexMethod property.

The scene's bounding rect is set by calling setSceneRect(). Items can be placed at any position on the scene, and the size of the scene is by default unlimited. The scene rect is used only for internal bookkeeping, maintaining the scene's item index. If the scene rect is unset, QGraphicsScene will use the bounding area of all items, as returned by itemsBoundingRect(), as the scene rect. However, itemsBoundingRect() is a relatively time consuming function, as it operates by collecting positional information for every item on the scene. Because of this, you should always set the scene rect when operating on large scenes.

One of QGraphicsScene's greatest strengths is its ability to efficiently determine the location of items. Even with millions of items on the scene, the items() functions can determine the location of an item within few milliseconds. There are several overloads to items(): one that finds items at a certain position, one that finds items inside or intersecting with a polygon or a rectangle, and more. The list of returned items is sorted by stacking order, with the topmost item being the first item in the list. For convenience, there is also an itemAt() function that returns the topmost item at a given position.

QGraphicsScene maintains selection information for the scene. To select items, call setSelectionArea(), and to clear the current selection, call clearSelection(). Call selectedItems() to get the list of all selected items.

Event Handling and Propagation

Another responsibility that QGraphicsScene has, is to propagate events from QGraphicsView. To send an event to a scene, you construct an event that inherits QEvent, and then send it using, for example, QApplication::sendEvent(). event() is responsible for dispatching the event to the individual items. Some common events are handled by convenience event handlers. For example, key press events are handled by keyPressEvent(), and mouse press events are handled by mousePressEvent().

Key events are delivered to the {focus item}. To set the focus item, you can either call setFocusItem(), passing an item that accepts focus, or the item itself can call QGraphicsItem::setFocus(). Call focusItem() to get the current focus item. For compatibility with widgets, the scene also maintains its own focus information. By default, the scene does not have focus, and all key events are discarded. If setFocus() is called, or if an item on the scene gains focus, the scene automatically gains focus. If the scene has focus, hasFocus() will return true, and key events will be forwarded to the focus item, if any. If the scene loses focus, (i.e., someone calls clearFocus()) while an item has focus, the scene will maintain its item focus information, and once the scene regains focus, it will make sure the last focus item regains focus.

For mouse-over effects, QGraphicsScene dispatches {hover events}. If an item accepts hover events (see QGraphicsItem::acceptHoverEvents()), it will receive a QEvent::GraphicsSceneHoverEnter event when the mouse enters its area. As the mouse continues moving inside the item's area, QGraphicsScene will send it QEvent::GraphicsSceneHoverMove events. When the mouse leaves the item's area, the item will receive a QEvent::GraphicsSceneHoverLeave event.

All mouse events are delivered to the current {mouse grabber} item. An item becomes the scene's mouse grabber if it accepts mouse events (see QGraphicsItem::acceptedMouseButtons()) and it receives a mouse press. It stays the mouse grabber until it receives a mouse release when no other mouse buttons are pressed. You can call mouseGrabberItem() to determine what item is currently grabbing the mouse.

See also

QGraphicsItem, QGraphicsView

Definition at line 101 of file qgraphicsscene.h.

Enumerations

ItemIndexMethod

enum QGraphicsScene::ItemIndexMethod

This enum describes the indexing algorithms QGraphicsScene provides for managing positional information about items on the scene.

• BspTreeIndex A Binary Space Partitioning tree is applied. All QGraphicsScene's item location algorithms are of an order close to logarithmic complexity, by making use of binary search. Adding, moving and removing items is logarithmic. This approach is best for static scenes (i.e., scenes where most items do not move).

• NoIndex No index is applied. Item location is of linear complexity, as all items on the scene are searched. Adding, moving and removing items, however, is done in constant time. This approach is ideal for dynamic scenes, where many items are added, moved or removed continuously.

See also

setItemIndexMethod(), bspTreeDepth

Enumerator
BspTreeIndex
NoIndex

Definition at line 115 of file qgraphicsscene.h.

                         {
        BspTreeIndex,
        NoIndex = -1
    };

SceneLayer

enum QGraphicsScene::SceneLayer

This enum describes the rendering layers in a QGraphicsScene.

Since

4.3

When QGraphicsScene draws the scene contents, it renders each of these layers separately, in order.

Each layer represents a flag that can be OR'ed together when calling functions such as invalidate() or QGraphicsView::invalidateScene().

• ItemLayer The item layer. QGraphicsScene renders all items are in this layer by calling the virtual function drawItems(). The item layer is drawn after the background layer, but before the foreground layer.

• BackgroundLayer The background layer. QGraphicsScene renders the scene's background in this layer by calling the virtual function drawBackground(). The background layer is drawn first of all layers.

• ForegroundLayer The foreground layer. QGraphicsScene renders the scene's foreground in this layer by calling the virtual function drawForeground(). The foreground layer is drawn last of all layers.

• AllLayers All layers; this value represents a combination of all three layers.

See also

invalidate(), QGraphicsView::invalidateScene()

Enumerator
ItemLayer
BackgroundLayer
ForegroundLayer
AllLayers

Definition at line 120 of file qgraphicsscene.h.

                    {
        ItemLayer = 0x1,
        BackgroundLayer = 0x2,
        ForegroundLayer = 0x4,
        AllLayers = 0xffff
    };

Constructors and Destructors

QGraphicsScene() [1/3]

QGraphicsScene::QGraphicsScene

(

QObject *

parent = 0

)

Constructs a QGraphicsScene object.

The parent parameter is passed to QObject's constructor.

Definition at line 1638 of file qgraphicsscene.cpp.

    : QObject(*new QGraphicsScenePrivate, parent)
{
    d_func()->init();
}

QGraphicsScene() [2/3]

QGraphicsScene::QGraphicsScene	(	const QRectF &	sceneRect,
		QObject *	parent = 0
	)

Constructs a QGraphicsScene object, using sceneRect for its scene rectangle.

The parent parameter is passed to QObject's constructor.

See also

sceneRect

Definition at line 1651 of file qgraphicsscene.cpp.

    : QObject(*new QGraphicsScenePrivate, parent)
{
    d_func()->init();
    setSceneRect(sceneRect);
}

QGraphicsScene() [3/3]

QGraphicsScene::QGraphicsScene	(	qreal	x,
		qreal	y,
		qreal	width,
		qreal	height,
		QObject *	parent = 0
	)

Constructs a QGraphicsScene object, using the rectangle specified by (x, y), and the given width and height for its scene rectangle.

The parent parameter is passed to QObject's constructor.

See also

sceneRect

Definition at line 1666 of file qgraphicsscene.cpp.

    : QObject(*new QGraphicsScenePrivate, parent)
{
    d_func()->init();
    setSceneRect(x, y, width, height);
}

~QGraphicsScene()

QGraphicsScene::~QGraphicsScene ( )

virtual

Removes and deletes all items from the scene object before destroying the scene object.

The scene object is removed from the application's global scene list, and it is removed from all associated views.

Definition at line 1679 of file qgraphicsscene.cpp.

{
    Q_D(QGraphicsScene);

    // Remove this scene from qApp's global scene list.
    if (!QApplicationPrivate::is_app_closing)
        qApp->d_func()->scene_list.removeAll(this);

    clear();

    // Remove this scene from all associated views.
    for (int j = 0; j < d->views.size(); ++j)
        d->views.at(j)->setScene(0);
}

Functions

activePanel()

QGraphicsItem * QGraphicsScene::activePanel

(

)

const

Returns the current active panel, or 0 if no panel is currently active.

Since

4.6

See also

QGraphicsScene::setActivePanel()

Definition at line 5818 of file qgraphicsscene.cpp.

Referenced by QGraphicsItem::hasFocus(), and QGraphicsItem::isActive().

{
    Q_D(const QGraphicsScene);
    return d->activePanel;
}

activeWindow()

QGraphicsWidget * QGraphicsScene::activeWindow

(

)

const

Returns the current active window, or 0 if no window is currently active.

Since

4.4

See also

QGraphicsScene::setActiveWindow()

Definition at line 5855 of file qgraphicsscene.cpp.

Referenced by QShortcutMap::correctGraphicsWidgetContext().

{
    Q_D(const QGraphicsScene);
    if (d->activePanel && d->activePanel->isWindow())
        return static_cast<QGraphicsWidget *>(d->activePanel);
    return 0;
}

addEllipse() [1/2]

QGraphicsEllipseItem * QGraphicsScene::addEllipse	(	const QRectF &	rect,
		const QPen &	pen = QPen(),
		const QBrush &	brush = QBrush()
	)

Creates and adds an ellipse item to the scene, and returns the item pointer.

The geometry of the ellipse is defined by rect, and its pen and brush are initialized to pen and brush.

Note that the item's geometry is provided in item coordinates, and its position is initialized to (0, 0).

If the item is visible (i.e., QGraphicsItem::isVisible() returns true), QGraphicsScene will emit changed() once control goes back to the event loop.

See also

addLine(), addPath(), addPixmap(), addRect(), addText(), addItem(), addWidget()

Definition at line 2833 of file qgraphicsscene.cpp.

{
    QGraphicsEllipseItem *item = new QGraphicsEllipseItem(rect);
    item->setPen(pen);
    item->setBrush(brush);
    addItem(item);
    return item;
}

addEllipse() [2/2]

QGraphicsEllipseItem * QGraphicsScene::addEllipse ( qreal  x, qreal  y, qreal  w, qreal  h, const QPen &  pen = QPen(), const QBrush &  brush = QBrush()  )

inline

Since

4.3

This convenience function is equivalent to calling addEllipse(QRectF(x, y, w, h), pen, brush).

Definition at line 203 of file qgraphicsscene.h.

    { return addEllipse(QRectF(x, y, w, h), pen, brush); }

addItem()

void QGraphicsScene::addItem

(

QGraphicsItem *

item

)

Adds or moves the item and all its childen to this scene.

This scene takes ownership of the item.

If the item is visible (i.e., QGraphicsItem::isVisible() returns true), QGraphicsScene will emit changed() once control goes back to the event loop.

If the item is already in a different scene, it will first be removed from its old scene, and then added to this scene as a top-level.

QGraphicsScene will send ItemSceneChange notifications to item while it is added to the scene. If item does not currently belong to a scene, only one notification is sent. If it does belong to scene already (i.e., it is moved to this scene), QGraphicsScene will send an addition notification as the item is removed from its previous scene.

If the item is a panel, the scene is active, and there is no active panel in the scene, then the item will be activated.

See also

removeItem(), addEllipse(), addLine(), addPath(), addPixmap(), addRect(), addText(), addWidget(), {QGraphicsItem::Sorting}{Sorting}

Definition at line 2650 of file qgraphicsscene.cpp.

Referenced by addEllipse(), addItem(), addLine(), addPath(), addPixmap(), addPolygon(), addRect(), addSimpleText(), addText(), QGraphicsItem::addToIndex(), addWidget(), createItemGroup(), QmlJSDebugger::LiveLayerItem::LiveLayerItem(), QGraphicsItem::QGraphicsItem(), removeItem(), and QDeclarativeView::setRootObject().

{
    Q_D(QGraphicsScene);
    if (!item) {
        qWarning("QGraphicsScene::addItem: cannot add null item");
        return;
    }
    if (item->d_ptr->scene == this) {
        qWarning("QGraphicsScene::addItem: item has already been added to this scene");
        return;
    }
    // Remove this item from its existing scene
    if (QGraphicsScene *oldScene = item->d_ptr->scene)
        oldScene->removeItem(item);

    // Notify the item that its scene is changing, and allow the item to
    // react.
    const QVariant newSceneVariant(item->itemChange(QGraphicsItem::ItemSceneChange,
                                                    QVariant::fromValue<QGraphicsScene *>(this)));
    QGraphicsScene *targetScene = qvariant_cast<QGraphicsScene *>(newSceneVariant);
    if (targetScene != this) {
        if (targetScene && item->d_ptr->scene != targetScene)
            targetScene->addItem(item);
        return;
    }

    // QDeclarativeItems do not rely on initial itemChanged message, as the componentComplete
    // function allows far more opportunity for delayed-construction optimization.
    if (!item->d_ptr->isDeclarativeItem) {
        if (d->unpolishedItems.isEmpty()) {
            QMetaMethod method = metaObject()->method(d->polishItemsIndex);
            method.invoke(this, Qt::QueuedConnection);
        }
        d->unpolishedItems.append(item);
        item->d_ptr->pendingPolish = true;
    }

    // Detach this item from its parent if the parent's scene is different
    // from this scene.
    if (QGraphicsItem *itemParent = item->d_ptr->parent) {
        if (itemParent->d_ptr->scene != this)
            item->setParentItem(0);
    }

    // Add the item to this scene
    item->d_func()->scene = targetScene;

    // Add the item in the index
    d->index->addItem(item);

    // Add to list of toplevels if this item is a toplevel.
    if (!item->d_ptr->parent)
        d->registerTopLevelItem(item);

    // Add to list of items that require an update. We cannot assume that the
    // item is fully constructed, so calling item->update() can lead to a pure
    // virtual function call to boundingRect().
    d->markDirty(item);
    d->dirtyGrowingItemsBoundingRect = true;

    // Disable selectionChanged() for individual items
    ++d->selectionChanging;
    int oldSelectedItemSize = d->selectedItems.size();

    // Enable mouse tracking if the item accepts hover events or has a cursor set.
    if (d->allItemsIgnoreHoverEvents && d->itemAcceptsHoverEvents_helper(item)) {
        d->allItemsIgnoreHoverEvents = false;
        d->enableMouseTrackingOnViews();
    }
#ifndef QT_NO_CURSOR
    if (d->allItemsUseDefaultCursor && item->d_ptr->hasCursor) {
        d->allItemsUseDefaultCursor = false;
        if (d->allItemsIgnoreHoverEvents) // already enabled otherwise
            d->enableMouseTrackingOnViews();
    }
#endif //QT_NO_CURSOR

    // Enable touch events if the item accepts touch events.
    if (d->allItemsIgnoreTouchEvents && item->d_ptr->acceptTouchEvents) {
        d->allItemsIgnoreTouchEvents = false;
        d->enableTouchEventsOnViews();
    }

#ifndef QT_NO_GESTURES
    foreach (Qt::GestureType gesture, item->d_ptr->gestureContext.keys())
        d->grabGesture(item, gesture);
#endif

    // Update selection lists
    if (item->isSelected())
        d->selectedItems << item;
    if (item->isWidget() && item->isVisible() && static_cast<QGraphicsWidget *>(item)->windowType() == Qt::Popup)
        d->addPopup(static_cast<QGraphicsWidget *>(item));
    if (item->isPanel() && item->isVisible() && item->panelModality() != QGraphicsItem::NonModal)
        d->enterModal(item);

    // Update creation order focus chain. Make sure to leave the widget's
    // internal tab order intact.
    if (item->isWidget()) {
        QGraphicsWidget *widget = static_cast<QGraphicsWidget *>(item);
        if (!d->tabFocusFirst) {
            // No first tab focus widget - make this the first tab focus
            // widget.
            d->tabFocusFirst = widget;
        } else if (!widget->parentWidget()) {
            // Adding a widget that is not part of a tab focus chain.
            QGraphicsWidget *last = d->tabFocusFirst->d_func()->focusPrev;
            QGraphicsWidget *lastNew = widget->d_func()->focusPrev;
            last->d_func()->focusNext = widget;
            widget->d_func()->focusPrev = last;
            d->tabFocusFirst->d_func()->focusPrev = lastNew;
            lastNew->d_func()->focusNext = d->tabFocusFirst;
        }
    }

    // Add all children recursively
    item->d_ptr->ensureSortedChildren();
    for (int i = 0; i < item->d_ptr->children.size(); ++i)
        addItem(item->d_ptr->children.at(i));

    // Resolve font and palette.
    item->d_ptr->resolveFont(d->font.resolve());
    item->d_ptr->resolvePalette(d->palette.resolve());


    // Reenable selectionChanged() for individual items
    --d->selectionChanging;
    if (!d->selectionChanging && d->selectedItems.size() != oldSelectedItemSize)
        emit selectionChanged();

    // Deliver post-change notification
    item->itemChange(QGraphicsItem::ItemSceneHasChanged, newSceneVariant);

    // Update explicit activation
    bool autoActivate = true;
    if (!d->childExplicitActivation && item->d_ptr->explicitActivate)
        d->childExplicitActivation = item->d_ptr->wantsActive ? 1 : 2;
    if (d->childExplicitActivation && item->isPanel()) {
        if (d->childExplicitActivation == 1)
            setActivePanel(item);
        else
            autoActivate = false;
        d->childExplicitActivation = 0;
    } else if (!item->d_ptr->parent) {
        d->childExplicitActivation = 0;
    }

    // Auto-activate this item's panel if nothing else has been activated
    if (autoActivate) {
        if (!d->lastActivePanel && !d->activePanel && item->isPanel()) {
            if (isActive())
                setActivePanel(item);
            else
                d->lastActivePanel = item;
        }
    }

    if (item->d_ptr->flags & QGraphicsItem::ItemSendsScenePositionChanges)
        d->registerScenePosItem(item);

    // Ensure that newly added items that have subfocus set, gain
    // focus automatically if there isn't a focus item already.
    if (!d->focusItem && item != d->lastFocusItem && item->focusItem() == item)
        item->focusItem()->setFocus();

    d->updateInputMethodSensitivityInViews();
}

addLine() [1/2]

QGraphicsLineItem * QGraphicsScene::addLine	(	const QLineF &	line,
		const QPen &	pen = QPen()
	)

Creates and adds a line item to the scene, and returns the item pointer.

The geometry of the line is defined by line, and its pen is initialized to pen.

Note that the item's geometry is provided in item coordinates, and its position is initialized to (0, 0).

If the item is visible (i.e., QGraphicsItem::isVisible() returns true), QGraphicsScene will emit changed() once control goes back to the event loop.

See also

addEllipse(), addPath(), addPixmap(), addRect(), addText(), addItem(), addWidget()

Definition at line 2865 of file qgraphicsscene.cpp.

{
    QGraphicsLineItem *item = new QGraphicsLineItem(line);
    item->setPen(pen);
    addItem(item);
    return item;
}

addLine() [2/2]

QGraphicsLineItem * QGraphicsScene::addLine ( qreal  x1, qreal  y1, qreal  x2, qreal  y2, const QPen &  pen = QPen()  )

inline

Since

4.3

This convenience function is equivalent to calling addLine(QLineF(x1, y1, x2, y2), pen).

Definition at line 205 of file qgraphicsscene.h.

    { return addLine(QLineF(x1, y1, x2, y2), pen); }

addPath()

QGraphicsPathItem * QGraphicsScene::addPath	(	const QPainterPath &	path,
		const QPen &	pen = QPen(),
		const QBrush &	brush = QBrush()
	)

Creates and adds a path item to the scene, and returns the item pointer.

The geometry of the path is defined by path, and its pen and brush are initialized to pen and brush.

Note that the item's geometry is provided in item coordinates, and its position is initialized to (0, 0).

If the item is visible (i.e., QGraphicsItem::isVisible() returns true), QGraphicsScene will emit changed() once control goes back to the event loop.

See also

addEllipse(), addLine(), addPixmap(), addRect(), addText(), addItem(), addWidget()

Definition at line 2896 of file qgraphicsscene.cpp.

{
    QGraphicsPathItem *item = new QGraphicsPathItem(path);
    item->setPen(pen);
    item->setBrush(brush);
    addItem(item);
    return item;
}

addPixmap()

QGraphicsPixmapItem * QGraphicsScene::addPixmap

(

const QPixmap &

pixmap

)

Creates and adds a pixmap item to the scene, and returns the item pointer.

The pixmap is defined by pixmap.

Note that the item's geometry is provided in item coordinates, and its position is initialized to (0, 0).

If the item is visible (i.e., QGraphicsItem::isVisible() returns true), QGraphicsScene will emit changed() once control goes back to the event loop.

See also

addEllipse(), addLine(), addPath(), addRect(), addText(), addItem(), addWidget()

Definition at line 2919 of file qgraphicsscene.cpp.

{
    QGraphicsPixmapItem *item = new QGraphicsPixmapItem(pixmap);
    addItem(item);
    return item;
}

addPolygon()

QGraphicsPolygonItem * QGraphicsScene::addPolygon	(	const QPolygonF &	polygon,
		const QPen &	pen = QPen(),
		const QBrush &	brush = QBrush()
	)

Creates and adds a polygon item to the scene, and returns the item pointer.

The polygon is defined by polygon, and its pen and brush are initialized to pen and brush.

Note that the item's geometry is provided in item coordinates, and its position is initialized to (0, 0).

If the item is visible (i.e., QGraphicsItem::isVisible() returns true), QGraphicsScene will emit changed() once control goes back to the event loop.

See also

addEllipse(), addLine(), addPath(), addRect(), addText(), addItem(), addWidget()

Definition at line 2941 of file qgraphicsscene.cpp.

{
    QGraphicsPolygonItem *item = new QGraphicsPolygonItem(polygon);
    item->setPen(pen);
    item->setBrush(brush);
    addItem(item);
    return item;
}

addRect() [1/2]

QGraphicsRectItem * QGraphicsScene::addRect	(	const QRectF &	rect,
		const QPen &	pen = QPen(),
		const QBrush &	brush = QBrush()
	)

Creates and adds a rectangle item to the scene, and returns the item pointer.

The geometry of the rectangle is defined by rect, and its pen and brush are initialized to pen and brush.

Note that the item's geometry is provided in item coordinates, and its position is initialized to (0, 0). For example, if a QRect(50, 50, 100, 100) is added, its top-left corner will be at (50, 50) relative to the origin in the items coordinate system.

If the item is visible (i.e., QGraphicsItem::isVisible() returns true), QGraphicsScene will emit changed() once control goes back to the event loop.

See also

addEllipse(), addLine(), addPixmap(), addPixmap(), addText(), addItem(), addWidget()

Definition at line 2968 of file qgraphicsscene.cpp.

{
    QGraphicsRectItem *item = new QGraphicsRectItem(rect);
    item->setPen(pen);
    item->setBrush(brush);
    addItem(item);
    return item;
}

addRect() [2/2]

QGraphicsRectItem * QGraphicsScene::addRect ( qreal  x, qreal  y, qreal  w, qreal  h, const QPen &  pen = QPen(), const QBrush &  brush = QBrush()  )

inline

Since

4.3

This convenience function is equivalent to calling addRect(QRectF(x, y, w, h), pen, brush).

Definition at line 207 of file qgraphicsscene.h.

    { return addRect(QRectF(x, y, w, h), pen, brush); }

addSimpleText()

QGraphicsSimpleTextItem * QGraphicsScene::addSimpleText	(	const QString &	text,
		const QFont &	font = QFont()
	)

Creates and adds a QGraphicsSimpleTextItem to the scene, and returns the item pointer.

The text string is initialized to text, and its font is initialized to font.

The item's position is initialized to (0, 0).

If the item is visible (i.e., QGraphicsItem::isVisible() returns true), QGraphicsScene will emit changed() once control goes back to the event loop.

See also

addEllipse(), addLine(), addPixmap(), addPixmap(), addRect(), addItem(), addWidget()

Definition at line 3021 of file qgraphicsscene.cpp.

{
    QGraphicsSimpleTextItem *item = new QGraphicsSimpleTextItem(text);
    item->setFont(font);
    addItem(item);
    return item;
}

addText()

QGraphicsTextItem * QGraphicsScene::addText	(	const QString &	text,
		const QFont &	font = QFont()
	)

Creates and adds a text item to the scene, and returns the item pointer.

The text string is initialized to text, and its font is initialized to font.

The item's position is initialized to (0, 0).

If the item is visible (i.e., QGraphicsItem::isVisible() returns true), QGraphicsScene will emit changed() once control goes back to the event loop.

See also

addEllipse(), addLine(), addPixmap(), addPixmap(), addRect(), addItem(), addWidget()

Definition at line 2999 of file qgraphicsscene.cpp.

{
    QGraphicsTextItem *item = new QGraphicsTextItem(text);
    item->setFont(font);
    addItem(item);
    return item;
}

addWidget()

QGraphicsProxyWidget * QGraphicsScene::addWidget	(	QWidget *	widget,
		Qt::WindowFlags	wFlags = 0
	)

Creates a new QGraphicsProxyWidget for widget, adds it to the scene, and returns a pointer to the proxy.

wFlags set the default window flags for the embedding proxy widget.

The item's position is initialized to (0, 0).

If the item is visible (i.e., QGraphicsItem::isVisible() returns true), QGraphicsScene will emit changed() once control goes back to the event loop.

Note that widgets with the Qt::WA_PaintOnScreen widget attribute set and widgets that wrap an external application or controller are not supported. Examples are QGLWidget and QAxWidget.

See also

addEllipse(), addLine(), addPixmap(), addPixmap(), addRect(), addText(), addSimpleText(), addItem()

Definition at line 3047 of file qgraphicsscene.cpp.

{
    QGraphicsProxyWidget *proxy = new QGraphicsProxyWidget(0, wFlags);
    proxy->setWidget(widget);
    addItem(proxy);
    return proxy;
}

advance

void QGraphicsScene::advance ( )

slot

This slot advances the scene by one step, by calling QGraphicsItem::advance() for all items on the scene.

This is done in two phases: in the first phase, all items are notified that the scene is about to change, and in the second phase all items are notified that they can move. In the first phase, QGraphicsItem::advance() is called passing a value of 0 as an argument, and 1 is passed in the second phase.

See also

QGraphicsItem::advance(), QGraphicsItemAnimation, QTimeLine

Definition at line 3461 of file qgraphicsscene.cpp.

{
    for (int i = 0; i < 2; ++i) {
        foreach (QGraphicsItem *item, items())
            item->advance(i);
    }
}

backgroundBrush()

QBrush QGraphicsScene::backgroundBrush

(

)

const

Referenced by drawBackground(), and mouseGrabberItem().

bspTreeDepth()

int QGraphicsScene::bspTreeDepth

(

)

const

Referenced by setItemIndexMethod().

changed

QGraphicsScene::changed ( const QList< QRectF > &  region )

signal

This signal is emitted by QGraphicsScene when control reaches the event loop, if the scene content changes.

The region parameter contains a list of scene rectangles that indicate the area that has been changed.

See also

QGraphicsView::updateScene()

Referenced by clearSelection(), and setSelectionArea().

clear

void QGraphicsScene::clear ( )

slot

Removes and deletes all items from the scene, but otherwise leaves the state of the scene unchanged.

Since

4.4

See also

addItem()

Definition at line 2538 of file qgraphicsscene.cpp.

Referenced by QGraphicsItem::mouseReleaseEvent(), and ~QGraphicsScene().

{
    Q_D(QGraphicsScene);
    // NB! We have to clear the index before deleting items; otherwise the
    // index might try to access dangling item pointers.
    d->index->clear();
    // NB! QGraphicsScenePrivate::unregisterTopLevelItem() removes items
    while (!d->topLevelItems.isEmpty())
        delete d->topLevelItems.first();
    Q_ASSERT(d->topLevelItems.isEmpty());
    d->lastItemCount = 0;
    d->allItemsIgnoreHoverEvents = true;
    d->allItemsUseDefaultCursor = true;
    d->allItemsIgnoreTouchEvents = true;
}

clearFocus()

void QGraphicsScene::clearFocus

(

)

Clears focus from the scene.

If any item has focus when this function is called, it will lose focus, and regain focus again once the scene regains focus.

A scene that does not have focus ignores key events.

See also

hasFocus(), setFocus(), setFocusItem()

Definition at line 3178 of file qgraphicsscene.cpp.

{
    Q_D(QGraphicsScene);
    if (d->hasFocus) {
        d->hasFocus = false;
        d->passiveFocusItem = d->focusItem;
        setFocusItem(0, Qt::OtherFocusReason);
    }
}

clearSelection

void QGraphicsScene::clearSelection ( )

slot

Clears the current selection.

See also

setSelectionArea(), selectedItems()

Definition at line 2508 of file qgraphicsscene.cpp.

Referenced by QGraphicsItem::mousePressEvent(), and QGraphicsItem::mouseReleaseEvent().

{
    Q_D(QGraphicsScene);

    // Disable emitting selectionChanged
    ++d->selectionChanging;
    bool changed = !d->selectedItems.isEmpty();

    foreach (QGraphicsItem *item, d->selectedItems)
        item->setSelected(false);
    d->selectedItems.clear();

    // Reenable emitting selectionChanged() for individual items.
    --d->selectionChanging;

    if (!d->selectionChanging && changed)
        emit selectionChanged();
}

collidingItems()

QList< QGraphicsItem * > QGraphicsScene::collidingItems	(	const QGraphicsItem *	item,
		Qt::ItemSelectionMode	mode = Qt::IntersectsItemShape
	)		const

Returns a list of all items that collide with item.

Collisions are determined by calling QGraphicsItem::collidesWithItem(); the collision detection is determined by mode. By default, all items whose shape intersects item or is contained inside item's shape are returned.

The items are returned in descending stacking order (i.e., the first item in the list is the uppermost item, and the last item is the lowermost item).

See also

items(), itemAt(), QGraphicsItem::collidesWithItem(), {QGraphicsItem::Sorting}{Sorting}

Definition at line 2255 of file qgraphicsscene.cpp.

Referenced by QGraphicsItem::collidingItems().

{
    Q_D(const QGraphicsScene);
    if (!item) {
        qWarning("QGraphicsScene::collidingItems: cannot find collisions for null item");
        return QList<QGraphicsItem *>();
    }

    // Does not support ItemIgnoresTransformations.
    QList<QGraphicsItem *> tmp;
    foreach (QGraphicsItem *itemInVicinity, d->index->estimateItems(item->sceneBoundingRect(), Qt::DescendingOrder)) {
        if (item != itemInVicinity && item->collidesWithItem(itemInVicinity, mode))
            tmp << itemInVicinity;
    }
    return tmp;
}

contextMenuEvent()

void QGraphicsScene::contextMenuEvent ( QGraphicsSceneContextMenuEvent *  contextMenuEvent )

protectedvirtual

This event handler, for event contextMenuEvent, can be reimplemented in a subclass to receive context menu events.

The default implementation forwards the event to the topmost item that accepts context menu events at the position of the event. If no items accept context menu events at this position, the event is ignored.

See also

QGraphicsItem::contextMenuEvent()

Definition at line 3722 of file qgraphicsscene.cpp.

Referenced by event().

{
    Q_D(QGraphicsScene);
    // Ignore by default.
    contextMenuEvent->ignore();

    // Send the event to all items at this position until one item accepts the
    // event.
    foreach (QGraphicsItem *item, d->itemsAtPosition(contextMenuEvent->screenPos(),
                                                     contextMenuEvent->scenePos(),
                                                     contextMenuEvent->widget())) {
        contextMenuEvent->setPos(item->d_ptr->genericMapFromScene(contextMenuEvent->scenePos(),
                                                                  contextMenuEvent->widget()));
        contextMenuEvent->accept();
        if (!d->sendEvent(item, contextMenuEvent))
            break;

        if (contextMenuEvent->isAccepted())
            break;
    }
}

createItemGroup()

QGraphicsItemGroup * QGraphicsScene::createItemGroup

(

const QList< QGraphicsItem *> &

items

)

Groups all items in items into a new QGraphicsItemGroup, and returns a pointer to the group.

The group is created with the common ancestor of items as its parent, and with position (0, 0). The items are all reparented to the group, and their positions and transformations are mapped to the group. If items is empty, this function will return an empty top-level QGraphicsItemGroup.

QGraphicsScene has ownership of the group item; you do not need to delete it. To dismantle (ungroup) a group, call destroyItemGroup().

See also

destroyItemGroup(), QGraphicsItemGroup::addToGroup()

Definition at line 2567 of file qgraphicsscene.cpp.

{
    // Build a list of the first item's ancestors
    QList<QGraphicsItem *> ancestors;
    int n = 0;
    if (!items.isEmpty()) {
        QGraphicsItem *parent = items.at(n++);
        while ((parent = parent->parentItem()))
            ancestors.append(parent);
    }

    // Find the common ancestor for all items
    QGraphicsItem *commonAncestor = 0;
    if (!ancestors.isEmpty()) {
        while (n < items.size()) {
            int commonIndex = -1;
            QGraphicsItem *parent = items.at(n++);
            do {
                int index = ancestors.indexOf(parent, qMax(0, commonIndex));
                if (index != -1) {
                    commonIndex = index;
                    break;
                }
            } while ((parent = parent->parentItem()));

            if (commonIndex == -1) {
                commonAncestor = 0;
                break;
            }

            commonAncestor = ancestors.at(commonIndex);
        }
    }

    // Create a new group at that level
    QGraphicsItemGroup *group = new QGraphicsItemGroup(commonAncestor);
    if (!commonAncestor)
        addItem(group);
    foreach (QGraphicsItem *item, items)
        group->addToGroup(item);
    return group;
}

destroyItemGroup()

void QGraphicsScene::destroyItemGroup

(

QGraphicsItemGroup *

group

)

Reparents all items in group to group's parent item, then removes group from the scene, and finally deletes it.

The items' positions and transformations are mapped from the group to the group's parent.

See also

createItemGroup(), QGraphicsItemGroup::removeFromGroup()

Definition at line 2617 of file qgraphicsscene.cpp.

{
    foreach (QGraphicsItem *item, group->children())
        group->removeFromGroup(item);
    removeItem(group);
    delete group;
}

dragEnterEvent()

void QGraphicsScene::dragEnterEvent ( QGraphicsSceneDragDropEvent *  event )

protectedvirtual

This event handler, for event event, can be reimplemented in a subclass to receive drag enter events for the scene.

The default implementation accepts the event and prepares the scene to accept drag move events.

See also

QGraphicsItem::dragEnterEvent(), dragMoveEvent(), dragLeaveEvent(), dropEvent()

Definition at line 3754 of file qgraphicsscene.cpp.

Referenced by event().

{
    Q_D(QGraphicsScene);
    d->dragDropItem = 0;
    d->lastDropAction = Qt::IgnoreAction;
    event->accept();
}

dragLeaveEvent()

void QGraphicsScene::dragLeaveEvent ( QGraphicsSceneDragDropEvent *  event )

protectedvirtual

This event handler, for event event, can be reimplemented in a subclass to receive drag leave events for the scene.

See also

QGraphicsItem::dragLeaveEvent(), dragEnterEvent(), dragMoveEvent(), dropEvent()

Definition at line 3852 of file qgraphicsscene.cpp.

Referenced by event().

{
    Q_D(QGraphicsScene);
    if (d->dragDropItem) {
        // Leave the last drag drop item
        d->sendDragDropEvent(d->dragDropItem, event);
        d->dragDropItem = 0;
    }
}

dragMoveEvent()

void QGraphicsScene::dragMoveEvent ( QGraphicsSceneDragDropEvent *  event )

protectedvirtual

This event handler, for event event, can be reimplemented in a subclass to receive drag move events for the scene.

See also

QGraphicsItem::dragMoveEvent(), dragEnterEvent(), dragLeaveEvent(), dropEvent()

Definition at line 3769 of file qgraphicsscene.cpp.

Referenced by event().

{
    Q_D(QGraphicsScene);
    event->ignore();

    if (!d->mouseGrabberItems.isEmpty()) {
        // Mouse grabbers that start drag events lose the mouse grab.
        d->clearMouseGrabber();
        d->mouseGrabberButtonDownPos.clear();
        d->mouseGrabberButtonDownScenePos.clear();
        d->mouseGrabberButtonDownScreenPos.clear();
    }

    bool eventDelivered = false;

    // Find the topmost enabled items under the cursor. They are all
    // candidates for accepting drag & drop events.
    foreach (QGraphicsItem *item, d->itemsAtPosition(event->screenPos(),
                                                     event->scenePos(),
                                                     event->widget())) {
        if (!item->isEnabled() || !item->acceptDrops())
            continue;

        if (item != d->dragDropItem) {
            // Enter the new drag drop item. If it accepts the event, we send
            // the leave to the parent item.
            QGraphicsSceneDragDropEvent dragEnter(QEvent::GraphicsSceneDragEnter);
            d->cloneDragDropEvent(&dragEnter, event);
            dragEnter.setDropAction(event->proposedAction());
            d->sendDragDropEvent(item, &dragEnter);
            event->setAccepted(dragEnter.isAccepted());
            event->setDropAction(dragEnter.dropAction());
            if (!event->isAccepted()) {
                // Propagate to the item under
                continue;
            }

            d->lastDropAction = event->dropAction();

            if (d->dragDropItem) {
                // Leave the last drag drop item. A perfect implementation
                // would set the position of this event to the point where
                // this event and the last event intersect with the item's
                // shape, but that's not easy to do. :-)
                QGraphicsSceneDragDropEvent dragLeave(QEvent::GraphicsSceneDragLeave);
                d->cloneDragDropEvent(&dragLeave, event);
                d->sendDragDropEvent(d->dragDropItem, &dragLeave);
            }

            // We've got a new drag & drop item
            d->dragDropItem = item;
        }

        // Send the move event.
        event->setDropAction(d->lastDropAction);
        event->accept();
        d->sendDragDropEvent(item, event);
        if (event->isAccepted())
            d->lastDropAction = event->dropAction();
        eventDelivered = true;
        break;
    }

    if (!eventDelivered) {
        if (d->dragDropItem) {
            // Leave the last drag drop item
            QGraphicsSceneDragDropEvent dragLeave(QEvent::GraphicsSceneDragLeave);
            d->cloneDragDropEvent(&dragLeave, event);
            d->sendDragDropEvent(d->dragDropItem, &dragLeave);
            d->dragDropItem = 0;
        }
        // Propagate
        event->setDropAction(Qt::IgnoreAction);
    }
}

drawBackground()

void QGraphicsScene::drawBackground ( QPainter *  painter, const QRectF &  rect  )

protectedvirtual

Draws the background of the scene using painter, before any items and the foreground are drawn.

Reimplement this function to provide a custom background for the scene.

All painting is done in scene coordinates. The rect parameter is the exposed rectangle.

If all you want is to define a color, texture, or gradient for the background, you can call setBackgroundBrush() instead.

See also

drawForeground(), drawItems()

Definition at line 4381 of file qgraphicsscene.cpp.

Referenced by render().

{
    Q_D(QGraphicsScene);

    if (d->backgroundBrush.style() != Qt::NoBrush) {
        if (d->painterStateProtection)
            painter->save();
        painter->setBrushOrigin(0, 0);
        painter->fillRect(rect, backgroundBrush());
        if (d->painterStateProtection)
            painter->restore();
    }
}

drawForeground()

void QGraphicsScene::drawForeground ( QPainter *  painter, const QRectF &  rect  )

protectedvirtual

Draws the foreground of the scene using painter, after the background and all items have been drawn.

Reimplement this function to provide a custom foreground for the scene.

All painting is done in scene coordinates. The rect parameter is the exposed rectangle.

If all you want is to define a color, texture or gradient for the foreground, you can call setForegroundBrush() instead.

See also

drawBackground(), drawItems()

Definition at line 4408 of file qgraphicsscene.cpp.

Referenced by render().

{
    Q_D(QGraphicsScene);

    if (d->foregroundBrush.style() != Qt::NoBrush) {
        if (d->painterStateProtection)
            painter->save();
        painter->setBrushOrigin(0, 0);
        painter->fillRect(rect, foregroundBrush());
        if (d->painterStateProtection)
            painter->restore();
    }
}

drawItems()

void QGraphicsScene::drawItems ( QPainter *  painter, int  numItems, QGraphicsItem *  items[], const QStyleOptionGraphicsItem  options[], QWidget *  widget = 0  )

protectedvirtual

Paints the given items using the provided painter, after the background has been drawn, and before the foreground has been drawn.

All painting is done in scene coordinates. Before drawing each item, the painter must be transformed using QGraphicsItem::sceneTransform().

The options parameter is the list of style option objects for each item in items. The numItems parameter is the number of items in items and options in options. The widget parameter is optional; if specified, it should point to the widget that is being painted on.

The default implementation prepares the painter matrix, and calls QGraphicsItem::paint() on all items. Reimplement this function to provide custom painting of all items for the scene; gaining complete control over how each item is drawn. In some cases this can increase drawing performance significantly.

Example:

void CustomScene::drawItems(QPainter *painter, int numItems,
                            QGraphicsItem *items[],
                            const QStyleOptionGraphicsItem options[],
                            QWidget *widget)
{
    for (int i = 0; i < numItems; ++i) {
         // Draw the item
         painter->save();
         painter->setMatrix(items[i]->sceneMatrix(), true);
         items[i]->paint(painter, &options[i], widget);
         painter->restore();
     }
}

Since Qt 4.6, this function is not called anymore unless the QGraphicsView::IndirectPainting flag is given as an Optimization flag.

See also

drawBackground(), drawForeground()

Definition at line 5483 of file qgraphicsscene.cpp.

Referenced by render().

{
    Q_D(QGraphicsScene);
    // Make sure we don't have unpolished items before we draw.
    if (!d->unpolishedItems.isEmpty())
        d->_q_polishItems();

    const qreal opacity = painter->opacity();
    QTransform viewTransform = painter->worldTransform();
    Q_UNUSED(options);

    // Determine view, expose and flags.
    QGraphicsView *view = widget ? qobject_cast<QGraphicsView *>(widget->parentWidget()) : 0;
    QRegion *expose = 0;
    const quint32 oldRectAdjust = d->rectAdjust;
    if (view) {
        d->updateAll = false;
        expose = &view->d_func()->exposedRegion;
        if (view->d_func()->optimizationFlags & QGraphicsView::DontAdjustForAntialiasing)
            d->rectAdjust = 1;
        else
            d->rectAdjust = 2;
    }

    // Find all toplevels, they are already sorted.
    QList<QGraphicsItem *> topLevelItems;
    for (int i = 0; i < numItems; ++i) {
        QGraphicsItem *item = items[i]->topLevelItem();
        if (!item->d_ptr->itemDiscovered) {
            topLevelItems << item;
            item->d_ptr->itemDiscovered = 1;
            d->drawSubtreeRecursive(item, painter, &viewTransform, expose, widget);
        }
    }

    d->rectAdjust = oldRectAdjust;
    // Reset discovery bits.
    for (int i = 0; i < topLevelItems.size(); ++i)
        topLevelItems.at(i)->d_ptr->itemDiscovered = 0;

    painter->setWorldTransform(viewTransform);
    painter->setOpacity(opacity);
}

dropEvent()

void QGraphicsScene::dropEvent ( QGraphicsSceneDragDropEvent *  event )

protectedvirtual

This event handler, for event event, can be reimplemented in a subclass to receive drop events for the scene.

See also

QGraphicsItem::dropEvent(), dragEnterEvent(), dragMoveEvent(), dragLeaveEvent()

Definition at line 3869 of file qgraphicsscene.cpp.

Referenced by event().

{
    Q_UNUSED(event);
    Q_D(QGraphicsScene);
    if (d->dragDropItem) {
        // Drop on the last drag drop item
        d->sendDragDropEvent(d->dragDropItem, event);
        d->dragDropItem = 0;
    }
}

event()

bool QGraphicsScene::event ( QEvent *  event )

protectedvirtual

Processes the event event, and dispatches it to the respective event handlers.

In addition to calling the convenience event handlers, this function is responsible for converting mouse move events to hover events for when there is no mouse grabber item. Hover events are delivered directly to items; there is no convenience function for them.

Unlike QWidget, QGraphicsScene does not have the convenience functions QWidget::enterEvent() and QWidget::leaveEvent(). Use this function to obtain those events instead.

See also

contextMenuEvent(), keyPressEvent(), keyReleaseEvent(), mousePressEvent(), mouseMoveEvent(), mouseReleaseEvent(), mouseDoubleClickEvent(), focusInEvent(), focusOutEvent()

Reimplemented from QObject.

Definition at line 3487 of file qgraphicsscene.cpp.

Referenced by setFocus(), and setStyle().

{
    Q_D(QGraphicsScene);

    switch (event->type()) {
    case QEvent::GraphicsSceneMousePress:
    case QEvent::GraphicsSceneMouseMove:
    case QEvent::GraphicsSceneMouseRelease:
    case QEvent::GraphicsSceneMouseDoubleClick:
    case QEvent::GraphicsSceneHoverEnter:
    case QEvent::GraphicsSceneHoverLeave:
    case QEvent::GraphicsSceneHoverMove:
    case QEvent::TouchBegin:
    case QEvent::TouchUpdate:
    case QEvent::TouchEnd:
        // Reset the under-mouse list to ensure that this event gets fresh
        // item-under-mouse data. Be careful about this list; if people delete
        // items from inside event handlers, this list can quickly end up
        // having stale pointers in it. We need to clear it before dispatching
        // events that use it.
        // ### this should only be cleared if we received a new mouse move event,
        // which relies on us fixing the replay mechanism in QGraphicsView.
        d->cachedItemsUnderMouse.clear();
    default:
        break;
    }

    switch (event->type()) {
    case QEvent::GraphicsSceneDragEnter:
        dragEnterEvent(static_cast<QGraphicsSceneDragDropEvent *>(event));
        break;
    case QEvent::GraphicsSceneDragMove:
        dragMoveEvent(static_cast<QGraphicsSceneDragDropEvent *>(event));
        break;
    case QEvent::GraphicsSceneDragLeave:
        dragLeaveEvent(static_cast<QGraphicsSceneDragDropEvent *>(event));
        break;
    case QEvent::GraphicsSceneDrop:
        dropEvent(static_cast<QGraphicsSceneDragDropEvent *>(event));
        break;
    case QEvent::GraphicsSceneContextMenu:
        contextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent *>(event));
        break;
    case QEvent::KeyPress:
        if (!d->focusItem) {
            QKeyEvent *k = static_cast<QKeyEvent *>(event);
            if (k->key() == Qt::Key_Tab || k->key() == Qt::Key_Backtab) {
                if (!(k->modifiers() & (Qt::ControlModifier | Qt::AltModifier))) {  //### Add MetaModifier?
                    bool res = false;
                    if (k->key() == Qt::Key_Backtab
                        || (k->key() == Qt::Key_Tab && (k->modifiers() & Qt::ShiftModifier))) {
                        res = focusNextPrevChild(false);
                    } else if (k->key() == Qt::Key_Tab) {
                        res = focusNextPrevChild(true);
                    }
                    if (!res)
                        event->ignore();
                    return true;
                }
            }
        }
        keyPressEvent(static_cast<QKeyEvent *>(event));
        break;
    case QEvent::KeyRelease:
        keyReleaseEvent(static_cast<QKeyEvent *>(event));
        break;
    case QEvent::ShortcutOverride: {
            QGraphicsItem *parent = focusItem();
            while (parent) {
                d->sendEvent(parent, event);
                if (event->isAccepted())
                    return true;
                parent = parent->parentItem();
            }
        }
        return false;
    case QEvent::GraphicsSceneMouseMove:
    {
        QGraphicsSceneMouseEvent *mouseEvent = static_cast<QGraphicsSceneMouseEvent *>(event);
        d->lastSceneMousePos = mouseEvent->scenePos();
        mouseMoveEvent(mouseEvent);
        break;
    }
    case QEvent::GraphicsSceneMousePress:
        mousePressEvent(static_cast<QGraphicsSceneMouseEvent *>(event));
        break;
    case QEvent::GraphicsSceneMouseRelease:
        mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent *>(event));
        break;
    case QEvent::GraphicsSceneMouseDoubleClick:
        mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent *>(event));
        break;
    case QEvent::GraphicsSceneWheel:
        wheelEvent(static_cast<QGraphicsSceneWheelEvent *>(event));
        break;
    case QEvent::FocusIn:
        focusInEvent(static_cast<QFocusEvent *>(event));
        break;
    case QEvent::FocusOut:
        focusOutEvent(static_cast<QFocusEvent *>(event));
        break;
    case QEvent::GraphicsSceneHoverEnter:
    case QEvent::GraphicsSceneHoverLeave:
    case QEvent::GraphicsSceneHoverMove:
    {
        QGraphicsSceneHoverEvent *hoverEvent = static_cast<QGraphicsSceneHoverEvent *>(event);
        d->lastSceneMousePos = hoverEvent->scenePos();
        d->dispatchHoverEvent(hoverEvent);
        break;
    }
    case QEvent::Leave:
        // hackieshly unpacking the viewport pointer from the leave event.
        d->leaveScene(reinterpret_cast<QWidget *>(event->d));
        break;
    case QEvent::GraphicsSceneHelp:
        helpEvent(static_cast<QGraphicsSceneHelpEvent *>(event));
        break;
    case QEvent::InputMethod:
        inputMethodEvent(static_cast<QInputMethodEvent *>(event));
        break;
    case QEvent::WindowActivate:
        if (!d->activationRefCount++) {
            if (d->lastActivePanel) {
                // Activate the last panel.
                d->setActivePanelHelper(d->lastActivePanel, true);
            } else if (d->tabFocusFirst && d->tabFocusFirst->isPanel()) {
                // Activate the panel of the first item in the tab focus
                // chain.
                d->setActivePanelHelper(d->tabFocusFirst, true);
            } else {
                // Activate all toplevel items.
                QEvent event(QEvent::WindowActivate);
                foreach (QGraphicsItem *item, items()) {
                    if (item->isVisible() && !item->isPanel() && !item->parentItem())
                        sendEvent(item, &event);
                }
            }
        }
        break;
    case QEvent::WindowDeactivate:
        if (d->activationRefCount > 0)
            --d->activationRefCount;
        if (!d->activationRefCount) {
            if (d->activePanel) {
                // Deactivate the active panel (but keep it so we can
                // reactivate it later).
                QGraphicsItem *lastActivePanel = d->activePanel;
                d->setActivePanelHelper(0, true);
                d->lastActivePanel = lastActivePanel;
            } else {
                // Activate all toplevel items.
                QEvent event(QEvent::WindowDeactivate);
                foreach (QGraphicsItem *item, items()) {
                    if (item->isVisible() && !item->isPanel() && !item->parentItem())
                        sendEvent(item, &event);
                }
            }
        }
        break;
    case QEvent::ApplicationFontChange: {
        // Resolve the existing scene font.
        d->resolveFont();
        break;
    }
    case QEvent::FontChange:
        // Update the entire scene when the font changes.
        update();
        break;
    case QEvent::ApplicationPaletteChange: {
        // Resolve the existing scene palette.
        d->resolvePalette();
        break;
    }
    case QEvent::PaletteChange:
        // Update the entire scene when the palette changes.
        update();
        break;
    case QEvent::StyleChange:
        // Reresolve all widgets' styles. Update all top-level widgets'
        // geometries that do not have an explicit style set.
        update();
        break;
    case QEvent::TouchBegin:
    case QEvent::TouchUpdate:
    case QEvent::TouchEnd:
        d->touchEventHandler(static_cast<QTouchEvent *>(event));
        break;
#ifndef QT_NO_GESTURES
    case QEvent::Gesture:
    case QEvent::GestureOverride:
        d->gestureEventHandler(static_cast<QGestureEvent *>(event));
        break;
#endif // QT_NO_GESTURES
    default:
        return QObject::event(event);
    }
    return true;
}

eventFilter()

bool QGraphicsScene::eventFilter ( QObject *  watched, QEvent *  event  )

protectedvirtual

QGraphicsScene filters QApplication's events to detect palette and font changes.

Reimplemented Function

Reimplemented from QObject.

Definition at line 3695 of file qgraphicsscene.cpp.

{
    if (watched != qApp)
        return false;

    switch (event->type()) {
    case QEvent::ApplicationPaletteChange:
        QApplication::postEvent(this, new QEvent(QEvent::ApplicationPaletteChange));
        break;
    case QEvent::ApplicationFontChange:
        QApplication::postEvent(this, new QEvent(QEvent::ApplicationFontChange));
        break;
    default:
        break;
    }
    return false;
}

focusInEvent()

void QGraphicsScene::focusInEvent ( QFocusEvent *  focusEvent )

protectedvirtual

This event handler, for event focusEvent, can be reimplemented in a subclass to receive focus in events.

The default implementation sets focus on the scene, and then on the last focus item.

See also

QGraphicsItem::focusOutEvent()

Definition at line 3889 of file qgraphicsscene.cpp.

Referenced by event().

{
    Q_D(QGraphicsScene);

    d->hasFocus = true;
    switch (focusEvent->reason()) {
    case Qt::TabFocusReason:
        if (!focusNextPrevChild(true))
            focusEvent->ignore();
        break;
    case Qt::BacktabFocusReason:
        if (!focusNextPrevChild(false))
            focusEvent->ignore();
        break;
    default:
        if (d->passiveFocusItem) {
            // Set focus on the last focus item
            setFocusItem(d->passiveFocusItem, focusEvent->reason());
        }
        break;
    }
}

focusItem()

QGraphicsItem * QGraphicsScene::focusItem

(

)

const

When the scene is active, this functions returns the scene's current focus item, or 0 if no item currently has focus.

When the scene is inactive, this functions returns the item that will gain input focus when the scene becomes active.

The focus item receives keyboard input when the scene receives a key event.

See also

setFocusItem(), QGraphicsItem::hasFocus(), isActive()

Definition at line 3106 of file qgraphicsscene.cpp.

Referenced by QShortcutMap::correctGraphicsWidgetContext(), QMotifStyle::event(), QMacStyle::event(), event(), QUIKitSoftwareInputHandler::eventFilter(), focusNextPrevChild(), QDeclarativeItem::hasActiveFocus(), QGraphicsItem::hasFocus(), keyPressEvent(), keyReleaseEvent(), QGraphicsItemPrivate::setEnabledHelper(), QGraphicsItemPrivate::setFocusHelper(), QGraphicsItemPrivate::setVisibleHelper(), QGraphicsViewPrivate::updateInputMethodSensitivity(), and wheelEvent().

{
    Q_D(const QGraphicsScene);
    return isActive() ? d->focusItem : d->passiveFocusItem;
}

focusNextPrevChild

bool QGraphicsScene::focusNextPrevChild ( bool  next )

protectedslot

Finds a new widget to give the keyboard focus to, as appropriate for Tab and Shift+Tab, and returns true if it can find a new widget, or false if it cannot.

Since

4.4

If next is true, this function searches forward; if next is false, it searches backward.

You can reimplement this function in a subclass of QGraphicsScene to provide fine-grained control over how tab focus passes inside your scene. The default implementation is based on the tab focus chain defined by QGraphicsWidget::setTabOrder().

Definition at line 5546 of file qgraphicsscene.cpp.

Referenced by event(), focusInEvent(), and QGraphicsItem::sceneEvent().

{
    Q_D(QGraphicsScene);

    QGraphicsItem *item = focusItem();
    if (item && !item->isWidget()) {
        // Tab out of the scene.
        return false;
    }
    if (!item) {
        if (d->lastFocusItem && !d->lastFocusItem->isWidget()) {
            // Restore focus to the last focusable non-widget item that had
            // focus.
            setFocusItem(d->lastFocusItem, next ? Qt::TabFocusReason : Qt::BacktabFocusReason);
            return true;
        }
    }
    if (!d->tabFocusFirst) {
        // No widgets...
        return false;
    }

    // The item must be a widget.
    QGraphicsWidget *widget = 0;
    if (!item) {
        widget = next ? d->tabFocusFirst : d->tabFocusFirst->d_func()->focusPrev;
    } else {
        QGraphicsWidget *test = static_cast<QGraphicsWidget *>(item);
        widget = next ? test->d_func()->focusNext : test->d_func()->focusPrev;
        if ((next && widget == d->tabFocusFirst) || (!next && widget == d->tabFocusFirst->d_func()->focusPrev))
            return false;
    }
    QGraphicsWidget *widgetThatHadFocus = widget;

    // Run around the focus chain until we find a widget that can take tab focus.
    do {
        if (widget->flags() & QGraphicsItem::ItemIsFocusable
            && widget->isEnabled() && widget->isVisibleTo(0)
            && (widget->focusPolicy() & Qt::TabFocus)
            && (!item || !item->isPanel() || item->isAncestorOf(widget))
            ) {
            setFocusItem(widget, next ? Qt::TabFocusReason : Qt::BacktabFocusReason);
            return true;
        }
        widget = next ? widget->d_func()->focusNext : widget->d_func()->focusPrev;
        if ((next && widget == d->tabFocusFirst) || (!next && widget == d->tabFocusFirst->d_func()->focusPrev))
            return false;
    } while (widget != widgetThatHadFocus);

    return false;
}

focusOutEvent()

void QGraphicsScene::focusOutEvent ( QFocusEvent *  focusEvent )

protectedvirtual

This event handler, for event focusEvent, can be reimplemented in a subclass to receive focus out events.

The default implementation removes focus from any focus item, then removes focus from the scene.

See also

QGraphicsItem::focusInEvent()

Definition at line 3921 of file qgraphicsscene.cpp.

Referenced by event().

{
    Q_D(QGraphicsScene);
    d->hasFocus = false;
    d->passiveFocusItem = d->focusItem;
    setFocusItem(0, focusEvent->reason());

    // Remove all popups when the scene loses focus.
    if (!d->popupWidgets.isEmpty())
        d->removePopup(d->popupWidgets.first());
}

font()

QFont QGraphicsScene::font

(

)

const

Referenced by setStyle().

foregroundBrush()

QBrush QGraphicsScene::foregroundBrush

(

)

const

Referenced by drawForeground(), and setBackgroundBrush().

hasFocus()

bool QGraphicsScene::hasFocus

(

)

const

Returns true if the scene has focus; otherwise returns false.

If the scene has focus, it will will forward key events from QKeyEvent to any item that has focus.

See also

setFocus(), setFocusItem()

Definition at line 3144 of file qgraphicsscene.cpp.

Referenced by QDeclarativeTextEditPrivate::focusChanged(), and QDeclarativeTextInputPrivate::focusChanged().

{
    Q_D(const QGraphicsScene);
    return d->hasFocus;
}

height()

qreal QGraphicsScene::height ( ) const

inline

This convenience function is equivalent to calling sceneRect().

height().

 \sa width()

Definition at line 135 of file qgraphicsscene.h.

{ return sceneRect().height(); }

helpEvent()

void QGraphicsScene::helpEvent ( QGraphicsSceneHelpEvent *  helpEvent )

protectedvirtual

This event handler, for event helpEvent, can be reimplemented in a subclass to receive help events.

The events are of type QEvent::ToolTip, which are created when a tooltip is requested.

The default implementation shows the tooltip of the topmost item, i.e., the item with the highest z-value, at the mouse cursor position. If no item has a tooltip set, this function does nothing.

See also

QGraphicsItem::toolTip(), QGraphicsSceneHelpEvent

Definition at line 3946 of file qgraphicsscene.cpp.

Referenced by event().

{
#ifdef QT_NO_TOOLTIP
    Q_UNUSED(helpEvent);
#else
    // Find the first item that does tooltips
    Q_D(QGraphicsScene);
    QList<QGraphicsItem *> itemsAtPos = d->itemsAtPosition(helpEvent->screenPos(),
                                                           helpEvent->scenePos(),
                                                           helpEvent->widget());
    QGraphicsItem *toolTipItem = 0;
    for (int i = 0; i < itemsAtPos.size(); ++i) {
        QGraphicsItem *tmp = itemsAtPos.at(i);
        if (tmp->d_func()->isProxyWidget()) {
            // if the item is a proxy widget, the event is forwarded to it
            sendEvent(tmp, helpEvent);
            if (helpEvent->isAccepted())
                return;
        }
        if (!tmp->toolTip().isEmpty()) {
            toolTipItem = tmp;
            break;
        }
    }

    // Show or hide the tooltip
    QString text;
    QPoint point;
    if (toolTipItem && !toolTipItem->toolTip().isEmpty()) {
        text = toolTipItem->toolTip();
        point = helpEvent->screenPos();
    }
    QToolTip::showText(point, text, helpEvent->widget());
    helpEvent->setAccepted(!text.isEmpty());
#endif
}

inputMethodEvent()

void QGraphicsScene::inputMethodEvent ( QInputMethodEvent *  event )

protectedvirtual

This event handler, for event event, can be reimplemented in a subclass to receive input method events for the scene.

The default implementation forwards the event to the focusItem(). If no item currently has focus or the current focus item does not accept input methods, this function does nothing.

See also

QGraphicsItem::inputMethodEvent()

Definition at line 4361 of file qgraphicsscene.cpp.

Referenced by event().

{
    Q_D(QGraphicsScene);
    if (d->focusItem && (d->focusItem->flags() & QGraphicsItem::ItemAcceptsInputMethod))
        d->sendEvent(d->focusItem, event);
}

inputMethodQuery()

QVariant QGraphicsScene::inputMethodQuery ( Qt::InputMethodQuery  query ) const

virtual

This method is used by input methods to query a set of properties of the scene to be able to support complex input method operations as support for surrounding text and reconversions.

The query parameter specifies which property is queried.

See also

QWidget::inputMethodQuery()

Definition at line 3329 of file qgraphicsscene.cpp.

{
    Q_D(const QGraphicsScene);
    if (!d->focusItem || !(d->focusItem->flags() & QGraphicsItem::ItemAcceptsInputMethod))
        return QVariant();
    const QTransform matrix = d->focusItem->sceneTransform();
    QVariant value = d->focusItem->inputMethodQuery(query);
    if (value.type() == QVariant::RectF)
        value = matrix.mapRect(value.toRectF());
    else if (value.type() == QVariant::PointF)
        value = matrix.map(value.toPointF());
    else if (value.type() == QVariant::Rect)
        value = matrix.mapRect(value.toRect());
    else if (value.type() == QVariant::Point)
        value = matrix.map(value.toPoint());
    return value;
}

invalidate() [1/2]

void QGraphicsScene::invalidate ( qreal  x, qreal  y, qreal  w, qreal  h, SceneLayers  layers = AllLayers  )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Since

4.3

This convenience function is equivalent to calling invalidate(QRectF(x, y, w, h), layers);

Definition at line 234 of file qgraphicsscene.h.

    { invalidate(QRectF(x, y, w, h), layers); }

invalidate [2/2]

void QGraphicsScene::invalidate ( const QRectF &  rect = QRectF(), SceneLayers  layers = AllLayers  )

slot

Invalidates and schedules a redraw of the layers in rect on the scene.

Any cached content in layers is unconditionally invalidated and redrawn.

You can use this function overload to notify QGraphicsScene of changes to the background or the foreground of the scene. This function is commonly used for scenes with tile-based backgrounds to notify changes when QGraphicsView has enabled CacheBackground.

Example:

QRectF TileScene::rectForTile(int x, int y) const
{
    // Return the rectangle for the tile at position (x, y).
    return QRectF(x * tileWidth, y * tileHeight, tileWidth, tileHeight);
}

void TileScene::setTile(int x, int y, const QPixmap &pixmap)
{
    // Sets or replaces the tile at position (x, y) with pixmap.
    if (x >= 0 && x < numTilesH && y >= 0 && y < numTilesV) {
        tiles[y][x] = pixmap;
        invalidate(rectForTile(x, y), BackgroundLayer);
    }
}

void TileScene::drawBackground(QPainter *painter, const QRectF &exposed)
{
    // Draws all tiles that intersect the exposed area.
    for (int y = 0; y < numTilesV; ++y) {
        for (int x = 0; x < numTilesH; ++x) {
            QRectF rect = rectForTile(x, y);
            if (exposed.intersects(rect))
                painter->drawPixmap(rect.topLeft(), tiles[y][x]);
        }
    }
}

Note that QGraphicsView currently supports background caching only (see QGraphicsView::CacheBackground). This function is equivalent to calling update() if any layer but BackgroundLayer is passed.

See also

QGraphicsView::resetCachedContent()

Definition at line 3424 of file qgraphicsscene.cpp.

{
    foreach (QGraphicsView *view, views())
        view->invalidateScene(rect, layers);
    update(rect);
}

isActive()

bool QGraphicsScene::isActive

(

)

const

Returns true if the scene is active (e.

Since

4.6

g., it's viewed by at least one QGraphicsView that is active); otherwise returns false.

See also

QGraphicsItem::isActive(), QWidget::isActiveWindow()

Definition at line 5803 of file qgraphicsscene.cpp.

Referenced by addItem(), focusItem(), QGraphicsItem::hasFocus(), QGraphicsItem::isActive(), setFocus(), QGraphicsItemPrivate::setFocusHelper(), and QGraphicsItemPrivate::setSubFocus().

{
    Q_D(const QGraphicsScene);
    return d->activationRefCount > 0;
}

isSortCacheEnabled()

bool QGraphicsScene::isSortCacheEnabled

(

)

const

Definition at line 1964 of file qgraphicsscene.cpp.

{
    Q_D(const QGraphicsScene);
    return d->sortCacheEnabled;
}

itemAt() [1/4]

QGraphicsItem * QGraphicsScene::itemAt

(

const QPointF &

position

)

const

Returns the topmost visible item at the specified position, or 0 if there are no items at this position.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

This function is deprecated and returns incorrect results if the scene contains items that ignore transformations. Use the overload that takes a QTransform instead.

See also

items(), collidingItems(), {QGraphicsItem::Sorting}{Sorting}

Definition at line 2289 of file qgraphicsscene.cpp.

{
    QList<QGraphicsItem *> itemsAtPoint = items(position);
    return itemsAtPoint.isEmpty() ? 0 : itemsAtPoint.first();
}

itemAt() [2/4]

QGraphicsItem * QGraphicsScene::itemAt	(	const QPointF &	position,
		const QTransform &	deviceTransform
	)		const

Returns the topmost visible item at the specified position, or 0 if there are no items at this position.

Since

4.6

deviceTransform is the transformation that applies to the view, and needs to be provided if the scene contains items that ignore transformations.

See also

items(), collidingItems(), {QGraphicsItem::Sorting}{Sorting}

Definition at line 2309 of file qgraphicsscene.cpp.

{
    QList<QGraphicsItem *> itemsAtPoint = items(position, Qt::IntersectsItemShape,
                                                Qt::DescendingOrder, deviceTransform);
    return itemsAtPoint.isEmpty() ? 0 : itemsAtPoint.first();
}

itemAt() [3/4]

QGraphicsScene::itemAt ( qreal  x, qreal  y  ) const

inline

Returns the topmost item at the position specified by (x, y), or 0 if there are no items at this position.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

This convenience function is equivalent to calling {itemAt(QPointF(x, y))}.

This function is deprecated and returns incorrect results if the scene contains items that ignore transformations. Use the overload that takes a QTransform instead.

Definition at line 178 of file qgraphicsscene.h.

    { return itemAt(QPointF(x, y)); }

itemAt() [4/4]

QGraphicsScene::itemAt ( qreal  x, qreal  y, const QTransform &  deviceTransform  ) const

inline

Returns the topmost item at the position specified by (x, y), or 0 if there are no items at this position.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Since

4.6

deviceTransform is the transformation that applies to the view, and needs to be provided if the scene contains items that ignore transformations.

This convenience function is equivalent to calling {itemAt(QPointF(x, y), deviceTransform)}.

Definition at line 180 of file qgraphicsscene.h.

    { return itemAt(QPointF(x, y), deviceTransform); }

itemIndexMethod()

ItemIndexMethod QGraphicsScene::itemIndexMethod

(

)

const

Referenced by render().

items() [1/12]

QList< QGraphicsItem * > QGraphicsScene::items

(

)

const

Returns a list of all items in the scene in descending stacking order.

See also

addItem(), removeItem(), {QGraphicsItem::Sorting}{Sorting}

Definition at line 1998 of file qgraphicsscene.cpp.

Referenced by advance(), QGraphicsScenePrivate::cancelGesturesForChildren(), QGraphicsScenePrivate::enterModal(), event(), QGraphicsViewPrivate::findItems(), QGraphicsScenePrivate::gestureTargetsAtHotSpots(), itemAt(), itemsBoundingRect(), QGraphicsScenePrivate::leaveModal(), render(), setActiveWindow(), setSelectionArea(), and setStyle().

{
    Q_D(const QGraphicsScene);
    return d->index->items(Qt::DescendingOrder);
}

items() [2/12]

QList< QGraphicsItem * > QGraphicsScene::items

(

Qt::SortOrder

order

)

const

Returns an ordered list of all items on the scene.

order decides the stacking order.

See also

addItem(), removeItem(), {QGraphicsItem::Sorting}{Sorting}

Definition at line 2010 of file qgraphicsscene.cpp.

{
    Q_D(const QGraphicsScene);
    return d->index->items(order);
}

items() [3/12]

QList< QGraphicsItem * > QGraphicsScene::items	(	const QPointF &	pos,
		Qt::ItemSelectionMode	mode,
		Qt::SortOrder	order,
		const QTransform &	deviceTransform = QTransform()
	)		const

Returns all visible items that, depending on mode, are at the specified pos in a list sorted using order.

Since

4.6

The default value for mode is Qt::IntersectsItemShape; all items whose exact shape intersects with pos are returned.

deviceTransform is the transformation that applies to the view, and needs to be provided if the scene contains items that ignore transformations.

See also

itemAt(), {QGraphicsItem::Sorting}{Sorting}

Definition at line 2155 of file qgraphicsscene.cpp.

{
    Q_D(const QGraphicsScene);
    return d->index->items(pos, mode, order, deviceTransform);
}

items() [4/12]

QList< QGraphicsItem * > QGraphicsScene::items	(	const QRectF &	rect,
		Qt::ItemSelectionMode	mode,
		Qt::SortOrder	order,
		const QTransform &	deviceTransform = QTransform()
	)		const

Returns all visible items that, depending on mode, are either inside or intersect with the specified rect and return a list sorted using order.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Since

4.6

The default value for mode is Qt::IntersectsItemShape; all items whose exact shape intersects with or is contained by rect are returned.

deviceTransform is the transformation that applies to the view, and needs to be provided if the scene contains items that ignore transformations.

See also

itemAt(), {QGraphicsItem::Sorting}{Sorting}

Definition at line 2182 of file qgraphicsscene.cpp.

{
    Q_D(const QGraphicsScene);
    return d->index->items(rect, mode, order, deviceTransform);
}

items() [5/12]

QList< QGraphicsItem * > QGraphicsScene::items	(	const QPolygonF &	polygon,
		Qt::ItemSelectionMode	mode,
		Qt::SortOrder	order,
		const QTransform &	deviceTransform = QTransform()
	)		const

Returns all visible items that, depending on mode, are either inside or intersect with the specified polygon and return a list sorted using order.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Since

4.6

The default value for mode is Qt::IntersectsItemShape; all items whose exact shape intersects with or is contained by polygon are returned.

deviceTransform is the transformation that applies to the view, and needs to be provided if the scene contains items that ignore transformations.

See also

itemAt(), {QGraphicsItem::Sorting}{Sorting}

Definition at line 2209 of file qgraphicsscene.cpp.

{
    Q_D(const QGraphicsScene);
    return d->index->items(polygon, mode, order, deviceTransform);
}

items() [6/12]

QList< QGraphicsItem * > QGraphicsScene::items	(	const QPainterPath &	path,
		Qt::ItemSelectionMode	mode,
		Qt::SortOrder	order,
		const QTransform &	deviceTransform = QTransform()
	)		const

Returns all visible items that, depending on mode, are either inside or intersect with the specified path and return a list sorted using order.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Since

4.6

The default value for mode is Qt::IntersectsItemShape; all items whose exact shape intersects with or is contained by path are returned.

deviceTransform is the transformation that applies to the view, and needs to be provided if the scene contains items that ignore transformations.

See also

itemAt(), {QGraphicsItem::Sorting}{Sorting}

Definition at line 2236 of file qgraphicsscene.cpp.

{
    Q_D(const QGraphicsScene);
    return d->index->items(path, mode, order, deviceTransform);
}

items() [7/12]

QList< QGraphicsItem * > QGraphicsScene::items

(

const QPointF &

pos

)

const

Returns all visible items at position pos in the scene.

The items are listed in descending stacking order (i.e., the first item in the list is the top-most item, and the last item is the bottom-most item).

This function is deprecated and returns incorrect results if the scene contains items that ignore transformations. Use the overload that takes a QTransform instead.

See also

itemAt(), {QGraphicsItem::Sorting}{Sorting}

Definition at line 2032 of file qgraphicsscene.cpp.

{
    Q_D(const QGraphicsScene);
    return d->index->items(pos, Qt::IntersectsItemShape, Qt::DescendingOrder);
}

items() [8/12]

QList< QGraphicsItem * > QGraphicsScene::items	(	const QRectF &	rectangle,
		Qt::ItemSelectionMode	mode = Qt::IntersectsItemShape
	)		const

Returns all visible items that, depending on mode, are either inside or intersect with the specified rectangle.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

The default value for mode is Qt::IntersectsItemShape; all items whose exact shape intersects with or is contained by rectangle are returned.

This function is deprecated and returns incorrect results if the scene contains items that ignore transformations. Use the overload that takes a QTransform instead.

See also

itemAt(), {QGraphicsItem::Sorting}{Sorting}

Definition at line 2057 of file qgraphicsscene.cpp.

{
    Q_D(const QGraphicsScene);
    return d->index->items(rectangle, mode, Qt::DescendingOrder);
}

items() [9/12]

QList< QGraphicsItem * > QGraphicsScene::items	(	const QPolygonF &	polygon,
		Qt::ItemSelectionMode	mode = Qt::IntersectsItemShape
	)		const

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Returns all visible items that, depending on mode, are either inside or intersect with the polygon polygon.

The default value for mode is Qt::IntersectsItemShape; all items whose exact shape intersects with or is contained by polygon are returned.

This function is deprecated and returns incorrect results if the scene contains items that ignore transformations. Use the overload that takes a QTransform instead.

See also

itemAt(), {QGraphicsItem::Sorting}{Sorting}

Definition at line 2108 of file qgraphicsscene.cpp.

{
    Q_D(const QGraphicsScene);
    return d->index->items(polygon, mode, Qt::DescendingOrder);
}

items() [10/12]

QList< QGraphicsItem * > QGraphicsScene::items	(	const QPainterPath &	path,
		Qt::ItemSelectionMode	mode = Qt::IntersectsItemShape
	)		const

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Returns all visible items that, depending on path, are either inside or intersect with the path path.

The default value for mode is Qt::IntersectsItemShape; all items whose exact shape intersects with or is contained by path are returned.

This function is deprecated and returns incorrect results if the scene contains items that ignore transformations. Use the overload that takes a QTransform instead.

See also

itemAt(), {QGraphicsItem::Sorting}{Sorting}

Definition at line 2131 of file qgraphicsscene.cpp.

{
    Q_D(const QGraphicsScene);
    return d->index->items(path, mode, Qt::DescendingOrder);
}

items() [11/12]

QList< QGraphicsItem * > QGraphicsScene::items ( qreal  x, qreal  y, qreal  w, qreal  h, Qt::ItemSelectionMode  mode = Qt::IntersectsItemShape  ) const

inline

Since

4.3

This convenience function is equivalent to calling items(QRectF(x, y, w, h), mode).

This function is deprecated and returns incorrect results if the scene contains items that ignore transformations. Use the overload that takes a QTransform instead.

Definition at line 173 of file qgraphicsscene.h.

    { return items(QRectF(x, y, w, h), mode); } // ### obsolete

items() [12/12]

QList< QGraphicsItem * > QGraphicsScene::items ( qreal  x, qreal  y, qreal  w, qreal  h, Qt::ItemSelectionMode  mode, Qt::SortOrder  order, const QTransform &  deviceTransform = QTransform()  ) const

inline

Returns all visible items that, depending on mode, are either inside or intersect with the rectangle defined by x, y,.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Since

4.6

w and h, in a list sorted using order.

deviceTransform is the transformation that applies to the view, and needs to be provided if the scene contains items that ignore transformations.

Definition at line 175 of file qgraphicsscene.h.

    { return items(QRectF(x, y, w, h), mode, order, deviceTransform); }

itemsBoundingRect()

QRectF QGraphicsScene::itemsBoundingRect

(

)

const

Calculates and returns the bounding rect of all items on the scene.

This function works by iterating over all items, and because if this, it can be slow for large scenes.

See also

sceneRect()

Definition at line 1984 of file qgraphicsscene.cpp.

Referenced by ~QGraphicsScene().

{
    // Does not take untransformable items into account.
    QRectF boundingRect;
    foreach (QGraphicsItem *item, items())
        boundingRect |= item->sceneBoundingRect();
    return boundingRect;
}

keyPressEvent()

void QGraphicsScene::keyPressEvent ( QKeyEvent *  keyEvent )

protectedvirtual

This event handler, for event keyEvent, can be reimplemented in a subclass to receive keypress events.

The default implementation forwards the event to current focus item.

See also

QGraphicsItem::keyPressEvent(), focusItem()

Reimplemented in QDeclarativeScene.

Definition at line 4112 of file qgraphicsscene.cpp.

Referenced by event(), and QDeclarativeScene::keyPressEvent().

{
    // ### Merge this function with keyReleaseEvent; they are identical
    // ### (except this comment).
    Q_D(QGraphicsScene);
    QGraphicsItem *item = !d->keyboardGrabberItems.isEmpty() ? d->keyboardGrabberItems.last() : 0;
    if (!item)
        item = focusItem();
    if (item) {
        QGraphicsItem *p = item;
        do {
            // Accept the event by default
            keyEvent->accept();
            // Send it; QGraphicsItem::keyPressEvent ignores it.  If the event
            // is filtered out, stop propagating it.
            if (p->isBlockedByModalPanel())
                break;
            if (!d->sendEvent(p, keyEvent))
                break;
        } while (!keyEvent->isAccepted() && !p->isPanel() && (p = p->parentItem()));
    } else {
        keyEvent->ignore();
    }
}

keyReleaseEvent()

void QGraphicsScene::keyReleaseEvent ( QKeyEvent *  keyEvent )

protectedvirtual

This event handler, for event keyEvent, can be reimplemented in a subclass to receive key release events.

The default implementation forwards the event to current focus item.

See also

QGraphicsItem::keyReleaseEvent(), focusItem()

Reimplemented in QDeclarativeScene.

Definition at line 4144 of file qgraphicsscene.cpp.

Referenced by event(), and QDeclarativeScene::keyReleaseEvent().

{
    // ### Merge this function with keyPressEvent; they are identical (except
    // ### this comment).
    Q_D(QGraphicsScene);
    QGraphicsItem *item = !d->keyboardGrabberItems.isEmpty() ? d->keyboardGrabberItems.last() : 0;
    if (!item)
        item = focusItem();
    if (item) {
        QGraphicsItem *p = item;
        do {
            // Accept the event by default
            keyEvent->accept();
            // Send it; QGraphicsItem::keyPressEvent ignores it.  If the event
            // is filtered out, stop propagating it.
            if (p->isBlockedByModalPanel())
                break;
            if (!d->sendEvent(p, keyEvent))
                break;
        } while (!keyEvent->isAccepted() && !p->isPanel() && (p = p->parentItem()));
    } else {
        keyEvent->ignore();
    }
}

mouseDoubleClickEvent()

void QGraphicsScene::mouseDoubleClickEvent ( QGraphicsSceneMouseEvent *  mouseEvent )

protectedvirtual

This event handler, for event mouseEvent, can be reimplemented in a subclass to receive mouse doubleclick events for the scene.

If someone doubleclicks on the scene, the scene will first receive a mouse press event, followed by a release event (i.e., a click), then a doubleclick event, and finally a release event. If the doubleclick event is delivered to a different item than the one that received the first press and release, it will be delivered as a press event. However, tripleclick events are not delivered as doubleclick events in this case.

The default implementation is similar to mousePressEvent().

See also

QGraphicsItem::mousePressEvent(), QGraphicsItem::mouseMoveEvent(), QGraphicsItem::mouseReleaseEvent(), QGraphicsItem::setAcceptedMouseButtons()

Definition at line 4287 of file qgraphicsscene.cpp.

Referenced by event().

{
    Q_D(QGraphicsScene);
    d->mousePressEventHandler(mouseEvent);
}

mouseGrabberItem()

QGraphicsItem * QGraphicsScene::mouseGrabberItem

(

)

const

Returns the current mouse grabber item, or 0 if no item is currently grabbing the mouse.

The mouse grabber item is the item that receives all mouse events sent to the scene.

An item becomes a mouse grabber when it receives and accepts a mouse press event, and it stays the mouse grabber until either of the following events occur:

• If the item receives a mouse release event when there are no other buttons pressed, it loses the mouse grab.
• If the item becomes invisible (i.e., someone calls {item->setVisible(false)}), or if it becomes disabled (i.e., someone calls {item->setEnabled(false)}), it loses the mouse grab.
• If the item is removed from the scene, it loses the mouse grab.

If the item loses its mouse grab, the scene will ignore all mouse events until a new item grabs the mouse (i.e., until a new item receives a mouse press event).

Definition at line 3242 of file qgraphicsscene.cpp.

Referenced by QDeclarativeMouseArea::mouseReleaseEvent(), QDeclarativePinchArea::mouseReleaseEvent(), QDeclarativePathView::sendMouseEvent(), QDeclarativeMouseArea::sendMouseEvent(), QDeclarativeFlickable::sendMouseEvent(), QDeclarativePinchArea::sendMouseEvent(), QGraphicsItem::setAcceptedMouseButtons(), QGraphicsItemPrivate::setEnabledHelper(), QDeclarativeFlickable::timerEvent(), and QDeclarativePinchArea::updatePinch().

{
    Q_D(const QGraphicsScene);
    return !d->mouseGrabberItems.isEmpty() ? d->mouseGrabberItems.last() : 0;
}

mouseMoveEvent()

void QGraphicsScene::mouseMoveEvent ( QGraphicsSceneMouseEvent *  mouseEvent )

protectedvirtual

This event handler, for event mouseEvent, can be reimplemented in a subclass to receive mouse move events for the scene.

The default implementation depends on the mouse grabber state. If there is a mouse grabber item, the event is sent to the mouse grabber. If there are any items that accept hover events at the current position, the event is translated into a hover event and accepted; otherwise it's ignored.

See also

QGraphicsItem::mousePressEvent(), QGraphicsItem::mouseReleaseEvent(), QGraphicsItem::mouseDoubleClickEvent(), QGraphicsItem::setAcceptedMouseButtons()

Reimplemented in QDeclarativeScene.

Definition at line 4211 of file qgraphicsscene.cpp.

Referenced by event(), and QDeclarativeScene::mouseMoveEvent().

{
    Q_D(QGraphicsScene);
    if (d->mouseGrabberItems.isEmpty()) {
        if (mouseEvent->buttons())
            return;
        QGraphicsSceneHoverEvent hover;
        _q_hoverFromMouseEvent(&hover, mouseEvent);
        mouseEvent->setAccepted(d->dispatchHoverEvent(&hover));
        return;
    }

    // Forward the event to the mouse grabber
    d->sendMouseEvent(mouseEvent);
    mouseEvent->accept();
}

mousePressEvent()

void QGraphicsScene::mousePressEvent ( QGraphicsSceneMouseEvent *  mouseEvent )

protectedvirtual

This event handler, for event mouseEvent, can be reimplemented in a subclass to receive mouse press events for the scene.

The default implementation depends on the state of the scene. If there is a mouse grabber item, then the event is sent to the mouse grabber. Otherwise, it is forwarded to the topmost item that accepts mouse events at the scene position from the event, and that item promptly becomes the mouse grabber item.

If there is no item at the given position on the scene, the selection area is reset, any focus item loses its input focus, and the event is then ignored.

See also

QGraphicsItem::mousePressEvent(), QGraphicsItem::setAcceptedMouseButtons()

Reimplemented in QDeclarativeScene.

Definition at line 4186 of file qgraphicsscene.cpp.

Referenced by event(), and QDeclarativeScene::mousePressEvent().

{
    Q_D(QGraphicsScene);
    if (d->mouseGrabberItems.isEmpty()) {
        // Dispatch hover events
        QGraphicsSceneHoverEvent hover;
        _q_hoverFromMouseEvent(&hover, mouseEvent);
        d->dispatchHoverEvent(&hover);
    }

    d->mousePressEventHandler(mouseEvent);
}

mouseReleaseEvent()

void QGraphicsScene::mouseReleaseEvent ( QGraphicsSceneMouseEvent *  mouseEvent )

protectedvirtual

This event handler, for event mouseEvent, can be reimplemented in a subclass to receive mouse release events for the scene.

The default implementation depends on the mouse grabber state. If there is no mouse grabber, the event is ignored. Otherwise, if there is a mouse grabber item, the event is sent to the mouse grabber. If this mouse release represents the last pressed button on the mouse, the mouse grabber item then loses the mouse grab.

See also

QGraphicsItem::mousePressEvent(), QGraphicsItem::mouseMoveEvent(), QGraphicsItem::mouseDoubleClickEvent(), QGraphicsItem::setAcceptedMouseButtons()

Reimplemented in QDeclarativeScene.

Definition at line 4241 of file qgraphicsscene.cpp.

Referenced by event(), and QDeclarativeScene::mouseReleaseEvent().

{
    Q_D(QGraphicsScene);
    if (d->mouseGrabberItems.isEmpty()) {
        mouseEvent->ignore();
        return;
    }

    // Forward the event to the mouse grabber
    d->sendMouseEvent(mouseEvent);
    mouseEvent->accept();

    // Reset the mouse grabber when the last mouse button has been released.
    if (!mouseEvent->buttons()) {
        if (!d->mouseGrabberItems.isEmpty()) {
            d->lastMouseGrabberItem = d->mouseGrabberItems.last();
            if (d->lastMouseGrabberItemHasImplicitMouseGrab)
                d->mouseGrabberItems.last()->ungrabMouse();
        } else {
            d->lastMouseGrabberItem = 0;
        }

        // Generate a hoverevent
        QGraphicsSceneHoverEvent hoverEvent;
        _q_hoverFromMouseEvent(&hoverEvent, mouseEvent);
        d->dispatchHoverEvent(&hoverEvent);
    }
}

palette()

QPalette QGraphicsScene::palette

(

)

const

Referenced by setFont().

removeItem()

void QGraphicsScene::removeItem

(

QGraphicsItem *

item

)

Removes the item item and all its children from the scene.

The ownership of item is passed on to the caller (i.e., QGraphicsScene will no longer delete item when destroyed).

See also

addItem()

Definition at line 3062 of file qgraphicsscene.cpp.

Referenced by QmlJSDebugger::LiveSelectionIndicator::clear(), QDeclarativeLoaderPrivate::clear(), QDeclarativeFlickablePrivate::data_clear(), destroyItemGroup(), QDeclarativeVisualItemModel::release(), QDeclarativeVisualDataModel::release(), QGraphicsItem::removeFromIndex(), QGraphicsScenePrivate::removeItemHelper(), QDeclarativeGridView::setFooter(), QDeclarativeListView::setFooter(), QDeclarativeGridView::setHeader(), QDeclarativeListView::setHeader(), QGraphicsProxyWidgetPrivate::unembedSubWindow(), and QmlJSDebugger::LiveSelectionRectangle::~LiveSelectionRectangle().

{
    // ### Refactoring: This function shares much functionality with _q_removeItemLater()
    Q_D(QGraphicsScene);
    if (!item) {
        qWarning("QGraphicsScene::removeItem: cannot remove 0-item");
        return;
    }
    if (item->scene() != this) {
        qWarning("QGraphicsScene::removeItem: item %p's scene (%p)"
                 " is different from this scene (%p)",
                 item, item->scene(), this);
        return;
    }

    // Notify the item that it's scene is changing to 0, allowing the item to
    // react.
    const QVariant newSceneVariant(item->itemChange(QGraphicsItem::ItemSceneChange,
                                                    QVariant::fromValue<QGraphicsScene *>(0)));
    QGraphicsScene *targetScene = qvariant_cast<QGraphicsScene *>(newSceneVariant);
    if (targetScene != 0 && targetScene != this) {
        targetScene->addItem(item);
        return;
    }

    d->removeItemHelper(item);

    // Deliver post-change notification
    item->itemChange(QGraphicsItem::ItemSceneHasChanged, newSceneVariant);

    d->updateInputMethodSensitivityInViews();
}

render()

void QGraphicsScene::render	(	QPainter *	painter,
		const QRectF &	target = QRectF(),
		const QRectF &	source = QRectF(),
		Qt::AspectRatioMode	aspectRatioMode = Qt::KeepAspectRatio
	)

Renders the source rect from scene into target, using painter.

This function is useful for capturing the contents of the scene onto a paint device, such as a QImage (e.g., to take a screenshot), or for printing with QPrinter. For example:

QGraphicsScene scene;
scene.addItem(...
...
QPrinter printer(QPrinter::HighResolution);
printer.setPaperSize(QPrinter::A4);

QPainter painter(&printer);
scene.render(&painter);

If source is a null rect, this function will use sceneRect() to determine what to render. If target is a null rect, the dimensions of painter's paint device will be used.

The source rect contents will be transformed according to aspectRatioMode to fit into the target rect. By default, the aspect ratio is kept, and source is scaled to fit in target.

See also

QGraphicsView::render()

Definition at line 1779 of file qgraphicsscene.cpp.

{
    // ### Switch to using the recursive rendering algorithm instead.

    // Default source rect = scene rect
    QRectF sourceRect = source;
    if (sourceRect.isNull())
        sourceRect = sceneRect();

    // Default target rect = device rect
    QRectF targetRect = target;
    if (targetRect.isNull()) {
        if (painter->device()->devType() == QInternal::Picture)
            targetRect = sourceRect;
        else
            targetRect.setRect(0, 0, painter->device()->width(), painter->device()->height());
    }

    // Find the ideal x / y scaling ratio to fit \a source into \a target.
    qreal xratio = targetRect.width() / sourceRect.width();
    qreal yratio = targetRect.height() / sourceRect.height();

    // Scale according to the aspect ratio mode.
    switch (aspectRatioMode) {
    case Qt::KeepAspectRatio:
        xratio = yratio = qMin(xratio, yratio);
        break;
    case Qt::KeepAspectRatioByExpanding:
        xratio = yratio = qMax(xratio, yratio);
        break;
    case Qt::IgnoreAspectRatio:
        break;
    }

    // Find all items to draw, and reverse the list (we want to draw
    // in reverse order).
    QList<QGraphicsItem *> itemList = items(sourceRect, Qt::IntersectsItemBoundingRect);
    QGraphicsItem **itemArray = new QGraphicsItem *[itemList.size()];
    int numItems = itemList.size();
    for (int i = 0; i < numItems; ++i)
        itemArray[numItems - i - 1] = itemList.at(i);
    itemList.clear();

    painter->save();

    // Transform the painter.
    painter->setClipRect(targetRect, Qt::IntersectClip);
    QTransform painterTransform;
    painterTransform *= QTransform()
                        .translate(targetRect.left(), targetRect.top())
                        .scale(xratio, yratio)
                        .translate(-sourceRect.left(), -sourceRect.top());
    painter->setWorldTransform(painterTransform, true);

    // Two unit vectors.
    QLineF v1(0, 0, 1, 0);
    QLineF v2(0, 0, 0, 1);

    // Generate the style options
    QStyleOptionGraphicsItem *styleOptionArray = new QStyleOptionGraphicsItem[numItems];
    for (int i = 0; i < numItems; ++i)
        itemArray[i]->d_ptr->initStyleOption(&styleOptionArray[i], painterTransform, targetRect.toRect());

    // Render the scene.
    drawBackground(painter, sourceRect);
    drawItems(painter, numItems, itemArray, styleOptionArray);
    drawForeground(painter, sourceRect);

    delete [] itemArray;
    delete [] styleOptionArray;

    painter->restore();
}

sceneRect()

QRectF QGraphicsScene::sceneRect

(

)

const

Referenced by render(), and ~QGraphicsScene().

sceneRectChanged

QGraphicsScene::sceneRectChanged ( const QRectF &  rect )

signal

This signal is emitted by QGraphicsScene whenever the scene rect changes.

The rect parameter is the new scene rectangle.

See also

QGraphicsView::updateSceneRect()

Referenced by setSceneRect(), and ~QGraphicsScene().

selectedItems()

QList< QGraphicsItem * > QGraphicsScene::selectedItems

(

)

const

Returns a list of all currently selected items.

The items are returned in no particular order.

See also

setSelectionArea()

Definition at line 2359 of file qgraphicsscene.cpp.

Referenced by QGraphicsItem::mouseMoveEvent(), QGraphicsItem::mouseReleaseEvent(), and selectedItems().

{
    Q_D(const QGraphicsScene);

    // Optimization: Lazily removes items that are not selected.
    QGraphicsScene *that = const_cast<QGraphicsScene *>(this);
    QSet<QGraphicsItem *> actuallySelectedSet;
    foreach (QGraphicsItem *item, that->d_func()->selectedItems) {
        if (item->isSelected())
            actuallySelectedSet << item;
    }

    that->d_func()->selectedItems = actuallySelectedSet;

    return d->selectedItems.values();
}

selectionArea()

QPainterPath QGraphicsScene::selectionArea

(

)

const

Returns the selection area that was previously set with setSelectionArea(), or an empty QPainterPath if no selection area has been set.

See also

setSelectionArea()

Definition at line 2383 of file qgraphicsscene.cpp.

{
    Q_D(const QGraphicsScene);
    return d->selectionArea;
}

selectionChanged

QGraphicsScene::selectionChanged ( )

signal

This signal is emitted by QGraphicsScene whenever the selection changes.

Since

4.3

You can call selectedItems() to get the new list of selected items.

The selection changes whenever an item is selected or unselected, a selection area is set, cleared or otherwise changed, if a preselected item is added to the scene, or if a selected item is removed from the scene.

QGraphicsScene emits this signal only once for group selection operations. For example, if you set a selection area, select or unselect a QGraphicsItemGroup, or if you add or remove from the scene a parent item that contains several selected items, selectionChanged() is emitted only once after the operation has completed (instead of once for each item).

See also

setSelectionArea(), selectedItems(), QGraphicsItem::setSelected()

Referenced by addItem(), clearSelection(), QGraphicsItem::mouseReleaseEvent(), QGraphicsItem::setSelected(), and setSelectionArea().

sendEvent()

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

Sends event event to item item through possible event filters.

Since

4.6

The event is sent only if the item is enabled.

Returns false if the event was filtered or if the item is disabled. Otherwise returns the value that was returned from the event handler.

See also

QGraphicsItem::sceneEvent(), QGraphicsItem::sceneEventFilter()

Definition at line 5922 of file qgraphicsscene.cpp.

Referenced by QGraphicsScenePrivate::cancelGesturesForChildren(), QGraphicsScenePrivate::enterModal(), event(), QGraphicsScenePrivate::gestureEventHandler(), helpEvent(), QGraphicsScenePrivate::leaveModal(), QGraphicsItem::sceneEvent(), QDeclarativeFlickable::sendMouseEvent(), and QGraphicsScenePrivate::sendTouchBeginEvent().

{
    Q_D(QGraphicsScene);
    if (!item) {
        qWarning("QGraphicsScene::sendEvent: cannot send event to a null item");
        return false;
    }
    if (item->scene() != this) {
        qWarning("QGraphicsScene::sendEvent: item %p's scene (%p)"
                 " is different from this scene (%p)",
                 item, item->scene(), this);
        return false;
    }
    return d->sendEvent(item, event);
}

setActivePanel()

void QGraphicsScene::setActivePanel

(

QGraphicsItem *

item

)

Activates item, which must be an item in this scene.

Since

4.6 You can also pass 0 for item, in which case QGraphicsScene will deactivate any currently active panel.

If the scene is currently inactive, item remains inactive until the scene becomes active (or, ir item is 0, no item will be activated).

See also

activePanel(), isActive(), QGraphicsItem::isActive()

Definition at line 5838 of file qgraphicsscene.cpp.

Referenced by addItem(), QGraphicsItem::setActive(), setActiveWindow(), and QGraphicsItemPrivate::setVisibleHelper().

{
    Q_D(QGraphicsScene);
    d->setActivePanelHelper(item, false);
}

setActiveWindow()

void QGraphicsScene::setActiveWindow

(

QGraphicsWidget *

widget

)

Activates widget, which must be a widget in this scene.

Since

4.4 You can also pass 0 for widget, in which case QGraphicsScene will deactivate any currently active window.

See also

activeWindow(), QGraphicsWidget::isActiveWindow()

Definition at line 5874 of file qgraphicsscene.cpp.

{
    if (widget && widget->scene() != this) {
        qWarning("QGraphicsScene::setActiveWindow: widget %p must be part of this scene",
                 widget);
        return;
    }

    // Activate the widget's panel (all windows are panels).
    QGraphicsItem *panel = widget ? widget->panel() : 0;
    setActivePanel(panel);

    // Raise
    if (panel) {
        QList<QGraphicsItem *> siblingWindows;
        QGraphicsItem *parent = panel->parentItem();
        // Raise ### inefficient for toplevels
        foreach (QGraphicsItem *sibling, parent ? parent->children() : items()) {
            if (sibling != panel && sibling->isWindow())
                siblingWindows << sibling;
        }

        // Find the highest z value.
        qreal z = panel->zValue();
        for (int i = 0; i < siblingWindows.size(); ++i)
            z = qMax(z, siblingWindows.at(i)->zValue());

        // This will probably never overflow.
        const qreal litt = qreal(0.001);
        panel->setZValue(z + litt);
    }
}

setBackgroundBrush()

void QGraphicsScene::setBackgroundBrush

(

const QBrush &

brush

)

Definition at line 3272 of file qgraphicsscene.cpp.

{
    Q_D(QGraphicsScene);
    d->backgroundBrush = brush;
    foreach (QGraphicsView *view, d->views) {
        view->resetCachedContent();
        view->viewport()->update();
    }
    update();
}

setBspTreeDepth()

void QGraphicsScene::setBspTreeDepth

(

int

depth

)

Definition at line 1937 of file qgraphicsscene.cpp.

{
    Q_D(QGraphicsScene);
    if (depth < 0) {
        qWarning("QGraphicsScene::setBspTreeDepth: invalid depth %d ignored; must be >= 0", depth);
        return;
    }

    QGraphicsSceneBspTreeIndex *bspTree = qobject_cast<QGraphicsSceneBspTreeIndex *>(d->index);
    if (!bspTree) {
        qWarning("QGraphicsScene::setBspTreeDepth: can not apply if indexing method is not BSP");
        return;
    }
    bspTree->setBspTreeDepth(depth);
}

setFocus()

void QGraphicsScene::setFocus

(

Qt::FocusReason

focusReason = Qt::OtherFocusReason

)

Sets focus on the scene by sending a QFocusEvent to the scene, passing focusReason as the reason.

If the scene regains focus after having previously lost it while an item had focus, the last focus item will receive focus with focusReason as the reason.

If the scene already has focus, this function does nothing.

See also

hasFocus(), clearFocus(), setFocusItem()

Definition at line 3160 of file qgraphicsscene.cpp.

Referenced by QGraphicsScenePrivate::sendTouchBeginEvent().

{
    Q_D(QGraphicsScene);
    if (d->hasFocus || !isActive())
        return;
    QFocusEvent event(QEvent::FocusIn, focusReason);
    QCoreApplication::sendEvent(this, &event);
}

setFocusItem()

void QGraphicsScene::setFocusItem	(	QGraphicsItem *	item,
		Qt::FocusReason	focusReason = Qt::OtherFocusReason
	)

Sets the scene's focus item to item, with the focus reason focusReason, after removing focus from any previous item that may have had focus.

If item is 0, or if it either does not accept focus (i.e., it does not have the QGraphicsItem::ItemIsFocusable flag enabled), or is not visible or not enabled, this function only removes focus from any previous focusitem.

If item is not 0, and the scene does not currently have focus (i.e., hasFocus() returns false), this function will call setFocus() automatically.

See also

focusItem(), hasFocus(), setFocus()

Definition at line 3128 of file qgraphicsscene.cpp.

Referenced by clearFocus(), QGraphicsItemPrivate::clearFocusHelper(), focusInEvent(), focusNextPrevChild(), focusOutEvent(), QGraphicsItemPrivate::setVisibleHelper(), and wheelEvent().

{
    Q_D(QGraphicsScene);
    if (item)
        item->setFocus(focusReason);
    else
        d->setFocusItemHelper(item, focusReason);
}

setFont()

void QGraphicsScene::setFont

(

const QFont &

font

)

Definition at line 5743 of file qgraphicsscene.cpp.

{
    Q_D(QGraphicsScene);
    QFont naturalFont = QApplication::font();
    naturalFont.resolve(0);
    QFont resolvedFont = font.resolve(naturalFont);
    d->setFont_helper(resolvedFont);
}

setForegroundBrush()

void QGraphicsScene::setForegroundBrush

(

const QBrush &

brush

)

Definition at line 3311 of file qgraphicsscene.cpp.

{
    Q_D(QGraphicsScene);
    d->foregroundBrush = brush;
    foreach (QGraphicsView *view, views())
        view->viewport()->update();
    update();
}

setItemIndexMethod()

void QGraphicsScene::setItemIndexMethod

(

ItemIndexMethod

method

)

Definition at line 1878 of file qgraphicsscene.cpp.

{
    Q_D(QGraphicsScene);
    if (d->indexMethod == method)
        return;

    d->indexMethod = method;

    QList<QGraphicsItem *> oldItems = d->index->items(Qt::DescendingOrder);
    delete d->index;
    if (method == BspTreeIndex)
        d->index = new QGraphicsSceneBspTreeIndex(this);
    else
        d->index = new QGraphicsSceneLinearIndex(this);
    for (int i = oldItems.size() - 1; i >= 0; --i)
        d->index->addItem(oldItems.at(i));
}

setPalette()

void QGraphicsScene::setPalette

(

const QPalette &

palette

)

Definition at line 5783 of file qgraphicsscene.cpp.

{
    Q_D(QGraphicsScene);
    QPalette naturalPalette = QApplication::palette();
    naturalPalette.resolve(0);
    QPalette resolvedPalette = palette.resolve(naturalPalette);
    d->setPalette_helper(resolvedPalette);
}

setSceneRect() [1/2]

void QGraphicsScene::setSceneRect

(

const QRectF &

rect

)

Definition at line 1729 of file qgraphicsscene.cpp.

Referenced by QGraphicsScene().

{
    Q_D(QGraphicsScene);
    if (rect != d->sceneRect) {
        d->hasSceneRect = !rect.isNull();
        d->sceneRect = rect;
        emit sceneRectChanged(d->hasSceneRect ? rect : d->growingItemsBoundingRect);
    }
}

setSceneRect() [2/2]

void QGraphicsScene::setSceneRect ( qreal  x, qreal  y, qreal  w, qreal  h  )

inline

Definition at line 137 of file qgraphicsscene.h.

    { setSceneRect(QRectF(x, y, w, h)); }

setSelectionArea() [1/4]

void QGraphicsScene::setSelectionArea

(

const QPainterPath &

path

)

Sets the selection area to path.

This function is deprecated and leads to incorrect results if the scene contains items that ignore transformations. Use the overload that takes a QTransform instead.

Definition at line 2425 of file qgraphicsscene.cpp.

Referenced by setSelectionArea().

{
    setSelectionArea(path, Qt::IntersectsItemShape, QTransform());
}

setSelectionArea() [2/4]

void QGraphicsScene::setSelectionArea	(	const QPainterPath &	path,
		const QTransform &	deviceTransform
	)

Sets the selection area to path.

Since

4.6

All items within this area are immediately selected, and all items outside are unselected. You can get the list of all selected items by calling selectedItems().

deviceTransform is the transformation that applies to the view, and needs to be provided if the scene contains items that ignore transformations.

For an item to be selected, it must be marked as selectable (QGraphicsItem::ItemIsSelectable).

See also

clearSelection(), selectionArea()

Definition at line 2407 of file qgraphicsscene.cpp.

{
    setSelectionArea(path, Qt::IntersectsItemShape, deviceTransform);
}

setSelectionArea() [3/4]

void QGraphicsScene::setSelectionArea	(	const QPainterPath &	path,
		Qt::ItemSelectionMode	mode
	)

Sets the selection area to path using mode to determine if items are included in the selection area.

Since

4.3

See also

clearSelection(), selectionArea()

Definition at line 2443 of file qgraphicsscene.cpp.

{
    setSelectionArea(path, mode, QTransform());
}

setSelectionArea() [4/4]

void QGraphicsScene::setSelectionArea	(	const QPainterPath &	path,
		Qt::ItemSelectionMode	mode,
		const QTransform &	deviceTransform
	)

Sets the selection area to path using mode to determine if items are included in the selection area.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Since

4.6

deviceTransform is the transformation that applies to the view, and needs to be provided if the scene contains items that ignore transformations.

See also

clearSelection(), selectionArea()

Definition at line 2463 of file qgraphicsscene.cpp.

{
    Q_D(QGraphicsScene);

    // Note: with boolean path operations, we can improve performance here
    // quite a lot by "growing" the old path instead of replacing it. That
    // allows us to only check the intersect area for changes, instead of
    // reevaluating the whole path over again.
    d->selectionArea = path;

    QSet<QGraphicsItem *> unselectItems = d->selectedItems;

    // Disable emitting selectionChanged() for individual items.
    ++d->selectionChanging;
    bool changed = false;

    // Set all items in path to selected.
    foreach (QGraphicsItem *item, items(path, mode, Qt::DescendingOrder, deviceTransform)) {
        if (item->flags() & QGraphicsItem::ItemIsSelectable) {
            if (!item->isSelected())
                changed = true;
            unselectItems.remove(item);
            item->setSelected(true);
        }
    }

    // Unselect all items outside path.
    foreach (QGraphicsItem *item, unselectItems) {
        item->setSelected(false);
        changed = true;
    }

    // Reenable emitting selectionChanged() for individual items.
    --d->selectionChanging;

    if (!d->selectionChanging && changed)
        emit selectionChanged();
}

setSortCacheEnabled()

void QGraphicsScene::setSortCacheEnabled

(

bool

enabled

)

Definition at line 1969 of file qgraphicsscene.cpp.

{
    Q_D(QGraphicsScene);
    if (d->sortCacheEnabled == enabled)
        return;
    d->sortCacheEnabled = enabled;
}

setStickyFocus()

void QGraphicsScene::setStickyFocus

(

bool

enabled

)

Definition at line 3209 of file qgraphicsscene.cpp.

{
    Q_D(QGraphicsScene);
    d->stickyFocus = enabled;
}

setStyle()

void QGraphicsScene::setStyle

(

QStyle *

style

)

Sets or replaces the style of the scene to style, and reparents the style to this scene.

Since

4.4

Any previously assigned style is deleted. The scene's style defaults to QApplication::style(), and serves as the default for all QGraphicsWidget items in the scene.

Changing the style, either directly by calling this function, or indirectly by calling QApplication::setStyle(), will automatically update the style for all widgets in the scene that do not have a style explicitly assigned to them.

If style is 0, QGraphicsScene will revert to QApplication::style().

See also

style()

Definition at line 5686 of file qgraphicsscene.cpp.

{
    Q_D(QGraphicsScene);
    // ### This function, and the use of styles in general, is non-reentrant.
    if (style == d->style)
        return;

    // Delete the old style,
    delete d->style;
    if ((d->style = style))
        d->style->setParent(this);

    // Notify the scene.
    QEvent event(QEvent::StyleChange);
    QApplication::sendEvent(this, &event);

    // Notify all widgets that don't have a style explicitly set.
    foreach (QGraphicsItem *item, items()) {
        if (item->isWidget()) {
            QGraphicsWidget *widget = static_cast<QGraphicsWidget *>(item);
            if (!widget->testAttribute(Qt::WA_SetStyle))
                QApplication::sendEvent(widget, &event);
        }
    }
}

stickyFocus()

bool QGraphicsScene::stickyFocus

(

)

const

Referenced by QGraphicsScenePrivate::sendTouchBeginEvent(), and setStickyFocus().

style()

QStyle * QGraphicsScene::style

(

)

const

Returns the scene's style, or the same as QApplication::style() if the scene has not been explicitly assigned a style.

Since

4.4

See also

setStyle()

Definition at line 5659 of file qgraphicsscene.cpp.

Referenced by QGraphicsWidget::style().

{
    Q_D(const QGraphicsScene);
    // ### This function, and the use of styles in general, is non-reentrant.
    return d->style ? d->style : QApplication::style();
}

update() [1/2]

void QGraphicsScene::update ( qreal  x, qreal  y, qreal  w, qreal  h  )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Since

4.3

This function is equivalent to calling update(QRectF(x, y, w, h));

Definition at line 232 of file qgraphicsscene.h.

Referenced by event(), invalidate(), QDeclarativeView::paintEvent(), QGraphicsItem::prepareGeometryChange(), setBackgroundBrush(), and setForegroundBrush().

    { update(QRectF(x, y, w, h)); }

update [2/2]

void QGraphicsScene::update ( const QRectF &  rect = QRectF() )

slot

Schedules a redraw of the area rect on the scene.

See also

sceneRect(), changed()

Definition at line 3356 of file qgraphicsscene.cpp.

{
    Q_D(QGraphicsScene);
    if (d->updateAll || (rect.isEmpty() && !rect.isNull()))
        return;

    // Check if anyone's connected; if not, we can send updates directly to
    // the views. Otherwise or if there are no views, use old behavior.
    bool directUpdates = !(d->isSignalConnected(d->changedSignalIndex)) && !d->views.isEmpty();
    if (rect.isNull()) {
        d->updateAll = true;
        d->updatedRects.clear();
        if (directUpdates) {
            // Update all views.
            for (int i = 0; i < d->views.size(); ++i)
                d->views.at(i)->d_func()->fullUpdatePending = true;
        }
    } else {
        if (directUpdates) {
            // Update all views.
            for (int i = 0; i < d->views.size(); ++i) {
                QGraphicsView *view = d->views.at(i);
                if (view->isTransformed())
                    view->d_func()->updateRectF(view->viewportTransform().mapRect(rect));
                else
                    view->d_func()->updateRectF(rect);
            }
        } else {
            d->updatedRects << rect;
        }
    }

    if (!d->calledEmitUpdated) {
        d->calledEmitUpdated = true;
        QMetaObject::invokeMethod(this, "_q_emitUpdated", Qt::QueuedConnection);
    }
}

views()

QList< QGraphicsView * > QGraphicsScene::views

(

)

const

Returns a list of all the views that display this scene.

See also

QGraphicsView::scene()

Definition at line 3445 of file qgraphicsscene.cpp.

Referenced by QGraphicsScenePrivate::addView(), ShaderEffectItem::checkViewportUpdateMode(), QShortcutMap::correctGraphicsWidgetContext(), QGraphicsItemPrivate::effectiveBoundingRect(), QGraphicsScenePrivate::enableTouchEventsOnViews(), QGraphicsItem::ensureVisible(), invalidate(), QGraphicsScenePrivate::markDirty(), QGraphicsScenePrivate::processDirtyItemsRecursive(), QGraphicsScenePrivate::removeView(), QWidgetPrivate::screenGeometry(), QGraphicsItem::setCursor(), setForegroundBrush(), QGraphicsItem::setInputMethodHints(), QGraphicsScenePrivate::ungrabGesture(), QGraphicsItem::unsetCursor(), QGraphicsScenePrivate::updateInputMethodSensitivityInViews(), QGraphicsItem::updateMicroFocus(), and QGraphicsItemPrivate::updatePaintedViewBoundingRects().

{
    Q_D(const QGraphicsScene);
    return d->views;
}

wheelEvent()

void QGraphicsScene::wheelEvent ( QGraphicsSceneWheelEvent *  wheelEvent )

protectedvirtual

This event handler, for event wheelEvent, can be reimplemented in a subclass to receive mouse wheel events for the scene.

By default, the event is delivered to the topmost visible item under the cursor. If ignored, the event propagates to the item beneath, and again until the event is accepted, or it reaches the scene. If no items accept the event, it is ignored.

See also

QGraphicsItem::wheelEvent()

Definition at line 4304 of file qgraphicsscene.cpp.

Referenced by event().

{
    Q_D(QGraphicsScene);
    QList<QGraphicsItem *> wheelCandidates = d->itemsAtPosition(wheelEvent->screenPos(),
                                                                wheelEvent->scenePos(),
                                                                wheelEvent->widget());

#ifdef Q_WS_MAC
    // On Mac, ignore the event if the first item under the mouse is not the last opened
    // popup (or one of its descendant)
    if (!d->popupWidgets.isEmpty() && !wheelCandidates.isEmpty() && wheelCandidates.first() != d->popupWidgets.back() && !d->popupWidgets.back()->isAncestorOf(wheelCandidates.first())) {
        wheelEvent->accept();
        return;
    }
#else
    // Find the first popup under the mouse (including the popup's descendants) starting from the last.
    // Remove all popups after the one found, or all or them if no popup is under the mouse.
    // Then continue with the event.
    QList<QGraphicsWidget *>::const_iterator iter = d->popupWidgets.end();
    while (--iter >= d->popupWidgets.begin() && !wheelCandidates.isEmpty()) {
        if (wheelCandidates.first() == *iter || (*iter)->isAncestorOf(wheelCandidates.first()))
            break;
        d->removePopup(*iter);
    }
#endif

    bool hasSetFocus = false;
    foreach (QGraphicsItem *item, wheelCandidates) {
        if (!hasSetFocus && item->isEnabled()
            && ((item->flags() & QGraphicsItem::ItemIsFocusable) && item->d_ptr->mouseSetsFocus)) {
            if (item->isWidget() && static_cast<QGraphicsWidget *>(item)->focusPolicy() == Qt::WheelFocus) {
                hasSetFocus = true;
                if (item != focusItem())
                    setFocusItem(item, Qt::MouseFocusReason);
            }
        }

        wheelEvent->setPos(item->d_ptr->genericMapFromScene(wheelEvent->scenePos(),
                                                            wheelEvent->widget()));
        wheelEvent->accept();
        bool isPanel = item->isPanel();
        d->sendEvent(item, wheelEvent);
        if (isPanel || wheelEvent->isAccepted())
            break;
    }
}

width()

qreal QGraphicsScene::width ( ) const

inline

This convenience function is equivalent to calling sceneRect().

width().

 \sa height()

Definition at line 134 of file qgraphicsscene.h.

{ return sceneRect().width(); }

Friends and Related Functions

QGesture

friend class QGesture

friend

Definition at line 317 of file qgraphicsscene.h.

QGraphicsEffect

friend class QGraphicsEffect

friend

Definition at line 310 of file qgraphicsscene.h.

QGraphicsItem

friend class QGraphicsItem

friend

Definition at line 303 of file qgraphicsscene.h.

QGraphicsItemEffectSourcePrivate

friend class QGraphicsItemEffectSourcePrivate

friend

Definition at line 315 of file qgraphicsscene.h.

QGraphicsItemPrivate

friend class QGraphicsItemPrivate

friend

Definition at line 304 of file qgraphicsscene.h.

QGraphicsObject

friend class QGraphicsObject

friend

Definition at line 305 of file qgraphicsscene.h.

QGraphicsSceneBspTreeIndex

friend class QGraphicsSceneBspTreeIndex

friend

Definition at line 313 of file qgraphicsscene.h.

Referenced by setItemIndexMethod().

QGraphicsSceneBspTreeIndexPrivate

friend class QGraphicsSceneBspTreeIndexPrivate

friend

Definition at line 314 of file qgraphicsscene.h.

QGraphicsSceneIndex

friend class QGraphicsSceneIndex

friend

Definition at line 311 of file qgraphicsscene.h.

QGraphicsSceneIndexPrivate

friend class QGraphicsSceneIndexPrivate

friend

Definition at line 312 of file qgraphicsscene.h.

QGraphicsView

friend class QGraphicsView

friend

Definition at line 306 of file qgraphicsscene.h.

QGraphicsViewPrivate

friend class QGraphicsViewPrivate

friend

Definition at line 307 of file qgraphicsscene.h.

QGraphicsWidget

friend class QGraphicsWidget

friend

Definition at line 308 of file qgraphicsscene.h.

QGraphicsWidgetPrivate

friend class QGraphicsWidgetPrivate

friend

Definition at line 309 of file qgraphicsscene.h.

Properties

backgroundBrush

QBrush QGraphicsScene::backgroundBrush

private

the background brush of the scene.

Set this property to changes the scene's background to a different color, gradient or texture. The default background brush is Qt::NoBrush. The background is drawn before (behind) the items.

Example:

QGraphicsScene scene;
QGraphicsView view(&scene);
view.show();

// a blue background
scene.setBackgroundBrush(Qt::blue);

// a gradient background
QRadialGradient gradient(0, 0, 10);
gradient.setSpread(QGradient::RepeatSpread);
scene.setBackgroundBrush(gradient);

QGraphicsScene::render() calls drawBackground() to draw the scene background. For more detailed control over how the background is drawn, you can reimplement drawBackground() in a subclass of QGraphicsScene.

Definition at line 104 of file qgraphicsscene.h.

bspTreeDepth

int QGraphicsScene::bspTreeDepth

private

the depth of QGraphicsScene's BSP index tree

Since

4.3

This property has no effect when NoIndex is used.

This value determines the depth of QGraphicsScene's BSP tree. The depth directly affects QGraphicsScene's performance and memory usage; the latter growing exponentially with the depth of the tree. With an optimal tree depth, QGraphicsScene can instantly determine the locality of items, even for scenes with thousands or millions of items. This also greatly improves rendering performance.

By default, the value is 0, in which case Qt will guess a reasonable default depth based on the size, location and number of items in the scene. If these parameters change frequently, however, you may experience slowdowns as QGraphicsScene retunes the depth internally. You can avoid potential slowdowns by fixating the tree depth through setting this property.

The depth of the tree and the size of the scene rectangle decide the granularity of the scene's partitioning. The size of each scene segment is determined by the following algorithm:

QSizeF segmentSize = sceneRect().size() / pow(2, depth - 1);

The BSP tree has an optimal size when each segment contains between 0 and 10 items.

See also

itemIndexMethod

Definition at line 108 of file qgraphicsscene.h.

font

QFont QGraphicsScene::font

private

the scene's default font

Since

4.4

This property provides the scene's font. The scene font defaults to, and resolves all its entries from, QApplication::font.

If the scene's font changes, either directly through setFont() or indirectly when the application font changes, QGraphicsScene first sends itself a FontChange event, and it then sends FontChange events to all top-level widget items in the scene. These items respond by resolving their own fonts to the scene, and they then notify their children, who again notify their children, and so on, until all widget items have updated their fonts.

Changing the scene font, (directly or indirectly through QApplication::setFont(),) automatically schedules a redraw the entire scene.

See also

QWidget::font, QApplication::setFont(), palette, style()

Definition at line 110 of file qgraphicsscene.h.

Referenced by QGraphicsWidgetPrivate::naturalWidgetFont().

foregroundBrush

QBrush QGraphicsScene::foregroundBrush

private

the foreground brush of the scene.

Change this property to set the scene's foreground to a different color, gradient or texture.

The foreground is drawn after (on top of) the items. The default foreground brush is Qt::NoBrush ( i.e. the foreground is not drawn).

Example:

QGraphicsScene scene;
QGraphicsView view(&scene);
view.show();

// a white semi-transparent foreground
scene.setForegroundBrush(QColor(255, 255, 255, 127));

// a grid foreground
scene.setForegroundBrush(QBrush(Qt::lightGray, Qt::CrossPattern));

QGraphicsScene::render() calls drawForeground() to draw the scene foreground. For more detailed control over how the foreground is drawn, you can reimplement the drawForeground() function in a QGraphicsScene subclass.

Definition at line 105 of file qgraphicsscene.h.

itemIndexMethod

QGraphicsScene::ItemIndexMethod QGraphicsScene::itemIndexMethod

private

the item indexing method.

QGraphicsScene applies an indexing algorithm to the scene, to speed up item discovery functions like items() and itemAt(). Indexing is most efficient for static scenes (i.e., where items don't move around). For dynamic scenes, or scenes with many animated items, the index bookkeeping can outweight the fast lookup speeds.

For the common case, the default index method BspTreeIndex works fine. If your scene uses many animations and you are experiencing slowness, you can disable indexing by calling setItemIndexMethod(NoIndex).

See also

bspTreeDepth

Definition at line 106 of file qgraphicsscene.h.

palette

QPalette QGraphicsScene::palette

private

the scene's default palette

Since

4.4

This property provides the scene's palette. The scene palette defaults to, and resolves all its entries from, QApplication::palette.

If the scene's palette changes, either directly through setPalette() or indirectly when the application palette changes, QGraphicsScene first sends itself a PaletteChange event, and it then sends PaletteChange events to all top-level widget items in the scene. These items respond by resolving their own palettes to the scene, and they then notify their children, who again notify their children, and so on, until all widget items have updated their palettes.

Changing the scene palette, (directly or indirectly through QApplication::setPalette(),) automatically schedules a redraw the entire scene.

See also

QWidget::palette, QApplication::setPalette(), font, style()

Definition at line 109 of file qgraphicsscene.h.

Referenced by QGraphicsWidgetPrivate::naturalWidgetPalette().

sceneRect

QRectF QGraphicsScene::sceneRect

private

the scene rectangle; the bounding rectangle of the scene

The scene rectangle defines the extent of the scene. It is primarily used by QGraphicsView to determine the view's default scrollable area, and by QGraphicsScene to manage item indexing.

If unset, or if set to a null QRectF, sceneRect() will return the largest bounding rect of all items on the scene since the scene was created (i.e., a rectangle that grows when items are added to or moved in the scene, but never shrinks).

See also

width(), height(), QGraphicsView::sceneRect

Definition at line 107 of file qgraphicsscene.h.

Referenced by QGraphicsViewPrivate::findItems(), and QWidgetPrivate::screenGeometry().

sortCacheEnabled

QGraphicsScene::sortCacheEnabled

private

whether sort caching is enabled

Since

4.5

Since Qt 4.6, this property has no effect.

Definition at line 111 of file qgraphicsscene.h.

stickyFocus

bool QGraphicsScene::stickyFocus

private

whether clicking into the scene background will clear focus

Since

4.6

In a QGraphicsScene with stickyFocus set to true, focus will remain unchanged when the user clicks into the scene background or on an item that does not accept focus. Otherwise, focus will be cleared.

By default, this property is false.

Focus changes in response to a mouse press. You can reimplement mousePressEvent() in a subclass of QGraphicsScene to toggle this property based on where the user has clicked.

See also

clearFocus(), setFocusItem()

Definition at line 112 of file qgraphicsscene.h.

---

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

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