QGraphicsView Class
La clase QGraphicsView proporciona un widget para mostrar el contenido de un « QGraphicsScene ». Más información...
| Encabezado: | #include <QGraphicsView> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS Widgets) target_link_libraries(mytarget PRIVATE Qt6::Widgets) |
| qmake: | QT += widgets |
| Heredado de: | QAbstractScrollArea |
Tipos públicos
| flags | CacheMode |
| enum | CacheModeFlag { CacheNone, CacheBackground } |
| enum | DragMode { NoDrag, ScrollHandDrag, RubberBandDrag } |
| enum | OptimizationFlag { DontSavePainterState, DontAdjustForAntialiasing, IndirectPainting } |
| flags | OptimizationFlags |
| enum | ViewportAnchor { NoAnchor, AnchorViewCenter, AnchorUnderMouse } |
| enum | ViewportUpdateMode { FullViewportUpdate, MinimalViewportUpdate, SmartViewportUpdate, BoundingRectViewportUpdate, NoViewportUpdate } |
Propiedades
|
|
Funciones públicas
| QGraphicsView(QWidget *parent = nullptr) | |
| QGraphicsView(QGraphicsScene *scene, QWidget *parent = nullptr) | |
| virtual | ~QGraphicsView() |
| Qt::Alignment | alignment() const |
| QBrush | backgroundBrush() const |
| QGraphicsView::CacheMode | cacheMode() const |
| void | centerOn(const QPointF &pos) |
| void | centerOn(const QGraphicsItem *item) |
| void | centerOn(qreal x, qreal y) |
| QGraphicsView::DragMode | dragMode() const |
| void | ensureVisible(const QRectF &rect, int xmargin = 50, int ymargin = 50) |
| void | ensureVisible(const QGraphicsItem *item, int xmargin = 50, int ymargin = 50) |
| void | ensureVisible(qreal x, qreal y, qreal w, qreal h, int xmargin = 50, int ymargin = 50) |
| void | fitInView(const QRectF &rect, Qt::AspectRatioMode aspectRatioMode = Qt::IgnoreAspectRatio) |
| void | fitInView(const QGraphicsItem *item, Qt::AspectRatioMode aspectRatioMode = Qt::IgnoreAspectRatio) |
| void | fitInView(qreal x, qreal y, qreal w, qreal h, Qt::AspectRatioMode aspectRatioMode = Qt::IgnoreAspectRatio) |
| QBrush | foregroundBrush() const |
| bool | isInteractive() const |
| bool | isTransformed() const |
| QGraphicsItem * | itemAt(const QPoint &pos) const |
| QGraphicsItem * | itemAt(int x, int y) const |
| QList<QGraphicsItem *> | items() const |
| QList<QGraphicsItem *> | items(const QPoint &pos) const |
| QList<QGraphicsItem *> | items(int x, int y) const |
| QList<QGraphicsItem *> | items(int x, int y, int w, int h, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const |
| QList<QGraphicsItem *> | items(const QPainterPath &path, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const |
| QList<QGraphicsItem *> | items(const QPolygon &polygon, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const |
| QList<QGraphicsItem *> | items(const QRect &rect, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const |
| QPainterPath | mapFromScene(const QPainterPath &path) const |
| QPoint | mapFromScene(const QPointF &point) const |
| QPolygon | mapFromScene(const QPolygonF &polygon) const |
| QPolygon | mapFromScene(const QRectF &rect) const |
| QPoint | mapFromScene(qreal x, qreal y) const |
| QPolygon | mapFromScene(qreal x, qreal y, qreal w, qreal h) const |
| QPainterPath | mapToScene(const QPainterPath &path) const |
| QPointF | mapToScene(const QPoint &point) const |
| QPolygonF | mapToScene(const QPolygon &polygon) const |
| QPolygonF | mapToScene(const QRect &rect) const |
| QPointF | mapToScene(int x, int y) const |
| QPolygonF | mapToScene(int x, int y, int w, int h) const |
| QGraphicsView::OptimizationFlags | optimizationFlags() const |
| void | render(QPainter *painter, const QRectF &target = QRectF(), const QRect &source = QRect(), Qt::AspectRatioMode aspectRatioMode = Qt::KeepAspectRatio) |
| QPainter::RenderHints | renderHints() const |
| void | resetCachedContent() |
| void | resetTransform() |
| QGraphicsView::ViewportAnchor | resizeAnchor() const |
| void | rotate(qreal angle) |
| QRect | rubberBandRect() const |
| Qt::ItemSelectionMode | rubberBandSelectionMode() const |
| void | scale(qreal sx, qreal sy) |
| QGraphicsScene * | scene() const |
| QRectF | sceneRect() const |
| void | setAlignment(Qt::Alignment alignment) |
| void | setBackgroundBrush(const QBrush &brush) |
| void | setCacheMode(QGraphicsView::CacheMode mode) |
| void | setDragMode(QGraphicsView::DragMode mode) |
| void | setForegroundBrush(const QBrush &brush) |
| void | setInteractive(bool allowed) |
| void | setOptimizationFlag(QGraphicsView::OptimizationFlag flag, bool enabled = true) |
| void | setOptimizationFlags(QGraphicsView::OptimizationFlags flags) |
| void | setRenderHint(QPainter::RenderHint hint, bool enabled = true) |
| void | setRenderHints(QPainter::RenderHints hints) |
| void | setResizeAnchor(QGraphicsView::ViewportAnchor anchor) |
| void | setRubberBandSelectionMode(Qt::ItemSelectionMode mode) |
| void | setScene(QGraphicsScene *scene) |
| void | setSceneRect(const QRectF &rect) |
| void | setSceneRect(qreal x, qreal y, qreal w, qreal h) |
| void | setTransform(const QTransform &matrix, bool combine = false) |
| void | setTransformationAnchor(QGraphicsView::ViewportAnchor anchor) |
| void | setViewportUpdateMode(QGraphicsView::ViewportUpdateMode mode) |
| void | shear(qreal sh, qreal sv) |
| QTransform | transform() const |
| QGraphicsView::ViewportAnchor | transformationAnchor() const |
| void | translate(qreal dx, qreal dy) |
| QTransform | viewportTransform() const |
| QGraphicsView::ViewportUpdateMode | viewportUpdateMode() const |
Funciones públicas reimplementadas
| virtual QVariant | inputMethodQuery(Qt::InputMethodQuery query) const override |
| virtual QSize | sizeHint() const override |
Ranuras públicas
| void | invalidateScene(const QRectF &rect = QRectF(), QGraphicsScene::SceneLayers layers = QGraphicsScene::AllLayers) |
| void | updateScene(const QList<QRectF> &rects) |
| void | updateSceneRect(const QRectF &rect) |
Señales
| void | rubberBandChanged(QRect rubberBandRect, QPointF fromScenePoint, QPointF toScenePoint) |
Funciones protegidas
| virtual void | drawBackground(QPainter *painter, const QRectF &rect) |
| virtual void | drawForeground(QPainter *painter, const QRectF &rect) |
Funciones protegidas reimplementadas
| virtual void | contextMenuEvent(QContextMenuEvent *event) override |
| virtual void | dragEnterEvent(QDragEnterEvent *event) override |
| virtual void | dragLeaveEvent(QDragLeaveEvent *event) override |
| virtual void | dragMoveEvent(QDragMoveEvent *event) override |
| virtual void | dropEvent(QDropEvent *event) override |
| virtual bool | event(QEvent *event) override |
| virtual void | focusInEvent(QFocusEvent *event) override |
| virtual bool | focusNextPrevChild(bool next) override |
| virtual void | focusOutEvent(QFocusEvent *event) override |
| virtual void | inputMethodEvent(QInputMethodEvent *event) override |
| virtual void | keyPressEvent(QKeyEvent *event) override |
| virtual void | keyReleaseEvent(QKeyEvent *event) override |
| virtual void | mouseDoubleClickEvent(QMouseEvent *event) override |
| virtual void | mouseMoveEvent(QMouseEvent *event) override |
| virtual void | mousePressEvent(QMouseEvent *event) override |
| virtual void | mouseReleaseEvent(QMouseEvent *event) override |
| virtual void | paintEvent(QPaintEvent *event) override |
| virtual void | resizeEvent(QResizeEvent *event) override |
| virtual void | scrollContentsBy(int dx, int dy) override |
| virtual void | showEvent(QShowEvent *event) override |
| virtual bool | viewportEvent(QEvent *event) override |
| virtual void | wheelEvent(QWheelEvent *event) override |
Ranuras protegidas
| virtual void | setupViewport(QWidget *widget) override |
Descripción detallada
QGraphicsView visualiza el contenido de un objeto ` QGraphicsScene ` en una ventana de visualización desplazable. Para crear una escena con elementos geométricos, consulta la documentación de ` QGraphicsScene`. QGraphicsView forma parte del marco Graphics View Framework.
Para visualizar una escena, hay que empezar por crear un objeto QGraphicsView, pasando la dirección de la escena que se desea visualizar al constructor de QGraphicsView. Como alternativa, se puede llamar a setScene() para establecer la escena más adelante. Tras llamar a ` show()`, la vista se desplazará por defecto hasta el centro de la escena y mostrará los elementos que estén visibles en ese momento. Por ejemplo:
QGraphicsScene scene;
scene.addText("Hello, world!");
QGraphicsView view(&scene);
view.show();Puedes desplazarte explícitamente a cualquier posición de la escena utilizando las barras de desplazamiento o llamando a centerOn(). Al pasar un punto a centerOn(), QGraphicsView desplazará su ventana de visualización para garantizar que el punto quede centrado en la vista. Se proporciona una sobrecarga para desplazarse a un ` QGraphicsItem`, en cuyo caso QGraphicsView se encargará de que el centro del elemento quede centrado en la vista. Si lo único que quieres es asegurarte de que una determinada área sea visible (pero no necesariamente centrada), puedes llamar a ` ensureVisible()` en su lugar.
QGraphicsView se puede utilizar para visualizar una escena completa o solo partes de ella. El área visualizada se detecta de forma automática por defecto cuando se muestra la vista por primera vez (mediante la llamada a ` QGraphicsScene::itemsBoundingRect()`). Para establecer tú mismo el rectángulo del área visualizada, puedes llamar a ` setSceneRect()`. Esto ajustará los rangos de las barras de desplazamiento adecuadamente. Ten en cuenta que, aunque la escena admite un tamaño prácticamente ilimitado, el rango de las barras de desplazamiento nunca superará el rango de un entero (INT_MIN, INT_MAX).
QGraphicsView visualiza la escena llamando a ` render()`. Por defecto, los elementos se dibujan en la ventana de visualización utilizando un ` QPainter` estándar y las sugerencias de renderizado predeterminadas. Para cambiar las sugerencias de renderizado predeterminadas que QGraphicsView pasa a ` QPainter ` al dibujar los elementos, puede llamar a ` setRenderHints()`.
Por defecto, QGraphicsView proporciona un QWidget normal para el widget de la ventana gráfica. Se puede acceder a este widget llamando a viewport(), o se puede sustituir llamando a setViewport(). Para renderizar utilizando OpenGL, basta con llamar a setViewport(new QOpenGLWidget). QGraphicsView asume la propiedad del widget de la ventana gráfica.
QGraphicsView admite transformaciones afines mediante QTransform. Se puede pasar una matriz a setTransform() o llamar a una de las funciones de conveniencia rotate(), scale(), translate() o shear(). Las dos transformaciones más comunes son el escalado, que se utiliza para implementar el zoom, y la rotación. QGraphicsView mantiene fijo el centro de la vista durante una transformación. Debido a la alineación de la escena (setAlignment()), la traslación de la vista no tendrá ningún impacto visual.
Puedes interactuar con los elementos de la escena utilizando el ratón y el teclado. QGraphicsView convierte los eventos del ratón y del teclado en eventos de escena (eventos que heredan de QGraphicsSceneEvent) y los reenvía a la escena visualizada. En última instancia, es cada elemento individual el que gestiona los eventos y reacciona ante ellos. Por ejemplo, si haces clic en un elemento seleccionable, este normalmente notificará a la escena que ha sido seleccionado y, además, se redibujará para mostrar un rectángulo de selección. Del mismo modo, si haces clic y arrastras el ratón para mover un elemento desplazable, es el propio elemento el que gestiona los movimientos del ratón y se desplaza. La interacción con los elementos está habilitada por defecto, y puedes activarla o desactivarla llamando a ` setInteractive()`.
También puede proporcionar su propia interacción personalizada con la escena creando una subclase de `QGraphicsView` y reimplementando los controladores de eventos del ratón y del teclado. Para simplificar la forma de interactuar mediante programación con los elementos de la vista, QGraphicsView proporciona las funciones de mapeo mapToScene() y mapFromScene(), así como los accesores de elementos items() y itemAt(). Estas funciones permiten mapear puntos, rectángulos, polígonos y trazados entre las coordenadas de la vista y las de la escena, así como localizar elementos en la escena utilizando las coordenadas de la vista.
Cuando se utiliza un ` QOpenGLWidget ` como ventana de visualización, se admite el renderizado estereoscópico. Esto se lleva a cabo siguiendo el mismo patrón que en ` QOpenGLWidget::paintGL`. Para habilitarlo, activa el indicador ` QSurfaceFormat::StereoBuffers `. Debido a cómo se gestiona este indicador internamente, debes establecer el indicador ` QSurfaceFormat::StereoBuffers ` de forma global antes de crear la ventana mediante ` QSurfaceFormat::setDefaultFormat()`. Si el indicador está activado y existe compatibilidad de hardware para el renderizado estereoscópico, entonces drawBackground() y drawForeground() se activarán dos veces por fotograma. Llama a QOpenGLWidget::currentTargetBuffer() para consultar en qué búfer se está dibujando actualmente.

Nota: El uso de una ventana de visualización de OpenGL limita la capacidad de utilizar QGraphicsProxyWidget. No todas las combinaciones de widgets y estilos son compatibles con esta configuración. Debes probar minuciosamente tu interfaz de usuario y realizar los ajustes necesarios.
Véase también QGraphicsScene, QGraphicsItem y QGraphicsSceneEvent.
Documentación sobre tipos de miembros
enum QGraphicsView::CacheModeFlag
flags QGraphicsView::CacheMode
Esta enumeración describe los indicadores que se pueden establecer para el modo de caché de un ` QGraphicsView`.
| Constante | Valor | Descripción |
|---|---|---|
QGraphicsView::CacheNone | 0x0 | Todo el dibujo se realiza directamente en la ventana gráfica. |
QGraphicsView::CacheBackground | 0x1 | El fondo se almacena en caché. Esto afecta tanto a los fondos personalizados como a los basados en la propiedad « backgroundBrush ». Cuando se activa este indicador, « QGraphicsView » asignará un mapa de píxeles con el tamaño completo de la ventana gráfica. |
El tipo `CacheMode` es una definición de tipo (typedef) para `QFlags<CacheModeFlag>`. Almacena una combinación OR de valores de `CacheModeFlag`.
Véase también cacheMode.
enum QGraphicsView::DragMode
Esta enumeración describe la acción predeterminada de la vista al pulsar y arrastrar el ratón sobre la ventana de visualización.
| Constante | Valor | Descripción |
|---|---|---|
QGraphicsView::NoDrag | 0 | No ocurre nada; se ignora el evento del ratón. |
QGraphicsView::ScrollHandDrag | 1 | El cursor se convierte en una mano que señala y, al arrastrar el ratón, se desplazarán las barras de desplazamiento. Este modo funciona tanto en modo « interactive » como en modo no interactivo. |
QGraphicsView::RubberBandDrag | 2 | Aparecerá una banda elástica. Al arrastrar el ratón se definirá la geometría de la banda elástica, y se seleccionarán todos los elementos que quede cubiertos por ella. Este modo está desactivado en las vistas no interactivas. |
Véase también ` dragMode ` y ` QGraphicsScene::setSelectionArea()`.
enum QGraphicsView::OptimizationFlag
flags QGraphicsView::OptimizationFlags
Esta enumeración describe los indicadores que se pueden activar para mejorar el rendimiento de la representación en QGraphicsView. De forma predeterminada, ninguno de estos indicadores está activado. Ten en cuenta que activar un indicador suele tener un efecto secundario, y este efecto puede variar según los dispositivos de pintura y las plataformas.
| Constante | Valor | Descripción |
|---|---|---|
QGraphicsView::DontSavePainterState | 0x1 | Al renderizar, QGraphicsView protege el estado del pintor (véase QPainter::save()) al renderizar el fondo o el primer plano, y al renderizar cada elemento. Esto permite dejar el pintor en un estado alterado (es decir, se puede llamar a QPainter::setPen() o a QPainter::setBrush() sin restaurar el estado tras el pintado). Sin embargo, si los elementos restauran el estado de forma sistemática, deberías activar este indicador para evitar que QGraphicsView haga lo mismo. |
QGraphicsView::DontAdjustForAntialiasing | 0x2 | Desactiva el ajuste automático del suavizado de QGraphicsView en las áreas expuestas. Los elementos que representan líneas suavizadas en los límites de su QGraphicsItem::boundingRect() pueden acabar representando partes de la línea fuera de dichos límites. Para evitar artefactos de representación, QGraphicsView amplía todas las regiones expuestas en 2 píxeles en todas las direcciones. Si se activa esta opción, QGraphicsView dejará de realizar estos ajustes, lo que minimiza las áreas que requieren un redibujado y mejora el rendimiento. Un efecto secundario habitual es que los elementos que se dibujan con suavizado pueden dejar rastros de pintura en la escena al desplazarse. |
QGraphicsView::IndirectPainting | 0x4 | Desde Qt 4.6, se restaura el antiguo algoritmo de dibujo que llama a QGraphicsView::drawItems() y QGraphicsScene::drawItems(). Se debe utilizar únicamente para garantizar la compatibilidad con código antiguo. |
El tipo OptimizationFlags es un typedef para QFlags<OptimizationFlag>. Almacena una combinación OR de valores de OptimizationFlag.
enum QGraphicsView::ViewportAnchor
Esta enumeración describe los posibles puntos de anclaje que puede utilizar QGraphicsView cuando el usuario cambia el tamaño de la vista o cuando esta se transforma.
| Constante | Valor | Descripción |
|---|---|---|
QGraphicsView::NoAnchor | 0 | Sin ancla, es decir, la vista mantiene inalterada la posición de la escena. |
QGraphicsView::AnchorViewCenter | 1 | Se utiliza como ancla el punto de la escena situado en el centro de la vista. |
QGraphicsView::AnchorUnderMouse | 2 | Se utiliza como punto de anclaje el punto situado debajo del ratón. |
Véase también resizeAnchor y transformationAnchor.
enum QGraphicsView::ViewportUpdateMode
Esta enumeración describe cómo actualiza « QGraphicsView » su ventana de visualización cuando cambia el contenido de la escena o cuando este queda al descubierto.
| Constante | Valor | Descripción |
|---|---|---|
QGraphicsView::FullViewportUpdate | 0 | Cuando cualquier parte visible de la escena cambia o se vuelve a mostrar, QGraphicsView actualizará toda la ventana gráfica. Este enfoque es el más rápido cuando QGraphicsView dedica más tiempo a determinar qué debe dibujar que al propio dibujo (por ejemplo, cuando se actualizan repetidamente muchos elementos pequeños). Este es el modo de actualización preferido para ventanas de visualización que no admiten actualizaciones parciales, como QOpenGLWidget, y para aquellas que necesitan desactivar la optimización del desplazamiento. |
QGraphicsView::MinimalViewportUpdate | 1 | QGraphicsView Determinará la región mínima de la ventana gráfica que requiere un redibujado, minimizando el tiempo dedicado al dibujo al evitar redibujar las áreas que no han cambiado. Este es el modo predeterminado de QGraphicsView. Aunque este enfoque ofrece el mejor rendimiento en general, si hay muchos pequeños cambios visibles en la escena, QGraphicsView podría acabar dedicando más tiempo a encontrar el enfoque mínimo que al propio dibujo. |
QGraphicsView::SmartViewportUpdate | 2 | QGraphicsView Intentará encontrar un modo de actualización óptimo analizando las áreas que requieren un redibujado. |
QGraphicsView::BoundingRectViewportUpdate | 4 | Se volverá a dibujar el rectángulo delimitador de todos los cambios en la ventana gráfica. Este modo tiene la ventaja de que QGraphicsView busca cambios solo en una región, lo que minimiza el tiempo dedicado a determinar qué hay que volver a dibujar. La desventaja es que también hay que volver a dibujar las áreas que no han cambiado. |
QGraphicsView::NoViewportUpdate | 3 | QGraphicsView Nunca actualizará su ventana gráfica cuando cambie la escena; se espera que el usuario controle todas las actualizaciones. Este modo desactiva todas las comprobaciones de visibilidad de elementos (potencialmente lentas) en QGraphicsView, y es adecuado para escenas que requieran una frecuencia de fotogramas fija o en las que la ventana gráfica se actualice externamente. |
Véase también viewportUpdateMode.
Documentación de propiedades
alignment : Qt::Alignment
Esta propiedad determina la alineación de la escena en la vista cuando toda la escena está visible.
Si toda la escena está visible en la vista (es decir, no hay barras de desplazamiento visibles), la alineación de la vista determinará dónde se representará la escena en la vista. Por ejemplo, si la alineación es Qt::AlignCenter, que es la predeterminada, la escena se centrará en la vista, y si la alineación es (Qt::AlignLeft | Qt::AlignTop), la escena se representará en la esquina superior izquierda de la vista.
Funciones de acceso:
| Qt::Alignment | alignment() const |
| void | setAlignment(Qt::Alignment alignment) |
backgroundBrush : QBrush
Esta propiedad contiene el pincel de fondo de la escena.
Esta propiedad establece el pincel de fondo para la escena en esta vista. Se utiliza para anular el fondo propio de la escena y define el comportamiento de la función drawBackground(). Para proporcionar un dibujo de fondo personalizado para esta vista, puedes reimplementar la función drawBackground() en su lugar.
De forma predeterminada, esta propiedad contiene un pincel con el patrón Qt::NoBrush.
Funciones de acceso:
| QBrush | backgroundBrush() const |
| void | setBackgroundBrush(const QBrush &brush) |
Véase también QGraphicsScene::backgroundBrush y foregroundBrush.
cacheMode : CacheMode
Esta propiedad indica qué partes de la vista se almacenan en caché
QGraphicsView puede almacenar en caché contenido prerenderizado en un objeto « QPixmap », que luego se dibuja en la ventana gráfica. El objetivo de este almacenamiento en caché es acelerar el tiempo total de renderizado en aquellas áreas que tardan más en renderizarse. Los fondos con texturas, degradados y mezcla alfa, por ejemplo, pueden tardar bastante en renderizarse; especialmente con una vista transformada. El indicador « CacheBackground » habilita el almacenamiento en caché del fondo de la vista. Por ejemplo:
QGraphicsView view;
view.setBackgroundBrush(QImage(":/images/backgroundtile.png"));
view.setCacheMode(QGraphicsView::CacheBackground);La caché se invalida cada vez que se transforma la vista. Sin embargo, al desplazarse, solo se requiere una invalidación parcial.
Por defecto, no se almacena nada en caché.
Funciones de acceso:
| QGraphicsView::CacheMode | cacheMode() const |
| void | setCacheMode(QGraphicsView::CacheMode mode) |
Véase también resetCachedContent() y QPixmapCache.
dragMode : DragMode
Esta propiedad define el comportamiento al arrastrar el ratón sobre la escena mientras se mantiene pulsado el botón izquierdo del ratón.
Esta propiedad define lo que debe suceder cuando el usuario hace clic en el fondo de la escena y arrastra el ratón (por ejemplo, desplazar el contenido de la ventana gráfica con un cursor en forma de mano, o seleccionar varios elementos con una «banda elástica»). El valor por defecto, ` NoDrag`, no realiza ninguna acción.
Este comportamiento solo afecta a los clics del ratón que no son gestionados por ningún elemento. Puedes definir un comportamiento personalizado creando una subclase de ` QGraphicsView ` y reimplementando ` mouseMoveEvent()` ().
Funciones de acceso:
| QGraphicsView::DragMode | dragMode() const |
| void | setDragMode(QGraphicsView::DragMode mode) |
foregroundBrush : QBrush
Esta propiedad contiene el pincel de primer plano de la escena.
Esta propiedad establece el pincel de primer plano para la escena en esta vista. Se utiliza para anular el primer plano propio de la escena y define el comportamiento de la función ` drawForeground()`. Para proporcionar un dibujo de primer plano personalizado para esta vista, puedes reimplementar en su lugar la función ` drawForeground()`.
De forma predeterminada, esta propiedad contiene un pincel con el patrón Qt::NoBrush.
Funciones de acceso:
| QBrush | foregroundBrush() const |
| void | setForegroundBrush(const QBrush &brush) |
Véase también QGraphicsScene::foregroundBrush y backgroundBrush.
interactive : bool
Esta propiedad indica si la vista permite la interacción con la escena.
Si está habilitada, esta vista está configurada para permitir la interacción con la escena. De lo contrario, esta vista no permitirá la interacción y se ignorarán todos los eventos del ratón o del teclado (es decir, funcionará como una vista de solo lectura).
Por defecto, esta propiedad es « true ».
Funciones de acceso:
| bool | isInteractive() const |
| void | setInteractive(bool allowed) |
optimizationFlags : OptimizationFlags
opciones que se pueden utilizar para ajustar el rendimiento de QGraphicsView.
QGraphicsView Utiliza recorte, ajustes adicionales en los rectángulos delimitadores y otras técnicas para mejorar la calidad de renderizado y el rendimiento en las escenas gráficas más habituales. Sin embargo, dependiendo de la plataforma de destino, la escena y la ventana de visualización que se utilice, algunas de estas operaciones pueden reducir el rendimiento.
El efecto varía de un indicador a otro; consulta la documentación de OptimizationFlags para obtener más detalles.
Por defecto, no hay ninguna bandera de optimización activada.
Funciones de acceso:
| QGraphicsView::OptimizationFlags | optimizationFlags() const |
| void | setOptimizationFlags(QGraphicsView::OptimizationFlags flags) |
Véase también setOptimizationFlag().
renderHints : QPainter::RenderHints
Esta propiedad contiene las indicaciones de renderizado predeterminadas para la vista
Estas sugerencias se utilizan para inicializ QPainter antes de que se dibuje cada elemento visible. QPainter utiliza sugerencias de renderizado para activar o desactivar funciones de renderizado como el suavizado y la transformación suave de mapas de píxeles.
QPainter::TextAntialiasing está habilitado de forma predeterminada.
Ejemplo:
QGraphicsScene scene;
scene.addRect(QRectF(-10, -10, 20, 20));
QGraphicsView view(&scene);
view.setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform);
view.show();Funciones de acceso:
| QPainter::RenderHints | renderHints() const |
| void | setRenderHints(QPainter::RenderHints hints) |
resizeAnchor : ViewportAnchor
cómo debe la vista posicionar la escena cuando se cambia el tamaño de la vista.
QGraphicsView Utiliza esta propiedad para decidir cómo colocar la escena en la ventana gráfica cuando cambia el tamaño del widget de la ventana gráfica. El comportamiento predeterminado, NoAnchor, mantiene inalterada la posición de la escena durante un cambio de tamaño; la esquina superior izquierda de la vista parecerá estar anclada mientras se cambia el tamaño.
Ten en cuenta que el efecto de esta propiedad se aprecia cuando solo es visible una parte de la escena (es decir, cuando hay barras de desplazamiento). En caso contrario, si toda la escena cabe en la vista, QGraphicsScene utiliza la alineación de la vista para colocar la escena en la vista.
Funciones de acceso:
| QGraphicsView::ViewportAnchor | resizeAnchor() const |
| void | setResizeAnchor(QGraphicsView::ViewportAnchor anchor) |
Véase también «alignment» y « transformationAnchor ».
rubberBandSelectionMode : Qt::ItemSelectionMode
Esta propiedad define el comportamiento a la hora de seleccionar elementos con un rectángulo de selección tipo «goma elástica».
Esta propiedad define cómo se seleccionan los elementos cuando se utiliza el modo de arrastre « RubberBandDrag ».
El valor por defecto es « Qt::IntersectsItemShape »; se seleccionan todos los elementos cuya forma se cruza con la de la banda elástica o queda contenida dentro de ella.
Funciones de acceso:
| Qt::ItemSelectionMode | rubberBandSelectionMode() const |
| void | setRubberBandSelectionMode(Qt::ItemSelectionMode mode) |
Véase también « dragMode» , « items()» y « rubberBandRect()».
sceneRect : QRectF
Esta propiedad contiene el área de la escena que se visualiza en esta vista.
El rectángulo de la escena define la extensión de la misma y, en el caso de la vista, esto se refiere al área de la escena por la que se puede navegar utilizando las barras de desplazamiento.
Si no se establece, o si se establece un valor nulo QRectF, esta propiedad tiene el mismo valor que QGraphicsScene::sceneRect, y cambia con QGraphicsScene::sceneRect. De lo contrario, el rectángulo de la escena de la vista no se ve afectado por la escena.
Ten en cuenta que, aunque la escena admite un tamaño prácticamente ilimitado, el rango de las barras de desplazamiento nunca superará el rango de un entero (INT_MIN, INT_MAX). Cuando la escena sea más grande que los valores de las barras de desplazamiento, puedes optar por utilizar ` translate()` para desplazarte por la escena.
Por defecto, esta propiedad contiene un rectángulo en el origen con anchura y altura iguales a cero.
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 QGraphicsScene::sceneRect.
transformationAnchor : ViewportAnchor
cómo debe la vista posicionar la escena durante las transformaciones.
QGraphicsView Esta propiedad se utiliza para decidir cómo colocar la escena en la ventana gráfica cuando cambia la matriz de transformación y se transforma el sistema de coordenadas de la vista. El comportamiento predeterminado, ` AnchorViewCenter`, garantiza que el punto de la escena situado en el centro de la vista permanezca inalterado durante las transformaciones (por ejemplo, al girar, la escena parecerá girar alrededor del centro de la vista).
Ten en cuenta que el efecto de esta propiedad se aprecia cuando solo es visible una parte de la escena (es decir, cuando hay barras de desplazamiento). Por el contrario, si toda la escena cabe en la vista, QGraphicsScene utiliza la alineación de la vista para posicionar la escena en la misma.
Funciones de acceso:
| QGraphicsView::ViewportAnchor | transformationAnchor() const |
| void | setTransformationAnchor(QGraphicsView::ViewportAnchor anchor) |
Véase también «alignment» y « resizeAnchor ».
viewportUpdateMode : ViewportUpdateMode
cómo debe actualizar el visor su contenido.
QGraphicsView Utiliza esta propiedad para decidir cómo actualizar las áreas de la escena que se han vuelto a exponer o se han modificado. Normalmente no es necesario modificar esta propiedad, pero hay algunos casos en los que hacerlo puede mejorar el rendimiento del renderizado. Consulta la documentación de ViewportUpdateMode para obtener detalles específicos.
El valor por defecto es ` MinimalViewportUpdate`, donde ` QGraphicsView ` actualizará el área más pequeña posible de la ventana gráfica cuando cambie el contenido.
Funciones de acceso:
| QGraphicsView::ViewportUpdateMode | viewportUpdateMode() const |
| void | setViewportUpdateMode(QGraphicsView::ViewportUpdateMode mode) |
Véase también ViewportUpdateMode y cacheMode.
Documentación de las funciones de miembro
QGraphicsView::QGraphicsView(QWidget *parent = nullptr)
Crea un objeto `QGraphicsView`. Se pasa ` parent ` al constructor de ` QWidget`.
QGraphicsView::QGraphicsView(QGraphicsScene *scene, QWidget *parent = nullptr)
Crea un objeto `QGraphicsView` y establece la escena visualizada en ` scene`. El objeto ` parent ` se pasa al constructor de ` QWidget`.
[virtual noexcept] QGraphicsView::~QGraphicsView()
Destruye el objeto ` QGraphicsView `.
void QGraphicsView::centerOn(const QPointF &pos)
Desplaza el contenido de la ventana gráfica para garantizar que la coordenada de la escena pos, quede centrada en la vista.
Dado que pos es una coordenada de punto flotante y las barras de desplazamiento operan con coordenadas enteras, el centrado es solo una aproximación.
Nota: Si el elemento está cerca del borde o fuera de él, será visible en la vista, pero no estará centrado.
Véase también ensureVisible().
void QGraphicsView::centerOn(const QGraphicsItem *item)
Desplaza el contenido del área de visualización para garantizar que item quede centrado en la vista.
Esta es una función sobrecargada.
Véase también ensureVisible().
void QGraphicsView::centerOn(qreal x, qreal y)
Esta función se ofrece por comodidad. Equivale a llamar a centerOn(QPointF(x, y)).
Se trata de una función sobrecargada.
[override virtual protected] void QGraphicsView::contextMenuEvent(QContextMenuEvent *event)
Reimplementa: ` QAbstractScrollArea::contextMenuEvent(QContextMenuEvent *e)`.
[override virtual protected] void QGraphicsView::dragEnterEvent(QDragEnterEvent *event)
Reimplementa: QAbstractScrollArea::dragEnterEvent(QDragEnterEvent *event).
[override virtual protected] void QGraphicsView::dragLeaveEvent(QDragLeaveEvent *event)
Reimplementa: ` QAbstractScrollArea::dragLeaveEvent(QDragLeaveEvent *event)`.
[override virtual protected] void QGraphicsView::dragMoveEvent(QDragMoveEvent *event)
Reimplementa: QAbstractScrollArea::dragMoveEvent(QDragMoveEvent *event).
[virtual protected] void QGraphicsView::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 esta vista.
Si lo único que desea es definir un color, una textura o un degradado para el fondo, puede llamar a setBackgroundBrush() en su lugar.
Todo el dibujo se realiza en coordenadas de escena. ` rect ` es el rectángulo expuesto.
La implementación por defecto rellena ` rect ` utilizando el ` backgroundBrush` de la vista. Si no se ha definido dicho pincel (por defecto), se llama en su lugar a la función `drawBackground()` de la escena.
Véanse también drawForeground() y QGraphicsScene::drawBackground().
[virtual protected] void QGraphicsView::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 esta vista.
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.
Todo el dibujo se realiza en coordenadas de escena. ` rect ` es el rectángulo expuesto.
La implementación por defecto rellena rect utilizando el ` foregroundBrush` de la vista. Si no se ha definido dicho pincel (por defecto), se llama en su lugar a la función `drawForeground()` de la escena.
Véanse también drawBackground() y QGraphicsScene::drawForeground().
[override virtual protected] void QGraphicsView::dropEvent(QDropEvent *event)
Reimplementa: QAbstractScrollArea::dropEvent(QDropEvent *event).
void QGraphicsView::ensureVisible(const QRectF &rect, int xmargin = 50, int ymargin = 50)
Desplaza el contenido del área de visualización de modo que el rectángulo de la escena rect quede visible, con los márgenes especificados en píxeles mediante xmargin y ymargin. Si no se puede alcanzar el rectángulo especificado, el contenido se desplaza hasta la posición válida más cercana. El valor por defecto para ambos márgenes es de 50 píxeles.
Véase también centerOn().
void QGraphicsView::ensureVisible(const QGraphicsItem *item, int xmargin = 50, int ymargin = 50)
Desplaza el contenido de la ventana gráfica de modo que quede visible el centro del elemento item, con los márgenes especificados en píxeles mediante xmargin y ymargin. Si no se puede alcanzar el punto especificado, el contenido se desplaza hasta la posición válida más cercana. El valor por defecto para ambos márgenes es de 50 píxeles.
Esta es una función sobrecargada.
Véase también centerOn().
void QGraphicsView::ensureVisible(qreal x, qreal y, qreal w, qreal h, int xmargin = 50, int ymargin = 50)
Esta función se ofrece para mayor comodidad. Equivale a llamar a `ensureVisible(QRectF(x, y, w, h), xmargin, ymargin)`.
Esta es una función sobrecargada.
[override virtual protected] bool QGraphicsView::event(QEvent *event)
Reimplementa: ` QAbstractScrollArea::event(QEvent *event)`.
void QGraphicsView::fitInView(const QRectF &rect, Qt::AspectRatioMode aspectRatioMode = Qt::IgnoreAspectRatio)
Escala la matriz de vista y desplaza las barras de desplazamiento para garantizar que el rectángulo de la escena rect quepa dentro de la ventana gráfica. rect debe estar dentro del rectángulo de la escena; de lo contrario, fitInView() no puede garantizar que todo el rectángulo sea visible.
Esta función conserva la rotación, la traslación o el sesgo de la vista. La vista se escala según aspectRatioMode. rect se centrará en la vista si no encaja perfectamente.
Es habitual llamar a `fitInView()` desde el interior de una reimplementación de ` resizeEvent()`, para garantizar que toda la escena, o partes de ella, se escalen automáticamente para ajustarse al nuevo tamaño de la ventana de visualización a medida que se redimensiona la vista. Sin embargo, ten en cuenta que llamar a `fitInView()` desde dentro de ` resizeEvent()` puede provocar una recursión de redimensionamiento no deseada, si la nueva transformación alterna el estado automático de las barras de desplazamiento. Puedes establecer las políticas de las barras de desplazamiento en «siempre activadas» o «siempre desactivadas» para evitarlo (consulta ` horizontalScrollBarPolicy()` y ` verticalScrollBarPolicy()`).
Si rect está vacío, o si la ventana de visualización es demasiado pequeña, esta función no hará nada.
Véase también setTransform(), ensureVisible() y centerOn().
void QGraphicsView::fitInView(const QGraphicsItem *item, Qt::AspectRatioMode aspectRatioMode = Qt::IgnoreAspectRatio)
Garantiza que item se ajuste perfectamente dentro de la vista, ajustando el tamaño de esta según aspectRatioMode.
Esta es una función sobrecargada.
Véase también ensureVisible() y centerOn().
void QGraphicsView::fitInView(qreal x, qreal y, qreal w, qreal h, Qt::AspectRatioMode aspectRatioMode = Qt::IgnoreAspectRatio)
Esta función de conveniencia equivale a llamar a `fitInView(QRectF(x, y, w, h), aspectRatioMode)`.
Esta es una función sobrecargada.
Véase también ensureVisible() y centerOn().
[override virtual protected] void QGraphicsView::focusInEvent(QFocusEvent *event)
Reimplementa: QWidget::focusInEvent(QFocusEvent *event).
[override virtual protected] bool QGraphicsView::focusNextPrevChild(bool next)
Reimplementa: QWidget::focusNextPrevChild(bool next).
[override virtual protected] void QGraphicsView::focusOutEvent(QFocusEvent *event)
Reimplementa: QWidget::focusOutEvent(QFocusEvent *event).
[override virtual protected] void QGraphicsView::inputMethodEvent(QInputMethodEvent *event)
Reimplementa: ` QWidget::inputMethodEvent(QInputMethodEvent *event)`.
[override virtual] QVariant QGraphicsView::inputMethodQuery(Qt::InputMethodQuery query) const
Reimplementa: ` QWidget::inputMethodQuery` (constructor `Qt::InputMethodQuery`).
[slot] void QGraphicsView::invalidateScene(const QRectF &rect = QRectF(), QGraphicsScene::SceneLayers layers = QGraphicsScene::AllLayers)
Invalida y programa un redibujado de layers dentro de rect. rect está en coordenadas de escena. Cualquier contenido almacenado en caché para layers dentro de rect se invalida y se redibuja de forma incondicional.
Puedes llamar a esta función para notificar a QGraphicsView los cambios en el fondo o el primer plano de la escena. Se utiliza habitualmente en escenas con fondos basados en mosaicos para notificar cambios cuando QGraphicsView ha habilitado el almacenamiento en caché del fondo.
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 QGraphicsScene::BackgroundLayer.
Véanse también QGraphicsScene::invalidate() y update().
bool QGraphicsView::isTransformed() const
Devuelve « true » si la vista se ha transformado (es decir, si se le ha asignado una transformación distinta de la identidad o si se han ajustado las barras de desplazamiento).
Véase también setTransform(), horizontalScrollBar() y verticalScrollBar().
QGraphicsItem *QGraphicsView::itemAt(const QPoint &pos) const
Devuelve el elemento situado en la posición pos, expresada en coordenadas de la ventana gráfica. Si hay varios elementos en esta posición, esta función devuelve el elemento situado más arriba.
Ejemplo:
void CustomView::mousePressEvent(QMouseEvent*event)
{
if (QGraphicsItem*item = itemAt(event->pos())) {
qDebug() << "You clicked on item" << item;
} else {
qDebug("You didn't click on an item.");
}
}Véase también items() y Sorting.
QGraphicsItem *QGraphicsView::itemAt(int x, int y) const
Esta función se ofrece por comodidad. Equivale a llamar a `itemAt(QPoint(x, y))`.
Se trata de una función sobrecargada.
QList<QGraphicsItem *> QGraphicsView::items() const
Devuelve una lista con todos los elementos de la escena asociada, ordenados de mayor a menor según su posición en la pila (es decir, el primer elemento de la lista devuelta es el que se encuentra en la parte superior).
Véase también QGraphicsScene::items() y Sorting.
QList<QGraphicsItem *> QGraphicsView::items(const QPoint &pos) const
Devuelve una lista de todos los elementos situados en la posición pos dentro de la vista. Los elementos se enumeran en orden descendente de apilamiento (es decir, el primer elemento de la lista es el que se encuentra en la parte superior, y el último, el que está en la parte inferior). pos se expresa en coordenadas de la ventana gráfica.
Esta función se suele invocar desde los controladores de eventos del ratón en una subclase de ` QGraphicsView`. ` pos ` está en coordenadas de la ventana gráfica sin transformar, al igual que ` QMouseEvent::position()`.
void CustomView::mousePressEvent(QMouseEvent*event)
{
qDebug() << "There are" << items(event->pos()).size()
<< «elementos en la posición» << mapToScene(event->pos());
}Véase también QGraphicsScene::items() y Sorting.
QList<QGraphicsItem *> QGraphicsView::items(int x, int y) const
Esta función se ofrece para mayor comodidad. Equivale a llamar a items(QPoint(x, y)).
QList<QGraphicsItem *> QGraphicsView::items(int x, int y, int w, int h, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const
Esta función de conveniencia equivale a llamar a items(QRectF(x, y, w, h), mode).
QList<QGraphicsItem *> QGraphicsView::items(const QPainterPath &path, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const
Devuelve una lista de todos los elementos que, en función de ` mode`, están contenidos en ` path` o se cruzan con él. ` path ` está expresado en coordenadas de la ventana gráfica.
El valor por defecto de ` mode ` es ` Qt::IntersectsItemShape`; se devuelven todos los elementos cuya forma exacta se cruza con ` path ` o está contenida en él.
Esta es una función sobrecargada.
Véase también itemAt(), items(), mapToScene() y Sorting.
QList<QGraphicsItem *> QGraphicsView::items(const QPolygon &polygon, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const
Devuelve una lista de todos los elementos que, en función de ` mode`, están contenidos en ` polygon` o se cruzan con él. ` polygon ` está en coordenadas de la ventana gráfica.
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.
Los elementos se ordenan por orden de apilamiento descendente (es decir, el primer elemento de la lista devuelta es el que se encuentra en la parte superior).
Esta es una función sobrecargada.
Véanse también itemAt(), items(), mapToScene() y Sorting.
QList<QGraphicsItem *> QGraphicsView::items(const QRect &rect, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const
Devuelve una lista de todos los elementos que, en función de ` mode`, están contenidos en ` rect` o se cruzan con él. ` rect ` está expresado en coordenadas de la ventana gráfica.
El valor por defecto de mode es Qt::IntersectsItemShape; se devuelven todos los elementos cuya forma exacta se cruza con rect o está contenida en él.
Los elementos se ordenan en orden de apilamiento descendente (es decir, el primer elemento de la lista devuelta es el que se encuentra en la parte superior).
Esta es una función sobrecargada.
Véase también itemAt(), items(), mapToScene() y Sorting.
[override virtual protected] void QGraphicsView::keyPressEvent(QKeyEvent *event)
Reimplementa: QAbstractScrollArea::keyPressEvent(QKeyEvent *e).
[override virtual protected] void QGraphicsView::keyReleaseEvent(QKeyEvent *event)
Reimplementa: ` QWidget::keyReleaseEvent(QKeyEvent *event)`.
QPainterPath QGraphicsView::mapFromScene(const QPainterPath &path) const
Devuelve la ruta del pintor de coordenadas de la escena path a una ruta del pintor de coordenadas de la ventana gráfica.
Véase también mapToScene().
QPoint QGraphicsView::mapFromScene(const QPointF &point) const
Devuelve las coordenadas de la escena point a coordenadas de la ventana gráfica.
Véase también mapToScene().
QPolygon QGraphicsView::mapFromScene(const QPolygonF &polygon) const
Devuelve el polígono de coordenadas de escena polygon a un polígono de coordenadas de ventana gráfica.
Véase también mapToScene().
QPolygon QGraphicsView::mapFromScene(const QRectF &rect) const
Devuelve el rectángulo de la escena rect a un polígono de coordenadas de la ventana gráfica.
Véase también mapToScene().
QPoint QGraphicsView::mapFromScene(qreal x, qreal y) const
Esta función se ofrece por comodidad. Equivale a llamar a `mapFromScene(QPointF(x, y))`.
QPolygon QGraphicsView::mapFromScene(qreal x, qreal y, qreal w, qreal h) const
Esta función se ofrece para mayor comodidad. Equivale a llamar a mapFromScene(QRectF(x, y, w, h)).
QPainterPath QGraphicsView::mapToScene(const QPainterPath &path) const
Devuelve la ruta del pintor de la ventana gráfica path asignada a una ruta del pintor de coordenadas de la escena.
Véase también mapFromScene().
QPointF QGraphicsView::mapToScene(const QPoint &point) const
Devuelve la coordenada de la ventana gráfica point mapeada a las coordenadas de la escena.
Nota: Puede resultar útil mapear todo el rectángulo que abarca el píxel en point en lugar del propio punto. Para ello, puedes llamar a mapToScene(QRect(point, QSize(2, 2))).
Véase también mapFromScene().
QPolygonF QGraphicsView::mapToScene(const QPolygon &polygon) const
Devuelve el polígono de la ventana gráfica polygon mapeado a un polígono de coordenadas de la escena.
Véase también mapFromScene().
QPolygonF QGraphicsView::mapToScene(const QRect &rect) const
Devuelve el rectángulo de la ventana de visualización rect asignado a un polígono de coordenadas de la escena.
Véase también mapFromScene().
QPointF QGraphicsView::mapToScene(int x, int y) const
Esta función se ofrece para mayor comodidad. Equivale a llamar a `mapToScene(QPoint(x, y))`.
QPolygonF QGraphicsView::mapToScene(int x, int y, int w, int h) const
Esta función se ofrece para mayor comodidad. Equivale a llamar a `mapToScene(QRect(x, y, w, h))`.
[override virtual protected] void QGraphicsView::mouseDoubleClickEvent(QMouseEvent *event)
Reimplementa: QAbstractScrollArea::mouseDoubleClickEvent(QMouseEvent *e).
[override virtual protected] void QGraphicsView::mouseMoveEvent(QMouseEvent *event)
Reimplementa: QAbstractScrollArea::mouseMoveEvent(QMouseEvent *e).
[override virtual protected] void QGraphicsView::mousePressEvent(QMouseEvent *event)
Reimplementa: QAbstractScrollArea::mousePressEvent(QMouseEvent *e).
[override virtual protected] void QGraphicsView::mouseReleaseEvent(QMouseEvent *event)
Reimplementa: ` QAbstractScrollArea::mouseReleaseEvent(QMouseEvent *e)`.
[override virtual protected] void QGraphicsView::paintEvent(QPaintEvent *event)
Reimplementa: QAbstractScrollArea::paintEvent(QPaintEvent *event).
void QGraphicsView::render(QPainter *painter, const QRectF &target = QRectF(), const QRect &source = QRect(), Qt::AspectRatioMode aspectRatioMode = Qt::KeepAspectRatio)
Convierte el rectángulo ` source `, que está en coordenadas de vista, de la escena a ` target`, que está en coordenadas del dispositivo de dibujo, utilizando ` painter`. Esta función resulta útil para capturar el contenido de la vista en un dispositivo de dibujo, como un ` QImage ` (por ejemplo, para hacer una captura de pantalla), o para imprimir en `QPrinter`. Por ejemplo:
QGraphicsScene scene;
scene.addItem(someItem);
//...
QGraphicsView view(&scene);
view.show();
//...
QPrinter printer(QPrinter::HighResolution);
printer.setDocName("Example");
QPainter painter(&printer);
// print, fitting the viewport contents into a full page
view.render(&painter);
// print the upper half of the viewport into the lower.
// half of the page.
QRect viewport = view.viewport()->rect();
view.render(&painter,
QRectF(0, printer.height() / 2,
printer.width(), printer.height() / 2),
viewport.adjusted(0, 0, 0, -viewport.height() / 2));Si source es un rect nulo, esta función utilizará viewport()->rect() para determinar qué dibujar. Si target es un rect nulo, se utilizarán las dimensiones completas del dispositivo de dibujo de painter(por ejemplo, para un QPrinter, el tamaño de la página).
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 QGraphicsScene::render().
void QGraphicsView::resetCachedContent()
Restablece cualquier contenido almacenado en caché. Al llamar a esta función, se borrará la caché de QGraphicsView. Si el modo de caché actual es CacheNone, esta función no realiza ninguna acción.
Esta función se invoca automáticamente cuando cambian las propiedades backgroundBrush o QGraphicsScene::backgroundBrush; solo es necesario invocar esta función si se ha reimplementado QGraphicsScene::drawBackground() o QGraphicsView::drawBackground() para dibujar un fondo personalizado y se necesita provocar un redibujado completo.
Véase también cacheMode().
void QGraphicsView::resetTransform()
Restablece la transformación de la vista a la matriz identidad.
Véase también transform() y setTransform().
[override virtual protected] void QGraphicsView::resizeEvent(QResizeEvent *event)
Reimplementa: QAbstractScrollArea::resizeEvent(QResizeEvent *event).
void QGraphicsView::rotate(qreal angle)
Gira la transformación de la vista actual angle grados en el sentido de las agujas del reloj.
Véase también setTransform(), transform(), scale(), shear() y translate().
[signal] void QGraphicsView::rubberBandChanged(QRect rubberBandRect, QPointF fromScenePoint, QPointF toScenePoint)
Esta señal se emite cuando se modifica el rectángulo de la goma elástica. El rectángulo de la ventana de visualización se especifica mediante rubberBandRect. Las posiciones inicial y final del arrastre se indican en puntos de la escena mediante fromScenePoint y toScenePoint.
Cuando finaliza la selección con el rectángulo de goma, se emite esta señal con valores nulos.
Véase también rubberBandRect().
QRect QGraphicsView::rubberBandRect() const
Esta función devuelve el área actual de la «goma elástica» (en coordenadas de la ventana gráfica) si el usuario está seleccionando elementos con la «goma elástica». Cuando el usuario no está utilizando la «goma elástica», esta función devuelve (un valor nulo) QRectF().
Ten en cuenta que parte de este ` QRect ` puede estar fuera del área visible. Por ejemplo, puede contener valores negativos.
Véase también rubberBandSelectionMode y rubberBandChanged().
void QGraphicsView::scale(qreal sx, qreal sy)
Aplica una escala a la transformación de la vista actual según (sx, sy).
Véase también setTransform(), transform(), rotate(), shear() y translate().
QGraphicsScene *QGraphicsView::scene() const
Devuelve un puntero a la escena que se está visualizando actualmente en la vista. Si no hay ninguna escena visualizada en ese momento, se devuelve « nullptr ».
Véase también setScene().
[override virtual protected] void QGraphicsView::scrollContentsBy(int dx, int dy)
Reimplementa: QAbstractScrollArea::scrollContentsBy(int dx, int dy).
void QGraphicsView::setOptimizationFlag(QGraphicsView::OptimizationFlag flag, bool enabled = true)
Activa flag si enabled es verdadero; en caso contrario, desactiva flag.
Véase también optimizationFlags.
void QGraphicsView::setRenderHint(QPainter::RenderHint hint, bool enabled = true)
Si enabled es verdadero, se activa la indicación de renderizado hint; en caso contrario, se desactiva.
Véase también renderHints.
void QGraphicsView::setScene(QGraphicsScene *scene)
Establece la escena actual en « scene ». Si ya se está visualizando « scene », esta función no realiza ninguna acción.
Cuando se establece una escena en una vista, la señal QGraphicsScene::changed() se conecta automáticamente a la ranura updateScene() de dicha vista, y las barras de desplazamiento de la vista se ajustan para adaptarse al tamaño de la escena.
La vista no asume la propiedad de scene.
Véase también scene().
void QGraphicsView::setTransform(const QTransform &matrix, bool combine = false)
Establece la matriz de transformación actual de la vista en matrix.
Si ` combine ` es `true`, entonces ` matrix ` se combina con la matriz actual; en caso contrario, ` matrix ` sustituye a la matriz actual. ` combine ` es `false` por defecto.
La matriz de transformación transforma la escena a coordenadas de vista. Utilizando la transformación por defecto, proporcionada por la matriz identidad, un píxel en la vista representa una unidad en la escena (por ejemplo, un elemento rectangular de 10x10 se dibuja utilizando 10x10 píxeles en la vista). Si se aplica una matriz de escala 2x2, la escena se dibujará en una proporción de 1:2 (por ejemplo, un elemento rectangular de 10x10 se dibujará entonces utilizando 20x20 píxeles en la vista).
Ejemplo:
QGraphicsScene scene;
scene.addText("GraphicsView rotated clockwise");
QGraphicsView view(&scene);
view.rotate(90); // the text is rendered with a 90 degree clockwise rotation
view.show();Para simplificar la interacción con los elementos utilizando una vista transformada, QGraphicsView proporciona las funciones `mapTo...` y `mapFrom...`, que permiten convertir entre coordenadas de escena y de vista. Por ejemplo, puede llamar a ` mapToScene()` para asignar una coordenada de vista a una coordenada de escena de punto flotante, o a ` mapFromScene()` para asignar coordenadas de escena de punto flotante a coordenadas de vista.
Véase también transform(), resetTransform(), rotate(), scale(), shear() y translate().
[override virtual protected slot] void QGraphicsView::setupViewport(QWidget *widget)
Reimplementa: QAbstractScrollArea::setupViewport(QWidget *viewport).
QAbstractScrollArea invoca esta ranura después de que se haya llamado a setViewport(). Reimplementa esta función en una subclase de QGraphicsView para inicializar la nueva ventana de visualización widget antes de que se utilice.
Véase también setViewport().
void QGraphicsView::shear(qreal sh, qreal sv)
Recorta la transformación de la vista actual mediante (sh, sv).
Véanse también setTransform(), transform(), rotate(), scale() y translate().
[override virtual protected] void QGraphicsView::showEvent(QShowEvent *event)
Reimplementa: ` QWidget::showEvent(QShowEvent *event)`.
[override virtual] QSize QGraphicsView::sizeHint() const
Reimplementa: QAbstractScrollArea::sizeHint() const.
QTransform QGraphicsView::transform() const
Devuelve la matriz de transformación actual de la vista. Si no hay ninguna transformación actual definida, se devuelve la matriz de identidad.
Véase también setTransform(), rotate(), scale(), shear() y translate().
void QGraphicsView::translate(qreal dx, qreal dy)
Transforma la vista actual según (dx, dy).
Véase también setTransform(), transform(), rotate() y shear().
[slot] void QGraphicsView::updateScene(const QList<QRectF> &rects)
Programa una actualización de los rectángulos de escena rects.
Véase también QGraphicsScene::changed().
[slot] void QGraphicsView::updateSceneRect(const QRectF &rect)
Notifica a QGraphicsView que el rectángulo de escena ha cambiado. rect es el nuevo rectángulo de escena. Si la vista ya tiene un rectángulo de escena establecido explícitamente, esta función no realiza ninguna acción.
Véase también sceneRect y QGraphicsScene::sceneRectChanged().
[override virtual protected] bool QGraphicsView::viewportEvent(QEvent *event)
Reimplementa: ` QAbstractScrollArea::viewportEvent(QEvent *event)`.
QTransform QGraphicsView::viewportTransform() const
Devuelve una matriz que asigna las coordenadas de la escena a las coordenadas de la ventana gráfica.
Véase también mapToScene() y mapFromScene().
[override virtual protected] void QGraphicsView::wheelEvent(QWheelEvent *event)
Reimplementa: QAbstractScrollArea::wheelEvent(QWheelEvent *e).
© 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.