En esta página

Marco de trabajo de la vista gráfica

La vista gráfica proporciona una superficie para gestionar e interactuar con un gran número de elementos gráficos 2D personalizados, así como un widget de vista para visualizar dichos elementos, con soporte para el zoom y la rotación.

El marco incluye una arquitectura de propagación de eventos que permite capacidades de interacción de doble precisión para los elementos de la escena. Los elementos pueden gestionar eventos de teclado, así como eventos de pulsación, desplazamiento, liberación y doble clic del ratón, y también pueden seguir el movimiento del ratón.

Graphics View utiliza un árbol BSP (partición binaria del espacio) para proporcionar una localización muy rápida de los elementos y, gracias a ello, puede visualizar escenas de gran tamaño en tiempo real, incluso con millones de elementos.

Graphics View se introdujo en Qt 4.2, sustituyendo a su predecesor, QCanvas.

La arquitectura de Graphics View

Graphics View ofrece un enfoque basado en elementos para la programación modelo-vista, muy similar a las clases de conveniencia de InterView: QTableView, QTreeView y QListView. Varias vistas pueden observar una misma escena, y la escena contiene elementos de diversas formas geométricas.

La escena

QGraphicsScene proporciona la escena de Graphics View. La escena tiene las siguientes responsabilidades:

  • Proporcionar una interfaz rápida para gestionar un gran número de elementos
  • Propagar eventos a cada elemento
  • Gestionar el estado de los elementos, como la selección y el manejo del foco
  • Proporcionar funcionalidad de renderizado sin transformar; principalmente para la impresión

La escena actúa como contenedor de objetos ` QGraphicsItem `. Los elementos se añaden a la escena llamando a ` QGraphicsScene::addItem()` y, a continuación, se recuperan llamando a una de las numerosas funciones de detección de elementos. ` QGraphicsScene::items()` y sus sobrecargas devuelven todos los elementos contenidos en un punto, un rectángulo, un polígono o una ruta vectorial general, o que se cruzan con ellos. ` QGraphicsScene::itemAt` () devuelve el elemento situado en la parte superior en un punto concreto. Todas las funciones de detección de elementos devuelven los elementos en orden descendente de apilamiento (es decir, el primer elemento devuelto es el que se encuentra en la parte superior y el último, el que se encuentra en la parte inferior).

QGraphicsScene scene;
QGraphicsRectItem *rect = scene.addRect(QRectF(0, 0, 100, 100));

QGraphicsItem *item = scene.itemAt(50, 50, QTransform());

QGraphicsSceneLa arquitectura de propagación de eventos de gestiona la entrega de eventos de la escena a los elementos y también gestiona la propagación entre ellos. Si la escena recibe un evento de pulsación del ratón en una posición determinada, la escena transmite el evento al elemento que se encuentre en esa posición.

QGraphicsScene También gestiona ciertos estados de los elementos, como la selección y el foco. Puedes seleccionar elementos de la escena llamando a ` QGraphicsScene::setSelectionArea()` y pasando una forma arbitraria. Esta funcionalidad también se utiliza como base para la selección con «lazo» en QGraphicsView. Para obtener la lista de todos los elementos seleccionados actualmente, llama a ` QGraphicsScene::selectedItems()`. Otro estado que gestiona QGraphicsScene es si un elemento tiene o no el foco de entrada del teclado. Puedes establecer el foco en un elemento llamando a QGraphicsScene::setFocusItem() o QGraphicsItem::setFocus(), o bien obtener el elemento que tiene el foco actualmente llamando a QGraphicsScene::focusItem().

Por último, QGraphicsScene permite renderizar partes de la escena en un dispositivo de pintura mediante la función QGraphicsScene::render(). Puede obtener más información al respecto en la sección «Impresión», más adelante en este documento.

El widget «View»

QGraphicsView proporciona el widget de vista, que visualiza el contenido de una escena. Se pueden asociar varias vistas a la misma escena, para ofrecer varias ventanas de visualización del mismo conjunto de datos. El widget de vista es un área de desplazamiento y proporciona barras de desplazamiento para navegar por escenas de gran tamaño. Para habilitar la compatibilidad con OpenGL, se puede establecer un QOpenGLWidget como ventana de visualización llamando a QGraphicsView::setViewport().

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

La vista recibe eventos de entrada del teclado y del ratón, y los traduce a eventos de escena (convirtiendo las coordenadas utilizadas a coordenadas de escena cuando sea necesario), antes de enviar los eventos a la escena visualizada.

Mediante su matriz de transformación, ` QGraphicsView::transform()`, la vista puede transformar el sistema de coordenadas de la escena. Esto permite funciones de navegación avanzadas, como el zoom y la rotación. Para mayor comodidad, ` QGraphicsView ` también proporciona funciones para la conversión entre coordenadas de vista y de escena: ` QGraphicsView::mapToScene()` y ` QGraphicsView::mapFromScene()`.

Matriz de chips informáticos

El elemento

QGraphicsItem es la clase base para los elementos gráficos de una escena. Graphics View proporciona varios elementos estándar para formas típicas, como rectángulos (QGraphicsRectItem), elipses (QGraphicsEllipseItem) y elementos de texto (QGraphicsTextItem), pero las funciones más potentes de QGraphicsItem están disponibles cuando se crea un elemento personalizado. Entre otras cosas, QGraphicsItem admite las siguientes funciones:

  • Eventos de pulsación, desplazamiento, suelta y doble clic del ratón, así como eventos de paso del cursor, de la rueda y del menú contextual.
  • Foco de entrada del teclado y eventos de teclas
  • Arrastrar y soltar
  • Agrupación, tanto a través de relaciones padre-hijo como con QGraphicsItemGroup
  • Detección de colisiones

Los elementos se sitúan en un sistema de coordenadas local y, al igual que QGraphicsView, también ofrece numerosas funciones para establecer correspondencias entre las coordenadas del elemento y las de la escena, así como entre un elemento y otro. Además, al igual que QGraphicsView, puede transformar su sistema de coordenadas mediante una matriz: QGraphicsItem::transform(). Esto resulta útil para rotar y escalar elementos individuales.

Los elementos pueden contener otros elementos (hijos). Las transformaciones de los elementos padres son heredadas por todos sus hijos. Sin embargo, independientemente de la transformación acumulada de un elemento, todas sus funciones (por ejemplo, QGraphicsItem::contains(), QGraphicsItem::boundingRect(), QGraphicsItem::collidesWith()) siguen operando en coordenadas locales.

QGraphicsItem Admite la detección de colisiones a través de las funciones QGraphicsItem::shape() y QGraphicsItem::collidesWith(), ambas funciones virtuales. Al devolver la forma de tu elemento como un QPainterPath en coordenadas locales desde QGraphicsItem::shape(), QGraphicsItem se encargará de toda la detección de colisiones por ti. No obstante, si deseas implementar tu propio sistema de detección de colisiones, puedes reimplementar QGraphicsItem::collidesWith().

Diversas formas y elementos gráficos en una cuadrícula

Clases del marco de trabajo Graphics View

Estas clases proporcionan un marco para crear aplicaciones interactivas.

QAbstractGraphicsShapeItem

Base común para todos los elementos de ruta

QGraphicsAnchor

Representa un anclaje entre dos elementos en un QGraphicsAnchorLayout

QGraphicsAnchorLayout

en el que se pueden anclar widgets entre sí en Graphics View

QGraphicsEffect

La clase base para todos los Graphical Effects

QGraphicsEllipseItem

Elemento de elipse que se puede añadir a un QGraphicsScene

QGraphicsGridLayout

Diseño de cuadrícula para gestionar widgets en la vista gráfica

QGraphicsItem

La clase base para todos los elementos gráficos de un QGraphicsScene

QGraphicsItemGroup

Contenedor que trata un grupo de elementos como un único elemento

QGraphicsLayout

La clase base para todas las distribuciones en Graphics View

QGraphicsLayoutItem

Se puede heredar para permitir que los diseños gestionen tus elementos personalizados

QGraphicsLineItem

Elemento de línea que se puede añadir a un QGraphicsScene

QGraphicsLinearLayout

Diseño horizontal o vertical para gestionar widgets en Graphics View

QGraphicsObject

Clase base para todos los elementos gráficos que requieren señales, ranuras y propiedades

QGraphicsPathItem

Elemento de ruta que se puede añadir a un QGraphicsScene

QGraphicsPixmapItem

Elemento «Pixmap» que se puede añadir a un QGraphicsScene

QGraphicsPolygonItem

Elemento «Polygon» que se puede añadir a un QGraphicsScene

QGraphicsProxyWidget

Capa proxy para incrustar un QWidget en un QGraphicsScene

QGraphicsRectItem

Elemento «Rectangle» que se puede añadir a un QGraphicsScene

QGraphicsScene

Superficie para gestionar un gran número de elementos gráficos 2D

QGraphicsSceneContextMenuEvent

Eventos del menú contextual en el marco de trabajo de la vista gráfica

QGraphicsSceneDragDropEvent

Eventos de arrastrar y soltar en el marco de trabajo de la vista gráfica

QGraphicsSceneEvent

Clase base para todos los eventos relacionados con la vista gráfica

QGraphicsSceneHelpEvent

Eventos cuando se solicita una información sobre el elemento

QGraphicsSceneHoverEvent

Eventos de paso del cursor en el marco de la vista gráfica

QGraphicsSceneMouseEvent

Eventos del ratón en el marco de la vista gráfica

QGraphicsSceneMoveEvent

Eventos relacionados con el desplazamiento de widgets en el marco de la vista gráfica

QGraphicsSceneResizeEvent

Eventos relacionados con el cambio de tamaño de los widgets en el marco de la vista gráfica

QGraphicsSceneWheelEvent

Eventos de rueda en el marco de trabajo de la vista gráfica

QGraphicsSimpleTextItem

Elemento de texto sencillo que se puede añadir a un QGraphicsScene

QGraphicsSvgItem

QGraphicsItem que se puede utilizar para representar el contenido de archivos SVG

QGraphicsTextItem

Elemento de texto que se puede añadir a un QGraphicsScene para mostrar texto formateado

QGraphicsTransform

Clase base abstracta para crear transformaciones avanzadas sobre QGraphicsItems

QGraphicsView

Widget para mostrar el contenido de un QGraphicsScene

QGraphicsWidget

La clase base para todos los elementos de widget de un QGraphicsScene

QStyleOptionGraphicsItem

Se utiliza para describir los parámetros necesarios para dibujar un QGraphicsItem

El sistema de coordenadas de la vista gráfica

Graphics View se basa en el sistema de coordenadas cartesianas; la posición y la geometría de los elementos en la escena se representan mediante pares de números: la coordenada x y la coordenada y. Al observar una escena mediante una vista sin transformar, una unidad de la escena se representa mediante un píxel en la pantalla.

Nota: El sistema de coordenadas con el eje Y invertido (en el que « y » crece hacia arriba) no es compatible, ya que Graphics View utiliza el sistema de coordenadas de Qt.

En Graphics View intervienen tres sistemas de coordenadas efectivos: las coordenadas de los elementos, las coordenadas de la escena y las coordenadas de la vista. Para simplificar la implementación, Graphics View proporciona funciones prácticas que permiten establecer correspondencias entre los tres sistemas de coordenadas.

Al renderizar, las coordenadas de escena de Graphics View se corresponden con las coordenadas lógicas de « QPainter », y las coordenadas de vista son las mismas que las coordenadas del dispositivo. En la documentación sobre el sistema de coordenadas, puedes consultar la relación entre las coordenadas lógicas y las coordenadas del dispositivo.

Transformación de varios sistemas de coordenadas

Coordenadas de los elementos

Los elementos se sitúan en su propio sistema de coordenadas local. Sus coordenadas suelen estar centradas en torno a su punto central (0, 0), que es también el centro de todas las transformaciones. Las primitivas geométricas en el sistema de coordenadas del elemento suelen denominarse «puntos del elemento», «líneas del elemento» o «rectángulos del elemento».

Al crear un elemento personalizado, solo tienes que preocuparte por las coordenadas del elemento; QGraphicsScene y QGraphicsView se encargarán de realizar todas las transformaciones por ti. Esto facilita enormemente la implementación de elementos personalizados. Por ejemplo, si recibes un evento de pulsación del ratón o de arrastre, la posición del evento se indica en coordenadas del elemento. La función virtual ` QGraphicsItem::contains()` —que devuelve ` true ` si un punto determinado se encuentra dentro de tu elemento y `false` en caso contrario— toma un argumento de tipo punto en coordenadas del elemento. Del mismo modo, el rectángulo delimitador y la forma de un elemento se expresan en coordenadas del elemento.

La posición del elemento es la coordenada del punto central del elemento en el sistema de coordenadas de su padre; a veces denominadas «coordenadas del padre ». En este sentido, la escena se considera el «padre» de todos los elementos que carecen de padre. Las posiciones de los elementos de nivel superior están en coordenadas de escena.

Las coordenadas de los elementos hijos son relativas a las del elemento padre. Si el elemento hijo no ha sido transformado, la diferencia entre una coordenada del elemento hijo y una del elemento padre es igual a la distancia entre los elementos en coordenadas del padre. Por ejemplo: si un elemento hijo no transformado se sitúa exactamente en el punto central de su elemento padre, los sistemas de coordenadas de ambos elementos serán idénticos. Sin embargo, si la posición del elemento hijo es (10, 0), el punto (0, 10) del elemento hijo se corresponderá con el punto (10, 10) de su elemento padre.

Dado que la posición y la transformación de los elementos son relativas al padre, las coordenadas de los elementos hijos no se ven afectadas por la transformación del padre, aunque esta transforme implícitamente al hijo. En el ejemplo anterior, aunque el elemento padre se gire y se escale, el punto (0, 10) del elemento hijo seguirá correspondiendo al punto (10, 10) del elemento padre. Sin embargo, en relación con la escena, el elemento hijo seguirá la transformación y la posición del elemento padre. Si el elemento padre se escala (2x, 2x), la posición del elemento hijo estará en la coordenada de la escena (20, 0), y su punto (10, 0) se corresponderá con el punto (40, 0) de la escena.

Salvo en el caso de ` QGraphicsItem::pos()` —una de las pocas excepciones—, las funciones de ` QGraphicsItem` operan en coordenadas del elemento, independientemente de la transformación del elemento o de cualquiera de sus padres. Por ejemplo, el rectángulo delimitador de un elemento (es decir, ` QGraphicsItem::boundingRect()`) siempre se expresa en coordenadas del elemento.

Coordenadas de la escena

La escena representa el sistema de coordenadas base para todos sus elementos. El sistema de coordenadas de la escena describe la posición de cada elemento de nivel superior y también constituye la base para todos los eventos de escena enviados a la escena desde la vista. Cada elemento de la escena tiene una posición en la escena y un rectángulo delimitador (QGraphicsItem::scenePos(), QGraphicsItem::sceneBoundingRect()), además de su posición local y su rectángulo delimitador. La posición en la escena describe la posición del elemento en coordenadas de la escena, y su rectángulo delimitador en la escena constituye la base sobre la que QGraphicsScene determina qué áreas de la escena han cambiado. Los cambios en la escena se comunican a través de la señal « QGraphicsScene::changed()», y el argumento es una lista de rectángulos de la escena.

Coordenadas de vista

Las coordenadas de la vista son las coordenadas del widget. Cada unidad en las coordenadas de la vista corresponde a un píxel. Lo especial de este sistema de coordenadas es que es relativo al widget, o ventana de visualización, y no se ve afectado por la escena observada. La esquina superior izquierda de la ventana de visualización de QGraphicsView es siempre (0, 0), y la esquina inferior derecha es siempre (anchura de la ventana de visualización, altura de la ventana de visualización). Todos los eventos del ratón y los eventos de arrastrar y soltar se reciben inicialmente como coordenadas de la vista, y es necesario asignar estas coordenadas a la escena para poder interactuar con los elementos.

Asignación de coordenadas

A menudo, al trabajar con elementos de una escena, puede resultar útil asignar coordenadas y formas arbitrarias desde la escena a un elemento, de un elemento a otro o desde la vista a la escena. Por ejemplo, al hacer clic con el ratón en el área de visualización de QGraphicsView, puedes preguntar a la escena qué elemento se encuentra bajo el cursor llamando a QGraphicsView::mapToScene(), seguido de QGraphicsScene::itemAt(). Si quieres saber en qué parte de la ventana de visualización se encuentra un elemento, puedes llamar a ` QGraphicsItem::mapToScene()` sobre el elemento y, a continuación, a ` QGraphicsView::mapFromScene()` sobre la vista. Por último, si quieres averiguar qué elementos hay dentro de una elipse de la vista, puedes pasar un ` QPainterPath ` a `mapToScene()` y, a continuación, pasar la ruta mapeada a ` QGraphicsScene::items()`.

Puedes asignar coordenadas y formas desde y hacia la escena de un elemento llamando a ` QGraphicsItem::mapToScene()` y ` QGraphicsItem::mapFromScene()`. También puedes asignar al elemento padre de un elemento llamando a ` QGraphicsItem::mapToParent()` y ` QGraphicsItem::mapFromParent()`, o entre elementos llamando a ` QGraphicsItem::mapToItem()` y ` QGraphicsItem::mapFromItem()`. Todas las funciones de asignación pueden asignar tanto puntos, rectángulos y polígonos como trazados.

Las mismas funciones de mapeo están disponibles en la vista, para realizar el mapeo hacia y desde la escena: QGraphicsView::mapFromScene() y QGraphicsView::mapToScene(). Para realizar el mapeo desde una vista a un elemento, primero hay que realizar el mapeo a la escena y, a continuación, desde la escena al elemento.

Características principales

Zoom y rotación

QGraphicsView admite las mismas transformaciones afines que QPainter a través de QGraphicsView::setMatrix(). Al aplicar una transformación a la vista, se puede añadir fácilmente soporte para funciones de navegación habituales, como el zoom y la rotación.

A continuación se muestra un ejemplo de cómo implementar las ranuras de zoom y rotación en una subclase de ` QGraphicsView`:

class View : public QGraphicsView
{
Q_OBJECT
    //...
public slots:
    void zoomIn() { scale(1.2, 1.2); }
    void zoomOut() { scale(1 / 1.2, 1 / 1.2); }
    void rotateLeft() { rotate(-10); }
    void rotateRight() { rotate(10); }
    //...
};

Las ranuras se pueden conectar a ` QToolButtons ` con la opción « autoRepeat » activada.

QGraphicsView mantiene alineado el centro de la vista al transformarla.

Consulta también el ejemplo «Elastic Nodes » para ver código que muestra cómo implementar funciones básicas de zoom.

Impresión

Graphics View permite la impresión de una sola línea a través de sus funciones de renderizado, ` QGraphicsScene::render()` y ` QGraphicsView::render()`. Las funciones proporcionan la misma API: puedes hacer que la escena o la vista rendericen todo o parte de su contenido en cualquier dispositivo de pintura pasando un ` QPainter ` a cualquiera de las funciones de renderizado. Este ejemplo muestra cómo imprimir toda la escena en una página completa, utilizando QPrinter.

QGraphicsScene scene;
QPrinter printer;
scene.addRect(QRectF(0, 0, 100, 200), QPen(Qt::black), QBrush(Qt::green));

if (QPrintDialog(&printer).exec() == QDialog::Accepted) {
    QPainter painter(&printer);
    painter.setRenderHint(QPainter::Antialiasing);
    scene.render(&painter);
}

La diferencia entre las funciones de representación de escena y de vista es que una opera en coordenadas de escena y la otra en coordenadas de vista. QGraphicsScene::render() suele ser la opción preferida para trazar segmentos completos de una escena sin transformar, como por ejemplo para representar datos geométricos o para trazar un documento de texto. QGraphicsView::render(), por otro lado, es adecuada para realizar capturas de pantalla; su comportamiento por defecto es renderizar el contenido exacto de la ventana de visualización utilizando el «pintor» proporcionado.

QGraphicsScene scene;
scene.addRect(QRectF(0, 0, 100, 200), QPen(Qt::black), QBrush(Qt::green));

QPixmap pixmap;
QPainter painter(&pixmap);
painter.setRenderHint(QPainter::Antialiasing);
scene.render(&painter);
painter.end();

pixmap.save("scene.png");

Cuando los tamaños de las áreas de origen y destino no coinciden, el contenido de origen se estira para ajustarse al área de destino. Al pasar un ` Qt::AspectRatioMode ` a la función de renderizado que estés utilizando, puedes elegir entre mantener o ignorar la relación de aspecto de la escena cuando se estira el contenido.

Arrastrar y soltar

Dado que ` QGraphicsView ` hereda indirectamente de ` QWidget `, ya proporciona la misma funcionalidad de arrastrar y soltar que ofrece ` QWidget `. Además, para mayor comodidad, el marco de trabajo de Graphics View proporciona compatibilidad con arrastrar y soltar para la escena y para todos y cada uno de los elementos. Cuando la vista recibe un arrastre, traduce los eventos de arrastrar y soltar en un ` QGraphicsSceneDragDropEvent`, que luego se reenvía a la escena. La escena se encarga de gestionar este evento y lo envía al primer elemento situado bajo el cursor del ratón que admita la colocación.

Para iniciar un arrastre desde un elemento, se debe crear un objeto ` QDrag `, pasando un puntero al widget que inicia el arrastre. Los elementos pueden ser observados por varias vistas al mismo tiempo, pero solo una vista puede iniciar el arrastre. En la mayoría de los casos, los arrastres se inician al pulsar o mover el ratón, por lo que en `mousePressEvent()` o `mouseMoveEvent()` se puede obtener el puntero del widget de origen a partir del evento. Por ejemplo:

void CustomItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
{
    QMimeData *data = new QMimeData;
    QDrag *drag = new QDrag(event->widget());
    drag->setMimeData(data);
    drag->exec();
}

Para interceptar eventos de arrastrar y soltar en la escena, hay que reimplementar ` QGraphicsScene::dragEnterEvent()` y los controladores de eventos que necesite tu escena concreta, en una subclase de ` QGraphicsItem `. Puedes obtener más información sobre el arrastrar y soltar en Graphics View en la documentación de cada uno de los controladores de eventos de ` QGraphicsScene`.

Los elementos pueden habilitar la compatibilidad con «arrastrar y soltar» llamando a ` QGraphicsItem::setAcceptDrops()`. Para gestionar el arrastre entrante, reimplementa ` QGraphicsItem::dragEnterEvent()`, ` QGraphicsItem::dragMoveEvent()`, ` QGraphicsItem::dragLeaveEvent()` y ` QGraphicsItem::dropEvent()`.

Consulte también el ejemplo «Drag and Drop Robot» para ver una demostración de cómo Graphics View admite las operaciones de arrastrar y soltar.

Cursores y información sobre herramientas

Al igual que QWidget, QGraphicsItem también admite cursores (QGraphicsItem::setCursor()) e información sobre herramientas (QGraphicsItem::setToolTip()). Los cursores y la información sobre herramientas se activan mediante QGraphicsView cuando el cursor del ratón entra en el área del elemento (lo cual se detecta llamando a QGraphicsItem::contains()).

También puedes establecer un cursor predeterminado directamente en la vista llamando a QGraphicsView::setCursor().

Consulte también el ejemplo «Drag and Drop Robot » para ver el código que implementa las descripciones emergentes y la gestión de la forma del cursor.

Animación

Graphics View admite animación a varios niveles. Puedes crear animaciones fácilmente utilizando el marco de trabajo de animación (Animation Framework). Para ello, tus elementos deberán heredar de QGraphicsObject y asociarles QPropertyAnimation. QPropertyAnimation permite animar cualquier propiedad de QObject.

Otra opción es crear un elemento personalizado que herede de ` QObject ` y ` QGraphicsItem`. El elemento puede configurar sus propios temporizadores y controlar las animaciones con pasos incrementales mediante ` QObject::timerEvent()` ().

Una tercera opción, disponible principalmente para garantizar la compatibilidad con QCanvas en Qt 3, consiste en avanzar la escena llamando a ` QGraphicsScene::advance()`, que a su vez llama a ` QGraphicsItem::advance()`.

Renderizado con OpenGL

Para habilitar el renderizado OpenGL, basta con establecer un nuevo ` QOpenGLWidget ` como ventana de visualización de ` QGraphicsView ` llamando a ` QGraphicsView::setViewport()`. Si se desea utilizar OpenGL con suavizado, es necesario establecer un ` QSurfaceFormat ` con el número de muestras necesario (véase ` QSurfaceFormat::setSamples()`).

Ejemplo:

QGraphicsView view(&scene);
QOpenGLWidget *gl = new QOpenGLWidget();
QSurfaceFormat format;
format.setSamples(4);
gl->setFormat(format);
view.setViewport(gl);

Grupos de elementos

Al convertir un elemento en hijo de otro, se consigue la característica más esencial de la agrupación de elementos: los elementos se moverán juntos y todas las transformaciones se propagarán del padre al hijo.

Además, « QGraphicsItemGroup » es un elemento especial que combina la gestión de eventos de los hijos con una interfaz útil para añadir y eliminar elementos de un grupo. Al añadir un elemento a un « QGraphicsItemGroup », este conservará su posición y transformación originales, mientras que, por lo general, al cambiar la relación de parentesco de los elementos, el hijo se reposicionará en relación con su nuevo padre. Para mayor comodidad, puedes crear « QGraphicsItemGroup» en la escena llamando a QGraphicsScene::createItemGroup().

Widgets y diseños

QGraphicsWidget QWidget QWidget QPaintDevice QGraphicsItem QGraphicsLinearLayout QGraphicsGridLayoutXML Qt

QGraphicsWidget

Aprovechando las capacidades y el tamaño reducido de QGraphicsItem, QGraphicsWidget ofrece lo mejor de ambos mundos: funcionalidad adicional de QWidget, como el estilo, la fuente, la paleta, la dirección del diseño y su geometría, y la independencia de la resolución y la compatibilidad con transformaciones de QGraphicsItem. Dado que Graphics View utiliza coordenadas reales en lugar de números enteros, las funciones geométricas de QGraphicsWidget también operan sobre QRectF y QPointF. Esto también se aplica a los rectángulos de marco, los márgenes y el espaciado. Con QGraphicsWidget no es raro especificar márgenes de contenido de (0,5; 0,5; 0,5; 0,5), por ejemplo. Se pueden crear tanto subwidgets como ventanas de «nivel superior»; en algunos casos, ahora se puede utilizar Graphics View para aplicaciones MDI avanzadas.

Se admiten algunas de las propiedades de QWidget, incluidos los indicadores y atributos de ventana, pero no todas. Debes consultar la documentación de la clase de QGraphicsWidget para obtener una visión general completa de lo que se admite y lo que no. Por ejemplo, puedes crear ventanas decoradas pasando el indicador de ventana Qt::Window al constructor de QGraphicsWidget, pero Graphics View actualmente no admite los indicadores Qt::Sheet y Qt::Drawer, que son habituales en macOS.

QGraphicsLayout

QGraphicsLayout forma parte de un marco de diseño de segunda generación diseñado específicamente para QGraphicsWidget. Su API es muy similar a la de QLayout. Puedes gestionar widgets y subdiseños tanto dentro de QGraphicsLinearLayout como de QGraphicsGridLayout. También puedes crear fácilmente tu propio diseño creando una subclase de QGraphicsLayout, o añadir tus propios elementos QGraphicsItem al diseño creando una subclase adaptadora de QGraphicsLayoutItem.

Compatibilidad con widgets incrustados

Graphics View ofrece una compatibilidad perfecta para incrustar cualquier widget en la escena. Puedes incrustar widgets sencillos, como QLineEdit o QPushButton, widgets complejos como QTabWidget e incluso ventanas principales completas. Para incrustar tu widget en la escena, basta con llamar a QGraphicsScene::addWidget() o crear una instancia de QGraphicsProxyWidget para incrustar tu widget manualmente.

A través de QGraphicsProxyWidget, Graphics View es capaz de integrar en profundidad las funciones del widget del cliente, incluidos sus cursores, información sobre herramientas, eventos de ratón, tableta y teclado, widgets secundarios, animaciones, ventanas emergentes (por ejemplo, QComboBox o QCompleter) y el foco de entrada y la activación del widget. QGraphicsProxyWidget incluso integra el orden de tabulación del widget incrustado, de modo que se puede navegar entre los widgets incrustados mediante la tecla Tab. Incluso se puede incrustar un nuevo QGraphicsView en la escena para crear escenas anidadas complejas.

Al transformar un widget incrustado, Graphics View se asegura de que el widget se transforme independientemente de la resolución, lo que permite que las fuentes y el estilo se mantengan nítidos al ampliar la imagen. (Ten en cuenta que el efecto de la independencia de la resolución depende del estilo).

Rendimiento

Instrucciones de punto flotante

Para aplicar transformaciones y efectos a los elementos de forma precisa y rápida, Graphics View se ha diseñado partiendo de la base de que el hardware del usuario es capaz de ofrecer un rendimiento razonable para las instrucciones de punto flotante.

Muchas estaciones de trabajo y ordenadores de sobremesa están equipados con el hardware adecuado para acelerar este tipo de cálculos, pero es posible que algunos dispositivos integrados solo dispongan de bibliotecas para gestionar operaciones matemáticas o emulen instrucciones de punto flotante mediante software.

Como resultado, ciertos tipos de efectos pueden resultar más lentos de lo esperado en determinados dispositivos. Es posible compensar esta pérdida de rendimiento realizando optimizaciones en otras áreas; por ejemplo, utilizando OpenGL para renderizar una escena. Sin embargo, cualquiera de estas optimizaciones puede provocar a su vez una reducción del rendimiento si también depende de la presencia de hardware de punto flotante.

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