QGraphicsScene

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

Inheritance diagram of PySide2.QtWidgets.QGraphicsScene

Synopsis

Functions

Virtual functions

Slots

Signals

Detailed Description

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:

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

view = QGraphicsView(&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 a 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, 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 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 acceptHoverEvents() ), it will receive a GraphicsSceneHoverEnter event when the mouse enters its area. As the mouse continues moving inside the item’s area, QGraphicsScene will send it GraphicsSceneHoverMove events. When the mouse leaves the item’s area, the item will receive a 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 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.

class QGraphicsScene([parent=None])

QGraphicsScene(sceneRect[, parent=None])

QGraphicsScene(x, y, width, height[, parent=None])

param parent

QObject

param x

qreal

param y

qreal

param width

qreal

param sceneRect

QRectF

param height

qreal

Constructs a QGraphicsScene object. The parent parameter is passed to QObject ‘s constructor.

Constructs a QGraphicsScene object, using sceneRect for its scene rectangle. The parent parameter is passed to QObject ‘s constructor.

See also

sceneRect

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

PySide2.QtWidgets.QGraphicsScene.ItemIndexMethod

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

Constant

Description

QGraphicsScene.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).

QGraphicsScene.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.

PySide2.QtWidgets.QGraphicsScene.SceneLayer

This enum describes the rendering layers in a QGraphicsScene . 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 invalidateScene() .

Constant

Description

QGraphicsScene.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.

QGraphicsScene.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.

QGraphicsScene.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.

QGraphicsScene.AllLayers

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

PySide2.QtWidgets.QGraphicsScene.activePanel()
Return type

QGraphicsItem

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

See also

setActivePanel()

PySide2.QtWidgets.QGraphicsScene.activeWindow()
Return type

QGraphicsWidget

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

PySide2.QtWidgets.QGraphicsScene.addEllipse(rect[, pen=QPen()[, brush=QBrush()]])
Parameters
  • rectQRectF

  • penQPen

  • brushQBrush

Return type

QGraphicsEllipseItem

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., isVisible() returns true ), QGraphicsScene will emit changed() once control goes back to the event loop.

PySide2.QtWidgets.QGraphicsScene.addEllipse(x, y, w, h[, pen=QPen()[, brush=QBrush()]])
Parameters
  • xqreal

  • yqreal

  • wqreal

  • hqreal

  • penQPen

  • brushQBrush

Return type

QGraphicsEllipseItem

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

PySide2.QtWidgets.QGraphicsScene.addItem(item)
Parameters

itemQGraphicsItem

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., 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.

PySide2.QtWidgets.QGraphicsScene.addLine(line[, pen=QPen()])
Parameters
  • lineQLineF

  • penQPen

Return type

QGraphicsLineItem

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., isVisible() returns true ), QGraphicsScene will emit changed() once control goes back to the event loop.

PySide2.QtWidgets.QGraphicsScene.addLine(x1, y1, x2, y2[, pen=QPen()])
Parameters
  • x1qreal

  • y1qreal

  • x2qreal

  • y2qreal

  • penQPen

Return type

QGraphicsLineItem

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

PySide2.QtWidgets.QGraphicsScene.addPath(path[, pen=QPen()[, brush=QBrush()]])
Parameters
  • pathQPainterPath

  • penQPen

  • brushQBrush

Return type

QGraphicsPathItem

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., isVisible() returns true ), QGraphicsScene will emit changed() once control goes back to the event loop.

PySide2.QtWidgets.QGraphicsScene.addPixmap(pixmap)
Parameters

pixmapQPixmap

Return type

QGraphicsPixmapItem

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., isVisible() returns true ), QGraphicsScene will emit changed() once control goes back to the event loop.

PySide2.QtWidgets.QGraphicsScene.addPolygon(polygon[, pen=QPen()[, brush=QBrush()]])
Parameters
  • polygonQPolygonF

  • penQPen

  • brushQBrush

Return type

QGraphicsPolygonItem

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., isVisible() returns true ), QGraphicsScene will emit changed() once control goes back to the event loop.

PySide2.QtWidgets.QGraphicsScene.addRect(rect[, pen=QPen()[, brush=QBrush()]])
Parameters
  • rectQRectF

  • penQPen

  • brushQBrush

Return type

QGraphicsRectItem

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 item’s coordinate system.

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

PySide2.QtWidgets.QGraphicsScene.addRect(x, y, w, h[, pen=QPen()[, brush=QBrush()]])
Parameters
  • xqreal

  • yqreal

  • wqreal

  • hqreal

  • penQPen

  • brushQBrush

Return type

QGraphicsRectItem

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

PySide2.QtWidgets.QGraphicsScene.addSimpleText(text[, font=QFont()])
Parameters
  • text – unicode

  • fontQFont

Return type

QGraphicsSimpleTextItem

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., isVisible() returns true ), QGraphicsScene will emit changed() once control goes back to the event loop.

PySide2.QtWidgets.QGraphicsScene.addText(text[, font=QFont()])
Parameters
  • text – unicode

  • fontQFont

Return type

QGraphicsTextItem

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., isVisible() returns true ), QGraphicsScene will emit changed() once control goes back to the event loop.

PySide2.QtWidgets.QGraphicsScene.addWidget(widget[, wFlags=Qt.WindowFlags()])
Parameters
  • widgetQWidget

  • wFlagsWindowFlags

Return type

QGraphicsProxyWidget

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., isVisible() returns true ), QGraphicsScene will emit changed() once control goes back to the event loop.

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

PySide2.QtWidgets.QGraphicsScene.advance()

This slot advances the scene by one step, by calling 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, advance() is called passing a value of 0 as an argument, and 1 is passed in the second phase.

Note that you can also use the Animation Framework for animations.

See also

advance() QTimeLine

PySide2.QtWidgets.QGraphicsScene.backgroundBrush()
Return type

QBrush

PySide2.QtWidgets.QGraphicsScene.bspTreeDepth()
Return type

int

PySide2.QtWidgets.QGraphicsScene.changed(region)
Parameters

region

PySide2.QtWidgets.QGraphicsScene.clear()

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

See also

addItem()

PySide2.QtWidgets.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.

PySide2.QtWidgets.QGraphicsScene.clearSelection()

Clears the current selection.

PySide2.QtWidgets.QGraphicsScene.collidingItems(item[, mode=Qt.IntersectsItemShape])
Parameters
Return type

Returns a list of all items that collide with item . Collisions are determined by calling 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).

PySide2.QtWidgets.QGraphicsScene.contextMenuEvent(event)
Parameters

eventQGraphicsSceneContextMenuEvent

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 visible 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.

Note: See items() for a definition of which items are considered visible by this function.

PySide2.QtWidgets.QGraphicsScene.createItemGroup(items)
Parameters

items

Return type

QGraphicsItemGroup

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() .

PySide2.QtWidgets.QGraphicsScene.destroyItemGroup(group)
Parameters

groupQGraphicsItemGroup

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.

PySide2.QtWidgets.QGraphicsScene.dragEnterEvent(event)
Parameters

eventQGraphicsSceneDragDropEvent

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.

PySide2.QtWidgets.QGraphicsScene.dragLeaveEvent(event)
Parameters

eventQGraphicsSceneDragDropEvent

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

PySide2.QtWidgets.QGraphicsScene.dragMoveEvent(event)
Parameters

eventQGraphicsSceneDragDropEvent

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

Note: See items() for a definition of which items are considered visible by this function.

PySide2.QtWidgets.QGraphicsScene.drawBackground(painter, rect)
Parameters
  • painterQPainter

  • rectQRectF

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()

PySide2.QtWidgets.QGraphicsScene.drawForeground(painter, rect)
Parameters
  • painterQPainter

  • rectQRectF

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()

PySide2.QtWidgets.QGraphicsScene.dropEvent(event)
Parameters

eventQGraphicsSceneDragDropEvent

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

PySide2.QtWidgets.QGraphicsScene.focusInEvent(event)
Parameters

eventQFocusEvent

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

focusOutEvent()

PySide2.QtWidgets.QGraphicsScene.focusItem()
Return type

QGraphicsItem

When the scene is active, this functions returns the scene’s current focus item, or None 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.

PySide2.QtWidgets.QGraphicsScene.focusItemChanged(newFocus, oldFocus, reason)
Parameters
PySide2.QtWidgets.QGraphicsScene.focusNextPrevChild(next)
Parameters

nextbool

Return type

bool

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. 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 setTabOrder() .

PySide2.QtWidgets.QGraphicsScene.focusOnTouch()
Return type

bool

PySide2.QtWidgets.QGraphicsScene.focusOutEvent(event)
Parameters

eventQFocusEvent

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

focusInEvent()

PySide2.QtWidgets.QGraphicsScene.font()
Return type

QFont

See also

setFont()

PySide2.QtWidgets.QGraphicsScene.foregroundBrush()
Return type

QBrush

PySide2.QtWidgets.QGraphicsScene.hasFocus()
Return type

bool

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.

PySide2.QtWidgets.QGraphicsScene.height()
Return type

qreal

This convenience function is equivalent to calling sceneRect().height() .

See also

width()

PySide2.QtWidgets.QGraphicsScene.helpEvent(event)
Parameters

eventQGraphicsSceneHelpEvent

This event handler, for event helpEvent , can be reimplemented in a subclass to receive help events. The events are of type ToolTip , which are created when a tooltip is requested.

The default implementation shows the tooltip of the topmost visible 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.

Note: See items() for a definition of which items are considered visible by this function.

PySide2.QtWidgets.QGraphicsScene.inputMethodEvent(event)
Parameters

eventQInputMethodEvent

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.

PySide2.QtWidgets.QGraphicsScene.inputMethodQuery(query)
Parameters

queryInputMethodQuery

Return type

object

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.

PySide2.QtWidgets.QGraphicsScene.invalidate([rect=QRectF()[, layers=QGraphicsScene.AllLayers]])
Parameters
  • rectQRectF

  • layersSceneLayers

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:

class TileScene (QGraphicsScene):
    # ...
    def rectForTile(x, y):
        # Return the rectangle for the tile at position (x, y).
        return QRectF(x * self.tileWidth, y * self.tileHeight, self.tileWidth, self.tileHeight)

    def setTile(x, y, pixmap):
        # Sets or replaces the tile at position (x, y) with pixmap.
        if x >= 0 && x < self.numTilesH && y >= 0 && y < self.numTilesV:
            self.tiles[y][x] = pixmap
            invalidate(rectForTile(x, y), BackgroundLayer)

    def drawBackground(painter, exposed):
        # Draws all tiles that intersect the exposed area.
        for y in range(0, self.numTilesV:
            for x in range(0, self.numTilesH:
                rect = rectForTile(x, y)
                if exposed.intersects(rect):
                    painter.drawPixmap(rect.topLeft(), tiles[y][x])

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

PySide2.QtWidgets.QGraphicsScene.invalidate(x, y, w, h[, layers=QGraphicsScene.AllLayers])
Parameters
  • xqreal

  • yqreal

  • wqreal

  • hqreal

  • layersSceneLayers

This is an overloaded function.

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

PySide2.QtWidgets.QGraphicsScene.isActive()
Return type

bool

Returns true if the scene is active (e.g., it’s viewed by at least one QGraphicsView that is active); otherwise returns false .

PySide2.QtWidgets.QGraphicsScene.isSortCacheEnabled()
Return type

bool

Note

This function is deprecated.

PySide2.QtWidgets.QGraphicsScene.itemAt(x, y, deviceTransform)
Parameters
  • xqreal

  • yqreal

  • deviceTransformQTransform

Return type

QGraphicsItem

This is an overloaded function.

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

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) .

Note: See items() for a definition of which items are considered visible by this function.

PySide2.QtWidgets.QGraphicsScene.itemAt(pos, deviceTransform)
Parameters
  • posQPointF

  • deviceTransformQTransform

Return type

QGraphicsItem

PySide2.QtWidgets.QGraphicsScene.itemIndexMethod()
Return type

ItemIndexMethod

PySide2.QtWidgets.QGraphicsScene.items(x, y, w, h, mode, order[, deviceTransform=QTransform()])
Parameters
  • xqreal

  • yqreal

  • wqreal

  • hqreal

  • modeItemSelectionMode

  • orderSortOrder

  • deviceTransformQTransform

Return type

This is an overloaded function.

Returns all visible items that, depending on mode , are either inside or intersect with the rectangle defined by x , y , w and h , in a list sorted using order . In this case, “visible” defines items for which: isVisible() returns true , effectiveOpacity() returns a value greater than 0.0 (which is fully transparent) and the parent item does not clip it.

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

PySide2.QtWidgets.QGraphicsScene.items(rect[, mode=Qt.IntersectsItemShape[, order=Qt.DescendingOrder[, deviceTransform=QTransform()]]])
Parameters
  • rectQRectF

  • modeItemSelectionMode

  • orderSortOrder

  • deviceTransformQTransform

Return type

PySide2.QtWidgets.QGraphicsScene.items(polygon[, mode=Qt.IntersectsItemShape[, order=Qt.DescendingOrder[, deviceTransform=QTransform()]]])
Parameters
  • polygonQPolygonF

  • modeItemSelectionMode

  • orderSortOrder

  • deviceTransformQTransform

Return type

PySide2.QtWidgets.QGraphicsScene.items(pos[, mode=Qt.IntersectsItemShape[, order=Qt.DescendingOrder[, deviceTransform=QTransform()]]])
Parameters
  • posQPointF

  • modeItemSelectionMode

  • orderSortOrder

  • deviceTransformQTransform

Return type

PySide2.QtWidgets.QGraphicsScene.items(path[, mode=Qt.IntersectsItemShape[, order=Qt.DescendingOrder[, deviceTransform=QTransform()]]])
Parameters
  • pathQPainterPath

  • modeItemSelectionMode

  • orderSortOrder

  • deviceTransformQTransform

Return type

PySide2.QtWidgets.QGraphicsScene.items([order=Qt.DescendingOrder])
Parameters

orderSortOrder

Return type

Returns an ordered list of all items on the scene. order decides the stacking order.

See also

addItem() removeItem() Sorting

PySide2.QtWidgets.QGraphicsScene.itemsBoundingRect()
Return type

QRectF

Calculates and returns the bounding rect of all items on the scene. This function works by iterating over all items, and because of this, it can be slow for large scenes.

See also

sceneRect()

PySide2.QtWidgets.QGraphicsScene.keyPressEvent(event)
Parameters

eventQKeyEvent

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.

PySide2.QtWidgets.QGraphicsScene.keyReleaseEvent(event)
Parameters

eventQKeyEvent

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.

PySide2.QtWidgets.QGraphicsScene.minimumRenderSize()
Return type

qreal

PySide2.QtWidgets.QGraphicsScene.mouseDoubleClickEvent(event)
Parameters

eventQGraphicsSceneMouseEvent

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() .

Note: See items() for a definition of which items are considered visible by this function.

PySide2.QtWidgets.QGraphicsScene.mouseGrabberItem()
Return type

QGraphicsItem

Returns the current mouse grabber item, or None 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).

PySide2.QtWidgets.QGraphicsScene.mouseMoveEvent(event)
Parameters

eventQGraphicsSceneMouseEvent

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.

PySide2.QtWidgets.QGraphicsScene.mousePressEvent(event)
Parameters

eventQGraphicsSceneMouseEvent

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 visible 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.

Note: See items() for a definition of which items are considered visible by this function.

PySide2.QtWidgets.QGraphicsScene.mouseReleaseEvent(event)
Parameters

eventQGraphicsSceneMouseEvent

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.

PySide2.QtWidgets.QGraphicsScene.palette()
Return type

QPalette

See also

setPalette()

PySide2.QtWidgets.QGraphicsScene.removeItem(item)
Parameters

itemQGraphicsItem

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()

PySide2.QtWidgets.QGraphicsScene.render(painter[, target=QRectF()[, source=QRectF()[, aspectRatioMode=Qt.KeepAspectRatio]]])
Parameters
  • painterQPainter

  • targetQRectF

  • sourceQRectF

  • aspectRatioModeAspectRatioMode

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:

scene = QGraphicsScene
scene.addItem(...
...
printer = QPrinter(QPrinter.HighResolution)
printer.setPaperSize(QPrinter.A4)

painter = QPainter(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

render()

PySide2.QtWidgets.QGraphicsScene.sceneRect()
Return type

QRectF

See also

setSceneRect()

PySide2.QtWidgets.QGraphicsScene.sceneRectChanged(rect)
Parameters

rectQRectF

PySide2.QtWidgets.QGraphicsScene.selectedItems()
Return type

Returns a list of all currently selected items. The items are returned in no particular order.

PySide2.QtWidgets.QGraphicsScene.selectionArea()
Return type

QPainterPath

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

PySide2.QtWidgets.QGraphicsScene.selectionChanged()
PySide2.QtWidgets.QGraphicsScene.sendEvent(item, event)
Parameters
Return type

bool

Sends event event to item item through possible event filters.

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.

PySide2.QtWidgets.QGraphicsScene.setActivePanel(item)
Parameters

itemQGraphicsItem

Activates item , which must be an item in this scene. 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 None , no item will be activated).

PySide2.QtWidgets.QGraphicsScene.setActiveWindow(widget)
Parameters

widgetQGraphicsWidget

Activates widget , which must be a widget in this scene. You can also pass 0 for widget , in which case QGraphicsScene will deactivate any currently active window.

PySide2.QtWidgets.QGraphicsScene.setBackgroundBrush(brush)
Parameters

brushQBrush

PySide2.QtWidgets.QGraphicsScene.setBspTreeDepth(depth)
Parameters

depthint

See also

bspTreeDepth()

PySide2.QtWidgets.QGraphicsScene.setFocus([focusReason=Qt.OtherFocusReason])
Parameters

focusReasonFocusReason

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.

PySide2.QtWidgets.QGraphicsScene.setFocusItem(item[, focusReason=Qt.OtherFocusReason])
Parameters

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 None , or if it either does not accept focus (i.e., it does not have the ItemIsFocusable flag enabled), or is not visible or not enabled, this function only removes focus from any previous focusitem.

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

PySide2.QtWidgets.QGraphicsScene.setFocusOnTouch(enabled)
Parameters

enabledbool

See also

focusOnTouch()

PySide2.QtWidgets.QGraphicsScene.setFont(font)
Parameters

fontQFont

See also

font()

PySide2.QtWidgets.QGraphicsScene.setForegroundBrush(brush)
Parameters

brushQBrush

PySide2.QtWidgets.QGraphicsScene.setItemIndexMethod(method)
Parameters

methodItemIndexMethod

PySide2.QtWidgets.QGraphicsScene.setMinimumRenderSize(minSize)
Parameters

minSizeqreal

PySide2.QtWidgets.QGraphicsScene.setPalette(palette)
Parameters

paletteQPalette

See also

palette()

PySide2.QtWidgets.QGraphicsScene.setSceneRect(rect)
Parameters

rectQRectF

See also

sceneRect()

PySide2.QtWidgets.QGraphicsScene.setSceneRect(x, y, w, h)
Parameters
  • xqreal

  • yqreal

  • wqreal

  • hqreal

PySide2.QtWidgets.QGraphicsScene.setSelectionArea(path[, mode=Qt.IntersectsItemShape[, deviceTransform=QTransform()]])
Parameters
  • pathQPainterPath

  • modeItemSelectionMode

  • deviceTransformQTransform

This is an overloaded function.

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

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

PySide2.QtWidgets.QGraphicsScene.setSelectionArea(path, selectionOperation[, mode=Qt.IntersectsItemShape[, deviceTransform=QTransform()]])
Parameters
  • pathQPainterPath

  • selectionOperationItemSelectionOperation

  • modeItemSelectionMode

  • deviceTransformQTransform

This is an overloaded function.

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

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

selectionOperation determines what to do with the currently selected items.

PySide2.QtWidgets.QGraphicsScene.setSelectionArea(path, deviceTransform)
Parameters
  • pathQPainterPath

  • deviceTransformQTransform

Sets the selection area to path . 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 ( ItemIsSelectable ).

PySide2.QtWidgets.QGraphicsScene.setSortCacheEnabled(enabled)
Parameters

enabledbool

Note

This function is deprecated.

PySide2.QtWidgets.QGraphicsScene.setStickyFocus(enabled)
Parameters

enabledbool

See also

stickyFocus()

PySide2.QtWidgets.QGraphicsScene.setStyle(style)
Parameters

styleQStyle

Sets or replaces the style of the scene to style , and reparents the style to this scene. Any previously assigned style is deleted. The scene’s style defaults to 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 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 None , QGraphicsScene will revert to style() .

See also

style()

PySide2.QtWidgets.QGraphicsScene.stickyFocus()
Return type

bool

See also

setStickyFocus()

PySide2.QtWidgets.QGraphicsScene.style()
Return type

QStyle

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

See also

setStyle()

PySide2.QtWidgets.QGraphicsScene.update([rect=QRectF()])
Parameters

rectQRectF

Schedules a redraw of the area rect on the scene.

PySide2.QtWidgets.QGraphicsScene.update(x, y, w, h)
Parameters
  • xqreal

  • yqreal

  • wqreal

  • hqreal

This is an overloaded function.

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

PySide2.QtWidgets.QGraphicsScene.views()
Return type

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

See also

scene()

PySide2.QtWidgets.QGraphicsScene.wheelEvent(event)
Parameters

eventQGraphicsSceneWheelEvent

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.

Note: See items() for a definition of which items are considered visible by this function.

See also

wheelEvent()

PySide2.QtWidgets.QGraphicsScene.width()
Return type

qreal

This convenience function is equivalent to calling sceneRect() ..

See also

height()