[−][src]Struct qt_widgets::QGraphicsScene

#[repr(C)]pub struct QGraphicsScene { /* fields omitted */ }

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

C++ class: QGraphicsScene.

C++ documentation:

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

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

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

Example:

QGraphicsScene scene;
scene.addText("Hello, world!");
QGraphicsView view(&scene);
view.show();

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

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

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

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

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

One of QGraphicsScene's greatest strengths is its ability to efficiently determine the location of items. Even with millions of items on the scene, the items() functions can determine the location of an item within 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.

Methods

`impl QGraphicsScene`[src]

`pub fn slot_update(&self) -> Receiver<(*const QRectF,)>`[src]

Schedules a redraw of the area rect on the scene.

Returns a built-in Qt slot QGraphicsScene::update that can be passed to qt_core::Signal::connect.

C++ documentation:

Schedules a redraw of the area rect on the scene.

See also sceneRect() and changed().

`pub fn slot_invalidate(&self) -> Receiver<(*const QRectF, c_int)>`[src]

Invalidates and schedules a redraw of the layers in rect on the scene. Any cached content in layers is unconditionally invalidated and redrawn.

Returns a built-in Qt slot QGraphicsScene::invalidate that can be passed to qt_core::Signal::connect.

C++ documentation:

Invalidates and schedules a redraw of the layers in rect on the scene. Any cached content in layers is unconditionally invalidated and redrawn.

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

Example:

QRectF TileScene::rectForTile(int x, int y) const
{
      // Return the rectangle for the tile at position (x, y).
      return QRectF(x  tileWidth, y  tileHeight, tileWidth, tileHeight);
}
void TileScene::setTile(int x, int y, const QPixmap &pixmap)
{
      // Sets or replaces the tile at position (x, y) with pixmap.
      if (x >= 0 && x < numTilesH && y >= 0 && y < numTilesV) {
          tiles[y][x] = pixmap;
          invalidate(rectForTile(x, y), BackgroundLayer);
      }
}
void TileScene::drawBackground(QPainter *painter, const QRectF &exposed)
{
      // Draws all tiles that intersect the exposed area.
      for (int y = 0; y < numTilesV; ++y) {
          for (int x = 0; x < numTilesH; ++x) {
              QRectF rect = rectForTile(x, y);
              if (exposed.intersects(rect))
                  painter->drawPixmap(rect.topLeft(), tiles[y][x]);
          }
      }
}

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

See also QGraphicsView::resetCachedContent().

`pub fn slot_advance(&self) -> Receiver<()>`[src]

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.

Returns a built-in Qt slot QGraphicsScene::advance that can be passed to qt_core::Signal::connect.

C++ documentation:

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 Animation Framework for animations.

See also QGraphicsItem::advance() and QTimeLine.

`pub fn slot_clear_selection(&self) -> Receiver<()>`[src]

Clears the current selection.

Returns a built-in Qt slot QGraphicsScene::clearSelection that can be passed to qt_core::Signal::connect.

C++ documentation:

Clears the current selection.

See also setSelectionArea() and selectedItems().

`pub fn slot_clear(&self) -> Receiver<()>`[src]

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

Returns a built-in Qt slot QGraphicsScene::clear that can be passed to qt_core::Signal::connect.

C++ documentation:

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

This function was introduced in Qt 4.4.

See also addItem().

`pub fn slot_focus_next_prev_child(&self) -> Receiver<(bool,)>`[src]

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.

Returns a built-in Qt slot QGraphicsScene::focusNextPrevChild that can be passed to qt_core::Signal::connect.

C++ documentation:

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

This function was introduced in Qt 4.4.

`pub fn scene_rect_changed(&self) -> Signal<(*const QRectF,)>`[src]

This signal is emitted by QGraphicsScene whenever the scene rect changes. The rect parameter is the new scene rectangle.

Returns a built-in Qt signal QGraphicsScene::sceneRectChanged that can be passed to qt_core::Signal::connect.

C++ documentation:

This signal is emitted by QGraphicsScene whenever the scene rect changes. The rect parameter is the new scene rectangle.

See also QGraphicsView::updateSceneRect().

`pub fn selection_changed(&self) -> Signal<()>`[src]

This signal is emitted by QGraphicsScene whenever the selection changes. You can call selectedItems() to get the new list of selected items.

Returns a built-in Qt signal QGraphicsScene::selectionChanged that can be passed to qt_core::Signal::connect.

C++ documentation:

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

This function was introduced in Qt 4.3.

See also setSelectionArea(), selectedItems(), and QGraphicsItem::setSelected().

`pub fn focus_item_changed( &self ) -> Signal<(mut QGraphicsItem, mut QGraphicsItem, FocusReason)>`[src]

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.

Returns a built-in Qt signal QGraphicsScene::focusItemChanged that can be passed to qt_core::Signal::connect.

C++ documentation:

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 0 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 0, and reason would be Qt::ActiveWindowFocusReason.

`pub fn changed(&self) -> Signal<(*const QListOfQRectF,)>`[src]

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.

Returns a built-in Qt signal QGraphicsScene::changed that can be passed to qt_core::Signal::connect.

C++ documentation:

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

`pub unsafe fn active_panel(&self) -> Ptr<QGraphicsItem>`[src]

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

Calls C++ function: QGraphicsItem* QGraphicsScene::activePanel() const.

C++ documentation:

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

This function was introduced in Qt 4.6.

See also QGraphicsScene::setActivePanel().

`pub unsafe fn active_window(&self) -> QPtr<QGraphicsWidget>`[src]

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

Calls C++ function: QGraphicsWidget* QGraphicsScene::activeWindow() const.

C++ documentation:

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

This function was introduced in Qt 4.4.

See also QGraphicsScene::setActiveWindow().

`pub unsafe fn add_ellipse_3a( &self, rect: impl CastInto<Ref<QRectF>>, pen: impl CastInto<Ref<QPen>>, brush: impl CastInto<Ref<QBrush>> ) -> Ptr<QGraphicsEllipseItem>`[src]

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.

Calls C++ function: QGraphicsEllipseItem* QGraphicsScene::addEllipse(const QRectF& rect, const QPen& pen = …, const QBrush& brush = …).

C++ documentation:

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(), and addWidget().

`pub unsafe fn add_ellipse_6a( &self, x: c_double, y: c_double, w: c_double, h: c_double, pen: impl CastInto<Ref<QPen>>, brush: impl CastInto<Ref<QBrush>> ) -> Ptr<QGraphicsEllipseItem>`[src]

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

Calls C++ function: QGraphicsEllipseItem* QGraphicsScene::addEllipse(double x, double y, double w, double h, const QPen& pen = …, const QBrush& brush = …).

C++ documentation:

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

This function was introduced in Qt 4.3.

`pub unsafe fn add_ellipse_2a( &self, rect: impl CastInto<Ref<QRectF>>, pen: impl CastInto<Ref<QPen>> ) -> Ptr<QGraphicsEllipseItem>`[src]

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.

Calls C++ function: QGraphicsEllipseItem* QGraphicsScene::addEllipse(const QRectF& rect, const QPen& pen = …).

C++ documentation:

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(), and addWidget().

`pub unsafe fn add_ellipse_1a( &self, rect: impl CastInto<Ref<QRectF>> ) -> Ptr<QGraphicsEllipseItem>`[src]

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.

Calls C++ function: QGraphicsEllipseItem* QGraphicsScene::addEllipse(const QRectF& rect).

C++ documentation:

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(), and addWidget().

`pub unsafe fn add_ellipse_5a( &self, x: c_double, y: c_double, w: c_double, h: c_double, pen: impl CastInto<Ref<QPen>> ) -> Ptr<QGraphicsEllipseItem>`[src]

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

Calls C++ function: QGraphicsEllipseItem* QGraphicsScene::addEllipse(double x, double y, double w, double h, const QPen& pen = …).

C++ documentation:

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

This function was introduced in Qt 4.3.

`pub unsafe fn add_ellipse_4a( &self, x: c_double, y: c_double, w: c_double, h: c_double ) -> Ptr<QGraphicsEllipseItem>`[src]

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

Calls C++ function: QGraphicsEllipseItem* QGraphicsScene::addEllipse(double x, double y, double w, double h).

C++ documentation:

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

This function was introduced in Qt 4.3.

`pub unsafe fn add_item(&self, item: impl CastInto<Ptr<QGraphicsItem>>)`[src]

Adds or moves the item and all its childen to this scene. This scene takes ownership of the item.

Calls C++ function: void QGraphicsScene::addItem(QGraphicsItem* item).

C++ documentation:

Adds or moves the item and all its childen to this scene. This scene takes ownership of the item.

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

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

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

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

See also removeItem(), addEllipse(), addLine(), addPath(), addPixmap(), addRect(), addText(), addWidget(), and Sorting.

`pub unsafe fn add_line_2a( &self, line: impl CastInto<Ref<QLineF>>, pen: impl CastInto<Ref<QPen>> ) -> Ptr<QGraphicsLineItem>`[src]

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.

Calls C++ function: QGraphicsLineItem* QGraphicsScene::addLine(const QLineF& line, const QPen& pen = …).

C++ documentation:

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(), and addWidget().

`pub unsafe fn add_line_5a( &self, x1: c_double, y1: c_double, x2: c_double, y2: c_double, pen: impl CastInto<Ref<QPen>> ) -> Ptr<QGraphicsLineItem>`[src]

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

Calls C++ function: QGraphicsLineItem* QGraphicsScene::addLine(double x1, double y1, double x2, double y2, const QPen& pen = …).

C++ documentation:

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

This function was introduced in Qt 4.3.

`pub unsafe fn add_line_1a( &self, line: impl CastInto<Ref<QLineF>> ) -> Ptr<QGraphicsLineItem>`[src]

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.

Calls C++ function: QGraphicsLineItem* QGraphicsScene::addLine(const QLineF& line).

C++ documentation:

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(), and addWidget().

`pub unsafe fn add_line_4a( &self, x1: c_double, y1: c_double, x2: c_double, y2: c_double ) -> Ptr<QGraphicsLineItem>`[src]

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

Calls C++ function: QGraphicsLineItem* QGraphicsScene::addLine(double x1, double y1, double x2, double y2).

C++ documentation:

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

This function was introduced in Qt 4.3.

`pub unsafe fn add_path_3a( &self, path: impl CastInto<Ref<QPainterPath>>, pen: impl CastInto<Ref<QPen>>, brush: impl CastInto<Ref<QBrush>> ) -> Ptr<QGraphicsPathItem>`[src]

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.

Calls C++ function: QGraphicsPathItem* QGraphicsScene::addPath(const QPainterPath& path, const QPen& pen = …, const QBrush& brush = …).

C++ documentation:

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(), and addWidget().

`pub unsafe fn add_path_2a( &self, path: impl CastInto<Ref<QPainterPath>>, pen: impl CastInto<Ref<QPen>> ) -> Ptr<QGraphicsPathItem>`[src]

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.

Calls C++ function: QGraphicsPathItem* QGraphicsScene::addPath(const QPainterPath& path, const QPen& pen = …).

C++ documentation:

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(), and addWidget().

`pub unsafe fn add_path_1a( &self, path: impl CastInto<Ref<QPainterPath>> ) -> Ptr<QGraphicsPathItem>`[src]

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.

Calls C++ function: QGraphicsPathItem* QGraphicsScene::addPath(const QPainterPath& path).

C++ documentation:

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(), and addWidget().

`pub unsafe fn add_pixmap( &self, pixmap: impl CastInto<Ref<QPixmap>> ) -> Ptr<QGraphicsPixmapItem>`[src]

Creates and adds a pixmap item to the scene, and returns the item pointer. The pixmap is defined by pixmap.

Calls C++ function: QGraphicsPixmapItem* QGraphicsScene::addPixmap(const QPixmap& pixmap).

C++ documentation:

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(), and addWidget().

`pub unsafe fn add_polygon_3a( &self, polygon: impl CastInto<Ref<QPolygonF>>, pen: impl CastInto<Ref<QPen>>, brush: impl CastInto<Ref<QBrush>> ) -> Ptr<QGraphicsPolygonItem>`[src]

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.

Calls C++ function: QGraphicsPolygonItem* QGraphicsScene::addPolygon(const QPolygonF& polygon, const QPen& pen = …, const QBrush& brush = …).

C++ documentation:

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(), and addWidget().

`pub unsafe fn add_polygon_2a( &self, polygon: impl CastInto<Ref<QPolygonF>>, pen: impl CastInto<Ref<QPen>> ) -> Ptr<QGraphicsPolygonItem>`[src]

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.

Calls C++ function: QGraphicsPolygonItem* QGraphicsScene::addPolygon(const QPolygonF& polygon, const QPen& pen = …).

C++ documentation:

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(), and addWidget().

`pub unsafe fn add_polygon_1a( &self, polygon: impl CastInto<Ref<QPolygonF>> ) -> Ptr<QGraphicsPolygonItem>`[src]

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.

Calls C++ function: QGraphicsPolygonItem* QGraphicsScene::addPolygon(const QPolygonF& polygon).

C++ documentation:

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(), and addWidget().

`pub unsafe fn add_rect_3a( &self, rect: impl CastInto<Ref<QRectF>>, pen: impl CastInto<Ref<QPen>>, brush: impl CastInto<Ref<QBrush>> ) -> Ptr<QGraphicsRectItem>`[src]

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.

Calls C++ function: QGraphicsRectItem* QGraphicsScene::addRect(const QRectF& rect, const QPen& pen = …, const QBrush& brush = …).

C++ documentation:

Creates and adds a rectangle item to the scene, and returns the item pointer. The geometry of the rectangle is defined by rect, and its pen and brush are initialized to pen and brush.

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

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

See also addEllipse(), addLine(), addPixmap(), addPixmap(), addText(), addItem(), and addWidget().

`pub unsafe fn add_rect_6a( &self, x: c_double, y: c_double, w: c_double, h: c_double, pen: impl CastInto<Ref<QPen>>, brush: impl CastInto<Ref<QBrush>> ) -> Ptr<QGraphicsRectItem>`[src]

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

Calls C++ function: QGraphicsRectItem* QGraphicsScene::addRect(double x, double y, double w, double h, const QPen& pen = …, const QBrush& brush = …).

C++ documentation:

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

This function was introduced in Qt 4.3.

`pub unsafe fn add_rect_2a( &self, rect: impl CastInto<Ref<QRectF>>, pen: impl CastInto<Ref<QPen>> ) -> Ptr<QGraphicsRectItem>`[src]

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.

Calls C++ function: QGraphicsRectItem* QGraphicsScene::addRect(const QRectF& rect, const QPen& pen = …).

C++ documentation:

Creates and adds a rectangle item to the scene, and returns the item pointer. The geometry of the rectangle is defined by rect, and its pen and brush are initialized to pen and brush.

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

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

See also addEllipse(), addLine(), addPixmap(), addPixmap(), addText(), addItem(), and addWidget().

`pub unsafe fn add_rect_1a( &self, rect: impl CastInto<Ref<QRectF>> ) -> Ptr<QGraphicsRectItem>`[src]

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.

Calls C++ function: QGraphicsRectItem* QGraphicsScene::addRect(const QRectF& rect).

C++ documentation:

Creates and adds a rectangle item to the scene, and returns the item pointer. The geometry of the rectangle is defined by rect, and its pen and brush are initialized to pen and brush.

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

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

See also addEllipse(), addLine(), addPixmap(), addPixmap(), addText(), addItem(), and addWidget().

`pub unsafe fn add_rect_5a( &self, x: c_double, y: c_double, w: c_double, h: c_double, pen: impl CastInto<Ref<QPen>> ) -> Ptr<QGraphicsRectItem>`[src]

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

Calls C++ function: QGraphicsRectItem* QGraphicsScene::addRect(double x, double y, double w, double h, const QPen& pen = …).

C++ documentation:

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

This function was introduced in Qt 4.3.

`pub unsafe fn add_rect_4a( &self, x: c_double, y: c_double, w: c_double, h: c_double ) -> Ptr<QGraphicsRectItem>`[src]

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

Calls C++ function: QGraphicsRectItem* QGraphicsScene::addRect(double x, double y, double w, double h).

C++ documentation:

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

This function was introduced in Qt 4.3.

`pub unsafe fn add_simple_text_2a( &self, text: impl CastInto<Ref<QString>>, font: impl CastInto<Ref<QFont>> ) -> Ptr<QGraphicsSimpleTextItem>`[src]

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.

Calls C++ function: QGraphicsSimpleTextItem* QGraphicsScene::addSimpleText(const QString& text, const QFont& font = …).

C++ documentation:

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(), and addWidget().

`pub unsafe fn add_simple_text_1a( &self, text: impl CastInto<Ref<QString>> ) -> Ptr<QGraphicsSimpleTextItem>`[src]

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.

Calls C++ function: QGraphicsSimpleTextItem* QGraphicsScene::addSimpleText(const QString& text).

C++ documentation:

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(), and addWidget().

`pub unsafe fn add_text_2a( &self, text: impl CastInto<Ref<QString>>, font: impl CastInto<Ref<QFont>> ) -> QPtr<QGraphicsTextItem>`[src]

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.

Calls C++ function: QGraphicsTextItem* QGraphicsScene::addText(const QString& text, const QFont& font = …).

C++ documentation:

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(), and addWidget().

`pub unsafe fn add_text_1a( &self, text: impl CastInto<Ref<QString>> ) -> QPtr<QGraphicsTextItem>`[src]

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.

Calls C++ function: QGraphicsTextItem* QGraphicsScene::addText(const QString& text).

C++ documentation:

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(), and addWidget().

`pub unsafe fn add_widget_2a( &self, widget: impl CastInto<Ptr<QWidget>>, w_flags: QFlags<WindowType> ) -> QPtr<QGraphicsProxyWidget>`[src]

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.

Calls C++ function: QGraphicsProxyWidget* QGraphicsScene::addWidget(QWidget* widget, QFlags<Qt::WindowType> wFlags = …).

C++ documentation:

Creates a new QGraphicsProxyWidget for widget, adds it to the scene, and returns a pointer to the proxy. wFlags set the default window flags for the embedding proxy widget.

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

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

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

See also addEllipse(), addLine(), addPixmap(), addPixmap(), addRect(), addText(), addSimpleText(), and addItem().

`pub unsafe fn add_widget_1a( &self, widget: impl CastInto<Ptr<QWidget>> ) -> QPtr<QGraphicsProxyWidget>`[src]

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.

Calls C++ function: QGraphicsProxyWidget* QGraphicsScene::addWidget(QWidget* widget).

C++ documentation:

Creates a new QGraphicsProxyWidget for widget, adds it to the scene, and returns a pointer to the proxy. wFlags set the default window flags for the embedding proxy widget.

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

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

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

See also addEllipse(), addLine(), addPixmap(), addPixmap(), addRect(), addText(), addSimpleText(), and addItem().

`pub unsafe fn advance(&self)`[src]

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.

Calls C++ function: [slot] void QGraphicsScene::advance().

C++ documentation:

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 Animation Framework for animations.

See also QGraphicsItem::advance() and QTimeLine.

`pub unsafe fn background_brush(&self) -> CppBox<QBrush>`[src]

This property holds the background brush of the scene.

Calls C++ function: QBrush QGraphicsScene::backgroundBrush() const.

C++ documentation:

This property holds the background brush of the scene.

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

Example:

QGraphicsScene scene;
QGraphicsView view(&scene);
view.show();
// a blue background
scene.setBackgroundBrush(Qt::blue);
// a gradient background
QRadialGradient gradient(0, 0, 10);
gradient.setSpread(QGradient::RepeatSpread);
scene.setBackgroundBrush(gradient);

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

Access functions:

QBrush	backgroundBrush() const
void	setBackgroundBrush(const QBrush &brush)

`pub unsafe fn bsp_tree_depth(&self) -> c_int`[src]

This property holds the depth of QGraphicsScene's BSP index tree

Calls C++ function: int QGraphicsScene::bspTreeDepth() const.

C++ documentation:

This property holds the depth of QGraphicsScene's BSP index tree

This property has no effect when NoIndex is used.

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

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

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

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

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

This property was introduced in Qt 4.3.

Access functions:

int	bspTreeDepth() const
void	setBspTreeDepth(int depth)

See also itemIndexMethod.

`pub unsafe fn clear(&self)`[src]

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

Calls C++ function: [slot] void QGraphicsScene::clear().

C++ documentation:

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

This function was introduced in Qt 4.4.

See also addItem().

`pub unsafe fn clear_focus(&self)`[src]

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.

Calls C++ function: void QGraphicsScene::clearFocus().

C++ documentation:

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(), and setFocusItem().

`pub unsafe fn clear_selection(&self)`[src]

Clears the current selection.

Calls C++ function: [slot] void QGraphicsScene::clearSelection().

C++ documentation:

Clears the current selection.

See also setSelectionArea() and selectedItems().

`pub unsafe fn colliding_items_2a( &self, item: impl CastInto<Ptr<QGraphicsItem>>, mode: ItemSelectionMode ) -> CppBox<QListOfQGraphicsItem>`[src]

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.

Calls C++ function: QList<QGraphicsItem*> QGraphicsScene::collidingItems(const QGraphicsItem* item, Qt::ItemSelectionMode mode = …) const.

C++ documentation:

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(), and Sorting.

`pub unsafe fn colliding_items_1a( &self, item: impl CastInto<Ptr<QGraphicsItem>> ) -> CppBox<QListOfQGraphicsItem>`[src]

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.

Calls C++ function: QList<QGraphicsItem*> QGraphicsScene::collidingItems(const QGraphicsItem* item) const.

C++ documentation:

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(), and Sorting.

`pub unsafe fn create_item_group( &self, items: impl CastInto<Ref<QListOfQGraphicsItem>> ) -> Ptr<QGraphicsItemGroup>`[src]

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.

Calls C++ function: QGraphicsItemGroup* QGraphicsScene::createItemGroup(const QList<QGraphicsItem*>& items).

C++ documentation:

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

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

See also destroyItemGroup() and QGraphicsItemGroup::addToGroup().

`pub unsafe fn destroy_item_group( &self, group: impl CastInto<Ptr<QGraphicsItemGroup>> )`[src]

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.

Calls C++ function: void QGraphicsScene::destroyItemGroup(QGraphicsItemGroup* group).

C++ documentation:

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

See also createItemGroup() and QGraphicsItemGroup::removeFromGroup().

`pub unsafe fn focus_item(&self) -> Ptr<QGraphicsItem>`[src]

When the scene is active, this functions returns the scene's current focus item, or 0 if no item currently has focus. When the scene is inactive, this functions returns the item that will gain input focus when the scene becomes active.

Calls C++ function: QGraphicsItem* QGraphicsScene::focusItem() const.

C++ documentation:

When the scene is active, this functions returns the scene's current focus item, or 0 if no item currently has focus. When the scene is inactive, this functions returns the item that will gain input focus when the scene becomes active.

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

See also setFocusItem(), QGraphicsItem::hasFocus(), and isActive().

`pub unsafe fn focus_on_touch(&self) -> bool`[src]

This is supported on cpp_lib_version="5.12.2" or cpp_lib_version="5.13.0" or cpp_lib_version="5.14.0" only.

This property holds whether items gain focus when receiving a touch begin event.

Calls C++ function: bool QGraphicsScene::focusOnTouch() const.

C++ documentation:

This property holds whether items gain focus when receiving a touch begin event.

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.

This property was introduced in Qt 5.12.

Access functions:

bool	focusOnTouch() const
void	setFocusOnTouch(bool enabled)

`pub unsafe fn font(&self) -> CppBox<QFont>`[src]

This property holds the scene's default font

Calls C++ function: QFont QGraphicsScene::font() const.

C++ documentation:

This property holds the scene's default font

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

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

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

This property was introduced in Qt 4.4.

Access functions:

QFont	font() const
void	setFont(const QFont &font)

See also QWidget::font, QApplication::setFont(), palette, and style().

`pub unsafe fn foreground_brush(&self) -> CppBox<QBrush>`[src]

This property holds the foreground brush of the scene.

Calls C++ function: QBrush QGraphicsScene::foregroundBrush() const.

C++ documentation:

This property holds the foreground brush of the scene.

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

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

Example:

QGraphicsScene scene;
QGraphicsView view(&scene);
view.show();
// a white semi-transparent foreground
scene.setForegroundBrush(QColor(255, 255, 255, 127));
// a grid foreground
scene.setForegroundBrush(QBrush(Qt::lightGray, Qt::CrossPattern));

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

Access functions:

QBrush	foregroundBrush() const
void	setForegroundBrush(const QBrush &brush)

`pub unsafe fn has_focus(&self) -> bool`[src]

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.

Calls C++ function: bool QGraphicsScene::hasFocus() const.

C++ documentation:

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

`pub unsafe fn height(&self) -> c_double`[src]

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

Calls C++ function: double QGraphicsScene::height() const.

C++ documentation:

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

See also width().

`pub unsafe fn input_method_query( &self, query: InputMethodQuery ) -> CppBox<QVariant>`[src]

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.

Calls C++ function: virtual QVariant QGraphicsScene::inputMethodQuery(Qt::InputMethodQuery query) const.

C++ documentation:

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

`pub unsafe fn invalidate_5a( &self, x: c_double, y: c_double, w: c_double, h: c_double, layers: QFlags<SceneLayer> )`[src]

This is an overloaded function.

Calls C++ function: void QGraphicsScene::invalidate(double x, double y, double w, double h, QFlags<QGraphicsScene::SceneLayer> layers = …).

C++ documentation:

This is an overloaded function.

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

This function was introduced in Qt 4.3.

`pub unsafe fn invalidate_2a( &self, rect: impl CastInto<Ref<QRectF>>, layers: QFlags<SceneLayer> )`[src]

Invalidates and schedules a redraw of the layers in rect on the scene. Any cached content in layers is unconditionally invalidated and redrawn.

Calls C++ function: [slot] void QGraphicsScene::invalidate(const QRectF& rect = …, QFlags<QGraphicsScene::SceneLayer> layers = …).

C++ documentation:

Invalidates and schedules a redraw of the layers in rect on the scene. Any cached content in layers is unconditionally invalidated and redrawn.

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

Example:

QRectF TileScene::rectForTile(int x, int y) const
{
      // Return the rectangle for the tile at position (x, y).
      return QRectF(x  tileWidth, y  tileHeight, tileWidth, tileHeight);
}
void TileScene::setTile(int x, int y, const QPixmap &pixmap)
{
      // Sets or replaces the tile at position (x, y) with pixmap.
      if (x >= 0 && x < numTilesH && y >= 0 && y < numTilesV) {
          tiles[y][x] = pixmap;
          invalidate(rectForTile(x, y), BackgroundLayer);
      }
}
void TileScene::drawBackground(QPainter *painter, const QRectF &exposed)
{
      // Draws all tiles that intersect the exposed area.
      for (int y = 0; y < numTilesV; ++y) {
          for (int x = 0; x < numTilesH; ++x) {
              QRectF rect = rectForTile(x, y);
              if (exposed.intersects(rect))
                  painter->drawPixmap(rect.topLeft(), tiles[y][x]);
          }
      }
}

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

See also QGraphicsView::resetCachedContent().

`pub unsafe fn invalidate_4a( &self, x: c_double, y: c_double, w: c_double, h: c_double )`[src]

This is an overloaded function.

Calls C++ function: void QGraphicsScene::invalidate(double x, double y, double w, double h).

C++ documentation:

This is an overloaded function.

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

This function was introduced in Qt 4.3.

`pub unsafe fn invalidate_1a(&self, rect: impl CastInto<Ref<QRectF>>)`[src]

Invalidates and schedules a redraw of the layers in rect on the scene. Any cached content in layers is unconditionally invalidated and redrawn.

Calls C++ function: [slot] void QGraphicsScene::invalidate(const QRectF& rect = …).

C++ documentation:

Invalidates and schedules a redraw of the layers in rect on the scene. Any cached content in layers is unconditionally invalidated and redrawn.

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

Example:

QRectF TileScene::rectForTile(int x, int y) const
{
      // Return the rectangle for the tile at position (x, y).
      return QRectF(x  tileWidth, y  tileHeight, tileWidth, tileHeight);
}
void TileScene::setTile(int x, int y, const QPixmap &pixmap)
{
      // Sets or replaces the tile at position (x, y) with pixmap.
      if (x >= 0 && x < numTilesH && y >= 0 && y < numTilesV) {
          tiles[y][x] = pixmap;
          invalidate(rectForTile(x, y), BackgroundLayer);
      }
}
void TileScene::drawBackground(QPainter *painter, const QRectF &exposed)
{
      // Draws all tiles that intersect the exposed area.
      for (int y = 0; y < numTilesV; ++y) {
          for (int x = 0; x < numTilesH; ++x) {
              QRectF rect = rectForTile(x, y);
              if (exposed.intersects(rect))
                  painter->drawPixmap(rect.topLeft(), tiles[y][x]);
          }
      }
}

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

See also QGraphicsView::resetCachedContent().

`pub unsafe fn invalidate_0a(&self)`[src]

Invalidates and schedules a redraw of the layers in rect on the scene. Any cached content in layers is unconditionally invalidated and redrawn.

Calls C++ function: [slot] void QGraphicsScene::invalidate().

C++ documentation:

Invalidates and schedules a redraw of the layers in rect on the scene. Any cached content in layers is unconditionally invalidated and redrawn.

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

Example:

QRectF TileScene::rectForTile(int x, int y) const
{
      // Return the rectangle for the tile at position (x, y).
      return QRectF(x  tileWidth, y  tileHeight, tileWidth, tileHeight);
}
void TileScene::setTile(int x, int y, const QPixmap &pixmap)
{
      // Sets or replaces the tile at position (x, y) with pixmap.
      if (x >= 0 && x < numTilesH && y >= 0 && y < numTilesV) {
          tiles[y][x] = pixmap;
          invalidate(rectForTile(x, y), BackgroundLayer);
      }
}
void TileScene::drawBackground(QPainter *painter, const QRectF &exposed)
{
      // Draws all tiles that intersect the exposed area.
      for (int y = 0; y < numTilesV; ++y) {
          for (int x = 0; x < numTilesH; ++x) {
              QRectF rect = rectForTile(x, y);
              if (exposed.intersects(rect))
                  painter->drawPixmap(rect.topLeft(), tiles[y][x]);
          }
      }
}

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

See also QGraphicsView::resetCachedContent().

`pub unsafe fn is_active(&self) -> bool`[src]

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

Calls C++ function: bool QGraphicsScene::isActive() const.

C++ documentation:

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

This function was introduced in Qt 4.6.

See also QGraphicsItem::isActive() and QWidget::isActiveWindow().

`pub unsafe fn is_sort_cache_enabled(&self) -> bool`[src]

This property holds whether sort caching is enabled

Calls C++ function: bool QGraphicsScene::isSortCacheEnabled() const.

C++ documentation:

This property holds whether sort caching is enabled

Since Qt 4.6, this property has no effect.

This property was introduced in Qt 4.5.

Access functions:

bool	isSortCacheEnabled() const
void	setSortCacheEnabled(bool enabled)

Member Function Documentation

`pub unsafe fn item_at_2a( &self, pos: impl CastInto<Ref<QPointF>>, device_transform: impl CastInto<Ref<QTransform>> ) -> Ptr<QGraphicsItem>`[src]

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

Calls C++ function: QGraphicsItem* QGraphicsScene::itemAt(const QPointF& pos, const QTransform& deviceTransform) const.

C++ documentation:

Returns the topmost visible item at the specified position, or 0 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.

This function was introduced in Qt 4.6.

See also items(), collidingItems(), and Sorting.

`pub unsafe fn item_at_3a( &self, x: c_double, y: c_double, device_transform: impl CastInto<Ref<QTransform>> ) -> Ptr<QGraphicsItem>`[src]

This is an overloaded function.

Calls C++ function: QGraphicsItem* QGraphicsScene::itemAt(double x, double y, const QTransform& deviceTransform) const.

C++ documentation:

This is an overloaded function.

Returns the topmost visible item at the position specified by (x, y), or 0 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.

This function was introduced in Qt 4.6.

`pub unsafe fn item_index_method(&self) -> ItemIndexMethod`[src]

This property holds the item indexing method.

Calls C++ function: QGraphicsScene::ItemIndexMethod QGraphicsScene::itemIndexMethod() const.

C++ documentation:

This property holds the item indexing method.

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

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

Access functions:

ItemIndexMethod	itemIndexMethod() const
void	setItemIndexMethod(ItemIndexMethod method)

See also bspTreeDepth.