En esta página

QGraphicsView Class

La clase QGraphicsView proporciona un widget para mostrar el contenido de un QGraphicsScene. Más...

Cabecera: #include <QGraphicsView>
CMake: find_package(Qt6 REQUIRED COMPONENTS Widgets)
target_link_libraries(mytarget PRIVATE Qt6::Widgets)
qmake: QT += widgets
Hereda: 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 QGraphicsScene en un viewport desplazable. Para crear una escena con elementos geométricos, consulte la documentación de QGraphicsScene. QGraphicsView es parte del Graphics View Framework.

Para visualizar una escena, empieza por construir un objeto QGraphicsView, pasando la dirección de la escena que quieres visualizar al constructor de QGraphicsView. Alternativamente, puedes llamar a setScene() para establecer la escena en un momento posterior. Después de llamar a show(), la vista se desplazará por defecto al centro de la escena y mostrará cualquier elemento que sea visible en este punto. 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(). Pasando un punto a centerOn(), QGraphicsView desplazará su vista para asegurarse de que el punto está centrado en la vista. Se proporciona una sobrecarga para desplazarse a QGraphicsItem, en cuyo caso QGraphicsView se asegurará de que el centro del elemento esté centrado en la vista. Si todo lo que desea es asegurarse de que un área determinada es visible, (pero no necesariamente centrada,) puede llamar a ensureVisible() en su lugar.

QGraphicsView puede ser utilizado para visualizar una escena completa, o sólo partes de ella. Por defecto, el área visualizada se detecta automáticamente cuando la vista se muestra por primera vez (llamando a QGraphicsScene::itemsBoundingRect()). Para establecer el rectángulo del área visualizada, puede llamar a setSceneRect(). Esto ajustará apropiadamente los rangos de las barras de desplazamiento. Ten en cuenta que aunque la escena soporta un tamaño virtualmente ilimitado, el rango de las barras de desplazamiento nunca excederá el rango de un entero (INT_MIN, INT_MAX).

QGraphicsView visualiza la escena llamando a render(). Por defecto, los ítems se dibujan en la ventana gráfica usando un QPainter normal, y usando las sugerencias de renderizado por defecto. Para cambiar las pistas de renderizado por defecto que QGraphicsView pasa a QPainter cuando pinta elementos, puedes llamar a setRenderHints().

Por defecto, QGraphicsView proporciona un widget regular QWidget para la ventana gráfica. Puedes acceder a este widget llamando a viewport(), o puedes reemplazarlo llamando a setViewport(). Para renderizar usando OpenGL, simplemente llama a setViewport(new QOpenGLWidget). QGraphicsView toma posesión del widget viewport.

QGraphicsView soporta transformaciones afines, usando QTransform. Puedes pasar una matriz a setTransform(), o puedes llamar a una de las funciones de conveniencia rotate(), scale(), translate() o shear(). Las dos transformaciones más comunes son la escala, 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 traduce los eventos de ratón y teclado en eventos de escena, (eventos que heredan de QGraphicsSceneEvent,), y los reenvía a la escena visualizada. Al final, es el elemento individual el que maneja los eventos y reacciona a ellos. Por ejemplo, si haces clic en un elemento seleccionable, el elemento normalmente hará saber a la escena que ha sido seleccionado, y también 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 movible, es el elemento el que maneja los movimientos del ratón y se mueve a sí mismo. La interacción de elementos está activada por defecto, y puedes cambiarla llamando a setInteractive().

También puedes proporcionar tu propia interacción de escena personalizada, creando una subclase de QGraphicsView, y reimplementando los manejadores de eventos de ratón y tecla. Para simplificar la interacción programática con los elementos de la vista, QGraphicsView proporciona las funciones de mapeo mapToScene() y mapFromScene(), y los accesores a elementos items() y itemAt(). Estas funciones permiten mapear puntos, rectángulos, polígonos y rutas entre las coordenadas de la vista y las coordenadas de la escena, y encontrar elementos en la escena utilizando las coordenadas de la vista.

Cuando se utiliza QOpenGLWidget como ventana gráfica, se admite el renderizado estereoscópico. Para ello se utiliza el mismo patrón que en QOpenGLWidget::paintGL. Para activarlo, active la bandera QSurfaceFormat::StereoBuffers. Debido a cómo se gestiona internamente, active QSurfaceFormat::StereoBuffers globalmente antes de crear la ventana con QSurfaceFormat::setDefaultFormat(). Si la bandera está activada y hay soporte de hardware para renderizado estereoscópico, entonces drawBackground() y drawForeground() se activarán dos veces cada fotograma. Llame a QOpenGLWidget::currentTargetBuffer() para consultar en qué búfer se está dibujando actualmente.

Rejilla de chips informáticos

Nota: El uso de un viewport OpenGL limita la posibilidad de utilizar QGraphicsProxyWidget. No todas las combinaciones de widgets y estilos pueden ser soportadas con esta configuración. Deberías probar cuidadosamente tu interfaz de usuario y hacer los ajustes necesarios.

Véase también QGraphicsScene, QGraphicsItem, y QGraphicsSceneEvent.

Documentación de tipos de miembros

enum QGraphicsView::CacheModeFlag
flags QGraphicsView::CacheMode

Este enum describe los indicadores que se pueden definir para el modo de caché de QGraphicsView.

ConstanteValorDescripción
QGraphicsView::CacheNone0x0Toda la pintura se realiza directamente sobre la ventana gráfica.
QGraphicsView::CacheBackground0x1El fondo se almacena en caché. Esto afecta tanto a los fondos personalizados como a los fondos basados en la propiedad backgroundBrush. Cuando esta opción está activada, QGraphicsView asignará un pixmap con el tamaño completo de la ventana gráfica.

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

Véase también cacheMode.

enum QGraphicsView::DragMode

Este enum describe la acción por defecto para la vista al pulsar y arrastrar el ratón sobre la ventana gráfica.

ConstanteValorDescripción
QGraphicsView::NoDrag0No ocurre nada; el evento del ratón es ignorado.
QGraphicsView::ScrollHandDrag1El cursor se convierte en una mano, y al arrastrar el ratón se desplazan las barras de desplazamiento. Este modo funciona tanto en interactive como en modo no interactivo.
QGraphicsView::RubberBandDrag2Aparecerá una goma elástica. Si arrastra el ratón, se establecerá la geometría de la banda elástica y se seleccionarán todos los elementos cubiertos por ella. Este modo está desactivado para las vistas no interactivas.

Ver también dragMode y QGraphicsScene::setSelectionArea().

enum QGraphicsView::OptimizationFlag
flags QGraphicsView::OptimizationFlags

Este enum describe las banderas que puedes activar para mejorar el rendimiento de renderizado en QGraphicsView. Por defecto, ninguna de estas banderas está activada. Tenga en cuenta que el establecimiento de una bandera por lo general impone un efecto secundario, y este efecto puede variar entre los dispositivos de pintura y plataformas.

ConstanteValorDescripción
QGraphicsView::DontSavePainterState0x1Al 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 le permite dejar el pintor en un estado alterado (es decir, puede llamar a QPainter::setPen() o QPainter::setBrush() sin restaurar el estado después de pintar). Sin embargo, si los elementos restauran el estado de forma consistente, debería activar esta bandera para evitar que QGraphicsView haga lo mismo.
QGraphicsView::DontAdjustForAntialiasing0x2Desactiva el ajuste automático del antialiasing de las áreas expuestas de QGraphicsView. Los elementos que renderizan líneas con antialiasing en los límites de su QGraphicsItem::boundingRect() pueden acabar renderizando partes de la línea fuera. Para evitar artefactos de renderizado, QGraphicsView expande todas las regiones expuestas en 2 píxeles en todas las direcciones. Si habilita esta bandera, QGraphicsView ya no realizará estos ajustes, minimizando las áreas que requieren ser redibujadas, lo que mejora el rendimiento. Un efecto secundario común es que los elementos que se dibujan con antialiasing pueden dejar rastros de pintura en la escena cuando se mueven.
QGraphicsView::IndirectPainting0x4Desde Qt 4.6, restaura el antiguo algoritmo de pintado que llama a QGraphicsView::drawItems() y QGraphicsScene::drawItems(). Usar solo por compatibilidad con código antiguo.

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

enum QGraphicsView::ViewportAnchor

Estos enums describen los posibles anclajes que QGraphicsView puede utilizar cuando el usuario cambia el tamaño de la vista o cuando la vista se transforma.

ConstanteValorDescripción
QGraphicsView::NoAnchor0Sin ancla, es decir, la vista no cambia la posición de la escena.
QGraphicsView::AnchorViewCenter1El punto de la escena situado en el centro de la vista se utiliza como ancla.
QGraphicsView::AnchorUnderMouse2El punto situado bajo el ratón se utiliza como ancla.

Véase también resizeAnchor y transformationAnchor.

enum QGraphicsView::ViewportUpdateMode

Este enum describe cómo QGraphicsView actualiza su ventana gráfica cuando los contenidos de la escena cambian o son expuestos.

ConstanteValorDescripción
QGraphicsView::FullViewportUpdate0Cuando cualquier parte visible de la escena cambia o es reexpuesta, QGraphicsView actualizará toda la ventana gráfica. Este método es el más rápido cuando QGraphicsView emplea más tiempo en averiguar qué dibujar que en dibujar (por ejemplo, cuando se actualizan repetidamente muchos elementos pequeños). Este es el modo de actualización preferido para las ventanas gráficas que no admiten actualizaciones parciales, como QOpenGLWidget, y para las ventanas gráficas que necesitan desactivar la optimización del desplazamiento.
QGraphicsView::MinimalViewportUpdate1QGraphicsView determinará la región mínima de la ventana gráfica que requiere ser redibujada, minimizando el tiempo de dibujo al evitar redibujar áreas que no han cambiado. Este es el modo por defecto de QGraphicsView. Aunque este enfoque proporciona el mejor rendimiento en general, si hay muchos pequeños cambios visibles en la escena, QGraphicsView podría terminar gastando más tiempo en encontrar el enfoque mínimo que en dibujar.
QGraphicsView::SmartViewportUpdate2QGraphicsView intentará encontrar un modo de actualización óptimo analizando las áreas que requieren un redibujado.
QGraphicsView::BoundingRectViewportUpdate4Se redibujará el rectángulo que delimita todos los cambios en la ventana gráfica. Este modo tiene la ventaja de que QGraphicsView sólo busca cambios en una región, minimizando el tiempo dedicado a determinar qué necesita ser redibujado. La desventaja es que las áreas que no han cambiado también necesitan ser redibujadas.
QGraphicsView::NoViewportUpdate3QGraphicsView nunca actualizará su ventana gráfica cuando cambie la escena; se espera que el usuario controle todas las actualizaciones. Este modo desactiva todas las pruebas de visibilidad de elementos (potencialmente lentas) en QGraphicsView, y es adecuado para escenas que requieren una velocidad de fotogramas fija o en las que la ventana gráfica se actualiza externamente.

Véase también viewportUpdateMode.

Documentación de propiedades

alignment : Qt::Alignment

Esta propiedad contiene la alineación de la escena en la vista cuando toda la escena es visible.

Si toda la escena está visible en la vista (es decir, no hay barras de desplazamiento visibles), la alineación de la vista decidirá 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 de la escena en esta vista. Se utiliza para sobrescribir el propio fondo de la escena, y define el comportamiento de drawBackground(). Para proporcionar un dibujo de fondo personalizado para esta vista, puedes reimplementar drawBackground() en su lugar.

Por defecto, 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 pre-renderizado en QPixmap, que luego se dibuja en la ventana gráfica. El propósito de este tipo de caché es acelerar el tiempo total de renderizado para las áreas que son lentas de renderizar. Los fondos de texturas, degradados y mezclas alfa, por ejemplo, pueden ser notablemente lentos de renderizar; especialmente con una vista transformada. La opción CacheBackground permite almacenar en caché el 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, cuando se desplaza, sólo se requiere una invalidación parcial.

Por defecto, no se almacena nada en la caché.

Funciones de acceso:

QGraphicsView::CacheMode cacheMode() const
void setCacheMode(QGraphicsView::CacheMode mode)

Véase también resetCachedContent() y QPixmapCache.

dragMode : DragMode

Esta propiedad contiene el comportamiento para arrastrar el ratón sobre la escena mientras el botón izquierdo del ratón está pulsado.

Esta propiedad define lo que debe ocurrir cuando el usuario pulsa sobre el fondo de la escena y arrastra el ratón (por ejemplo, desplazar el contenido de la ventana gráfica utilizando un cursor de mano, o seleccionar múltiples elementos con una goma elástica). El valor por defecto, NoDrag, no hace nada.

Este comportamiento sólo afecta a los clics del ratón que no son manejados por ningún elemento. Puede 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 reemplazar el primer plano de la escena y define el comportamiento de drawForeground(). Para proporcionar un primer plano personalizado para esta vista, puedes reimplementar drawForeground() en su lugar.

Por defecto, 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á activada, la vista permite la interacción con la escena. En caso contrario, esta vista no permitirá interacción, y cualquier evento de ratón o tecla será ignorado (es decir, actuará como una vista de sólo lectura).

Por defecto, esta propiedad es true.

Funciones de acceso:

bool isInteractive() const
void setInteractive(bool allowed)

optimizationFlags : OptimizationFlags

que pueden utilizarse para ajustar el rendimiento de QGraphicsView.

QGraphicsView utiliza recortes, ajustes adicionales de los rectos delimitadores y algunas otras ayudas para mejorar la calidad y el rendimiento de la renderización en el caso común de las escenas gráficas. Sin embargo, dependiendo de la plataforma de destino, la escena y la ventana gráfica en uso, algunas de estas operaciones pueden degradar el rendimiento.

El efecto varía de un indicador a otro; consulte la documentación de OptimizationFlags para obtener más detalles.

Por defecto, no se activa ninguna bandera de optimización.

Funciones de acceso:

QGraphicsView::OptimizationFlags optimizationFlags() const
void setOptimizationFlags(QGraphicsView::OptimizationFlags flags)

Véase también setOptimizationFlag().

renderHints : QPainter::RenderHints

Esta propiedad contiene los consejos de renderizado por defecto para la vista.

Estas sugerencias se utilizan para inicializar QPainter antes de que se dibuje cada elemento visible. QPainter utiliza sugerencias de renderizado para activar funciones de renderizado como el antialiasing y la transformación suave de pixmaps.

QPainter::TextAntialiasing está activada por defecto.

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 posicionar la vista 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. El comportamiento por defecto, NoAnchor, deja la posición de la escena sin cambios durante un redimensionamiento; la esquina superior izquierda de la vista aparecerá anclada mientras se redimensiona.

Tenga en cuenta que el efecto de esta propiedad es notable cuando sólo 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 posicionar la escena en la vista.

Funciones de acceso:

QGraphicsView::ViewportAnchor resizeAnchor() const
void setResizeAnchor(QGraphicsView::ViewportAnchor anchor)

Véase también alineación y transformationAnchor.

rubberBandSelectionMode : Qt::ItemSelectionMode

Esta propiedad contiene el comportamiento para seleccionar elementos con un rectángulo de selección de banda 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 ítems cuya forma intersecte o esté contenida por la banda elástica.

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 visualizada por esta vista.

El rectángulo de la escena define la extensión de la escena, y en el caso de la vista, esto significa el área de la escena por la que se puede navegar utilizando las barras de desplazamiento.

Si no se establece, o si se establece un QRectF nulo, esta propiedad tiene el mismo valor que QGraphicsScene::sceneRect, y cambia con QGraphicsScene::sceneRect. En caso contrario, el rectángulo de 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 número entero (INT_MIN, INT_MAX). Cuando la escena es mayor que los valores de las barras de desplazamiento, puedes optar por utilizar translate() para navegar por la escena en su lugar.

Por defecto, esta propiedad contiene un rectángulo en el origen con anchura y altura 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 posicionar la vista la escena durante las transformaciones.

QGraphicsView utiliza esta propiedad 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 por defecto, AnchorViewCenter, asegura que el punto de la escena en el centro de la vista permanece inalterado durante las transformaciones (por ejemplo, al rotar, la escena parecerá rotar alrededor del centro de la vista).

Tenga en cuenta que el efecto de esta propiedad es notable cuando sólo 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 posicionar la escena en la vista.

Funciones de acceso:

QGraphicsView::ViewportAnchor transformationAnchor() const
void setTransformationAnchor(QGraphicsView::ViewportAnchor anchor)

Véase también alineación y resizeAnchor.

viewportUpdateMode : ViewportUpdateMode

cómo debe actualizar su contenido la ventana gráfica.

QGraphicsView utiliza esta propiedad para decidir cómo actualizar las áreas de la escena que han sido reexpuestas o modificadas. Normalmente no es necesario modificar esta propiedad, pero hay algunos casos en los que hacerlo puede mejorar el rendimiento del renderizado. Consulte la documentación de ViewportUpdateMode para obtener detalles específicos.

El valor por defecto es MinimalViewportUpdate, donde QGraphicsView actualizará un área lo 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 miembro

QGraphicsView::QGraphicsView(QWidget *parent = nullptr)

Construye una QGraphicsView. parent se pasa al constructor de QWidget.

QGraphicsView::QGraphicsView(QGraphicsScene *scene, QWidget *parent = nullptr)

Construye un QGraphicsView y establece la escena visualizada a scene. 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 vista para asegurarse de que la coordenada de la escena pos, está centrada en la vista.

Dado que pos es una coordenada de coma flotante y las barras de desplazamiento operan con coordenadas enteras, el centrado es sólo una aproximación.

Nota: Si el elemento está cerca o fuera del borde, será visible en la vista, pero no estará centrado.

Véase también ensureVisible().

void QGraphicsView::centerOn(const QGraphicsItem *item)

Desplaza el contenido de la ventana gráfica para asegurarse de que item está centrado en la vista.

Se trata de una función sobrecargada.

Véase también ensureVisible().

void QGraphicsView::centerOn(qreal x, qreal y)

Esta función se proporciona por comodidad. Es equivalente 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 dibuje cualquier elemento y el primer plano. Reimplemente esta función para proporcionar un fondo personalizado para esta vista.

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

Todo el pintado se realiza en coordenadas de escena. rect es el rectángulo expuesto.

La implementación por defecto rellena rect usando el pincel de la vista backgroundBrush. Si no se define tal pincel (por defecto), se llama a la función drawBackground() de la escena en su lugar.

Ver 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, después de dibujar el fondo y todos los elementos. Reimplemente esta función para proporcionar un primer plano personalizado para esta vista.

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

Todo el pintado se realiza en coordenadas de escena. rect es el rectángulo expuesto.

La implementación por defecto rellena rect usando el pincel de la vista foregroundBrush. Si no se define tal pincel (por defecto), se llama a la función drawForeground() de la escena en su lugar.

Véase 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 de la ventana gráfica de forma que el rectángulo de escena rect sea visible, con los márgenes especificados en píxeles por xmargin y ymargin. Si no se puede alcanzar el rectángulo especificado, el contenido se desplaza a 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 el centro del elemento item sea visible, con los márgenes especificados en píxeles por xmargin y ymargin. Si no se puede alcanzar el punto especificado, el contenido se desplaza a la posición válida más cercana. El valor por defecto para ambos márgenes es de 50 píxeles.

Se trata de 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 proporciona por comodidad. Es equivalente a llamar a ensureVisible(QRectF(x, y, w, h), xmargin, ymargin).

Se trata de 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 la vista y desplaza las barras de desplazamiento para asegurar que el rectángulo de la escena rect se ajusta 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 mantiene la rotación, traslación o cizalladura de la vista. La vista se escala de acuerdo con aspectRatioMode. rect se centrará en la vista si no se ajusta estrechamente.

Es común llamar a fitInView() desde dentro de una reimplementación de resizeEvent(), para asegurar que toda la escena, o partes de la escena, se escalan automáticamente para ajustarse al nuevo tamaño de la ventana gráfica cuando se redimensiona la vista. Tenga en cuenta, sin embargo, que llamar a fitInView() desde dentro de resizeEvent() puede llevar a una recursión de redimensionamiento no deseada, si la nueva transformación cambia el estado automático de las barras de desplazamiento. Puede cambiar las políticas de las barras de desplazamiento a siempre activadas o siempre desactivadas para evitarlo (consulte horizontalScrollBarPolicy() y verticalScrollBarPolicy()).

Si rect está vacío, o si la ventana 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 a la vista, escalándola de acuerdo con aspectRatioMode.

Se trata de 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 es equivalente a llamar a fitInView(QRectF(x, y, w, h), aspectRatioMode).

Se trata de 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(Qt::InputMethodQuery query) const.

[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 en caché de layers dentro de rect es invalidado incondicionalmente y redibujado.

Puede llamar a esta función para notificar a QGraphicsView cambios en el fondo o en el primer plano de la escena. Se suele utilizar en escenas con fondos basados en mosaicos para notificar cambios cuando QGraphicsView ha activado la caché de fondo.

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

Véase también QGraphicsScene::invalidate() y update().

bool QGraphicsView::isTransformed() const

Devuelve true si la vista está transformada (es decir, se ha asignado una transformación no idéntica o 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 en la posición pos, que está 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 proporciona por comodidad. Es equivalente a llamar a itemAt(QPoint(x, y)).

Se trata de una función sobrecargada.

QList<QGraphicsItem *> QGraphicsView::items() const

Devuelve una lista de todos los elementos de la escena asociada, en orden de apilamiento descendente (es decir, el primer elemento de la lista devuelta es el superior).

Véase también QGraphicsScene::items() y Sorting.

QList<QGraphicsItem *> QGraphicsView::items(const QPoint &pos) const

Devuelve una lista de todos los elementos en la posición pos en la vista. Los elementos se enumeran en orden de apilamiento descendente (es decir, el primer elemento de la lista es el superior y el último el inferior). pos está en coordenadas de la ventana gráfica.

Esta función es más comúnmente llamada desde los manejadores de eventos de ratón en una subclase en QGraphicsView. pos está en coordenadas de vista no transformadas, al igual que QMouseEvent::position().

void CustomView::mousePressEvent(QMouseEvent * evento){
    qDebug() << "There are" << items(event->pos()).size()
            << "items at position"<< mapToScene(event->pos()); }

Véase también QGraphicsScene::items() y Sorting.

QList<QGraphicsItem *> QGraphicsView::items(int x, int y) const

Esta función se proporciona por comodidad. Es equivalente 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 es equivalente 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, dependiendo de mode, están contenidos o se cruzan con path. path está en coordenadas de la ventana gráfica.

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

Se trata de 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, dependiendo de mode, están contenidos o se cruzan con polygon. polygon está en coordenadas de la ventana gráfica.

El valor predeterminado para 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 superior).

Se trata de una función sobrecargada.

Véase 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, dependiendo de mode, están contenidos o se cruzan con rect. rect está en coordenadas de la ventana gráfica.

El valor predeterminado para 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 descendente (es decir, el primer elemento de la lista devuelta es el superior).

Se trata de 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 el trazado del pintor de coordenadas de la escena path a un trazado 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 la escena polygon a un polígono de coordenadas de la 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 proporciona por comodidad. Es equivalente a llamar a mapFromScene(QPointF(x, y)).

QPolygon QGraphicsView::mapFromScene(qreal x, qreal y, qreal w, qreal h) const

Esta función se proporciona por comodidad. Es equivalente a llamar a mapFromScene(QRectF(x, y, w, h)).

QPainterPath QGraphicsView::mapToScene(const QPainterPath &path) const

Devuelve la ruta del pintor de la vista path asignada a una ruta de pintor de coordenadas de escena.

Véase también mapFromScene().

QPointF QGraphicsView::mapToScene(const QPoint &point) const

Devuelve las coordenadas de la ventana point asignadas a las coordenadas de la escena.

Nota: Puede ser útil mapear todo el rectángulo cubierto por el píxel en point en lugar del punto en sí. Para ello, puede 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 vista polygon mapeado a un polígono de coordenadas de escena.

Véase también mapFromScene().

QPolygonF QGraphicsView::mapToScene(const QRect &rect) const

Devuelve el rectángulo de la ventana rect mapeado a un polígono de coordenadas de escena.

Véase también mapFromScene().

QPointF QGraphicsView::mapToScene(int x, int y) const

Esta función se proporciona por comodidad. Es equivalente a llamar a mapToScene(QPoint(x, y)).

QPolygonF QGraphicsView::mapToScene(int x, int y, int w, int h) const

Esta función se proporciona por comodidad. Es equivalente 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)

Renderiza el rectángulo source, que está en coordenadas de vista, desde la escena a target, que está en coordenadas de dispositivo de pintura, usando painter. Esta función es útil para capturar el contenido de la vista en un dispositivo de pintura, como QImage (por ejemplo, para hacer una captura de pantalla), o para imprimir en QPrinter. Por ejemplo:

QGraphicsScene scene;
scene.addItem(...
...

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

QPrinter printer(QPrinter::HighResolution);
printer.setPageSize(QPrinter::A4);
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ángulo 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 pintura de painter(por ejemplo, para una QPrinter, el tamaño de página).

El contenido del rectángulo de origen se transformará según 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 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 hace nada.

Esta función es invocada automáticamente cuando cambian las propiedades backgroundBrush o QGraphicsScene::backgroundBrush; sólo es necesario invocar esta función si se ha reimplementado QGraphicsScene::drawBackground() o QGraphicsView::drawBackground() para dibujar un fondo personalizado, y se necesita activar un redibujado completo.

Véase también cacheMode().

void QGraphicsView::resetTransform()

Restablece la transformación de la vista a la matriz de 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)

Rota 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 cambia el rect de la banda elástica. El viewport Rect se especifica en rubberBandRect. La posición inicial y final de arrastre se proporcionan en puntos de escena con fromScenePoint y toScenePoint.

Cuando la selección de la banda elástica finaliza, esta señal se emite con valores nulos.

Véase también rubberBandRect().

QRect QGraphicsView::rubberBandRect() const

Esta función devuelve el área actual de la banda elástica (en coordenadas de la ventana gráfica) si el usuario está seleccionando un elemento con la banda elástica. Cuando el usuario no esta usando la banda elastica esta funcion devuelve (un null) QRectF().

Tenga en cuenta que parte de este QRect puede estar fuera de la ventana visual. Por ejemplo, puede contener valores negativos.

Ver también rubberBandSelectionMode y rubberBandChanged().

void QGraphicsView::scale(qreal sx, qreal sy)

Escala la transformación de la vista actual en (sx, sy).

Véase también setTransform(), transform(), rotate(), shear(), y translate().

QGraphicsScene *QGraphicsView::scene() const

Devuelve un puntero a la escena que se visualiza actualmente en la vista. Si no se visualiza ninguna escena, 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 sugerencia 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 hace nada.

Cuando se establece una escena en una vista, la señal QGraphicsScene::changed() se conecta automáticamente a la ranura updateScene() de esta vista, y las barras de desplazamiento de la vista se ajustan para adaptarse al tamaño de la escena.

La vista no se apropia 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 verdadero, entonces matrix se combina con la matriz actual; de lo contrario, matrix reemplaza la matriz actual. combine es falso por defecto.

La matriz de transformación transforma la escena en coordenadas de la vista. Utilizando la transformación por defecto, proporcionada por la matriz de 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 1:2 (por ejemplo, un elemento rectangular de 10x10 se dibuja 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 elementos que utilizan una vista transformada, QGraphicsView proporciona funciones mapTo... y mapFrom... que pueden traducir entre coordenadas de escena y de vista. Por ejemplo, puede llamar a mapToScene() para asignar una coordenada de vista a una coordenada de escena en coma flotante, o a mapFromScene() para asignar coordenadas de escena en coma 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).

Este slot es llamado por QAbstractScrollArea después de que setViewport() haya sido llamado. Reimplemente esta función en una subclase de QGraphicsView para inicializar el nuevo viewport widget antes de usarlo.

Véase también setViewport().

void QGraphicsView::shear(qreal sh, qreal sv)

Corta la transformación de la vista actual en (sh, sv).

Véase 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 se establece ninguna transformación actual, se devuelve la matriz de identidad.

Véase también setTransform(), rotate(), scale(), shear() y translate().

void QGraphicsView::translate(qreal dx, qreal dy)

Traduce la transformación de la vista actual por (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 la escena rects.

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

[slot] void QGraphicsView::updateSceneRect(const QRectF &rect)

Notifica a QGraphicsView que el rectángulo de escena de la 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 hace nada.

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.