The QGraphicsScene class provides a surface for managing a large number of 2D graphical items. More...
#include <qgraphicsscene.h>
Public Types | |
| enum | ItemIndexMethod { BspTreeIndex , NoIndex = -1 } |
| enum | SceneLayer { ItemLayer = 0x1 , BackgroundLayer = 0x2 , ForegroundLayer = 0x4 , AllLayers = 0xffff } |
Public Slots | |
| void | update (const QRectF &rect=QRectF()) |
| void | invalidate (const QRectF &rect=QRectF(), SceneLayers layers=AllLayers) |
| void | advance () |
| void | clearSelection () |
| void | clear () |
 Public Slots inherited from QObject | |
| void | deleteLater () |
Signals | |
| void | changed (const QList< QRectF > ®ion) |
| void | sceneRectChanged (const QRectF &rect) |
| void | selectionChanged () |
| void | focusItemChanged (QGraphicsItem *newFocus, QGraphicsItem *oldFocus, Qt::FocusReason reason) |
| Signals inherited from QObject | |
| void | destroyed (QObject *=nullptr) |
| void | objectNameChanged (const QString &objectName, QPrivateSignal) |
Protected Slots | |
| virtual bool | focusNextPrevChild (bool next) |
Properties | |
| QBrush | backgroundBrush |
| the background brush of the scene. More... | |
| QBrush | foregroundBrush |
| the foreground brush of the scene. More... | |
| ItemIndexMethod | itemIndexMethod |
| the item indexing method. More... | |
| QRectF | sceneRect |
| the scene rectangle; the bounding rectangle of the scene More... | |
| int | bspTreeDepth |
| the depth of QGraphicsScene's BSP index tree More... | |
| QPalette | palette |
| the scene's default palette More... | |
| QFont | font |
| the scene's default font More... | |
| bool | stickyFocus |
| whether clicking into the scene background will clear focus More... | |
| qreal | minimumRenderSize |
| the minimal view-transformed size an item must have to be drawn More... | |
| bool | focusOnTouch |
| whether items gain focus when receiving a {touch begin} event. More... | |
| Properties inherited from QObject | |
| QString | objectName |
| the name of this object More... | |
Friends | |
| class | QGraphicsItemPrivate |
| class | QGraphicsObject |
| class | QGraphicsView |
| class | QGraphicsViewPrivate |
| class | QGraphicsWidget |
| class | QGraphicsWidgetPrivate |
| class | QGraphicsEffect |
| class | QGraphicsSceneIndex |
| class | QGraphicsSceneIndexPrivate |
| class | QGraphicsSceneBspTreeIndex |
| class | QGraphicsSceneBspTreeIndexPrivate |
| class | QGraphicsItemEffectSourcePrivate |
| class | QGesture |
Detailed Description
The QGraphicsScene class provides a surface for managing a large number of 2D graphical items.
- Since
- 4.2
\inmodule QtWidgets
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 \l{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:
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.
Definition at line 94 of file qgraphicsscene.h.
Member Enumeration Documentation
◆ ItemIndexMethod
This enum describes the indexing algorithms QGraphicsScene provides for managing positional information about items on the scene.
\value 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).
\value 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 109 of file qgraphicsscene.h.
◆ SceneLayer
- Since
- 4.3
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 QGraphicsView::invalidateScene().
\value 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.
\value 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.
\value 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.
\value AllLayers All layers; this value represents a combination of all three layers.
| Enumerator | |
|---|---|
| ItemLayer | |
| BackgroundLayer | |
| ForegroundLayer | |
| AllLayers | |
Definition at line 114 of file qgraphicsscene.h.
Constructor & Destructor Documentation
◆ QGraphicsScene() [1/3]
Constructs a QGraphicsScene object. The parent parameter is passed to QObject's constructor.
Definition at line 1646 of file qgraphicsscene.cpp.
◆ QGraphicsScene() [2/3]
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 1659 of file qgraphicsscene.cpp.
◆ QGraphicsScene() [3/3]
| QGraphicsScene::QGraphicsScene | ( | qreal | x, |
| qreal | y, | ||
| qreal | width, | ||
| qreal | height, | ||
| QObject * | parent = nullptr |
||
| ) |
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 1674 of file qgraphicsscene.cpp.
◆ ~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 1687 of file qgraphicsscene.cpp.
Member Function Documentation
◆ activePanel()
| QGraphicsItem * QGraphicsScene::activePanel | ( | ) | const |
- Since
- 4.6 Returns the current active panel, or \nullptr if no panel is currently active.
- See also
- QGraphicsScene::setActivePanel()
Definition at line 5641 of file qgraphicsscene.cpp.
◆ activeWindow()
| QGraphicsWidget * QGraphicsScene::activeWindow | ( | ) | const |
- Since
- 4.4
Returns the current active window, or \nullptr if no window is currently active.
Definition at line 5672 of file qgraphicsscene.cpp.
◆ 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 2616 of file qgraphicsscene.cpp.
◆ addEllipse() [2/2]
|
inline |
- Since
- 4.3
This convenience function is equivalent to calling addEllipse(QRectF(x, y, w, h), pen, brush).
Definition at line 179 of file qgraphicsscene.h.
◆ addItem()
| void QGraphicsScene::addItem | ( | QGraphicsItem * | item | ) |
Adds or moves the item and all its children 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 2425 of file qgraphicsscene.cpp.
◆ addLine() [1/2]
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 2648 of file qgraphicsscene.cpp.
◆ addLine() [2/2]
|
inline |
- Since
- 4.3
This convenience function is equivalent to calling addLine(QLineF(x1, y1, x2, y2), pen).
Definition at line 181 of file qgraphicsscene.h.
◆ 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 2679 of file qgraphicsscene.cpp.
◆ 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 2702 of file qgraphicsscene.cpp.
◆ 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 2724 of file qgraphicsscene.cpp.
◆ 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 item's 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 2751 of file qgraphicsscene.cpp.
◆ addRect() [2/2]
|
inline |
- Since
- 4.3
This convenience function is equivalent to calling addRect(QRectF(x, y, w, h), pen, brush).
Definition at line 183 of file qgraphicsscene.h.
◆ 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 2804 of file qgraphicsscene.cpp.
◆ addText()
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 2782 of file qgraphicsscene.cpp.
◆ addWidget()
| QGraphicsProxyWidget * QGraphicsScene::addWidget | ( | QWidget * | widget, |
| Qt::WindowFlags | wFlags = Qt::WindowFlags() |
||
| ) |
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 QOpenGLWidget and QAxWidget.
- See also
- addEllipse(), addLine(), addPixmap(), addPixmap(), addRect(), addText(), addSimpleText(), addItem()
Definition at line 2830 of file qgraphicsscene.cpp.
◆ 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.
Note that you can also use the \l{The Animation Framework}{Animation Framework} for animations.
- See also
- QGraphicsItem::advance(), QTimeLine
Definition at line 3236 of file qgraphicsscene.cpp.
◆ backgroundBrush()
| QBrush QGraphicsScene::backgroundBrush | ( | ) | const |
Definition at line 3044 of file qgraphicsscene.cpp.
◆ bspTreeDepth()
| int QGraphicsScene::bspTreeDepth | ( | ) | const |
Definition at line 1922 of file qgraphicsscene.cpp.
◆ changed
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()
◆ clear
|
slot |
- Since
- 4.4
Removes and deletes all items from the scene, but otherwise leaves the state of the scene unchanged.
- See also
- addItem()
Definition at line 2311 of file qgraphicsscene.cpp.
◆ 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 2961 of file qgraphicsscene.cpp.
◆ clearSelection
|
slot |
Clears the current selection.
- See also
- setSelectionArea(), selectedItems()
Definition at line 2282 of file qgraphicsscene.cpp.
◆ 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 2102 of file qgraphicsscene.cpp.
◆ 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 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.
Definition at line 3511 of file qgraphicsscene.cpp.
◆ 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().
Definition at line 2341 of file qgraphicsscene.cpp.
◆ 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.
Definition at line 2391 of file qgraphicsscene.cpp.
◆ dragEnterEvent()
|
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.
Definition at line 3544 of file qgraphicsscene.cpp.
◆ dragLeaveEvent()
|
protectedvirtual |
This event handler, for event event, can be reimplemented in a subclass to receive drag leave events for the scene.
Definition at line 3645 of file qgraphicsscene.cpp.
◆ dragMoveEvent()
|
protectedvirtual |
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.
Definition at line 3561 of file qgraphicsscene.cpp.
◆ drawBackground()
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 4176 of file qgraphicsscene.cpp.
◆ drawForeground()
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 4203 of file qgraphicsscene.cpp.
◆ drawItems()
|
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:
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()
Reimplemented in ClippingAndTransformsScene, CustomScene, and ClippingAndTransformsScene.
Definition at line 5296 of file qgraphicsscene.cpp.
◆ dropEvent()
|
protectedvirtual |
This event handler, for event event, can be reimplemented in a subclass to receive drop events for the scene.
Definition at line 3662 of file qgraphicsscene.cpp.
◆ event()
|
overrideprotectedvirtual |
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 \l{QWidget::}{enterEvent()} and \l{QWidget::}{leaveEvent()}. Use this function to obtain those events instead.
Returns true if event has been recognized and processed; otherwise, returns false.
- See also
- contextMenuEvent(), keyPressEvent(), keyReleaseEvent(), mousePressEvent(), mouseMoveEvent(), mouseReleaseEvent(), mouseDoubleClickEvent(), focusInEvent(), focusOutEvent()
Reimplemented from QObject.
Definition at line 3266 of file qgraphicsscene.cpp.
◆ eventFilter()
\reimp
QGraphicsScene filters QApplication's events to detect palette and font changes.
Reimplemented from QObject.
Definition at line 3482 of file qgraphicsscene.cpp.
◆ focusInEvent()
|
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 3682 of file qgraphicsscene.cpp.
◆ focusItem()
| QGraphicsItem * QGraphicsScene::focusItem | ( | ) | const |
When the scene is active, this functions returns the scene's current focus item, or \nullptr 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.
Definition at line 2889 of file qgraphicsscene.cpp.
◆ focusItemChanged
|
signal |
This signal is emitted by QGraphicsScene whenever focus changes in the scene (i.e., when an item gains or loses input focus, or when focus passes from one item to another). You can connect to this signal if you need to keep track of when other items gain input focus. It is particularly useful for implementing virtual keyboards, input methods, and cursor items.
oldFocusItem is a pointer to the item that previously had focus, or 0 if no item had focus before the signal was emitted. newFocusItem is a pointer to the item that gained input focus, or \nullptr if focus was lost. reason is the reason for the focus change (e.g., if the scene was deactivated while an input field had focus, oldFocusItem would point to the input field item, newFocusItem would be \nullptr, and reason would be Qt::ActiveWindowFocusReason.
◆ focusNextPrevChild
|
protectedvirtualslot |
- Since
- 4.4
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 QGraphicsWidget::setTabOrder().
Definition at line 5356 of file qgraphicsscene.cpp.
◆ focusOnTouch()
| bool QGraphicsScene::focusOnTouch | ( | ) | const |
Definition at line 5813 of file qgraphicsscene.cpp.
◆ focusOutEvent()
|
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 3714 of file qgraphicsscene.cpp.
◆ font()
| QFont QGraphicsScene::font | ( | ) | const |
Definition at line 5569 of file qgraphicsscene.cpp.
◆ foregroundBrush()
| QBrush QGraphicsScene::foregroundBrush | ( | ) | const |
Definition at line 3080 of file qgraphicsscene.cpp.
◆ 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 2927 of file qgraphicsscene.cpp.
◆ height()
|
inline |
This convenience function is equivalent to calling sceneRect().height().
- See also
- width()
Definition at line 129 of file qgraphicsscene.h.
◆ 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 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.
- See also
- QGraphicsItem::toolTip(), QGraphicsSceneHelpEvent
Definition at line 3741 of file qgraphicsscene.cpp.
◆ inputMethodEvent()
|
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.
Definition at line 4152 of file qgraphicsscene.cpp.
◆ inputMethodQuery()
|
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 3104 of file qgraphicsscene.cpp.
◆ invalidate [1/2]
|
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 \l{QGraphicsView::CacheBackground}{CacheBackground}.
Example:
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.
Definition at line 3195 of file qgraphicsscene.cpp.
◆ invalidate() [2/2]
|
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 210 of file qgraphicsscene.h.
◆ isActive()
| bool QGraphicsScene::isActive | ( | ) | const |
- Since
- 4.6
Returns true if the scene is active (e.g., it's viewed by at least one QGraphicsView that is active); otherwise returns false.
Definition at line 5628 of file qgraphicsscene.cpp.
◆ itemAt() [1/2]
| QGraphicsItem * QGraphicsScene::itemAt | ( | const QPointF & | position, |
| const QTransform & | deviceTransform | ||
| ) | const |
- Since
- 4.6
Returns the topmost visible item at the specified position, or \nullptr 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.
Note: See items() for a definition of which items are considered visible by this function.
- See also
- items(), collidingItems(), {QGraphicsItem::Sorting}{Sorting}
Definition at line 2134 of file qgraphicsscene.cpp.
◆ itemAt() [2/2]
|
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.6
Returns the topmost visible item at the position specified by (x, y), or \nullptr 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.
Definition at line 158 of file qgraphicsscene.h.
◆ itemIndexMethod()
| QGraphicsScene::ItemIndexMethod QGraphicsScene::itemIndexMethod | ( | ) | const |
Definition at line 1867 of file qgraphicsscene.cpp.
◆ items() [1/6]
| QList< QGraphicsItem * > QGraphicsScene::items | ( | const QPainterPath & | path, |
| Qt::ItemSelectionMode | mode = Qt::IntersectsItemShape, |
||
| Qt::SortOrder | order = Qt::DescendingOrder, |
||
| const QTransform & | deviceTransform = QTransform() |
||
| ) | const |
Returns all visible items that, depending on mode, are either inside or intersect with the specified path, 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.
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 2083 of file qgraphicsscene.cpp.
◆ items() [2/6]
| QList< QGraphicsItem * > QGraphicsScene::items | ( | const QPointF & | pos, |
| Qt::ItemSelectionMode | mode = Qt::IntersectsItemShape, |
||
| Qt::SortOrder | order = Qt::DescendingOrder, |
||
| const QTransform & | deviceTransform = QTransform() |
||
| ) | const |
Returns all visible items that, depending on mode, are at the specified pos 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.
- 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 2005 of file qgraphicsscene.cpp.
◆ items() [3/6]
| QList< QGraphicsItem * > QGraphicsScene::items | ( | const QPolygonF & | polygon, |
| Qt::ItemSelectionMode | mode = Qt::IntersectsItemShape, |
||
| Qt::SortOrder | order = Qt::DescendingOrder, |
||
| const QTransform & | deviceTransform = QTransform() |
||
| ) | const |
Returns all visible items that, depending on mode, are either inside or intersect with the specified polygon, 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.
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 2057 of file qgraphicsscene.cpp.
◆ items() [4/6]
| QList< QGraphicsItem * > QGraphicsScene::items | ( | const QRectF & | rect, |
| Qt::ItemSelectionMode | mode = Qt::IntersectsItemShape, |
||
| Qt::SortOrder | order = Qt::DescendingOrder, |
||
| const QTransform & | deviceTransform = QTransform() |
||
| ) | const |
Returns all visible items that, depending on mode, are either inside or intersect with the specified rect, 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.
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 2031 of file qgraphicsscene.cpp.
◆ items() [5/6]
|
inline |
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.
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.
Definition at line 152 of file qgraphicsscene.h.
◆ items() [6/6]
| QList< QGraphicsItem * > QGraphicsScene::items | ( | Qt::SortOrder | order = Qt::DescendingOrder | ) | 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 1967 of file qgraphicsscene.cpp.
◆ 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 of this, it can be slow for large scenes.
- See also
- sceneRect()
Definition at line 1951 of file qgraphicsscene.cpp.
◆ keyPressEvent()
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.
Definition at line 3904 of file qgraphicsscene.cpp.
◆ keyReleaseEvent()
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.
Definition at line 3936 of file qgraphicsscene.cpp.
◆ minimumRenderSize()
| qreal QGraphicsScene::minimumRenderSize | ( | ) | const |
Definition at line 5778 of file qgraphicsscene.cpp.
◆ mouseDoubleClickEvent()
|
protectedvirtual |
This event handler, for event mouseEvent, can be reimplemented in a subclass to receive mouse double-click 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 double-click event, and finally a release event. If the double-click 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 double-click 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.
- See also
- QGraphicsItem::mousePressEvent(), QGraphicsItem::mouseMoveEvent(), QGraphicsItem::mouseReleaseEvent(), QGraphicsItem::setAcceptedMouseButtons()
Reimplemented in MouseInterceptingGraphicsScene.
Definition at line 4083 of file qgraphicsscene.cpp.
◆ mouseGrabberItem()
| QGraphicsItem * QGraphicsScene::mouseGrabberItem | ( | ) | const |
Returns the current mouse grabber item, or \nullptr 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:
\list
- 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. \endlist
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 3022 of file qgraphicsscene.cpp.
◆ mouseMoveEvent()
|
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 DiagramScene, and Scene.
Definition at line 4005 of file qgraphicsscene.cpp.
◆ mousePressEvent()
|
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 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.
Reimplemented in DiagramScene, MousePressReleaseScene, DiagramScene, and MouseInterceptingGraphicsScene.
Definition at line 3980 of file qgraphicsscene.cpp.
◆ mouseReleaseEvent()
|
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 DiagramScene, MousePressReleaseScene, and DiagramScene.
Definition at line 4035 of file qgraphicsscene.cpp.
◆ palette()
| QPalette QGraphicsScene::palette | ( | ) | const |
Definition at line 5606 of file qgraphicsscene.cpp.
◆ 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 2845 of file qgraphicsscene.cpp.
◆ 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:
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 1780 of file qgraphicsscene.cpp.
◆ sceneRect()
| QRectF QGraphicsScene::sceneRect | ( | ) | const |
◆ sceneRectChanged
This signal is emitted by QGraphicsScene whenever the scene rect changes. The rect parameter is the new scene rectangle.
- See also
- QGraphicsView::updateSceneRect()
◆ 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 2164 of file qgraphicsscene.cpp.
◆ 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 2188 of file qgraphicsscene.cpp.
◆ selectionChanged
|
signal |
- Since
- 4.3
This signal is emitted by QGraphicsScene whenever the selection changes. 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).
◆ sendEvent()
| bool QGraphicsScene::sendEvent | ( | QGraphicsItem * | item, |
| QEvent * | event | ||
| ) |
- Since
- 4.6
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.
Definition at line 5731 of file qgraphicsscene.cpp.
◆ setActivePanel()
| void QGraphicsScene::setActivePanel | ( | QGraphicsItem * | item | ) |
- Since
- 4.6 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 \nullptr, no item will be activated).
- See also
- activePanel(), isActive(), QGraphicsItem::isActive()
Definition at line 5658 of file qgraphicsscene.cpp.
◆ setActiveWindow()
| void QGraphicsScene::setActiveWindow | ( | QGraphicsWidget * | widget | ) |
- Since
- 4.4 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.
Definition at line 5688 of file qgraphicsscene.cpp.
◆ setBackgroundBrush()
Definition at line 3049 of file qgraphicsscene.cpp.
◆ setBspTreeDepth()
| void QGraphicsScene::setBspTreeDepth | ( | int | 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 2943 of file qgraphicsscene.cpp.
◆ 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 \nullptr, 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 \nullptr, 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 2911 of file qgraphicsscene.cpp.
◆ setFocusOnTouch()
| void QGraphicsScene::setFocusOnTouch | ( | bool | enabled | ) |
Definition at line 5819 of file qgraphicsscene.cpp.
◆ setFont()
◆ setForegroundBrush()
◆ setItemIndexMethod()
| void QGraphicsScene::setItemIndexMethod | ( | ItemIndexMethod | method | ) |
Definition at line 1872 of file qgraphicsscene.cpp.
◆ setMinimumRenderSize()
◆ setPalette()
◆ setSceneRect() [1/2]
◆ setSceneRect() [2/2]
Definition at line 131 of file qgraphicsscene.h.
◆ setSelectionArea() [1/2]
| void QGraphicsScene::setSelectionArea | ( | const QPainterPath & | path, |
| const QTransform & | deviceTransform | ||
| ) |
- Since
- 4.6
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 (QGraphicsItem::ItemIsSelectable).
- See also
- clearSelection(), selectionArea()
Definition at line 2209 of file qgraphicsscene.cpp.
◆ setSelectionArea() [2/2]
| void QGraphicsScene::setSelectionArea | ( | const QPainterPath & | path, |
| Qt::ItemSelectionOperation | selectionOperation = Qt::ReplaceSelection, |
||
| Qt::ItemSelectionMode | mode = Qt::IntersectsItemShape, |
||
| const QTransform & | deviceTransform = QTransform() |
||
| ) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
- Since
- 5.5
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.
- See also
- clearSelection(), selectionArea()
Definition at line 2228 of file qgraphicsscene.cpp.
◆ setStickyFocus()
| void QGraphicsScene::setStickyFocus | ( | bool | enabled | ) |
◆ setStyle()
- Since
- 4.4
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 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 \nullptr, QGraphicsScene will revert to QApplication::style().
- See also
- style()
Definition at line 5519 of file qgraphicsscene.cpp.
◆ stickyFocus()
| bool QGraphicsScene::stickyFocus | ( | ) | const |
Definition at line 2994 of file qgraphicsscene.cpp.
◆ style()
| QStyle * QGraphicsScene::style | ( | ) | const |
- Since
- 4.4
Returns the scene's style, or the same as QApplication::style() if the scene has not been explicitly assigned a style.
- See also
- setStyle()
Definition at line 5495 of file qgraphicsscene.cpp.
◆ update [1/2]
Schedules a redraw of the area rect on the scene.
- See also
- sceneRect(), changed()
Definition at line 3128 of file qgraphicsscene.cpp.
◆ update() [2/2]
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 208 of file qgraphicsscene.h.
◆ views()
| QList< QGraphicsView * > QGraphicsScene::views | ( | ) | const |
Returns a list of all the views that display this scene.
- See also
- QGraphicsView::scene()
Definition at line 3217 of file qgraphicsscene.cpp.
◆ 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.
Note: See items() for a definition of which items are considered visible by this function.
- See also
- QGraphicsItem::wheelEvent()
Definition at line 4102 of file qgraphicsscene.cpp.
◆ width()
|
inline |
This convenience function is equivalent to calling sceneRect().width().
- See also
- height()
Definition at line 128 of file qgraphicsscene.h.
Friends And Related Function Documentation
◆ QGesture
|
friend |
Definition at line 300 of file qgraphicsscene.h.
◆ QGraphicsEffect
|
friend |
Definition at line 293 of file qgraphicsscene.h.
◆ QGraphicsItemEffectSourcePrivate
|
friend |
Definition at line 298 of file qgraphicsscene.h.
◆ QGraphicsItemPrivate
|
friend |
Definition at line 287 of file qgraphicsscene.h.
◆ QGraphicsObject
|
friend |
Definition at line 288 of file qgraphicsscene.h.
◆ QGraphicsSceneBspTreeIndex
|
friend |
Definition at line 296 of file qgraphicsscene.h.
◆ QGraphicsSceneBspTreeIndexPrivate
|
friend |
Definition at line 297 of file qgraphicsscene.h.
◆ QGraphicsSceneIndex
|
friend |
Definition at line 294 of file qgraphicsscene.h.
◆ QGraphicsSceneIndexPrivate
|
friend |
Definition at line 295 of file qgraphicsscene.h.
◆ QGraphicsView
|
friend |
Definition at line 289 of file qgraphicsscene.h.
◆ QGraphicsViewPrivate
|
friend |
Definition at line 290 of file qgraphicsscene.h.
◆ QGraphicsWidget
|
friend |
Definition at line 291 of file qgraphicsscene.h.
◆ QGraphicsWidgetPrivate
|
friend |
Definition at line 292 of file qgraphicsscene.h.
Property Documentation
◆ backgroundBrush
|
readwrite |
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::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 306 of file qgraphicsscene.h.
◆ bspTreeDepth
|
readwrite |
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:
The BSP tree has an optimal size when each segment contains between 0 and 10 items.
- See also
- itemIndexMethod
Definition at line 306 of file qgraphicsscene.h.
◆ focusOnTouch
|
readwrite |
whether items gain focus when receiving a {touch begin} event.
- Since
- 5.12
The usual behavior is to transfer focus only when an item is clicked. Often a tap on a touchpad is interpreted as equivalent to a mouse click by the operating system, generating a synthesized click event in response. However, at least on macOS you can configure this behavior.
By default, QGraphicsScene also transfers focus when you touch on a trackpad or similar. If the operating system is configured to not generate a synthetic mouse click on tapping the trackpad, this is surprising. If the operating system does generate synthetic mouse clicks on tapping the trackpad, the focus transfer on starting a touch gesture is unnecessary.
With focusOnTouch switched off, QGraphicsScene behaves as one would expect on macOS.
The default value is true, ensuring that the default behavior is just as in Qt versions prior to 5.12. Set to false to prevent touch events from triggering focus changes.
Definition at line 306 of file qgraphicsscene.h.
◆ font
|
readwrite |
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 \l{QEvent::FontChange}{FontChange} event, and it then sends \l{QEvent::FontChange}{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 306 of file qgraphicsscene.h.
◆ foregroundBrush
|
readwrite |
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::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 306 of file qgraphicsscene.h.
◆ itemIndexMethod
|
readwrite |
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 outweigh 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 306 of file qgraphicsscene.h.
◆ minimumRenderSize
|
readwrite |
the minimal view-transformed size an item must have to be drawn
- Since
- 5.4
When the scene is rendered, any item whose width or height, transformed to the target view, is smaller that minimumRenderSize(), will not be rendered. If an item is not rendered and it clips its children items they will also not be rendered. Set this value to speed up rendering of scenes with many objects rendered on a zoomed out view.
The default value is 0. If unset, or if set to 0 or a negative value, all items will always be rendered.
For example, setting this property can be especially useful if a scene is rendered by multiple views, one of which serves as an overview which always displays all items. In scenes with many items, such a view will use a high scaling factor so that all items can be shown. Due to the scaling, smaller items will only make an insignificant contribution to the final rendered scene. To avoid drawing these items and reduce the time necessary to render the scene, you can call setMinimumRenderSize() with a non-negative value.
- Note
- Items that are not drawn as a result of being too small, are still returned by methods such as items() and itemAt(), and participate in collision detection and interactions. It is recommended that you set minimumRenderSize() to a value less than or equal to 1 in order to avoid large unrendered items that are interactive.
Definition at line 306 of file qgraphicsscene.h.
◆ palette
|
readwrite |
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 \l{QEvent::PaletteChange}{PaletteChange} event, and it then sends \l{QEvent::PaletteChange}{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 306 of file qgraphicsscene.h.
◆ sceneRect
|
readwrite |
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 306 of file qgraphicsscene.h.
◆ stickyFocus
|
readwrite |
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 306 of file qgraphicsscene.h.
The documentation for this class was generated from the following files:
- src/widgets/graphicsview/qgraphicsscene.h
- src/widgets/graphicsview/qgraphicsscene.cpp
