En esta página

QGraphicsScene Class

La clase QGraphicsScene proporciona una superficie para gestionar un gran número de elementos gráficos en 2D. Más información...

Encabezado: #include <QGraphicsScene>
CMake: find_package(Qt6 REQUIRED COMPONENTS Widgets)
target_link_libraries(mytarget PRIVATE Qt6::Widgets)
qmake: QT += widgets
Heredan de: QObject

Tipos públicos

enum ItemIndexMethod { BspTreeIndex, NoIndex }
enum SceneLayer { ItemLayer, BackgroundLayer, ForegroundLayer, AllLayers }
flags SceneLayers

Propiedades

Funciones públicas

QGraphicsScene(QObject *parent = nullptr)
QGraphicsScene(const QRectF &sceneRect, QObject *parent = nullptr)
QGraphicsScene(qreal x, qreal y, qreal width, qreal height, QObject *parent = nullptr)
virtual ~QGraphicsScene()
QGraphicsItem *activePanel() const
QGraphicsWidget *activeWindow() const
QGraphicsEllipseItem *addEllipse(const QRectF &rect, const QPen &pen = QPen(), const QBrush &brush = QBrush())
QGraphicsEllipseItem *addEllipse(qreal x, qreal y, qreal w, qreal h, const QPen &pen = QPen(), const QBrush &brush = QBrush())
void addItem(QGraphicsItem *item)
QGraphicsLineItem *addLine(const QLineF &line, const QPen &pen = QPen())
QGraphicsLineItem *addLine(qreal x1, qreal y1, qreal x2, qreal y2, const QPen &pen = QPen())
QGraphicsPathItem *addPath(const QPainterPath &path, const QPen &pen = QPen(), const QBrush &brush = QBrush())
QGraphicsPixmapItem *addPixmap(const QPixmap &pixmap)
QGraphicsPolygonItem *addPolygon(const QPolygonF &polygon, const QPen &pen = QPen(), const QBrush &brush = QBrush())
QGraphicsRectItem *addRect(const QRectF &rect, const QPen &pen = QPen(), const QBrush &brush = QBrush())
QGraphicsRectItem *addRect(qreal x, qreal y, qreal w, qreal h, const QPen &pen = QPen(), const QBrush &brush = QBrush())
QGraphicsSimpleTextItem *addSimpleText(const QString &text, const QFont &font = QFont())
QGraphicsTextItem *addText(const QString &text, const QFont &font = QFont())
QGraphicsProxyWidget *addWidget(QWidget *widget, Qt::WindowFlags wFlags = Qt::WindowFlags())
QBrush backgroundBrush() const
int bspTreeDepth() const
void clearFocus()
QList<QGraphicsItem *> collidingItems(const QGraphicsItem *item, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const
QGraphicsItemGroup *createItemGroup(const QList<QGraphicsItem *> &items)
void destroyItemGroup(QGraphicsItemGroup *group)
QGraphicsItem *focusItem() const
bool focusOnTouch() const
QFont font() const
QBrush foregroundBrush() const
bool hasFocus() const
qreal height() const
virtual QVariant inputMethodQuery(Qt::InputMethodQuery query) const
void invalidate(qreal x, qreal y, qreal w, qreal h, QGraphicsScene::SceneLayers layers = AllLayers)
bool isActive() const
QGraphicsItem *itemAt(const QPointF &position, const QTransform &deviceTransform) const
QGraphicsItem *itemAt(qreal x, qreal y, const QTransform &deviceTransform) const
QGraphicsScene::ItemIndexMethod itemIndexMethod() const
QList<QGraphicsItem *> items(Qt::SortOrder order = Qt::DescendingOrder) const
QList<QGraphicsItem *> items(const QPointF &pos, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape, Qt::SortOrder order = Qt::DescendingOrder, const QTransform &deviceTransform = QTransform()) const
QList<QGraphicsItem *> items(const QPainterPath &path, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape, Qt::SortOrder order = Qt::DescendingOrder, const QTransform &deviceTransform = QTransform()) const
QList<QGraphicsItem *> items(const QPolygonF &polygon, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape, Qt::SortOrder order = Qt::DescendingOrder, const QTransform &deviceTransform = QTransform()) const
QList<QGraphicsItem *> items(const QRectF &rect, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape, Qt::SortOrder order = Qt::DescendingOrder, const QTransform &deviceTransform = QTransform()) const
QList<QGraphicsItem *> items(qreal x, qreal y, qreal w, qreal h, Qt::ItemSelectionMode mode, Qt::SortOrder order, const QTransform &deviceTransform = QTransform()) const
QRectF itemsBoundingRect() const
qreal minimumRenderSize() const
QGraphicsItem *mouseGrabberItem() const
QPalette palette() const
void removeItem(QGraphicsItem *item)
void render(QPainter *painter, const QRectF &target = QRectF(), const QRectF &source = QRectF(), Qt::AspectRatioMode aspectRatioMode = Qt::KeepAspectRatio)
QRectF sceneRect() const
QList<QGraphicsItem *> selectedItems() const
QPainterPath selectionArea() const
bool sendEvent(QGraphicsItem *item, QEvent *event)
void setActivePanel(QGraphicsItem *item)
void setActiveWindow(QGraphicsWidget *widget)
void setBackgroundBrush(const QBrush &brush)
void setBspTreeDepth(int depth)
void setFocus(Qt::FocusReason focusReason = Qt::OtherFocusReason)
void setFocusItem(QGraphicsItem *item, Qt::FocusReason focusReason = Qt::OtherFocusReason)
void setFocusOnTouch(bool enabled)
void setFont(const QFont &font)
void setForegroundBrush(const QBrush &brush)
void setItemIndexMethod(QGraphicsScene::ItemIndexMethod method)
void setMinimumRenderSize(qreal minSize)
void setPalette(const QPalette &palette)
void setSceneRect(const QRectF &rect)
void setSceneRect(qreal x, qreal y, qreal w, qreal h)
void setSelectionArea(const QPainterPath &path, const QTransform &deviceTransform)
void setSelectionArea(const QPainterPath &path, Qt::ItemSelectionOperation selectionOperation = Qt::ReplaceSelection, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape, const QTransform &deviceTransform = QTransform())
void setStickyFocus(bool enabled)
void setStyle(QStyle *style)
bool stickyFocus() const
QStyle *style() const
void update(qreal x, qreal y, qreal w, qreal h)
QList<QGraphicsView *> views() const
qreal width() const

Ranuras públicas

void advance()
void clear()
void clearSelection()
void invalidate(const QRectF &rect = QRectF(), QGraphicsScene::SceneLayers layers = AllLayers)
void update(const QRectF &rect = QRectF())

Señales

void changed(const QList<QRectF> &region)
void focusItemChanged(QGraphicsItem *newFocusItem, QGraphicsItem *oldFocusItem, Qt::FocusReason reason)
void sceneRectChanged(const QRectF &rect)
void selectionChanged()

Funciones protegidas

virtual void contextMenuEvent(QGraphicsSceneContextMenuEvent *contextMenuEvent)
virtual void dragEnterEvent(QGraphicsSceneDragDropEvent *event)
virtual void dragLeaveEvent(QGraphicsSceneDragDropEvent *event)
virtual void dragMoveEvent(QGraphicsSceneDragDropEvent *event)
virtual void drawBackground(QPainter *painter, const QRectF &rect)
virtual void drawForeground(QPainter *painter, const QRectF &rect)
virtual void dropEvent(QGraphicsSceneDragDropEvent *event)
virtual void focusInEvent(QFocusEvent *focusEvent)
virtual void focusOutEvent(QFocusEvent *focusEvent)
virtual void helpEvent(QGraphicsSceneHelpEvent *helpEvent)
virtual void inputMethodEvent(QInputMethodEvent *event)
virtual void keyPressEvent(QKeyEvent *keyEvent)
virtual void keyReleaseEvent(QKeyEvent *keyEvent)
virtual void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *mouseEvent)
virtual void mouseMoveEvent(QGraphicsSceneMouseEvent *mouseEvent)
virtual void mousePressEvent(QGraphicsSceneMouseEvent *mouseEvent)
virtual void mouseReleaseEvent(QGraphicsSceneMouseEvent *mouseEvent)
virtual void wheelEvent(QGraphicsSceneWheelEvent *wheelEvent)

Funciones protegidas reimplementadas

virtual bool event(QEvent *event) override
virtual bool eventFilter(QObject *watched, QEvent *event) override

Ranuras protegidas

virtual bool focusNextPrevChild(bool next)

Descripción detallada

Esta clase sirve como contenedor para QGraphicsItems. Se utiliza junto con QGraphicsView para visualizar elementos gráficos, como líneas, rectángulos, texto o incluso elementos personalizados, en una superficie 2D. QGraphicsScene forma parte del Graphics View Framework.

QGraphicsScene también ofrece funcionalidades que permiten determinar de forma eficiente tanto la ubicación de los elementos como cuáles de ellos son visibles dentro de un área arbitraria de la escena. Con el widget « QGraphicsView », puedes visualizar la escena completa o ampliarla para ver solo partes de la misma.

Ejemplo:

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

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

Ten en cuenta que QGraphicsScene no tiene apariencia visual propia; solo gestiona los elementos. Es necesario crear un widget « QGraphicsView » para visualizar la escena.

Para añadir elementos a una escena, hay que empezar por crear un objeto QGraphicsScene. A continuación, tienes dos opciones: añadir tus objetos ` QGraphicsItem ` existentes llamando a ` addItem()`, o bien llamar a una de las funciones de conveniencia ` addEllipse()`, ` addLine()`, ` addPath()`, ` addPixmap()`, ` addPolygon()`, ` addRect()` o ` addText()`, todas las cuales devuelven un puntero al elemento recién añadido. Las dimensiones de los elementos añadidos con estas funciones son relativas al sistema de coordenadas del elemento, y la posición del elemento se inicializa en (0, 0) dentro de la escena.

A continuación, puede visualizar la escena utilizando ` QGraphicsView`. Cuando la escena cambia (por ejemplo, cuando un elemento se mueve o se transforma), `QGraphicsScene` emite la señal ` changed()`. Para eliminar un elemento, llame a ` removeItem()`.

QGraphicsScene utiliza un algoritmo de indexación para gestionar la ubicación de los elementos de forma eficiente. Por defecto, se utiliza un árbol BSP (partición binaria del espacio); un algoritmo adecuado para escenas grandes en las que la mayoría de los elementos permanecen estáticos (es decir, no se mueven). Puedes desactivar este índice llamando a setItemIndexMethod(). Para obtener más información sobre los algoritmos de indexación disponibles, consulta la propiedad itemIndexMethod.

El rectángulo delimitador de la escena se establece llamando a setSceneRect(). Los elementos pueden colocarse en cualquier posición de la escena y, por defecto, el tamaño de la escena es ilimitado. El rectángulo de la escena se utiliza únicamente para el control interno, manteniendo el índice de elementos de la escena. Si el rectángulo de la escena no está definido, QGraphicsScene utilizará el área delimitadora de todos los elementos, tal y como la devuelve itemsBoundingRect(), como rectángulo de la escena. Sin embargo, itemsBoundingRect() es una función que consume relativamente mucho tiempo, ya que opera recopilando información posicional de cada elemento de la escena. Por este motivo, siempre se debe establecer el rectángulo de la escena cuando se trabaje con escenas de gran tamaño.

Una de las mayores ventajas de QGraphicsScene es su capacidad para determinar de forma eficiente la ubicación de los elementos. Incluso con millones de elementos en la escena, las funciones items() pueden determinar la ubicación de un elemento en unos pocos milisegundos. Existen varias sobrecargas de la función ` items()`: una que busca elementos en una posición determinada, otra que busca elementos dentro de un polígono o un rectángulo, o que se cruzan con ellos, y otras más. La lista de elementos devueltos se ordena por orden de apilamiento, siendo el elemento superior el primero de la lista. Para mayor comodidad, también existe la función itemAt() que devuelve el elemento superior en una posición determinada.

QGraphicsScene mantiene la información de selección de la escena. Para seleccionar elementos, llama a setSelectionArea(), y para borrar la selección actual, llama a clearSelection(). Llama a selectedItems() para obtener la lista de todos los elementos seleccionados.

Gestión y propagación de eventos

Otra de las responsabilidades de QGraphicsScene es propagar eventos desde QGraphicsView. Para enviar un evento a una escena, se crea un evento que hereda de QEvent y, a continuación, se envía utilizando, por ejemplo, QCoreApplication::sendEvent(). event() se encarga de distribuir el evento a los elementos individuales. Algunos eventos comunes son gestionados por controladores de eventos predefinidos. Por ejemplo, los eventos de pulsación de tecla son gestionados por keyPressEvent(), y los eventos de pulsación del ratón son gestionados por mousePressEvent().

Los eventos de teclas se envían al elemento que tiene el foco. Para establecer el elemento con el foco, puedes llamar a ` setFocusItem()`, pasando un elemento que acepte el foco, o bien el propio elemento puede llamar a ` QGraphicsItem::setFocus()`. Llama a ` focusItem()` para obtener el elemento que tiene el foco actualmente. Para garantizar la compatibilidad con los widgets, la escena también mantiene su propia información de foco. Por defecto, la escena no tiene el foco y se descartan todos los eventos de teclas. Si se llama a ` setFocus()` o si un elemento de la escena obtiene el foco, la escena obtiene automáticamente el foco. Si la escena tiene el foco, ` hasFocus()` devolverá «true» y los eventos de teclas se reenviarán al elemento con el foco, si lo hay. Si la escena pierde el foco (es decir, si alguien llama a clearFocus()) mientras un elemento tiene el foco, la escena conservará la información de foco de ese elemento y, una vez que la escena recupere el foco, se asegurará de que el último elemento que tuviera el foco lo recupere de nuevo.

Para los efectos al pasar el ratón por encima, QGraphicsScene envía eventos de desplazamiento. Si un elemento acepta eventos de paso del ratón (véase QGraphicsItem::acceptHoverEvents()), recibirá un evento « GraphicsSceneHoverEnter » cuando el ratón entre en su área. A medida que el ratón continúe moviéndose dentro del área del elemento, QGraphicsScene le enviará eventos « GraphicsSceneHoverMove ». Cuando el ratón salga del área del elemento, este recibirá un evento « GraphicsSceneHoverLeave ».

Todos los eventos del ratón se envían al elemento que tiene actualmente el control del ratón. Un elemento se convierte en el controlador del ratón de la escena si acepta eventos del ratón (véase QGraphicsItem::acceptedMouseButtons()) y recibe una pulsación del ratón. Sigue siendo el controlador del ratón hasta que recibe una liberación del ratón cuando no hay ningún otro botón del ratón pulsado. Puedes llamar a mouseGrabberItem() para determinar qué elemento está capturando el ratón en ese momento.

Véase también QGraphicsItem y QGraphicsView.

Documentación sobre los tipos de miembros

enum QGraphicsScene::ItemIndexMethod

Esta enumeración describe los algoritmos de indexación que ofrece QGraphicsScene para gestionar la información posicional de los elementos de la escena.

ConstanteValorDescripción
QGraphicsScene::BspTreeIndex0Se aplica un árbol de partición binaria del espacio. Todos los algoritmos de localización de elementos de QGraphicsScene tienen una complejidad cercana a la logarítmica, gracias al uso de la búsqueda binaria. Añadir, mover y eliminar elementos tiene una complejidad logarítmica. Este enfoque es el más adecuado para escenas estáticas (es decir, escenas en las que la mayoría de los elementos no se mueven).
QGraphicsScene::NoIndex-1No se aplica ningún índice. La localización de elementos tiene una complejidad lineal, ya que se buscan todos los elementos de la escena. Sin embargo, añadir, mover y eliminar elementos se realiza en tiempo constante. Este enfoque es ideal para escenas dinámicas, en las que se añaden, mueven o eliminan muchos elementos de forma continua.

Véase también setItemIndexMethod() y bspTreeDepth.

enum QGraphicsScene::SceneLayer
flags QGraphicsScene::SceneLayers

Esta enumeración describe las capas de renderizado de un ` QGraphicsScene`. Cuando ` QGraphicsScene ` dibuja el contenido de la escena, renderiza cada una de estas capas por separado, en orden.

Cada capa representa un indicador que se puede combinar mediante la operación OR al llamar a funciones como invalidate() o QGraphicsView::invalidateScene().

ConstanteValorDescripción
QGraphicsScene::ItemLayer0x1La capa de elementos. QGraphicsScene renderiza todos los elementos que se encuentran en esta capa llamando a la función virtual drawItems(). La capa de elementos se dibuja después de la capa de fondo, pero antes de la capa de primer plano.
QGraphicsScene::BackgroundLayer0x2La capa de fondo. QGraphicsScene representa el fondo de la escena en esta capa llamando a la función virtual drawBackground(). La capa de fondo se dibuja en primer lugar, antes que el resto de capas.
QGraphicsScene::ForegroundLayer0x4La capa de primer plano. QGraphicsScene representa el primer plano de la escena en esta capa mediante la llamada a la función virtual drawForeground(). La capa de primer plano se dibuja en último lugar de todas las capas.
QGraphicsScene::AllLayers0xffffTodas las capas; este valor representa una combinación de las tres capas.

El tipo SceneLayers es un typedef para QFlags<SceneLayer>. Almacena una combinación OR de valores de SceneLayer.

Véase también invalidate() y QGraphicsView::invalidateScene().

Documentación de propiedades

backgroundBrush : QBrush

Esta propiedad contiene el pincel de fondo de la escena.

Establece esta propiedad para cambiar el fondo de la escena a un color, degradado o textura diferentes. El pincel de fondo predeterminado es Qt::NoBrush. El fondo se dibuja antes (detrás) de los elementos.

Ejemplo:

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() llama a drawBackground() para dibujar el fondo de la escena. Para un control más detallado sobre cómo se dibuja el fondo, puedes reimplementar drawBackground() en una subclase de QGraphicsScene.

Funciones de acceso:

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

bspTreeDepth : int

Esta propiedad contiene la profundidad del árbol de índices BSP de QGraphicsScene

Esta propiedad no tiene ningún efecto cuando se utiliza NoIndex.

Este valor determina la profundidad del árbol BSP de QGraphicsScene. La profundidad afecta directamente al rendimiento y al uso de memoria de QGraphicsScene; este último crece exponencialmente con la profundidad del árbol. Con una profundidad óptima del árbol, QGraphicsScene puede determinar al instante la localidad de los elementos, incluso en escenas con miles o millones de elementos. Esto también mejora considerablemente el rendimiento del renderizado.

Por defecto, el valor es 0; en ese caso, Qt estimará una profundidad predeterminada razonable basándose en el tamaño, la ubicación y el número de elementos de la escena. Sin embargo, si estos parámetros cambian con frecuencia, es posible que se produzcan ralentizaciones, ya que QGraphicsScene reajusta la profundidad internamente. Puedes evitar posibles ralentizaciones fijando la profundidad del árbol mediante la configuración de esta propiedad.

La profundidad del árbol y el tamaño del rectángulo de la escena determinan la granularidad de la partición de la escena. El tamaño de cada segmento de la escena viene determinado por el siguiente algoritmo:

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

El árbol BSP tiene un tamaño óptimo cuando cada segmento contiene entre 0 y 10 elementos.

Funciones de acceso:

int bspTreeDepth() const
void setBspTreeDepth(int depth)

Véase también itemIndexMethod.

focusOnTouch : bool

Esta propiedad indica si los elementos obtienen el foco al recibir un evento «touch begin ».

El comportamiento habitual es transferir el foco solo cuando se hace clic en un elemento. A menudo, el sistema operativo interpreta un toque en un panel táctil como equivalente a un clic del ratón, generando un evento de clic sintético como respuesta. Sin embargo, al menos en macOS, puedes configurar este comportamiento.

Por defecto, « QGraphicsScene » también transfiere el foco al tocar un trackpad o dispositivo similar. Si el sistema operativo está configurado para no generar un clic de ratón sintético al tocar el trackpad, esto resulta sorprendente. Si el sistema operativo sí genera clics de ratón sintéticos al tocar el trackpad, la transferencia del foco al iniciar un gesto táctil es innecesaria.

Con «focusOnTouch» desactivado, « QGraphicsScene » se comporta como cabría esperar en macOS.

El valor por defecto es « true », lo que garantiza que el comportamiento predeterminado sea el mismo que en las versiones de Qt anteriores a la 5.12. Establece el valor en « false » para evitar que los eventos táctiles provoquen cambios de foco.

Funciones de acceso:

bool focusOnTouch() const
void setFocusOnTouch(bool enabled)

font : QFont

Esta propiedad contiene la fuente predeterminada de la escena

Esta propiedad proporciona la fuente de la escena. La fuente predeterminada de la escena es QApplication::font, y todas sus entradas se resuelven a partir de ella.

Si la fuente de la escena cambia, ya sea directamente mediante setFont() o indirectamente cuando cambia la fuente de la aplicación, QGraphicsScene primero se envía a sí mismo un evento « FontChange » y, a continuación, envía eventos « FontChange » a todos los elementos de widget de nivel superior de la escena. Estos elementos responden aplicando sus propias fuentes a la escena y, a continuación, notifican a sus elementos secundarios, que a su vez notifican a los suyos, y así sucesivamente, hasta que todos los elementos de widget hayan actualizado sus fuentes.

Al cambiar la fuente de la escena (ya sea directamente o indirectamente mediante ` QApplication::setFont()`), se programa automáticamente un redibujado de toda la escena.

Funciones de acceso:

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

Véase también QWidget::font, QApplication::setFont(), palette y style().

foregroundBrush : QBrush

Esta propiedad contiene el pincel de primer plano de la escena.

Cambia esta propiedad para establecer el primer plano de la escena con un color, degradado o textura diferentes.

El primer plano se dibuja después (sobre) de los elementos. El pincel de primer plano predeterminado es « Qt::NoBrush » (es decir, el primer plano no se dibuja).

Ejemplo:

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() llama a drawForeground() para dibujar el primer plano de la escena. Para un control más detallado sobre cómo se dibuja el primer plano, puedes reimplementar la función drawForeground() en una subclase de QGraphicsScene.

Funciones de acceso:

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

itemIndexMethod : ItemIndexMethod

Esta propiedad contiene el método de indexación de elementos.

QGraphicsScene Aplica un algoritmo de indexación a la escena para acelerar las funciones de búsqueda de elementos, como items() y itemAt(). La indexación resulta más eficaz en escenas estáticas (es decir, en las que los elementos no se mueven). En escenas dinámicas, o con muchos elementos animados, el mantenimiento del índice puede contrarrestar las velocidades de búsqueda rápidas.

En el caso habitual, el método de indexación predeterminado BspTreeIndex funciona correctamente. Si tu escena utiliza muchas animaciones y notas lentitud, puedes desactivar la indexación llamando a setItemIndexMethod(NoIndex).

Funciones de acceso:

QGraphicsScene::ItemIndexMethod itemIndexMethod() const
void setItemIndexMethod(QGraphicsScene::ItemIndexMethod method)

Véase también bspTreeDepth.

minimumRenderSize : qreal

Esta propiedad establece el tamaño mínimo, transformado según la vista, que debe tener un elemento para que se dibuje

Cuando se renderiza la escena, cualquier elemento cuya anchura o altura, transformada a la vista de destino, sea inferior a minimumRenderSize(), no se renderizará. Si un elemento no se renderiza y recorta a sus elementos hijos, estos tampoco se renderizarán. Establece este valor para acelerar el renderizado de escenas con muchos objetos renderizados en una vista alejada.

El valor por defecto es 0. Si no se establece, o si se establece en 0 o en un valor negativo, todos los elementos se renderizarán siempre.

Por ejemplo, configurar esta propiedad puede resultar especialmente útil si una escena se renderiza mediante varias vistas, una de las cuales sirve como vista general que siempre muestra todos los elementos. En escenas con muchos elementos, dicha vista utilizará un factor de escala elevado para que se puedan mostrar todos los elementos. Debido a la escala, los elementos más pequeños solo aportarán una contribución insignificante a la escena renderizada final. Para evitar dibujar estos elementos y reducir el tiempo necesario para renderizar la escena, puedes llamar a `setMinimumRenderSize()` con un valor no negativo.

Nota: Los elementos que no se dibujan por ser demasiado pequeños siguen siendo devueltos por métodos como items() y itemAt(), y participan en la detección de colisiones y en las interacciones. Se recomienda establecer minimumRenderSize() en un valor menor o igual a 1 para evitar que haya elementos grandes no renderizados que sean interactivos.

Funciones de acceso:

qreal minimumRenderSize() const
void setMinimumRenderSize(qreal minSize)

Véase también ` QStyleOptionGraphicsItem::levelOfDetailFromTransform()`.

palette : QPalette

Esta propiedad contiene la paleta predeterminada de la escena

Esta propiedad proporciona la paleta de la escena. La paleta de la escena toma por defecto QApplication::palette y resuelve todas sus entradas a partir de ella.

Si la paleta de la escena cambia, ya sea directamente mediante setPalette() o indirectamente cuando cambia la paleta de la aplicación, QGraphicsScene primero se envía a sí misma un evento « PaletteChange » y, a continuación, envía eventos « PaletteChange » a todos los elementos de widget de nivel superior de la escena. Estos elementos responden resolviendo sus propias paletas para la escena y, a continuación, notifican a sus elementos secundarios, que a su vez notifican a los suyos, y así sucesivamente, hasta que todos los elementos de widget hayan actualizado sus paletas.

Al cambiar la paleta de la escena (ya sea directamente o de forma indirecta mediante ` QApplication::setPalette()`), se programa automáticamente un redibujado de toda la escena.

Funciones de acceso:

QPalette palette() const
void setPalette(const QPalette &palette)

Véase también QWidget::palette, QApplication::setPalette(), font y style().

sceneRect : QRectF

Esta propiedad contiene el rectángulo de la escena; el rectángulo delimitador de la escena

El rectángulo de la escena define la extensión de la misma. Lo utilizan principalmente QGraphicsView para determinar el área desplazable por defecto de la vista, y QGraphicsScene para gestionar la indexación de los elementos.

Si no se establece, o si se establece en un QRectF nulo, sceneRect() devolverá el rectángulo delimitador más grande de todos los elementos de la escena desde que se creó esta (es decir, un rectángulo que crece cuando se añaden o se mueven elementos en la escena, pero que nunca se reduce).

Funciones de acceso:

QRectF sceneRect() const
void setSceneRect(const QRectF &rect)
void setSceneRect(qreal x, qreal y, qreal w, qreal h)

Véase también width(), height() y QGraphicsView::sceneRect.

stickyFocus : bool

Esta propiedad determina si al hacer clic en el fondo de la escena se perderá el foco

En un ` QGraphicsScene ` con `stickyFocus` establecido en `true`, el foco permanecerá sin cambios cuando el usuario haga clic en el fondo de la escena o en un elemento que no acepte el foco. De lo contrario, el foco se perderá.

Por defecto, esta propiedad es ` false`.

El foco cambia en respuesta a una pulsación del ratón. Puedes reimplementar ` mousePressEvent()` en una subclase de ` QGraphicsScene ` para activar o desactivar esta propiedad en función de dónde haya hecho clic el usuario.

Funciones de acceso:

bool stickyFocus() const
void setStickyFocus(bool enabled)

Véase también clearFocus() y setFocusItem().

Documentación de funciones de miembro

QGraphicsScene::QGraphicsScene(QObject *parent = nullptr)

Crea un objeto `QGraphicsScene`. El parámetro ` parent ` se pasa al constructor de ` QObject`.

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

Crea un objeto `QGraphicsScene` utilizando ` sceneRect ` como rectángulo de escena. El parámetro ` parent ` se pasa al constructor de ` QObject`.

Véase también sceneRect.

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

Crea un objeto `QGraphicsScene` utilizando el rectángulo especificado por (x, y) y los valores ` width ` y ` height ` proporcionados para su rectángulo de escena. El parámetro ` parent ` se pasa al constructor de ` QObject`.

Véase también sceneRect.

[virtual noexcept] QGraphicsScene::~QGraphicsScene()

Elimina y borra todos los elementos del objeto de escena antes de destruir dicho objeto. El objeto de escena se elimina de la lista global de escenas de la aplicación y de todas las vistas asociadas.

QGraphicsItem *QGraphicsScene::activePanel() const

Devuelve el panel activo actualmente o ` nullptr ` si no hay ningún panel activo en este momento.

Véase también QGraphicsScene::setActivePanel().

QGraphicsWidget *QGraphicsScene::activeWindow() const

Devuelve la ventana activa actual o ` nullptr ` si no hay ninguna ventana activa en ese momento.

Véase también QGraphicsScene::setActiveWindow().

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

Crea y añade un elemento elíptico a la escena, y devuelve el puntero al elemento. La geometría de la elipse viene definida por rect, y su pluma y pincel se inicializan con pen y brush.

Ten en cuenta que la geometría del elemento se proporciona en coordenadas del elemento, y su posición se inicializa en (0, 0).

Si el elemento está visible (es decir, QGraphicsItem::isVisible() devuelve true), QGraphicsScene emitirá changed() una vez que el control vuelva al bucle de eventos.

Véase también addLine(), addPath(), addPixmap(), addRect(), addText(), addItem() y addWidget().

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

Esta función de conveniencia equivale a llamar a addEllipse(QRectF(x, y, w, h), pen, brush).

void QGraphicsScene::addItem(QGraphicsItem *item)

Añade o mueve el item y todos sus elementos secundarios a esta escena. Esta escena asume la propiedad del item.

Si el elemento está visible (es decir, QGraphicsItem::isVisible() devuelve «true»), QGraphicsScene emitirá changed() en cuanto el control vuelva al bucle de eventos.

Si el elemento ya se encuentra en otra escena, primero se eliminará de su escena anterior y, a continuación, se añadirá a esta escena como elemento de nivel superior.

QGraphicsScene Enviará notificaciones de «ItemSceneChange» a « item » mientras se añade a la escena. Si el elemento no pertenece actualmente a ninguna escena, solo se envía una notificación. Si ya pertenece a una escena (es decir, se traslada a esta escena), « QGraphicsScene » enviará una notificación adicional cuando el elemento se elimine de su escena anterior.

Si el elemento es un panel, la escena está activa y no hay ningún panel activo en la escena, entonces el elemento se activará.

Véase también removeItem(), addEllipse(), addLine(), addPath(), addPixmap(), addRect(), addText(), addWidget() y Sorting.

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

Crea y añade un elemento de línea a la escena, y devuelve el puntero al elemento. La geometría de la línea viene definida por ` line`, y su trazo se inicializa con ` pen`.

Ten en cuenta que la geometría del elemento se proporciona en coordenadas del elemento, y su posición se inicializa en (0, 0).

Si el elemento es visible (es decir, QGraphicsItem::isVisible() devuelve true), QGraphicsScene emitirá changed() una vez que el control vuelva al bucle de eventos.

Véase también addEllipse(), addPath(), addPixmap(), addRect(), addText(), addItem() y addWidget().

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

Esta función de conveniencia equivale a llamar a addLine(QLineF(x1, y1, x2, y2), pen).

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

Crea y añade un elemento de trazado a la escena, y devuelve el puntero al elemento. La geometría del trazado viene definida por path, y su pluma y pincel se inicializan con pen y brush.

Ten en cuenta que la geometría del elemento se proporciona en coordenadas del elemento, y su posición se inicializa en (0, 0).

Si el elemento es visible (es decir, QGraphicsItem::isVisible() devuelve true), QGraphicsScene emitirá changed() una vez que el control vuelva al bucle de eventos.

Véase también addEllipse(), addLine(), addPixmap(), addRect(), addText(), addItem() y addWidget().

QGraphicsPixmapItem *QGraphicsScene::addPixmap(const QPixmap &pixmap)

Crea y añade un elemento «pixmap» a la escena, y devuelve el puntero al elemento. El «pixmap» se define mediante pixmap.

Ten en cuenta que la geometría del elemento se proporciona en coordenadas del elemento, y su posición se inicializa en (0, 0).

Si el elemento es visible (es decir, si QGraphicsItem::isVisible() devuelve true), QGraphicsScene emitirá changed() una vez que el control vuelva al bucle de eventos.

Véase también addEllipse(), addLine(), addPath(), addRect(), addText(), addItem() y addWidget().

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

Crea y añade un elemento poligonal a la escena, y devuelve el puntero al elemento. El polígono viene definido por polygon, y su pluma y pincel se inicializan con pen y brush.

Ten en cuenta que la geometría del elemento se proporciona en coordenadas del elemento, y su posición se inicializa en (0, 0).

Si el elemento está visible (es decir, QGraphicsItem::isVisible() devuelve true), QGraphicsScene emitirá changed() en cuanto el control vuelva al bucle de eventos.

Véanse también addEllipse(), addLine(), addPath(), addRect(), addText(), addItem() y addWidget().

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

Crea y añade un elemento rectangular a la escena, y devuelve el puntero al elemento. La geometría del rectángulo viene definida por rect, y su pluma y pincel se inicializan con pen y brush.

Ten en cuenta que la geometría del elemento se proporciona en coordenadas del elemento, y su posición se inicializa en (0, 0). Por ejemplo, si se añade un QRect(50, 50, 100, 100), su esquina superior izquierda estará en (50, 50) con respecto al origen en el sistema de coordenadas del elemento.

Si el elemento es visible (es decir, QGraphicsItem::isVisible() devuelve true), QGraphicsScene emitirá changed() una vez que el control vuelva al bucle de eventos.

Véase también addEllipse(), addLine(), addPixmap(), addText(), addItem() y addWidget().

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

Esta función de conveniencia equivale a llamar a addRect(QRectF(x, y, w, h), pen, brush).

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

Crea y añade un elemento « QGraphicsSimpleTextItem » a la escena, y devuelve el puntero al elemento. La cadena de texto se inicializa con el valor « text », y su fuente se inicializa con « font ».

La posición del elemento se inicializa en (0, 0).

Si el elemento está visible (es decir, QGraphicsItem::isVisible() devuelve true), QGraphicsScene emitirá changed() una vez que el control vuelva al bucle de eventos.

Véase también addEllipse(), addLine(), addPixmap(), addRect(), addItem() y addWidget().

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

Crea y añade un elemento de texto a la escena, y devuelve el puntero al elemento. La cadena de texto se inicializa con « text », y su fuente se inicializa con « font ».

La posición del elemento se inicializa en (0, 0).

Si el elemento está visible (es decir, si QGraphicsItem::isVisible() devuelve true), QGraphicsScene emitirá changed() una vez que el control vuelva al bucle de eventos.

Véase también addEllipse(), addLine(), addPixmap(), addRect(), addItem() y addWidget().

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

Crea un nuevo ` QGraphicsProxyWidget ` para ` widget`, lo añade a la escena y devuelve un puntero al proxy. ` wFlags ` establece los indicadores de ventana predeterminados para el widget proxy de incrustación.

La posición del elemento se inicializa en (0, 0).

Si el elemento está visible (es decir, QGraphicsItem::isVisible() devuelve true), QGraphicsScene emitirá changed() una vez que el control vuelva al bucle de eventos.

Ten en cuenta que no se admiten los widgets con el atributo « Qt::WA_PaintOnScreen » activado ni los widgets que envuelven una aplicación o un controlador externo. Algunos ejemplos son « QOpenGLWidget » y «QAxWidget».

Véase también addEllipse(), addLine(), addPixmap(), addRect(), addText(), addSimpleText() y addItem().

[slot] void QGraphicsScene::advance()

Esta ranura hace avanzar la escena un paso, llamando a QGraphicsItem::advance() para todos los elementos de la escena. Esto se lleva a cabo en dos fases: en la primera fase, se notifica a todos los elementos que la escena está a punto de cambiar, y en la segunda fase se les notifica que pueden moverse. En la primera fase, se llama a QGraphicsItem::advance() pasando el valor 0 como argumento, y en la segunda fase se pasa el valor 1.

Ten en cuenta que también puedes utilizar el Marco de animación para las animaciones.

Véanse también QGraphicsItem::advance() y QTimeLine.

[signal] void QGraphicsScene::changed(const QList<QRectF> &region)

QGraphicsScene emite esta señal cuando el control llega al bucle de eventos, si cambia el contenido de la escena. El parámetro « region » contiene una lista de rectángulos de la escena que indican el área que se ha modificado.

Véase también QGraphicsView::updateScene().

[slot] void QGraphicsScene::clear()

Elimina y borra todos los elementos de la escena, pero por lo demás mantiene inalterado el estado de la misma.

Véase también addItem().

void QGraphicsScene::clearFocus()

Elimina el foco de la escena. Si algún elemento tiene el foco cuando se llama a esta función, lo perderá y lo recuperará de nuevo una vez que la escena recupere el foco.

Una escena que no tiene el foco ignora los eventos de teclas.

Véase también hasFocus(), setFocus() y setFocusItem().

[slot] void QGraphicsScene::clearSelection()

Borra la selección actual.

Véase también setSelectionArea() y selectedItems().

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

Devuelve una lista de todos los elementos que colisionan con item. Las colisiones se determinan llamando a QGraphicsItem::collidesWithItem(); la detección de colisiones se establece mediante mode. Por defecto, se devuelven todos los elementos cuya forma se cruza con item o que están contenidos dentro de la forma de item.

Los elementos se devuelven en orden de apilamiento descendente (es decir, el primer elemento de la lista es el más superior y el último es el más inferior).

Véase también items(), itemAt(), QGraphicsItem::collidesWithItem() y Sorting.

[virtual protected] void QGraphicsScene::contextMenuEvent(QGraphicsSceneContextMenuEvent *contextMenuEvent)

Este controlador de eventos, para el evento ` contextMenuEvent`, puede reimplementarse en una subclase para recibir eventos del menú contextual. La implementación predeterminada reenvía el evento al elemento visible más superpuesto que acepte eventos del menú contextual en la posición del evento. Si ningún elemento acepta eventos del menú contextual en esa posición, el evento se ignora.

Nota: Consulte items() para conocer qué elementos se consideran visibles por esta función.

Véase también QGraphicsItem::contextMenuEvent().

QGraphicsItemGroup *QGraphicsScene::createItemGroup(const QList<QGraphicsItem *> &items)

Agrupa todos los elementos de ` items ` en un nuevo ` QGraphicsItemGroup` y devuelve un puntero al grupo. El grupo se crea con el antepasado común de items como padre y con la posición (0, 0). Todos los elementos pasan a tener como padre al grupo, y sus posiciones y transformaciones se asignan al grupo. Si items está vacío, esta función devolverá un QGraphicsItemGroup de nivel superior vacío.

QGraphicsScene tiene la propiedad del elemento del grupo; no es necesario eliminarlo. Para desmontar (desagrupar) un grupo, llama a destroyItemGroup().

Véanse también destroyItemGroup() y QGraphicsItemGroup::addToGroup().

void QGraphicsScene::destroyItemGroup(QGraphicsItemGroup *group)

Reasigna todos los elementos de group al elemento padre de group, a continuación elimina group de la escena y, por último, lo borra. Las posiciones y transformaciones de los elementos se transfieren del grupo a su elemento padre.

Véanse también createItemGroup() y QGraphicsItemGroup::removeFromGroup().

[virtual protected] void QGraphicsScene::dragEnterEvent(QGraphicsSceneDragDropEvent *event)

Este controlador de eventos, para el evento « event », puede reimplementarse en una subclase para recibir eventos de inicio de arrastre para la escena.

La implementación predeterminada acepta el evento y prepara la escena para aceptar eventos de «drag move».

Véase también QGraphicsItem::dragEnterEvent(), dragMoveEvent(), dragLeaveEvent() y dropEvent().

[virtual protected] void QGraphicsScene::dragLeaveEvent(QGraphicsSceneDragDropEvent *event)

Este controlador de eventos, para el evento « event », puede reimplementarse en una subclase para recibir eventos de salida de arrastre de la escena.

Véase también QGraphicsItem::dragLeaveEvent(), dragEnterEvent(), dragMoveEvent() y dropEvent().

[virtual protected] void QGraphicsScene::dragMoveEvent(QGraphicsSceneDragDropEvent *event)

Este controlador de eventos, para el evento « event », puede reimplementarse en una subclase para recibir eventos de arrastre y desplazamiento de la escena.

Nota: Consulta items() para conocer qué elementos se consideran visibles por esta función.

Véanse también QGraphicsItem::dragMoveEvent(), dragEnterEvent(), dragLeaveEvent() y dropEvent().

[virtual protected] void QGraphicsScene::drawBackground(QPainter *painter, const QRectF &rect)

Dibuja el fondo de la escena utilizando ` painter`, antes de que se dibujen los elementos y el primer plano. Reimplementa esta función para proporcionar un fondo personalizado para la escena.

Todo el dibujo se realiza en coordenadas de escena. El parámetro rect es el rectángulo expuesto.

Si lo único que quieres es definir un color, una textura o un degradado para el fondo, puedes llamar a ` setBackgroundBrush()` en su lugar.

Véanse también ` drawForeground()` y ` drawItems()`.

[virtual protected] void QGraphicsScene::drawForeground(QPainter *painter, const QRectF &rect)

Dibuja el primer plano de la escena utilizando ` painter`, una vez que se han dibujado el fondo y todos los elementos. Reimplementa esta función para proporcionar un primer plano personalizado para la escena.

Todo el dibujo se realiza en coordenadas de escena. El parámetro ` rect ` es el rectángulo expuesto.

Si lo único que quieres es definir un color, una textura o un degradado para el primer plano, puedes llamar a ` setForegroundBrush()` en su lugar.

Véanse también drawBackground() y drawItems().

[virtual protected] void QGraphicsScene::dropEvent(QGraphicsSceneDragDropEvent *event)

Este controlador de eventos, para el evento « event », puede reimplementarse en una subclase para recibir eventos de «drop» de la escena.

Véase también QGraphicsItem::dropEvent(), dragEnterEvent(), dragMoveEvent() y dragLeaveEvent().

[override virtual protected] bool QGraphicsScene::event(QEvent *event)

Reimplementa: QObject::event(QEvent *e).

Procesa el evento event y lo envía a los controladores de eventos correspondientes.

Además de llamar a los controladores de eventos de conveniencia, esta función se encarga de convertir los eventos de movimiento del ratón en eventos de desplazamiento del cursor cuando no hay ningún elemento que capture el ratón. Los eventos de desplazamiento del cursor se envían directamente a los elementos; no existe ninguna función de conveniencia para ellos.

A diferencia de ` QWidget`, ` QGraphicsScene ` no dispone de las funciones de conveniencia ` enterEvent()` y ` leaveEvent()`. Utiliza esta función para obtener dichos eventos en su lugar.

Devuelve ` true ` si ` event ` ha sido reconocido y procesado; en caso contrario, devuelve ` false`.

Véanse también contextMenuEvent(), keyPressEvent(), keyReleaseEvent(), mousePressEvent(), mouseMoveEvent(), mouseReleaseEvent(), mouseDoubleClickEvent(), focusInEvent() y focusOutEvent().

[override virtual protected] bool QGraphicsScene::eventFilter(QObject *watched, QEvent *event)

Reimplementa: QObject::eventFilter(QObject *watched, QEvent *event).

QGraphicsScene Filtra los eventos de ` QApplication` para detectar cambios en la paleta y la fuente.

[virtual protected] void QGraphicsScene::focusInEvent(QFocusEvent *focusEvent)

Este controlador de eventos, para el evento « focusEvent », se puede reimplementar en una subclase para recibir el foco en los eventos.

La implementación por defecto establece el foco en la escena y, a continuación, en el último elemento con foco.

Véase también ` QGraphicsItem::focusOutEvent()`.

QGraphicsItem *QGraphicsScene::focusItem() const

Cuando la escena está activa, esta función devuelve el elemento que tiene el foco actualmente en la escena, o ` nullptr ` si ningún elemento tiene el foco en ese momento. Cuando la escena está inactiva, esta función devuelve el elemento que obtendrá el foco de entrada cuando la escena se active.

El elemento con foco recibe la entrada del teclado cuando la escena recibe un evento de tecla.

Véanse también setFocusItem(), QGraphicsItem::hasFocus() y isActive().

[signal] void QGraphicsScene::focusItemChanged(QGraphicsItem *newFocusItem, QGraphicsItem *oldFocusItem, Qt::FocusReason reason)

Esta señal la emite QGraphicsScene cada vez que cambia el foco en la escena (es decir, cuando un elemento obtiene o pierde el foco de entrada, o cuando el foco pasa de un elemento a otro). Puedes conectarte a esta señal si necesitas llevar un control de cuándo otros elementos obtienen el foco de entrada. Resulta especialmente útil para implementar teclados virtuales, métodos de entrada y elementos de cursor.

oldFocusItem es un puntero al elemento que tenía el foco anteriormente, o 0 si ningún elemento tenía el foco antes de que se emitiera la señal. ` newFocusItem ` es un puntero al elemento que ha obtenido el foco de entrada, o ` nullptr ` si se ha perdido el foco. ` reason ` es el motivo del cambio de foco (por ejemplo, si la escena se desactivó mientras un campo de entrada tenía el foco, oldFocusItem apuntaría al elemento del campo de entrada, newFocusItem sería nullptr y reason sería Qt::ActiveWindowFocusReason).

[virtual protected slot] bool QGraphicsScene::focusNextPrevChild(bool next)

Busca un nuevo widget al que asignar el foco del teclado, según corresponda para las teclas Tab y Shift+Tab, y devuelve ` true ` si encuentra un nuevo widget, o `false` si no lo encuentra. Si ` next ` es `true`, esta función busca hacia adelante; si ` next ` es `false`, busca hacia atrás.

Puedes reimplementar esta función en una subclase de ` QGraphicsScene ` para proporcionar un control más preciso sobre cómo se desplaza el foco de la tecla Tab dentro de tu escena. La implementación predeterminada se basa en la cadena de foco de la tecla Tab definida por ` QGraphicsWidget::setTabOrder()`.

[virtual protected] void QGraphicsScene::focusOutEvent(QFocusEvent *focusEvent)

Este controlador de eventos, para el evento « focusEvent », puede reimplementarse en una subclase para recibir eventos de pérdida de foco.

La implementación predeterminada retira el foco de cualquier elemento que lo tenga y, a continuación, retira el foco de la escena.

Véase también QGraphicsItem::focusInEvent().

bool QGraphicsScene::hasFocus() const

Devuelve « true » si la escena tiene el foco; en caso contrario, devuelve « false ». Si la escena tiene el foco, reenviará los eventos de teclas desde « QKeyEvent » a cualquier elemento que tenga el foco.

Véase también setFocus() y setFocusItem().

qreal QGraphicsScene::height() const

Esta función de conveniencia equivale a llamar a ` sceneRect().height()`.

Véase también width().

[virtual protected] void QGraphicsScene::helpEvent(QGraphicsSceneHelpEvent *helpEvent)

Este controlador de eventos, para el evento « helpEvent », puede reimplementarse en una subclase para recibir eventos de ayuda. Los eventos son de tipo « QEvent::ToolTip », que se crean cuando se solicita una información sobre herramientas.

La implementación por defecto muestra la información de ayuda del elemento visible situado más arriba, es decir, el elemento con el valor z más alto, en la posición del cursor del ratón. Si ningún elemento tiene configurada una información de ayuda, esta función no realiza ninguna acción.

Nota: Consulta ` items()` para conocer qué elementos se consideran visibles por esta función.

Véase también QGraphicsItem::toolTip() y QGraphicsSceneHelpEvent.

[virtual protected] void QGraphicsScene::inputMethodEvent(QInputMethodEvent *event)

Este controlador de eventos, para el evento « event », puede reimplementarse en una subclase para recibir eventos de métodos de entrada para la escena.

La implementación predeterminada reenvía el evento a focusItem(). Si ningún elemento tiene el foco en ese momento o si el elemento que tiene el foco no admite métodos de entrada, esta función no realiza ninguna acción.

Véase también ` QGraphicsItem::inputMethodEvent()`.

[virtual] QVariant QGraphicsScene::inputMethodQuery(Qt::InputMethodQuery query) const

Los métodos de entrada utilizan este método para consultar un conjunto de propiedades de la escena, con el fin de poder admitir operaciones complejas de los métodos de entrada, como el soporte para el texto circundante y las reconversiones.

El parámetro « query » especifica qué propiedad se consulta.

Véase también QWidget::inputMethodQuery().

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

Invalida y programa un redibujado del « layers » en « rect » de la escena. Cualquier contenido almacenado en caché en « layers » se invalida y se redibuja de forma incondicional.

Puedes utilizar esta sobrecarga de función para notificar a QGraphicsScene los cambios en el fondo o el primer plano de la escena. Esta función se utiliza habitualmente en escenas con fondos basados en mosaicos para notificar cambios cuando QGraphicsView ha habilitado CacheBackground.

Ejemplo:

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]);
        }
    }
}

Ten en cuenta que QGraphicsView actualmente solo admite el almacenamiento en caché del fondo (véase QGraphicsView::CacheBackground). Esta función equivale a llamar a update() si se pasa cualquier capa que no sea BackgroundLayer.

Nota: Esta ranura está sobrecargada. Para conectarse a esta ranura:

// Connect using qOverload:
connect(sender, &SenderClass::signal,
        graphicsScene, qOverload(&QGraphicsScene::invalidate));

// Or using a lambda as wrapper:
connect(sender, &SenderClass::signal,
        graphicsScene, [receiver = graphicsScene](const QRectF &rect, QGraphicsScene::SceneLayers layers) { receiver->invalidate(rect, layers); });
Para ver más ejemplos y enfoques, consulta «Conexión a ranuras sobrecargadas».

Véase también QGraphicsView::resetCachedContent().

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

Esta función de conveniencia equivale a llamar a `invalidate(QRectF(x, y, w, h), layers);`

Esta es una función sobrecargada.

bool QGraphicsScene::isActive() const

Devuelve « true » si la escena está activa (por ejemplo, si al menos un « QGraphicsView » activo la está visualizando); en caso contrario, devuelve « false ».

Véase también QGraphicsItem::isActive() y QWidget::isActiveWindow().

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

Devuelve el elemento visible situado más arriba en la posición especificada position, o nullptr si no hay ningún elemento en esa posición.

deviceTransform es la transformación que se aplica a la vista, y debe proporcionarse si la escena contiene elementos que ignoran las transformaciones.

Nota: Consulte items() para conocer qué elementos se consideran visibles por esta función.

Véase también items(), collidingItems() y Sorting.

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

Devuelve el elemento visible situado más arriba en la posición especificada por (x, y), o nullptr si no hay ningún elemento en esa posición.

deviceTransform es la transformación que se aplica a la vista, y debe proporcionarse si la escena contiene elementos que ignoran las transformaciones.

Esta función de conveniencia equivale a llamar a ` itemAt(QPointF(x, y), deviceTransform)`.

Nota: Consulte items() para conocer qué elementos se consideran visibles por esta función.

Esta es una función sobrecargada.

QList<QGraphicsItem *> QGraphicsScene::items(Qt::SortOrder order = Qt::DescendingOrder) const

Devuelve una lista ordenada de todos los elementos de la escena. La propiedad ` order ` determina el orden de superposición.

Véase también addItem(), removeItem() y Sorting.

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

Devuelve todos los elementos visibles que, según mode, se encuentran en la posición especificada pos en una lista ordenada mediante order. En este caso, «visible» se refiere a los elementos para los que: isVisible() devuelve true, effectiveOpacity() devuelve un valor superior a 0,0 (que es totalmente transparente) y el elemento padre no los recorta.

El valor por defecto de « mode » es « Qt::IntersectsItemShape »; se devuelven todos los elementos cuya forma exacta se intersecta con « pos ».

deviceTransform es la transformación que se aplica a la vista y debe proporcionarse si la escena contiene elementos que ignoran las transformaciones.

Véase también itemAt() y Sorting.

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

Devuelve todos los elementos visibles que, en función de ` mode`, se encuentren dentro de ` path` o se crucen con él, en una lista ordenada según ` order`. En este caso, «visible» se refiere a aquellos elementos para los que: `isVisible()` devuelve ` true`, `effectiveOpacity()` devuelve un valor superior a 0,0 (que es totalmente transparente) y el elemento padre no los recorta.

El valor por defecto de « mode » es « Qt::IntersectsItemShape »; se devuelven todos los elementos cuya forma exacta se intersecta con « path » o está contenida en él.

deviceTransform es la transformación que se aplica a la vista, y debe proporcionarse si la escena contiene elementos que ignoran las transformaciones.

Esta es una función sobrecargada.

Véase también itemAt() y Sorting.

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

Devuelve todos los elementos visibles que, en función de ` mode`, se encuentran dentro de la ` polygon` especificada o se cruzan con ella, en una lista ordenada según ` order`. En este caso, «visible» se refiere a los elementos para los que: `isVisible()` devuelve ` true`, `effectiveOpacity()` devuelve un valor superior a 0,0 (que es totalmente transparente) y el elemento padre no los recorta.

El valor por defecto de ` mode ` es ` Qt::IntersectsItemShape`; se devuelven todos los elementos cuya forma exacta se cruza con ` polygon ` o está contenida en él.

deviceTransform es la transformación que se aplica a la vista, y debe proporcionarse si la escena contiene elementos que ignoran las transformaciones.

Esta es una función sobrecargada.

Véase también itemAt() y Sorting.

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

Devuelve todos los elementos visibles que, en función de mode, se encuentren dentro de la zona de recorte especificada rect o se crucen con ella, en una lista ordenada según order. En este caso, «visible» se refiere a aquellos elementos para los que: isVisible() devuelve true, effectiveOpacity() devuelve un valor superior a 0,0 (que corresponde a la transparencia total) y el elemento padre no los recorta.

El valor por defecto de ` mode ` es ` Qt::IntersectsItemShape`; se devuelven todos los elementos cuya forma exacta se intersecta con ` rect ` o está contenida en él.

deviceTransform es la transformación que se aplica a la vista, y debe proporcionarse si la escena contiene elementos que ignoran las transformaciones.

Esta es una función sobrecargada.

Véase también itemAt() y Sorting.

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

Devuelve todos los elementos visibles que, en función de mode, se encuentren dentro o se crucen con el rectángulo definido por x, y, w y h, en una lista ordenada según order. En este caso, «visible» define los elementos para los que: isVisible() devuelve true, effectiveOpacity() devuelve un valor superior a 0,0 (que es totalmente transparente) y el elemento padre no los recorta.

deviceTransform es la transformación que se aplica a la vista, y debe proporcionarse si la escena contiene elementos que ignoran las transformaciones.

Se trata de una función sobrecargada.

QRectF QGraphicsScene::itemsBoundingRect() const

Calcula y devuelve el rectángulo delimitador de todos los elementos de la escena. Esta función funciona iterando sobre todos los elementos y, por ello, puede resultar lenta en escenas de gran tamaño.

Véase también sceneRect().

[virtual protected] void QGraphicsScene::keyPressEvent(QKeyEvent *keyEvent)

Este controlador de eventos, para el evento « keyEvent », puede reimplementarse en una subclase para recibir eventos de pulsación de teclas. La implementación predeterminada reenvía el evento al elemento que tiene el foco actualmente.

Véanse también QGraphicsItem::keyPressEvent() y focusItem().

[virtual protected] void QGraphicsScene::keyReleaseEvent(QKeyEvent *keyEvent)

Este controlador de eventos, para el evento keyEvent, puede reimplementarse en una subclase para recibir eventos de liberación de teclas. La implementación predeterminada reenvía el evento al elemento que tiene el foco actualmente.

Véanse también QGraphicsItem::keyReleaseEvent() y focusItem().

[virtual protected] void QGraphicsScene::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *mouseEvent)

Este controlador de eventos, para el evento mouseEvent, puede reimplementarse en una subclase para recibir eventos de doble clic del ratón en la escena.

Si alguien hace doble clic en la escena, esta recibirá primero un evento de pulsación del ratón, seguido de un evento de liberación (es decir, un clic), luego un evento de doble clic y, por último, un evento de liberación. Si el evento de doble clic se envía a un elemento distinto de aquel que recibió la primera pulsación y sueltazo, se enviará como un evento de pulsación. Sin embargo, en este caso, los eventos de triple clic no se envían como eventos de doble clic.

La implementación por defecto es similar a mousePressEvent().

Nota: Consulte items() para conocer la definición de qué elementos se consideran visibles por esta función.

Véanse también QGraphicsItem::mousePressEvent(), QGraphicsItem::mouseMoveEvent(), QGraphicsItem::mouseReleaseEvent() y QGraphicsItem::setAcceptedMouseButtons().

QGraphicsItem *QGraphicsScene::mouseGrabberItem() const

Devuelve el elemento que actualmente tiene el control del ratón, o bien ` nullptr ` si ningún elemento tiene el control del ratón en ese momento. El elemento que tiene el control del ratón es aquel que recibe todos los eventos del ratón enviados a la escena.

Un elemento se convierte en «mouse grabber» cuando recibe y acepta un evento de pulsación del ratón, y sigue siéndolo hasta que se produzca cualquiera de los siguientes eventos:

  • Si el elemento recibe un evento de suelta del ratón cuando no hay ningún otro botón pulsado, pierde el control del ratón.
  • Si el elemento se vuelve invisible (es decir, alguien llama a ` item->setVisible(false)`), o si se desactiva (es decir, alguien llama a ` item->setEnabled(false)`), pierde el control del ratón.
  • Si el elemento se elimina de la escena, pierde el control del ratón.

Si el elemento pierde el control del ratón, la escena ignorará todos los eventos del ratón hasta que un nuevo elemento adquiera el control del ratón (es decir, hasta que un nuevo elemento reciba un evento de pulsación del ratón).

[virtual protected] void QGraphicsScene::mouseMoveEvent(QGraphicsSceneMouseEvent *mouseEvent)

Este controlador de eventos, para el evento « mouseEvent », puede reimplementarse en una subclase para recibir eventos de movimiento del ratón en la escena.

La implementación predeterminada depende del estado del captador del ratón. Si hay un elemento captador del ratón, el evento se envía al captador del ratón. Si hay algún elemento que acepte eventos de paso del cursor en la posición actual, el evento se convierte en un evento de paso del cursor y se acepta; de lo contrario, se ignora.

Véase también ` QGraphicsItem::mousePressEvent()`, ` QGraphicsItem::mouseReleaseEvent()`, ` QGraphicsItem::mouseDoubleClickEvent()` y ` QGraphicsItem::setAcceptedMouseButtons()`.

[virtual protected] void QGraphicsScene::mousePressEvent(QGraphicsSceneMouseEvent *mouseEvent)

Este controlador de eventos, para el evento « mouseEvent », puede reimplementarse en una subclase para recibir eventos de pulsación del ratón en la escena.

La implementación por defecto depende del estado de la escena. Si hay un elemento «mouse grabber», el evento se envía a dicho elemento. De lo contrario, se reenvía al elemento visible más cercano que acepte eventos de ratón en la posición de la escena indicada por el evento, y ese elemento se convierte inmediatamente en el «mouse grabber».

Si no hay ningún elemento en la posición indicada de la escena, se restablece el área de selección, cualquier elemento con foco pierde dicho foco y, a continuación, el evento se ignora.

Nota: Consulte items() para conocer la definición de qué elementos se consideran visibles por esta función.

Véanse también QGraphicsItem::mousePressEvent() y QGraphicsItem::setAcceptedMouseButtons().

[virtual protected] void QGraphicsScene::mouseReleaseEvent(QGraphicsSceneMouseEvent *mouseEvent)

Este controlador de eventos, para el evento « mouseEvent », puede reimplementarse en una subclase para recibir eventos de liberación del ratón para la escena.

La implementación por defecto depende del estado del «mouse grabber». Si no hay ningún «mouse grabber», el evento se ignora. En caso contrario, si hay un elemento «mouse grabber», el evento se envía a dicho elemento. Si esta suelta del ratón corresponde al último botón pulsado, el elemento «mouse grabber» pierde entonces el control del ratón.

Véase también QGraphicsItem::mousePressEvent(), QGraphicsItem::mouseMoveEvent(), QGraphicsItem::mouseDoubleClickEvent() y QGraphicsItem::setAcceptedMouseButtons().

void QGraphicsScene::removeItem(QGraphicsItem *item)

Elimina el elemento item y todos sus elementos secundarios de la escena. La propiedad de item pasa a manos de quien realiza la llamada (es decir, QGraphicsScene ya no eliminará item cuando se destruya).

Véase también addItem().

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

Renderiza el rectángulo « source » de la escena en « target », utilizando « painter ». Esta función resulta útil para capturar el contenido de la escena en un dispositivo de dibujo, como un « QImage » (por ejemplo, para hacer una captura de pantalla), o para imprimir con «QPrinter». Por ejemplo:

QGraphicsScene scene;
scene.addItem(someItem);
//...
QPrinter printer(QPrinter::HighResolution);
printer.setPageSize(QPageSize::A4);

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

Si source es un rectángulo nulo, esta función utilizará sceneRect() para determinar qué renderizar. Si target es un rectángulo nulo, se utilizarán las dimensiones del dispositivo de pintura de painter.

El contenido del rectángulo de origen se transformará según aspectRatioMode para ajustarse al rectángulo de destino. Por defecto, se mantiene la relación de aspecto y source se escala para ajustarse a target.

Véase también QGraphicsView::render().

[signal] void QGraphicsScene::sceneRectChanged(const QRectF &rect)

Esta señal la emite QGraphicsScene cada vez que cambia el rectángulo de la escena. El parámetro rect es el nuevo rectángulo de la escena.

Véase también QGraphicsView::updateSceneRect().

QList<QGraphicsItem *> QGraphicsScene::selectedItems() const

Devuelve una lista con todos los elementos seleccionados actualmente. Los elementos se muestran sin ningún orden en particular.

Véase también setSelectionArea().

QPainterPath QGraphicsScene::selectionArea() const

Devuelve el área de selección que se había establecido previamente con ` setSelectionArea()`; si no se ha establecido ninguna área de selección, devuelve un ` QPainterPath ` vacío.

Véase también setSelectionArea().

[signal] void QGraphicsScene::selectionChanged()

QGraphicsScene emite esta señal cada vez que cambia la selección. Puedes llamar a selectedItems() para obtener la nueva lista de elementos seleccionados.

La selección cambia cada vez que se selecciona o deselecciona un elemento, se establece, se borra o se modifica de cualquier otra forma un área de selección, si se añade a la escena un elemento preseleccionado o si se elimina de la escena un elemento seleccionado.

QGraphicsScene emite esta señal solo una vez para las operaciones de selección de grupo. Por ejemplo, si se establece un área de selección, se selecciona o deselecciona un ` QGraphicsItemGroup`, o si se añade o elimina de la escena un elemento padre que contiene varios elementos seleccionados, `selectionChanged()` se emite solo una vez una vez finalizada la operación (en lugar de una vez por cada elemento).

Véase también setSelectionArea(), selectedItems() y QGraphicsItem::setSelected().

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

Envía el evento « event » al elemento « item » tras aplicar los posibles filtros de eventos.

El evento solo se envía si el elemento está habilitado.

Devuelve « false » si el evento ha sido filtrado o si el elemento está desactivado. En caso contrario, devuelve el valor que devolvió el controlador de eventos.

Véase también QGraphicsItem::sceneEvent() y QGraphicsItem::sceneEventFilter().

void QGraphicsScene::setActivePanel(QGraphicsItem *item)

Activa « item », que debe ser un elemento de esta escena. También puedes pasar un valor de 0 para « item »; en ese caso, « QGraphicsScene » desactivará cualquier panel que esté activo en ese momento.

Si la escena está inactiva en ese momento, item permanece inactivo hasta que la escena se active (o, si item es nullptr, no se activará ningún elemento).

Véase también activePanel(), isActive() y QGraphicsItem::isActive().

void QGraphicsScene::setActiveWindow(QGraphicsWidget *widget)

Activa « widget », que debe ser un widget de esta escena. También puedes pasar el valor 0 para « widget »; en ese caso, « QGraphicsScene » desactivará cualquier ventana que esté activa en ese momento.

Véase también activeWindow() y QGraphicsWidget::isActiveWindow().

void QGraphicsScene::setFocus(Qt::FocusReason focusReason = Qt::OtherFocusReason)

Establece el foco en la escena enviando un ` QFocusEvent ` a la escena, pasando ` focusReason ` como motivo. Si la escena recupera el foco tras haberlo perdido previamente mientras otro elemento tenía el foco, el último elemento que tenía el foco lo volverá a recibir con ` focusReason ` como motivo.

Si la escena ya tiene el foco, esta función no realiza ninguna acción.

Véase también hasFocus(), clearFocus() y setFocusItem().

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

Establece el elemento de enfoque de la escena en item, con el motivo de enfoque focusReason, tras retirar el enfoque de cualquier elemento anterior que pudiera tenerlo.

Si item es nullptr, o si no acepta el foco (es decir, no tiene activado el indicador QGraphicsItem::ItemIsFocusable ), o no está visible o no está habilitado, esta función solo retira el foco de cualquier elemento que lo tuviera anteriormente.

Si item no es un elemento con foco ( nullptr) y la escena no tiene actualmente el foco (es decir, hasFocus() devuelve false), esta función llamará automáticamente a setFocus().

Véase también « focusItem()», « hasFocus()» y « setFocus()».

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

Establece el área de selección en path. Todos los elementos que se encuentren dentro de esta área se seleccionan inmediatamente, y todos los que estén fuera se deseleccionan. Puedes obtener la lista de todos los elementos seleccionados llamando a selectedItems().

deviceTransform es la transformación que se aplica a la vista y debe proporcionarse si la escena contiene elementos que ignoran las transformaciones.

Para que un elemento pueda ser seleccionado, debe estar marcado como seleccionable (QGraphicsItem::ItemIsSelectable).

Véanse también clearSelection() y selectionArea().

void QGraphicsScene::setSelectionArea(const QPainterPath &path, Qt::ItemSelectionOperation selectionOperation = Qt::ReplaceSelection, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape, const QTransform &deviceTransform = QTransform())

Establece el área de selección en path utilizando mode para determinar si los elementos están incluidos en el área de selección.

deviceTransform es la transformación que se aplica a la vista, y debe indicarse si la escena contiene elementos que ignoran las transformaciones.

selectionOperation determina qué hacer con los elementos seleccionados actualmente.

Esta es una función sobrecargada.

Véase también clearSelection() y selectionArea().

void QGraphicsScene::setStyle(QStyle *style)

Establece o sustituye el estilo de la escena por style y vuelve a vincular el estilo a esta escena. Se elimina cualquier estilo asignado anteriormente. El estilo predeterminado de la escena es QApplication::style(), y sirve como valor predeterminado para todos los elementos QGraphicsWidget de la escena.

Al cambiar el estilo, ya sea directamente llamando a esta función o indirectamente llamando a QApplication::setStyle(), se actualizará automáticamente el estilo de todos los widgets de la escena a los que no se les haya asignado explícitamente un estilo.

Si style es nullptr, QGraphicsScene volverá a QApplication::style().

Véase también style().

QStyle *QGraphicsScene::style() const

Devuelve el estilo de la escena, o el mismo resultado que QApplication::style() si no se ha asignado explícitamente ningún estilo a la escena.

Véase también setStyle().

[slot] void QGraphicsScene::update(const QRectF &rect = QRectF())

Programa un redibujado del área rect en la escena.

Nota: Esta ranura está sobrecargada. Para conectarse a esta ranura:

// Connect using qOverload:
connect(sender, &SenderClass::signal,
        graphicsScene, qOverload(&QGraphicsScene::update));

// Or using a lambda as wrapper:
connect(sender, &SenderClass::signal,
        graphicsScene, [receiver = graphicsScene](const QRectF &rect) { receiver->update(rect); });
Para ver más ejemplos y métodos, consulta «Conexión a ranuras sobrecargadas».

Véase también ` sceneRect()` y ` changed()`.

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

Esta función equivale a llamar a `update(QRectF(x, y, w, h));`

Se trata de una función sobrecargada.

QList<QGraphicsView *> QGraphicsScene::views() const

Devuelve una lista de todas las vistas que muestran esta escena.

Véase también QGraphicsView::scene().

[virtual protected] void QGraphicsScene::wheelEvent(QGraphicsSceneWheelEvent *wheelEvent)

Este controlador de eventos, para el evento « wheelEvent », puede reimplementarse en una subclase para recibir eventos de la rueda del ratón para la escena.

Por defecto, el evento se envía al elemento visible situado más arriba bajo el cursor. Si se ignora, el evento se propaga al elemento situado justo debajo, y así sucesivamente hasta que el evento sea aceptado o llegue a la escena. Si ningún elemento acepta el evento, este se ignora.

Nota: Consulta ` items()` para conocer qué elementos se consideran visibles por esta función.

Véase también QGraphicsItem::wheelEvent().

qreal QGraphicsScene::width() const

Esta función de conveniencia equivale a llamar a sceneRect().width().

Véase también ` height()`.

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.