QGraphicsScene Class

Documentación de las funciones miembro

QGraphicsScene::QGraphicsScene(QObject *parent = nullptr)

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

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

Construye un objeto QGraphicsScene, usando sceneRect para su 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)

Construye un objeto QGraphicsScene, usando el rectángulo especificado por (x, y), y los dados width y height 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 el objeto de escena. El objeto de escena se elimina de la lista global de escenas de la aplicación, y se elimina de todas las vistas asociadas.

QGraphicsItem *QGraphicsScene::activePanel() const

Devuelve el panel activo actual, o nullptr si no hay ningún panel activo.

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

QGraphicsWidget *QGraphicsScene::activeWindow() const

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

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 elipse a la escena, y devuelve el puntero del elemento. La geometría de la elipse se define en rect, y su pluma y pincel se inicializan en pen y brush.

Tenga en cuenta que la geometría del elemento se proporciona en coordenadas de 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 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 es equivalente 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 hijos a esta escena. Esta escena toma posesión del item.

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

Si el elemento ya se encuentra en una escena diferente, primero se eliminará de su antigua escena, y luego se añadirá a esta escena como nivel superior.

QGraphicsScene enviará notificaciones ItemSceneChange a item mientras se añade a la escena. Si el elemento no pertenece actualmente a una escena, sólo se enviará una notificación. Si ya pertenece a una escena (es decir, se mueve a esta escena), QGraphicsScene enviará una notificación de adición 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, 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 del elemento. La geometría de la línea se define en line, y su pluma se inicializa en pen.

Ten en cuenta que la geometría del elemento se proporciona en coordenadas de 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 es equivalente 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 ruta a la escena, y devuelve el puntero del elemento. La geometría de la ruta se define en path, y su pluma y pincel se inicializan en pen y brush.

Tenga en cuenta que la geometría del elemento se proporciona en coordenadas de 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 del elemento. El mapa de píxeles se define en pixmap.

Ten en cuenta que la geometría del elemento se proporciona en coordenadas de 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(), 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 del elemento. El polígono se define en polygon, y su pluma y pincel se inicializan en pen y brush.

Ten en cuenta que la geometría del elemento se proporciona en coordenadas de 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(), 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 rectángulo a la escena, y devuelve el puntero del elemento. La geometría del rectángulo se define en rect, y su pluma y pincel se inicializan en pen y brush.

Tenga en cuenta que la geometría del elemento se proporciona en coordenadas de elemento, y su posición se inicializa a (0, 0). Por ejemplo, si se añade un QRect(50, 50, 100, 100), su esquina superior izquierda estará en (50, 50) 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 es equivalente 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 QGraphicsSimpleTextItem a la escena, y devuelve el puntero del elemento. La cadena de texto se inicializa a text, y su fuente se inicializa a font.

La posición del elemento se inicializa a (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(), 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 del elemento. La cadena de texto se inicializa a text, y su fuente se inicializa a font.

La posición del elemento se inicializa a (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(), 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 incrustado.

La posición del elemento se inicializa a (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.

Ten en cuenta que los widgets con el atributo widget Qt::WA_PaintOnScreen establecido y los widgets que envuelven una aplicación o controlador externo no son compatibles. Algunos ejemplos son QOpenGLWidget y QAxWidget.

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

[slot] void QGraphicsScene::advance()

Esta ranura avanza la escena un paso, llamando a QGraphicsItem::advance() para todos los elementos de la escena. Esto se hace 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 notifica a todos los elementos que pueden moverse. En la primera fase, QGraphicsItem::advance() es llamado pasando un valor de 0 como argumento, y 1 es pasado en la segunda fase.

Ten en cuenta que también puedes utilizar el Animation Framework para las animaciones.

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

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

Esta señal es emitida por QGraphicsScene cuando el control alcanza el bucle de eventos, si el contenido de la escena cambia. El parámetro region contiene una lista de rectángulos de escena que indican el área que ha sido modificada.

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

[slot] void QGraphicsScene::clear()

Elimina y borra todos los elementos de la escena, pero por lo demás deja el estado de la escena sin cambios.

Véase también addItem().

void QGraphicsScene::clearFocus()

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

Una escena que no tiene foco ignora los eventos clave.

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 la determina mode. Por defecto, se devuelven todos los elementos cuya forma se cruza con item o está contenida 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 superior y el último el inferior).

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

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

Este manejador de eventos, para el evento contextMenuEvent, puede ser reimplementado en una subclase para recibir eventos de menú contextual. La implementación por defecto reenvía el evento al elemento visible superior que acepta eventos de menú contextual en la posición del evento. Si ningún elemento acepta eventos de menú contextual en esta posición, el evento es ignorado.

Nota: Véase items() para una definición de los elementos que esta función considera visibles.

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 ancestro común de items como padre y con la posición (0, 0). Todos los elementos se reasignan al grupo, y sus posiciones y transformaciones se asignan al grupo. Si items está vacío, esta función devolverá un nivel superior vacío QGraphicsItemGroup.

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

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

void QGraphicsScene::destroyItemGroup(QGraphicsItemGroup *group)

Reenvía todos los elementos de group al elemento padre de group, luego elimina group de la escena y, por último, lo borra. Las posiciones y transformaciones de los ítems son mapeadas desde el grupo al padre del grupo.

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

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

Este manejador de eventos, para el evento event, puede ser reimplementado en una subclase para recibir eventos drag enter para la escena.

La implementación por defecto acepta el evento y prepara la escena para aceptar eventos de movimiento de arrastre.

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

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

Este manejador de eventos, para el evento event, puede ser reimplementado en una subclase para recibir eventos de arrastrar y dejar para la escena.

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

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

Este manejador de eventos, para el evento event, puede ser reimplementado en una subclase para recibir eventos de movimiento de arrastre para la escena.

Nota: Ver items() para una definición de qué elementos son considerados visibles por esta función.

Ver 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 dibujar cualquier elemento y el primer plano. Reimplemente esta función para proporcionar un fondo personalizado para la escena.

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

Si todo lo que desea es definir un color, textura o gradiente para el fondo, puede llamar a setBackgroundBrush() en su lugar.

Véase también drawForeground() y drawItems().

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

Dibuja el primer plano de la escena utilizando painter, después de haber dibujado el fondo y todos los elementos. Reimplemente esta función para proporcionar un primer plano personalizado para la escena.

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

Si todo lo que desea es definir un color, textura o gradiente para el primer plano, puede llamar a setForegroundBrush() en su lugar.

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

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

Este manejador de eventos, para el evento event, puede ser reimplementado en una subclase para recibir eventos drop para la escena.

Ver 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 respectivos manejadores de eventos.

Además de llamar a los manejadores de eventos de conveniencia, esta función es responsable de convertir los eventos de movimiento del ratón en eventos hover para cuando no hay un ítem que agarre el ratón. Los eventos hover se envían directamente a los elementos; no existe una función de conveniencia para ellos.

A diferencia de QWidget, QGraphicsScene no tiene las funciones de conveniencia enterEvent() y leaveEvent(). Utilice esta función para obtener esos eventos en su lugar.

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

Véase 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 de paleta y fuente.

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

Este manejador de eventos, para el evento focusEvent, puede ser reimplementado en una subclase para recibir el foco en eventos.

La implementación por defecto establece el foco en la escena, y luego en el último elemento enfocado.

Ver también QGraphicsItem::focusOutEvent().

QGraphicsItem *QGraphicsScene::focusItem() const

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

El elemento enfocado recibe entrada de teclado cuando la escena recibe un evento de tecla.

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

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

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

oldFocusItem es un puntero al elemento que anteriormente tenía el foco, 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 ganó el foco de entrada, o nullptr si se perdió el foco. reason es la razón 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 dar el foco del teclado, según corresponda para Tab y Shift+Tab, y devuelve true si puede encontrar un nuevo widget, o false si no puede. Si next es verdadero, esta función busca hacia adelante; si next es falso, busca hacia atrás.

Puedes reimplementar esta función en una subclase de QGraphicsScene para proporcionar un control preciso sobre cómo pasa el foco de la pestaña dentro de tu escena. La implementación predeterminada se basa en la cadena de enfoque de pestañas definida por QGraphicsWidget::setTabOrder().

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

Este manejador de eventos, para el evento focusEvent, puede ser reimplementado en una subclase para recibir eventos de foco fuera.

La implementación por defecto elimina el foco de cualquier elemento de foco, y luego elimina el foco de la escena.

Ver también QGraphicsItem::focusInEvent().

bool QGraphicsScene::hasFocus() const

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

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

qreal QGraphicsScene::height() const

Esta función es equivalente a llamar a sceneRect().height().

Véase también width().

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

Este manejador de eventos, para el evento helpEvent, puede ser reimplementado en una subclase para recibir eventos de ayuda. Los eventos son del tipo QEvent::ToolTip, que se crean cuando se solicita un tooltip.

La implementación predeterminada muestra la información sobre herramientas 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 una descripción emergente, esta función no hace nada.

Nota: Véase items() para una definición de los elementos que esta función considera visibles.

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

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

Este manejador de eventos, para el evento event, puede ser reimplementado en una subclase para recibir eventos de métodos de entrada para la escena.

La implementación por defecto reenvía el evento a focusItem(). Si ningún elemento tiene actualmente el foco o el elemento con el foco actual no acepta métodos de entrada, esta función no hace nada.

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

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

Este método es utilizado por los métodos de entrada para consultar un conjunto de propiedades de la escena para poder soportar operaciones complejas de métodos de entrada como el soporte para texto circundante y 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 de layers en rect en la escena. Cualquier contenido almacenado en caché en layers es invalidado y redibujado incondicionalmente.

Puedes utilizar esta sobrecarga de la función para notificar a QGraphicsScene cambios en el fondo o en 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]);
        }
    }
}

Tenga en cuenta que QGraphicsView sólo admite actualmente el almacenamiento en caché del fondo (consulte QGraphicsView::CacheBackground). Esta función es equivalente a llamar a update() si se pasa cualquier capa menos BackgroundLayer.

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

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

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

Esta función es equivalente a llamar a invalidate(QRectF(x, y, w, h), layers);

bool QGraphicsScene::isActive() const

Devuelve true si la escena está activa (por ejemplo, es vista por al menos un QGraphicsView que esté activo); 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 más alto en la dirección position especificada, o nullptr si no hay elementos en esta 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: Ver items() para una definición de qué elementos son considerados visibles por esta función.

Ver también items(), collidingItems(), y Sorting.

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

Devuelve el elemento visible más alto en la posición especificada por (x, y), o nullptr si no hay elementos en esta 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 es equivalente a llamar a itemAt(QPointF(x, y), deviceTransform).

Nota: Ver items() para una definición de qué elementos son considerados visibles por esta función.

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

Devuelve una lista ordenada de todos los elementos de la escena. order decide el orden de apilamiento.

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, en función de mode, se encuentran en el pos especificado en una lista ordenada mediante 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 lo recorta.

El valor por defecto para mode es Qt::IntersectsItemShape; se devuelven todos los elementos cuya forma exacta se cruza 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, dependiendo de mode, están dentro o se cruzan con el path especificado, en una lista ordenada utilizando 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 lo recorta.

El valor por defecto para mode es Qt::IntersectsItemShape; se devuelven todos los elementos cuya forma exacta se cruza con o está contenida por path.

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 QPolygonF &polygon, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape, Qt::SortOrder order = Qt::DescendingOrder, const QTransform &deviceTransform = QTransform()) const

Devuelve todos los elementos visibles que, dependiendo de mode, están dentro o se cruzan con el polygon especificado, en una lista ordenada utilizando 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 lo recorta.

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

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 QRectF &rect, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape, Qt::SortOrder order = Qt::DescendingOrder, const QTransform &deviceTransform = QTransform()) const

Devuelve todos los elementos visibles que, dependiendo de mode, están dentro o se cruzan con el rect especificado, en una lista ordenada utilizando 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 lo recorta.

El valor por defecto para mode es Qt::IntersectsItemShape; se devuelven todos los elementos cuya forma exacta se cruza con o está contenida por rect.

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(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, están dentro del rectángulo definido por x, y, w y h o se cruzan con él, en una lista ordenada mediante 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 lo recorta.

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

QRectF QGraphicsScene::itemsBoundingRect() const

Calcula y devuelve el rectángulo delimitador de todos los elementos de la escena. Esta función trabaja iterando sobre todos los elementos, y debido a esto, puede ser lenta para escenas grandes.

Véase también sceneRect().

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

Este manejador de eventos, para el evento keyEvent, puede ser reimplementado en una subclase para recibir eventos de pulsación de teclas. La implementación por defecto reenvía el evento al elemento de foco actual.

Ver también QGraphicsItem::keyPressEvent() y focusItem().

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

Este manejador de eventos, para el evento keyEvent, puede ser reimplementado en una subclase para recibir eventos de liberación de teclas. La implementación por defecto reenvía el evento al elemento de foco actual.

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

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

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

Si alguien hace doble clic en la escena, la escena 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 finalmente un evento de liberación. Si el evento de doble clic se envía a un elemento diferente del que recibió la primera pulsación y liberación, 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: Véase items() para una definición de los elementos que esta función considera visibles.

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

QGraphicsItem *QGraphicsScene::mouseGrabberItem() const

Devuelve el ítem actual que captura el ratón, o nullptr si no hay ningún ítem capturando el ratón. El elemento de captura del ratón es el elemento que recibe todos los eventos de ratón enviados a la escena.

Un elemento se convierte en capturador del ratón cuando recibe y acepta un evento de pulsación del ratón, y permanece como capturador del ratón hasta que ocurre cualquiera de los siguientes eventos:

• Si el elemento recibe un evento de liberación del ratón cuando no hay otros botones pulsados, pierde el agarre 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 agarre del ratón.
• Si el elemento se elimina de la escena, pierde el agarre del ratón.

Si el elemento pierde el agarre del ratón, la escena ignorará todos los eventos de ratón hasta que un nuevo elemento agarre el 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 manejador de eventos, para el evento mouseEvent, puede ser reimplementado en una subclase para recibir eventos de movimiento del ratón para la escena.

La implementación por defecto depende del estado del mouse grabber. Si hay un ítem mouse grabber, el evento es enviado al mouse grabber. Si hay algún elemento que acepte eventos hover en la posición actual, el evento se traduce en un evento hover y se acepta; en caso contrario, se ignora.

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

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

Este manejador de eventos, para el evento mouseEvent, puede ser reimplementado en una subclase para recibir eventos de pulsación del ratón para la escena.

La implementación por defecto depende del estado de la escena. Si hay un elemento de captura del ratón, entonces el evento se envía a la captura del ratón. En caso contrario, se reenvía al elemento visible más alto que acepte eventos de ratón en la posición de la escena del evento, y ese elemento se convierte inmediatamente en el elemento de captura del ratón.

Si no hay ningún elemento en la posición dada en la escena, el área de selección se reinicia, cualquier elemento enfocado pierde su foco de entrada, y el evento es ignorado.

Nota: Véase items() para una definición de qué elementos son considerados visibles por esta función.

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

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

Este manejador de eventos, para el evento mouseEvent, puede ser reimplementado 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 mouse grabber, el evento es ignorado. De lo contrario, si hay un elemento de captura del ratón, el evento se envía al capturador del ratón. Si esta liberación del ratón representa el último botón pulsado del ratón, el elemento de agarre del ratón pierde entonces el agarre 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 hijos de la escena. La propiedad de item se transfiere a la persona que llama (es decir, QGraphicsScene ya no borrará 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 source rect de la escena en target, usando painter. Esta función es útil para capturar el contenido de la escena en un dispositivo de pintura, como QImage (por ejemplo, para hacer una captura de pantalla), o para imprimir con QPrinter. Por ejemplo:

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

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

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

El contenido del rectángulo de origen se transformará de acuerdo con aspectRatioMode para encajar en el rectángulo de destino. Por defecto, la relación de aspecto se mantiene, y source se escala para encajar en target.

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

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

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

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

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

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

Véase también setSelectionArea().

QPainterPath QGraphicsScene::selectionArea() const

Devuelve el área de selección que se estableció previamente con setSelectionArea(), o un QPainterPath vacío si no se ha establecido ningún área de selección.

Véase también setSelectionArea().

[signal] void QGraphicsScene::selectionChanged()

Esta señal es emitida por QGraphicsScene cada vez que cambia la selección. Puede llamar a selectedItems() para obtener la nueva lista de elementos seleccionados.

La selección cambia siempre que se selecciona o deselecciona un elemento, se establece, borra o modifica de otro modo 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 sólo una vez para las operaciones de selección de grupo. Por ejemplo, si establece un área de selección, selecciona o deselecciona un QGraphicsItemGroup, o si añade o elimina de la escena un elemento padre que contiene varios elementos seleccionados, selectionChanged() se emite sólo una vez después de que la operación haya finalizado (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 a través de los posibles filtros de eventos.

El evento se envía sólo si el elemento está habilitado.

Devuelve false si el evento fue filtrado o si el ítem está deshabilitado. En caso contrario devuelve el valor que fue devuelto por el manejador del evento.

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

void QGraphicsScene::setActivePanel(QGraphicsItem *item)

Activa item, que debe ser un elemento en esta escena. También puedes pasar 0 para item, en cuyo caso QGraphicsScene desactivará cualquier panel actualmente activo.

Si la escena está actualmente inactiva, item permanecerá inactivo hasta que la escena se active (o, ir 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 en esta escena. También puedes pasar 0 para widget, en cuyo caso QGraphicsScene desactivará cualquier ventana actualmente activa.

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

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

Fija el foco en la escena enviando un QFocusEvent a la escena, pasando focusReason como razón. Si la escena recupera el foco después de haberlo perdido previamente mientras un elemento tenía el foco, el último elemento enfocado recibirá el foco con focusReason como razón.

Si la escena ya tiene foco, esta función no hace nada.

Ver también hasFocus(), clearFocus(), y setFocusItem().

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

Establece el elemento de foco de la escena en item, con el motivo de foco focusReason, después de quitar el foco de cualquier elemento anterior que pudiera haberlo tenido.

Si item es nullptr, o si no acepta el foco (es decir, no tiene la bandera QGraphicsItem::ItemIsFocusable activada), o no es visible o no está activado, esta función sólo elimina el foco de cualquier focusitem anterior.

Si el elemento no es 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 dentro de esta área se seleccionan inmediatamente, y todos los elementos fuera de ella 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 sea seleccionado, debe estar marcado como seleccionable (QGraphicsItem::ItemIsSelectable).

Véase 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 proporcionarse si la escena contiene elementos que ignoran las transformaciones.

selectionOperation determina qué hacer con los elementos actualmente seleccionados.

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

void QGraphicsScene::setStyle(QStyle *style)

Establece o reemplaza el estilo de la escena a style, y reparents el estilo a esta escena. Cualquier estilo asignado previamente se elimina. El estilo por defecto de la escena es QApplication::style(), y sirve como estilo por defecto para todos los elementos QGraphicsWidget de la escena.

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

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 lo mismo que QApplication::style() si no se ha asignado explícitamente un 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.

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

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

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 manejador de eventos, para el evento wheelEvent, puede ser reimplementado en una subclase para recibir eventos de rueda de 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 debajo, y de nuevo hasta que el evento es aceptado, o alcanza la escena. Si ningún elemento acepta el evento, éste se ignora.

Nota: Véase items() para una definición de los elementos que esta función considera visibles.

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

qreal QGraphicsScene::width() const

Esta función es equivalente a llamar a sceneRect().width().

Véase también height().